@oino-ts/common 0.1.0

package/dist/cjs/OINOStr.js

@@ -0,0 +1,265 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINOStr = void 0;
+const _1 = require(".");
+/**
+ * Static class string utilities.
+ *
+ */
+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 == _1.OINOContentType.csv) {
+            return this.decodeCSV(str);
+        }
+        else if (contentType == _1.OINOContentType.json) {
+            return this.decodeJSON(str);
+        }
+        else if (contentType == _1.OINOContentType.formdata) {
+            return this.decodeFormdata(str);
+        }
+        else if (contentType == _1.OINOContentType.urlencode) {
+            return this.decodeUrlencode(str);
+        }
+        else if (contentType == _1.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 == _1.OINOContentType.csv) {
+            return this.encodeCSV(str);
+        }
+        else if (contentType == _1.OINOContentType.json) {
+            return this.encodeJSON(str);
+        }
+        else if (contentType == _1.OINOContentType.formdata) {
+            return this.encodeFormdata(str);
+        }
+        else if (contentType == _1.OINOContentType.urlencode) {
+            return this.encodeUrlencode(str);
+        }
+        else if (contentType == _1.OINOContentType.html) {
+            return this.encodeHtml(str);
+        }
+        else {
+            return str || "";
+        }
+    }
+}
+exports.OINOStr = OINOStr;

package/dist/cjs/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OINOContentType = exports.OINO_DEBUG_PREFIX = exports.OINO_INFO_PREFIX = exports.OINO_WARNING_PREFIX = exports.OINO_ERROR_PREFIX = exports.OINOHtmlTemplate = exports.OINOStr = exports.OINOHttpResult = exports.OINOResult = exports.OINOConsoleLog = exports.OINOLogLevel = exports.OINOLog = exports.OINOBenchmark = void 0;
+var OINOBenchmark_js_1 = require("./OINOBenchmark.js");
+Object.defineProperty(exports, "OINOBenchmark", { enumerable: true, get: function () { return OINOBenchmark_js_1.OINOBenchmark; } });
+var OINOLog_js_1 = require("./OINOLog.js");
+Object.defineProperty(exports, "OINOLog", { enumerable: true, get: function () { return OINOLog_js_1.OINOLog; } });
+Object.defineProperty(exports, "OINOLogLevel", { enumerable: true, get: function () { return OINOLog_js_1.OINOLogLevel; } });
+Object.defineProperty(exports, "OINOConsoleLog", { enumerable: true, get: function () { return OINOLog_js_1.OINOConsoleLog; } });
+var OINOResult_js_1 = require("./OINOResult.js");
+Object.defineProperty(exports, "OINOResult", { enumerable: true, get: function () { return OINOResult_js_1.OINOResult; } });
+Object.defineProperty(exports, "OINOHttpResult", { enumerable: true, get: function () { return OINOResult_js_1.OINOHttpResult; } });
+var OINOStr_js_1 = require("./OINOStr.js");
+Object.defineProperty(exports, "OINOStr", { enumerable: true, get: function () { return OINOStr_js_1.OINOStr; } });
+var OINOHtmlTemplate_js_1 = require("./OINOHtmlTemplate.js");
+Object.defineProperty(exports, "OINOHtmlTemplate", { enumerable: true, get: function () { return OINOHtmlTemplate_js_1.OINOHtmlTemplate; } });
+/** OINO error message prefix */
+exports.OINO_ERROR_PREFIX = "OINO ERROR";
+/** OINO warning message prefix */
+exports.OINO_WARNING_PREFIX = "OINO WARNING";
+/** OINO info message prefix */
+exports.OINO_INFO_PREFIX = "OINO INFO";
+/** OINO debug message prefix */
+exports.OINO_DEBUG_PREFIX = "OINO DEBUG";
+/**
+ * Supported content format mime-types
+ */
+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 || (exports.OINOContentType = OINOContentType = {}));

package/dist/esm/OINOBenchmark.js

@@ -0,0 +1,104 @@
+/*
+ * 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/.
+ */
+/**
+ * Static class for benchmarking functions.
+ *
+ */
+export class OINOBenchmark {
+    static _benchmarkCount = {};
+    static _benchmarkData = {};
+    static _benchmarkEnabled = {};
+    static _benchmarkStart = {};
+    /**
+     * Reset benchmark data (but not what is enabled).
+     *
+     */
+    static reset() {
+        this._benchmarkData = {};
+        this._benchmarkCount = {};
+    }
+    /**
+     *  Set benchmark names that are enabled.
+     *
+     *  @param module array of those benchmarks that are enabled
+     */
+    static setEnabled(module) {
+        this._benchmarkEnabled = {};
+        module.forEach(module_name => {
+            this._benchmarkEnabled[module_name] = true;
+        });
+    }
+    /**
+     * Start benchmark timing.
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     */
+    static start(module, method) {
+        const name = module + "." + method;
+        if (this._benchmarkEnabled[module]) {
+            if (this._benchmarkCount[name] == undefined) {
+                this._benchmarkCount[name] = 0;
+                this._benchmarkData[name] = 0;
+            }
+            this._benchmarkStart[name] = performance.now();
+        }
+    }
+    /**
+     * Complete benchmark timing
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     * @param category optional subcategory of the benchmark
+     */
+    static end(module, method, category) {
+        const name = module + "." + method;
+        let result = 0;
+        if (this._benchmarkEnabled[module]) {
+            const duration = performance.now() - this._benchmarkStart[name];
+            this._benchmarkCount[name] += 1;
+            this._benchmarkData[name] += duration;
+            if (category) {
+                const category_name = name + "." + category;
+                if (this._benchmarkCount[category_name] == undefined) {
+                    this._benchmarkCount[category_name] = 0;
+                    this._benchmarkData[category_name] = 0;
+                }
+                this._benchmarkCount[category_name] += 1;
+                this._benchmarkData[category_name] += duration;
+            }
+            result = this._benchmarkData[name] / this._benchmarkCount[name];
+        }
+        return result;
+    }
+    /**
+     * Get given benchmark data.
+     *
+     * @param module of the benchmark
+     * @param method of the benchmark
+     *
+     */
+    static get(module, method) {
+        const name = module + "." + method;
+        if (this._benchmarkEnabled[module]) {
+            return this._benchmarkData[module] / this._benchmarkCount[module];
+        }
+        return -1;
+    }
+    /**
+     * Get all benchmark data.
+     *
+     */
+    static getAll() {
+        let result = {};
+        for (const name in this._benchmarkData) {
+            if (this._benchmarkCount[name] > 0) {
+                result[name] = this._benchmarkData[name] / this._benchmarkCount[name];
+            }
+        }
+        return result;
+    }
+}

package/dist/esm/OINOHtmlTemplate.js

@@ -0,0 +1,173 @@
+import { OINOStr, OINOContentType, OINOHttpResult, OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOBenchmark } from ".";
+/**
+ * Class for rendering HTML from data.
+ */
+export class OINOHtmlTemplate {
+    _tag;
+    _tagCleanRegex;
+    _variables = {};
+    /** HTML template string */
+    template;
+    /** Cache modified value for template */
+    modified;
+    /** Cache expiration value for template */
+    expires;
+    /**
+     * Creates HTML Response from a key-value-pair.
+     *
+     * @param template template string
+     * @param tag tag to identify variables in template
+     *
+     */
+    constructor(template, tag = "###") {
+        this.template = template;
+        this.modified = 0;
+        this.expires = 0;
+        this._tag = tag;
+        this._tagCleanRegex = new RegExp(tag + ".*" + tag, "g");
+    }
+    /**
+     * @returns whether template is empty
+     */
+    isEmpty() {
+        return this.template == "";
+    }
+    _createHttpResult(html, removeUnusedTags) {
+        if (removeUnusedTags) {
+            html = html.replace(this._tagCleanRegex, "");
+        }
+        const result = new OINOHttpResult(html);
+        if (this.expires >= 1) {
+            result.expires = Math.round(this.expires);
+        }
+        if (this.modified >= 1) {
+            result.lastModified = this.modified;
+        }
+        return result;
+    }
+    _renderHtml() {
+        let html = this.template;
+        for (let key in this._variables) {
+            const value = this._variables[key];
+            html = html.replaceAll(this._tag + key + this._tag, value);
+        }
+        return html;
+    }
+    /**
+     * Clear template variables.
+     *
+     */
+    clearVariables() {
+        this._variables = {};
+    }
+    /**
+     * Sets template variable from a key-value-pair.
+     *
+     * @param variable key
+     * @param value value
+     * @param escapeValue whether to escape value
+     *
+     */
+    setVariableFromValue(variable, value, escapeValue = true) {
+        if (escapeValue) {
+            value = OINOStr.encode(value, OINOContentType.html);
+        }
+        this._variables[variable] = value;
+    }
+    /**
+     * Sets template variables from object properties.
+     *
+     * @param object any object
+     * @param escapeValue whether to escape value
+     *
+     */
+    setVariableFromProperties(object, escapeValue = true) {
+        if (object) {
+            for (let key in object) {
+                if (escapeValue) {
+                    this._variables[key] = OINOStr.encode(object[key], OINOContentType.html);
+                }
+                else {
+                    this._variables[key] = object[key];
+                }
+            }
+        }
+    }
+    /**
+     * Creates HTML Response from set variables.
+     *
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    render(removeUnusedTags = true) {
+        return this._createHttpResult(this._renderHtml(), removeUnusedTags);
+    }
+    /**
+     * Creates HTML Response from a key-value-pair.
+     *
+     * @param key key
+     * @param value value
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    renderFromKeyValue(key, value, removeUnusedTags = true) {
+        OINOBenchmark.start("OINOHtmlTemplate", "renderFromKeyValue");
+        this.setVariableFromValue(key, value);
+        const result = this.render(removeUnusedTags);
+        OINOBenchmark.end("OINOHtmlTemplate", "renderFromKeyValue");
+        return result;
+    }
+    /**
+     * Creates HTML Response from object properties.
+     *
+     * @param object object
+     * @param removeUnusedTags whether to remove unused tags
+     *
+     */
+    renderFromObject(object, removeUnusedTags = true) {
+        OINOBenchmark.start("OINOHtmlTemplate", "renderFromObject");
+        this.setVariableFromProperties(object);
+        const result = this.render(removeUnusedTags);
+        OINOBenchmark.end("OINOHtmlTemplate", "renderFromObject");
+        return result;
+    }
+    /**
+     * 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, removeUnusedTags = true, messageSeparator, includeErrorMessages = false, includeWarningMessages = false, includeInfoMessages = false, includeDebugMessages = false) {
+        OINOBenchmark.start("OINOHtmlTemplate", "renderFromResult");
+        this.setVariableFromValue("statusCode", result.statusCode.toString());
+        this.setVariableFromValue("statusMessage", result.statusMessage.toString());
+        let messages = [];
+        for (let i = 0; i < result.messages.length; i++) {
+            if (includeErrorMessages && result.messages[i].startsWith(OINO_ERROR_PREFIX)) {
+                messages.push(OINOStr.encode(result.messages[i], OINOContentType.html));
+            }
+            if (includeWarningMessages && result.messages[i].startsWith(OINO_WARNING_PREFIX)) {
+                messages.push(OINOStr.encode(result.messages[i], OINOContentType.html));
+            }
+            if (includeInfoMessages && result.messages[i].startsWith(OINO_INFO_PREFIX)) {
+                messages.push(OINOStr.encode(result.messages[i], OINOContentType.html));
+            }
+            if (includeDebugMessages && result.messages[i].startsWith(OINO_DEBUG_PREFIX)) {
+                messages.push(OINOStr.encode(result.messages[i], OINOContentType.html));
+            }
+        }
+        if (messages.length > 0) {
+            this.setVariableFromValue("messages", messages.join(messageSeparator), false); // messages have been escaped already
+        }
+        const http_result = this.render(removeUnusedTags);
+        OINOBenchmark.end("OINOHtmlTemplate", "renderFromResult");
+        return http_result;
+    }
+}
+;