@udixio/theme 1.0.0-beta.5 → 1.0.0-beta.7

package/src/app.module.ts

@@ -1,10 +1,7 @@
-import { Module } from '@nestjs/common';
+import { asClass } from 'awilix';
 import { AppService } from './app.service';
-import { ColorModule } from './color/color.module';
-import { ThemeModule } from './theme/theme.module';
+import { Module } from './app.container';
 
-@Module({
-  imports: [ColorModule, ThemeModule],
-  providers: [AppService],
-})
-export class AppModule {}
+export const AppModule: Module = {
+  appService: asClass(AppService).singleton(),
+};

package/src/app.service.spec.ts

@@ -1,6 +1,6 @@
 import { Test, TestingModule } from '@nestjs/testing';
 import { AppService } from '../src/app.service';
-import { AppModule } from '../src/app.module';
+import { AppModule } from './app.container';
 
 describe('AppController (e2e)', () => {
   let appService: AppService;

package/src/app.service.ts

@@ -1,11 +1,17 @@
-import { Injectable } from '@nestjs/common';
 import { ColorService } from './color/color.service';
 import { ThemeService } from './theme/services/theme.service';
 
-@Injectable()
 export class AppService {
-  constructor(
-    public colorService: ColorService,
-    public themeService: ThemeService
-  ) {}
+  public colorService: ColorService;
+  public themeService: ThemeService;
+  constructor({
+    colorService,
+    themeService,
+  }: {
+    colorService: ColorService;
+    themeService: ThemeService;
+  }) {
+    this.colorService = colorService;
+    this.themeService = themeService;
+  }
 }

package/src/color/color-manager.service.ts

@@ -1,4 +1,3 @@
-import { Injectable } from '@nestjs/common';
 import { ContrastCurve, ToneDeltaPair } from '../material-color-utilities';
 import { DynamicColor } from '../material-color-utilities/dynamic_color';
 import { SchemeEntity } from '../theme/entities/scheme.entity';
@@ -20,10 +19,12 @@ export const highestSurface = (
     : colorManagerService.get('surfaceDim').getDynamicColor();
 };
 
-@Injectable()
 export class ColorManagerService {
   private colorMap = new Map<string, ColorEntity>();
-  constructor(private schemeService: SchemeService) {}
+  private readonly schemeService: SchemeService;
+  constructor({ schemeService }: { schemeService: SchemeService }) {
+    this.schemeService = schemeService;
+  }
 
   createOrUpdate(key: string, args: Partial<ColorOptions>): ColorEntity {
     let colorEntity = this.colorMap.get(key);

package/src/color/color.module.ts

@@ -1,11 +1,9 @@
 import { ColorService } from './color.service';
-import { Module } from '@nestjs/common';
 import { ColorManagerService } from './color-manager.service';
-import { ThemeModule } from '../theme/theme.module';
+import { asClass } from 'awilix';
+import { Module } from '../app.container';
 
-@Module({
-  imports: [ThemeModule],
-  providers: [ColorService, ColorManagerService],
-  exports: [ColorService],
-})
-export class ColorModule {}
+export const ColorModule: Module = {
+  colorManagerService: asClass(ColorManagerService).singleton(),
+  colorService: asClass(ColorService).singleton(),
+};

package/src/color/color.service.ts

@@ -1,12 +1,17 @@
-import { Injectable } from '@nestjs/common';
 import { ColorManagerService } from './color-manager.service';
 import { ColorInterface } from './color.interface';
 import { ColorEntity, ColorOptions } from './entities/color.entity';
 import { defaultColors, DynamicColorKey } from './models/default-color.model';
 
-@Injectable()
 export class ColorService implements ColorInterface {
-  constructor(private colorManagerService: ColorManagerService) {}
+  private readonly colorManagerService: ColorManagerService;
+  constructor({
+    colorManagerService,
+  }: {
+    colorManagerService: ColorManagerService;
+  }) {
+    this.colorManagerService = colorManagerService;
+  }
 
   getAllColors() {
     return this.colorManagerService.getAll();

package/src/index.ts

@@ -1,3 +1,5 @@
+export { default as AppContainer } from './app.container';
+export * from './app.container';
 export * from './app.module';
 export * from './app.service';
 export * from './color';

package/src/main.ts

@@ -1,11 +1,6 @@
-import { NestFactory } from '@nestjs/core';
-import { AppModule } from './app.module';
+import AppContainer from './app.container';
 import { AppService } from './app.service';
 
-export async function main(): Promise<[AppService, () => Promise<void>]> {
-  const app = await NestFactory.create(AppModule);
-  const appService = app.get(AppService);
-
-  const close = () => app.close();
-  return [appService, close];
+export function main(): AppService {
+  return AppContainer.resolve<AppService>('appService');
 }

package/src/theme/services/scheme.service.ts

@@ -1,11 +1,9 @@
-import { Injectable } from '@nestjs/common';
 import { SchemeEntity, SchemeOptions } from '../entities/scheme.entity';
 import {
   argbFromHex,
   Hct,
   TonalPalette,
 } from '@material/material-color-utilities';
-import mergeDeep from 'merge-deep';
 
 export type SchemeServiceOptions = Omit<
   SchemeOptions,
@@ -15,13 +13,19 @@ export type SchemeServiceOptions = Omit<
   palettes: Record<string, (sourceColorHct: Hct) => TonalPalette>;
 };
 
-@Injectable()
 export class SchemeService {
   private schemeEntity?: SchemeEntity;
   private options?: SchemeServiceOptions;
 
   createOrUpdate(options: Partial<SchemeServiceOptions>) {
-    this.options = mergeDeep(options, this.options);
+    this.options = {
+      ...this.options,
+      ...options,
+      palettes: {
+        ...this.options?.palettes,
+        ...options.palettes,
+      },
+    } as SchemeServiceOptions;
     const palettes = new Map<string, TonalPalette>();
 
     const sourceColorArgb = argbFromHex(this.options.sourceColorHex);

package/src/theme/services/theme.service.ts

@@ -1,5 +1,4 @@
 import { DynamicColor } from '@material/material-color-utilities';
-import { Injectable } from '@nestjs/common';
 import { SchemeService, SchemeServiceOptions } from './scheme.service';
 import { VariantService } from './variant.service';
 import { VariantEntity } from '../entities/variant.entity';
@@ -12,12 +11,19 @@ const colorPaletteKeyColor = DynamicColor.fromPalette({
   tone: (s) => s.primaryPalette.keyColor.tone,
 });
 
-@Injectable()
 export class ThemeService {
-  constructor(
-    private schemeService: SchemeService,
-    private variantService: VariantService
-  ) {
+  private readonly schemeService: SchemeService;
+  private readonly variantService: VariantService;
+  constructor({
+    schemeService,
+    variantService,
+  }: {
+    schemeService: SchemeService;
+    variantService: VariantService;
+  }) {
+    this.schemeService = schemeService;
+    this.variantService = variantService;
+
     // this.addPalette({key: "primary", addDefaultColors: true})
     // this.addPalette({key: "secondary", addDefaultColors: true})
     // this.addPalette({key: "tertiary", addDefaultColors: true})

package/src/theme/services/variant.service.ts

@@ -1,11 +1,12 @@
 import { SchemeService } from './scheme.service';
 import { VariantEntity } from '../entities/variant.entity';
-import { Injectable } from '@nestjs/common';
 import { TonalPalette } from '@material/material-color-utilities';
 
-@Injectable()
 export class VariantService {
-  constructor(private schemeService: SchemeService) {}
+  private readonly schemeService: SchemeService;
+  constructor({ schemeService }: { schemeService: SchemeService }) {
+    this.schemeService = schemeService;
+  }
 
   set(variantEntity: VariantEntity) {
     if (!variantEntity.palettes.error) {

package/src/theme/theme.module.ts

@@ -1,10 +1,9 @@
-import { Module } from '@nestjs/common';
-import { SchemeService } from './services/scheme.service';
-import { ThemeService } from './services/theme.service';
-import { VariantService } from './services/variant.service';
+import { SchemeService, ThemeService, VariantService } from './services';
+import { asClass } from 'awilix';
+import { Module } from '../app.container';
 
-@Module({
-  providers: [SchemeService, ThemeService, VariantService],
-  exports: [ThemeService, SchemeService],
-})
-export class ThemeModule {}
+export const ThemeModule: Module = {
+  schemeService: asClass(SchemeService).singleton(),
+  variantService: asClass(VariantService).singleton(),
+  themeService: asClass(ThemeService).singleton(),
+};