@tstdl/base 0.83.0-beta2 → 0.83.0-beta4

package/text/localization.service.js

@@ -1,210 +1,237 @@
-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,
+  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_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 import_rxjs = require("rxjs");
+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 { enumEntries, enumValueName } from '../utils/enum.js';
-import { memoizeSingle } from '../utils/function/memoize.js';
-import { deepObjectEntries } from '../utils/object/object.js';
-import { getPropertyName, getPropertyNameProxy, isPropertyName, propertyName } from '../utils/object/property-name.js';
-import { assertDefinedPass, isArray, isDefined, isFunction, isNotNull, isNullOrUndefined, isObject, isString, isUndefined } from '../utils/type-guards.js';
-import { BehaviorSubject, map } from 'rxjs';
-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);
 }
-/** helper function to ensure type safety */
-export function localizationData(data) {
-    return data;
+function localizationData(data) {
+  return data;
 }
-/**
- * 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 = memoizeSingle(_autoEnumerationLocalization, { weak: true });
+const autoEnumerationLocalization = (0, import_memoize.memoizeSingle)(_autoEnumerationLocalization, { weak: true });
 const parametersPattern = /(?:\{\{\s*(?<parameter>\w+)\s*\}\})/ug;
-const warnedMissingKeys = new Set();
-let LocalizationService = class LocalizationService {
-    logger;
-    localizations;
-    activeLanguageSubject;
-    availableLanguagesSubject;
-    get activeLocalization() {
-        if (isUndefined(this.activeLanguage)) {
-            return undefined;
-        }
-        return this.localizations.get(this.activeLanguage.code);
-    }
-    get availableLanguages() {
-        return this.availableLanguagesSubject.value;
-    }
-    get activeLanguage() {
-        return this.activeLanguageSubject.value;
-    }
-    activeLanguage$;
-    availableLanguages$;
-    constructor(logger) {
-        this.logger = logger;
-        this.localizations = new Map();
-        this.activeLanguageSubject = new BehaviorSubject(undefined);
-        this.availableLanguagesSubject = new BehaviorSubject([]);
-        this.activeLanguage$ = this.activeLanguageSubject.asObservable();
-        this.availableLanguages$ = this.availableLanguagesSubject.asObservable();
-    }
-    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);
-            }
-            if (isUndefined(this.activeLanguage)) {
-                this.setLocalization(localization);
-            }
-            const availableLanguages = [...this.localizations].map(([, loc]) => loc.language);
-            this.availableLanguagesSubject.next(availableLanguages);
-        }
-    }
-    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.activeLanguageSubject.next(language);
-    }
-    setLocalization(localization) {
-        this.setLanguage(localization.language);
-    }
-    tryGetItem(key) {
-        if (isUndefined(this.activeLanguage)) {
-            return undefined;
-        }
-        const actualKey = getStringKey(key);
-        return this.localizations.get(this.activeLanguage.code)?.keys.get(actualKey);
-    }
-    hasKey(key) {
-        const item = this.tryGetItem(key);
-        return isDefined(item);
-    }
-    // eslint-disable-next-line max-statements
-    localize(keyOrData) {
-        const key = getStringKey(keyOrData);
-        const parameters = (isString(keyOrData) || isProxyLocalizationKey(keyOrData)) ? {} : keyOrData.parameters;
-        const templateOrFunction = isDefined(this.activeLanguage) ? this.localizations.get(this.activeLanguage.code)?.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);
-    }
-    localizeEnum(enumeration, value, parameters) {
-        const key = isArray(enumeration) ? value : enumValueName(enumeration, value);
-        const item = this.activeLocalization?.enums.get(enumeration)?.[value];
-        if (isUndefined(item)) {
-            return autoEnumerationLocalization(enumeration)[1][value];
-        }
-        return this.localizeItem(key, item, parameters);
-    }
-    localize$(data) {
-        return this.activeLanguage$.pipe(map(() => this.localize(data)));
-    }
-    localizeEnum$(enumeration, value, parameters) {
-        return this.activeLanguage$.pipe(map(() => 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;
-    }
+const warnedMissingKeys = /* @__PURE__ */ new Set();
+let LocalizationService = class LocalizationService2 {
+  logger;
+  localizations;
+  activeLanguageSubject;
+  availableLanguagesSubject;
+  get activeLocalization() {
+    if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
+      return void 0;
+    }
+    return this.localizations.get(this.activeLanguage.code);
+  }
+  get availableLanguages() {
+    return this.availableLanguagesSubject.value;
+  }
+  get activeLanguage() {
+    return this.activeLanguageSubject.value;
+  }
+  activeLanguage$;
+  availableLanguages$;
+  constructor(logger) {
+    this.logger = logger;
+    this.localizations = /* @__PURE__ */ new Map();
+    this.activeLanguageSubject = new import_rxjs.BehaviorSubject(void 0);
+    this.availableLanguagesSubject = new import_rxjs.BehaviorSubject([]);
+    this.activeLanguage$ = this.activeLanguageSubject.asObservable();
+    this.availableLanguages$ = this.availableLanguagesSubject.asObservable();
+  }
+  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);
+      }
+      if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
+        this.setLocalization(localization);
+      }
+      const availableLanguages = [...this.localizations].map(([, loc]) => loc.language);
+      this.availableLanguagesSubject.next(availableLanguages);
+    }
+  }
+  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.");
+    }
+    this.activeLanguageSubject.next(language);
+  }
+  setLocalization(localization) {
+    this.setLanguage(localization.language);
+  }
+  tryGetItem(key) {
+    if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
+      return void 0;
+    }
+    const actualKey = getStringKey(key);
+    return this.localizations.get(this.activeLanguage.code)?.keys.get(actualKey);
+  }
+  hasKey(key) {
+    const item = this.tryGetItem(key);
+    return (0, import_type_guards.isDefined)(item);
+  }
+  // eslint-disable-next-line max-statements
+  localize(keyOrData) {
+    const key = getStringKey(keyOrData);
+    const parameters = (0, import_type_guards.isString)(keyOrData) || isProxyLocalizationKey(keyOrData) ? {} : keyOrData.parameters;
+    const templateOrFunction = (0, import_type_guards.isDefined)(this.activeLanguage) ? this.localizations.get(this.activeLanguage.code)?.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);
+      }
+    }
+    return this.localizeItem(key, templateOrFunction, parameters);
+  }
+  localizeEnum(enumeration, value, parameters) {
+    const key = (0, import_type_guards.isArray)(enumeration) ? value : (0, import_enum.enumValueName)(enumeration, value);
+    const item = this.activeLocalization?.enums.get(enumeration)?.[value];
+    if ((0, import_type_guards.isUndefined)(item)) {
+      return autoEnumerationLocalization(enumeration)[1][value];
+    }
+    return this.localizeItem(key, item, parameters);
+  }
+  localize$(data) {
+    return this.activeLanguage$.pipe((0, import_rxjs.map)(() => this.localize(data)));
+  }
+  localizeEnum$(enumeration, value, parameters) {
+    return this.activeLanguage$.pipe((0, import_rxjs.map)(() => this.localizeEnum(enumeration, value, parameters)));
+  }
+  localizeItem(key, templateOrFunction, parameters) {
+    if ((0, import_type_guards.isUndefined)(templateOrFunction)) {
+      return `__${key}__`;
+    }
+    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_container.singleton)(),
+  __param(0, (0, import_container.resolveArg)("LocalizationService")),
+  __metadata("design:paramtypes", [import_logger.Logger])
 ], LocalizationService);
-export { LocalizationService };
-export function enumerationLocalization(enumeration, localization) {
-    return [enumeration, localization];
+function enumerationLocalization(enumeration, localization) {
+  return [enumeration, localization];
 }
 function _autoEnumerationLocalization(enumeration) {
-    if (isObject(enumeration)) {
-        return [enumeration, Object.fromEntries(enumEntries(enumeration).map(([key, value]) => [value, key]))];
-    }
-    const arrayEntries = enumeration.map((value) => [value, value]);
-    return [enumeration, Object.fromEntries(arrayEntries)];
+  if ((0, import_type_guards.isObject)(enumeration)) {
+    return [enumeration, Object.fromEntries((0, import_enum.enumEntries)(enumeration).map(([key, value]) => [value, key]))];
+  }
+  const arrayEntries = enumeration.map((value) => [value, value]);
+  return [enumeration, Object.fromEntries(arrayEntries)];
 }
 function buildMappedLocalization({ language, keys, enums }) {
-    const mappedLocalization = {
-        language,
-        keys: new Map(deepObjectEntries(keys)),
-        enums: new Map(enums)
-    };
-    return mappedLocalization;
+  const mappedLocalization = {
+    language,
+    keys: new Map((0, import_object.deepObjectEntries)(keys)),
+    enums: new Map(enums)
+  };
+  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])
+  };
 }
-//# sourceMappingURL=localization.service.js.map

package/theme/adapters/css-adapter.js

@@ -1,30 +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];
 }
-//# sourceMappingURL=css-adapter.js.map

package/theme/adapters/tailwind-adapter.js

@@ -1,32 +1,54 @@
-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>)`
-        /* 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>)`
+    /* eslint-enable @typescript-eslint/naming-convention */
+  };
 }
-//# sourceMappingURL=tailwind-adapter.js.map

package/theme/index.js

@@ -1,2 +1,18 @@
-export * from './theme-service.js';
-//# sourceMappingURL=index.js.map
+"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);