@schukai/monster 3.4.2 → 3.7.0

package/source/data/transformer.mjs

@@ -1,5 +1,3 @@
-
-
 /**
  * Copyright schukai GmbH and contributors 2022. All Rights Reserved.
  * Node module: @schukai/monster
@@ -7,22 +5,21 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-
-import {Base} from '../types/base.mjs';
-import {getGlobal, getGlobalObject} from "../types/global.mjs";
-import {ID} from '../types/id.mjs';
-import {isArray, isObject, isString} from '../types/is.mjs';
+import { Base } from "../types/base.mjs";
+import { getGlobal, getGlobalObject } from "../types/global.mjs";
+import { ID } from "../types/id.mjs";
+import { isArray, isObject, isString } from "../types/is.mjs";
 import {
     validateFunction,
     validateInteger,
     validateObject,
     validatePrimitive,
-    validateString
-} from '../types/validate.mjs';
-import {clone} from "../util/clone.mjs";
-import {Pathfinder} from "./pathfinder.mjs";
+    validateString,
+} from "../types/validate.mjs";
+import { clone } from "../util/clone.mjs";
+import { Pathfinder } from "./pathfinder.mjs";
 
-export {Transformer}
+export { Transformer };
 
 /**
  * The transformer class is a swiss army knife for manipulating values. especially in combination with the pipe, processing chains can be built up.
@@ -82,7 +79,7 @@ export {Transformer}
  *         url: 'http://example.com/',
  *         pretendToBeVisual: true
  *     });
- * 
+ *
  *     [
  *         'self',
  *         'document',
@@ -120,9 +117,8 @@ class Transformer extends Base {
     constructor(definition) {
         super();
         this.args = disassemble(definition);
-        this.command = this.args.shift()
+        this.command = this.args.shift();
         this.callbacks = new Map();
-
     }
 
     /**
@@ -135,8 +131,8 @@ class Transformer extends Base {
      * @throws {TypeError} value is not a function
      */
     setCallback(name, callback, context) {
-        validateString(name)
-        validateFunction(callback)
+        validateString(name);
+        validateFunction(callback);
 
         if (context !== undefined) {
             validateObject(context);
@@ -159,7 +155,7 @@ class Transformer extends Base {
      * @throws {Error} type not supported
      */
     run(value) {
-        return transform.apply(this, [value])
+        return transform.apply(this, [value]);
     }
 }
 
@@ -170,33 +166,31 @@ class Transformer extends Base {
  * @private
  */
 function disassemble(command) {
-
     validateString(command);
 
-    let placeholder = new Map;
-    const regex = /((?<pattern>\\(?<char>.)){1})/mig;
+    let placeholder = new Map();
+    const regex = /((?<pattern>\\(?<char>.)){1})/gim;
 
     // The separator for args must be escaped
     // undefined string which should not occur normally and is also not a regex
-    let result = command.matchAll(regex)
+    let result = command.matchAll(regex);
 
     for (let m of result) {
-        let g = m?.['groups'];
+        let g = m?.["groups"];
         if (!isObject(g)) {
             continue;
         }
 
-        let p = g?.['pattern'];
-        let c = g?.['char'];
+        let p = g?.["pattern"];
+        let c = g?.["char"];
 
         if (p && c) {
-            let r = '__' + new ID().toString() + '__';
+            let r = `__${new ID().toString()}__`;
             placeholder.set(r, c);
             command = command.replace(p, r);
         }
-
     }
-    let parts = command.split(':');
+    let parts = command.split(":");
 
     parts = parts.map(function (value) {
         let v = value.trim();
@@ -204,11 +198,9 @@ function disassemble(command) {
             v = v.replace(k[0], k[1]);
         }
         return v;
-
-
     });
 
-    return parts
+    return parts;
 }
 
 /**
@@ -219,12 +211,11 @@ function disassemble(command) {
  * @private
  */
 function convertToString(value) {
-
-    if (isObject(value) && value.hasOwnProperty('toString')) {
+    if (isObject(value) && value.hasOwnProperty("toString")) {
         value = value.toString();
     }
 
-    validateString(value)
+    validateString(value);
     return value;
 }
 
@@ -239,59 +230,56 @@ function convertToString(value) {
  * @throws {Error} missing key parameter
  */
 function transform(value) {
-
-    const console = getGlobalObject('console');
+    const console = getGlobalObject("console");
 
     let args = clone(this.args);
-    let key, defaultValue;
+    let key;
+    let defaultValue;
 
     switch (this.command) {
+        case "static":
+            return this.args.join(":");
 
-        case 'static':
-            return this.args.join(':');
-
-        case 'tolower':
-        case 'strtolower':
-        case 'tolowercase':
-            validateString(value)
+        case "tolower":
+        case "strtolower":
+        case "tolowercase":
+            validateString(value);
             return value.toLowerCase();
 
-        case 'toupper':
-        case 'strtoupper':
-        case 'touppercase':
-            validateString(value)
+        case "toupper":
+        case "strtoupper":
+        case "touppercase":
+            validateString(value);
             return value.toUpperCase();
 
-        case 'tostring':
-            return "" + value;
+        case "tostring":
+            return `${value}`;
 
-        case 'tointeger':
+        case "tointeger":
             let n = parseInt(value);
             validateInteger(n);
-            return n
+            return n;
 
-        case 'tojson':
+        case "tojson":
             return JSON.stringify(value);
 
-        case 'fromjson':
+        case "fromjson":
             return JSON.parse(value);
 
-        case 'trim':
-            validateString(value)
+        case "trim":
+            validateString(value);
             return value.trim();
 
-        case 'rawurlencode':
-            validateString(value)
+        case "rawurlencode":
+            validateString(value);
             return encodeURIComponent(value)
-                .replace(/!/g, '%21')
-                .replace(/'/g, '%27')
-                .replace(/\(/g, '%28')
-                .replace(/\)/g, '%29')
-                .replace(/\*/g, '%2A');
-
-
-        case  'call':
+                .replace(/!/g, "%21")
+                .replace(/'/g, "%27")
+                .replace(/\(/g, "%28")
+                .replace(/\)/g, "%29")
+                .replace(/\*/g, "%2A");
 
+        case "call":
             /**
              * callback-definition
              * function callback(value, ...args) {
@@ -307,9 +295,9 @@ function transform(value) {
                 callback = value[callbackName];
             } else if (this.callbacks.has(callbackName)) {
                 let s = this.callbacks.get(callbackName);
-                callback = s?.['callback'];
-                context = s?.['context'];
-            } else if (typeof window === 'object' && window.hasOwnProperty(callbackName)) {
+                callback = s?.["callback"];
+                context = s?.["context"];
+            } else if (typeof window === "object" && window.hasOwnProperty(callbackName)) {
                 callback = window[callbackName];
             }
             validateFunction(callback);
@@ -317,119 +305,117 @@ function transform(value) {
             args.unshift(value);
             return callback.call(context, ...args);
 
-        case  'plain':
-        case  'plaintext':
+        case "plain":
+        case "plaintext":
             validateString(value);
-            let doc = new DOMParser().parseFromString(value, 'text/html');
+            let doc = new DOMParser().parseFromString(value, "text/html");
             return doc.body.textContent || "";
 
-        case  'if':
-        case  '?':
-
+        case "if":
+        case "?":
             validatePrimitive(value);
 
-            let trueStatement = (args.shift() || undefined);
-            let falseStatement = (args.shift() || undefined);
+            let trueStatement = args.shift() || undefined;
+            let falseStatement = args.shift() || undefined;
 
-            if (trueStatement === 'value') {
+            if (trueStatement === "value") {
                 trueStatement = value;
             }
-            if (trueStatement === '\\value') {
-                trueStatement = 'value';
+            if (trueStatement === "\\value") {
+                trueStatement = "value";
             }
-            if (falseStatement === 'value') {
+            if (falseStatement === "value") {
                 falseStatement = value;
             }
-            if (falseStatement === '\\value') {
-                falseStatement = 'value';
+            if (falseStatement === "\\value") {
+                falseStatement = "value";
             }
 
-            let condition = ((value !== undefined && value !== '' && value !== 'off' && value !== 'false' && value !== false) || value === 'on' || value === 'true' || value === true);
+            let condition =
+                (value !== undefined && value !== "" && value !== "off" && value !== "false" && value !== false) ||
+                value === "on" ||
+                value === "true" ||
+                value === true;
             return condition ? trueStatement : falseStatement;
 
-
-        case 'ucfirst':
+        case "ucfirst":
             validateString(value);
 
             let firstchar = value.charAt(0).toUpperCase();
             return firstchar + value.substr(1);
-        case 'ucwords':
+        case "ucwords":
             validateString(value);
 
             return value.replace(/^([a-z\u00E0-\u00FC])|\s+([a-z\u00E0-\u00FC])/g, function (v) {
                 return v.toUpperCase();
             });
 
-        case  'count':
-        case  'length':
-
-            if ((isString(value) || isObject(value) || isArray(value)) && value.hasOwnProperty('length')) {
+        case "count":
+        case "length":
+            if ((isString(value) || isObject(value) || isArray(value)) && value.hasOwnProperty("length")) {
                 return value.length;
             }
 
-            throw new TypeError("unsupported type " + typeof value);
+            throw new TypeError(`unsupported type ${typeof value}`);
 
-        case 'to-base64':
-        case 'btoa':
-        case 'base64':
+        case "to-base64":
+        case "btoa":
+        case "base64":
             return btoa(convertToString(value));
 
-        case 'atob':
-        case 'from-base64':
+        case "atob":
+        case "from-base64":
             return atob(convertToString(value));
 
-        case 'empty':
-            return '';
+        case "empty":
+            return "";
 
-        case 'undefined':
+        case "undefined":
             return undefined;
 
-        case 'debug':
-
+        case "debug":
             if (isObject(console)) {
                 console.log(value);
             }
 
             return value;
 
-        case 'prefix':
+        case "prefix":
             validateString(value);
             let prefix = args?.[0];
             return prefix + value;
 
-        case 'suffix':
+        case "suffix":
             validateString(value);
             let suffix = args?.[0];
             return value + suffix;
 
-        case 'uniqid':
-            return (new ID()).toString();
-
-        case 'first-key':
-        case 'last-key':
-        case 'nth-last-key':
-        case 'nth-key':
+        case "uniqid":
+            return new ID().toString();
 
+        case "first-key":
+        case "last-key":
+        case "nth-last-key":
+        case "nth-key":
             if (!isObject(value)) {
-                throw new Error("type not supported")
+                throw new Error("type not supported");
             }
 
-            const keys = Object.keys(value).sort()
+            const keys = Object.keys(value).sort();
 
-            if (this.command === 'first-key') {
+            if (this.command === "first-key") {
                 key = 0;
-            } else if (this.command === 'last-key') {
+            } else if (this.command === "last-key") {
                 key = keys.length - 1;
             } else {
-
                 key = validateInteger(parseInt(args.shift()));
 
-                if (this.command === 'nth-last-key') {
+                if (this.command === "nth-last-key") {
                     key = keys.length - key - 1;
                 }
             }
 
-            defaultValue = (args.shift() || '');
+            defaultValue = args.shift() || "";
 
             let useKey = keys?.[key];
 
@@ -439,18 +425,16 @@ function transform(value) {
 
             return defaultValue;
 
-
-        case 'key':
-        case 'property':
-        case 'index':
-
+        case "key":
+        case "property":
+        case "index":
             key = args.shift() || undefined;
 
             if (key === undefined) {
-                throw new Error("missing key parameter")
+                throw new Error("missing key parameter");
             }
 
-            defaultValue = (args.shift() || undefined);
+            defaultValue = args.shift() || undefined;
 
             if (value instanceof Map) {
                 if (!value.has(key)) {
@@ -460,7 +444,6 @@ function transform(value) {
             }
 
             if (isObject(value) || isArray(value)) {
-
                 if (value?.[key]) {
                     return value?.[key];
                 }
@@ -468,22 +451,20 @@ function transform(value) {
                 return defaultValue;
             }
 
-            throw new Error("type not supported")
-
-        case 'path-exists':
+            throw new Error("type not supported");
 
+        case "path-exists":
             key = args.shift();
             if (key === undefined) {
-                throw new Error("missing key parameter")
+                throw new Error("missing key parameter");
             }
 
             return new Pathfinder(value).exists(key);
 
-        case 'path':
-
+        case "path":
             key = args.shift();
             if (key === undefined) {
-                throw new Error("missing key parameter")
+                throw new Error("missing key parameter");
             }
 
             let pf = new Pathfinder(value);
@@ -494,9 +475,7 @@ function transform(value) {
 
             return pf.getVia(key);
 
-
-        case 'substring':
-
+        case "substring":
             validateString(value);
 
             let start = parseInt(args[0]) || 0;
@@ -504,11 +483,11 @@ function transform(value) {
 
             return value.substring(start, end);
 
-        case 'nop':
+        case "nop":
             return value;
 
-        case  '??':
-        case 'default':
+        case "??":
+        case "default":
             if (value !== undefined && value !== null) {
                 return value;
             }
@@ -516,34 +495,39 @@ function transform(value) {
             defaultValue = args.shift();
             let defaultType = args.shift();
             if (defaultType === undefined) {
-                defaultType = 'string';
+                defaultType = "string";
             }
 
             switch (defaultType) {
-                case 'int':
-                case 'integer':
+                case "int":
+                case "integer":
                     return parseInt(defaultValue);
-                case 'float':
+                case "float":
                     return parseFloat(defaultValue);
-                case 'undefined':
-                    return undefined
-                case 'bool':
-                case 'boolean':
-                    defaultValue = defaultValue.toLowerCase()
-                    return ((defaultValue !== 'undefined' && defaultValue !== '' && defaultValue !== 'off' && defaultValue !== 'false' && defaultValue !== 'false') || defaultValue === 'on' || defaultValue === 'true' || defaultValue === 'true');
-                case 'string':
-                    return "" + defaultValue;
+                case "undefined":
+                    return undefined;
+                case "bool":
+                case "boolean":
+                    defaultValue = defaultValue.toLowerCase();
+                    return (
+                        (defaultValue !== "undefined" &&
+                            defaultValue !== "" &&
+                            defaultValue !== "off" &&
+                            defaultValue !== "false" &&
+                            defaultValue !== "false") ||
+                        defaultValue === "on" ||
+                        defaultValue === "true" ||
+                        defaultValue === "true"
+                    );
+                case "string":
+                    return `${defaultValue}`;
                 case "object":
                     return JSON.parse(atob(defaultValue));
             }
 
-            throw new Error("type not supported")
-
+            throw new Error("type not supported");
 
         default:
-            throw new Error("unknown command " + this.command)
+            throw new Error(`unknown command ${this.command}`);
     }
-
-    return value;
 }
-

package/source/dom/assembler.mjs

@@ -5,12 +5,12 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-import {Base} from '../types/base.mjs';
-import {getGlobalFunction} from "../types/global.mjs";
-import {ProxyObserver} from "../types/proxyobserver.mjs";
-import {validateInstance, validateString} from "../types/validate.mjs";
+import { Base } from "../types/base.mjs";
+import { getGlobalFunction } from "../types/global.mjs";
+import { ProxyObserver } from "../types/proxyobserver.mjs";
+import { validateInstance, validateString } from "../types/validate.mjs";
 
-export {ATTRIBUTEPREFIX,Assembler}
+export { ATTRIBUTEPREFIX, Assembler };
 
 /**
  * attribute prefix
@@ -30,7 +30,6 @@ const ATTRIBUTEPREFIX = "data-monster-";
  * @summary Allows you to build an html fragment
  */
 class Assembler extends Base {
-
     /**
      * @param {DocumentFragment} fragment
      * @throws {TypeError} value is not an instance of
@@ -40,7 +39,7 @@ class Assembler extends Base {
     constructor(fragment) {
         super();
         this.attributePrefix = ATTRIBUTEPREFIX;
-        validateInstance(fragment, getGlobalFunction('DocumentFragment'));
+        validateInstance(fragment, getGlobalFunction("DocumentFragment"));
         this.fragment = fragment;
     }
 
@@ -71,7 +70,6 @@ class Assembler extends Base {
      * @throws {TypeError} value is not an instance of
      */
     createDocumentFragment(data) {
-
         if (data === undefined) {
             data = new ProxyObserver({});
         }
@@ -80,5 +78,4 @@ class Assembler extends Base {
         let fragment = this.fragment.cloneNode(true);
         return fragment;
     }
-
 }