add-traverse

Author: prohazko2

.editorconfig

@@ -10,10 +10,10 @@ insert_final_newline = true
 
 # Matches multiple files with brace expansion notation
 # Set default charset
-[*.{js,css,html,less,jade}]
+[*.{js,ts,css,html,less,jade}]
 charset = utf-8
 
 # 2 space indentation
-[*.{js,css,html,less,jade}]
+[*.{js,ts,css,html,less,jade}]
 indent_style = space
-indent_size = 2
+indent_size = 2

.gitignore

@@ -59,3 +59,4 @@ typings/
 
 # next.js build output
 .next
+test.js

index.d.ts

@@ -2,28 +2,37 @@
 /* @file ./src/log.js */
 
 interface LogggerOptions {
-    level: number; /* 0 | 1 | 2 | 3 | 4 */
-    time: 'iso' | 'ru' | 'en';
+  level: number; /* 0 | 1 | 2 | 3 | 4 */
+  time: 'iso' | 'ru' | 'en';
 }
 interface Loggger {
-    //(msg: string | object, category?: string, level?: number): void;
-    setOptions(opts: LogggerOptions): void;
+  //(msg: string | object, category?: string, level?: number): void;
+  setOptions(opts: LogggerOptions): void;
 
-    debug(msg: string): void;
-    info(msg: string): void;
-    warn(msg: string): void;
-    error(msg: string): void;
+  debug(msg: string): void;
+  info(msg: string): void;
+  warn(msg: string): void;
+  error(msg: string): void;
 }
 
 export declare var log: Loggger;
 
 
 /* @file ./src/safe.js */
 interface SafeOps {
-    bit(value: number, bit: number): boolean;
+  bit(value: number, bit: number): boolean;
 
-    get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey): TObject[TKey];
-    set<TObject extends object, T>(object: TObject, path: string, value:T): T;
-    unset<TObject extends object>(object: TObject, path: string): void;
+  get<TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey): TObject[TKey];
+  set<TObject extends object, T>(object: TObject, path: string, value: T): T;
+  unset<TObject extends object>(object: TObject, path: string): void;
 }
 export declare var safe: SafeOps;
+
+
+/* @file ./src/traverse.js */
+interface Traverse<T> {
+  each(pred: (node: T, parent: T) => any): void;
+  find(pred: (node: T) => boolean): T;
+  filter(pred: (node: T) => boolean): T[];
+}
+export declare function traverse<T>(tree: T & { children: T[] }): Traverse<T & { children: T[] }>;

index.js

@@ -3,5 +3,6 @@
 module.exports = Object.assign({}, {
   node: require('./src/node'),
   safe: require('./src/safe'),
+  traverse: require('./src/traverse'),
   log: require('./src/log')
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightech/utils",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "",
   "main": "index.js",
   "private": false,

src/traverse.js

@@ -0,0 +1,81 @@
+/*
+ *  name        : Rightech IoT Cloud ~.
+ *  description : ~
+ *  author      : Oleg Prohazko
+ *
+ *  LLC, Komnet, Russian Federation, Moscow, 2016
+ *
+ */
+
+
+function walk(child, callback, parent) {
+  callback(child, parent);
+
+  parent = child;
+  const children = child.children || [];
+  for (const child of children) {
+    walk(child, callback, parent);
+  }
+}
+
+function walkFind(tree, callback) {
+  if (callback(tree)) {
+    return tree;
+  }
+
+  for (const child of tree.children || []) {
+    const result = walkFind(child, callback);
+    if (result) {
+      return result;
+    }
+  }
+}
+
+function walkFindWithStats(tree, callback, stats = {}) {
+  if (!stats.level) {
+    stats.level = 0;
+  }
+  if (!stats.path) {
+    stats.path = [tree];
+  }
+  stats.node = tree;
+  if (callback(tree)) {
+    stats.level = stats.path.length - 1; 
+    stats.path.pop();
+    return stats;
+  }
+
+  for (const child of tree.children || []) {
+    stats.path.push(child);
+    const result = walkFindWithStats(child, callback, stats);
+    if (result) {
+      return result;
+    }
+    stats.path.pop();
+  }
+}
+
+function walkFilter(child, callback, result) {
+  if (callback(child)) {
+    result.push(child);
+  }
+
+  const children = child.children || [];
+  for (const child of children) {
+    walkFilter(child, callback, result);
+  }
+}
+
+
+module.exports = function traverse(tree) {
+  return {
+    each: callback => walk(tree, callback),
+    find: callback => walkFind(tree, callback),
+    findWithStats: callback => walkFindWithStats(tree, callback, {}),
+    filter: callback => {
+      const result = [];
+      walkFilter(tree, callback, result);
+      return result;
+    }
+  };
+};