@udixio/theme 1.0.0-beta.8 → 1.0.0

package/src/theme/{entities/scheme.entity.ts → scheme.ts}

@@ -1,14 +1,21 @@
-import { Hct, TonalPalette } from '@material/material-color-utilities';
+import { TonalPalette } from '@material/material-color-utilities';
+import { Hct } from '../material-color-utilities/htc';
+import { Variant } from './variant';
 
 export interface SchemeOptions {
   sourceColorArgb: number;
   contrastLevel: number;
   isDark: boolean;
   palettes: Map<string, TonalPalette>;
+  variant: Variant;
 }
 
-export class SchemeEntity {
-  constructor(private options: SchemeOptions) {}
+export class Scheme {
+  constructor(readonly options: SchemeOptions) {}
+
+  get variant(): 'expressive' | 'neutral' | 'tonalSpot' | 'vibrant' | string {
+    return this.options.variant.name;
+  }
 
   get contrastLevel() {
     if (!this.options) {
@@ -31,7 +38,16 @@ export class SchemeEntity {
     return Hct.fromInt(this.options.sourceColorArgb);
   }
 
-  getPalette(key: string): TonalPalette {
+  getPalette(
+    key:
+      | 'primary'
+      | 'secondary'
+      | 'tertiary'
+      | 'neutral'
+      | 'neutralVariant'
+      | 'error'
+      | string,
+  ): TonalPalette {
     if (!this.options) {
       throw new Error('Scheme options is not set');
     }

package/src/theme/{services/theme.service.ts → theme.api.ts}

@@ -1,7 +1,7 @@
 import { DynamicColor } from '@material/material-color-utilities';
-import { SchemeService, SchemeServiceOptions } from './scheme.service';
-import { VariantService } from './variant.service';
-import { VariantEntity } from '../entities/variant.entity';
+import { SchemeManager, SchemeServiceOptions } from './scheme.manager';
+import { VariantManager } from './variant.manager';
+import { Variant } from './variant';
 
 type ThemeOptions = Omit<
   SchemeServiceOptions,
@@ -14,18 +14,19 @@ const colorPaletteKeyColor = DynamicColor.fromPalette({
   tone: (s) => s.primaryPalette.keyColor.tone,
 });
 
-export class ThemeService {
-  private readonly schemeService: SchemeService;
-  private readonly variantService: VariantService;
+export class ThemeApi {
+  private readonly schemeManager: SchemeManager;
+  private readonly variantManager: VariantManager;
+
   constructor({
-    schemeService,
-    variantService,
+    schemeManager,
+    variantManager,
   }: {
-    schemeService: SchemeService;
-    variantService: VariantService;
+    schemeManager: SchemeManager;
+    variantManager: VariantManager;
   }) {
-    this.schemeService = schemeService;
-    this.variantService = variantService;
+    this.schemeManager = schemeManager;
+    this.variantManager = variantManager;
 
     // this.addPalette({key: "primary", addDefaultColors: true})
     // this.addPalette({key: "secondary", addDefaultColors: true})
@@ -34,6 +35,7 @@ export class ThemeService {
     // this.addPalette({key: "neutral"})
     // this.addPalette({key: "neutralVariant"})
   }
+
   // addPalette({key, palette, addDefaultColors}: {key: string; palette: TonalPalette; addDefaultColors: boolean}) {
   //   this.themeOptions.palettes.set(key, palette);
   //   if (addDefaultColors){
@@ -50,24 +52,26 @@ export class ThemeService {
   //   return this.theme();
   // }
 
-  create(options: ThemeOptions & { variant: VariantEntity }) {
-    this.schemeService.createOrUpdate({
+  create(options: ThemeOptions & { variant: Variant }) {
+    this.schemeManager.createOrUpdate({
       ...options,
       sourcesColorHex: { primary: options.sourceColorHex },
     });
-    this.variantService.set(options.variant);
+    this.variantManager.set(options.variant);
   }
 
-  update(options: Partial<ThemeOptions> & { variant?: VariantEntity }) {
+  update(options: Partial<ThemeOptions> & { variant?: Variant }) {
     const themeOptions: Partial<SchemeServiceOptions> = { ...options };
     if (options.sourceColorHex)
       themeOptions.sourcesColorHex = { primary: options.sourceColorHex };
-    this.schemeService.createOrUpdate(themeOptions);
-    if (options.variant) this.variantService.set(options.variant);
+    this.schemeManager.createOrUpdate(themeOptions);
+    if (options.variant) this.variantManager.set(options.variant);
   }
+
   addCustomPalette(key: string, colorHex: string) {
-    this.variantService.addCustomPalette(key, colorHex);
+    this.variantManager.addCustomPalette(key, colorHex);
   }
+
   // theme(): SchemeService {
   //   return new SchemeService(this.themeOptions, this.colorService)
   // }

package/src/theme/theme.module.ts

@@ -1,9 +1,11 @@
-import { SchemeService, ThemeService, VariantService } from './services';
 import { asClass } from 'awilix';
 import { Module } from '../app.container';
+import { SchemeManager } from './scheme.manager';
+import { VariantManager } from './variant.manager';
+import { ThemeApi } from './theme.api';
 
 export const ThemeModule: Module = {
-  schemeService: asClass(SchemeService).singleton(),
-  variantService: asClass(VariantService).singleton(),
-  themeService: asClass(ThemeService).singleton(),
+  schemeManager: asClass(SchemeManager).singleton(),
+  variantManager: asClass(VariantManager).singleton(),
+  themeApi: asClass(ThemeApi).singleton(),
 };

package/src/theme/variant.manager.ts

@@ -0,0 +1,58 @@
+import {
+  CustomPaletteFunction,
+  PaletteFunction,
+  SchemeManager,
+} from './scheme.manager';
+import { Variant } from './variant';
+
+export class VariantManager {
+  public customPalettes: Record<string, string> = {};
+  private variantEntity?: Variant;
+
+  private readonly schemeManager: SchemeManager;
+
+  constructor({ schemeManager }: { schemeManager: SchemeManager }) {
+    this.schemeManager = schemeManager;
+  }
+
+  addCustomPalette(key: string, colorHex: string) {
+    this.customPalettes[key] = colorHex;
+    this.update();
+  }
+
+  set(variantEntity: Variant) {
+    this.variantEntity = variantEntity;
+    this.update();
+  }
+
+  private update() {
+    if (!this.variantEntity) return;
+    const palettes: Record<
+      string,
+      | {
+          sourceColorkey: string;
+          tonalPalette: CustomPaletteFunction;
+        }
+      | {
+          tonalPalette: PaletteFunction;
+        }
+    > = {};
+    Object.keys(this.variantEntity.palettes).forEach((key) => {
+      palettes[key] = { tonalPalette: this.variantEntity!.palettes[key] };
+    });
+
+    const customPalettes = this.variantEntity.customPalettes;
+    if (customPalettes) {
+      Object.keys(this.customPalettes).forEach((key) => {
+        palettes[key] = {
+          sourceColorkey: key,
+          tonalPalette: customPalettes,
+        };
+      });
+    }
+    this.schemeManager.createOrUpdate({
+      sourcesColorHex: this.customPalettes,
+      palettes: palettes,
+    });
+  }
+}

package/src/theme/variant.ts

@@ -0,0 +1,53 @@
+import {
+  sanitizeDegreesDouble,
+  TonalPalette,
+} from '@material/material-color-utilities';
+import { Hct } from '../material-color-utilities/htc';
+import { AddColors } from '../color';
+
+export const getPiecewiseHue = (
+  sourceColorHct: Hct,
+  hueBreakpoints: number[],
+  hues: number[],
+): number => {
+  const size = Math.min(hueBreakpoints.length - 1, hues.length);
+  const sourceHue = sourceColorHct.hue;
+  for (let i = 0; i < size; i++) {
+    if (sourceHue >= hueBreakpoints[i] && sourceHue < hueBreakpoints[i + 1]) {
+      return sanitizeDegreesDouble(hues[i]);
+    }
+  }
+  return sourceHue;
+};
+
+export const getRotatedHue = (
+  sourceColorHct: Hct,
+  hueBreakpoints: number[],
+  rotations: number[],
+): number => {
+  let rotation = getPiecewiseHue(sourceColorHct, hueBreakpoints, rotations);
+  if (Math.min(hueBreakpoints.length - 1, rotations.length) <= 0) {
+    rotation = 0;
+  }
+  return sanitizeDegreesDouble(sourceColorHct.hue + rotation);
+};
+
+export class Variant {
+  constructor(
+    public palettes: Record<
+      string,
+      (args: { sourceColorHct: Hct; isDark: boolean }) => TonalPalette
+    > = {},
+    public name: string,
+    public customPalettes?: (args: {
+      isDark: boolean;
+      sourceColorHct: Hct;
+      colorHct: Hct;
+    }) => TonalPalette,
+    /** TODO
+     * Defines color modifications through variation.
+     * Allows customization of specific colors in the theme.
+     */
+    public colors?: AddColors['colors'],
+  ) {}
+}

package/src/theme/variants/expressive.variant.ts

@@ -0,0 +1,81 @@
+import { getPiecewiseHue, getRotatedHue, Variant } from '../variant';
+import { TonalPalette } from '@material/material-color-utilities';
+import { Hct } from '../../material-color-utilities/htc';
+
+const getExpressiveNeutralHue = (sourceColorHct: Hct): number => {
+  const hue = getRotatedHue(
+    sourceColorHct,
+    [0, 71, 124, 253, 278, 300, 360],
+    [10, 0, 10, 0, 10, 0],
+  );
+  return hue;
+};
+const getExpressiveNeutralChroma = (
+  sourceColorHct: Hct,
+  isDark: boolean,
+): number => {
+  const neutralHue = getExpressiveNeutralHue(sourceColorHct);
+  return isDark ? (Hct.isYellow(neutralHue) ? 6 : 14) : 18;
+};
+
+export const expressiveVariant: Variant = {
+  name: 'expressive',
+  palettes: {
+    primary: ({ sourceColorHct, isDark }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, isDark ? 36 : 48),
+    secondary: ({ sourceColorHct, isDark }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 105, 140, 204, 253, 278, 300, 333, 360],
+          [-160, 155, -100, 96, -96, -156, -165, -160],
+        ),
+        isDark ? 16 : 24,
+      ),
+    tertiary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 105, 140, 204, 253, 278, 300, 333, 360],
+          [-165, 160, -105, 101, -101, -160, -170, -165],
+        ),
+        48,
+      ),
+    neutral: ({ sourceColorHct, isDark }) =>
+      TonalPalette.fromHueAndChroma(
+        getExpressiveNeutralHue(sourceColorHct),
+        getExpressiveNeutralChroma(sourceColorHct, isDark),
+      ),
+    neutralVariant: ({ sourceColorHct, isDark }) => {
+      const expressiveNeutralHue = getExpressiveNeutralHue(sourceColorHct);
+      const expressiveNeutralChroma = getExpressiveNeutralChroma(
+        sourceColorHct,
+        isDark,
+      );
+      return TonalPalette.fromHueAndChroma(
+        expressiveNeutralHue,
+        expressiveNeutralChroma *
+          (expressiveNeutralHue >= 105 && expressiveNeutralHue < 125
+            ? 1.6
+            : 2.3),
+      );
+    },
+    error: ({ sourceColorHct }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColorHct,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12],
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 64);
+    },
+  },
+  customPalettes: ({ colorHct, isDark }) =>
+    TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        colorHct,
+        [0, 105, 140, 204, 253, 278, 300, 333, 360],
+        [-160, 155, -100, 96, -96, -156, -165, -160],
+      ),
+      isDark ? 16 : 24,
+    ),
+};

package/src/theme/variants/index.ts

@@ -0,0 +1,16 @@
+import { expressiveVariant } from './expressive.variant';
+import { neutralVariant } from './neutral.variant';
+import { tonalSpotVariant } from './tonal-spot.variant';
+import { vibrantVariant } from './vibrant.variant';
+
+export * from './tonal-spot.variant';
+export * from './vibrant.variant';
+export * from './expressive.variant';
+export * from './neutral.variant';
+
+export const Variants = {
+  Expressive: expressiveVariant,
+  Neutral: neutralVariant,
+  TonalSpot: tonalSpotVariant,
+  Vibrant: vibrantVariant,
+};

package/src/theme/variants/neutral.variant.ts

@@ -0,0 +1,45 @@
+import { getPiecewiseHue, getRotatedHue, Variant } from '../variant';
+import { TonalPalette } from '@material/material-color-utilities';
+import { Hct } from '../../material-color-utilities/htc';
+
+export const neutralVariant: Variant = {
+  name: 'neutral',
+  palettes: {
+    primary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        sourceColorHct.hue,
+        Hct.isBlue(sourceColorHct.hue) ? 12 : 8,
+      ),
+    secondary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        sourceColorHct.hue,
+        Hct.isBlue(sourceColorHct.hue) ? 6 : 4,
+      ),
+    tertiary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 38, 105, 161, 204, 278, 333, 360],
+          [-32, 26, 10, -39, 24, -15, -32],
+        ),
+        20,
+      ),
+    neutral: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 1.4),
+    neutralVariant: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 1.4 * 2.2),
+    error: ({ sourceColorHct }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColorHct,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12],
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 50);
+    },
+  },
+  customPalettes: ({ colorHct }) =>
+    TonalPalette.fromHueAndChroma(
+      colorHct.hue,
+      Hct.isBlue(colorHct.hue) ? 6 : 4,
+    ),
+};

package/src/theme/variants/tonal-spot.variant.ts

@@ -0,0 +1,35 @@
+import { getPiecewiseHue, getRotatedHue, Variant } from '../variant';
+import { TonalPalette } from '@material/material-color-utilities';
+
+export const tonalSpotVariant: Variant = {
+  name: 'tonalSpot',
+  palettes: {
+    primary: ({ sourceColorHct, isDark }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, isDark ? 26 : 32),
+    secondary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16),
+    tertiary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 20, 71, 161, 333, 360],
+          [-40, 48, -32, 40, -32],
+        ),
+        28,
+      ),
+    neutral: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 5),
+    neutralVariant: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 5 * 1.7),
+    error: ({ sourceColorHct }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColorHct,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12],
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 60);
+    },
+  },
+  customPalettes: ({ colorHct }) =>
+    TonalPalette.fromHueAndChroma(colorHct.hue, 16),
+};

package/src/theme/variants/vibrant.variant.ts

@@ -0,0 +1,72 @@
+import { getPiecewiseHue, getRotatedHue, Variant } from '../variant';
+import { TonalPalette } from '@material/material-color-utilities';
+import { Hct } from '../../material-color-utilities/htc';
+
+const getVibrantNeutralHue = (sourceColorHct: Hct): number => {
+  return getRotatedHue(
+    sourceColorHct,
+    [0, 38, 105, 140, 333, 360],
+    [-14, 10, -14, 10, -14],
+  );
+};
+
+const getVibrantNeutralChroma = (sourceColorHct: Hct): number => {
+  const neutralHue = getVibrantNeutralHue(sourceColorHct);
+  return 28;
+};
+
+export const vibrantVariant: Variant = {
+  name: 'vibrant',
+  palettes: {
+    primary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(sourceColorHct.hue, 74),
+    secondary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 38, 105, 140, 333, 360],
+          [-14, 10, -14, 10, -14],
+        ),
+        56,
+      ),
+    tertiary: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getRotatedHue(
+          sourceColorHct,
+          [0, 38, 71, 105, 140, 161, 253, 333, 360],
+          [-72, 35, 24, -24, 62, 50, 62, -72],
+        ),
+        56,
+      ),
+    neutral: ({ sourceColorHct }) =>
+      TonalPalette.fromHueAndChroma(
+        getVibrantNeutralHue(sourceColorHct),
+        getVibrantNeutralChroma(sourceColorHct),
+      ),
+    neutralVariant: ({ sourceColorHct }) => {
+      const vibrantNeutralHue = getVibrantNeutralHue(sourceColorHct);
+      const vibrantNeutralChroma = getVibrantNeutralChroma(sourceColorHct);
+      return TonalPalette.fromHueAndChroma(
+        vibrantNeutralHue,
+        vibrantNeutralChroma * 1.29,
+      );
+    },
+    error: ({ sourceColorHct }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColorHct,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12],
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 80);
+    },
+  },
+  customPalettes: ({ colorHct }) =>
+    TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        colorHct,
+        [0, 38, 105, 140, 333, 360],
+        [-14, 10, -14, 10, -14],
+      ),
+      56,
+    ),
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,33 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "baseUrl": ".",
+    "rootDir": "src",
+    "outDir": "dist",
+    "tsBuildInfoFile": "dist/tsconfig.lib.tsbuildinfo",
+    "emitDeclarationOnly": true,
+    "forceConsistentCasingInFileNames": true,
+    "types": [
+      "node",
+      "vite/client"
+    ]
+  },
+  "include": [
+    "src/**/*.ts"
+  ],
+  "references": [],
+  "exclude": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx"
+  ]
+}

package/tsconfig.spec.json

@@ -0,0 +1,36 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/vitest",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ],
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/vite.config.ts

@@ -0,0 +1,54 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import dts from 'vite-plugin-dts';
+import * as path from 'path';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/theme',
+  plugins: [
+    dts({
+      entryRoot: 'src',
+      tsconfigPath: path.join(__dirname, 'tsconfig.lib.json'),
+    }),
+  ],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },
+  // Configuration for building your library.
+  // See: https://vitejs.dev/guide/build.html#library-mode
+  build: {
+    outDir: './dist',
+    emptyOutDir: true,
+    reportCompressedSize: true,
+    ssr: true,
+    commonjsOptions: {
+      transformMixedEsModules: true,
+    },
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: 'src/index.ts',
+      name: '@udixio/theme',
+      fileName: 'index',
+      // Change this to the formats you want to support.
+      // Don't forget to update your package.json as well.
+      formats: ['es' as const, 'cjs' as const],
+    },
+    rollupOptions: {
+      // External packages that should not be bundled into your library.
+      external: [],
+    },
+  },
+  test: {
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: './test-output/vitest/coverage',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 vigreux-joël
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/app.service.d.ts

@@ -1,13 +0,0 @@
-import { ColorService } from './color';
-import { ThemeService } from './theme';
-import { PluginService } from './plugin/plugin.service';
-export declare class AppService {
-    colorService: ColorService;
-    themeService: ThemeService;
-    pluginService: PluginService;
-    constructor({ colorService, themeService, pluginService, }: {
-        colorService: ColorService;
-        themeService: ThemeService;
-        pluginService: PluginService;
-    });
-}