@schukai/monster 3.5.0 → 3.8.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, isString } from "../types/is.mjs";
+import { Stack } from "../types/stack.mjs";
+import { validateInteger, validateBoolean, 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;
@@ -104,7 +103,7 @@ class Pathfinder extends Base {
 
     /**
      *
-     * @param {string} path
+     * @param {string|array} path
      * @since 1.4.0
      * @returns {*}
      * @throws {TypeError} unsupported type
@@ -114,12 +113,12 @@ class Pathfinder extends Base {
      * @throws {Error} unsupported action for this data type
      */
     getVia(path) {
-        return getValueViaPath.call(this, this.object, validateString(path));
+        return getValueViaPath.call(this, this.object, path);
     }
 
     /**
      *
-     * @param {string} path
+     * @param {string|array} path
      * @param {*} value
      * @returns {Pathfinder}
      * @since 1.4.0
@@ -129,7 +128,6 @@ class Pathfinder extends Base {
      * @throws {Error} unsupported action for this data type
      */
     setVia(path, value) {
-        validateString(path);
         setValueViaPath.call(this, this.object, path, value);
         return this;
     }
@@ -137,7 +135,7 @@ class Pathfinder extends Base {
     /**
      * Delete Via Path
      *
-     * @param {string} path
+     * @param {string|array} path
      * @returns {Pathfinder}
      * @since 1.6.0
      * @throws {TypeError} unsupported type
@@ -146,14 +144,13 @@ class Pathfinder extends Base {
      * @throws {Error} unsupported action for this data type
      */
     deleteVia(path) {
-        validateString(path);
         deleteValueViaPath.call(this, this.object, path);
         return this;
     }
 
     /**
      *
-     * @param {string} path
+     * @param {string|array} path
      * @return {bool}
      * @throws {TypeError} unsupported type
      * @throws {TypeError} value is not a string
@@ -161,25 +158,20 @@ class Pathfinder extends Base {
      * @since 1.4.0
      */
     exists(path) {
-        validateString(path);
         try {
             getValueViaPath.call(this, this.object, path, true);
             return true;
-        } catch (e) {
-
-        }
+        } catch (e) {}
 
         return false;
     }
-
 }
 
-
 /**
  *
  * @param {*} subject
- * @param {string} path
- * @param {string} check
+ * @param {string|array} path
+ * @param {boolean} check
  * @return {Map}
  * @throws {TypeError} unsupported type
  * @throws {Error} the journey is not at its end
@@ -187,12 +179,20 @@ class Pathfinder extends Base {
  * @private
  */
 function iterate(subject, path, check) {
+    if (check === undefined) {
+        check = false;
+    }
+    validateBoolean(check);
 
-    const result = new Map;
+    const result = new Map();
+
+    if (isArray(path)) {
+        path = path.join(DELIMITER);
+    }
 
     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 +200,13 @@ function iterate(subject, path, check) {
     }
 
     return result;
-
-
 }
 
 /**
  *
  * @param {*} subject
- * @param [string} path
- * @param [boolean} check 
+ * @param [string|array} path
+ * @param [boolean} check
  * @returns {*}
  * @throws {TypeError} unsupported type
  * @throws {Error} the journey is not at its end
@@ -216,12 +214,24 @@ function iterate(subject, path, check) {
  * @private
  */
 function getValueViaPath(subject, path, check) {
+    if (check === undefined) {
+        check = false;
+    }
+    validateBoolean(check);
 
-    if (path === "") {
-        return subject;
+    if (!(isArray(path) || isString(path))) {
+        throw new Error("type error: path must be a string or an array");
+    }
+
+    let parts;
+    if (isString(path)) {
+        if (path === "") {
+            return subject;
+        }
+
+        parts = path.split(DELIMITER);
     }
 
-    let parts = path.split(DELIMITER)
     let current = parts.shift();
 
     if (current === this.wildCard) {
@@ -229,58 +239,50 @@ 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}`);
 }
 
 /**
  *
- * @param object
- * @param path
- * @param value
+ * @param {object} subject
+ * @param {string|array} path
+ * @param {*} value
  * @returns {void}
  * @throws {TypeError} unsupported type
  * @throws {TypeError} unsupported type
@@ -288,24 +290,32 @@ function getValueViaPath(subject, path, check) {
  * @throws {Error} unsupported action for this data type
  * @private
  */
-function setValueViaPath(object, path, value) {
+function setValueViaPath(subject, path, value) {
+    if (!(isArray(path) || isString(path))) {
+        throw new Error("type error: path must be a string or an array");
+    }
 
-    validateString(path);
+    let parts;
+    if (isArray(path)) {
+        if (path.length === 0) {
+            return subject;
+        }
+
+        parts = path;
+    } else {
+        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, subject, current, true);
             break;
-        } catch (e) {
-
-        }
+        } catch (e) {}
 
         stack.push(current);
         parts.pop();
@@ -323,35 +333,30 @@ function setValueViaPath(object, path, value) {
             if (isInteger(parseInt(n))) {
                 obj = [];
             }
-
         }
 
-        setValueViaPath.call(this, object, current, obj);
+        setValueViaPath.call(this, subject, current, obj);
     }
 
-    let anchor = getValueViaPath.call(this, object, subpath);
+    let anchor = getValueViaPath.call(this, subject, subpath);
 
-    if (!isObject(object) && !isArray(object)) {
-        throw TypeError("unsupported type: " + typeof object);
+    if (!(isObject(subject) || isArray(subject))) {
+        throw TypeError(`unsupported type: ${typeof subject}`);
     }
 
     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 +366,6 @@ function setValueViaPath(object, path, value) {
  * @param {*} value
  */
 function assignProperty(object, key, value) {
-
     if (!object.hasOwnProperty(key)) {
         object[key] = value;
         return;
@@ -372,13 +376,12 @@ function assignProperty(object, key, value) {
     }
 
     object[key] = value;
-
 }
 
 /**
  *
- * @param object
- * @param path
+ * @param {object} subject
+ * @param {string} path
  * @returns {void}
  * @throws {TypeError} unsupported type
  * @throws {TypeError} unsupported type
@@ -388,26 +391,41 @@ function assignProperty(object, key, value) {
  * @since 1.6.0
  * @private
  */
-function deleteValueViaPath(object, path) {
+function deleteValueViaPath(subject, path) {
+    if (!(isArray(path) || isString(path))) {
+        throw new Error("type error: path must be a string or an array");
+    }
+
+    let parts;
+    if (isArray(path)) {
+        if (path.length === 0) {
+            return subject;
+        }
+
+        parts = path;
+    } else {
+        parts = path.split(DELIMITER);
+    }
 
-    const parts = path.split(DELIMITER)
     let last = parts.pop();
     const subpath = parts.join(DELIMITER);
 
-    const anchor = getValueViaPath.call(this, object, subpath);
+    const anchor = getValueViaPath.call(this, subject, subpath);
 
     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);
         }