@bjoernboss/mws 1.0.0

package/dist/builder.js

@@ -0,0 +1,146 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+/* Copyright (c) 2026 Bjoern Boss Henrichsen */
+import * as libHelper from "./helper.js";
+export class HtmlGuard {
+    content;
+    constructor(content) {
+        this.content = content;
+    }
+    /* ensure the value is safe for html insertion; escapes plain strings, passes through HtmlGuard as-is */
+    static get(str) {
+        return (str instanceof HtmlGuard ? str : new HtmlGuard(libHelper.escapeHtml(str)));
+    }
+    /* wrap a string for html insertion; if safe is false, it will be html-escaped first */
+    static make(str, safe) {
+        return new HtmlGuard(safe ? str : libHelper.escapeHtml(str));
+    }
+}
+/* create a secure string [if safe is true, content is taken as-is; otherwise it is html escaped] */
+export function Safe(content, safe = true) {
+    return HtmlGuard.make(content, safe);
+}
+/* raw text content to be embedded into an html tree */
+export class EmbeddedContent {
+    content;
+    constructor(content, safe) {
+        this.content = (safe ? content : libHelper.escapeHtml(content));
+    }
+    simple() {
+        return (this.content.indexOf('\n') < 0);
+    }
+    finalize(_) {
+        return this.content;
+    }
+}
+/* self-closing html tag (e.g. <meta/>, <link/>, <br/>) */
+export class SingleTag {
+    content;
+    constructor(name, properties) {
+        let details = '';
+        for (const name in properties)
+            details += ` ${name}="${HtmlGuard.get(properties[name]).content}"`;
+        this.content = `<${name}${details}/>`;
+    }
+    simple() { return false; }
+    finalize(indent) {
+        return `${indent}${this.content}`;
+    }
+}
+/* html tag with children (e.g. <div>...</div>, <p>text</p>) */
+export class DualTag {
+    openTag;
+    closeTag;
+    children;
+    constructor(name, properties, children) {
+        let details = '';
+        for (const name in properties)
+            details += ` ${name}="${HtmlGuard.get(properties[name]).content}"`;
+        this.openTag = `<${name}${details}>`;
+        this.closeTag = `</${name}>`;
+        this.children = (Array.isArray(children) ? children : [children]);
+    }
+    simple() { return false; }
+    finalize(indent) {
+        if (this.children.length == 0)
+            return `${indent}${this.openTag}${this.closeTag}`;
+        /* inline the child if its the only one and it fits on a single line */
+        if (this.children.length == 1 && this.children[0].simple())
+            return `${indent}${this.openTag}${this.children[0].finalize('')}${this.closeTag}`;
+        /* construct the element with indented children */
+        let body = '', childIndent = `\t${indent}`;
+        for (const child of this.children)
+            body += `\n${child.finalize(childIndent)}`;
+        return `${indent}${this.openTag}${body}\n${indent}${this.closeTag}`;
+    }
+}
+/* full html page; automatically adds utf-8 charset and defaults language to 'en' */
+export class HtmlPage {
+    _head;
+    _body;
+    language;
+    constructor(options) {
+        this._head = (Array.isArray(options?.head) ? options?.head : (options?.head == undefined ? [] : [options?.head]));
+        this._body = (Array.isArray(options?.body) ? options?.body : (options?.body == undefined ? [] : [options?.body]));
+        this.language = options?.language ?? Safe('en', true);
+    }
+    get head() {
+        return this._head;
+    }
+    set head(value) {
+        this._head = (Array.isArray(value) ? value : [value]);
+    }
+    get body() {
+        return this._body;
+    }
+    set body(value) {
+        this._body = (Array.isArray(value) ? value : [value]);
+    }
+    finalize() {
+        const properties = { style: 'margin:0;height:100%;' };
+        if ((typeof this.language == 'string' ? this.language : this.language.content) != '')
+            properties['lang'] = this.language;
+        const page = new DualTag('html', properties, [
+            new DualTag('head', {}, [
+                new SingleTag('meta', { charset: 'utf-8' }),
+                ...this._head
+            ]),
+            new DualTag('body', { style: 'margin:0;height:100%;display:flex;' }, this._body)
+        ]);
+        return `<!DOCTYPE html>\n${page.finalize('')}`;
+    }
+}
+/* embed raw content; if safe is true, the content is trusted and
+*	inserted verbatim; otherwise it is html-escaped before insertion */
+export function Embed(content, safe) {
+    return new EmbeddedContent(content, safe);
+}
+export function Meta(name, content) {
+    return new SingleTag('meta', { name, content });
+}
+export function Title(name) {
+    return new DualTag('title', {}, new EmbeddedContent(HtmlGuard.get(name).content, true));
+}
+export function LoadStyle(path) {
+    return new SingleTag('link', { rel: 'stylesheet', type: 'text/css', href: path });
+}
+export function LoadScript(path, properties = {}) {
+    return new DualTag('script', { ...properties, src: path }, []);
+}
+/* inline css; content is inserted verbatim as <style> is a raw text element */
+export function AddStyle(content, properties = {}) {
+    return new DualTag('style', properties, [new EmbeddedContent(content, true)]);
+}
+/* inline javascript; content is inserted verbatim as <script> is a raw text element */
+export function AddScript(content, properties = {}) {
+    return new DualTag('script', properties, new EmbeddedContent(content, true));
+}
+export function Text(text, properties = {}) {
+    return new DualTag('p', properties, [new EmbeddedContent(HtmlGuard.get(text).content, true)]);
+}
+export function Div(properties = {}, children = []) {
+    return new DualTag('div', properties, children);
+}
+export function LoadingError() {
+    return Text('Failed to load Page Content', { style: 'font-family: monospace; color: red; font-weight: bold; text-align: center;' });
+}
+//# sourceMappingURL=builder.js.map

package/dist/cache.d.ts

@@ -0,0 +1,66 @@
+import * as libLog from "./log.js";
+import * as libBase from "./base.js";
+import * as libStream from "stream";
+export interface Cached {
+    isImmutable(): boolean;
+    filePath(): string;
+    fileSize(): number;
+    lastModified(): string;
+    uniqueId(): string;
+    stream(options?: {
+        start?: number;
+        end?: number;
+    }): libStream.Readable;
+    read(): Promise<Buffer>;
+    readSync(): Buffer;
+    encoded(encoding?: libBase.EncodingType): EncodedCache;
+}
+export interface EncodedCache {
+    contentSize(): number | null;
+    stream(): libStream.Readable;
+    read(): Promise<Buffer>;
+    readSync(): Buffer;
+}
+export declare class CacheHost extends libLog.Logger {
+    private _cacheManager;
+    private _immutableManager;
+    private _config;
+    constructor(config?: CacheConfig | BurntCacheConfig);
+    private resolveCache;
+    get config(): BurntCacheConfig;
+    fetchImmutable(path: string, options?: {
+        checkFreshness?: boolean;
+    }): Cached | string | null;
+    fetchDirect(path: string, options?: {
+        checkFreshness?: boolean;
+    }): Cached | null;
+    immutable(handler: string, path: string, options?: {
+        checkFreshness?: boolean;
+    }): string;
+    flush(): void;
+    read(path: string, options?: {
+        checkFreshness?: boolean;
+    }): Promise<Buffer | null>;
+    write(path: string, data: Buffer | string, options?: {
+        what?: string;
+        temporary?: string;
+    }): Promise<void>;
+}
+export declare function createCache(config?: CacheConfig | BurntCacheConfig): CacheHost;
+export interface CacheConfig {
+    immutableStatePath?: string;
+    cacheSize?: number;
+    fileSizeLimit?: number;
+    alwaysValidate?: boolean;
+    immutableTagging?: boolean;
+}
+export declare class BurntCacheConfig {
+    readonly immutableStatePath: string;
+    readonly cacheSize: number;
+    readonly fileSizeLimit: number;
+    readonly alwaysValidate: boolean;
+    readonly immutableTagging: boolean;
+    constructor(config?: CacheConfig);
+    static from(config?: CacheConfig | BurntCacheConfig): BurntCacheConfig;
+}
+//# sourceMappingURL=cache.d.ts.map