chore: cleanup

Author: Sascha Goldhofer

.npmignore

@@ -1,9 +1,3 @@
-/test/
-/dev/
-/release/
-/docs/
-/test/
-.*
 *.dat
 *.gz
 *.log
@@ -12,11 +6,16 @@
 *.sublime*
 *.tmp
 *.zip
+.*
 .DS_Store
 .editorconfig
 .eslintrc
 .gitignore
 .nyc_output
+/docs/
+/lib/
+/test/
+/test/
 build
 dev
 docs
@@ -25,3 +24,4 @@ test
 Thumbs.db
 tsconfig.json
 webpack.config.js
+yarn-error.log

dist/index.d.ts

@@ -1,7 +1,7 @@
-import get, { ReturnType, ResultCallback } from "./lib/get";
-import set from "./lib/set";
-import split from "./lib/split";
-import remove from "./lib/remove";
+import { get, ReturnType, ResultCallback } from "./lib/get";
+import { set } from "./lib/set";
+import { split } from "./lib/split";
+import { remove } from "./lib/remove";
 export { get, set, split, remove, ReturnType };
 declare const _default: {
     get: typeof get;
@@ -12,4 +12,4 @@ declare const _default: {
 };
 export default _default;
 export type { ResultCallback };
-export type { Input, JSONPointer, QueryResult } from "./lib/types";
+export type { Input, JsonPointer, QueryResult } from "./lib/types";

dist/gsonQuery.js renamed to dist/jsonQuery.js

@@ -1,4 +1,4 @@
-import { Input, JSONPointer } from "./types";
+import { Input, JsonPointer } from "./types";
 export declare enum ReturnType {
     POINTER = "pointer",
     VALUE = "value",
@@ -7,18 +7,17 @@ export declare enum ReturnType {
 }
 export type ResultCallback = (value: any, property: string | null, parent: {
     [p: string]: any;
-} | Array<any> | null, pointer: JSONPointer) => any;
+} | Array<any> | null, pointer: JsonPointer) => any;
 /**
  * Runs query on input data and returns the results
  * @param data - input data
- * @param queryString - gson-query string
+ * @param queryString - json-query string
  * @param returnType - result format or a custom callback
  */
-declare function get(data: Input, queryString: string, returnType?: ReturnType | ResultCallback): any;
-declare namespace get {
+export declare function get(data: Input, queryString: string, returnType?: ReturnType | ResultCallback): any;
+export declare namespace get {
     var POINTER: ReturnType;
     var VALUE: ReturnType;
     var ALL: ReturnType;
     var MAP: ReturnType;
 }
-export default get;

dist/gsonQuery.js.LICENSE.txt renamed to dist/jsonQuery.js.LICENSE.txt

@@ -1,5 +1,5 @@
 import { VALUE_INDEX, KEY_INDEX, PARENT_INDEX, POINTER_INDEX } from "./keys";
 import { QueryResult, Input } from "../types";
 import { IToken } from "ebnf";
-export default function run(data: Input, ast: IToken): Array<QueryResult>;
-export { run, VALUE_INDEX, KEY_INDEX, PARENT_INDEX, POINTER_INDEX };
+export declare function run(data: Input, ast: IToken): Array<QueryResult>;
+export { VALUE_INDEX, KEY_INDEX, PARENT_INDEX, POINTER_INDEX };

dist/lib/get.d.ts

@@ -5,9 +5,9 @@ declare const cache: {
     reset(): void;
 };
 declare const expand: {
-    any(node: IToken, entry: any): any;
+    any(node: IToken, entry: any): any[][];
     all(node: IToken, entry: any): any[];
-    regex(node: IToken, entry: any): any;
+    regex(node: IToken, entry: any): any[][];
 };
 declare const select: {
     escaped: (node: IToken, entry: any) => any[];

dist/lib/interpreter/index.d.ts

@@ -0,0 +1,2 @@
+export declare const propertyRegex = "[^?/{}*,()#]+";
+export declare const jsonQueryGrammar: string;

dist/lib/interpreter/nodes.d.ts

@@ -1,7 +1,7 @@
 /**
  * Runs query on input data and removes matching properties from results
  * @param data - input data
- * @param queryString - gson-query string
+ * @param queryString - json-query string
  * @param [returnRemoved] - if true, will returned removed properties, else input-data is removed
  */
-export default function queryRemove(data: any, queryString: any, returnRemoved?: boolean): any;
+export declare function remove(data: any, queryString: any, returnRemoved?: boolean): any;

dist/lib/parser/grammar.d.ts

@@ -6,13 +6,12 @@ export declare enum InsertMode {
 /**
  * Runs query on input data and assigns a value to query-results.
  * @param data - input data
- * @param queryString - gson-query string
+ * @param queryString - json-query string
  * @param value - value to assign
  * @param [force] - whether to replace or insert into arrays
  */
-declare function set<T extends Input>(data: T, queryString: string, value: any, force?: InsertMode): T;
-declare namespace set {
+export declare function set<T extends Input>(data: T, queryString: string, value: any, force?: InsertMode): T;
+export declare namespace set {
     var REPLACE_ITEMS: InsertMode;
     var INSERT_ITEMS: InsertMode;
 }
-export default set;

dist/lib/parser/jsonQueryGrammar.d.ts

@@ -1,4 +1,4 @@
 /**
  * Returns queryString as a list of property-queries
  */
-export default function split(queryString?: string): Array<string>;
+export declare function split(queryString?: string): Array<string>;

dist/lib/remove.d.ts

@@ -1,7 +1,12 @@
 export type Input = {
     [p: string]: any;
 } | Array<any>;
-export type JSONPointer = string;
-export type QueryResult = [any, string | null, {
-    [p: string]: any;
-} | Array<any> | null, JSONPointer];
+export type JsonPointer = string;
+export type QueryResult = [
+    any,
+    string | null,
+    {
+        [p: string]: any;
+    } | Array<any> | null,
+    JsonPointer
+];

dist/lib/set.d.ts

@@ -1,6 +1,6 @@
-import get, { ReturnType } from "./lib/get";
-import set from "./lib/set";
-import split from "./lib/split";
-import remove from "./lib/remove";
+import { get, ReturnType } from "./lib/get";
+import { set } from "./lib/set";
+import { split } from "./lib/split";
+import { remove } from "./lib/remove";
 export { get, set, split, remove, ReturnType };
 export default { get, set, split, remove, ReturnType };

dist/lib/split.d.ts

@@ -1,14 +1,14 @@
 import { parse } from "./parser";
 import { run, VALUE_INDEX, POINTER_INDEX } from "./interpreter";
 const returnTypes = {
-    value: r => r.map(e => e[VALUE_INDEX]),
-    pointer: r => r.map(e => e[POINTER_INDEX]),
-    all: r => r,
-    map: r => {
+    value: (r) => r.map((e) => e[VALUE_INDEX]),
+    pointer: (r) => r.map((e) => e[POINTER_INDEX]),
+    all: (r) => r,
+    map: (r) => {
         const map = {};
-        r.forEach(e => (map[e[POINTER_INDEX]] = e[VALUE_INDEX]));
+        r.forEach((e) => (map[e[POINTER_INDEX]] = e[VALUE_INDEX]));
         return map;
-    }
+    },
 };
 export var ReturnType;
 (function (ReturnType) {
@@ -25,10 +25,10 @@ get.MAP = ReturnType.MAP;
 /**
  * Runs query on input data and returns the results
  * @param data - input data
- * @param queryString - gson-query string
+ * @param queryString - json-query string
  * @param returnType - result format or a custom callback
  */
-export default function get(data, queryString, returnType = ReturnType.VALUE) {
+export function get(data, queryString, returnType = ReturnType.VALUE) {
     if (queryString == null) {
         return [];
     }

dist/lib/types.d.ts

@@ -19,7 +19,7 @@ function reduce(func, input, node, pointer) {
 }
 function query(data, ast, pointer) {
     let result = data;
-    ast.children.forEach(node => {
+    ast.children.forEach((node) => {
         if (expand[node.type]) {
             result = collect(expand[node.type], result, node, pointer);
         }
@@ -35,7 +35,7 @@ function query(data, ast, pointer) {
 function runPatternOnce(inputSet, ast, pointer) {
     const resultingSet = [];
     let workingSet = inputSet;
-    ast.children.forEach(node => {
+    ast.children.forEach((node) => {
         if (node.type === "orPattern") {
             resultingSet.push(...workingSet);
             workingSet = inputSet;
@@ -58,7 +58,7 @@ function getIterationCount(quantifier) {
 }
 function pattern(data, ast, pointer) {
     const result = [];
-    const quantifier = ast.children.find(node => node.type === "quantifier");
+    const quantifier = ast.children.find((node) => node.type === "quantifier");
     const iterationCount = getIterationCount(quantifier && quantifier.text);
     let workingSet = data;
     if (quantifier && quantifier.text === "*") {
@@ -74,7 +74,7 @@ function pattern(data, ast, pointer) {
 }
 function skip(data, ast, pointer) {
     let result = data;
-    ast.children.forEach(n => (result = runNode(result, n, pointer)));
+    ast.children.forEach((n) => (result = runNode(result, n, pointer)));
     return result;
 }
 function runNode(data, ast, pointer) {
@@ -93,9 +93,9 @@ function runNode(data, ast, pointer) {
     cache.mem.push(data);
     return result;
 }
-export default function run(data, ast) {
+export function run(data, ast) {
     cache.reset();
     cache.mem.push(data);
     return runNode([[data, null, null, "#"]], ast);
 }
-export { run, VALUE_INDEX, KEY_INDEX, PARENT_INDEX, POINTER_INDEX };
+export { VALUE_INDEX, KEY_INDEX, PARENT_INDEX, POINTER_INDEX };

dist/module/index.js

@@ -1,13 +1,47 @@
-import o from "gson-conform";
 const join = (a, b) => `${a}/${b}`;
 import { VALUE_INDEX, POINTER_INDEX } from "./keys";
 const toString = Object.prototype.toString;
 const rContainer = /Object|Array/;
-const isContainer = v => rContainer.test(toString.call(v));
-const getTypeOf = v => toString.call(v).match(/\s([^\]]+)\]/).pop().toLowerCase();
+const isContainer = (v) => rContainer.test(toString.call(v));
+const getTypeOf = (v) => toString
+    .call(v)
+    .match(/\s([^\]]+)\]/)
+    .pop()
+    .toLowerCase();
 function nodeAsRegex(node) {
     return new RegExp(node.text.replace(/(^{|}$)/g, ""));
 }
+/**
+ * Iterates over object or array, passing each key, value and parentObject to the callback
+ * @param value - to iterate
+ * @param callback - receiving key on given input value
+ */
+function forEach(parent, callback) {
+    if (Array.isArray(parent)) {
+        parent.forEach(callback);
+    }
+    else if (Object.prototype.toString.call(parent) === "[object Object]") {
+        Object.keys(parent).forEach(function (key) {
+            callback(parent[key], key, parent);
+        });
+    }
+}
+/**
+ * Returns all keys of the given input data
+ * @param  value
+ * @return {Array} containing keys of given value
+ */
+function getKeys(value) {
+    if (Array.isArray(value)) {
+        return value.map(function (value, index) {
+            return `${index}`;
+        });
+    }
+    if (Object.prototype.toString.call(value) === "[object Object]") {
+        return Object.keys(value);
+    }
+    return [];
+}
 const cache = {
     mem: [],
     get(entry, prop) {
@@ -22,18 +56,23 @@ const cache = {
     },
     reset() {
         cache.mem.length = 0;
-    }
+    },
 };
 const expand = {
     any(node, entry) {
         const value = entry[VALUE_INDEX];
-        return o.keys(value)
+        return (getKeys(value)
             // .map(prop => cache.get(entry, prop));
-            .map(prop => [value[prop], prop, value, join(entry[POINTER_INDEX], prop)]);
+            .map((prop) => [
+            value[prop],
+            prop,
+            value,
+            join(entry[POINTER_INDEX], prop),
+        ]));
     },
     all(node, entry) {
         const result = [entry];
-        o.forEach(entry[VALUE_INDEX], (value, prop) => {
+        forEach(entry[VALUE_INDEX], (value, prop) => {
             const childEntry = cache.get(entry, prop);
             // const childEntry = [value, prop, entry[VALUE_INDEX], join(entry[POINTER_INDEX], prop)];
             childEntry && result.push(...expand.all(node, childEntry));
@@ -43,10 +82,15 @@ const expand = {
     regex(node, entry) {
         const regex = nodeAsRegex(node);
         const value = entry[VALUE_INDEX];
-        return o.keys(value)
-            .filter(prop => regex.test(prop))
-            .map(prop => [value[prop], prop, value, join(entry[POINTER_INDEX], prop)]);
-    }
+        return getKeys(value)
+            .filter((prop) => regex.test(prop))
+            .map((prop) => [
+            value[prop],
+            prop,
+            value,
+            join(entry[POINTER_INDEX], prop),
+        ]);
+    },
 };
 const select = {
     // alias to property (but escaped)
@@ -58,7 +102,7 @@ const select = {
                 entry[VALUE_INDEX][prop],
                 prop,
                 entry[VALUE_INDEX],
-                join(entry[POINTER_INDEX], prop)
+                join(entry[POINTER_INDEX], prop),
             ];
         }
     },
@@ -75,10 +119,10 @@ const select = {
     lookahead: (node, entry) => {
         let valid = true;
         let or = false;
-        node.children.forEach(expr => {
+        node.children.forEach((expr) => {
             if (expr.type === "expression") {
                 const isValid = select.expression(expr, entry) !== undefined;
-                valid = or === true ? (valid || isValid) : valid && isValid;
+                valid = or === true ? valid || isValid : valid && isValid;
             }
             else {
                 or = expr.type === "orExpr";
@@ -95,14 +139,14 @@ const select = {
             return undefined;
         }
         return expressionMatches(value[prop], cmp, test) ? entry : undefined;
-    }
+    },
 };
 function expressionMatches(value, cmp, test) {
     if (cmp === undefined) {
         return value !== undefined;
     }
     let valid;
-    const valueString = "" + value;
+    const valueString = `${value}`;
     if (test.type === "regex") {
         const regex = nodeAsRegex(test);
         valid = regex.test(valueString);