@tstdl/base 0.85.14 → 0.86.0-beta2

package/text/localization.service.js

@@ -1,264 +1,231 @@
-"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 __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;
 };
-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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-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_container = require("../container/index.js");
-var import_details_error = require("../error/details.error.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;
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
 };
-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);
+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);
 }
-function isProxyLocalizationKey(value) {
-  return (0, import_property_name.isPropertyName)(value);
+export function isProxyLocalizationKey(value) {
+    return isPropertyName(value);
 }
-function isEnumLocalizationKey(key) {
-  return (0, import_type_guards.isObject)(key) && (0, import_object.hasOwnProperty)(key, "enum");
+export function isEnumLocalizationKey(key) {
+    return isObject(key) && hasOwnProperty(key, 'enum');
 }
-function isLocalizationDataObject(value) {
-  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "key");
+export function isLocalizationDataObject(value) {
+    return isObject(value) && hasOwnProperty(value, 'key');
 }
-function localizationData(keyOrData, parameters) {
-  if ((0, import_type_guards.isString)(keyOrData) || isProxyLocalizationKey(keyOrData)) {
-    return { key: keyOrData, parameters };
-  }
-  return keyOrData;
+export function localizationData(keyOrData, parameters) {
+    if (isString(keyOrData) || isProxyLocalizationKey(keyOrData)) {
+        return { key: keyOrData, parameters };
+    }
+    return keyOrData;
 }
-function getLocalizationKeys(_localization) {
-  return (0, import_property_name.getPropertyNameProxy)();
+/**
+ * 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();
 }
-const autoEnumerationLocalization = (0, import_memoize.memoize)(_autoEnumerationLocalization);
+export const autoEnumerationLocalization = memoize(_autoEnumerationLocalization);
 const parametersPattern = /(?:\{\{\s*(?<parameter>\w+)\s*\}\})/ug;
-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;
+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;
     }
-    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);
-      }
+    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 (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.");
+    hasLanguage(languageCode) {
+        return this.#localizations.has(languageCode);
     }
-    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;
+    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);
+    }
+    setLocalization(localization) {
+        this.setLanguage(localization.language.code);
     }
-    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;
+    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);
     }
-    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);
+    hasKey(key) {
+        const item = this.tryGetItem(key);
+        return isDefined(item);
     }
-    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);
-      }
+    // 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);
     }
-    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);
+    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 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];
+    localize(data) {
+        return computed(() => this.localizeOnce(data));
     }
-    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}__`;
+    localizeEnum(enumeration, value, parameters) {
+        return computed(() => this.localizeEnumOnce(enumeration, value, parameters));
     }
-    if ((0, import_type_guards.isFunction)(templateOrFunction)) {
-      return templateOrFunction(parameters);
+    localize$(data) {
+        return toObservable(this.localize(data));
     }
-    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;
+    localizeEnum$(enumeration, value, parameters) {
+        return toObservable(this.localizeEnum(enumeration, value, parameters));
+    }
+    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;
     }
-    result += template.slice(currentIndex);
-    return result;
-  }
 };
 LocalizationService = __decorate([
-  (0, import_container.singleton)(),
-  __param(0, (0, import_container.resolveArg)("LocalizationService")),
-  __metadata("design:paramtypes", [import_logger.Logger])
+    singleton(),
+    __param(0, resolveArg('LocalizationService')),
+    __metadata("design:paramtypes", [Logger])
 ], LocalizationService);
-function enumerationLocalization(enumeration, nameOrLocalization, localizationOrNothing) {
-  return [enumeration, isLocalizeItem(nameOrLocalization) ? nameOrLocalization : void 0, localizationOrNothing ?? nameOrLocalization];
+export function enumerationLocalization(enumeration, nameOrLocalization, localizationOrNothing) {
+    return [enumeration, isLocalizeItem(nameOrLocalization) ? nameOrLocalization : undefined, localizationOrNothing ?? nameOrLocalization];
 }
 function _autoEnumerationLocalization(enumeration, name) {
-  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)];
+    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)];
 }
 function buildMappedLocalization({ language, keys, enums }) {
-  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;
+    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;
 }
 function getStringKey(key, sourceKey = key) {
-  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);
+    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);
 }
 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])
+    };
 }
-function isLocalizeItem(value) {
-  return (0, import_type_guards.isString)(value) || (0, import_type_guards.isFunction)(value);
+export function isLocalizeItem(value) {
+    return isString(value) || isFunction(value);
 }

package/theme/adapters/css-adapter.js

@@ -1,52 +1,29 @@
-"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();
-    }
-  };
+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();
+        }
+    };
 }
 function setVariables(cssRule, palette) {
-  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`]);
+    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`]);
+        }
     }
-  }
 }
 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,55 +1,32 @@
-"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);
+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);
 }
-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 generateTailwindColorsFromThemeColors(colors, tailwindNamePrefix) {
+    const prefix = isDefined(tailwindNamePrefix) ? `${tailwindNamePrefix}-` : '';
+    const entries = colors
+        .map(hyphenate)
+        .map((color) => [`${prefix}${color}`, generateTailwindPalette(color)]);
+    return fromEntries(entries);
 }
-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 */
-  };
+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 */
+    };
 }