feat(theming): rework facade api

Author: Char2sGu

packages/theming/src/builder-composition.ts

@@ -0,0 +1,16 @@
+import { ProviderToken } from '@angular/core';
+
+import { ThemeBuilder, ThemeBuilderConfigOf } from './builder';
+
+export interface ThemeBuilderComposition {
+  builder: ProviderToken<ThemeBuilder<any>>;
+  config: unknown;
+}
+
+export const withThemeBuilder = <Builder extends ThemeBuilder<any>>(
+  builder: ProviderToken<Builder>,
+  config: ThemeBuilderConfigOf<Builder>,
+): ThemeBuilderComposition => ({
+  builder,
+  config,
+});

packages/theming/src/builder.ts

@@ -8,3 +8,6 @@ export interface ThemeBuilderContext<Config> {
   name: string;
   config: Config;
 }
+
+export type ThemeBuilderConfigOf<Builder extends ThemeBuilder<any>> =
+  Builder extends ThemeBuilder<infer Config> ? Config : never;

packages/theming/src/manager.ts

@@ -1,69 +1,34 @@
-import {
-  forwardRef,
-  inject,
-  Injectable,
-  Injector,
-  ProviderToken,
-} from '@angular/core';
+import { inject, Injectable, Injector } from '@angular/core';
 
-import { ThemeBuilder } from './builder';
+import { ThemeBuilderComposition } from './builder-composition';
 import { ThemeTokenRegistry, ThemeTokens } from './token';
 
-@Injectable({
-  providedIn: 'root',
-  useExisting: forwardRef(() => SimpleThemeManager),
-})
-export abstract class ThemeManager {
-  abstract buildAndApply<Builders extends ThemeBuilderMap>(
-    builders: Builders,
-    configs: ThemeBuilderConfigMapOf<Builders>,
-  ): void;
-  abstract build<Builders extends ThemeBuilderMap>(
-    builders: Builders,
-    configs: ThemeBuilderConfigMapOf<Builders>,
-  ): ThemeTokens;
-  abstract apply(tokens: ThemeTokens): void;
-}
-
-export interface ThemeBuilderMap {
-  [name: string]: ProviderToken<ThemeBuilder<unknown>>;
-}
-
-export type ThemeBuilderConfigMapOf<Builders extends ThemeBuilderMap> = {
-  [Name in keyof Builders]: Builders[Name] extends ProviderToken<
-    ThemeBuilder<infer Config>
-  >
-    ? Config
-    : never;
-};
-
 @Injectable({ providedIn: 'root' })
-export class SimpleThemeManager implements ThemeManager {
+export class ThemeManager {
   protected injector = inject(Injector);
   protected tokens = inject(ThemeTokenRegistry);
 
-  buildAndApply<Builders extends ThemeBuilderMap>(
-    builders: Builders,
-    configs: ThemeBuilderConfigMapOf<Builders>,
-  ): void {
-    const tokens = this.build(builders, configs);
-    this.apply(tokens);
-  }
-
-  build<Builders extends ThemeBuilderMap>(
-    builders: Builders,
-    configs: ThemeBuilderConfigMapOf<Builders>,
-  ): ThemeTokens {
-    return Object.entries(builders).reduce(
-      (tokens, [name, builder]) => ({
-        ...tokens,
-        ...this.injector.get(builder).build({ name, config: configs[name] }),
-      }),
-      {},
-    );
+  build(config: ThemeBuildConfig): ThemeTokens {
+    const tokens: ThemeTokens = {};
+    for (const [name, composition] of Object.entries(config)) {
+      const { builder: token, config } = composition;
+      const builder = this.injector.get(token);
+      const result = builder.build({ name, config });
+      Object.assign(tokens, result);
+    }
+    return tokens;
   }
 
   apply(tokens: ThemeTokens): void {
     for (const name in tokens) this.tokens.set(name, tokens[name]);
   }
+
+  buildAndApply(config: ThemeBuildConfig): void {
+    const tokens = this.build(config);
+    this.apply(tokens);
+  }
+}
+
+export interface ThemeBuildConfig {
+  [name: string]: ThemeBuilderComposition;
 }