@tstdl/base 0.87.13 → 0.88.0-alpha1

package/text/dynamic-text.model.js

@@ -1,72 +1,43 @@
-"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 dynamic_text_model_exports = {};
-__export(dynamic_text_model_exports, {
-  missingLocalizationKeyText: () => missingLocalizationKeyText,
-  resolveDynamicText: () => resolveDynamicText,
-  resolveDynamicText$: () => resolveDynamicText$,
-  resolveDynamicTexts: () => resolveDynamicTexts,
-  resolveDynamicTexts$: () => resolveDynamicTexts$,
-  resolveNestedDynamicText: () => resolveNestedDynamicText,
-  resolveNestedDynamicText$: () => resolveNestedDynamicText$,
-  resolveNestedDynamicTexts: () => resolveNestedDynamicTexts,
-  resolveNestedDynamicTexts$: () => resolveNestedDynamicTexts$
-});
-module.exports = __toCommonJS(dynamic_text_model_exports);
-var import_rxjs = require("rxjs");
-var import_core = require("../core.js");
-var import_inject = require("../injector/inject.js");
-var import_api = require("../signals/api.js");
-var import_switch_map = require("../signals/switch-map.js");
-var import_untracked_operator = require("../signals/untracked-operator.js");
-var import_type_guards = require("../utils/type-guards.js");
-var import_localization_service = require("./localization.service.js");
-const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
-function resolveDynamicText(text, localizationService) {
-  const resolvedLocalizationService = localizationService ?? ((0, import_inject.isInInjectionContext)() ? (0, import_inject.inject)(import_localization_service.LocalizationService) : (0, import_core.getGlobalInjector)().resolve(import_localization_service.LocalizationService));
-  const localizableTextSignal = (0, import_api.isSignal)(text) ? text : (0, import_rxjs.isObservable)(text) ? (0, import_api.toSignal)(text.pipe((0, import_untracked_operator.runInUntracked)()), { initialValue: missingLocalizationKeyText }) : (0, import_api.computed)(() => text);
-  return (0, import_switch_map.switchMap)(() => {
-    const localizableText = localizableTextSignal();
-    return (0, import_type_guards.isString)(localizableText) ? (0, import_api.computed)(() => localizableText) : resolvedLocalizationService.localize(localizableText);
-  });
-}
-function resolveDynamicText$(text, localizationService) {
-  return (0, import_api.toObservable)(resolveDynamicText(text, localizationService));
-}
-function resolveDynamicTexts(texts, localizationService) {
-  const signals = texts.map((text) => resolveDynamicText(text, localizationService));
-  return (0, import_api.computed)(() => signals.map((s) => s()));
-}
-function resolveDynamicTexts$(texts, localizationService) {
-  return (0, import_api.toObservable)(resolveDynamicTexts(texts, localizationService));
-}
-function resolveNestedDynamicText(item, key, localizationService) {
-  const result = resolveDynamicText(item[key], localizationService);
-  return (0, import_api.computed)(() => ({ ...item, [key]: result() }));
-}
-function resolveNestedDynamicText$(item, key, localizationService) {
-  return (0, import_api.toObservable)(resolveNestedDynamicText(item, key, localizationService));
-}
-function resolveNestedDynamicTexts(items, key, localizationService) {
-  const itemSignals = items.map((item) => resolveNestedDynamicText(item, key, localizationService));
-  return (0, import_api.computed)(() => itemSignals.map((s) => s()));
-}
-function resolveNestedDynamicTexts$(items, key, localizationService) {
-  return (0, import_api.toObservable)(resolveNestedDynamicTexts(items, key, localizationService));
+import { isObservable } from 'rxjs';
+import { getGlobalInjector } from '../core.js';
+import { inject, isInInjectionContext } from '../injector/inject.js';
+import { computed, isSignal, toObservable, toSignal } from '../signals/api.js';
+import { switchMap } from '../signals/switch-map.js';
+import { runInUntracked } from '../signals/untracked-operator.js';
+import { isString } from '../utils/type-guards.js';
+import { LocalizationService } from './localization.service.js';
+export const missingLocalizationKeyText = '[MISSING LOCALIZATION KEY]';
+export function resolveDynamicText(text, localizationService) {
+    const resolvedLocalizationService = localizationService ?? (isInInjectionContext() ? inject(LocalizationService) : getGlobalInjector().resolve(LocalizationService));
+    const localizableTextSignal = isSignal(text) ? text
+        : isObservable(text) ? toSignal(text.pipe(runInUntracked()), { initialValue: missingLocalizationKeyText })
+            : computed(() => text);
+    return switchMap(() => {
+        const localizableText = localizableTextSignal();
+        return isString(localizableText) ? computed(() => localizableText) : resolvedLocalizationService.localize(localizableText);
+    });
+}
+export function resolveDynamicText$(text, localizationService) {
+    return toObservable(resolveDynamicText(text, localizationService));
+}
+export function resolveDynamicTexts(texts, localizationService) {
+    const signals = texts.map((text) => resolveDynamicText(text, localizationService));
+    return computed(() => signals.map((s) => s()));
+}
+export function resolveDynamicTexts$(texts, localizationService) {
+    return toObservable(resolveDynamicTexts(texts, localizationService));
+}
+export function resolveNestedDynamicText(item, key, localizationService) {
+    const result = resolveDynamicText(item[key], localizationService);
+    return computed(() => ({ ...item, [key]: result() }));
+}
+export function resolveNestedDynamicText$(item, key, localizationService) {
+    return toObservable(resolveNestedDynamicText(item, key, localizationService));
+}
+export function resolveNestedDynamicTexts(items, key, localizationService) {
+    const itemSignals = items.map((item) => resolveNestedDynamicText(item, key, localizationService));
+    return computed(() => itemSignals.map((s) => s()));
+}
+export function resolveNestedDynamicTexts$(items, key, localizationService) {
+    return toObservable(resolveNestedDynamicTexts(items, key, localizationService));
 }

package/text/index.js

@@ -1,20 +1,3 @@
-"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 text_exports = {};
-module.exports = __toCommonJS(text_exports);
-__reExport(text_exports, require("./dynamic-text.model.js"), module.exports);
-__reExport(text_exports, require("./localizable-text.model.js"), module.exports);
-__reExport(text_exports, require("./localization.service.js"), module.exports);
+export * from './dynamic-text.model.js';
+export * from './localizable-text.model.js';
+export * from './localization.service.js';

package/text/localizable-text.model.js

@@ -1,16 +1 @@
-"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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var localizable_text_model_exports = {};
-module.exports = __toCommonJS(localizable_text_model_exports);
+export {};

package/text/localization.service.js

@@ -1,264 +1,232 @@
-"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_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;
+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 { DetailsError } from '../error/details.error.js';
+import { ResolveArg, Singleton } from '../injector/decorators.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();
+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_decorators.Singleton)(),
-  __param(0, (0, import_decorators.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 { LocalizationService };
+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);
 }