@payloadcms/plugin-import-export 4.0.0-internal.5b1e7cd → 4.0.0-internal.5d5a2b2

package/dist/utilities/processRichTextField.spec.js

@@ -0,0 +1,308 @@
+import { describe, expect, it } from 'vitest';
+import { processRichTextField } from './processRichTextField.js';
+// Minimal helpers to keep assertions readable
+const asRecord = (v)=>v;
+const asArray = (v)=>v;
+// ─── Fixtures ────────────────────────────────────────────────────────────────
+const textNode = (overrides = {})=>({
+        detail: 0,
+        format: 0,
+        mode: 'normal',
+        text: 'Hello',
+        type: 'text',
+        version: 1,
+        ...overrides
+    });
+const paragraphNode = (children = [
+    textNode()
+])=>({
+        children,
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        type: 'paragraph',
+        version: 1
+    });
+const lexicalDoc = (children = [
+    paragraphNode()
+])=>({
+        children,
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        type: 'root',
+        version: 1
+    });
+// ─── Primitive pass-through ──────────────────────────────────────────────────
+describe('processRichTextField — primitive pass-through', ()=>{
+    it('should return null unchanged', ()=>{
+        expect(processRichTextField(null)).toBeNull();
+    });
+    it('should return undefined unchanged', ()=>{
+        expect(processRichTextField(undefined)).toBeUndefined();
+    });
+    it('should return a number unchanged', ()=>{
+        expect(processRichTextField(42)).toBe(42);
+    });
+    it('should return false unchanged', ()=>{
+        expect(processRichTextField(false)).toBe(false);
+    });
+});
+// ─── String input (the recovered-from-missed-hook path) ─────────────────────
+describe('processRichTextField — JSON string input', ()=>{
+    it('should parse a valid JSON string into an object', ()=>{
+        const doc = lexicalDoc();
+        expect(processRichTextField(JSON.stringify(doc))).toEqual(doc);
+    });
+    it('should return an unparseable string unchanged', ()=>{
+        expect(processRichTextField('not json')).toBe('not json');
+    });
+    it('should return an empty string unchanged', ()=>{
+        expect(processRichTextField('')).toBe('');
+    });
+    it('should parse a string and still convert numeric string properties', ()=>{
+        const node = {
+            type: 'text',
+            detail: '0',
+            format: '3',
+            indent: '0',
+            version: '1',
+            text: 'hi'
+        };
+        const result = asRecord(processRichTextField(JSON.stringify(node)));
+        expect(result.detail).toBe(0);
+        expect(result.format).toBe(3);
+        expect(result.indent).toBe(0);
+        expect(result.version).toBe(1);
+    });
+});
+// ─── Numeric property coercion ───────────────────────────────────────────────
+describe('processRichTextField — numeric property coercion', ()=>{
+    it('should convert detail, format, indent, version from strings to numbers', ()=>{
+        const input = textNode({
+            detail: '0',
+            format: '0',
+            indent: '0',
+            version: '1'
+        });
+        const result = asRecord(processRichTextField(input));
+        expect(result.detail).toBe(0);
+        expect(result.format).toBe(0);
+        expect(result.indent).toBe(0);
+        expect(result.version).toBe(1);
+    });
+    it('should convert start and value from strings to numbers (list/listitem nodes)', ()=>{
+        const listItemNode = {
+            type: 'listitem',
+            start: '1',
+            value: '2',
+            version: '1'
+        };
+        const result = asRecord(processRichTextField(listItemNode));
+        expect(result.start).toBe(1);
+        expect(result.value).toBe(2);
+    });
+    it('should convert textFormat and textStyle from strings to numbers', ()=>{
+        const input = {
+            type: 'text',
+            textFormat: '4',
+            textStyle: '0',
+            version: '1',
+            text: 'x'
+        };
+        const result = asRecord(processRichTextField(input));
+        expect(result.textFormat).toBe(4);
+        expect(result.textStyle).toBe(0);
+    });
+    it('should leave a non-numeric string in a numeric-property slot unchanged', ()=>{
+        // Lexical paragraph format can be "" (empty) or alignment strings
+        const input = paragraphNode();
+        const result = asRecord(processRichTextField(input));
+        expect(result.format).toBe('');
+    });
+    it('should leave already-numeric values unchanged', ()=>{
+        const input = textNode({
+            detail: 0,
+            format: 3,
+            version: 1
+        });
+        const result = asRecord(processRichTextField(input));
+        expect(result.detail).toBe(0);
+        expect(result.format).toBe(3);
+        expect(result.version).toBe(1);
+    });
+    it('should not convert boolean values on numeric-property keys', ()=>{
+        const input = {
+            type: 'custom',
+            format: true,
+            version: '1'
+        };
+        const result = asRecord(processRichTextField(input));
+        expect(result.format).toBe(true);
+        expect(result.version).toBe(1);
+    });
+});
+// ─── Recursive children processing ──────────────────────────────────────────
+describe('processRichTextField — recursive children', ()=>{
+    it('should recursively convert numeric strings inside children arrays', ()=>{
+        const input = paragraphNode([
+            textNode({
+                detail: '0',
+                format: '0',
+                version: '1'
+            })
+        ]);
+        const result = asRecord(processRichTextField(input));
+        const child = asRecord(asArray(result.children)[0]);
+        expect(child.detail).toBe(0);
+        expect(child.format).toBe(0);
+        expect(child.version).toBe(1);
+    });
+    it('should handle three levels of nesting (root → paragraph → text)', ()=>{
+        const input = lexicalDoc([
+            paragraphNode([
+                textNode({
+                    version: '1',
+                    format: '2'
+                })
+            ])
+        ]);
+        const result = asRecord(processRichTextField(input));
+        const paragraph = asRecord(asArray(result.children)[0]);
+        const text = asRecord(asArray(paragraph.children)[0]);
+        expect(text.version).toBe(1);
+        expect(text.format).toBe(2);
+    });
+    it('should handle multiple children at the same level', ()=>{
+        const input = lexicalDoc([
+            paragraphNode([
+                textNode({
+                    text: 'Bold',
+                    format: '1'
+                }),
+                textNode({
+                    text: ' normal',
+                    format: '0'
+                })
+            ]),
+            paragraphNode([
+                textNode({
+                    text: 'Second para',
+                    version: '1'
+                })
+            ])
+        ]);
+        const result = asRecord(processRichTextField(input));
+        const firstPara = asRecord(asArray(result.children)[0]);
+        const secondPara = asRecord(asArray(result.children)[1]);
+        const bold = asRecord(asArray(firstPara.children)[0]);
+        const normal = asRecord(asArray(firstPara.children)[1]);
+        const secondText = asRecord(asArray(secondPara.children)[0]);
+        expect(bold.format).toBe(1);
+        expect(normal.format).toBe(0);
+        expect(secondText.version).toBe(1);
+    });
+    it('should skip null and non-object entries in children without throwing', ()=>{
+        const input = {
+            type: 'root',
+            version: 1,
+            children: [
+                null,
+                undefined,
+                'stray',
+                textNode()
+            ]
+        };
+        const result = asRecord(processRichTextField(input));
+        const children = asArray(result.children);
+        expect(children[0]).toBeNull();
+        expect(children[1]).toBeUndefined();
+        expect(children[2]).toBe('stray');
+        expect(asRecord(children[3]).type).toBe('text');
+    });
+});
+// ─── Nested non-children objects ─────────────────────────────────────────────
+describe('processRichTextField — nested non-children objects', ()=>{
+    it('should recurse into plain nested objects (e.g. decorator node data)', ()=>{
+        const input = {
+            type: 'decorator',
+            version: '1',
+            data: {
+                detail: '2',
+                label: 'keep me'
+            }
+        };
+        const result = asRecord(processRichTextField(input));
+        const data = asRecord(result.data);
+        expect(result.version).toBe(1);
+        expect(data.detail).toBe(2);
+        expect(data.label).toBe('keep me');
+    });
+});
+// ─── Full Lexical document round-trips ───────────────────────────────────────
+describe('processRichTextField — full document', ()=>{
+    it('should produce a stable result when called on an already-processed object', ()=>{
+        const doc = lexicalDoc();
+        const firstPass = processRichTextField(doc);
+        const secondPass = processRichTextField(firstPass);
+        expect(secondPass).toEqual(firstPass);
+    });
+    it('should fully round-trip a complex Lexical document serialised to JSON', ()=>{
+        const doc = lexicalDoc([
+            paragraphNode([
+                textNode({
+                    text: 'Bold',
+                    format: '1',
+                    detail: '0',
+                    indent: '0',
+                    version: '1'
+                }),
+                textNode({
+                    text: ' normal',
+                    format: '0',
+                    version: '1'
+                })
+            ]),
+            {
+                type: 'list',
+                listType: 'number',
+                start: '1',
+                version: '1',
+                indent: '0',
+                direction: 'ltr',
+                children: [
+                    {
+                        type: 'listitem',
+                        value: '1',
+                        detail: '0',
+                        format: '0',
+                        version: '1',
+                        text: 'Item A'
+                    },
+                    {
+                        type: 'listitem',
+                        value: '2',
+                        detail: '0',
+                        format: '0',
+                        version: '1',
+                        text: 'Item B'
+                    }
+                ]
+            }
+        ]);
+        const result = asRecord(processRichTextField(JSON.stringify(doc)));
+        const para = asRecord(asArray(result.children)[0]);
+        const boldText = asRecord(asArray(para.children)[0]);
+        expect(boldText.format).toBe(1);
+        expect(boldText.detail).toBe(0);
+        const list = asRecord(asArray(result.children)[1]);
+        expect(list.start).toBe(1);
+        expect(list.indent).toBe(0);
+        const itemA = asRecord(asArray(list.children)[0]);
+        const itemB = asRecord(asArray(list.children)[1]);
+        expect(itemA.value).toBe(1);
+        expect(itemB.value).toBe(2);
+    });
+});
+
+//# sourceMappingURL=processRichTextField.spec.js.map

package/dist/utilities/processRichTextField.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utilities/processRichTextField.spec.ts"],"sourcesContent":["import { describe, expect, it } from 'vitest'\n\nimport { processRichTextField } from './processRichTextField.js'\n\n// Minimal helpers to keep assertions readable\nconst asRecord = (v: unknown) => v as Record<string, unknown>\nconst asArray = (v: unknown) => v as unknown[]\n\n// ─── Fixtures ────────────────────────────────────────────────────────────────\n\nconst textNode = (overrides: Record<string, unknown> = {}) => ({\n  detail: 0,\n  format: 0,\n  mode: 'normal',\n  text: 'Hello',\n  type: 'text',\n  version: 1,\n  ...overrides,\n})\n\nconst paragraphNode = (children: unknown[] = [textNode()]) => ({\n  children,\n  direction: 'ltr',\n  format: '',\n  indent: 0,\n  type: 'paragraph',\n  version: 1,\n})\n\nconst lexicalDoc = (children: unknown[] = [paragraphNode()]) => ({\n  children,\n  direction: 'ltr',\n  format: '',\n  indent: 0,\n  type: 'root',\n  version: 1,\n})\n\n// ─── Primitive pass-through ──────────────────────────────────────────────────\n\ndescribe('processRichTextField — primitive pass-through', () => {\n  it('should return null unchanged', () => {\n    expect(processRichTextField(null)).toBeNull()\n  })\n\n  it('should return undefined unchanged', () => {\n    expect(processRichTextField(undefined)).toBeUndefined()\n  })\n\n  it('should return a number unchanged', () => {\n    expect(processRichTextField(42)).toBe(42)\n  })\n\n  it('should return false unchanged', () => {\n    expect(processRichTextField(false)).toBe(false)\n  })\n})\n\n// ─── String input (the recovered-from-missed-hook path) ─────────────────────\n\ndescribe('processRichTextField — JSON string input', () => {\n  it('should parse a valid JSON string into an object', () => {\n    const doc = lexicalDoc()\n    expect(processRichTextField(JSON.stringify(doc))).toEqual(doc)\n  })\n\n  it('should return an unparseable string unchanged', () => {\n    expect(processRichTextField('not json')).toBe('not json')\n  })\n\n  it('should return an empty string unchanged', () => {\n    expect(processRichTextField('')).toBe('')\n  })\n\n  it('should parse a string and still convert numeric string properties', () => {\n    const node = { type: 'text', detail: '0', format: '3', indent: '0', version: '1', text: 'hi' }\n    const result = asRecord(processRichTextField(JSON.stringify(node)))\n    expect(result.detail).toBe(0)\n    expect(result.format).toBe(3)\n    expect(result.indent).toBe(0)\n    expect(result.version).toBe(1)\n  })\n})\n\n// ─── Numeric property coercion ───────────────────────────────────────────────\n\ndescribe('processRichTextField — numeric property coercion', () => {\n  it('should convert detail, format, indent, version from strings to numbers', () => {\n    const input = textNode({ detail: '0', format: '0', indent: '0', version: '1' })\n    const result = asRecord(processRichTextField(input))\n    expect(result.detail).toBe(0)\n    expect(result.format).toBe(0)\n    expect(result.indent).toBe(0)\n    expect(result.version).toBe(1)\n  })\n\n  it('should convert start and value from strings to numbers (list/listitem nodes)', () => {\n    const listItemNode = { type: 'listitem', start: '1', value: '2', version: '1' }\n    const result = asRecord(processRichTextField(listItemNode))\n    expect(result.start).toBe(1)\n    expect(result.value).toBe(2)\n  })\n\n  it('should convert textFormat and textStyle from strings to numbers', () => {\n    const input = { type: 'text', textFormat: '4', textStyle: '0', version: '1', text: 'x' }\n    const result = asRecord(processRichTextField(input))\n    expect(result.textFormat).toBe(4)\n    expect(result.textStyle).toBe(0)\n  })\n\n  it('should leave a non-numeric string in a numeric-property slot unchanged', () => {\n    // Lexical paragraph format can be \"\" (empty) or alignment strings\n    const input = paragraphNode()\n    const result = asRecord(processRichTextField(input))\n    expect(result.format).toBe('')\n  })\n\n  it('should leave already-numeric values unchanged', () => {\n    const input = textNode({ detail: 0, format: 3, version: 1 })\n    const result = asRecord(processRichTextField(input))\n    expect(result.detail).toBe(0)\n    expect(result.format).toBe(3)\n    expect(result.version).toBe(1)\n  })\n\n  it('should not convert boolean values on numeric-property keys', () => {\n    const input = { type: 'custom', format: true, version: '1' }\n    const result = asRecord(processRichTextField(input))\n    expect(result.format).toBe(true)\n    expect(result.version).toBe(1)\n  })\n})\n\n// ─── Recursive children processing ──────────────────────────────────────────\n\ndescribe('processRichTextField — recursive children', () => {\n  it('should recursively convert numeric strings inside children arrays', () => {\n    const input = paragraphNode([textNode({ detail: '0', format: '0', version: '1' })])\n    const result = asRecord(processRichTextField(input))\n    const child = asRecord(asArray(result.children)[0])\n    expect(child.detail).toBe(0)\n    expect(child.format).toBe(0)\n    expect(child.version).toBe(1)\n  })\n\n  it('should handle three levels of nesting (root → paragraph → text)', () => {\n    const input = lexicalDoc([paragraphNode([textNode({ version: '1', format: '2' })])])\n    const result = asRecord(processRichTextField(input))\n    const paragraph = asRecord(asArray(result.children)[0])\n    const text = asRecord(asArray(paragraph.children)[0])\n    expect(text.version).toBe(1)\n    expect(text.format).toBe(2)\n  })\n\n  it('should handle multiple children at the same level', () => {\n    const input = lexicalDoc([\n      paragraphNode([\n        textNode({ text: 'Bold', format: '1' }),\n        textNode({ text: ' normal', format: '0' }),\n      ]),\n      paragraphNode([textNode({ text: 'Second para', version: '1' })]),\n    ])\n    const result = asRecord(processRichTextField(input))\n    const firstPara = asRecord(asArray(result.children)[0])\n    const secondPara = asRecord(asArray(result.children)[1])\n    const bold = asRecord(asArray(firstPara.children)[0])\n    const normal = asRecord(asArray(firstPara.children)[1])\n    const secondText = asRecord(asArray(secondPara.children)[0])\n    expect(bold.format).toBe(1)\n    expect(normal.format).toBe(0)\n    expect(secondText.version).toBe(1)\n  })\n\n  it('should skip null and non-object entries in children without throwing', () => {\n    const input = { type: 'root', version: 1, children: [null, undefined, 'stray', textNode()] }\n    const result = asRecord(processRichTextField(input))\n    const children = asArray(result.children)\n    expect(children[0]).toBeNull()\n    expect(children[1]).toBeUndefined()\n    expect(children[2]).toBe('stray')\n    expect(asRecord(children[3]).type).toBe('text')\n  })\n})\n\n// ─── Nested non-children objects ─────────────────────────────────────────────\n\ndescribe('processRichTextField — nested non-children objects', () => {\n  it('should recurse into plain nested objects (e.g. decorator node data)', () => {\n    const input = {\n      type: 'decorator',\n      version: '1',\n      data: { detail: '2', label: 'keep me' },\n    }\n    const result = asRecord(processRichTextField(input))\n    const data = asRecord(result.data)\n    expect(result.version).toBe(1)\n    expect(data.detail).toBe(2)\n    expect(data.label).toBe('keep me')\n  })\n})\n\n// ─── Full Lexical document round-trips ───────────────────────────────────────\n\ndescribe('processRichTextField — full document', () => {\n  it('should produce a stable result when called on an already-processed object', () => {\n    const doc = lexicalDoc()\n    const firstPass = processRichTextField(doc)\n    const secondPass = processRichTextField(firstPass)\n    expect(secondPass).toEqual(firstPass)\n  })\n\n  it('should fully round-trip a complex Lexical document serialised to JSON', () => {\n    const doc = lexicalDoc([\n      paragraphNode([\n        textNode({ text: 'Bold', format: '1', detail: '0', indent: '0', version: '1' }),\n        textNode({ text: ' normal', format: '0', version: '1' }),\n      ]),\n      {\n        type: 'list',\n        listType: 'number',\n        start: '1',\n        version: '1',\n        indent: '0',\n        direction: 'ltr',\n        children: [\n          { type: 'listitem', value: '1', detail: '0', format: '0', version: '1', text: 'Item A' },\n          { type: 'listitem', value: '2', detail: '0', format: '0', version: '1', text: 'Item B' },\n        ],\n      },\n    ])\n\n    const result = asRecord(processRichTextField(JSON.stringify(doc)))\n\n    const para = asRecord(asArray(result.children)[0])\n    const boldText = asRecord(asArray(para.children)[0])\n    expect(boldText.format).toBe(1)\n    expect(boldText.detail).toBe(0)\n\n    const list = asRecord(asArray(result.children)[1])\n    expect(list.start).toBe(1)\n    expect(list.indent).toBe(0)\n\n    const itemA = asRecord(asArray(list.children)[0])\n    const itemB = asRecord(asArray(list.children)[1])\n    expect(itemA.value).toBe(1)\n    expect(itemB.value).toBe(2)\n  })\n})\n"],"names":["describe","expect","it","processRichTextField","asRecord","v","asArray","textNode","overrides","detail","format","mode","text","type","version","paragraphNode","children","direction","indent","lexicalDoc","toBeNull","undefined","toBeUndefined","toBe","doc","JSON","stringify","toEqual","node","result","input","listItemNode","start","value","textFormat","textStyle","child","paragraph","firstPara","secondPara","bold","normal","secondText","data","label","firstPass","secondPass","listType","para","boldText","list","itemA","itemB"],"mappings":"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"}

package/dist/utilities/removeDisabledFields.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeDisabledFields.d.ts","sourceRoot":"","sources":["../../src/utilities/removeDisabledFields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,oBAAoB,QAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,aAClB,MAAM,EAAE,KACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CA8DxB,CAAA"}
+{"version":3,"file":"removeDisabledFields.d.ts","sourceRoot":"","sources":["../../src/utilities/removeDisabledFields.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,eAAO,MAAM,oBAAoB,GAC/B,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,WAAU,MAAM,EAAO,KACtB,MAAM,CAAC,MAAM,EAAE,OAAO,CA8DxB,CAAA"}

package/dist/utilities/removeDisabledFields.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/removeDisabledFields.ts"],"sourcesContent":["/**\n * Recursively removes fields from a deeply nested object based on dot-notation paths.\n *\n * This utility supports removing:\n * - Nested fields in plain objects (e.g., \"group.value\")\n * - Fields inside arrays of objects (e.g., \"group.array.field1\")\n *\n * It safely traverses both object and array structures and avoids mutating the original input.\n *\n * @param obj - The original object to clean.\n * @param disabled - An array of dot-separated paths indicating which fields to remove.\n * @returns A deep clone of the original object with specified fields removed.\n */\n\nexport const removeDisabledFields = (\n  obj: Record<string, unknown>,\n  disabled: string[] = [],\n): Record<string, unknown> => {\n  if (!disabled.length) {\n    return obj\n  }\n\n  const clone = structuredClone(obj)\n\n  // Process each disabled path independently\n  for (const path of disabled) {\n    const parts = path.split('.')\n\n    /**\n     * Recursively walks the object tree according to the dot path,\n     * and deletes the field once the full path is reached.\n     *\n     * @param target - The current object or array being traversed\n     * @param i - The index of the current path part\n     */\n    const removeRecursively = (target: any, i = 0): void => {\n      if (target == null) {\n        return\n      }\n\n      const key = parts[i]\n\n      // If at the final part of the path, perform the deletion\n      if (i === parts.length - 1) {\n        // If the current level is an array, delete the key from each item\n        if (Array.isArray(target)) {\n          for (const item of target) {\n            if (item && typeof item === 'object' && key !== undefined) {\n              delete item[key as keyof typeof item]\n            }\n          }\n        } else if (typeof target === 'object' && key !== undefined) {\n          delete target[key]\n        }\n        return\n      }\n\n      if (key === undefined) {\n        return\n      }\n\n      // Traverse to the next level in the path\n      const next = target[key]\n\n      if (Array.isArray(next)) {\n        // If the next value is an array, recurse into each item\n        for (const item of next) {\n          removeRecursively(item, i + 1)\n        }\n      } else {\n        // Otherwise, continue down the object path\n        removeRecursively(next, i + 1)\n      }\n    }\n\n    removeRecursively(clone)\n  }\n\n  return clone\n}\n"],"names":["removeDisabledFields","obj","disabled","length","clone","structuredClone","path","parts","split","removeRecursively","target","i","key","Array","isArray","item","undefined","next"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,OAAO,MAAMA,uBAAuB,CAClCC,KACAC,WAAqB,EAAE;IAEvB,IAAI,CAACA,SAASC,MAAM,EAAE;QACpB,OAAOF;IACT;IAEA,MAAMG,QAAQC,gBAAgBJ;IAE9B,2CAA2C;IAC3C,KAAK,MAAMK,QAAQJ,SAAU;QAC3B,MAAMK,QAAQD,KAAKE,KAAK,CAAC;QAEzB;;;;;;KAMC,GACD,MAAMC,oBAAoB,CAACC,QAAaC,IAAI,CAAC;YAC3C,IAAID,UAAU,MAAM;gBAClB;YACF;YAEA,MAAME,MAAML,KAAK,CAACI,EAAE;YAEpB,yDAAyD;YACzD,IAAIA,MAAMJ,MAAMJ,MAAM,GAAG,GAAG;gBAC1B,kEAAkE;gBAClE,IAAIU,MAAMC,OAAO,CAACJ,SAAS;oBACzB,KAAK,MAAMK,QAAQL,OAAQ;wBACzB,IAAIK,QAAQ,OAAOA,SAAS,YAAYH,QAAQI,WAAW;4BACzD,OAAOD,IAAI,CAACH,IAAyB;wBACvC;oBACF;gBACF,OAAO,IAAI,OAAOF,WAAW,YAAYE,QAAQI,WAAW;oBAC1D,OAAON,MAAM,CAACE,IAAI;gBACpB;gBACA;YACF;YAEA,IAAIA,QAAQI,WAAW;gBACrB;YACF;YAEA,yCAAyC;YACzC,MAAMC,OAAOP,MAAM,CAACE,IAAI;YAExB,IAAIC,MAAMC,OAAO,CAACG,OAAO;gBACvB,wDAAwD;gBACxD,KAAK,MAAMF,QAAQE,KAAM;oBACvBR,kBAAkBM,MAAMJ,IAAI;gBAC9B;YACF,OAAO;gBACL,2CAA2C;gBAC3CF,kBAAkBQ,MAAMN,IAAI;YAC9B;QACF;QAEAF,kBAAkBL;IACpB;IAEA,OAAOA;AACT,EAAC"}
+{"version":3,"sources":["../../src/utilities/removeDisabledFields.ts"],"sourcesContent":["/**\n * Recursively removes fields from a deeply nested object based on dot-notation paths.\n *\n * This utility supports removing:\n * - Nested fields in plain objects (e.g., \"group.value\")\n * - Fields inside arrays of objects (e.g., \"group.array.field1\")\n *\n * It safely traverses both object and array structures and avoids mutating the original input.\n *\n * @param obj - The original object to clean.\n * @param disabled - An array of dot-separated paths indicating which fields to remove.\n * @returns A deep clone of the original object with specified fields removed.\n */\n\nexport const removeDisabledFields = (\n  obj: Record<string, unknown>,\n  disabled: string[] = [],\n): Record<string, unknown> => {\n  if (!disabled.length) {\n    return obj\n  }\n\n  const clone = structuredClone(obj)\n\n  // Process each disabled path independently\n  for (const path of disabled) {\n    const parts = path.split('.')\n\n    /**\n     * Recursively walks the object tree according to the dot path,\n     * and deletes the field once the full path is reached.\n     *\n     * @param target - The current object or array being traversed\n     * @param i - The index of the current path part\n     */\n    const removeRecursively = (target: unknown, i = 0): void => {\n      if (target == null) {\n        return\n      }\n\n      const key = parts[i]\n\n      // If at the final part of the path, perform the deletion\n      if (i === parts.length - 1) {\n        // If the current level is an array, delete the key from each item\n        if (Array.isArray(target)) {\n          for (const item of target) {\n            if (item && typeof item === 'object' && key !== undefined) {\n              delete (item as Record<string, unknown>)[key]\n            }\n          }\n        } else if (typeof target === 'object' && key !== undefined) {\n          delete (target as Record<string, unknown>)[key]\n        }\n        return\n      }\n\n      if (key === undefined) {\n        return\n      }\n\n      // Traverse to the next level in the path\n      const next = (target as Record<string, unknown>)[key]\n\n      if (Array.isArray(next)) {\n        // If the next value is an array, recurse into each item\n        for (const item of next) {\n          removeRecursively(item, i + 1)\n        }\n      } else {\n        // Otherwise, continue down the object path\n        removeRecursively(next, i + 1)\n      }\n    }\n\n    removeRecursively(clone)\n  }\n\n  return clone\n}\n"],"names":["removeDisabledFields","obj","disabled","length","clone","structuredClone","path","parts","split","removeRecursively","target","i","key","Array","isArray","item","undefined","next"],"mappings":"AAAA;;;;;;;;;;;;CAYC,GAED,OAAO,MAAMA,uBAAuB,CAClCC,KACAC,WAAqB,EAAE;IAEvB,IAAI,CAACA,SAASC,MAAM,EAAE;QACpB,OAAOF;IACT;IAEA,MAAMG,QAAQC,gBAAgBJ;IAE9B,2CAA2C;IAC3C,KAAK,MAAMK,QAAQJ,SAAU;QAC3B,MAAMK,QAAQD,KAAKE,KAAK,CAAC;QAEzB;;;;;;KAMC,GACD,MAAMC,oBAAoB,CAACC,QAAiBC,IAAI,CAAC;YAC/C,IAAID,UAAU,MAAM;gBAClB;YACF;YAEA,MAAME,MAAML,KAAK,CAACI,EAAE;YAEpB,yDAAyD;YACzD,IAAIA,MAAMJ,MAAMJ,MAAM,GAAG,GAAG;gBAC1B,kEAAkE;gBAClE,IAAIU,MAAMC,OAAO,CAACJ,SAAS;oBACzB,KAAK,MAAMK,QAAQL,OAAQ;wBACzB,IAAIK,QAAQ,OAAOA,SAAS,YAAYH,QAAQI,WAAW;4BACzD,OAAO,AAACD,IAAgC,CAACH,IAAI;wBAC/C;oBACF;gBACF,OAAO,IAAI,OAAOF,WAAW,YAAYE,QAAQI,WAAW;oBAC1D,OAAO,AAACN,MAAkC,CAACE,IAAI;gBACjD;gBACA;YACF;YAEA,IAAIA,QAAQI,WAAW;gBACrB;YACF;YAEA,yCAAyC;YACzC,MAAMC,OAAO,AAACP,MAAkC,CAACE,IAAI;YAErD,IAAIC,MAAMC,OAAO,CAACG,OAAO;gBACvB,wDAAwD;gBACxD,KAAK,MAAMF,QAAQE,KAAM;oBACvBR,kBAAkBM,MAAMJ,IAAI;gBAC9B;YACF,OAAO;gBACL,2CAA2C;gBAC3CF,kBAAkBQ,MAAMN,IAAI;YAC9B;QACF;QAEAF,kBAAkBL;IACpB;IAEA,OAAOA;AACT,EAAC"}

package/dist/utilities/setNestedValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setNestedValue.d.ts","sourceRoot":"","sources":["../../src/utilities/setNestedValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,cAAc,QACpB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QACtB,MAAM,SACL,OAAO,KACb,IA0CF,CAAA"}
+{"version":3,"file":"setNestedValue.d.ts","sourceRoot":"","sources":["../../src/utilities/setNestedValue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,eAAO,MAAM,cAAc,GACzB,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC5B,MAAM,MAAM,EACZ,OAAO,OAAO,KACb,IA8CF,CAAA"}

package/dist/utilities/setNestedValue.js

@@ -27,26 +27,28 @@
             if (!Array.isArray(current)) {
                 current = [];
             }
+            const currentArray = current;
             // Ensure the array slot is initialized
-            if (!current[index]) {
-                current[index] = {};
+            if (!currentArray[index]) {
+                currentArray[index] = {};
             }
             if (isLast) {
-                current[index] = value;
+                currentArray[index] = value;
             } else {
-                current = current[index];
+                current = currentArray[index];
             }
         } else {
+            const currentObj = current;
             // Ensure the object key exists
             if (isLast) {
                 if (typeof part === 'string') {
-                    current[part] = value;
+                    currentObj[part] = value;
                 }
             } else {
-                if (typeof current[part] !== 'object' || current[part] === null) {
-                    current[part] = {};
+                if (typeof currentObj[part] !== 'object' || currentObj[part] === null) {
+                    currentObj[part] = {};
                 }
-                current = current[part];
+                current = currentObj[part];
             }
         }
     }

package/dist/utilities/setNestedValue.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utilities/setNestedValue.ts"],"sourcesContent":["/**\n * Sets a value deeply into a nested object or array, based on a dot-notation path.\n *\n * This function:\n * - Supports array indexing (e.g., \"array.0.field1\")\n * - Creates intermediate arrays/objects as needed\n * - Mutates the target object directly\n *\n * @example\n * const obj = {}\n * setNestedValue(obj, 'group.array.0.field1', 'hello')\n * // Result: { group: { array: [ { field1: 'hello' } ] } }\n *\n * @param obj - The target object to mutate.\n * @param path - A dot-separated string path indicating where to assign the value.\n * @param value - The value to set at the specified path.\n */\n\nexport const setNestedValue = (\n  obj: Record<string, unknown>,\n  path: string,\n  value: unknown,\n): void => {\n  const parts = path.split('.')\n  let current: any = obj\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const isLast = i === parts.length - 1\n    const isIndex = !Number.isNaN(Number(part))\n\n    if (isIndex) {\n      const index = Number(part)\n\n      // Ensure the current target is an array\n      if (!Array.isArray(current)) {\n        current = []\n      }\n\n      // Ensure the array slot is initialized\n      if (!current[index]) {\n        current[index] = {}\n      }\n\n      if (isLast) {\n        current[index] = value\n      } else {\n        current = current[index] as Record<string, unknown>\n      }\n    } else {\n      // Ensure the object key exists\n      if (isLast) {\n        if (typeof part === 'string') {\n          current[part] = value\n        }\n      } else {\n        if (typeof current[part as string] !== 'object' || current[part as string] === null) {\n          current[part as string] = {}\n        }\n\n        current = current[part as string] as Record<string, unknown>\n      }\n    }\n  }\n}\n"],"names":["setNestedValue","obj","path","value","parts","split","current","i","length","part","isLast","isIndex","Number","isNaN","index","Array","isArray"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GAED,OAAO,MAAMA,iBAAiB,CAC5BC,KACAC,MACAC;IAEA,MAAMC,QAAQF,KAAKG,KAAK,CAAC;IACzB,IAAIC,UAAeL;IAEnB,IAAK,IAAIM,IAAI,GAAGA,IAAIH,MAAMI,MAAM,EAAED,IAAK;QACrC,MAAME,OAAOL,KAAK,CAACG,EAAE;QACrB,MAAMG,SAASH,MAAMH,MAAMI,MAAM,GAAG;QACpC,MAAMG,UAAU,CAACC,OAAOC,KAAK,CAACD,OAAOH;QAErC,IAAIE,SAAS;YACX,MAAMG,QAAQF,OAAOH;YAErB,wCAAwC;YACxC,IAAI,CAACM,MAAMC,OAAO,CAACV,UAAU;gBAC3BA,UAAU,EAAE;YACd;YAEA,uCAAuC;YACvC,IAAI,CAACA,OAAO,CAACQ,MAAM,EAAE;gBACnBR,OAAO,CAACQ,MAAM,GAAG,CAAC;YACpB;YAEA,IAAIJ,QAAQ;gBACVJ,OAAO,CAACQ,MAAM,GAAGX;YACnB,OAAO;gBACLG,UAAUA,OAAO,CAACQ,MAAM;YAC1B;QACF,OAAO;YACL,+BAA+B;YAC/B,IAAIJ,QAAQ;gBACV,IAAI,OAAOD,SAAS,UAAU;oBAC5BH,OAAO,CAACG,KAAK,GAAGN;gBAClB;YACF,OAAO;gBACL,IAAI,OAAOG,OAAO,CAACG,KAAe,KAAK,YAAYH,OAAO,CAACG,KAAe,KAAK,MAAM;oBACnFH,OAAO,CAACG,KAAe,GAAG,CAAC;gBAC7B;gBAEAH,UAAUA,OAAO,CAACG,KAAe;YACnC;QACF;IACF;AACF,EAAC"}
+{"version":3,"sources":["../../src/utilities/setNestedValue.ts"],"sourcesContent":["/**\n * Sets a value deeply into a nested object or array, based on a dot-notation path.\n *\n * This function:\n * - Supports array indexing (e.g., \"array.0.field1\")\n * - Creates intermediate arrays/objects as needed\n * - Mutates the target object directly\n *\n * @example\n * const obj = {}\n * setNestedValue(obj, 'group.array.0.field1', 'hello')\n * // Result: { group: { array: [ { field1: 'hello' } ] } }\n *\n * @param obj - The target object to mutate.\n * @param path - A dot-separated string path indicating where to assign the value.\n * @param value - The value to set at the specified path.\n */\n\nexport const setNestedValue = (\n  obj: Record<string, unknown>,\n  path: string,\n  value: unknown,\n): void => {\n  const parts = path.split('.')\n  let current: unknown = obj\n\n  for (let i = 0; i < parts.length; i++) {\n    const part = parts[i]\n    const isLast = i === parts.length - 1\n    const isIndex = !Number.isNaN(Number(part))\n\n    if (isIndex) {\n      const index = Number(part)\n\n      // Ensure the current target is an array\n      if (!Array.isArray(current)) {\n        current = []\n      }\n\n      const currentArray = current as unknown[]\n\n      // Ensure the array slot is initialized\n      if (!currentArray[index]) {\n        currentArray[index] = {}\n      }\n\n      if (isLast) {\n        currentArray[index] = value\n      } else {\n        current = currentArray[index]\n      }\n    } else {\n      const currentObj = current as Record<string, unknown>\n\n      // Ensure the object key exists\n      if (isLast) {\n        if (typeof part === 'string') {\n          currentObj[part] = value\n        }\n      } else {\n        if (typeof currentObj[part as string] !== 'object' || currentObj[part as string] === null) {\n          currentObj[part as string] = {}\n        }\n\n        current = currentObj[part as string]\n      }\n    }\n  }\n}\n"],"names":["setNestedValue","obj","path","value","parts","split","current","i","length","part","isLast","isIndex","Number","isNaN","index","Array","isArray","currentArray","currentObj"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GAED,OAAO,MAAMA,iBAAiB,CAC5BC,KACAC,MACAC;IAEA,MAAMC,QAAQF,KAAKG,KAAK,CAAC;IACzB,IAAIC,UAAmBL;IAEvB,IAAK,IAAIM,IAAI,GAAGA,IAAIH,MAAMI,MAAM,EAAED,IAAK;QACrC,MAAME,OAAOL,KAAK,CAACG,EAAE;QACrB,MAAMG,SAASH,MAAMH,MAAMI,MAAM,GAAG;QACpC,MAAMG,UAAU,CAACC,OAAOC,KAAK,CAACD,OAAOH;QAErC,IAAIE,SAAS;YACX,MAAMG,QAAQF,OAAOH;YAErB,wCAAwC;YACxC,IAAI,CAACM,MAAMC,OAAO,CAACV,UAAU;gBAC3BA,UAAU,EAAE;YACd;YAEA,MAAMW,eAAeX;YAErB,uCAAuC;YACvC,IAAI,CAACW,YAAY,CAACH,MAAM,EAAE;gBACxBG,YAAY,CAACH,MAAM,GAAG,CAAC;YACzB;YAEA,IAAIJ,QAAQ;gBACVO,YAAY,CAACH,MAAM,GAAGX;YACxB,OAAO;gBACLG,UAAUW,YAAY,CAACH,MAAM;YAC/B;QACF,OAAO;YACL,MAAMI,aAAaZ;YAEnB,+BAA+B;YAC/B,IAAII,QAAQ;gBACV,IAAI,OAAOD,SAAS,UAAU;oBAC5BS,UAAU,CAACT,KAAK,GAAGN;gBACrB;YACF,OAAO;gBACL,IAAI,OAAOe,UAAU,CAACT,KAAe,KAAK,YAAYS,UAAU,CAACT,KAAe,KAAK,MAAM;oBACzFS,UAAU,CAACT,KAAe,GAAG,CAAC;gBAChC;gBAEAH,UAAUY,UAAU,CAACT,KAAe;YACtC;QACF;IACF;AACF,EAAC"}