@tstdl/base 0.84.23 → 0.84.25

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

@@ -1,2 +1,5 @@
-declare const template: import("../../../mail/index.js").MailTemplate<object>;
+type HelloMailContext = {
+    name: string;
+};
+declare const template: import("../../../mail/index.js").MailTemplate<HelloMailContext>;
 export default template;

package/examples/mail/templates/hello-name.js

@@ -31,6 +31,6 @@ function HelloMail({ name }) {
 const template = (0, import_mail.mailTemplate)("hello-name", {
   subject: (0, import_string_template_resolver.stringTemplateField)({ renderer: "handlebars", template: "Hello {{ name }} in subject!" }),
   html: (0, import_jsx_template_resolver.jsxTemplateField)({ renderer: "mjml-jsx", template: HelloMail }),
-  text: (0, import_string_template_resolver.stringTemplateField)({ renderer: "handlebars", template: "Hello {{ name }} in text!" })
+  text: (0, import_string_template_resolver.stringTemplateField)({ renderer: "string", template: ({ name }) => `Hello ${name} in text!` })
 });
 var hello_name_default = template;

package/mail/models/mail-template.model.d.ts

@@ -1,11 +1,14 @@
 import type { Template, TemplateField } from '../../templates/template.model.js';
-export type MailTemplate<Context extends object = any> = Template<{
+import type { Record } from '../../types.js';
+export type MailTemplate<Context extends Record = any> = Template<{
     subject: false;
     html: false;
     text: false;
 }, undefined, Context>;
-export declare function mailTemplate<Context extends object>(name: string, fields: {
-    subject?: TemplateField;
-    html?: TemplateField;
-    text?: TemplateField;
-}): MailTemplate<Context>;
+type MailTemplateFields<Context extends Record> = {
+    subject?: TemplateField<string, string, any, Context>;
+    html?: TemplateField<string, string, any, Context>;
+    text?: TemplateField<string, string, any, Context>;
+};
+export declare function mailTemplate<Context extends Record>(name: string, fields: MailTemplateFields<Context>): MailTemplate<Context>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.23",
+  "version": "0.84.25",
   "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",

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/jsx.template-resolver.d.ts

@@ -1,15 +1,15 @@
-import type { TypedOmit } from '../../types.js';
+import type { Record, TypedOmit } from '../../types.js';
 import type { ComponentClass, FunctionComponent } from 'preact';
 import { TemplateField } from '../template.model.js';
 import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
 import { TemplateResolver } from '../template.resolver.js';
-export type JsxTemplate = FunctionComponent<any> | ComponentClass<any, any>;
-export declare class JsxTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'string', Renderer, Options> {
-    template: JsxTemplate;
+export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
+export declare class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: JsxTemplate<Context>;
 }
 export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
     constructor();
     canHandle(resolver: string): boolean;
     resolve(field: JsxTemplateField): JsxTemplate;
 }
-export declare function jsxTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

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 declare class StringTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'string', Renderer, Options> {
-    template: string;
+export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
+export declare class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
+    template: StringTemplate<Context>;
 }
 export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
     constructor();
     canHandle(resolver: string): boolean;
-    resolve(field: StringTemplateField): string;
+    resolve(field: StringTemplateField): StringTemplate<Record>;
 }
-export declare function stringTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
+export declare function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

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

@@ -1,21 +1,23 @@
 import type { PickBy, Record, SimplifyObject } from '../types.js';
-export type TemplateContext<T extends Template> = T[typeof templateContext];
-export declare const templateContext: unique symbol;
-export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any> {
+export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
+declare const templateContext: unique symbol;
+export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
     resolver: Resolver;
     renderer: Renderer;
     options?: Options;
 }
-export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any> = SimplifyObject<{
-    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options>;
+export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<{
+    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>;
 } & {
-    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options>;
+    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>;
 }>;
-export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends object = any> {
-    readonly [templateContext]?: Context;
+export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
+    readonly [templateContext]?: (context: Context) => void;
     /** name of template */
     name: string;
-    fields: TemplateFields<Fields>;
+    fields: TemplateFields<Fields, string, string, any, Context>;
     options?: TemplateOptions;
 }
 export declare function simpleTemplate(name: string, template: TemplateField): Template;
+export {};

package/templates/template.model.js

@@ -20,8 +20,7 @@ var template_model_exports = {};
 __export(template_model_exports, {
   Template: () => Template,
   TemplateField: () => TemplateField,
-  simpleTemplate: () => simpleTemplate,
-  templateContext: () => templateContext
+  simpleTemplate: () => simpleTemplate
 });
 module.exports = __toCommonJS(template_model_exports);
 var import_schema = require("../schema/index.js");
@@ -39,7 +38,6 @@ var __metadata = function(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
     return Reflect.metadata(k, v);
 };
-const templateContext = Symbol("templateData");
 let TemplateField = class TemplateField2 {
   resolver;
   renderer;

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/templates/tokens.d.ts

@@ -1,4 +1,4 @@
 import type { TemplateRenderer } from './template.renderer.js';
 import type { TemplateResolver } from './template.resolver.js';
 export declare const TEMPLATE_RENDERERS: import("../container/index.js").InjectionToken<TemplateRenderer<string, any>[], any>;
-export declare const TEMPLATE_RESOLVERS: import("../container/index.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any>, unknown>[], any>;
+export declare const TEMPLATE_RESOLVERS: import("../container/index.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any, any>, unknown>[], any>;