@oino-ts/common 0.10.4 → 0.12.0

package/dist/esm/OINOHtmlTemplate.js

@@ -1,11 +1,17 @@
 import { OINOStr, OINOContentType, OINOHttpResult, OINO_ERROR_PREFIX, OINO_WARNING_PREFIX, OINO_INFO_PREFIX, OINO_DEBUG_PREFIX, OINOBenchmark } from ".";
+import { OINO_EMPTY_FORMATTER, OINOFormatter } from "./OINOFormatter";
 /**
  * Class for rendering HTML from data.
  */
 export class OINOHtmlTemplate {
-    _tag;
-    _tagCleanRegex;
+    _tagOpen;
+    _tagClose;
     _variables = {};
+    _tagStart = [];
+    _tagEnd = [];
+    _tagVariable = [];
+    _tagFormatters = [];
+    _tagCount = 0;
     /** HTML template string */
     template;
     /** Cache modified value for template */
@@ -19,12 +25,13 @@ export class OINOHtmlTemplate {
      * @param tag tag to identify variables in template
      *
      */
-    constructor(template, tag = "###") {
+    constructor(template, tagOpen = "{{{", tagClose = "}}}") {
         this.template = template;
         this.modified = 0;
         this.expires = 0;
-        this._tag = tag;
-        this._tagCleanRegex = new RegExp(tag + ".*" + tag, "g");
+        this._tagOpen = tagOpen;
+        this._tagClose = tagClose;
+        this._parseTemplate();
     }
     /**
      * @returns whether template is empty
@@ -32,10 +39,30 @@ export class OINOHtmlTemplate {
     isEmpty() {
         return this.template == "";
     }
-    _createHttpResult(html, removeUnusedTags) {
-        if (removeUnusedTags) {
-            html = html.replace(this._tagCleanRegex, "");
+    _parseTemplate() {
+        const tag_open_length = this._tagOpen.length;
+        const tag_close_length = this._tagClose.length;
+        let tag_start_pos = this.template.indexOf(this._tagOpen, 0);
+        let tag_end_pos = this.template.indexOf(this._tagClose, tag_start_pos + tag_open_length) + tag_close_length;
+        while ((tag_start_pos >= 0) && (tag_end_pos > tag_start_pos)) {
+            this._tagStart.push(tag_start_pos);
+            this._tagEnd.push(tag_end_pos);
+            let variable = this.template.slice(tag_start_pos + tag_open_length, tag_end_pos - tag_close_length);
+            const variable_parts = variable.split("|");
+            if (variable_parts.length > 1) {
+                const formatter = OINOFormatter.parse(variable_parts.slice(1));
+                this._tagFormatters.push(formatter);
+            }
+            else {
+                this._tagFormatters.push(OINO_EMPTY_FORMATTER);
+            }
+            this._tagVariable.push(variable_parts[0]);
+            this._tagCount = this._tagCount + 1;
+            tag_start_pos = this.template.indexOf(this._tagOpen, tag_end_pos);
+            tag_end_pos = this.template.indexOf(this._tagClose, tag_start_pos + tag_open_length) + tag_close_length;
         }
+    }
+    _createHttpResult(html) {
         const result = new OINOHttpResult(html);
         if (this.expires >= 1) {
             result.expires = Math.round(this.expires);
@@ -46,11 +73,22 @@ export class OINOHtmlTemplate {
         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);
+        let html = "";
+        let start_pos = 0;
+        let end_pos = 0;
+        for (let i = 0; i < this._tagCount; i++) {
+            end_pos = this._tagStart[i];
+            const key = this._tagVariable[i];
+            const value = this._tagFormatters[i].format(this._variables[key] || "");
+            html += this.template.slice(start_pos, end_pos) + value;
+            start_pos = this._tagEnd[i];
         }
+        html += this.template.slice(start_pos);
+        // let html:string = this.template
+        // for (let key in this._variables) {
+        //     const value = this._variables[key]
+        //     html = html.replaceAll(this._tag + key + this._tag, value)
+        // }
         return html;
     }
     /**
@@ -96,26 +134,23 @@ export class OINOHtmlTemplate {
     /**
      * Creates HTML Response from set variables.
      *
-     * @param removeUnusedTags whether to remove unused tags
-     *
      */
-    render(removeUnusedTags = true) {
+    render() {
         const html = this._renderHtml();
         this.clearVariables(); // clear variables after rendering
-        return this._createHttpResult(html, removeUnusedTags);
+        return this._createHttpResult(html);
     }
     /**
      * 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) {
+    renderFromKeyValue(key, value) {
         OINOBenchmark.startMetric("OINOHtmlTemplate", "renderFromKeyValue");
         this.setVariableFromValue(key, value);
-        const result = this.render(removeUnusedTags);
+        const result = this.render();
         OINOBenchmark.endMetric("OINOHtmlTemplate", "renderFromKeyValue");
         return result;
     }
@@ -123,13 +158,12 @@ export class OINOHtmlTemplate {
      * Creates HTML Response from object properties.
      *
      * @param object object
-     * @param removeUnusedTags whether to remove unused tags
      *
      */
-    renderFromObject(object, removeUnusedTags = true) {
+    renderFromObject(object = true) {
         OINOBenchmark.startMetric("OINOHtmlTemplate", "renderFromObject");
         this.setVariableFromProperties(object);
-        const result = this.render(removeUnusedTags);
+        const result = this.render();
         OINOBenchmark.endMetric("OINOHtmlTemplate", "renderFromObject");
         return result;
     }
@@ -137,7 +171,6 @@ export class OINOHtmlTemplate {
      * 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
@@ -145,7 +178,7 @@ export class OINOHtmlTemplate {
      * @param includeDebugMessages include debug messages in result
      *
      */
-    renderFromResult(result, removeUnusedTags = true, messageSeparator = "", includeErrorMessages = false, includeWarningMessages = false, includeInfoMessages = false, includeDebugMessages = false) {
+    renderFromResult(result, messageSeparator = "", includeErrorMessages = false, includeWarningMessages = false, includeInfoMessages = false, includeDebugMessages = false) {
         OINOBenchmark.startMetric("OINOHtmlTemplate", "renderFromResult");
         this.setVariableFromValue("statusCode", result.statusCode.toString());
         this.setVariableFromValue("statusMessage", result.statusMessage.toString());
@@ -167,7 +200,7 @@ export class OINOHtmlTemplate {
         if (messageSeparator && (messages.length > 0)) {
             this.setVariableFromValue("messages", messages.join(messageSeparator), false); // messages have been escaped already
         }
-        const http_result = this.render(removeUnusedTags);
+        const http_result = this.render();
         OINOBenchmark.endMetric("OINOHtmlTemplate", "renderFromResult");
         return http_result;
     }

package/dist/esm/OINOLog.js

@@ -183,14 +183,13 @@ export class OINOLog {
         return result;
     }
     /**
-     * Import log levels from an array of objects with domain, channel, method and level.
+     * Set log levels from an array of objects with domain, channel, method and level overwriting existing values (i.e. non-existing values are not affected).
      *
      * @param logLevels array of log level objects
      *
      */
-    static importLogLevels(logLevels) {
+    static setLogLevels(logLevels) {
         if (OINOLog._instance) {
-            OINOLog._instance._logLevels = { "||": OINOLog._instance._defaultLogLevel }; // reset to default log level
             for (const logLevel of logLevels) {
                 const domain = logLevel.domain || "";
                 const channel = logLevel.channel || "";
@@ -202,6 +201,18 @@ export class OINOLog {
             }
         }
     }
+    /**
+     * Import log levels from an array of objects with domain, channel, method and level resetting existing values (i.e. non-existing values get removed).
+     *
+     * @param logLevels array of log level objects
+     *
+     */
+    static importLogLevels(logLevels) {
+        if (OINOLog._instance) {
+            OINOLog._instance._logLevels = { "||": OINOLog._instance._defaultLogLevel }; // reset to default log level
+            this.setLogLevels(logLevels);
+        }
+    }
 }
 /**
  * Logging implementation based on console.log.

package/dist/esm/index.js

@@ -3,6 +3,7 @@ export { OINOLog, OINOLogLevel, OINOConsoleLog } from "./OINOLog.js";
 export { OINOResult, OINOHttpResult } from "./OINOResult.js";
 export { OINOStr } from "./OINOStr.js";
 export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
+export { OINOFormatter, OINO_EMPTY_FORMATTER } from "./OINOFormatter.js";
 /** OINO error message prefix */
 export const OINO_ERROR_PREFIX = "OINO ERROR";
 /** OINO warning message prefix */

package/dist/types/OINOFormatter.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Class for formatting strings and values.
+ *
+ */
+export declare class OINOFormatter {
+    static OINO_FORMATTER_REGEXP: RegExp;
+    _types: string[];
+    _params: any[][];
+    /**
+     * Constructor of `OINOFormatter`
+     * @param types array of formatter types
+     * @param params array of formatter parameters according to type
+     */
+    constructor(types: string[], params: any[][]);
+    /**
+     * Constructor for `OINOFormatter` as parser of http parameter.
+     *
+     * @param formatters string or array of strings of serialized representation of formatters with following functions
+     * - trim()
+     * - trimLeft()
+     * - trimRight()
+     * - toUpper()
+     * - toLower()
+     * - cropLeft(charsToCrop)
+     * - cropRight(charsToCrop)
+     * - cropToDelimiter(delimiter,offsetChars)
+     * - cropFromDelimiter(delimiter,offsetChars)
+     * - substring(start,end)
+     * - replace(search,replace)
+     */
+    static parse(formatters: string | string[]): OINOFormatter;
+    /**
+     * Does formatter include any operations.
+     * @return true if formatter is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Applies all formatters in order to given value.
+     *
+     * @param value string value to be formatted
+     * @returns formatted string value
+     */
+    format(value: string): string;
+}
+export declare const OINO_EMPTY_FORMATTER: OINOFormatter;

package/dist/types/OINOHtmlTemplate.d.ts

@@ -3,9 +3,14 @@ import { OINOResult, OINOHttpResult } from ".";
  * Class for rendering HTML from data.
  */
 export declare class OINOHtmlTemplate {
-    private _tag;
-    private _tagCleanRegex;
+    private _tagOpen;
+    private _tagClose;
     private _variables;
+    private _tagStart;
+    private _tagEnd;
+    private _tagVariable;
+    private _tagFormatters;
+    private _tagCount;
     /** HTML template string */
     template: string;
     /** Cache modified value for template */
@@ -19,12 +24,13 @@ export declare class OINOHtmlTemplate {
      * @param tag tag to identify variables in template
      *
      */
-    constructor(template: string, tag?: string);
+    constructor(template: string, tagOpen?: string, tagClose?: string);
     /**
      * @returns whether template is empty
      */
     isEmpty(): boolean;
-    protected _createHttpResult(html: string, removeUnusedTags: boolean): OINOHttpResult;
+    protected _parseTemplate(): void;
+    protected _createHttpResult(html: string): OINOHttpResult;
     protected _renderHtml(): string;
     /**
      * Clear template variables.
@@ -51,32 +57,27 @@ export declare class OINOHtmlTemplate {
     /**
      * Creates HTML Response from set variables.
      *
-     * @param removeUnusedTags whether to remove unused tags
-     *
      */
-    render(removeUnusedTags?: boolean): OINOHttpResult;
+    render(): 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;
+    renderFromKeyValue(key: string, value: string): OINOHttpResult;
     /**
      * Creates HTML Response from object properties.
      *
      * @param object object
-     * @param removeUnusedTags whether to remove unused tags
      *
      */
-    renderFromObject(object: any, removeUnusedTags?: boolean): OINOHttpResult;
+    renderFromObject(object?: any): 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
@@ -84,5 +85,5 @@ export declare class OINOHtmlTemplate {
      * @param includeDebugMessages include debug messages in result
      *
      */
-    renderFromResult(result: OINOResult, removeUnusedTags?: boolean, messageSeparator?: string, includeErrorMessages?: boolean, includeWarningMessages?: boolean, includeInfoMessages?: boolean, includeDebugMessages?: boolean): OINOHttpResult;
+    renderFromResult(result: OINOResult, messageSeparator?: string, includeErrorMessages?: boolean, includeWarningMessages?: boolean, includeInfoMessages?: boolean, includeDebugMessages?: boolean): OINOHttpResult;
 }

package/dist/types/OINOLog.d.ts

@@ -134,7 +134,14 @@ export declare abstract class OINOLog {
      */
     static exportLogLevels(): any[];
     /**
-     * Import log levels from an array of objects with domain, channel, method and level.
+     * Set log levels from an array of objects with domain, channel, method and level overwriting existing values (i.e. non-existing values are not affected).
+     *
+     * @param logLevels array of log level objects
+     *
+     */
+    static setLogLevels(logLevels: any[]): void;
+    /**
+     * Import log levels from an array of objects with domain, channel, method and level resetting existing values (i.e. non-existing values get removed).
      *
      * @param logLevels array of log level objects
      *

package/dist/types/index.d.ts

@@ -3,6 +3,7 @@ export { OINOLog, OINOLogLevel, OINOConsoleLog } from "./OINOLog.js";
 export { OINOResult, OINOHttpResult } from "./OINOResult.js";
 export { OINOStr } from "./OINOStr.js";
 export { OINOHtmlTemplate } from "./OINOHtmlTemplate.js";
+export { OINOFormatter, OINO_EMPTY_FORMATTER } from "./OINOFormatter.js";
 /** OINO error message prefix */
 export declare const OINO_ERROR_PREFIX = "OINO ERROR";
 /** OINO warning message prefix */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oino-ts/common",
-  "version": "0.10.4",
+  "version": "0.12.0",
   "description": "OINO TS package for common classes.",
   "author": "Matias Kiviniemi (pragmatta)",
   "license": "MPL-2.0",
@@ -19,7 +19,9 @@
   "dependencies": {
   },
   "devDependencies": {
-    "@oino-ts/types": "0.10.4"
+    "@oino-ts/types": "0.12.0",
+    "@types/node": "^22.0.0",
+    "typescript": "~5.9.0"
   },
   "files": [
     "src/*.ts",

package/src/OINOFormatter.ts

@@ -0,0 +1,165 @@
+/*
+ * 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 { OINO_ERROR_PREFIX, OINOLog } from "./index.js"
+
+
+
+/**
+ * Class for formatting strings and values.
+ *
+ */
+export class OINOFormatter {
+    static OINO_FORMATTER_REGEXP = /\s?(trim(\(\))?|trimLeft(\(\))?|trimRight(\(\))?|toUpper(\(\))?|toLower(\(\))?|cropLeft\((\d+)\)|cropRight\((\d+)\)|cropToDelimiter\(([^\(\),]+),(\d+)\)|cropFromDelimiter\(([^\(\),]+),(\d+)\)|substring\((\d+),(\d+)\)|replace\(([^\(\),]+),([^\(\),]+)\))\s?$/i
+    _types: string[]
+    _params: any[][]
+
+    /**
+     * Constructor of `OINOFormatter`
+     * @param types array of formatter types
+     * @param params array of formatter parameters according to type
+     */
+    constructor(types: string[], params: any[][]) {
+        this._types = types
+        this._params = params
+    }
+
+    /**
+     * Constructor for `OINOFormatter` as parser of http parameter.
+     *
+     * @param formatters string or array of strings of serialized representation of formatters with following functions
+     * - trim()
+     * - trimLeft()
+     * - trimRight()
+     * - toUpper()
+     * - toLower()
+     * - cropLeft(charsToCrop)
+     * - cropRight(charsToCrop)
+     * - cropToDelimiter(delimiter,offsetChars)
+     * - cropFromDelimiter(delimiter,offsetChars)
+     * - substring(start,end)
+     * - replace(search,replace)
+     */
+    static parse(formatters: string|string[]): OINOFormatter {
+        if (typeof formatters === "string") {
+            formatters = [formatters]
+        }
+        if (!formatters || formatters.length === 0) {
+            return OINO_EMPTY_FORMATTER
+
+        } else {
+            const types:string[] = []
+            const params:any[][] = []
+            for (let i=0; i<formatters.length; i++) {
+                let match = formatters[i]?.match(this.OINO_FORMATTER_REGEXP)
+                if (!match) {
+                    OINOLog.error("@oino-ts/common", "OINOFormatter", "parse", "Invalid formatter string", {formatter:formatters[i]})
+                    throw new Error(OINO_ERROR_PREFIX + "Invalid formatter: " + formatters[i])
+                } else {
+                    const formatter_type = match[1].toLowerCase().substring(0, match[1].indexOf('('))
+                    const formatter_params: any[] = []
+                    if ((formatter_type === "trim") || (formatter_type === "trimleft") || (formatter_type === "trimright") || (formatter_type === "toupper") || (formatter_type === "tolower")) {
+                        // no parameters
+
+                    } else if (formatter_type=== "cropleft") {
+                        formatter_params.push(parseInt(match[7]))
+
+                    } else if (formatter_type === "cropright") {
+                        formatter_params.push(parseInt(match[8]))
+
+                    } else if (formatter_type === "croptodelimiter") {
+                        formatter_params.push(decodeURIComponent(match[9]), parseInt(match[10]))
+
+                    } else if (formatter_type === "cropfromdelimiter") {
+                        formatter_params.push(decodeURIComponent(match[11]), parseInt(match[12]))
+
+                    } else if (formatter_type === "substring") {
+                        formatter_params.push(parseInt(match[13]), parseInt(match[14]))
+
+                    } else if (formatter_type === "replace") {
+                        formatter_params.push(decodeURIComponent(match[15]), decodeURIComponent(match[16]))
+                    } else {
+                        OINOLog.error("@oino-ts/common", "OINOFormatter", "parse", "Unknown formatter type", {formatter:formatters[i]})
+                        throw new Error(OINO_ERROR_PREFIX + "Unsupported formatter: " + formatters[i])
+                    }
+                    types.push(formatter_type)
+                    params.push(formatter_params)
+                }
+            }
+            return new OINOFormatter(types, params)
+        }
+    }
+
+    /**
+     * Does formatter include any operations.
+     * @return true if formatter is empty
+     */
+    isEmpty():boolean {
+        return this._types.length === 0
+    }
+
+    /**
+     * Applies all formatters in order to given value.
+     *
+     * @param value string value to be formatted
+     * @returns formatted string value
+     */
+    format(value: string): string {
+        let formatted = value
+        for (let i = 0; i < this._types.length; i++) {
+            const formatter_type = this._types[i]
+            const formatter_params = this._params[i]
+            if (formatter_type === "trim") {
+                formatted = formatted.trim()
+
+            } else if (formatter_type === "trimleft") {
+                formatted = formatted.trimStart()
+
+            } else if (formatter_type === "trimright") {
+                formatted = formatted.trimEnd()
+
+            } else if (formatter_type === "toupper") {
+                formatted = formatted.toUpperCase()
+
+            } else if (formatter_type === "tolower") {
+                formatted = formatted.toLowerCase()
+
+            } else if (formatter_type === "cropleft") {
+                formatted = formatted.slice(formatter_params[0])
+
+            } else if (formatter_type === "cropright") {
+                formatted = formatted.slice(0, formatted.length-formatter_params[0])
+
+            } else if (formatter_type === "croptodelimiter") {
+                const to_demilimiter_idx = formatted.indexOf(formatter_params[0])
+                if (to_demilimiter_idx >= 0) {
+                    formatted = formatted.slice(Math.max(to_demilimiter_idx + formatter_params[0].length + formatter_params[1], 0))
+                }
+                
+            } else if (formatter_type === "cropfromdelimiter") {
+                const from_demilimiter_idx = formatted.indexOf(formatter_params[0])
+                if (from_demilimiter_idx >= 0) {
+                    formatted = formatted.slice(0, Math.max(from_demilimiter_idx + formatter_params[1], 0))
+                }
+
+            } else if (formatter_type === "substring") {
+                const start = formatter_params[0] ? parseInt(formatter_params[0]) : 0
+                const end = formatter_params[1] ? parseInt(formatter_params[1]) : formatted.length
+                formatted = formatted.substring(start, end)
+
+            } else if (formatter_type === "replace") {
+                const search = formatter_params[0]
+                const replacement = formatter_params[1]
+                formatted = formatted.replaceAll(search, replacement)
+            }
+            // console.log("formatter:", formatter_type, "params:", formatter_params, "formatted:", formatted)
+        }
+        return formatted
+    }
+
+}
+
+export const OINO_EMPTY_FORMATTER = new OINOFormatter([], [])

package/src/OINOHtmlTemplate.test.ts

@@ -0,0 +1,114 @@
+/*
+ * 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 { expect, test } from "bun:test";
+
+import { OINOHtmlTemplate } from "./OINOHtmlTemplate"
+import { OINOFormatter } from "./OINOFormatter";
+import { OINOLog, OINOConsoleLog, OINOLogLevel } from "./OINOLog"
+
+Math.random()
+
+OINOLog.setInstance(new OINOConsoleLog(OINOLogLevel.error))
+
+const VARIABLE_OPTIONS = [
+    "{{{var{i}}}}", // 0 nothing
+    "{{{var{i}|trim()}}}", // 1 trim
+    "{{{var{i}|trimLeft()}}}", // 2 trimLeft
+    "{{{var{i}|trimRight()}}}", // 3 trimRight
+    "{{{var{i}|toLower()}}}", // 4 toLower
+    "{{{var{i}|cropLeft(1)}}}", // 5 cropLeft
+    "{{{var{i}|cropRight(1)}}}", // 6 cropRight
+    "{{{var{i}|cropToDelimiter(¤,1)}}}", // 7 cropToDelimiter
+    "{{{var{i}|cropFromDelimiter(¤,0)}}}", // 8 cropFromDelimiter
+    "{{{var{i}|substring(2,10)}}}", // 9 substring
+    "{{{var{i}|replace(¤,a)}}}" // 10 replace
+]
+const VARIABLE_VALUES = [
+    "value{i}",   // 0 nothing
+    "  value{i}  ", // 1 trim
+    "  value{i}", // 2 trimLeft
+    "value{i}  ", // 3 trimRight
+    "VALUE{i}", // 4 toLower
+    "¤value{i}", // 5 cropLeft
+    "value{i}¤", // 6 cropRight
+    "¤¤value{i}", // 7 cropToDelimiter
+    "value{i}¤!", // 8 cropFromDelimiter
+    "!¤value{i}",   // 9 substring
+    "v¤lue{i}"    // 10 replace
+]
+
+
+function _generateTemplateVariable(i:number): string {
+    return VARIABLE_OPTIONS[i % VARIABLE_OPTIONS.length].replace(/\{i\}/g, i.toString())
+}
+
+function _generateTemplateHtml(variableCount: number): string {
+    let template = "{{{header}}}\n<div>\n" // edge case: tag at the start of the template
+    for (let i = 1; i <= variableCount; i++) {
+        template += `<p>${_generateTemplateVariable(i)}</p>\n`
+    }
+    template += "</div>\n{{{footer}}}" // edge case: tag at the end of the template
+    return template
+}
+
+function _generateResultHtml(variableCount: number): string {
+    let template = "header\n<div>\n"
+    for (let i = 1; i <= variableCount; i++) {
+        template += `<p>value${i}</p>\n`
+    }
+    template += "</div>\nfooter"
+    return template
+}
+
+
+function _generateValue(i: number): string {
+    return VARIABLE_VALUES[i % VARIABLE_VALUES.length].replace(/\{i\}/g, i.toString())
+}
+
+function _generateValues(variableCount: number): any {
+    const values: any = { header: "header", footer: "footer" }
+    for (let i = 1; i <= variableCount; i++) {
+        values[`var${i}`] = _generateValue(i)
+    }
+    return values
+}
+
+function benchmarkOINOHtmlTemplate(variables:number, replacements: number = 1000): number {
+    const template = new OINOHtmlTemplate(_generateTemplateHtml(variables))
+    const values = _generateValues(variables)
+    const result = _generateResultHtml(variables)
+
+    const start = performance.now();
+
+    for (let i = 0; i < replacements; i+=variables) {
+        template.setVariableFromProperties(values)
+        const res = template.render()
+        expect(res.body).toBe(result)
+    }
+
+    const end = performance.now()
+    const duration = end - start
+    return Math.round(replacements / duration)
+}   
+
+await test("OINOHtmlTemplate render and performance", async () => {
+
+    let hps_min = Number.MAX_VALUE
+    let hps_max = 0
+    
+    for (let j=10; j<=100; j+=10) {
+        const rps = benchmarkOINOHtmlTemplate(j, 100000)
+        // console.log(`Template variable renders per second with ${j} variables: ${rps}krps`)
+        hps_min = Math.min(rps, hps_min)
+        hps_max = Math.max(rps, hps_max)
+        expect(hps_min).toBeGreaterThanOrEqual(2500)
+        expect(hps_max).toBeLessThanOrEqual(5000)
+    }
+    console.log("OINOHtmlTemplate performance: " + hps_min + "k - " + hps_max + "k renders per second")
+})
+    
+