npm - structured-fw - Versions diffs - 0.7.2 - Mend

structured-fw 0.7.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (129) hide show

package/Config.ts +47 -0
package/LICENSE +21 -0
package/README.md +332 -0
package/app/Types.ts +1 -0
package/app/models/README.md +9 -0
package/app/routes/README.md +19 -0
package/app/views/README.md +1 -0
package/app/views/layout.html +1 -0
package/bin/structured +114 -0
package/build/Config.d.ts +2 -0
package/build/Config.js +31 -0
package/build/app/Types.d.ts +1 -0
package/build/app/Types.js +1 -0
package/build/app/models/Users.d.ts +0 -0
package/build/app/models/Users.js +1 -0
package/build/app/routes/Auth.d.ts +0 -0
package/build/app/routes/Auth.js +1 -0
package/build/app/routes/Test.d.ts +2 -0
package/build/app/routes/Test.js +101 -0
package/build/app/routes/Todo.d.ts +0 -0
package/build/app/routes/Todo.js +1 -0
package/build/app/routes/Upload.d.ts +0 -0
package/build/app/routes/Upload.js +1 -0
package/build/app/routes/Validation.d.ts +2 -0
package/build/app/routes/Validation.js +34 -0
package/build/app/views/components/ClientImport/ClientImport.client.d.ts +2 -0
package/build/app/views/components/ClientImport/ClientImport.client.js +4 -0
package/build/app/views/components/ClientImport/Export.d.ts +1 -0
package/build/app/views/components/ClientImport/Export.js +1 -0
package/build/app/views/components/Conditionals/Conditionals.client.d.ts +2 -0
package/build/app/views/components/Conditionals/Conditionals.client.js +43 -0
package/build/app/views/components/FormTest/FormTestNested/FormTestNested.d.ts +8 -0
package/build/app/views/components/FormTest/FormTestNested/FormTestNested.js +7 -0
package/build/app/views/components/ModelsTest/ModelsTest.client.d.ts +2 -0
package/build/app/views/components/ModelsTest/ModelsTest.client.js +5 -0
package/build/app/views/components/MultipartForm/MultipartForm.client.d.ts +0 -0
package/build/app/views/components/MultipartForm/MultipartForm.client.js +1 -0
package/build/app/views/components/PassObject/PassObject.d.ts +10 -0
package/build/app/views/components/PassObject/PassObject.js +10 -0
package/build/app/views/components/PassObject/ReceiveObj/ReceiveObj.d.ts +6 -0
package/build/app/views/components/PassObject/ReceiveObj/ReceiveObj.js +6 -0
package/build/app/views/components/RedrawAbort/RedrawAbort.client.d.ts +2 -0
package/build/app/views/components/RedrawAbort/RedrawAbort.client.js +6 -0
package/build/app/views/components/RedrawAbort/RedrawAbort.d.ts +8 -0
package/build/app/views/components/RedrawAbort/RedrawAbort.js +8 -0
package/build/app/views/components/ServerSideContext/ServerSideContext.d.ts +7 -0
package/build/app/views/components/ServerSideContext/ServerSideContext.js +10 -0
package/build/assets/ts/Export.d.ts +1 -0
package/build/assets/ts/Export.js +1 -0
package/build/index.d.ts +1 -0
package/build/index.js +3 -0
package/build/system/Helpers.d.ts +3 -0
package/build/system/Helpers.js +72 -0
package/build/system/Symbols.d.ts +3 -0
package/build/system/Symbols.js +3 -0
package/build/system/Types.d.ts +171 -0
package/build/system/Types.js +1 -0
package/build/system/Util.d.ts +20 -0
package/build/system/Util.js +336 -0
package/build/system/client/App.d.ts +7 -0
package/build/system/client/App.js +8 -0
package/build/system/client/Client.d.ts +6 -0
package/build/system/client/Client.js +9 -0
package/build/system/client/ClientComponent.d.ts +68 -0
package/build/system/client/ClientComponent.js +734 -0
package/build/system/client/DataStore.d.ts +22 -0
package/build/system/client/DataStore.js +64 -0
package/build/system/client/DataStoreView.d.ts +19 -0
package/build/system/client/DataStoreView.js +56 -0
package/build/system/client/EventEmitter.d.ts +7 -0
package/build/system/client/EventEmitter.js +31 -0
package/build/system/client/Net.d.ts +13 -0
package/build/system/client/Net.js +39 -0
package/build/system/client/NetRequest.d.ts +13 -0
package/build/system/client/NetRequest.js +45 -0
package/build/system/server/Application.d.ts +31 -0
package/build/system/server/Application.js +171 -0
package/build/system/server/Component.d.ts +27 -0
package/build/system/server/Component.js +249 -0
package/build/system/server/Components.d.ts +12 -0
package/build/system/server/Components.js +77 -0
package/build/system/server/Cookies.d.ts +6 -0
package/build/system/server/Cookies.js +19 -0
package/build/system/server/Document.d.ts +24 -0
package/build/system/server/Document.js +107 -0
package/build/system/server/DocumentHead.d.ts +32 -0
package/build/system/server/DocumentHead.js +118 -0
package/build/system/server/FormValidation.d.ts +16 -0
package/build/system/server/FormValidation.js +197 -0
package/build/system/server/Handlebars.d.ts +11 -0
package/build/system/server/Handlebars.js +34 -0
package/build/system/server/Request.d.ts +21 -0
package/build/system/server/Request.js +356 -0
package/build/system/server/Session.d.ts +23 -0
package/build/system/server/Session.js +114 -0
package/build/system/server/dom/DOMFragment.d.ts +4 -0
package/build/system/server/dom/DOMFragment.js +6 -0
package/build/system/server/dom/DOMNode.d.ts +31 -0
package/build/system/server/dom/DOMNode.js +110 -0
package/build/system/server/dom/HTMLParser.d.ts +21 -0
package/build/system/server/dom/HTMLParser.js +204 -0
package/index.ts +4 -0
package/package.json +31 -0
package/system/Helpers.ts +97 -0
package/system/Symbols.ts +6 -0
package/system/Types.ts +234 -0
package/system/Util.ts +488 -0
package/system/client/App.ts +11 -0
package/system/client/Client.ts +9 -0
package/system/client/ClientComponent.ts +1117 -0
package/system/client/DataStore.ts +101 -0
package/system/client/DataStoreView.ts +82 -0
package/system/client/EventEmitter.ts +38 -0
package/system/client/Net.ts +58 -0
package/system/client/NetRequest.ts +64 -0
package/system/server/Application.ts +230 -0
package/system/server/Component.ts +404 -0
package/system/server/Components.ts +111 -0
package/system/server/Cookies.ts +29 -0
package/system/server/Document.ts +163 -0
package/system/server/DocumentHead.ts +150 -0
package/system/server/FormValidation.ts +231 -0
package/system/server/Handlebars.ts +51 -0
package/system/server/Request.ts +497 -0
package/system/server/Session.ts +151 -0
package/system/server/dom/DOMFragment.ts +7 -0
package/system/server/dom/DOMNode.ts +140 -0
package/system/server/dom/HTMLParser.ts +238 -0
package/tsconfig.json +35 -0

package/system/server/Document.ts ADDED Viewed

@@ -0,0 +1,163 @@
+import { ServerResponse } from 'node:http';
+import { Md5 } from 'ts-md5';
+import { Initializers, LooseObject, RequestContext, StructuredClientConfig } from '../../system/Types.js';
+import { Application } from './Application.js';
+import { DocumentHead } from './DocumentHead.js';
+import { Component } from './Component.js';
+import { attributeValueToString, randomString } from '../Util.js';
+import path from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+export class Document extends Component {
+    head: DocumentHead;
+    language = 'en';
+    application: Application;
+    initializers: Initializers = {};
+    initializersInitialized: boolean = false;
+    componentIds: Array<string> = [];
+    ctx: undefined|RequestContext;
+    appendHTML: string = '';
+    constructor(app: Application, title: string, ctx?: RequestContext) {
+        super('root');
+        this.application = app;
+        this.ctx = ctx;
+        this.document = this;
+        this.head = new DocumentHead(title);
+        // include client side JS, not an actual URL, Application.ts adds a request handler
+        // for routes starting with /assets/client-js/
+        this.head.addJS('/assets/client-js/client/Client.js', 0, { type: 'module' });
+        this.application.emit('documentCreated', this);
+    }
+    // HTTP2 push, Link headers
+    push(response: ServerResponse): void {
+        const resourcesJS = this.head.js.map((resource) => {
+            return `<${resource.path}>; rel=${this.application.config.http.linkHeaderRel}; as=script; crossorigin=anonymous`;
+        });
+        const resourcesCSS = this.head.css.map((resource) => {
+            return `<${resource.path}>; rel=${this.application.config.http.linkHeaderRel}; as=style; crossorigin=anonymous`;
+        });
+        const value = resourcesCSS.concat(resourcesJS).join(', ');
+        response.setHeader('Link', value);
+    }
+    body(): string {
+        return this.dom.innerHTML + '\n' + this.appendHTML;
+    }
+    public initInitializers(): Record<string, string> {
+        const initializers: {
+            [key: string] : string
+        } = {};
+        for (const name in this.initializers) {
+            initializers[name] = this.initializers[name].toString();
+        }
+        const initializersString = '<script type="application/javascript">window.initializers = ' + JSON.stringify(initializers) + '</script>';
+        this.head.add(initializersString);
+        this.initializersInitialized = true;
+        return initializers;
+    }
+    private initClientConfig(): void {
+        const clientConf: StructuredClientConfig = {
+            componentRender: this.application.config.url.componentRender,
+            componentNameAttribute: this.application.config.components.componentNameAttribute
+        }
+        const clientConfString = `<script type="application/javascript">window.structuredClientConfig = ${JSON.stringify(clientConf)}</script>`;
+        this.head.add(clientConfString);
+    }
+    public toString(): string {
+        if (! this.initializersInitialized) {
+            this.initInitializers();
+            this.initClientConfig();
+        }
+        return `<!DOCTYPE html>
+        <html lang="${this.language}">
+        ${this.head.toString()}
+        <body>
+            ${this.body()}
+        </body>
+        </html>`;
+    }
+    // generate an unique component id and store it to componentIds
+    // so that each component within the document has an unique id
+    allocateId(component: Component): string {
+        if (! this.componentIds) {
+            // if auto initialized it may have not yet initialized it as an empty array
+            this.componentIds = [];
+        }
+        // if component has data-id then md5(ComponentName:id), otherwise md5(ComponentName:DOM path:attributes JSON string)
+        let id = Md5.hashStr(`${component.name}:${'id' in component.attributes ? component.attributes.id : `${component.path.join('/')}:${JSON.stringify(component.attributesRaw)}`}`);
+        // but multiple components might render the exact same thing
+        // so in those cases travel up the tree and append the MD5 sum of the parent
+        if (this.componentIds.includes(id)) {
+            let current: Component|Document|null = component.parent;
+            do {
+                if (current === null || current.isRoot) {
+                    // reached root without being able to uniquely identify
+                    // resort to a random string
+                    // these components won't work as expected
+                    // they will lose access to their store (client side) whenever they or their parent is redrawn
+                    console.error(`Could not define an unique ID for component ${component.name}, path: ${component.path}`);
+                    id = randomString(16);
+                } else {
+                    id += '-' + Md5.hashStr(current.dom.outerHTML);
+                }
+                current = current?.parent || null;
+            } while(this.componentIds.includes(id));
+        }
+        this.componentIds.push(id);
+        return id;
+    }
+    // load the view from file system
+    public async loadView(pathRelative: string, data?: LooseObject): Promise<boolean> {
+        const viewPath = path.resolve('../' + this.application.config.components.path + '/' + pathRelative + (pathRelative.endsWith('.html') ? '' : '.html'));
+        if (! existsSync(viewPath)) {
+            console.warn(`Couldn't load document ${this.document.head.title}: ${viewPath}`);
+            return false;
+        }
+        const html = readFileSync(viewPath).toString();
+        await this.init(html, data);
+        return true;
+    }
+    // load given component into this document
+    public async loadComponent(componentName: string, data?: LooseObject): Promise<void> {
+        const componentEntry = this.document.application.components.getByName(componentName);
+        if (componentEntry) {
+            const dataString = data === undefined ? '' : Object.keys(data).reduce((prev, key) => {
+                prev.push(`data-${key}="${attributeValueToString(key, data[key])}"`)
+                return prev;
+            }, [] as Array<string>).join(' ');
+            await this.init(`<${componentName} ${dataString}></${componentName}>`, data);
+        }
+    }
+}

package/system/server/DocumentHead.ts ADDED Viewed

@@ -0,0 +1,150 @@
+import { DocumentResource } from '../Types';
+export class DocumentHead {
+    title: string;
+    js: Array<DocumentResource> = [];
+    css: Array<DocumentResource> = [];
+    custom: Array<string> = [];
+    charset = 'UTF-8';
+    favicon: {
+        image: string|null,
+        type: string
+    } = {
+        image: null,
+        type: 'image/png'
+    }
+    constructor(title: string) {
+        this.title = title;
+    }
+    public setTitle(title: string): void {
+        this.title = title;
+    }
+    public add(str: string): void {
+        this.custom.push(str);
+    }
+    public remove(str: string): void {
+        this.custom = this.custom.filter((strExisting) => {
+            return strExisting !== str;
+        });
+    }
+    public addJS(path: string, priority: number = 0, attributes: { [ attributeName: string ] : string|null } = {}): DocumentResource {
+        const resource = this.toResource(path, priority, attributes);
+        this.js.push(resource);
+        return resource;
+    }
+    public addCSS(path: string, priority: number = 0, attributes: { [ attributeName: string ] : string|null } = {}): DocumentResource {
+        const resource = this.toResource(path, priority, attributes);
+        this.css.push(resource);
+        return resource;
+    }
+    public removeJS(path: string): void {
+        const index = this.js.findIndex((resource) => {
+            return resource.path == path;
+        });
+        this.js.splice(index, 1);
+    }
+    public removeCSS(path: string): void {
+        const index = this.css.findIndex((resource) => {
+            return resource.path == path;
+        });
+        this.css.splice(index, 1);
+    }
+    private toResource(path: string, priority: number = 0, attributes: { [ attributeName: string ] : string|null } = {}): DocumentResource {
+        return {
+            path,
+            priority,
+            attributes
+        };
+    }
+    private attributesString(resource: DocumentResource): string {
+        let attributesString = '';
+        for (const attributeName in resource.attributes) {
+            const val = resource.attributes[attributeName]
+            if (val === null) {
+                attributesString += ` ${attributeName}`;
+            } else {
+                attributesString += ` ${attributeName}="${val}"`;
+            }
+        }
+        return attributesString;
+    }
+    public toString(): string {
+        const css = this.css.reduce((prev, curr) => {
+            return prev + '\n' + `<link rel="stylesheet" href="${curr.path}"${this.attributesString(curr)}>`;
+        }, '');
+        const js = this.js.reduce((prev, curr) => {
+            return prev + '\n' + `<script src="${curr.path}"${this.attributesString(curr)}></script>`;
+        }, '');
+        const custom = this.custom.reduce((prev, curr) => {
+            return prev + '\n' + curr;
+        }, '');
+        return `<head>
+            <meta charset="${this.charset}">
+            <meta http-equiv="X-UA-Compatible" content="IE=edge">
+            <meta name="viewport" content="width=device-width, initial-scale=1.0">
+            <title>${this.title}</title>
+            <link rel="icon" type="${this.favicon.type}" href="${this.favicon.image}">
+            ${css}
+            ${js}
+            ${custom}
+        </head>`;
+    }
+    public setFavicon(faviconPath: string|{
+        image: string|null,
+        type: string
+    }): void {
+        if (typeof faviconPath === 'string') {
+            this.favicon = {
+                image: faviconPath,
+                type: this.faviconType(faviconPath)
+            }
+            return;
+        }
+        // favicon given as object
+        if (faviconPath.type === '') {
+            // detect type
+            faviconPath.type = faviconPath.image ? this.faviconType(faviconPath.image) : 'image/png';
+        }
+        this.favicon = faviconPath;
+    }
+    private faviconType(file: string): string {
+        let ext: RegExpExecArray|string|null = /\.([^.]+)$/.exec(file);
+        let type = 'image/png';
+        if (ext !== null) {
+            ext = ext[1].toLowerCase();
+            const types: {
+                [key: string] : string
+            } = {
+                'png' : 'image/png',
+                'jpg' : 'image/jpeg',
+                'jpeg' : 'image/jpeg',
+                'gif' : 'image/gif',
+                'ico' : 'image/x-icon'
+            }
+            if (types[ext]) {
+                type = types[ext];
+            }
+        }
+        return type;
+    }
+}

package/system/server/FormValidation.ts ADDED Viewed

@@ -0,0 +1,231 @@
+import { FormValidationEntry, PostedDataDecoded, ValidationErrors, ValidationErrorsSingle, ValidationResult, ValidationRuleWithArguments, ValidatorErrorDecorator, ValidatorFunction } from '../Types';
+export class FormValidation {
+    fieldRules: Array<FormValidationEntry> = [];
+    // if true, only a single error is kept per field
+    singleError: boolean = false;
+    validators: {
+        [name: string] : ValidatorFunction
+    } = {
+        'required' : async (data, field) => {
+            if (! (field in data)) {
+                // field missing but required
+                return false;
+            }
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            // field exists, but consider empty strings non valid
+            return value.trim().length > 0;
+        },
+        'number' : async (data, field) => {
+            // does not need to be a number, but rather contain only numbers
+            // eg. 14
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            return /^-?\d+$/.test(value);
+        },
+        'float' : async (data, field) => {
+            // 14.2
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            return /^-?\d+\.\d+$/.test(value);
+        },
+        'numeric' : async (data, field, arg, rules) => {
+            // 14 or 14.2
+            return await this.validators['number'](data, field, arg, rules) || await this.validators['float'](data, field, arg, rules);
+        },
+        'min' : async(data, field, arg, rules) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            if (await this.validators['numeric'](data, field, arg, rules)) {
+                return parseFloat(value) >= arg;
+            }
+            // non numeric value, can't be determined so consider invalid
+            return false;
+        },
+        'max' : async(data, field, arg, rules) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            if (await this.validators['numeric'](data, field, arg, rules)) {
+                return parseFloat(value) <= arg;
+            }
+            // non numeric value, can't be determined so consider invalid
+            return false;
+        },
+        'minLength' : async (data, field, arg) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            return value.length >= arg;
+        },
+        'maxLength' : async (data, field, arg) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            return value.length <= arg;
+        },
+        'alphanumeric' : async (data, field) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            // string must contain only letters and numbers
+            return /^[a-zA-Z0-9]+$/.test(value);
+        },
+        'validEmail' : async (data, field) => {
+            const value = data[field];
+            if (typeof value !== 'string') {return false;}
+            return /^(?=.{1,254}$)(?=.{1,64}@)[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+(\.[-!#$%&'*+/0-9=?A-Z^_`a-z{|}~]+)*@[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/.test(value);
+        }
+    }
+    // functions that return error messages
+    decorators: {
+        [validatorName: string] : ValidatorErrorDecorator
+    } = {
+        'required' : (fieldHuman) => {
+            return `${fieldHuman} is required`;
+        },
+        'number' : (fieldHuman) => {
+            return `${fieldHuman} has to be a whole number`;
+        },
+        'float' : (fieldHuman) => {
+            return `${fieldHuman} has to be a decimal number`;
+        },
+        'numeric' : (fieldHuman) => {
+            return `${fieldHuman} has to contain a numeric value`;
+        },
+        'min' : (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to be a value greater than ${arg}`;
+        },
+        'max' : (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to be a value lower than ${arg}`;
+        },
+        'minLength' : (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to contain at least ${arg} characters`;
+        },
+        'maxLength' : (fieldHuman, data, field, arg) => {
+            return `${fieldHuman} has to contain no more than ${arg} characters`;
+        },
+        'alphanumeric' : (fieldHuman) => {
+            return `${fieldHuman} can contain only letter and numbers`;
+        },
+        'validEmail' : () => {
+            return `Please enter a valid email address`;
+        }
+    }
+    public addRule(fieldName: string, nameHumanReadable: string, rules: Array<string|ValidationRuleWithArguments|ValidatorFunction>): void {
+        const rule: FormValidationEntry = {
+            field: [fieldName, nameHumanReadable],
+            rules
+        }
+        this.fieldRules.push(rule);
+    }
+    // register new/override existing validator
+    public registerValidator(name: string, validator: ValidatorFunction, decorator?: ValidatorErrorDecorator): void {
+        this.validators[name] = validator;
+        // if decorator is provided, store it
+        if (typeof decorator === 'function') {
+            this.decorators[name] = decorator;
+        }
+    }
+    public registerDecorator(name: string, decorator: ValidatorErrorDecorator): void {
+        this.decorators[name] = decorator;
+    }
+    public async validate(data: PostedDataDecoded): Promise<ValidationResult> {
+        const result: ValidationResult = {
+            valid: true,
+            errors: {}
+        }
+        // run all validation rules
+        for (let i = 0; i < this.fieldRules.length; i++) {
+            const entry = this.fieldRules[i];
+            const isRequired = entry.rules.includes('required');
+            const value = data[entry.field[0]];
+            const possiblyValidDataExists = typeof value === 'string';
+            // content - a non required field that is not passed or is blank
+            // will pass all checks, for example rules ['numeric']
+            // we expect the field to contain a numeric value, but we don't expect the field to exist in the first place
+            // se all validators are skipped for content entries
+            const isContent = ! isRequired && (! possiblyValidDataExists  || value.trim().length === 0);
+            if (! isContent) {
+                for (let j = 0; j < entry.rules.length; j++) {
+                    const rule = entry.rules[j];
+                    if (typeof rule === 'function') {
+                        // custom callback (ValidatorFunction)
+                        const valid = await rule.apply(this, [data, entry.field[0], 0, entry.rules]);
+                        if (! valid) {
+                            await this.addError(result.errors, data, entry.field, 'callback');
+                        }
+                    } else {
+                        // uses a validator
+                        if (typeof rule === 'string') {
+                            // no arguments
+                            if (this.validators[rule]) {
+                                const valid = await this.validators[rule].apply(this, [data, entry.field[0], 0, entry.rules]);
+                                if (! valid) {
+                                    await this.addError(result.errors, data, entry.field, rule);
+                                }
+                            }
+                        } else {
+                            // rule with arguments
+                            const validatorName = rule[0];
+                            const arg = rule[1];
+                            if (this.validators[validatorName]) {
+                                const valid = await this.validators[validatorName].apply(this, [data, entry.field[0], arg, entry.rules]);
+                                if (! valid) {
+                                    await this.addError(result.errors, data, entry.field, validatorName, arg);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // valid if no errors
+        result.valid = Object.keys(result.errors).length == 0;
+        return result;
+    }
+    private async addError(errors: ValidationErrors|ValidationErrorsSingle, data: PostedDataDecoded, field: [string, string], rule: string, arg?: any): Promise<void> {
+        // error will be a human readable error returned by decorator
+        // if no decorator is found for the rule, rule itself becomes the error
+        let errorMessage = '';
+        if (this.decorators[rule]) {
+            errorMessage = await this.decorators[rule](field[1], data, field[0], arg);
+        } else {
+            errorMessage = rule;
+        }
+        if (! this.singleError) {
+            if (! errors[field[0]]) {
+                errors[field[0]] = [];
+            }
+            (errors as ValidationErrors)[field[0]].push(errorMessage);
+        } else {
+            // single error mode
+            if (! errors[field[0]]) {
+                errors[field[0]] = errorMessage;
+            }
+        }
+    }
+}

package/system/server/Handlebars.ts ADDED Viewed

@@ -0,0 +1,51 @@
+import { HelperDelegate } from "handlebars";
+import { default as HandlebarsInstance }  from 'handlebars';
+import { LooseObject } from "../Types.js";
+// handlebars helper manager
+export class Handlebars {
+    readonly instance: typeof HandlebarsInstance = HandlebarsInstance;
+    readonly helpers: Record<string, HelperDelegate> = {};
+    // register a handlebars helper
+    // registers it to this.instance and stores it to this.helpers
+    // if needed later all helpers can be applied to another instance of handlebars
+    public register(name: string, helper: HelperDelegate): void {
+        this.helpers[name] = helper;
+        this.instance.registerHelper(name, helper);
+    }
+    // load helpers from given path and register them
+    public async loadHelpers(path: string): Promise<void> {
+        try {
+            const helpers = await import(path) as {
+                default?: Record<string, HelperDelegate>
+            };
+            if (! ('default' in helpers)) {
+                throw new Error('File has no default export, expected default: Record<string, HelperDelegate>');
+            }
+            // register helpers
+            for (const name in helpers.default) {
+                this.register(name, helpers.default[name]);
+            }
+        } catch(e) {
+            throw new Error(e.message);
+        }
+    }
+    // apply all registered helpers to given Handlebars instance
+    public applyTo(handlebarsInstance: typeof HandlebarsInstance): void {
+        for (const name in this.helpers) {
+            handlebarsInstance.registerHelper(name, this.helpers[name]);
+        }
+    }
+    // given a HTML template that uses handlebars synthax and data
+    // compile and return resulting HTML
+    public compile(html: string, data: LooseObject): string {
+        const template = this.instance.compile(html);
+        return template(data);
+    }
+}