@peter.naydenov/walk-async 1.0.3 → 1.2.0

package/Changelog.md

@@ -1,5 +1,17 @@
 # Release History
 
+
+
+### 1.2.0 ( 2023-09-18)
+- [x] HTML DOM nodes - copy by reference; 
+
+
+
+### 1.1.0 ( 2022-11-23)
+- [x] Resolving with `Null` and `undefined` from callback functions will be treated as value;
+
+
+
 ### 1.0.1 ( 2022-09-19)
 - [x] Fix: Deep copy process is losing object properties that are equal to 'null';
 

package/README.md

@@ -1,5 +1,8 @@
 # Walk-async (@peter.naydenov/walk-async)
 
+![version](https://img.shields.io/github/package-json/v/peterNaydenov/walk-async)
+![license](https://img.shields.io/github/license/peterNaydenov/walk-async)
+
 Creates an immutable copies of javascript data structures(objects, arrays or mixed). Can execute callback functions on every object property(objectCallback) and/or every primitive property(keyCallback). Callbacks can modify result object during the walk process. Mask, filter or substitute values during the copy process. 
 
 ```js
@@ -24,9 +27,24 @@ It is very simular to [`@peter.naydenov/walk`](https://github.com/PeterNaydenov/
  - `walk` can not execute another walk call inside callback functions;
 
 
+ Data structure values must be one of the following data types:
+ - string;
+ - number;
+ - bigint;
+ - boolean;
+ - symbol;
+ - null;
+ - undefined;
+ - array;
+ - object(data only);
+ - function;
+
+ Other data types can compromise the results;
+
+
 
 ## кeyCallback
-Function **keyCallback**  of the `walk-async` could be used also as a deep '**forEach**' method no matter of the type of the object(object or array).
+Function **keyCallback**  of the `walk-async` could be used also as a deep '**forEach**' method no matter of the type of the object(objects, array or mixed).
 
 ```js
 function keyCallbackFn ({ value, key, breadcrumbs, resolve, reject }) {
@@ -155,7 +173,7 @@ let x = {
     };
 function keyFn ({value,key,resolve,reject}) {
         if ( key === 'name' )   reject ()
-        else                   resolve ( value )
+        else                    resolve ( value )
 }
 
 walk ({

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@peter.naydenov/walk-async",
-  "version": "1.0.3",
+  "version": "1.2.0",
   "description": "Deep copy with fine control during the process. Can be used also as a deep forEach function",
   "main": "src/main.js",
   "scripts": {
     "test": "mocha test",
-    "cover": "nyc mocha test",
-    "build": "webpack --config ./webpack.config.js"
+    "cover": "nyc mocha test"
   },
   "repository": {
     "type": "git",
@@ -18,14 +17,9 @@
     "ask-for-promise": "1.3.1"
   },
   "devDependencies": {
-    "@babel/core": "^7.20.2",
-    "@babel/preset-env": "^7.20.2",
-    "babel-loader": "^9.1.0",
-    "chai": "^4.3.7",
-    "mocha": "^10.1.0",
-    "nyc": "^15.1.0",
-    "webpack": "^5.75.0",
-    "webpack-cli": "^4.10.0"
+    "chai": "^4.3.8",
+    "mocha": "^10.2.0",
+    "nyc": "^15.1.0"
   },
   "nyc": {
     "include": [

package/src/main.js

@@ -62,11 +62,11 @@ async function goNext ( extend, result, end ) {
 
 
 function findType ( x ) {
-    if ( x == null              )   return 'simple'
-    if ( typeof x === 'boolean' )   return 'simple'
+    if ( x == null              )   return 'simple' // null and undefined
+    if ( x.nodeType             )   return 'simple' // DOM node
     if ( x instanceof Array     )   return 'array'
     if ( typeof x === 'object'  )   return 'object'
-    return 'simple'
+    return 'simple' // number, bigint, string, boolean, symbol, function 
  } // findType func.
 
 
@@ -104,12 +104,13 @@ function copyObject ( origin, result, extend, cb, breadcrumbs ) {
                         , finishWithCallbacks     = askForPromise ()
                         , resultIsArray = (findType (result) === 'array') 
                         , keyNumber = !isNaN ( k )
+                        , IGNORE = Symbol ( 'ignore___' )
                         ;
 
                     if ( hasObjectCallback ) {
                                         objectCallback  ({
                                                               resolve : objectCallbackTask.done
-                                                            , reject  : () => objectCallbackTask.done ( null )
+                                                            , reject  : () => objectCallbackTask.done ( IGNORE )
                                                             , value : item
                                                             , key   : k  
                                                             , breadcrumbs : `${breadcrumbs}/${k}`
@@ -128,8 +129,8 @@ function copyObject ( origin, result, extend, cb, breadcrumbs ) {
                                                 item = res
                                                 type = findType ( item )
                                             }
-                                        if ( item == null     ) {  
-                                                executeCallback[i].done ()
+                                        if ( item == IGNORE     ) {  
+                                                executeCallback[i].done ( 'ignore object' )
                                                 return
                                             }                                        
                                         if ( type === 'simple' ) {
@@ -139,7 +140,7 @@ function copyObject ( origin, result, extend, cb, breadcrumbs ) {
                                                         }
                                                     keyCallback ({
                                                                   resolve  : keyCallbackTask.done
-                                                                , reject   : () => keyCallbackTask.done ( null ) 
+                                                                , reject   : () => keyCallbackTask.done ( IGNORE ) 
                                                                 , value : item
                                                                 , key   : k
                                                                 , breadcrumbs : `${breadcrumbs}/${k}`
@@ -151,8 +152,8 @@ function copyObject ( origin, result, extend, cb, breadcrumbs ) {
                         }) // objectCallbackTask complete
 
                     keyCallbackTask.onComplete ( value => {
-                                        if ( value == null ) {  
-                                                    executeCallback[i].done ( 'nulls' )
+                                        if ( value == IGNORE ) {  
+                                                    executeCallback[i].done ( 'ignore key' )
                                                     return
                                             }
                                         if ( value === '$$cancel' ) { 

package/test/01-deepCopy.test.js

@@ -83,6 +83,35 @@ describe ( 'Walk-async -> Deep copy', () => {
                     done ()
                 })
     }) // it Data property has value null
+
+
+
+    it ( 'html nodes - copy by reference', done => {
+        const data = {
+                      name : 'Peter'
+                    , pretendHTML : { nodeType: 1 }
+                };
+        walk ({ data })
+            .then ( r => {
+                    r.pretendHTML.something = 'hello'
+                    expect ( data.pretendHTML.something ).to.be.equal ( 'hello' )   // Recognize html nodes and keep them as a reference
+                    done ()
+            })
+    }) // html nodes - copy by reference
+
+
+
+  it ( 'Functions type - copy by reference', () => {
+            const data = {
+                          name : 'Peter'
+                        , func : () => 12
+                    };
+                    
+            walk ({ data })
+                .then ( r => {  
+                            expect ( r.func() ).to.be.equal ( 12 )
+                    })
+    }) // it Functions type - copy by reference
   
 }) // describe
 

package/test/02-keyCallback.test.js

@@ -145,6 +145,83 @@ describe ( 'Walk-async -> keyCallback function', () => {
                                 expect ( r.group ).to.be.equal ( 'work' )
                         })
       }) // it Properties of the array
+
+
+
+      it ( 'Set a value to NULL', done => {
+                let
+                    x = {
+                              ls   : [ 1,2,3 ]
+                            , name : 'Peter'
+                            , props : {
+                                          eyeColor: null   // Use callback and return this exact value
+                                        , age     : 47
+                                        , height  : 176
+                                        , sizes : [12,33,12,21]
+                                    }
+                            };
+
+                function checkNull ({ value, resolve }) {
+                            resolve (value) 
+                    } // checkNull func.
+
+                walk ({ data:x, keyCallback:checkNull })
+                    .then ( r => {
+                            expect ( r.props.eyeColor ).to.be.equal ( null )
+                            done ()
+                        })
+        }) // it set a value to NULL
+
+
+
+        it ( 'Set a value to undefined', done => {
+                    let
+                        x = {
+                                  ls   : [ 1,2,3 ]
+                                , name : 'Peter'
+                                , props : {
+                                              eyeColor: undefined   // Use callback and return this exact value
+                                            , age     : 47
+                                            , height  : 176
+                                            , sizes : [12,33,12,21]
+                                        }
+                                };
+
+                    function checkNull ({ value, resolve }) {
+                                resolve(value)
+                        } // checkNull func.
+
+                    walk ({ data:x, keyCallback:checkNull })
+                      .then ( r => {
+                                expect ( r.props.eyeColor ).to.be.equal ( undefined )
+                                done ()
+                            })
+          }) // it Set a value to undefined
+        
+
+        it ( 'Copy a function', done => {
+                    let
+                        x = {
+                                  ls   : [ 1,2,3 ]
+                                , name : 'Peter'
+                                , props : {
+                                              eyeColor: undefined   // Use callback and return this exact value
+                                            , age     : function age () { return 47 } 
+                                            , height  : 176
+                                            , sizes : [12,33,12,21]
+                                        }
+                                };
+
+                    function checkNull ({ value, resolve }) {
+                                resolve ( value ) 
+                        } // checkNull func.
+
+                    walk ({ data:x, keyCallback:checkNull })
+                        .then ( r => {
+                                expect ( r.props.age() ).to.be.equal ( 47 )
+                                done ()
+                            })
+            }) // it Copy a function
       
 }) // describe
 

package/test/03-objectCallback.test.js

@@ -240,7 +240,61 @@ describe ( 'Walk-async -> objectCallback function', () => {
                           expect ( r.length ).to.be.equal ( 1 )
                           expect ( r[0]     ).to.be.equal ( 5 )
                     })
-      }) // it Prevent array empty items 2
+          }) // it Prevent array empty items 2
+
+
+
+      it ( 'Set a object to NULL', done => {
+                 let 
+                    x = {
+                              ls   : [ 1,2,3 ]
+                            , name : 'Peter'
+                            , props : {
+                                          eyeColor: 'blue'
+                                        , age     : 47
+                                        , height  : 176
+                                        , sizes : [12,33,12,21]
+                                    }
+                            };
+                  
+                  function objToNull ({value,key, resolve }) {
+                            if ( key === 'props' )   resolve ( null )
+                            else                     resolve (value)
+                      } // objToNull func.
+
+                  walk ({ data:x, objectCallback:objToNull })
+                      .then ( r => {
+                                  expect ( r.props ).to.be.equal ( null )
+                                  done ()
+                          })
+          }) // it Set a object to NULL
+
+
+
+      it ( 'Set a object to undefined', done => {
+                 let 
+                    x = {
+                              ls   : [ 1,2,3 ]
+                            , name : 'Peter'
+                            , props : {
+                                          eyeColor: 'blue'
+                                        , age     : 47
+                                        , height  : 176
+                                        , sizes : [12,33,12,21]
+                                    }
+                            };
+                  
+                  function objToNull ({value,key, resolve }) {
+                            if ( key === 'props' )   resolve ( undefined )
+                            else                     resolve ( value ) 
+                      } // objToNull func.
+
+                  walk ({ data:x, objectCallback:objToNull })
+                    .then ( r => {
+                                expect ( r.props ).to.be.equal ( undefined )
+                                done ()
+                          })
+          }) // it Set a object to undefined
 
 
       

package/test/05-bothCallbacks.test.js

@@ -0,0 +1,56 @@
+"use strict"
+
+const
+      chai = require ( 'chai' )
+    , expect = chai.expect
+    , walk = require ( '../src/main.js' )
+    ;
+
+
+describe ( 'Walk-async -> Both callbacks together', () => {
+
+    it ( 'Modify on object and key callback level', () => {
+                let 
+                    x = {
+                              ls   : [ 1,2,3 ]
+                            , name : 'Peter'
+                            , props : {
+                                          eyeColor: 'blue'
+                                        , age     : 47
+                                        , height  : 176
+                                        , sizes : [12,33,12,21]
+                                    }
+                            }
+                  ;
+                
+                function keysModifier ({value, key, resolve, reject }) {
+                                if ( key === 'age')             reject ()  // remove 'age'
+                                else if ( key=== 'eyeColor' )   resolve ( 'xxx' ) 
+                                else                            resolve ( value )
+                        }
+
+                function objectModifier ({value, key, resolve }) {
+                                if ( key === 'props' ) {
+                                        const { sizes, ... others } = value  // remove 'sizes'
+                                        resolve ( others )
+                                    }
+                                else    resolve ( value )
+                        }
+
+
+                walk ({
+                          data : x
+                        , keyCallback : keysModifier
+                        , objectCallback : objectModifier
+                        })
+                  .then ( r => {
+                                        expect ( r.props ).to.not.have.property ( 'age' )
+                                        expect ( r.props ).to.not.have.property ( 'sizes' )
+                                        expect ( r.props.eyeColor ).to.be.equal ( 'xxx' )
+                        })
+       })  // it Modify on object and key callback level
+
+      
+}) // describe
+
+

package/dist/walk-async.min.js

@@ -1 +0,0 @@
-var walk;(()=>{var e={406:e=>{"use strict";function n(){let e,n;const t=new Promise(((o,t)=>{e=o,n=t}));return{promise:t,done:e,cancel:n,onComplete:o(t)}}function o(e){return function(n){e.then((e=>n(e)))}}e.exports=function(e){let t,r=!1;return e?(t=function(e){let t=e.map((e=>n())),r=t.map((e=>e.promise));return t.promises=r,t.onComplete=o(Promise.all(r)),t}(e),r=!0):t=n(),t.timeout=function(e,n){let t;return t=e?Promise.all(n.promises):n.promise,function(e,r){let l,s=new Promise(((n,o)=>{l=setTimeout((()=>{n(r),Promise.resolve(t)}),e)}));return t.then((()=>clearTimeout(l))),n.onComplete=o(Promise.race([t,s])),n}}(r,t),t}},880:(e,n,o)=>{const t=o(406);async function r(e,n,o){for await(const n of e)await n.next();o.done(n)}function l(e){return null==e||"boolean"==typeof e?"simple":e instanceof Array?"array":"object"==typeof e?"object":"simple"}async function*s(e,n,o,t,r){yield await a(e,n,o,t,r)}function a(e,n,o,r,a){let[i,c]=r,u=Object.keys(e),p=t(u),m=t();return u.forEach(((u,m)=>{let f=l(e[u]),d=e[u],$="simple"!==f&&null!=c,y=t(),b=t(),v=t(),h="array"===l(n),k=!isNaN(u);$?c({resolve:y.done,reject:()=>y.done(null),value:d,key:u,breadcrumbs:`${a}/${u}`}):y.done("$$cancel"),y.onComplete((e=>{if("$$cancel"!==e||null!=d)if("$$cancel"!==e&&(d=e,f=l(d)),null!=d)if("simple"===f){if(!i)return void b.done("$$noUpdates");i({resolve:b.done,reject:()=>b.done(null),value:d,key:u,breadcrumbs:`${a}/${u}`})}else b.done("$$cancel");else p[m].done();else b.done("$$noUpdates")})),b.onComplete((e=>{if(null!=e)if("$$cancel"!==e){if("$$noUpdates"!==e&&(d=e,f=l(d)),"simple"===f){const e=function(e,n){return n instanceof Array&&!isNaN(e)}(u,n);return e?n.push(d):n[u]=d,void p[m].done("key")}v.done()}else v.done();else p[m].done("nulls")})),v.onComplete((()=>{if("object"===f){const e={};h&&k?n.push(e):n[u]=e,o.push(s(d,e,o,r,`${a}/${u}`)),p[m].done("object")}if("array"===f){const e=[];h&&k?n.push(e):n[u]=e,o.push(s(d,e,o,r,`${a}/${u}`)),p[m].done("array")}}))})),p.onComplete((e=>m.done())),m.promise}e.exports=function(e){let n,{data:o,objectCallback:s=null,keyCallback:i=null}=e,c=l(o),u=[],p="root",m=[i,s],f=t();switch(c){case"array":n=[],a(o,n,u,m,p).then((()=>r(u,n,f)));break;case"object":n={},a(o,n,u,m,p).then((()=>{r(u,n,f)}));break;case"simple":f.done(o)}return f.promise}}},n={},o=function o(t){var r=n[t];if(void 0!==r)return r.exports;var l=n[t]={exports:{}};return e[t](l,l.exports,o),l.exports}(880);walk=o})();

package/webpack.config.js

@@ -1,26 +0,0 @@
-'use strict';
-
-module.exports = {
-      entry: './src/main.js'
-    , mode: 'production'
-    , output: {
-              filename: "walk-async.min.js"
-            , path: __dirname + "/dist"
-            , library: 'walk'
-            , libraryTarget: "var"
-            , umdNamedDefine : true
-       }
-    , optimization: {}
-    , module: {
-          rules: [
-                  {
-                        test: /\.js$/
-                      , exclude: /node_modules/
-                      , use : { 
-                            loader: 'babel-loader'
-                          , options : { presets: ['@babel/preset-env']}
-                        }
-                    }
-                ]
-        }
-}