change: set to default to array for indices in path, introduce object-syntax

Author: sagold

README.md

@@ -117,6 +117,45 @@ const data = pointer.set({}, ['list', '[]', 'value'], 42);
 console.log(data); // output: { list: [ { value: 42 } ] }
 ```
 
+#### behaviour using `set`
+
+`set` will create arrays when encountering a number
+
+```js
+pointer.set({}, ['list', '1', 'value'], 42);
+// { list: [undefined, { value: 42 }] }
+```
+
+alternatively you may use array-syntax `[index]`
+
+```js
+pointer.set({}, ['list', '[1]', 'value'], 42);
+// { list: [undefined, { value: 42 }] }
+```
+
+append items using empty array syntax `[]`
+
+```js
+pointer.set({ list: [1, 2] }, ['list', '[]', 'value'], 42);
+// { list: [1, 2, { value: 42 }] }
+```
+
+create object using object syntax `{index}`
+
+```js
+pointer.set({}, ['list', '{1}', 'value'], 42);
+// { list: { 1: { value: 42 } }
+```
+
+> ⚠️ `set` prefers existing data-type over specified data-types. For example: Setting an object for an existing array, will keep the object intact:
+>
+> ```js
+> pointer.set({ list: []}, ['list', '{0}', 'value'], 42);
+> // { list: [{ value: 42 }] }
+> ```
+
+
+
 #### array
 
 Per default `set` creates objects for each each missing data. Thus, a pointer to `/list/1` will create an object with `{ list: { 1: {} } }`. If you want to specify array-data you will need to wrap the array-index in array-brackets:
@@ -276,6 +315,9 @@ console.log(pointer); // output: '/my pointer/to/property'
 
 ## Breaking Changes
 
+- 2025/01/14 with `v7`
+    - `pointer.set` creates arrays using numbers as properties `/1` when the data is null or an array (previously created objects)
+    - `pointer.set` creates objects for numbers when using object-syntax `/{1}` (previously unsupported)
 - 2024/04/06 with `v6`, selection of empty properties is supported:
     -  `"/"` now selects an empty property (previously root-pointer)
     -  `"a//b"` is now a valid pointer to `"a" » "" » "b"`

lib/set.ts

@@ -3,6 +3,7 @@ import { JsonPointer, JsonPath, JsonData } from "./types";
 
 const isArray = /^\[.*\]$/;
 const arrayIndex = /^\[(.+)\]$/;
+const findProperty = /^[[{](.+)[\]}]$/;
 
 function accessToPrototype(key: string, properties: string[]) {
 	return (
@@ -36,7 +37,7 @@ export function set<T = JsonData>(
 		current = data;
 	while (properties.length > 1) {
 		key = properties.shift();
-		nextKeyIsArray = isArray.test(properties[0]);
+		nextKeyIsArray = isArray.test(properties[0]) || `${parseInt(properties[0])}` === properties[0];
 		if (accessToPrototype(key, properties)) {
 			continue;
 		}
@@ -48,20 +49,16 @@ export function set<T = JsonData>(
 }
 
 function addValue(data, key, value) {
-	let index;
-	const keyAsIndex = key.match(arrayIndex);
+	const property = key.match(findProperty)?.pop() ?? key;
 	if (key === "[]" && Array.isArray(data)) {
 		data.push(value);
-	} else if (keyAsIndex) {
-		index = keyAsIndex.pop();
-		data[index] = value;
 	} else {
-		data[key] = value;
+		data[property] = value;
 	}
 }
 
 function create(data, key, isArray) {
-	const property = key.match(arrayIndex)?.pop() ?? key;
+	const property = key.match(findProperty)?.pop() ?? key;
 	if (data[property] != null) {
 		return data[property];
 	}

test/issues/issue23.set-merge.test.ts

@@ -12,4 +12,35 @@ describe("pointer.set", () => {
 
 		expect(obj.list).to.deep.equal([{ itemA: 1, itemB: 1 }]);
 	});
+
+	it("should merge properties in array items using number as index", () => {
+		const obj: Record<string, any> = {};
+
+		set(obj, '/list/0/itemA', 1)
+		set(obj, '/list/0/itemB', 1)
+
+		expect(obj.list).to.deep.equal([{ itemA: 1, itemB: 1 }]);
+	});
+
+	it("should prefer existing data-type array over specified data-type in pointer", () => {
+		const obj: Record<string, any> = {
+			list: []
+		};
+
+		set(obj, '/list/{0}/itemA', 1)
+		set(obj, '/list/{0}/itemB', 1)
+
+		expect(obj.list).to.deep.equal([{ itemA: 1, itemB: 1 }]);
+	});
+
+	it("should prefer existing data-type object over specified data-type in pointer", () => {
+		const obj: Record<string, any> = {
+			list: {}
+		};
+
+		set(obj, '/list/[0]/itemA', 1)
+		set(obj, '/list/[0]/itemB', 1)
+
+		expect(obj.list).to.deep.equal({ 0: { itemA: 1, itemB: 1 } });
+	});
 });

test/unit/set.test.ts

@@ -70,7 +70,7 @@ describe("pointer.set", () => {
         expect(result.array.length).to.eq(1);
     });
 
-    it("should insert index in array", () => {
+    it("should insert index in array using array-syntax", () => {
         const result = set<{ array?: any[] }>({}, "/array/[1]", true);
 
         assert(result.array);
@@ -79,6 +79,23 @@ describe("pointer.set", () => {
         expect(result.array[1]).to.be.true;
     });
 
+    it("should insert index in array using number as string", () => {
+        const result = set<{ array?: any[] }>({}, "/array/1", true);
+
+        assert(result.array);
+        expect(result.array).to.be.an("array");
+        expect(result.array.length).to.eq(2);
+        expect(result.array[1]).to.be.true;
+    });
+
+    it("should insert object using object-syntax", () => {
+        const result = set<{ array?: any[] }>({}, "/array/{1}", true);
+
+        assert(result.array);
+        expect(result.array).to.be.an("object");
+        expect(result.array).to.deep.equal({ "1": true });
+    });
+
     it("should append item to array", () => {
         const result = set<{ array: any[] }>({ array: ["first"] }, "/array/[]", "next");
 
@@ -94,14 +111,22 @@ describe("pointer.set", () => {
         expect(result.array[0][0]).to.be.true;
     });
 
-    it("should insert array to index in array", () => {
+    it("should insert array to index in array using array-syntax", () => {
         const result = set<{ array?: any[] }>({}, "/array/[1]/[]", true);
 
         assert(result.array);
         expect(result.array).to.be.an("array");
         expect(result.array[1][0]).to.be.true;
     });
 
+    it("should insert array to index in array using number as string", () => {
+        const result = set<{ array?: any[] }>({}, "/array/1/[]", true);
+
+        assert(result.array);
+        expect(result.array).to.be.an("array");
+        expect(result.array[1][0]).to.be.true;
+    });
+
     it("should insert object in array", () => {
         const result = set<{ array?: any[] }>(
             {},