Merge pull request #18 from dotvirus/dev

Dev

Author: marvin-j97

.gitignore

@@ -0,0 +1 @@
+node_modules

README.md

@@ -2,9 +2,9 @@
 
 # ptree
 
-Deep object walking, manipulation and validation
+Deep object walking & manipulation
 
-This package wraps regular Objects and Arrays, providing more functionality for accessing, manipulating and validating deep object/array integrity.
+This package wraps regular Objects and Arrays, providing more functionality for accessing & manipulating deep objects.
 
 # Install
 
@@ -39,6 +39,7 @@ const root = new ptree([1, 2, 3]);
 Get the value at given key.
 Key can be a dot-separated string, or an array containing single key segments as strings, numbers or functions.
 If a non-existing key is accessed (see example 3), undefined is returned.
+If no argument is passed, the root object is returned (same as getRoot()).
 
 ```javascript
 const root = new ptree({ a: 2, b: 3 });
@@ -172,125 +173,6 @@ console.log(root.map(v => v * v)); // -> { a: 25, b: { c: 49, d: 64, e: 81 } }
 console.log(root.map(v => v.toString())); // -> { a: '5', b: { c: '7', d: '8', e: '9' } }
 ```
 
-# validate
-
-Checks the integrity of the root object.
-This is done by defining rules for each key you want to check.
-
-```javascript
-const root = new ptree([1, 2, 3]);
-
-// Check if keys are defined
-// this returns false, because the array is only length 3.
-console.log(
-  root.validate([
-    {
-      key: "0"
-    },
-    {
-      key: "1"
-    },
-    {
-      key: "2"
-    },
-    {
-      key: "3"
-    }
-  ])
-); // -> false
-
-// Like above, but this time index 3 is optional
-console.log(
-  root.validate([
-    {
-      key: "0"
-    },
-    {
-      key: "1"
-    },
-    {
-      key: "2"
-    },
-    {
-      key: "3",
-      optional: true
-    }
-  ])
-); // -> true
-
-// Check for equality at given keys
-console.log(
-  root.validate([
-    {
-      key: "0",
-      rules: [v => v === 1]
-    },
-    {
-      key: "1",
-      rules: [v => v === 2]
-    }
-  ])
-); // -> true
-
-// Wildcard
-console.log(
-  root.validate([
-    {
-      key: "*",
-      rules: [v => typeof v === "number"]
-    }
-  ])
-); // -> true
-
-// Error message
-const root = new ptree({
-  a: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-});
-
-console.log(
-  root.validate([
-    {
-      key: "a",
-      rules: [
-        v => Array.isArray(v),
-        v => (v.length > 5 ? "Array too long!" : true)
-      ]
-    }
-  ])
-); // -> "Array too long!"
-
-// Using (pre/post) transforms, you can alter the object before or after applying your rules; this alters the original object!
-// Trim all strings before checking rules
-const tree = new ptree({
-  a: " string",
-  b: ["  not trimmed  "]
-});
-
-tree.validate([
-  {
-    key: "*",
-    preTransform: [v => v.trim()],
-    rules: [v => true]
-    // postTransform: [
-    // ]
-  }
-]);
-
-console.log(tree.root); // -> { a: 'string', b: [ 'not trimmed' ] }
-
-// Access the original object in rules (or transforms)
-const root = new ptree({ a: 5, b: 5 });
-
-console.log(
-  root.validate([
-    {
-      key: "a",
-      rules: [(v, obj) => v === obj.b]
-    }
-  ])
-);
-```
-
 # copy
 
 Deep-copies the root object/array.
@@ -328,3 +210,40 @@ new ptree({
   b: 3
 }).includes(5); // -> false
 ```
+
+# Remove
+
+Removes a property from an object
+
+```javascript
+const obj = {
+  a: {
+    b: 2,
+    c: {
+      d: 3,
+      e: 5,
+      f: [1, 2, 3]
+    }
+  }
+};
+
+console.log(obj.a.b); // -> 2
+new ptree(obj).remove("a.b");
+console.log(obj.a.b); // -> undefined
+```
+
+# Pick
+
+Returns a new object only with the given keys
+
+# every/all
+
+Same as Array.prototype.every, but deep.
+
+# some/any
+
+Same as Array.prototype.some, but deep.
+
+# Merge
+
+Same as Object.assign(), but deep. Second argument controls if existing keys should be overwritten (default: true, like Object.assign()).

dist/index.d.ts

@@ -1,15 +1,4 @@
 export declare type Key = string | number | (() => string | number);
-export declare type DefaultFunction = (root: object) => any;
-export declare type TransformFunction = (val: any, root: object) => any;
-export declare type Rule = (val: any, root: object) => boolean | string;
-export declare type ValidationProp = {
-    key: Key;
-    optional?: boolean;
-    default?: any | DefaultFunction;
-    rules?: Rule | Rule[];
-    preTransform?: TransformFunction | TransformFunction[];
-    postTransform?: TransformFunction | TransformFunction[];
-};
 interface KeyValueMap {
     [key: string]: any;
 }
@@ -19,6 +8,8 @@ export default class PTree {
     constructor(root: object);
     static from(root: object): PTree;
     get(key?: Key): any;
+    wildcard(pattern: string): string[];
+    innerNodes(prev?: string): string[];
     keys(prev?: string): string[];
     remove(key: Key): any;
     set(key: Key, value: any): void;
@@ -30,7 +21,6 @@ export default class PTree {
     equal(other: object): boolean;
     findKey(finder: (val: any, key: string, root: object) => boolean): string | undefined;
     map(mapper: (val: any, key: string, root: object) => any): any;
-    validate(props: ValidationProp[]): boolean | string;
     copy(): any;
     each(func: (val: any, key: string, root: object) => void): void;
     forEach(func: (val: any, key: string, root: object) => void): void;

dist/index.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const pm = require("picomatch");
 function getSegments(path) {
     let segments = [];
     if (typeof path === "string") {
@@ -56,6 +57,38 @@ class PTree {
         }
         return obj;
     }
+    wildcard(pattern) {
+        const isMatch = pm(pattern.replace(/[.]/g, "/"));
+        return this.keys().filter(key => isMatch(key.replace(/[.]/g, "/")));
+    }
+    innerNodes(prev) {
+        let keys = [];
+        if (!Array.isArray(this.root)) {
+            let props = Object.keys(this.root);
+            props.forEach(key => {
+                const v = this.root[key];
+                if (typeof v === "object" && v !== null) {
+                    keys.push(key);
+                    keys.push(...new PTree(v).innerNodes(key));
+                }
+            });
+        }
+        else if (Array.isArray(this.root)) {
+            this.root.forEach((v, i) => {
+                if (typeof v === "object" && v !== null) {
+                    keys.push(i.toString());
+                    keys.push(...new PTree(v).innerNodes(i.toString()));
+                }
+            });
+        }
+        else {
+            throw `Tried to get keys of atomic value`;
+        }
+        if (prev !== undefined) {
+            keys = keys.map(k => `${prev}.${k}`);
+        }
+        return keys;
+    }
     keys(prev) {
         let keys = [];
         if (!Array.isArray(this.root)) {
@@ -196,71 +229,6 @@ class PTree {
         });
         return mapped;
     }
-    validate(props) {
-        for (const prop of props) {
-            if (!prop.key) {
-                throw "PTree: Invalid key in validation function";
-            }
-            if (prop.key === "*") {
-                props.push(...this.keys().map(key => {
-                    return {
-                        key,
-                        optional: prop.optional,
-                        rules: prop.rules,
-                        preTransform: prop.preTransform,
-                        postTransform: prop.postTransform
-                    };
-                }));
-                continue;
-            }
-            let value = this.get(prop.key);
-            if (value === undefined && !prop.optional) {
-                return false;
-            }
-            if (value === undefined && prop.optional) {
-                if (prop.default !== undefined) {
-                    if (typeof prop.default == "function")
-                        this.set(prop.key, prop.default(this.root));
-                    else
-                        this.set(prop.key, prop.default);
-                }
-                continue;
-            }
-            if (prop.preTransform) {
-                if (Array.isArray(prop.preTransform))
-                    for (const transformer of prop.preTransform) {
-                        this.set(prop.key, transformer(value, this.root));
-                    }
-                else
-                    this.set(prop.key, prop.preTransform(value, this.root));
-                value = this.get(prop.key);
-            }
-            if (prop.rules) {
-                if (Array.isArray(prop.rules)) {
-                    for (const rule of prop.rules) {
-                        const result = rule(value, this.root);
-                        if (result === true)
-                            continue;
-                        return result;
-                    }
-                }
-                else {
-                    const result = prop.rules(value, this.root);
-                    if (!result)
-                        return result;
-                }
-            }
-            if (prop.postTransform) {
-                if (Array.isArray(prop.postTransform))
-                    for (const transformer of prop.postTransform) {
-                        this.set(prop.key, transformer(value, this.root));
-                    }
-                else
-                    this.set(prop.key, prop.postTransform(value, this.root));
-            }
-        }
-        return true;
-    }
     copy() {
         return JSON.parse(JSON.stringify(this.root));
     }

package-lock.json

@@ -1,11 +1,11 @@
 {
   "name": "@dotvirus/ptree",
-  "version": "1.5.2",
-  "description": "Deep object walking, manipulation and validation",
+  "version": "2.1.0",
+  "description": "Deep object walking & manipulation",
   "main": "dist/index.js",
   "scripts": {
+    "deploy": "tsc && npm run test && npm publish --access public",
     "watch": "tsc --watch",
-    "build": "tsc",
     "test": "node test/"
   },
   "types": "dist/index.d.ts",
@@ -15,13 +15,21 @@
     "type": "git",
     "url": "https://github.com/dotvirus/ptree.ts.git"
   },
+  "files": [
+    "dist/"
+  ],
   "keywords": [
     "typescript",
-    "object-validator",
     "object-manipulation",
     "tree-structure",
     "deep",
     "ptree",
     "leaf"
-  ]
+  ],
+  "dependencies": {
+    "picomatch": "^2.1.1"
+  },
+  "devDependencies": {
+    "@types/node": "^12.12.18"
+  }
 }