@tstdl/base 0.85.4 → 0.85.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.4",
+  "version": "0.85.6",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/text/dynamic-text.model.d.ts

@@ -1,9 +1,14 @@
-import type { PickBy, ReplaceKey } from '../types.js';
 import type { Observable } from 'rxjs';
+import type { Signal } from '../signals/api.js';
+import type { PickBy, ReactiveValue, ReplaceKey } from '../types.js';
 import type { LocalizableText } from './localizable-text.model.js';
 import { LocalizationService } from './localization.service.js';
-export type DynamicText = LocalizableText | Observable<LocalizableText>;
+export type DynamicText = ReactiveValue<LocalizableText>;
+export declare function resolveDynamicText(text: DynamicText, localizationService?: LocalizationService): Signal<string>;
 export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;
+export declare function resolveDynamicTexts(texts: DynamicText[], localizationService?: LocalizationService): Signal<string[]>;
 export declare function resolveDynamicTexts$(texts: DynamicText[], localizationService?: LocalizationService): Observable<string[]>;
+export declare function resolveNestedDynamicText<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>>;
 export declare function resolveNestedDynamicText$<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>>;
+export declare function resolveNestedDynamicTexts<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>[]>;
 export declare function resolveNestedDynamicTexts$<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>[]>;

package/text/dynamic-text.model.js

@@ -18,34 +18,59 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var dynamic_text_model_exports = {};
 __export(dynamic_text_model_exports, {
+  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_container = require("../container/index.js");
+var import_api = require("../signals/api.js");
+var import_to_observable = require("../signals/implementation/to-observable.js");
+var import_to_signal = require("../signals/implementation/to-signal.js");
 var import_type_guards = require("../utils/type-guards.js");
 var import_rxjs = require("rxjs");
 var import_localization_service = require("./localization.service.js");
+const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
+function resolveDynamicText(text, localizationService) {
+  return (0, import_to_signal.toSignal)(resolveDynamicText$(text, localizationService), { initialValue: missingLocalizationKeyText });
+}
 function resolveDynamicText$(text, localizationService) {
   const resolvedLocalizationService = localizationService ?? import_container.container.resolve(import_localization_service.LocalizationService);
   if ((0, import_rxjs.isObservable)(text)) {
     return text.pipe((0, import_rxjs.switchMap)((inner) => resolveDynamicText$(inner, localizationService)));
   }
+  if ((0, import_api.isSignal)(text)) {
+    const text$ = (0, import_to_observable.toObservable)(text);
+    return resolveDynamicText$(text$, resolvedLocalizationService);
+  }
   if ((0, import_type_guards.isString)(text)) {
     return (0, import_rxjs.of)(text);
   }
   return resolvedLocalizationService.localize$(text);
 }
+function resolveDynamicTexts(texts, localizationService) {
+  const initialValue = texts.map(() => missingLocalizationKeyText);
+  return (0, import_to_signal.toSignal)(resolveDynamicTexts$(texts, localizationService), { initialValue });
+}
 function resolveDynamicTexts$(texts, localizationService) {
   const resolvedLocalizationService = localizationService ?? import_container.container.resolve(import_localization_service.LocalizationService);
   const resolvedTextObservables = texts.map((text) => resolveDynamicText$(text, resolvedLocalizationService));
   return (0, import_rxjs.combineLatest)(resolvedTextObservables);
 }
+function resolveNestedDynamicText(item, key, localizationService) {
+  return (0, import_to_signal.toSignal)(resolveNestedDynamicText$(item, key, localizationService), { requireSync: true });
+}
 function resolveNestedDynamicText$(item, key, localizationService) {
   return resolveDynamicText$(item[key], localizationService).pipe((0, import_rxjs.map)((resolvedText) => ({ ...item, [key]: resolvedText })));
 }
+function resolveNestedDynamicTexts(items, key, localizationService) {
+  return (0, import_to_signal.toSignal)(resolveNestedDynamicTexts$(items, key, localizationService), { requireSync: true });
+}
 function resolveNestedDynamicTexts$(items, key, localizationService) {
   const resolvedLocalizationService = localizationService ?? import_container.container.resolve(import_localization_service.LocalizationService);
   const resolvedTextObservables = items.map((item) => resolveNestedDynamicText$(item, key, resolvedLocalizationService));

package/text/localization.service.d.ts

@@ -1,7 +1,8 @@
+import type { Observable } from 'rxjs';
 import { Logger } from '../logger/index.js';
+import type { Signal } from '../signals/api.js';
 import type { Enumeration, EnumerationValue } from '../types.js';
 import type { PropertyName } from '../utils/object/property-name.js';
-import type { Observable } from 'rxjs';
 export type Language = {
     code: string;
     name: string;
@@ -62,15 +63,11 @@ export declare function localizationData<T>(data: LocalizationData<T>): Localiza
 export declare function getLocalizationKeys<T extends Localization>(_localization?: T): ProxyLocalizationKeys<T['keys']>;
 export declare const autoEnumerationLocalization: typeof _autoEnumerationLocalization;
 export declare class LocalizationService {
-    private readonly logger;
-    private readonly localizations;
-    private readonly activeLanguageSubject;
-    private readonly availableLanguagesSubject;
-    private get activeLocalization();
-    get availableLanguages(): readonly Language[];
-    get activeLanguage(): Language | undefined;
-    readonly activeLanguage$: Observable<Language | undefined>;
-    readonly availableLanguages$: Observable<readonly Language[]>;
+    #private;
+    readonly activeLanguage: Signal<Language | null>;
+    readonly availableLanguages: Signal<Language[]>;
+    readonly activeLanguage$: Observable<Language | null>;
+    readonly availableLanguages$: Observable<Language[]>;
     constructor(logger: Logger);
     registerLocalization(...localizations: Localization[]): void;
     hasLanguage(languageCode: string): boolean;
@@ -79,8 +76,10 @@ export declare class LocalizationService {
     setLocalization(localization: Localization): void;
     tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
     hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
-    localize<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
-    localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
+    localizeOnce<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
+    localizeEnumOnce<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
+    localize<Parameters>(data: LocalizationData<Parameters>): Signal<string>;
+    localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Signal<string>;
     localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
     localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;
     private localizeItem;

package/text/localization.service.js

@@ -33,12 +33,13 @@ 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_computed_with_dependencies = require("../signals/computed-with-dependencies.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")
@@ -83,113 +84,113 @@ const autoEnumerationLocalization = (0, import_memoize.memoize)(_autoEnumeration
 const parametersPattern = /(?:\{\{\s*(?<parameter>\w+)\s*\}\})/ug;
 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;
+  #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;
     }
-    return this.localizations.get(this.activeLanguage.code);
-  }
-  get availableLanguages() {
-    return this.availableLanguagesSubject.value;
-  }
-  get activeLanguage() {
-    return this.activeLanguageSubject.value;
-  }
-  activeLanguage$;
-  availableLanguages$;
+    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;
-    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();
+    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);
+      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);
+        this.#localizations.set(localization.language.code, merged);
       } else {
-        this.localizations.set(localization.language.code, mappedLocalization);
+        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);
+      const availableLanguages = [...this.#localizations].map(([, loc]) => loc.language);
+      this.#availableLanguages.set(availableLanguages);
     }
   }
   hasLanguage(languageCode) {
-    return this.localizations.has(languageCode);
+    return this.#localizations.has(languageCode);
   }
   getLanguage(languageCode) {
-    return (0, import_type_guards.assertDefinedPass)(this.localizations.get(languageCode), "language not available").language;
+    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)) {
+    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);
+    this.#activeLanguage.set(language);
   }
   setLocalization(localization) {
     this.setLanguage(localization.language);
   }
   tryGetItem(keyOrData) {
-    if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
+    const activeLanguageCode = this.#activeLanguage()?.code;
+    if ((0, import_type_guards.isUndefined)(activeLanguageCode)) {
       return void 0;
     }
     if (isEnumLocalizationKey(keyOrData)) {
-      const enumEntry = this.localizations.get(this.activeLanguage.code)?.enums.get(keyOrData.enum);
+      const enumEntry = this.#localizations.get(activeLanguageCode)?.enums.get(keyOrData.enum);
       return (0, import_type_guards.isDefined)(keyOrData.value) ? enumEntry?.values[keyOrData.value] : enumEntry?.name;
     }
     const actualKey = getStringKey(keyOrData);
-    return this.localizations.get(this.activeLanguage.code)?.keys.get(actualKey);
+    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
-  localize(keyOrData) {
+  localizeOnce(keyOrData) {
     if (isEnumLocalizationKey(keyOrData)) {
-      return this.localizeEnum(keyOrData.enum, keyOrData.value, keyOrData.parameters);
+      return this.localizeEnumOnce(keyOrData.enum, keyOrData.value, keyOrData.parameters);
     }
     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;
+    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.`);
+        this.#logger.warn(`Localization for ${key} not available.`);
         warnedMissingKeys.add(key);
       }
     }
     return this.localizeItem(key, templateOrFunction, parameters);
   }
-  localizeEnum(enumeration, value, parameters) {
+  localizeEnumOnce(enumeration, value, parameters) {
     if ((0, import_type_guards.isUndefined)(value)) {
-      const name = this.activeLocalization?.enums.get(enumeration)?.name;
+      const name = this.#activeLocalization()?.enums.get(enumeration)?.name;
       return this.localizeItem("ENUM", name, 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];
+    const item = this.#activeLocalization()?.enums.get(enumeration)?.values[value];
     if ((0, import_type_guards.isUndefined)(item)) {
       return autoEnumerationLocalization(enumeration)[2][value];
     }
     return this.localizeItem(key, item, parameters);
   }
+  localize(data) {
+    return (0, import_computed_with_dependencies.computedWithDependencies)(() => this.localizeOnce(data), [this.#activeLanguage]);
+  }
+  localizeEnum(enumeration, value, parameters) {
+    return (0, import_computed_with_dependencies.computedWithDependencies)(() => this.localizeEnumOnce(enumeration, value, parameters), [this.#activeLanguage]);
+  }
   localize$(data) {
-    return this.activeLanguage$.pipe((0, import_rxjs.map)(() => this.localize(data)));
+    return (0, import_api.toObservable)(this.localize(data));
   }
   localizeEnum$(enumeration, value, parameters) {
-    return this.activeLanguage$.pipe((0, import_rxjs.map)(() => this.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)) {

package/types.d.ts

@@ -1,4 +1,6 @@
+import type { Observable } from 'rxjs';
 import type { Except, UnionToIntersection } from 'type-fest';
+import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
     'string': string;
@@ -189,4 +191,5 @@ export type TypeFromPath<T extends Record, Path extends Paths<T> | string> = {
     [K in Path]: K extends keyof T ? T[K] : K extends `${infer P}.${infer S}` ? T[P] extends Record ? TypeFromPath<T[P], S> : never : never;
 }[Path];
 export type ConstructorParameterDecorator = (target: Object, propertyKey: undefined, parameterIndex: number) => void;
+export type ReactiveValue<T> = T | Signal<T> | Observable<T>;
 export {};