@krainovsd/js-helpers 0.16.4 → 0.16.5

package/lib/cjs/index.cjs

@@ -6,8 +6,6 @@ const dayjs = require('dayjs');
 const todayPlugin = require('dayjs/plugin/isToday');
 const tomorrowPlugin = require('dayjs/plugin/isTomorrow');
 const yesterdayPlugin = require('dayjs/plugin/isYesterday');
-const get = require('lodash/get');
-const set = require('lodash/set');
 
 class ResponseError extends Error {
     status;
@@ -347,21 +345,185 @@ function arrayToMapByKey(array, key) {
     return map;
 }
 
+/* eslint-disable max-depth */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const startArray$1 = "[".codePointAt(0);
+const endArray$1 = "]".codePointAt(0);
+const separator$1 = ".".codePointAt(0);
+const numbers$1 = new Set(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"].map((n) => n.codePointAt(0)));
 function getByPath(data, path, defaultValue) {
-    if ((!isObject(data) && !isArray(data)) || !isString(path))
+    if (!isString(path) || (!isObject(data) && !isArray(data)))
         return defaultValue;
-    return get(data, path, defaultValue);
+    let cursor = 0;
+    let pathStart = 0;
+    let arrayPathStart = -1;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let extractedData = data;
+    try {
+        while (cursor < path.length) {
+            const char = path.codePointAt(cursor);
+            if (char === separator$1) {
+                arrayPathStart = -1;
+                if (pathStart === cursor) {
+                    pathStart++;
+                }
+                else {
+                    if (extractedData == undefined || typeof extractedData !== "object")
+                        return defaultValue;
+                    extractedData = extractedData[path.slice(pathStart, cursor)];
+                    pathStart = cursor + 1;
+                }
+                /** start array path if not started yet */
+            }
+            else if (char === startArray$1 && arrayPathStart === -1) {
+                arrayPathStart = cursor;
+                /** end array if its started min 2 char ago */
+            }
+            else if (char === endArray$1 && arrayPathStart !== -1 && cursor - arrayPathStart > 1) {
+                /** before array was an object path */
+                if (pathStart < arrayPathStart) {
+                    if (extractedData == undefined || typeof extractedData !== "object")
+                        return defaultValue;
+                    extractedData = extractedData[path.slice(pathStart, arrayPathStart)];
+                }
+                const index = +path.slice(arrayPathStart + 1, cursor);
+                if (!Array.isArray(extractedData))
+                    return defaultValue;
+                extractedData = extractedData[index];
+                arrayPathStart = -1;
+                pathStart = cursor + 1;
+                /** if array started but char is not number */
+            }
+            else if (arrayPathStart !== -1 && !numbers$1.has(char)) {
+                arrayPathStart = -1;
+            }
+            cursor++;
+        }
+        if (pathStart < path.length) {
+            if (extractedData == undefined || typeof extractedData !== "object")
+                return defaultValue;
+            extractedData = extractedData[path.slice(pathStart, cursor)];
+        }
+    }
+    catch {
+        return defaultValue;
+    }
+    if (extractedData === undefined) {
+        return defaultValue;
+    }
+    return extractedData;
 }
 
-function setByPath(data, path, value) {
+/* eslint-disable max-depth */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-non-null-assertion */
+const startArray = "[".codePointAt(0);
+const endArray = "]".codePointAt(0);
+const separator = ".".codePointAt(0);
+const numbers = new Set(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"].map((n) => n.codePointAt(0)));
+function setByPath(data, path, settableValue) {
+    if (!isString(path) || (!isObject(data) && !isArray(data)))
+        return false;
+    let cursor = 0;
+    let pathStart = 0;
+    let arrayPathStart = -1;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let extractedData = data;
+    let prevPath;
     try {
-        if (!isObject(data) && !isArray(data))
-            throw new Error("bad data");
-        set(data, path, value);
+        while (cursor < path.length) {
+            const char = path.codePointAt(cursor);
+            /** get */
+            if (char === separator) {
+                arrayPathStart = -1;
+                if (pathStart === cursor) {
+                    pathStart++;
+                }
+                else {
+                    if (prevPath) {
+                        const object = {};
+                        extractedData[prevPath] = object;
+                        extractedData = object;
+                    }
+                    if (cursor === path.length - 1) {
+                        extractedData[path.slice(pathStart, cursor)] = settableValue;
+                    }
+                    else {
+                        const currentPath = path.slice(pathStart, cursor);
+                        const extractedValue = extractedData[currentPath];
+                        if (extractedValue == undefined) {
+                            prevPath = currentPath;
+                        }
+                        else {
+                            extractedData = extractedValue;
+                        }
+                        pathStart = cursor + 1;
+                    }
+                }
+                /** start array path if not started yet */
+            }
+            else if (char === startArray && arrayPathStart === -1) {
+                arrayPathStart = cursor;
+                /** end array if its started min 2 char ago */
+            }
+            else if (char === endArray && arrayPathStart !== -1 && cursor - arrayPathStart > 1) {
+                /** before array was an object path */
+                if (pathStart < arrayPathStart) {
+                    if (prevPath) {
+                        const object = {};
+                        extractedData[prevPath] = object;
+                        extractedData = object;
+                    }
+                    const currentPath = path.slice(pathStart, arrayPathStart);
+                    const extractedValue = extractedData[currentPath];
+                    if (extractedValue == undefined) {
+                        prevPath = currentPath;
+                    }
+                    else {
+                        extractedData = extractedValue;
+                    }
+                }
+                if (prevPath) {
+                    const array = [];
+                    extractedData[prevPath] = array;
+                    extractedData = array;
+                }
+                const index = +path.slice(arrayPathStart + 1, cursor);
+                if (cursor === path.length - 1) {
+                    extractedData[index] = settableValue;
+                }
+                else {
+                    const extractedValue = extractedData[index];
+                    if (extractedValue == undefined) {
+                        prevPath = index;
+                    }
+                    else {
+                        extractedData = extractedValue;
+                    }
+                }
+                arrayPathStart = -1;
+                pathStart = cursor + 1;
+                /** if array started but char is not number */
+            }
+            else if (arrayPathStart !== -1 && !numbers.has(char)) {
+                arrayPathStart = -1;
+            }
+            cursor++;
+        }
+        if (pathStart < path.length) {
+            if (prevPath) {
+                const object = {};
+                extractedData[prevPath] = object;
+                extractedData = object;
+            }
+            extractedData[path.slice(pathStart, cursor)] = settableValue;
+        }
     }
-    catch (error) {
-        console.warn(error);
+    catch {
+        return false;
     }
+    return true;
 }
 
 function syncObjectValues(oldObj, newObj, exception = []) {
@@ -634,11 +796,11 @@ function speedTest(cb, opts) {
     if (type === "performance") {
         const start = performance.now();
         if (iterations <= 1) {
-            result = cb();
+            result = cb(0);
         }
         else {
             for (let i = 0; i < iterations; i++) {
-                result = cb();
+                result = cb(i);
             }
         }
         const end = performance.now();
@@ -649,11 +811,11 @@ function speedTest(cb, opts) {
         // eslint-disable-next-line no-console
         console.time(name);
         if (iterations <= 1) {
-            result = cb();
+            result = cb(0);
         }
         else {
             for (let i = 0; i < iterations; i++) {
-                result = cb();
+                result = cb(i);
             }
         }
         // eslint-disable-next-line no-console