@oino-ts/common 0.1.0

package/dist/esm/OINOResult.js

@@ -0,0 +1,211 @@
+/*
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+import { createHash } from "node:crypto";
+import { OINO_DEBUG_PREFIX, OINO_ERROR_PREFIX, OINO_INFO_PREFIX, OINO_WARNING_PREFIX } from ".";
+/**
+ * OINO API request result object with returned data and/or http status code/message and
+ * error / warning messages.
+ *
+ */
+export class OINOResult {
+    /** Wheter request was successfully executed */
+    success;
+    /** HTTP status code */
+    statusCode;
+    /** HTTP status message */
+    statusMessage;
+    /** Error / warning messages */
+    messages;
+    /**
+     * Constructor of OINOResult.
+     *
+     */
+    constructor() {
+        this.success = true;
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+        this.messages = [];
+    }
+    /**
+     * Copy values from different result.
+     *
+     * @param result source value
+     */
+    copy(result) {
+        this.success = result.success;
+        this.statusCode = result.statusCode;
+        this.statusMessage = result.statusMessage;
+        this.messages = result.messages.slice();
+    }
+    /**
+     * Set HTTP OK status (does not reset messages).
+     *
+     */
+    setOk() {
+        this.success = true;
+        this.statusCode = 200;
+        this.statusMessage = "OK";
+    }
+    /**
+     * Set HTTP error status using given code and message. Returns self reference for chaining.
+     *
+     * @param statusCode HTTP status code
+     * @param statusMessage HTTP status message
+     * @param operation operation where error occured
+     *
+     */
+    setError(statusCode, statusMessage, operation) {
+        this.success = false;
+        this.statusCode = statusCode;
+        if (this.statusMessage != "OK") {
+            this.messages.push(this.statusMessage); // latest error becomes status, but if there was something non-trivial, add it to the messages
+        }
+        if (statusMessage.startsWith(OINO_ERROR_PREFIX)) {
+            this.statusMessage = statusMessage;
+        }
+        else {
+            this.statusMessage = OINO_ERROR_PREFIX + " (" + operation + "): " + statusMessage;
+        }
+        return this;
+    }
+    /**
+     * Add warning message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where warning occured
+     *
+     */
+    addWarning(message, operation) {
+        message = message.trim();
+        if (message) {
+            this.messages.push(OINO_WARNING_PREFIX + " (" + operation + "): " + message);
+        }
+        return this;
+    }
+    /**
+     * Add info message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where info occured
+     *
+     */
+    addInfo(message, operation) {
+        message = message.trim();
+        if (message) {
+            this.messages.push(OINO_INFO_PREFIX + " (" + operation + "): " + message);
+        }
+        return this;
+    }
+    /**
+     * Add debug message. Returns self reference for chaining.
+     *
+     * @param message HTTP status message
+     * @param operation operation where debug occured
+     *
+     */
+    addDebug(message, operation) {
+        message = message.trim();
+        if (message) {
+            this.messages.push(OINO_DEBUG_PREFIX + " (" + operation + "): " + message);
+        }
+        return this;
+    }
+    /**
+     * Copy given messages to HTTP headers.
+     *
+     * @param headers HTTP headers
+     * @param copyErrors wether error messages should be copied (default true)
+     * @param copyWarnings wether warning messages should be copied (default false)
+     * @param copyInfos wether info messages should be copied (default false)
+     * @param copyDebug wether debug messages should be copied (default false)
+     *
+     */
+    copyMessagesToHeaders(headers, copyErrors = true, copyWarnings = false, copyInfos = false, copyDebug = false) {
+        let j = 1;
+        for (let i = 0; i < this.messages.length; i++) {
+            const message = this.messages[i].replaceAll("\r", " ").replaceAll("\n", " ");
+            if (copyErrors && message.startsWith(OINO_ERROR_PREFIX)) {
+                headers.append('X-OINO-MESSAGE-' + j, message);
+                j++;
+            }
+            if (copyWarnings && message.startsWith(OINO_WARNING_PREFIX)) {
+                headers.append('X-OINO-MESSAGE-' + j, message);
+                j++;
+            }
+            if (copyInfos && message.startsWith(OINO_INFO_PREFIX)) {
+                headers.append('X-OINO-MESSAGE-' + j, message);
+                j++;
+            }
+            if (copyDebug && message.startsWith(OINO_DEBUG_PREFIX)) {
+                headers.append('X-OINO-MESSAGE-' + j, message);
+                j++;
+            }
+        }
+    }
+    /**
+     * Print result for logging.
+     *
+     */
+    printLog() {
+        return "OINOResult: statusCode=" + this.statusCode + ", statusMessage=" + this.statusMessage + ", messages=[" + this.messages.join(", ") + "]";
+    }
+}
+/**
+ * Specialized result for HTTP responses.
+ */
+export class OINOHttpResult extends OINOResult {
+    _etag;
+    /** HTTP body data */
+    body;
+    /** HTTP cache expiration value */
+    expires;
+    /** HTTP cache last-modified value */
+    lastModified;
+    /**
+     * Constructor for a `OINOHttpResult`
+     *
+     * @param body HTTP body
+     *
+     */
+    constructor(body) {
+        super();
+        this.body = body;
+        this.expires = 0;
+        this.lastModified = 0;
+        this._etag = "";
+    }
+    /**
+     * Get the ETag value for the body opportunistically, i.e. don't calculate until requested and reuse value.
+     *
+     */
+    getEtag() {
+        if (this._etag == "") {
+            const hash = createHash("sha256");
+            this._etag = hash.update(this.body).digest("hex");
+        }
+        return this._etag;
+    }
+    /**
+     * Get a Response object from the result values.
+     *
+     * @param headers HTTP headers (overrides existing values)
+     */
+    getResponse(headers) {
+        const result = new Response(this.body, { status: this.statusCode, statusText: this.statusMessage, headers: headers });
+        result.headers.set('Content-Length', this.body.length.toString());
+        if (this.lastModified > 0) {
+            result.headers.set('Last-Modified', new Date(this.lastModified).toUTCString());
+        }
+        if (this.expires >= 0) {
+            result.headers.set('Expires', Math.round(this.expires).toString());
+            if (this.expires == 0) {
+                result.headers.set('Pragma', 'no-cache');
+            }
+        }
+        result.headers.set("ETag", this.getEtag());
+        return result;
+    }
+}

package/dist/esm/OINOStr.js

@@ -0,0 +1,261 @@
+import { OINOContentType } from ".";
+/**
+ * Static class string utilities.
+ *
+ */
+export class OINOStr {
+    /**
+     * Split string by the top level of the given type of brackets.
+     * E.g. splitByBrackets("a(bc(d))ef(gh)kl", true, true, '(', ')') would return ["a", "bc(d)", "ef", "gh", "kl"]
+     *
+     * @param str string to split
+     * @param includePartsBetweenBlocks whether to include strings between top level brackets
+     * @param includeTrailingUnescapedBlock whether to include final block that is missing necessary end brackets
+     * @param startBracket starting bracket, e.g. '('
+     * @param endBracket ending bracket, e.g. ')'
+     *
+     */
+    static splitByBrackets(str, includePartsBetweenBlocks, includeTrailingUnescapedBlock, startBracket, endBracket) {
+        let result = [];
+        let parenthesis_count = 0;
+        let start = 0;
+        let end = 0;
+        while (end < str.length) {
+            if (str[end] == startBracket) {
+                if (parenthesis_count == 0) {
+                    if ((end > start) && includePartsBetweenBlocks) { // there is some first level string to add to result
+                        result.push(str.substring(start, end));
+                    }
+                    start = end + 1;
+                }
+                parenthesis_count++;
+            }
+            else if (str[end] == endBracket) {
+                parenthesis_count--;
+                if (parenthesis_count == 0) {
+                    if (end >= start) {
+                        result.push(str.substring(start, end));
+                    }
+                    start = end + 1;
+                }
+            }
+            end++;
+        }
+        if ((end > start) && ((includePartsBetweenBlocks && (parenthesis_count == 0)) || (includeTrailingUnescapedBlock && (parenthesis_count > 0)))) { // if there is stuff after last block or unfinished block (and those are supported)
+            result.push(str.substring(start, end)); // i == str.length
+        }
+        return result;
+    }
+    /**
+     * Split string by delimeter excluding delimeters inside given brackets.
+     * E.g. splitExcludingBrackets("a,(bc,d),ef,(g,h),k", ',', '(', ')') would return ["a", "bc,d", "ef", "g,h", "k"]
+     *
+     * @param str string to split
+     * @param delimeter string to use as delimeter
+     * @param startBracket starting bracket, e.g. '('
+     * @param endBracket ending bracket, e.g. ')'
+     */
+    static splitExcludingBrackets(str, delimeter, startBracket, endBracket) {
+        let result = [];
+        let bracket_level = 0;
+        let start = 0;
+        let end = 0;
+        while (end < str.length) {
+            if (str[end] == startBracket) {
+                bracket_level++;
+            }
+            else if (str[end] == endBracket) {
+                bracket_level--;
+            }
+            else if ((str[end] == delimeter) && (bracket_level == 0)) { // only delimeters at top level will break 
+                result.push(str.substring(start, end));
+                start = end + 1;
+            }
+            end++;
+        }
+        if (end > start) {
+            result.push(str.substring(start, end)); // i == str.length
+        }
+        return result;
+    }
+    /**
+     * Encode OINO serialized strings as valid JSON.
+     *
+     * @param str string to encode
+     * @param valueType wether it is a value type
+     */
+    static encodeJSON(str, valueType = false) {
+        if (str === undefined) { // no undefined literal in JSON
+            return "null";
+        }
+        else if (str === null) {
+            return "null";
+        }
+        else {
+            if (valueType) {
+                return str;
+            }
+            else {
+                return JSON.stringify(str);
+            }
+        }
+    }
+    /**
+     * Decode JSON string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeJSON(str) {
+        return str; // JSON parsing using JS methods, no need to decode anything
+    }
+    /**
+     * Encode OINO serialized strings as valid CSV.
+     *
+     * @param str string to encode
+     */
+    static encodeCSV(str) {
+        if (str === undefined) {
+            return "";
+        }
+        else if (str === null) {
+            return "null";
+        }
+        else {
+            return "\"" + str.replaceAll("\"", "\"\"") + "\"";
+        }
+    }
+    /**
+     * Decode CSV string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeCSV(str) {
+        return str.replaceAll("\"\"", "\"");
+    }
+    /**
+     * Encode OINO serialized strings as valid Formdata.
+     *
+     * @param str string to encode
+     */
+    static encodeFormdata(str) {
+        if (str === undefined) {
+            return "";
+        }
+        else if (str === null) {
+            return "";
+        }
+        else {
+            return str;
+        }
+    }
+    /**
+     * Decode Formdata string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeFormdata(str) {
+        return str;
+    }
+    /**
+     * Encode OINO serialized strings as valid Urlencode.
+     *
+     * @param str string to encode
+     */
+    static encodeUrlencode(str) {
+        if (str === undefined) {
+            return "";
+        }
+        else if (str === null) {
+            return "null";
+        }
+        else {
+            return encodeURIComponent(str);
+        }
+    }
+    /**
+     * Decode Urlencode string as OINO serialization.
+     *
+     * @param str string to decode
+     */
+    static decodeUrlencode(str) {
+        return decodeURIComponent(str);
+    }
+    /**
+     * Encode OINO serialized strings as valid HTML content.
+     *
+     * @param str string to encode
+     */
+    static encodeHtml(str) {
+        if (str === undefined) {
+            return "";
+        }
+        else if (str === null) {
+            return "";
+        }
+        else {
+            return str.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('>', '&gt;').replaceAll('"', '&quot;').replaceAll("'", '&#039;');
+        }
+    }
+    /**
+     * Decode HTML string as OINO serialization.
+     *
+     * @param str string to encode
+     */
+    static decodeHtml(str) {
+        return str.replaceAll('&amp;', '&').replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&quot;', '"').replaceAll('&#039;', "'");
+    }
+    /**
+     * Decode content type formatted string as OINO serialization.
+     *
+     * @param str string to decode
+     * @param contentType content type for serialization
+     *
+     */
+    static decode(str, contentType) {
+        if (contentType == OINOContentType.csv) {
+            return this.decodeCSV(str);
+        }
+        else if (contentType == OINOContentType.json) {
+            return this.decodeJSON(str);
+        }
+        else if (contentType == OINOContentType.formdata) {
+            return this.decodeFormdata(str);
+        }
+        else if (contentType == OINOContentType.urlencode) {
+            return this.decodeUrlencode(str);
+        }
+        else if (contentType == OINOContentType.html) {
+            return str;
+        }
+        else {
+            return str;
+        }
+    }
+    /**
+     * Encode OINO serialized string to the content type formatting.
+     *
+     * @param str string to encode
+     * @param contentType content type for serialization
+     *
+     */
+    static encode(str, contentType) {
+        if (contentType == OINOContentType.csv) {
+            return this.encodeCSV(str);
+        }
+        else if (contentType == OINOContentType.json) {
+            return this.encodeJSON(str);
+        }
+        else if (contentType == OINOContentType.formdata) {
+            return this.encodeFormdata(str);
+        }
+        else if (contentType == OINOContentType.urlencode) {
+            return this.encodeUrlencode(str);
+        }
+        else if (contentType == OINOContentType.html) {
+            return this.encodeHtml(str);
+        }
+        else {
+            return str || "";
+        }
+    }
+}

package/dist/esm/index.js

@@ -0,0 +1,29 @@
+export { OINOBenchmark } from "./OINOBenchmark.js";
+export { OINOLog, OINOLogLevel, OINOConsoleLog } from "./OINOLog.js";
+export { OINOResult, OINOHttpResult } from "./OINOResult.js";
+export { OINOStr } from "./OINOStr.js";
+export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
+/** OINO error message prefix */
+export const OINO_ERROR_PREFIX = "OINO ERROR";
+/** OINO warning message prefix */
+export const OINO_WARNING_PREFIX = "OINO WARNING";
+/** OINO info message prefix */
+export const OINO_INFO_PREFIX = "OINO INFO";
+/** OINO debug message prefix */
+export const OINO_DEBUG_PREFIX = "OINO DEBUG";
+/**
+ * Supported content format mime-types
+ */
+export var OINOContentType;
+(function (OINOContentType) {
+    /** JSON encoded data */
+    OINOContentType["json"] = "application/json";
+    /** CSV encoded data */
+    OINOContentType["csv"] = "text/csv";
+    /** Multipart encoded form data */
+    OINOContentType["formdata"] = "multipart/form-data";
+    /** URL encoded form data */
+    OINOContentType["urlencode"] = "application/x-www-form-urlencoded";
+    /** HTML encoded data (output only) */
+    OINOContentType["html"] = "text/html";
+})(OINOContentType || (OINOContentType = {}));

package/dist/types/OINOBenchmark.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Static class for benchmarking functions.
+ *
+ */
+export declare class OINOBenchmark {
+    private static _benchmarkCount;
+    private static _benchmarkData;
+    private static _benchmarkEnabled;
+    private static _benchmarkStart;
+    /**
+     * Reset benchmark data (but not what is enabled).
+     *
+     */
+    static reset(): void;
+    /**
+     *  Set benchmark names that are enabled.
+     *
+     *  @param module array of those benchmarks that are enabled
+     */
+    static setEnabled(module: string[]): void;
+    /**
+     * Start benchmark timing.
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     */
+    static start(module: string, method: string): void;
+    /**
+     * Complete benchmark timing
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     * @param category optional subcategory of the benchmark
+     */
+    static end(module: string, method: string, category?: string): number;
+    /**
+     * Get given benchmark data.
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     *
+     */
+    static get(module: string, method: string): number;
+    /**
+     * Get all benchmark data.
+     *
+     */
+    static getAll(): number;
+}

package/dist/types/OINOHtmlTemplate.d.ts

@@ -0,0 +1,88 @@
+import { OINOResult, OINOHttpResult } from ".";
+/**
+ * Class for rendering HTML from data.
+ */
+export declare class OINOHtmlTemplate {
+    private _tag;
+    private _tagCleanRegex;
+    private _variables;
+    /** HTML template string */
+    template: string;
+    /** Cache modified value for template */
+    modified: number;
+    /** Cache expiration value for template */
+    expires: number;
+    /**
+     * Creates HTML Response from a key-value-pair.
+     *
+     * @param template template string
+     * @param tag tag to identify variables in template
+     *
+     */
+    constructor(template: string, tag?: string);
+    /**
+     * @returns whether template is empty
+     */
+    isEmpty(): boolean;
+    protected _createHttpResult(html: string, removeUnusedTags: boolean): OINOHttpResult;
+    protected _renderHtml(): string;
+    /**
+     * Clear template variables.
+     *
+     */
+    clearVariables(): void;
+    /**
+     * Sets template variable from a key-value-pair.
+     *
+     * @param variable key
+     * @param value value
+     * @param escapeValue whether to escape value
+     *
+     */
+    setVariableFromValue(variable: string, value: string, escapeValue?: boolean): void;
+    /**
+     * Sets template variables from object properties.
+     *
+     * @param object any object
+     * @param escapeValue whether to escape value
+     *
+     */
+    setVariableFromProperties(object: any, escapeValue?: boolean): void;
+    /**
+     * Creates HTML Response from set variables.
+     *
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    render(removeUnusedTags?: boolean): OINOHttpResult;
+    /**
+     * Creates HTML Response from a key-value-pair.
+     *
+     * @param key key
+     * @param value value
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    renderFromKeyValue(key: string, value: string, removeUnusedTags?: boolean): OINOHttpResult;
+    /**
+     * Creates HTML Response from object properties.
+     *
+     * @param object object
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    renderFromObject(object: any, removeUnusedTags?: boolean): OINOHttpResult;
+    /**
+     * Creates HTML Response from API result.
+     *
+     * @param result OINOResult-object
+     * @param removeUnusedTags whether to remove unused tags
+     * @param messageSeparator HTML separator for messages
+     * @param includeErrorMessages include debug messages in result
+     * @param includeWarningMessages include debug messages in result
+     * @param includeInfoMessages include debug messages in result
+     * @param includeDebugMessages include debug messages in result
+     *
+     */
+    renderFromResult(result: OINOResult, removeUnusedTags: boolean | undefined, messageSeparator: string, includeErrorMessages?: boolean, includeWarningMessages?: boolean, includeInfoMessages?: boolean, includeDebugMessages?: boolean): OINOHttpResult;
+}