@builder.io/sdk-react 0.4.5 → 0.5.0

package/dist/functions/apply-patch-with-mutation.d.ts

@@ -0,0 +1,10 @@
+export type Patch = {
+    path: string;
+    op: 'add' | 'remove' | 'replace';
+    value: any;
+};
+export declare const applyPatchWithMinimalMutationChain: <T extends object>(obj: T, patch: {
+    path: string;
+    op: 'add' | 'remove' | 'replace';
+    value: any;
+}, preserveRoot?: boolean) => T;

package/dist/functions/apply-patch-with-mutation.js

@@ -0,0 +1,54 @@
+export const applyPatchWithMinimalMutationChain = (obj, patch, preserveRoot = false) => {
+    if (Object(obj) !== obj) {
+        return obj;
+    }
+    const { path, op, value } = patch;
+    const pathArr = path.split(/\//);
+    if (pathArr[0] === '') {
+        pathArr.shift();
+    }
+    const newObj = preserveRoot ? obj : {
+        ...obj
+    };
+    let objPart = newObj;
+    for (let i = 0; i < pathArr.length; i++) {
+        const isLast = i === pathArr.length - 1;
+        const property = pathArr[i];
+        if (isLast) {
+            if (op === 'replace') {
+                objPart[property] = value;
+            }
+            else if (op === 'add') {
+                const index = Number(property);
+                if (Array.isArray(objPart)) {
+                    if (property === '-') {
+                        objPart.push(value);
+                    }
+                    else {
+                        objPart.splice(index, 0, value);
+                    }
+                }
+                else {
+                    objPart[property] = value;
+                }
+            }
+            else if (op === 'remove') {
+                const index = Number(property);
+                if (Array.isArray(objPart)) {
+                    objPart.splice(index, 1);
+                }
+                else {
+                    delete objPart[property];
+                }
+            }
+        }
+        else {
+            const nextProperty = pathArr[i + 1];
+            const newPart = Object(objPart[property]) === objPart[property] ? objPart[property] : String(Number(nextProperty)) === nextProperty ? [] : {};
+            objPart = objPart[property] = Array.isArray(newPart) ? [...newPart] : {
+                ...newPart
+            };
+        }
+    }
+    return newObj;
+};

package/dist/functions/apply-patch-with-mutation.test.js

@@ -0,0 +1,53 @@
+import { applyPatchWithMinimalMutationChain } from './apply-patch-with-mutation.js';
+describe('applyPatchWithMinimalMutationChain', () => {
+    test('Basic shallow update', () => {
+        const obj = {
+            foo: 'bar'
+        };
+        const patch = {
+            op: 'replace',
+            path: '/foo',
+            value: '60px'
+        };
+        const applied = applyPatchWithMinimalMutationChain(obj, patch);
+        expect(applied.foo).toBe('60px');
+        expect(applied).not.toBe(obj);
+    });
+    test('Deep object updates', () => {
+        const obj = {
+            foo: {
+                bar: true
+            },
+            baz: {}
+        };
+        const patch = {
+            op: 'replace',
+            path: '/foo/bar',
+            value: '60px'
+        };
+        const applied = applyPatchWithMinimalMutationChain(obj, patch);
+        expect(applied.foo.bar).toBe('60px');
+        expect(applied).not.toBe(obj);
+        expect(applied.foo).not.toBe(obj.foo);
+        expect(applied.baz).toBe(obj.baz);
+    });
+    test('Deep array updates', () => {
+        const obj = {
+            foo: [{
+                    bar: true
+                }],
+            baz: {}
+        };
+        const patch = {
+            op: 'replace',
+            path: '/foo/0/bar',
+            value: '60px'
+        };
+        const applied = applyPatchWithMinimalMutationChain(obj, patch);
+        expect(applied.foo[0].bar).toBe('60px');
+        expect(applied).not.toBe(obj);
+        expect(applied.foo).not.toBe(obj.foo);
+        expect(applied.foo[0]).not.toBe(obj.foo[0]);
+        expect(applied.baz).toBe(obj.baz);
+    });
+});