@schukai/monster 3.4.2 → 3.7.0

package/source/data/pathfinder.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 {isArray, isInteger, isObject, isPrimitive} from '../types/is.mjs';
-import {Stack} from "../types/stack.mjs";
-import {validateInteger, validateString} from '../types/validate.mjs';
+import { Base } from "../types/base.mjs";
+import { isArray, isInteger, isObject, isPrimitive } from "../types/is.mjs";
+import { Stack } from "../types/stack.mjs";
+import { validateInteger, validateString } from "../types/validate.mjs";
 
-export {Pathfinder, DELIMITER, WILDCARD}
+export { Pathfinder, DELIMITER, WILDCARD };
 
 /**
  * path separator
@@ -18,13 +18,13 @@ export {Pathfinder, DELIMITER, WILDCARD}
  * @private
  * @type {string}
  */
-const DELIMITER = '.';
+const DELIMITER = ".";
 
 /**
  * @private
  * @type {string}
  */
-const WILDCARD = '*';
+const WILDCARD = "*";
 
 /**
  * Pathfinder is a class to find a path to an object.
@@ -72,7 +72,6 @@ const WILDCARD = '*';
  * @memberOf Monster.Data
  */
 class Pathfinder extends Base {
-
     /**
      * @param {array|object|Map|Set} value
      * @since 1.4.0
@@ -82,7 +81,7 @@ class Pathfinder extends Base {
         super();
 
         if (isPrimitive(object)) {
-            throw new Error('the parameter must not be a simple type');
+            throw new Error("the parameter must not be a simple type");
         }
 
         this.object = object;
@@ -165,16 +164,12 @@ class Pathfinder extends Base {
         try {
             getValueViaPath.call(this, this.object, path, true);
             return true;
-        } catch (e) {
-
-        }
+        } catch (e) {}
 
         return false;
     }
-
 }
 
-
 /**
  *
  * @param {*} subject
@@ -187,12 +182,11 @@ class Pathfinder extends Base {
  * @private
  */
 function iterate(subject, path, check) {
-
-    const result = new Map;
+    const result = new Map();
 
     if (isObject(subject) || isArray(subject)) {
         for (const [key, value] of Object.entries(subject)) {
-            result.set(key, getValueViaPath.call(this, value, path, check))
+            result.set(key, getValueViaPath.call(this, value, path, check));
         }
     } else {
         let key = path.split(DELIMITER).shift();
@@ -200,15 +194,13 @@ function iterate(subject, path, check) {
     }
 
     return result;
-
-
 }
 
 /**
  *
  * @param {*} subject
  * @param [string} path
- * @param [boolean} check 
+ * @param [boolean} check
  * @returns {*}
  * @throws {TypeError} unsupported type
  * @throws {Error} the journey is not at its end
@@ -216,12 +208,11 @@ function iterate(subject, path, check) {
  * @private
  */
 function getValueViaPath(subject, path, check) {
-
     if (path === "") {
         return subject;
     }
 
-    let parts = path.split(DELIMITER)
+    let parts = path.split(DELIMITER);
     let current = parts.shift();
 
     if (current === this.wildCard) {
@@ -229,51 +220,43 @@ function getValueViaPath(subject, path, check) {
     }
 
     if (isObject(subject) || isArray(subject)) {
-
         let anchor;
         if (subject instanceof Map || subject instanceof WeakMap) {
             anchor = subject.get(current);
-
         } else if (subject instanceof Set || subject instanceof WeakSet) {
             current = parseInt(current);
-            validateInteger(current)
+            validateInteger(current);
             anchor = [...subject]?.[current];
-
-        } else if (typeof WeakRef === 'function' && subject instanceof WeakRef) {
-            throw Error('unsupported action for this data type');
-
+        } else if (typeof WeakRef === "function" && subject instanceof WeakRef) {
+            throw Error("unsupported action for this data type");
         } else if (isArray(subject)) {
             current = parseInt(current);
-            validateInteger(current)
+            validateInteger(current);
             anchor = subject?.[current];
         } else {
             anchor = subject?.[current];
         }
 
         if (isObject(anchor) || isArray(anchor)) {
-            return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check)
+            return getValueViaPath.call(this, anchor, parts.join(DELIMITER), check);
         }
 
         if (parts.length > 0) {
-            throw Error("the journey is not at its end (" + parts.join(DELIMITER) + ")");
+            throw Error(`the journey is not at its end (${parts.join(DELIMITER)})`);
         }
 
-
         if (check === true) {
             const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(subject), current);
 
             if (!subject.hasOwnProperty(current) && descriptor === undefined) {
-                throw Error('unknown value');
+                throw Error("unknown value");
             }
-
         }
 
         return anchor;
-
     }
 
-    throw TypeError("unsupported type " + typeof subject)
-
+    throw TypeError(`unsupported type ${typeof subject}`);
 }
 
 /**
@@ -289,23 +272,19 @@ function getValueViaPath(subject, path, check) {
  * @private
  */
 function setValueViaPath(object, path, value) {
-
     validateString(path);
 
-    let parts = path.split(DELIMITER)
+    let parts = path.split(DELIMITER);
     let last = parts.pop();
     let subpath = parts.join(DELIMITER);
 
-    let stack = new Stack()
+    let stack = new Stack();
     let current = subpath;
     while (true) {
-
         try {
-            getValueViaPath.call(this, object, current, true)
+            getValueViaPath.call(this, object, current, true);
             break;
-        } catch (e) {
-
-        }
+        } catch (e) {}
 
         stack.push(current);
         parts.pop();
@@ -323,7 +302,6 @@ function setValueViaPath(object, path, value) {
             if (isInteger(parseInt(n))) {
                 obj = [];
             }
-
         }
 
         setValueViaPath.call(this, object, current, obj);
@@ -331,27 +309,23 @@ function setValueViaPath(object, path, value) {
 
     let anchor = getValueViaPath.call(this, object, subpath);
 
-    if (!isObject(object) && !isArray(object)) {
-        throw TypeError("unsupported type: " + typeof object);
+    if (!(isObject(object) || isArray(object))) {
+        throw TypeError(`unsupported type: ${typeof object}`);
     }
 
     if (anchor instanceof Map || anchor instanceof WeakMap) {
         anchor.set(last, value);
     } else if (anchor instanceof Set || anchor instanceof WeakSet) {
-        anchor.append(value)
-
-    } else if (typeof WeakRef === 'function' && anchor instanceof WeakRef) {
-        throw Error('unsupported action for this data type');
-
+        anchor.append(value);
+    } else if (typeof WeakRef === "function" && anchor instanceof WeakRef) {
+        throw Error("unsupported action for this data type");
     } else if (isArray(anchor)) {
         last = parseInt(last);
-        validateInteger(last)
+        validateInteger(last);
         assignProperty(anchor, last, value);
     } else {
         assignProperty(anchor, last, value);
     }
-
-
 }
 
 /**
@@ -361,7 +335,6 @@ function setValueViaPath(object, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-
     if (!object.hasOwnProperty(key)) {
         object[key] = value;
         return;
@@ -372,7 +345,6 @@ function assignProperty(object, key, value) {
     }
 
     object[key] = value;
-
 }
 
 /**
@@ -389,8 +361,7 @@ function assignProperty(object, key, value) {
  * @private
  */
 function deleteValueViaPath(object, path) {
-
-    const parts = path.split(DELIMITER)
+    const parts = path.split(DELIMITER);
     let last = parts.pop();
     const subpath = parts.join(DELIMITER);
 
@@ -398,16 +369,18 @@ function deleteValueViaPath(object, path) {
 
     if (anchor instanceof Map) {
         anchor.delete(last);
-    } else if (anchor instanceof Set || anchor instanceof WeakMap || anchor instanceof WeakSet || (typeof WeakRef === 'function' && anchor instanceof WeakRef)) {
-        throw Error('unsupported action for this data type');
-
+    } else if (
+        anchor instanceof Set ||
+        anchor instanceof WeakMap ||
+        anchor instanceof WeakSet ||
+        (typeof WeakRef === "function" && anchor instanceof WeakRef)
+    ) {
+        throw Error("unsupported action for this data type");
     } else if (isArray(anchor)) {
         last = parseInt(last);
-        validateInteger(last)
+        validateInteger(last);
         delete anchor[last];
     } else {
         delete anchor[last];
     }
-
-
 }

package/source/data/pipe.mjs

@@ -5,17 +5,17 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-import {Base} from '../types/base.mjs';
-import {validateString} from '../types/validate.mjs';
-import {Transformer} from './transformer.mjs';
+import { Base } from "../types/base.mjs";
+import { validateString } from "../types/validate.mjs";
+import { Transformer } from "./transformer.mjs";
 
-export {Pipe}
+export { Pipe };
 
 /**
  * @private
  * @type {string}
  */
-const DELIMITER = '|';
+const DELIMITER = "|";
 
 /**
  * The pipe class makes it possible to combine several processing steps.
@@ -32,7 +32,6 @@ const DELIMITER = '|';
  * @memberOf Monster.Data
  */
 class Pipe extends Base {
-
     /**
      * @param {string} pipe a pipe consists of commands whose input and output are connected with the pipe symbol `|`.
      * @throws {TypeError}
@@ -40,12 +39,10 @@ class Pipe extends Base {
     constructor(pipe) {
         super();
         validateString(pipe);
-        
+
         this.pipe = pipe.split(DELIMITER).map((v) => {
             return new Transformer(v);
         });
-
-
     }
 
     /**
@@ -57,7 +54,6 @@ class Pipe extends Base {
      * @throws {TypeError} value is not a function
      */
     setCallback(name, callback, context) {
-
         for (const [, t] of Object.entries(this.pipe)) {
             t.setCallback(name, callback, context);
         }