maraj 2.4.1 → 2.5.1

package/README.md

@@ -1,16 +1,18 @@
 
 # Maraj
 
-A fast lightweight utility for creating **immutable updates**. Full typescript support. Only 600 bytes gziped. Includes usefull utilities for manipulating updates (like remove, select).
+A fast lightweight utility for creating **immutable updates**. Fully typed. Only 600 bytes gziped. Includes usefull utilities for manipulating updates (like remove, select).
 
 ### Features
 
+- updateImmutably and modifyImmutably.
 - Full typescript support.
 - Correct type inference.
-- Multiple updates at same time mantaining the order of execution.
+- Multiple and concurrent updates.
 - Functional updates.
+- Includes usefull utilities like "remove", "select".
 
-**<u>For Typescript:</u>** in tsconfig.json set **"strictNullChecks"** and **"noUncheckedIndexedAccess"** to true for correct type inference of optional properties (so it can correctly differentiate between optional props and props with possible undefined value)
+**<u>_For Typescript:_</u>** in tsconfig.json set **"strictNullChecks"** and **"noUncheckedIndexedAccess"** to **true** to be able to infer correctly the type of optional properties and properties with posible undefined value. ({key?: ''} !== {key: '' | undefined})
 
 ```ts
 const originalValue = { name: 'one', lastname: 'two' modified: false, files: [{ filename: 'one' }] }
@@ -20,24 +22,36 @@ const updatedValue = updateImmutably(orignalValue, {
    'modified': (value, fullObject) => !value,
    'files.0.filename': 'zero',
 })
-
 // updatedValue = { name: 'updated', lastname: 'two' modified: true, files: [{ filename: 'zero' }] }
-
 originalValue.files[1] === updatedValue.files[1] // true
+
+const newValue = modifyImmutably(orignalValue, {
+   'newProp': 'new',
+   'data.0.name': 'dataName'
+})
+// updatedValue = { ... , newProp: 'new', data: [{ name: 'dataName' }] }
+originalValue.files[1] === newValue.files[1] // true
 ```
 
 ### Limitations
 
-- If "addNonExistentPropsAndIndexes" is enabled, numbers will always create an array if the array/object doesnt exist beforehand.
+- In "modifyImmutably", **numbers** inside path will **always** create an **array** if the array/object doesnt exist beforehand. If you want an object instead of an array, add it beforehand.
 
 ```ts
-const updatedValue = updateImmutably({}, {
+const updatedValue = modifyImmutably({}, {
    'files.1.name': 'new name',
-}, true)
-// updatedValue = { files: [<empty>, { name: 'new name' }] }
+})
+// The "files" prop is an array. updatedValue = { files: [<empty>, { name: 'new name' }] }
+
+// To get an object instead of an array create an object beforehand
+const updatedValue2 = modifyImmutably({}, {
+   'files': {}, // add an object first, so then i can add props as numbers after it
+   'files.1.name': 'new name',
+})
+// updatedValue2 = { files: { '1': { name: 'new name' } } }
 ```
 
-- The type "UpdateDotObject" using computed properties ( [key] ) will always throw a ts error even if the typing is correct. [Playground simple explanation](https://www.typescriptlang.org/play?ts=5.3.2#code/LAKALgngDgpgBAGQJYGcxwLxwOQENtwA+cABgCQDeAdgK4C2ARjAE4C+JooksiqYASjADGAe2YATTHApwA2gGk4SKrzQBdAPwAuOItacQoqmjhDmMXGBiDREqQB4AKnBgAPK1XEpVYAHwAKAGsYCB1HAEpMX2lQODijE3MhHWQ0GzFJLApYuNyAejy4AD0wbxZmMR0UZSF4ADcAFgA6AGYmgFYldAB3JAAbPrgwAAsK7rhcFXKxCfQhYeFA5QBzUxE6KBorSWCIb0nJOtw+mhhvGmqqVasNvst4PqQrZmOyupgVJAAzIYWh6BWSm8tiSYByuTkuzUOl24P0IFy5jANGYKiSoFYQA)
+- The type "UpdateDotPathObject" (the type used as second parameter in the updateImmutably function) if used to create new update objects using computed properties { [key]: value } will always throw a ts error even if the typing is correct. [Playground simple explanation](https://www.typescriptlang.org/play?ts=5.3.2#code/LAKALgngDgpgBAGQJYGcxwLxwOQENtwA+cABgCQDeAdgK4C2ARjAE4C+JooksiqYASjADGAe2YATTHApwA2gGk4SKrzQBdAPwAuOItacQoqmjhDmMXGBiDREqQB4AKnBgAPK1XEpVYAHwAKAGsYCB1HAEpMX2lQODijE3MhHWQ0GzFJLApYuNyAejy4AD0wbxZmMR0UZSF4ADcAFgA6AGYmgFYldAB3JAAbPrgwAAsK7rhcFXKxCfQhYeFA5QBzUxE6KBorSWCIb0nJOtw+mhhvGmqqVasNvst4PqQrZmOyupgVJAAzIYWh6BWSm8tiSYByuTkuzUOl24P0IFy5jANGYKiSoFYQA)
 
 ```ts
 const updateFieldStore = <TPath extends DotPaths<Store>>(
@@ -52,24 +66,23 @@ const updateFieldStore = <TPath extends DotPaths<Store>>(
 }
 ```
 
-- Use the "set" utility if typescript doesn't distinguish properly _"an optional field"_ vs a _"field which can have 'undefined' as type"_. Usually happens in optional nested props inside arrays.
+- Use the "set" utility if typescript doesn't infer properly _"an optional field"_ vs a _"field which can have 'undefined' as type"_. Usually happens in optional nested props inside arrays.
 
 ```ts
 const updatedValue = updateImmutably(data, {
-   'files.0.optionalProperty': 'new name',
-   'files.1.optionalProperty': undefined, //no ts error
-   'files.0.optionalProperty': set('new name'),
-   'files.1.optionalProperty': set(undefined), //throws ts error, undefined cant be a value.
+   'files.0.nonOptionalProperty': 'new name',
+   'files.1.nonOptionalProperty': undefined, //no ts error
+   'files.0.nonOptionalProperty': set('new name'),
+   'files.1.nonOptionalProperty': set(undefined), //throws ts error, undefined cant be a value.
 })
 ```
 
-## Creating an Immutable Update
+## Creating a Strict Immutable Update
 
 Arguments:
 
 - Original Object
 - Update Object
-- If it should add non-existent properties/indexes
 
 ## Example
 
@@ -86,7 +99,6 @@ const data = {
 }
 
 const newUpdatedObject = updateImmutably(data, {
-    "profile.age": 28, //add new properties if "addNonExistentPropsAndIndexes" is enabled
     "profile.name": "Lucas", //update values
     "works.1": "gs", //nested array update
     "history.1.available": (currentValue) => (!currentValue), //functional update
@@ -94,6 +106,34 @@ const newUpdatedObject = updateImmutably(data, {
 })
 ```
 
+## Creating an Immutable Update allowing new props to be added
+
+Arguments:
+
+- Original Object
+- Update Object
+
+## Example
+
+```js
+import { modifyImmutably } from "maraj";
+
+const data = {
+    profile: { name: "Lukasz" },
+    works: ["soum", "fi"],
+    history: [
+        { title: "soum", size: 90, available: true, info: ["info1"] },
+        { title: "fi", size: 30, available: false, info: ["infoA"] },
+    ]
+}
+
+const newUpdatedObject = modifyImmutably(data, {
+    "profile.age": 28, //add new property
+    "profile.name": "Lucas", //update values
+    "works.10": "gs", //increases the array (filling it up with empty/undefined) and sets the value in the index of 10 to "gs"
+})
+```
+
 ## Remove Utility
 
 Removes the **key of an object** or the **index of an array** in the key provided in the **updateImmutably.**
@@ -103,8 +143,9 @@ import {remove} from 'maraj'
 
 const newUpdatedObject = updateImmutably(person,{
     'profile': (value) => remove(value, 'name'), // returns new value without the "name" prop
+    'profile': (value) => remove(value, ['name', 'lastname']), // returns new value without the "name" and "lastname" prop
     'works': (value) => remove(value, 1), // returns new array without the provided index (1)
-    'works': (value) => remove(value, [1, "0"]), // returns new array without the provided index (0,1)
+    'works': (value) => remove(value, [1, "0"]), // returns new array without the provided index "0" and "1"
 })
 ```
 
@@ -134,8 +175,8 @@ import { splitPathAtLastKey } from 'maraj'
 
 const stringPath = 'works.1.size'
 
-const [remainingPath, last] = splitPathAtLastKey(stringPath)
-// last = 'size'
+const [remainingPath, lastKey] = splitPathAtLastKey(stringPath)
+// lastKey = 'size'
 // remainingPath = 'works.1'
 ```
 

package/dist/index.d.mts

@@ -1,3 +1,25 @@
+/** Index literal type to improve DX at managing updates. */
+declare const LITERAL_INDEX = "${number}";
+type LiteralIndex = typeof LITERAL_INDEX;
+type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>) => T;
+/**
+ * Creates a new object applying strict immutable updates using dot-path syntax. Can't add new props or indexes.
+ * @param state Original State Object.
+ * @param updates Dot Path Update Object.
+ * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @returns New Updated Object.
+ */
+declare const updateImmutably: UpdateImmutably;
+type ModifyImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T> | Record<string, any>) => T;
+/**
+ * Creates a new object applying immutable modifications using dot-path syntax. It will add non-existent props or indexes if provided.
+ * @param state Original State Object.
+ * @param updates Dot Path Update Object.
+ * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @returns New Updated Object.
+ */
+declare const modifyImmutably: ModifyImmutably;
+
 /**
  * --------------------------------------------
  *  UTILITIES
@@ -5,10 +27,8 @@
  */
 /** Primitives and browser native objects. */
 type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
-/** Index literal type to improve DX at managing updates. */
-type LiteralIndex = '${number}';
 /** Array indexes type. */
-type ArrayIndexes = `${number}` | LiteralIndex;
+type ArrayIndexes = number | LiteralIndex;
 /** To check if a ReadonlyArray is a tuple or not. */
 type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
 /**
@@ -60,18 +80,16 @@ type DotPathUpdateObject<TObject> = {
  *  REQUIRED OR OPTIONAL KEYS
  * --------------------------------------------
  */
-/** All types instead of undefined. */
-type NonPartialKeys = null | object;
 /** Returns only the optional keys of an object. */
-type RetrieveOptionalKeys<T> = {
-    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
-}[keyof T & string];
+type OptionalKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
 /** Returns only the required keys of an object. */
-type RetrieveRequiredKeys<T> = {
-    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
-}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
 
-type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (RetrieveOptionalKeys<T> | (RetrieveOptionalKeys<T>)[])) => T;
+type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : OptionalKeys<T> | (OptionalKeys<T>)[]) => T;
 /**
  * Removes properties or indexes, order doesn't matter.
  * @param value Object/array from where to remove keys/indexes shallowly.
@@ -107,14 +125,10 @@ type Set = <T>(newValue: T) => (value: T) => T;
  */
 declare const set: Set;
 
-type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
-/**
- * Creates a new object applying immutable updates using dot-path syntax.
- * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
- * @returns New Updated Object.
- */
-declare const updateImmutably: UpdateImmutably;
+/** Checks if any provided value is an object literal or not */
+declare const isObjectLiteral: (valueToTest: any) => boolean;
+
+declare const parseStringIndex: (v: string) => number | null;
+declare const isStringIndex: (v: string) => boolean;
 
-export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type PrimitivesAndNativeObjects, type RetrieveOptionalKeys, type RetrieveRequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type PrimitivesAndNativeObjects, type RequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, isObjectLiteral, isStringIndex, modifyImmutably, parseStringIndex, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.d.ts

@@ -1,3 +1,25 @@
+/** Index literal type to improve DX at managing updates. */
+declare const LITERAL_INDEX = "${number}";
+type LiteralIndex = typeof LITERAL_INDEX;
+type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>) => T;
+/**
+ * Creates a new object applying strict immutable updates using dot-path syntax. Can't add new props or indexes.
+ * @param state Original State Object.
+ * @param updates Dot Path Update Object.
+ * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @returns New Updated Object.
+ */
+declare const updateImmutably: UpdateImmutably;
+type ModifyImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T> | Record<string, any>) => T;
+/**
+ * Creates a new object applying immutable modifications using dot-path syntax. It will add non-existent props or indexes if provided.
+ * @param state Original State Object.
+ * @param updates Dot Path Update Object.
+ * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @returns New Updated Object.
+ */
+declare const modifyImmutably: ModifyImmutably;
+
 /**
  * --------------------------------------------
  *  UTILITIES
@@ -5,10 +27,8 @@
  */
 /** Primitives and browser native objects. */
 type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
-/** Index literal type to improve DX at managing updates. */
-type LiteralIndex = '${number}';
 /** Array indexes type. */
-type ArrayIndexes = `${number}` | LiteralIndex;
+type ArrayIndexes = number | LiteralIndex;
 /** To check if a ReadonlyArray is a tuple or not. */
 type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
 /**
@@ -60,18 +80,16 @@ type DotPathUpdateObject<TObject> = {
  *  REQUIRED OR OPTIONAL KEYS
  * --------------------------------------------
  */
-/** All types instead of undefined. */
-type NonPartialKeys = null | object;
 /** Returns only the optional keys of an object. */
-type RetrieveOptionalKeys<T> = {
-    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
-}[keyof T & string];
+type OptionalKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
 /** Returns only the required keys of an object. */
-type RetrieveRequiredKeys<T> = {
-    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
-}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+}[keyof T];
 
-type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (RetrieveOptionalKeys<T> | (RetrieveOptionalKeys<T>)[])) => T;
+type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : OptionalKeys<T> | (OptionalKeys<T>)[]) => T;
 /**
  * Removes properties or indexes, order doesn't matter.
  * @param value Object/array from where to remove keys/indexes shallowly.
@@ -107,14 +125,10 @@ type Set = <T>(newValue: T) => (value: T) => T;
  */
 declare const set: Set;
 
-type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
-/**
- * Creates a new object applying immutable updates using dot-path syntax.
- * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
- * @returns New Updated Object.
- */
-declare const updateImmutably: UpdateImmutably;
+/** Checks if any provided value is an object literal or not */
+declare const isObjectLiteral: (valueToTest: any) => boolean;
+
+declare const parseStringIndex: (v: string) => number | null;
+declare const isStringIndex: (v: string) => boolean;
 
-export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type PrimitivesAndNativeObjects, type RetrieveOptionalKeys, type RetrieveRequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type PrimitivesAndNativeObjects, type RequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, isObjectLiteral, isStringIndex, modifyImmutably, parseStringIndex, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.js

@@ -1 +1 @@
-"use strict";var f=Object.defineProperty;var O=Object.getOwnPropertyDescriptor;var j=Object.getOwnPropertyNames;var w=Object.prototype.hasOwnProperty;var D=(t,e)=>{for(var r in e)f(t,r,{get:e[r],enumerable:!0})},v=(t,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of j(e))!w.call(t,a)&&a!==r&&f(t,a,{get:()=>e[a],enumerable:!(o=O(e,a))||o.enumerable});return t};var I=t=>v(f({},"__esModule",{value:!0}),t);var R={};D(R,{remove:()=>b,select:()=>T,set:()=>K,splitPathAtLastKey:()=>P,updateImmutably:()=>x});module.exports=I(R);var b=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let r=Array.isArray(e)?e:[e];if(Array.isArray(t)){let a=Symbol(),y=[...t];return r.forEach(n=>{y[n]=a}),y.filter(n=>n!==a)}let o={...t};return r.forEach(a=>delete o[a]),o};var T=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((r,o)=>{if(r?.hasOwnProperty(o))return r[o]},t);var P=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,r=e?t.slice(0,e-1):"",o=t.slice(e);return[r,o]};var K=t=>()=>t;var x=(t,e,r)=>{if(t?.constructor!==Object&&!Array.isArray(t))throw new Error(`${t} is not an object/array`);if(!e)return t;let o=Array.isArray(t)?[...t]:{...t},a={};for(let[y,d]of Object.entries(e)){if(!y)continue;let n=y.split("."),s=n.pop(),u=a,c=o;for(let h=0;h<n.length;h++){let i=n[h],p=c[i],A=typeof p=="object"&&(p.constructor===Object||Array.isArray(p)),m=r&&p===void 0;if(!A&&!m)throw new Error(`Invalid path provided: "${i}" is not an object/array in "${y}"`);u[i]||(m?c[i]=isNaN(n[h+1]??s)?{}:[]:c[i]=Array.isArray(p)?[...p]:{...p},u[i]={}),c=c[i],u=u[i]}let l=c;if(!r){if(Array.isArray(l)&&!(s<l.length))throw new Error(`Index ${s} doesnt exist in the path ${n.join(".")} because its value is ${s}, use spread operator for adding new indexes`);if(!l.hasOwnProperty(s))throw new Error(`Property ${s} doesnt exist in the path ${n.join(".")} because its value is ${l}`)}l[s]=typeof d=="function"?d(l[s],o):d,delete u[s]}return o};0&&(module.exports={remove,select,set,splitPathAtLastKey,updateImmutably});
+"use strict";var b=Object.defineProperty;var S=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var E=Object.prototype.hasOwnProperty;var R=(t,e)=>{for(var r in e)b(t,r,{get:e[r],enumerable:!0})},$=(t,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of w(e))!E.call(t,n)&&n!==r&&b(t,n,{get:()=>e[n],enumerable:!(o=S(e,n))||o.enumerable});return t};var U=t=>$(b({},"__esModule",{value:!0}),t);var V={};R(V,{isObjectLiteral:()=>d,isStringIndex:()=>h,modifyImmutably:()=>D,parseStringIndex:()=>g,remove:()=>I,select:()=>T,set:()=>O,splitPathAtLastKey:()=>P,updateImmutably:()=>K});module.exports=U(V);var I=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let r=Array.isArray(e)?e:[e];if(Array.isArray(t)){let n=Symbol(),p=[...t];return r.forEach(a=>{p[a]=n}),p.filter(a=>a!==n)}let o={...t};return r.forEach(n=>delete o[n]),o};var T=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((r,o)=>{if(r?.hasOwnProperty(o))return r[o]},t);var P=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,r=e?t.slice(0,e-1):"",o=t.slice(e);return[r,o]};var O=t=>()=>t;var d=t=>!!t&&Object.getPrototypeOf(t)===Object.prototype;var g=t=>{let e=parseInt(t);return e.toString()===t?e:null},h=t=>parseInt(t).toString()===t;var A="${number}",j=(t,e,r)=>{if(!d(t)&&!Array.isArray(t))throw new Error(`"${t}" is not an literalObject/array`);if(!e)return t;let o=Array.isArray(t)?[...t]:{...t},n={};for(let[p,m]of Object.entries(e)){if(!p)continue;let a=p.split(".");if(a.includes(A))throw new Error(`"${A}" inside "${p}"`);let i=a.pop(),l=n,y=o;for(let u=0;u<a.length;u++){let s=a[u],c=y[s],L=d(c)||Array.isArray(c),x=r&&c===void 0;if(!L&&!x)throw new Error(`"${s}" doesnt exist in "${a.slice(0,u+1).join(".")}"`);l[s]||(x?y[s]=h(a[u+1]??i)?[]:{}:y[s]=Array.isArray(c)?[...c]:{...c},l[s]={}),y=y[s],l=l[s]}let f=y;if(!r&&!f.hasOwnProperty(i))throw new Error(`Property/Index "${i}" doesnt exist in the path "${a.join(".")+"."+i}". Its value is: "${f}"`);f[i]=typeof m=="function"?m(f[i],o):m,delete l[i]}return o},K=(t,e)=>j(t,e,!1),D=(t,e)=>j(t,e,!0);0&&(module.exports={isObjectLiteral,isStringIndex,modifyImmutably,parseStringIndex,remove,select,set,splitPathAtLastKey,updateImmutably});

package/dist/index.mjs

@@ -1 +1 @@
-var b=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let o=Array.isArray(e)?e:[e];if(Array.isArray(t)){let p=Symbol(),y=[...t];return o.forEach(a=>{y[a]=p}),y.filter(a=>a!==p)}let r={...t};return o.forEach(p=>delete r[p]),r};var T=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((o,r)=>{if(o?.hasOwnProperty(r))return o[r]},t);var P=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,o=e?t.slice(0,e-1):"",r=t.slice(e);return[o,r]};var K=t=>()=>t;var x=(t,e,o)=>{if(t?.constructor!==Object&&!Array.isArray(t))throw new Error(`${t} is not an object/array`);if(!e)return t;let r=Array.isArray(t)?[...t]:{...t},p={};for(let[y,d]of Object.entries(e)){if(!y)continue;let a=y.split("."),n=a.pop(),u=p,c=r;for(let h=0;h<a.length;h++){let s=a[h],i=c[s],m=typeof i=="object"&&(i.constructor===Object||Array.isArray(i)),f=o&&i===void 0;if(!m&&!f)throw new Error(`Invalid path provided: "${s}" is not an object/array in "${y}"`);u[s]||(f?c[s]=isNaN(a[h+1]??n)?{}:[]:c[s]=Array.isArray(i)?[...i]:{...i},u[s]={}),c=c[s],u=u[s]}let l=c;if(!o){if(Array.isArray(l)&&!(n<l.length))throw new Error(`Index ${n} doesnt exist in the path ${a.join(".")} because its value is ${n}, use spread operator for adding new indexes`);if(!l.hasOwnProperty(n))throw new Error(`Property ${n} doesnt exist in the path ${a.join(".")} because its value is ${l}`)}l[n]=typeof d=="function"?d(l[n],r):d,delete u[n]}return r};export{b as remove,T as select,K as set,P as splitPathAtLastKey,x as updateImmutably};
+var P=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let r=Array.isArray(e)?e:[e];if(Array.isArray(t)){let i=Symbol(),p=[...t];return r.forEach(n=>{p[n]=i}),p.filter(n=>n!==i)}let o={...t};return r.forEach(i=>delete o[i]),o};var O=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((r,o)=>{if(r?.hasOwnProperty(o))return r[o]},t);var g=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,r=e?t.slice(0,e-1):"",o=t.slice(e);return[r,o]};var A=t=>()=>t;var f=t=>!!t&&Object.getPrototypeOf(t)===Object.prototype;var j=t=>{let e=parseInt(t);return e.toString()===t?e:null},h=t=>parseInt(t).toString()===t;var x="${number}",I=(t,e,r)=>{if(!f(t)&&!Array.isArray(t))throw new Error(`"${t}" is not an literalObject/array`);if(!e)return t;let o=Array.isArray(t)?[...t]:{...t},i={};for(let[p,d]of Object.entries(e)){if(!p)continue;let n=p.split(".");if(n.includes(x))throw new Error(`"${x}" inside "${p}"`);let s=n.pop(),l=i,y=o;for(let u=0;u<n.length;u++){let a=n[u],c=y[a],T=f(c)||Array.isArray(c),b=r&&c===void 0;if(!T&&!b)throw new Error(`"${a}" doesnt exist in "${n.slice(0,u+1).join(".")}"`);l[a]||(b?y[a]=h(n[u+1]??s)?[]:{}:y[a]=Array.isArray(c)?[...c]:{...c},l[a]={}),y=y[a],l=l[a]}let m=y;if(!r&&!m.hasOwnProperty(s))throw new Error(`Property/Index "${s}" doesnt exist in the path "${n.join(".")+"."+s}". Its value is: "${m}"`);m[s]=typeof d=="function"?d(m[s],o):d,delete l[s]}return o},K=(t,e)=>I(t,e,!1),D=(t,e)=>I(t,e,!0);export{f as isObjectLiteral,h as isStringIndex,D as modifyImmutably,j as parseStringIndex,P as remove,O as select,A as set,g as splitPathAtLastKey,K as updateImmutably};

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "maraj",
-   "version": "2.4.1",
-   "description": "A lightweight 500 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
+   "version": "2.5.1",
+   "description": "A lightweight 600 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
    "keywords": [
       "shallow",
       "shallow copy",
@@ -23,6 +23,7 @@
       "test": "vitest run",
       "build": "tsup src/index.ts --minify --format cjs,esm --dts",
       "lint": "tsc",
+      "trace": "tsc --generateTrace trace",
       "ci": "npm run lint && npm run test && npm run build",
       "release": "npm run lint && npm run test && npm run build && changeset publish"
    },
@@ -37,6 +38,7 @@
    "devDependencies": {
       "@changesets/cli": "^2.27.1",
       "@microsoft/api-extractor": "^7.38.5",
+      "@typescript/analyze-trace": "^0.10.1",
       "tsup": "^8.0.1",
       "typescript": "^5.3.3",
       "vitest": "^0.28.4"