@eramux/rekey - npm Package Compare versions

Comparing version 0.0.11 to 0.0.12

dist/rekey.d.ts

@@ -1,9 +0,9 @@
-declare type KeyTraversalCallback = (workingObject: RekeyObject, currentSelector: string) => Boolean;
+declare type KeyTraversalCallback = (workingObject: RekeyObject, currentSelector: string) => void;
 export interface RekeyObject {
     [key: string]: any;
 }
-export declare function recursiveRename(workingObject: RekeyObject, selector: Array<string>, value: string): Boolean;
-export declare function recursiveDelete(workingObject: RekeyObject, selector: Array<string>): Boolean;
-export declare function recursiveKeyTraversal(workingObject: RekeyObject, selector: Array<string>, callback: KeyTraversalCallback): Boolean;
+export declare function recursiveRename(workingObject: RekeyObject, selector: Array<string>, value: string): void;
+export declare function recursiveDelete(workingObject: RekeyObject, selector: Array<string>): void;
+export declare function recursiveKeyTraversal(workingObject: RekeyObject, selectors: Array<string>, callback: KeyTraversalCallback): void;
 export {};
 //# sourceMappingURL=rekey.d.ts.map

dist/rekey.js

@@ -5,6 +5,5 @@ "use strict";
 function recursiveRename(workingObject, selector, value) {
-    return recursiveKeyTraversal(workingObject, selector, (object, currentSelector) => {
+    recursiveKeyTraversal(workingObject, selector, (object, currentSelector) => {
         object[value] = object[currentSelector];
         delete object[currentSelector];
-        return true;
     });
@@ -14,52 +13,45 @@ }
 function recursiveDelete(workingObject, selector) {
-    return recursiveKeyTraversal(workingObject, selector, (object, currentSelector) => {
+    recursiveKeyTraversal(workingObject, selector, (object, currentSelector) => {
         delete object[currentSelector];
-        return true;
     });
 }
 exports.recursiveDelete = recursiveDelete;
-function recursiveKeyTraversal(workingObject, selector, callback) {
-    let currentSelector = selector[0];
-    if (selector.length > 1) {
-        if (workingObject.hasOwnProperty(currentSelector)) {
-            if (workingObject[currentSelector] == null) {
-                return false;
-            }
-            else if (workingObject[currentSelector] instanceof Array) {
-                let restSelector = selector.slice(1);
-                workingObject[currentSelector] = workingObject[currentSelector].map((item) => {
-                    if (item == null) {
-                        return item;
-                    }
-                    else if (item instanceof Object) {
-                        recursiveKeyTraversal(item, restSelector, callback);
-                    }
-                    else {
-                        return item;
-                    }
-                    return item;
-                });
-            }
-            else if (workingObject[currentSelector] instanceof Object) {
-                return recursiveKeyTraversal(workingObject[currentSelector], selector.slice(1), callback);
-            }
-            else {
-                return false;
-            }
+function recursiveKeyTraversal(workingObject, selectors, callback) {
+    let currentSelector = selectors[0];
+    let remainingSelectors = selectors.slice(1);
+    if (selectors.length <= 1) {
+        if (workingObject instanceof Array && workingObject !== null) {
+            workingObject = workingObject.map((item) => {
+                if (item instanceof Object && item !== null) {
+                    recursiveKeyTraversal(item, selectors, callback);
+                }
+                return item;
+            });
+            return;
         }
-        else {
-            return false;
-        }
-    }
-    else {
-        if (workingObject.hasOwnProperty(currentSelector)) {
+        if (workingObject instanceof Object && workingObject !== null) {
             return callback(workingObject, currentSelector);
         }
-        else {
-            return false;
-        }
     }
-    return false;
+    if (!workingObject.hasOwnProperty(currentSelector)) {
+        return;
+    }
+    let currentElement = workingObject[currentSelector];
+    if (currentElement === null) {
+        return;
+    }
+    if (currentElement instanceof Array) {
+        currentElement = currentElement.map((item) => {
+            if (item instanceof Object && item !== null) {
+                recursiveKeyTraversal(item, remainingSelectors, callback);
+            }
+            return item;
+        });
+        return;
+    }
+    if (currentElement instanceof Object) {
+        recursiveKeyTraversal(currentElement, remainingSelectors, callback);
+    }
 }
 exports.recursiveKeyTraversal = recursiveKeyTraversal;
 //# sourceMappingURL=rekey.js.map

package.json

 {
   "name": "@eramux/rekey",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "description": "A simple and performant library to rename object keys",
@@ -5,0 +5,0 @@ "main": "dist/index.js",

No alert changes

Worsened metrics

Total package byte prevSize

20812

decreased by-1.29%

Lines of code

347

decreased by-2.25%

No dependency changes