@tstdl/base 0.84.22 → 0.84.24

package/examples/template/templates/hello-jsx.d.ts

@@ -1,2 +1,2 @@
-export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
+export declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, import("../../../types.js").Record>;
 export default template;

package/examples/template/templates/hello-name.d.ts

@@ -1,2 +1,2 @@
-declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, any>;
+declare const template: import("../../../templates/template.model.js").Template<import("../../../types.js").Record<string, boolean>, any, import("../../../types.js").Record>;
 export default template;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.22",
+  "version": "0.84.24",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -35,7 +35,7 @@
     "@types/nodemailer": "6.4",
     "@typescript-eslint/eslint-plugin": "5.59",
     "@typescript-eslint/parser": "5.59",
-    "concurrently": "8.0",
+    "concurrently": "8.1",
     "esbuild": "0.17",
     "eslint": "8.41",
     "eslint-import-resolver-typescript": "3.5",
@@ -45,7 +45,7 @@
     "typescript": "5.0"
   },
   "peerDependencies": {
-    "@elastic/elasticsearch": "^8.7",
+    "@elastic/elasticsearch": "^8.8",
     "@koa/router": "^12.0",
     "@tstdl/angular": "^0.84",
     "@zxcvbn-ts/core": "^3.0",

package/signals/implementation/api.d.ts

@@ -25,9 +25,9 @@ export interface Signal<T> {
     [SIGNAL]?: unknown;
 }
 /**
- * Checks if the given `value` function is a reactive `Signal`.
+ * Checks if the given `value` is a reactive `Signal`.
  */
-export declare function isSignal(value: Function): value is Signal<unknown>;
+export declare function isSignal(value: unknown): value is Signal<unknown>;
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`).
  *

package/signals/implementation/api.js

@@ -32,7 +32,7 @@ module.exports = __toCommonJS(api_exports);
  */
 const SIGNAL = Symbol("SIGNAL");
 function isSignal(value) {
-  return value[SIGNAL] !== void 0;
+  return typeof value == "function" && value[SIGNAL] !== void 0;
 }
 function createSignalFromFunction(node, fn, extraApi = {}) {
   fn[SIGNAL] = node;

package/templates/renderers/handlebars.template-renderer.d.ts

@@ -37,7 +37,7 @@ export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handle
     private readonly compileHandlebarsTemplate;
     constructor(templateResolverProvider: TemplateResolverProvider);
     canHandleType(type: string): boolean;
-    _render(renderObject: HandlebarsTemplateRenderObject, context?: object): Promise<string>;
+    _render(renderObject: HandlebarsTemplateRenderObject, context: Record): Promise<string>;
     private _compileHandlebarsTemplate;
     private normalizePartial;
 }

package/templates/renderers/jsx.template-renderer.d.ts

@@ -1,3 +1,4 @@
+import type { Record } from '../../types.js';
 import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
 import { TemplateRenderer } from '../template.renderer.js';
@@ -5,5 +6,5 @@ export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, Jsx
 export declare class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
     constructor();
     canHandleType(type: string): boolean;
-    _render({ template: TemplateComponent }: JsxTemplateRenderObject, context?: object): TemplateRenderResult;
+    _render({ template: TemplateComponent }: JsxTemplateRenderObject, context: Record): TemplateRenderResult;
 }

package/templates/renderers/mjml.template-renderer.d.ts

@@ -1,3 +1,4 @@
+import type { Record } from '../../types.js';
 import type { MJMLParsingOptions } from 'mjml-core';
 import { TemplateRendererProvider } from '../template-renderer.provider.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
@@ -11,5 +12,5 @@ export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererS
     private readonly rendererProvider;
     constructor(rendererProvider: TemplateRendererProvider);
     canHandleType(type: string): boolean;
-    _render({ renderer, template, options }: MjmlTemplateRenderObject, context?: object): Promise<TemplateRenderResult>;
+    _render({ renderer, template, options }: MjmlTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
 }

package/templates/renderers/mjml.template-renderer.js

@@ -79,7 +79,7 @@ let MjmlTemplateRenderer = class MjmlTemplateRenderer2 extends import_template_r
         renderer: "mjml",
         template: result
       };
-      return this._render(preprocessedTemplate);
+      return this._render(preprocessedTemplate, context);
     }
     return (0, import_mjml.default)(template).html;
   }

package/templates/renderers/string.template-renderer.d.ts

@@ -1,8 +1,10 @@
+import type { Record } from '../../types.js';
+import type { StringTemplate } from '../resolvers/string.template-resolver.js';
 import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
 import { TemplateRenderer } from '../template.renderer.js';
-export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, string>;
+export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, StringTemplate>;
 export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
     constructor();
     canHandleType(type: string): boolean;
-    _render({ template }: StringTemplateRenderObject, _context?: object): TemplateRenderResult;
+    _render({ template }: StringTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
 }

package/templates/renderers/string.template-renderer.js

@@ -22,6 +22,7 @@ __export(string_template_renderer_exports, {
 });
 module.exports = __toCommonJS(string_template_renderer_exports);
 var import_container = require("../../container/index.js");
+var import_type_guards = require("../../utils/type-guards.js");
 var import_template_renderer = require("../template.renderer.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;
@@ -44,8 +45,11 @@ let StringTemplateRenderer = class StringTemplateRenderer2 extends import_templa
   canHandleType(type) {
     return type == "string";
   }
-  _render({ template }, _context) {
-    return template;
+  async _render({ template }, context) {
+    if ((0, import_type_guards.isString)(template)) {
+      return template;
+    }
+    return template(context);
   }
 };
 StringTemplateRenderer = __decorate([

package/templates/resolvers/string.template-resolver.d.ts

@@ -1,13 +1,14 @@
-import type { TypedOmit } from '../../types.js';
+import type { Record, TypedOmit } from '../../types.js';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
+export type StringTemplate = string | ((context: Record) => string | Promise<string>);
 export declare class StringTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'string', Renderer, Options> {
-    template: string;
+    template: StringTemplate;
 }
 export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
     constructor();
     canHandle(resolver: string): boolean;
-    resolve(field: StringTemplateField): string;
+    resolve(field: StringTemplateField): StringTemplate;
 }
 export declare function stringTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;

package/templates/resolvers/string.template-resolver.js

@@ -45,8 +45,8 @@ class StringTemplateField extends import_template_model.TemplateField {
   template;
 }
 __decorate([
-  (0, import_schema.Property)(),
-  __metadata("design:type", String)
+  (0, import_schema.Union)(String, Function),
+  __metadata("design:type", Object)
 ], StringTemplateField.prototype, "template", void 0);
 let StringTemplateResolver = class StringTemplateResolver2 extends import_template_resolver.TemplateResolver {
   constructor() {

package/templates/template.model.d.ts

@@ -11,7 +11,7 @@ export type TemplateFields<Fields extends Record<string, boolean>, Resolver exte
 } & {
     [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;
 }>;
-export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends object = any> {
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = Record> {
     readonly [templateContext]?: Context;
     /** name of template */
     name: string;

package/templates/template.renderer.d.ts

@@ -14,7 +14,7 @@ export declare const templateRendererOptions: unique symbol;
 export declare abstract class TemplateRenderer<Renderer extends string = string, Options = any> {
     readonly [templateRendererString]: Renderer;
     readonly [templateRendererOptions]: Options;
-    render(template: TemplateRenderObject<Renderer, Options>, context?: object): Promise<TemplateRenderResult>;
+    render(template: TemplateRenderObject<Renderer, Options>, context?: Record): Promise<TemplateRenderResult>;
     abstract canHandleType(type: string): boolean;
-    protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context?: object): TemplateRenderResult | Promise<TemplateRenderResult>;
+    protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context: Record): TemplateRenderResult | Promise<TemplateRenderResult>;
 }

package/templates/template.renderer.js

@@ -30,6 +30,6 @@ const templateRendererOptions = Symbol("templateRendererOptions");
 class TemplateRenderer {
   async render(template, context) {
     const parsedContext = (0, import_type_guards.isDefined)(template.contextSchema) ? import_schema.Schema.parse(template.contextSchema, context) : context;
-    return this._render(template, parsedContext);
+    return this._render(template, parsedContext ?? {});
   }
 }

package/text/localization.service.d.ts

@@ -27,7 +27,16 @@ export type ProxyLocalizationKey<Parameters = void> = PropertyName & {
     [parametersSymbol]?: Parameters;
 };
 export type LocalizationKey<Parameters = void> = string | ProxyLocalizationKey<Parameters>;
-export type LocalizationData<Parameters = any> = LocalizationKey | LocalizationDataObject<Parameters> | {
+export type EnumLocalizationKey<T extends Enumeration = Enumeration, Parameters = void> = Parameters extends void ? {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters?: void;
+} : {
+    enum: T;
+    value?: EnumerationValue<T>;
+    parameters: Parameters;
+};
+export type LocalizationData<Parameters = any, E extends Enumeration = any> = LocalizationKey | EnumLocalizationKey<E, Parameters> | LocalizationDataObject<Parameters> | {
     key: LocalizationKey;
     parameters?: void;
 };
@@ -40,6 +49,8 @@ export type ProxyLocalizationKeys<T extends LocalizationTemplate> = {
 };
 export declare function getProxyLocalizationKey<Parameters = void>(key: string): ProxyLocalizationKey<Parameters>;
 export declare function isProxyLocalizationKey(value: any): value is ProxyLocalizationKey;
+export declare function isEnumLocalizationKey(key: any): key is EnumLocalizationKey;
+export declare function isLocalizationDataObject(value: LocalizationData): value is LocalizationDataObject<any>;
 /** helper function to ensure type safety */
 export declare function localizationData<T>(data: LocalizationData<T>): LocalizationData<T>;
 /**
@@ -65,9 +76,9 @@ export declare class LocalizationService {
     getLanguage(languageCode: string): Language;
     setLanguage(languageOrCode: Language | string): void;
     setLocalization(localization: Localization): void;
-    tryGetItem<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
+    tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
     hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
-    localize<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
+    localize<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
     localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
     localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
     localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;

package/text/localization.service.js

@@ -23,6 +23,8 @@ __export(localization_service_exports, {
   enumerationLocalization: () => enumerationLocalization,
   getLocalizationKeys: () => getLocalizationKeys,
   getProxyLocalizationKey: () => getProxyLocalizationKey,
+  isEnumLocalizationKey: () => isEnumLocalizationKey,
+  isLocalizationDataObject: () => isLocalizationDataObject,
   isLocalizeItem: () => isLocalizeItem,
   isProxyLocalizationKey: () => isProxyLocalizationKey,
   localizationData: () => localizationData
@@ -62,6 +64,12 @@ function getProxyLocalizationKey(key) {
 function isProxyLocalizationKey(value) {
   return (0, import_property_name.isPropertyName)(value);
 }
+function isEnumLocalizationKey(key) {
+  return (0, import_type_guards.isObject)(key) && (0, import_object.hasOwnProperty)(key, "enum");
+}
+function isLocalizationDataObject(value) {
+  return (0, import_type_guards.isObject)(value) && (0, import_object.hasOwnProperty)(value, "key");
+}
 function localizationData(data) {
   return data;
 }
@@ -131,11 +139,15 @@ let LocalizationService = class LocalizationService2 {
   setLocalization(localization) {
     this.setLanguage(localization.language);
   }
-  tryGetItem(key) {
+  tryGetItem(keyOrData) {
     if ((0, import_type_guards.isUndefined)(this.activeLanguage)) {
       return void 0;
     }
-    const actualKey = getStringKey(key);
+    if (isEnumLocalizationKey(keyOrData)) {
+      const enumEntry = this.localizations.get(this.activeLanguage.code)?.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);
   }
   hasKey(key) {
@@ -144,6 +156,9 @@ let LocalizationService = class LocalizationService2 {
   }
   // eslint-disable-next-line max-statements
   localize(keyOrData) {
+    if (isEnumLocalizationKey(keyOrData)) {
+      return this.localizeEnum(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;