@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/text/localization.service.js

@@ -1,231 +1,264 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var localization_service_exports = {};
+__export(localization_service_exports, {
+  LocalizationService: () => LocalizationService,
+  autoEnumerationLocalization: () => autoEnumerationLocalization,
+  enumerationLocalization: () => enumerationLocalization,
+  getLocalizationKeys: () => getLocalizationKeys,
+  getProxyLocalizationKey: () => getProxyLocalizationKey,
+  isEnumLocalizationKey: () => isEnumLocalizationKey,
+  isLocalizationDataObject: () => isLocalizationDataObject,
+  isLocalizeItem: () => isLocalizeItem,
+  isProxyLocalizationKey: () => isProxyLocalizationKey,
+  localizationData: () => localizationData
+});
+module.exports = __toCommonJS(localization_service_exports);
+var import_details_error = require("../error/details.error.js");
+var import_decorators = require("../injector/decorators.js");
+var import_logger = require("../logger/index.js");
+var import_api = require("../signals/api.js");
+var import_enum = require("../utils/enum.js");
+var import_memoize = require("../utils/function/memoize.js");
+var import_object = require("../utils/object/object.js");
+var import_property_name = require("../utils/object/property-name.js");
+var import_type_guards = require("../utils/type-guards.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { resolveArg, singleton } from '../container/index.js';
-import { DetailsError } from '../error/details.error.js';
-import { Logger } from '../logger/index.js';
-import { computed, signal, toObservable } from '../signals/api.js';
-import { enumEntries, enumValueName } from '../utils/enum.js';
-import { memoize } from '../utils/function/memoize.js';
-import { deepObjectEntries, hasOwnProperty } from '../utils/object/object.js';
-import { getPropertyName, getPropertyNameProxy, isPropertyName, propertyName } from '../utils/object/property-name.js';
-import { assertDefinedPass, isArray, isDefined, isFunction, isNotNull, isNull, isNullOrUndefined, isObject, isString, isUndefined } from '../utils/type-guards.js';
-export function getProxyLocalizationKey(key) {
-    return getPropertyName(key);
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+function getProxyLocalizationKey(key) {
+  return (0, import_property_name.getPropertyName)(key);
 }
-export function isProxyLocalizationKey(value) {
-    return isPropertyName(value);
+function isProxyLocalizationKey(value) {
+  return (0, import_property_name.isPropertyName)(value);
 }
-export function isEnumLocalizationKey(key) {
-    return isObject(key) && hasOwnProperty(key, 'enum');
+function isEnumLocalizationKey(key) {
+  return (0, import_type_guards.isObject)(key) && (0, import_object.hasOwnProperty)(key, "enum");
 }
-export function isLocalizationDataObject(value) {
-    return isObject(value) && hasOwnProperty(value, 'key');
+function isLocalizationDataObject(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "key");
 }
-export function localizationData(keyOrData, parameters) {
-    if (isString(keyOrData) || isProxyLocalizationKey(keyOrData)) {
-        return { key: keyOrData, parameters };
-    }
-    return keyOrData;
+function localizationData(keyOrData, parameters) {
+  if ((0, import_type_guards.isString)(keyOrData) || isProxyLocalizationKey(keyOrData)) {
+    return { key: keyOrData, parameters };
+  }
+  return keyOrData;
 }
-/**
- * returns a Proxy which simply returns the key you accessed. Can be used to have typesafe localizations (in templates and the API) by not relying on plain strings
- * @param localization
- * @returns
- */
-export function getLocalizationKeys(_localization) {
-    return getPropertyNameProxy();
+function getLocalizationKeys(_localization) {
+  return (0, import_property_name.getPropertyNameProxy)();
 }
-export const autoEnumerationLocalization = memoize(_autoEnumerationLocalization);
+const autoEnumerationLocalization = (0, import_memoize.memoize)(_autoEnumerationLocalization);
 const parametersPattern = /(?:\{\{\s*(?<parameter>\w+)\s*\}\})/ug;
-const warnedMissingKeys = new Set();
-export let LocalizationService = class LocalizationService {
-    #logger;
-    #localizations = new Map();
-    #activeLanguage = signal(null);
-    #availableLanguages = signal([]);
-    #activeLocalization = computed(() => {
-        const language = this.#activeLanguage();
-        if (isNull(language)) {
-            return null;
-        }
-        return this.#localizations.get(language.code);
-    });
-    activeLanguage = this.#activeLanguage.asReadonly();
-    availableLanguages = this.#availableLanguages.asReadonly();
-    activeLanguage$ = toObservable(this.activeLanguage);
-    availableLanguages$ = toObservable(this.availableLanguages);
-    constructor(logger) {
-        this.#logger = logger;
-    }
-    registerLocalization(...localizations) {
-        for (const localization of localizations) {
-            const mappedLocalization = buildMappedLocalization(localization);
-            if (this.#localizations.has(localization.language.code)) {
-                const existing = this.#localizations.get(localization.language.code);
-                const merged = mergeMappedLocalization(existing, mappedLocalization);
-                this.#localizations.set(localization.language.code, merged);
-            }
-            else {
-                this.#localizations.set(localization.language.code, mappedLocalization);
-            }
-            const availableLanguages = [...this.#localizations].map(([, loc]) => loc.language);
-            this.#availableLanguages.set(availableLanguages);
-            if (isNullOrUndefined(this.#activeLanguage())) {
-                this.setLanguage(localization.language.code);
-            }
-        }
-    }
-    hasLanguage(languageCode) {
-        return this.#localizations.has(languageCode);
-    }
-    getLanguage(languageCode) {
-        return assertDefinedPass(this.#localizations.get(languageCode), 'language not available').language;
-    }
-    setLanguage(languageOrCode) {
-        const language = isString(languageOrCode) ? this.#localizations.get(languageOrCode)?.language : languageOrCode;
-        if (isUndefined(language) || !this.#localizations.has(language.code)) {
-            throw new Error('Language not registered.');
-        }
-        this.#activeLanguage.set(language);
+const warnedMissingKeys = /* @__PURE__ */ new Set();
+let LocalizationService = class LocalizationService2 {
+  #logger;
+  #localizations = /* @__PURE__ */ new Map();
+  #activeLanguage = (0, import_api.signal)(null);
+  #availableLanguages = (0, import_api.signal)([]);
+  #activeLocalization = (0, import_api.computed)(() => {
+    const language = this.#activeLanguage();
+    if ((0, import_type_guards.isNull)(language)) {
+      return null;
     }
-    setLocalization(localization) {
+    return this.#localizations.get(language.code);
+  });
+  activeLanguage = this.#activeLanguage.asReadonly();
+  availableLanguages = this.#availableLanguages.asReadonly();
+  activeLanguage$ = (0, import_api.toObservable)(this.activeLanguage);
+  availableLanguages$ = (0, import_api.toObservable)(this.availableLanguages);
+  constructor(logger) {
+    this.#logger = logger;
+  }
+  registerLocalization(...localizations) {
+    for (const localization of localizations) {
+      const mappedLocalization = buildMappedLocalization(localization);
+      if (this.#localizations.has(localization.language.code)) {
+        const existing = this.#localizations.get(localization.language.code);
+        const merged = mergeMappedLocalization(existing, mappedLocalization);
+        this.#localizations.set(localization.language.code, merged);
+      } else {
+        this.#localizations.set(localization.language.code, mappedLocalization);
+      }
+      const availableLanguages = [...this.#localizations].map(([, loc]) => loc.language);
+      this.#availableLanguages.set(availableLanguages);
+      if ((0, import_type_guards.isNullOrUndefined)(this.#activeLanguage())) {
         this.setLanguage(localization.language.code);
+      }
     }
-    tryGetItem(keyOrData) {
-        const activeLanguageCode = this.#activeLanguage()?.code;
-        if (isUndefined(activeLanguageCode)) {
-            return undefined;
-        }
-        if (isEnumLocalizationKey(keyOrData)) {
-            const enumEntry = this.#localizations.get(activeLanguageCode)?.enums.get(keyOrData.enum);
-            return isDefined(keyOrData.value) ? enumEntry?.values[keyOrData.value] : enumEntry?.name;
-        }
-        const actualKey = getStringKey(keyOrData);
-        return this.#localizations.get(activeLanguageCode)?.keys.get(actualKey);
+  }
+  hasLanguage(languageCode) {
+    return this.#localizations.has(languageCode);
+  }
+  getLanguage(languageCode) {
+    return (0, import_type_guards.assertDefinedPass)(this.#localizations.get(languageCode), "language not available").language;
+  }
+  setLanguage(languageOrCode) {
+    const language = (0, import_type_guards.isString)(languageOrCode) ? this.#localizations.get(languageOrCode)?.language : languageOrCode;
+    if ((0, import_type_guards.isUndefined)(language) || !this.#localizations.has(language.code)) {
+      throw new Error("Language not registered.");
     }
-    hasKey(key) {
-        const item = this.tryGetItem(key);
-        return isDefined(item);
+    this.#activeLanguage.set(language);
+  }
+  setLocalization(localization) {
+    this.setLanguage(localization.language.code);
+  }
+  tryGetItem(keyOrData) {
+    const activeLanguageCode = this.#activeLanguage()?.code;
+    if ((0, import_type_guards.isUndefined)(activeLanguageCode)) {
+      return void 0;
     }
-    // eslint-disable-next-line max-statements
-    localizeOnce(keyOrData) {
-        if (isEnumLocalizationKey(keyOrData)) {
-            return this.localizeEnumOnce(keyOrData.enum, keyOrData.value, keyOrData.parameters);
-        }
-        const key = getStringKey(keyOrData);
-        const parameters = (isString(keyOrData) || isProxyLocalizationKey(keyOrData)) ? {} : keyOrData.parameters;
-        const activeLanguageCode = this.#activeLanguage()?.code;
-        const templateOrFunction = isDefined(activeLanguageCode) ? this.#localizations.get(activeLanguageCode)?.keys.get(key) : undefined;
-        if (isUndefined(templateOrFunction)) {
-            if (!warnedMissingKeys.has(key)) {
-                this.#logger.warn(`Localization for ${key} not available.`);
-                warnedMissingKeys.add(key);
-            }
-        }
-        return this.localizeItem(key, templateOrFunction, parameters);
+    if (isEnumLocalizationKey(keyOrData)) {
+      const enumEntry = this.#localizations.get(activeLanguageCode)?.enums.get(keyOrData.enum);
+      return (0, import_type_guards.isDefined)(keyOrData.value) ? enumEntry?.values[keyOrData.value] : enumEntry?.name;
     }
-    localizeEnumOnce(enumeration, value, parameters) {
-        if (isUndefined(value)) {
-            const name = this.#activeLocalization()?.enums.get(enumeration)?.name;
-            return this.localizeItem('ENUM', name, parameters);
-        }
-        const key = isArray(enumeration) ? value : enumValueName(enumeration, value);
-        const item = this.#activeLocalization()?.enums.get(enumeration)?.values[value];
-        if (isUndefined(item)) {
-            return autoEnumerationLocalization(enumeration)[2][value];
-        }
-        return this.localizeItem(key, item, parameters);
+    const actualKey = getStringKey(keyOrData);
+    return this.#localizations.get(activeLanguageCode)?.keys.get(actualKey);
+  }
+  hasKey(key) {
+    const item = this.tryGetItem(key);
+    return (0, import_type_guards.isDefined)(item);
+  }
+  // eslint-disable-next-line max-statements
+  localizeOnce(keyOrData) {
+    if (isEnumLocalizationKey(keyOrData)) {
+      return this.localizeEnumOnce(keyOrData.enum, keyOrData.value, keyOrData.parameters);
     }
-    localize(data) {
-        return computed(() => this.localizeOnce(data));
+    const key = getStringKey(keyOrData);
+    const parameters = (0, import_type_guards.isString)(keyOrData) || isProxyLocalizationKey(keyOrData) ? {} : keyOrData.parameters;
+    const activeLanguageCode = this.#activeLanguage()?.code;
+    const templateOrFunction = (0, import_type_guards.isDefined)(activeLanguageCode) ? this.#localizations.get(activeLanguageCode)?.keys.get(key) : void 0;
+    if ((0, import_type_guards.isUndefined)(templateOrFunction)) {
+      if (!warnedMissingKeys.has(key)) {
+        this.#logger.warn(`Localization for ${key} not available.`);
+        warnedMissingKeys.add(key);
+      }
     }
-    localizeEnum(enumeration, value, parameters) {
-        return computed(() => this.localizeEnumOnce(enumeration, value, parameters));
+    return this.localizeItem(key, templateOrFunction, parameters);
+  }
+  localizeEnumOnce(enumeration, value, parameters) {
+    if ((0, import_type_guards.isUndefined)(value)) {
+      const name = this.#activeLocalization()?.enums.get(enumeration)?.name;
+      return this.localizeItem("ENUM", name, parameters);
     }
-    localize$(data) {
-        return toObservable(this.localize(data));
+    const key = (0, import_type_guards.isArray)(enumeration) ? value : (0, import_enum.enumValueName)(enumeration, value);
+    const item = this.#activeLocalization()?.enums.get(enumeration)?.values[value];
+    if ((0, import_type_guards.isUndefined)(item)) {
+      return autoEnumerationLocalization(enumeration)[2][value];
     }
-    localizeEnum$(enumeration, value, parameters) {
-        return toObservable(this.localizeEnum(enumeration, value, parameters));
+    return this.localizeItem(key, item, parameters);
+  }
+  localize(data) {
+    return (0, import_api.computed)(() => this.localizeOnce(data));
+  }
+  localizeEnum(enumeration, value, parameters) {
+    return (0, import_api.computed)(() => this.localizeEnumOnce(enumeration, value, parameters));
+  }
+  localize$(data) {
+    return (0, import_api.toObservable)(this.localize(data));
+  }
+  localizeEnum$(enumeration, value, parameters) {
+    return (0, import_api.toObservable)(this.localizeEnum(enumeration, value, parameters));
+  }
+  localizeItem(key, templateOrFunction, parameters) {
+    if ((0, import_type_guards.isUndefined)(templateOrFunction)) {
+      return `__${key}__`;
     }
-    localizeItem(key, templateOrFunction, parameters) {
-        if (isUndefined(templateOrFunction)) {
-            return `__${key}__`;
-        }
-        if (isFunction(templateOrFunction)) {
-            return templateOrFunction(parameters);
-        }
-        const template = templateOrFunction;
-        const templateParameters = ((isNotNull(parameters) && isObject(parameters)) ? parameters : {});
-        const matches = template.matchAll(parametersPattern);
-        let currentIndex = 0;
-        let result = '';
-        for (const { 0: match, index, groups } of matches) {
-            const parameterName = groups['parameter'];
-            result += template.slice(currentIndex, index);
-            result += templateParameters[parameterName] ?? `__${parameterName}__`;
-            currentIndex = index + match.length;
-        }
-        result += template.slice(currentIndex);
-        return result;
+    if ((0, import_type_guards.isFunction)(templateOrFunction)) {
+      return templateOrFunction(parameters);
     }
+    const template = templateOrFunction;
+    const templateParameters = (0, import_type_guards.isNotNull)(parameters) && (0, import_type_guards.isObject)(parameters) ? parameters : {};
+    const matches = template.matchAll(parametersPattern);
+    let currentIndex = 0;
+    let result = "";
+    for (const { 0: match, index, groups } of matches) {
+      const parameterName = groups["parameter"];
+      result += template.slice(currentIndex, index);
+      result += templateParameters[parameterName] ?? `__${parameterName}__`;
+      currentIndex = index + match.length;
+    }
+    result += template.slice(currentIndex);
+    return result;
+  }
 };
 LocalizationService = __decorate([
-    singleton(),
-    __param(0, resolveArg('LocalizationService')),
-    __metadata("design:paramtypes", [Logger])
+  (0, import_decorators.Singleton)(),
+  __param(0, (0, import_decorators.ResolveArg)("LocalizationService")),
+  __metadata("design:paramtypes", [import_logger.Logger])
 ], LocalizationService);
-export function enumerationLocalization(enumeration, nameOrLocalization, localizationOrNothing) {
-    return [enumeration, isLocalizeItem(nameOrLocalization) ? nameOrLocalization : undefined, localizationOrNothing ?? nameOrLocalization];
+function enumerationLocalization(enumeration, nameOrLocalization, localizationOrNothing) {
+  return [enumeration, isLocalizeItem(nameOrLocalization) ? nameOrLocalization : void 0, localizationOrNothing ?? nameOrLocalization];
 }
 function _autoEnumerationLocalization(enumeration, name) {
-    if (isObject(enumeration)) {
-        return [enumeration, name, Object.fromEntries(enumEntries(enumeration).map(([key, value]) => [value, key]))];
-    }
-    const arrayEntries = enumeration.map((value) => [value, value]);
-    return [enumeration, name, Object.fromEntries(arrayEntries)];
+  if ((0, import_type_guards.isObject)(enumeration)) {
+    return [enumeration, name, Object.fromEntries((0, import_enum.enumEntries)(enumeration).map(([key, value]) => [value, key]))];
+  }
+  const arrayEntries = enumeration.map((value) => [value, value]);
+  return [enumeration, name, Object.fromEntries(arrayEntries)];
 }
 function buildMappedLocalization({ language, keys, enums }) {
-    const enumsEntries = enums.map((entry) => [entry[0], { name: entry[1], values: entry[2] }]);
-    const mappedLocalization = {
-        language,
-        keys: new Map(deepObjectEntries(keys)),
-        enums: new Map(enumsEntries)
-    };
-    return mappedLocalization;
+  const enumsEntries = enums.map((entry) => [entry[0], { name: entry[1], values: entry[2] }]);
+  const mappedLocalization = {
+    language,
+    keys: new Map((0, import_object.deepObjectEntries)(keys)),
+    enums: new Map(enumsEntries)
+  };
+  return mappedLocalization;
 }
 function getStringKey(key, sourceKey = key) {
-    if (isProxyLocalizationKey(key)) {
-        return key[propertyName];
-    }
-    if (isString(key)) {
-        return key;
-    }
-    if (isNullOrUndefined(key)) {
-        throw new DetailsError('Invalid localization key', { sourceKey });
-    }
-    return getStringKey(key.key, sourceKey);
+  if (isProxyLocalizationKey(key)) {
+    return key[import_property_name.propertyName];
+  }
+  if ((0, import_type_guards.isString)(key)) {
+    return key;
+  }
+  if ((0, import_type_guards.isNullOrUndefined)(key)) {
+    throw new import_details_error.DetailsError("Invalid localization key", { sourceKey });
+  }
+  return getStringKey(key.key, sourceKey);
 }
 function mergeMappedLocalization(a, b, force = false) {
-    if (!force && (a.language.code != b.language.code)) {
-        throw new Error('Language code mismatch. Set force to true to force.');
-    }
-    return {
-        language: b.language,
-        keys: new Map([...a.keys, ...b.keys]),
-        enums: new Map([...a.enums, ...b.enums])
-    };
+  if (!force && a.language.code != b.language.code) {
+    throw new Error("Language code mismatch. Set force to true to force.");
+  }
+  return {
+    language: b.language,
+    keys: new Map([...a.keys, ...b.keys]),
+    enums: new Map([...a.enums, ...b.enums])
+  };
 }
-export function isLocalizeItem(value) {
-    return isString(value) || isFunction(value);
+function isLocalizeItem(value) {
+  return (0, import_type_guards.isString)(value) || (0, import_type_guards.isFunction)(value);
 }

package/theme/adapters/css-adapter.js

@@ -1,29 +1,52 @@
-import { objectEntries } from '../../utils/object/object.js';
-import { hyphenate } from '../../utils/string/hypenate.js';
-import { themeColorTones } from '../theme-service.js';
-export function cssThemeAdapter(themeService) {
-    const styleSheet = new CSSStyleSheet();
-    document.adoptedStyleSheets.push(styleSheet);
-    const rootRule = createCssRule(styleSheet, ':root  {}');
-    const subscription = themeService.calculatedTheme$.subscribe((theme) => setVariables(rootRule, theme.palette));
-    return {
-        destroy() {
-            subscription.unsubscribe();
-        }
-    };
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var css_adapter_exports = {};
+__export(css_adapter_exports, {
+  cssThemeAdapter: () => cssThemeAdapter
+});
+module.exports = __toCommonJS(css_adapter_exports);
+var import_object = require("../../utils/object/object.js");
+var import_hypenate = require("../../utils/string/hypenate.js");
+var import_theme_service = require("../theme-service.js");
+function cssThemeAdapter(themeService) {
+  const styleSheet = new CSSStyleSheet();
+  document.adoptedStyleSheets.push(styleSheet);
+  const rootRule = createCssRule(styleSheet, ":root  {}");
+  const subscription = themeService.calculatedTheme$.subscribe((theme) => setVariables(rootRule, theme.palette));
+  return {
+    destroy() {
+      subscription.unsubscribe();
+    }
+  };
 }
 function setVariables(cssRule, palette) {
-    for (const [color, tones] of objectEntries(palette)) {
-        const colorVariable = hyphenate(color);
-        for (const tone of themeColorTones) {
-            cssRule.style.setProperty(`--theme-${colorVariable}`, tones.base);
-            cssRule.style.setProperty(`--theme-${colorVariable}-rgb`, tones.baseRgb);
-            cssRule.style.setProperty(`--theme-${colorVariable}-${tone}`, tones[tone]);
-            cssRule.style.setProperty(`--theme-${colorVariable}-${tone}-rgb`, tones[`${tone}Rgb`]);
-        }
+  for (const [color, tones] of (0, import_object.objectEntries)(palette)) {
+    const colorVariable = (0, import_hypenate.hyphenate)(color);
+    for (const tone of import_theme_service.themeColorTones) {
+      cssRule.style.setProperty(`--theme-${colorVariable}`, tones.base);
+      cssRule.style.setProperty(`--theme-${colorVariable}-rgb`, tones.baseRgb);
+      cssRule.style.setProperty(`--theme-${colorVariable}-${tone}`, tones[tone]);
+      cssRule.style.setProperty(`--theme-${colorVariable}-${tone}-rgb`, tones[`${tone}Rgb`]);
     }
+  }
 }
 function createCssRule(styleSheet, rule) {
-    const index = styleSheet.insertRule(rule);
-    return styleSheet.cssRules[index];
+  const index = styleSheet.insertRule(rule);
+  return styleSheet.cssRules[index];
 }

package/theme/adapters/tailwind-adapter.js

@@ -1,32 +1,55 @@
-import { fromEntries, objectKeys } from '../../utils/object/object.js';
-import { hyphenate } from '../../utils/string/hypenate.js';
-import { isDefined } from '../../utils/type-guards.js';
-export function generateTailwindColorsFromTheme(theme, tailwindNamePrefix) {
-    const colors = objectKeys(theme.palette);
-    return generateTailwindColorsFromThemeColors(colors, tailwindNamePrefix);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tailwind_adapter_exports = {};
+__export(tailwind_adapter_exports, {
+  generateTailwindColorsFromTheme: () => generateTailwindColorsFromTheme,
+  generateTailwindColorsFromThemeColors: () => generateTailwindColorsFromThemeColors,
+  generateTailwindPalette: () => generateTailwindPalette
+});
+module.exports = __toCommonJS(tailwind_adapter_exports);
+var import_object = require("../../utils/object/object.js");
+var import_hypenate = require("../../utils/string/hypenate.js");
+var import_type_guards = require("../../utils/type-guards.js");
+function generateTailwindColorsFromTheme(theme, tailwindNamePrefix) {
+  const colors = (0, import_object.objectKeys)(theme.palette);
+  return generateTailwindColorsFromThemeColors(colors, tailwindNamePrefix);
 }
-export function generateTailwindColorsFromThemeColors(colors, tailwindNamePrefix) {
-    const prefix = isDefined(tailwindNamePrefix) ? `${tailwindNamePrefix}-` : '';
-    const entries = colors
-        .map(hyphenate)
-        .map((color) => [`${prefix}${color}`, generateTailwindPalette(color)]);
-    return fromEntries(entries);
+function generateTailwindColorsFromThemeColors(colors, tailwindNamePrefix) {
+  const prefix = (0, import_type_guards.isDefined)(tailwindNamePrefix) ? `${tailwindNamePrefix}-` : "";
+  const entries = colors.map(import_hypenate.hyphenate).map((color) => [`${prefix}${color}`, generateTailwindPalette(color)]);
+  return (0, import_object.fromEntries)(entries);
 }
-export function generateTailwindPalette(color) {
-    return {
-        /* eslint-disable @typescript-eslint/naming-convention */
-        DEFAULT: `rgb(var(--theme-${color}-rgb) / <alpha-value>)`,
-        50: `rgb(var(--theme-${color}-50-rgb) / <alpha-value>)`,
-        100: `rgb(var(--theme-${color}-100-rgb) / <alpha-value>)`,
-        200: `rgb(var(--theme-${color}-200-rgb) / <alpha-value>)`,
-        300: `rgb(var(--theme-${color}-300-rgb) / <alpha-value>)`,
-        400: `rgb(var(--theme-${color}-400-rgb) / <alpha-value>)`,
-        500: `rgb(var(--theme-${color}-500-rgb) / <alpha-value>)`,
-        600: `rgb(var(--theme-${color}-600-rgb) / <alpha-value>)`,
-        700: `rgb(var(--theme-${color}-700-rgb) / <alpha-value>)`,
-        800: `rgb(var(--theme-${color}-800-rgb) / <alpha-value>)`,
-        900: `rgb(var(--theme-${color}-900-rgb) / <alpha-value>)`,
-        950: `rgb(var(--theme-${color}-950-rgb) / <alpha-value>)`
-        /* eslint-enable @typescript-eslint/naming-convention */
-    };
+function generateTailwindPalette(color) {
+  return {
+    /* eslint-disable @typescript-eslint/naming-convention */
+    DEFAULT: `rgb(var(--theme-${color}-rgb) / <alpha-value>)`,
+    50: `rgb(var(--theme-${color}-50-rgb) / <alpha-value>)`,
+    100: `rgb(var(--theme-${color}-100-rgb) / <alpha-value>)`,
+    200: `rgb(var(--theme-${color}-200-rgb) / <alpha-value>)`,
+    300: `rgb(var(--theme-${color}-300-rgb) / <alpha-value>)`,
+    400: `rgb(var(--theme-${color}-400-rgb) / <alpha-value>)`,
+    500: `rgb(var(--theme-${color}-500-rgb) / <alpha-value>)`,
+    600: `rgb(var(--theme-${color}-600-rgb) / <alpha-value>)`,
+    700: `rgb(var(--theme-${color}-700-rgb) / <alpha-value>)`,
+    800: `rgb(var(--theme-${color}-800-rgb) / <alpha-value>)`,
+    900: `rgb(var(--theme-${color}-900-rgb) / <alpha-value>)`,
+    950: `rgb(var(--theme-${color}-950-rgb) / <alpha-value>)`
+    /* eslint-enable @typescript-eslint/naming-convention */
+  };
 }

package/theme/index.js

@@ -1 +1,18 @@
-export * from './theme-service.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var theme_exports = {};
+module.exports = __toCommonJS(theme_exports);
+__reExport(theme_exports, require("./theme-service.js"), module.exports);