@arrai-innovations/reactive-helpers 2.3.4 → 2.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@arrai-innovations/reactive-helpers",
-    "version": "2.3.4",
+    "version": "2.5.0",
     "description": "VueJS 3 utility composition functions to help manipulate objects and lists.",
     "main": "index.js",
     "directories": {

package/tests/unit/utils/flattenPaths.spec.js

@@ -0,0 +1,118 @@
+import { flattenPaths } from "../../../utils/flattenPaths";
+
+describe("utils/flattenPaths", () => {
+    describe("flattenPaths", () => {
+        describe("should work on objects as the base", () => {
+            it("with a single level", () => {
+                expect(flattenPaths({ a: 1, b: 2 })).toEqual(["a", "b"]);
+            });
+            it("with a single level and a nested object", () => {
+                expect(flattenPaths({ a: 1, b: { c: 2 } })).toEqual(["a", "b.c"]);
+            });
+            it("with a single level and a nested array", () => {
+                expect(flattenPaths({ a: 1, b: [2] })).toEqual(["a", "b[0]"]);
+            });
+            it("with a single level and a nested object and array", () => {
+                expect(flattenPaths({ a: 1, b: { c: [2] } })).toEqual(["a", "b.c[0]"]);
+            });
+        });
+        describe("should work on arrays as the base", () => {
+            it("with a single level", () => {
+                expect(flattenPaths([1, 2])).toEqual(["[0]", "[1]"]);
+            });
+            it("with a single level and a nested object", () => {
+                expect(flattenPaths([1, { c: 2 }])).toEqual(["[0]", "[1].c"]);
+            });
+            it("with a single level and a nested array", () => {
+                expect(flattenPaths([1, [2]])).toEqual(["[0]", "[1][0]"]);
+            });
+            it("with a single level and a nested object and array", () => {
+                expect(flattenPaths([1, { c: [2] }])).toEqual(["[0]", "[1].c[0]"]);
+            });
+        });
+        it("should work on a real world example", () => {
+            const toBeFlattened = {
+                id: 1,
+                name: "test",
+                description: "test",
+                type: "test",
+                status: {
+                    id: 1,
+                    code: "test",
+                    name: "test",
+                },
+                products: [
+                    {
+                        id: 1,
+                        name: "test",
+                        description: "test",
+                        categories: [
+                            {
+                                id: 1,
+                                name: "test",
+                                description: "test",
+                            },
+                            {
+                                id: 2,
+                                name: "test2",
+                                description: "test2",
+                            },
+                        ],
+                        price: "$1.00",
+                        regularPrice: "$1.00",
+                    },
+                    {
+                        id: 2,
+                        name: "test2",
+                        description: "test2",
+                        categories: [
+                            {
+                                id: 3,
+                                name: "test3",
+                                description: "test3",
+                            },
+                            {
+                                id: 4,
+                                name: "test4",
+                                description: "test4",
+                            },
+                        ],
+                        price: "$2.00",
+                        regularPrice: "$2.00",
+                    },
+                ],
+            };
+            expect(flattenPaths(toBeFlattened)).toEqual([
+                "id",
+                "name",
+                "description",
+                "type",
+                "status.id",
+                "status.code",
+                "status.name",
+                "products[0].id",
+                "products[0].name",
+                "products[0].description",
+                "products[0].categories[0].id",
+                "products[0].categories[0].name",
+                "products[0].categories[0].description",
+                "products[0].categories[1].id",
+                "products[0].categories[1].name",
+                "products[0].categories[1].description",
+                "products[0].price",
+                "products[0].regularPrice",
+                "products[1].id",
+                "products[1].name",
+                "products[1].description",
+                "products[1].categories[0].id",
+                "products[1].categories[0].name",
+                "products[1].categories[0].description",
+                "products[1].categories[1].id",
+                "products[1].categories[1].name",
+                "products[1].categories[1].description",
+                "products[1].price",
+                "products[1].regularPrice",
+            ]);
+        });
+    });
+});

package/utils/flattenPaths.js

@@ -0,0 +1,28 @@
+import { isArray, isObject } from "lodash";
+
+export function flattenPaths(arrayOrObject, currentPath = "") {
+    // arrayOrObject keys or indexes values can be objects or arrays.
+    // find all paths you could use lodash to "get()" to.
+    // indexes use `[${index}]`, keys use `.${key}`
+    // first level should not include a leading ".", `[${index}]` or `${key}` is fine.
+    const paths = [];
+    const keysOrIndexes = isArray(arrayOrObject);
+    const dotOrNot = currentPath ? "." : "";
+    if (isObject(arrayOrObject)) {
+        Object.keys(arrayOrObject).forEach((key) => {
+            const value = arrayOrObject[key];
+            const keyPath = keysOrIndexes ? `[${key}]` : `${dotOrNot}${key}`;
+            if (isObject(value) || isArray(value)) {
+                paths.push(...flattenPaths(value, `${currentPath}${keyPath}`));
+            } else {
+                paths.push(`${currentPath}${keyPath}`);
+            }
+        });
+    } else {
+        // values
+        if (currentPath) {
+            paths.push(currentPath);
+        }
+    }
+    return paths;
+}

package/utils/getFakeId.js

@@ -1,12 +1,17 @@
-import { isArray } from "lodash";
+import { isArray, isSet } from "lodash";
 
-export function getFakeId(arrayOrObject, key = "id") {
+export function getFakeId(arraySetOrObject, key = "id") {
+    // sets are assumed to be of ids
+    // arrays are assumed to be objects with an property matching the passed key
+    // objects are assumed to have keys that are ids
     let fakeId;
     let test;
-    if (isArray(arrayOrObject)) {
-        test = () => arrayOrObject.some((item) => item[key] === fakeId);
+    if (isSet(arraySetOrObject)) {
+        test = () => arraySetOrObject.has(fakeId);
+    } else if (isArray(arraySetOrObject)) {
+        test = () => arraySetOrObject.some((item) => item[key] === fakeId);
     } else {
-        test = () => fakeId in arrayOrObject;
+        test = () => fakeId in arraySetOrObject;
     }
     do {
         fakeId = Math.floor(Math.random() * Number.MIN_SAFE_INTEGER);

package/utils/index.js

@@ -1,5 +1,6 @@
 export * from "./assignReactiveObject";
 export * from "./cancellableIntent";
+export * from "./flattenPaths";
 export * from "./getFakeId";
 export * from "./keyDiff";
 export * from "./set";