maraj 2.5.1 → 2.7.0

package/README.md

@@ -5,19 +5,19 @@ A fast lightweight utility for creating **immutable updates**. Fully typed. Only
 
 ### Features
 
-- updateImmutably and modifyImmutably.
+- Update and ExtendableUpdate.
+- Usefull utilities like "remove", "select".
 - Full typescript support.
 - Correct type inference.
 - Multiple and concurrent updates.
-- Functional updates.
-- Includes usefull utilities like "remove", "select".
+- Nested functional updates.
 
-**<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})
+<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' }] }
 
-const updatedValue = updateImmutably(orignalValue, {
+const updatedValue = update(orignalValue, {
    'name': 'updated',
    'modified': (value, fullObject) => !value,
    'files.0.filename': 'zero',
@@ -25,7 +25,7 @@ const updatedValue = updateImmutably(orignalValue, {
 // updatedValue = { name: 'updated', lastname: 'two' modified: true, files: [{ filename: 'zero' }] }
 originalValue.files[1] === updatedValue.files[1] // true
 
-const newValue = modifyImmutably(orignalValue, {
+const newValue = extendableUpdate(orignalValue, {
    'newProp': 'new',
    'data.0.name': 'dataName'
 })
@@ -35,23 +35,29 @@ originalValue.files[1] === newValue.files[1] // true
 
 ### Limitations
 
-- 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.
+- Can work with keys containing dots ({ "this.is.dotted.key": 123 }), however those keys (keys containing dots) must exist in the object beforehand (hasOwnProperty) and also must have a non-literal-object/array value to behave properly; like primitives, sets, maps, and so on. For example the path "a.b.c.d" will work properly in the following scenarios:
+  - { "a.b.c.d": ... }
+  - { a: { "b.c.d": ... } }
+  - { a: { b: {"c.d": ... } } }
+  - { a: { b: {"c": { d: ... } } } }
+
+- In "extendableUpdate", **numbers** inside path will **always** create a mutable **array** if the array/object doesnt exist beforehand. If you want an object/tuple/readonlyArray instead of an array, add it beforehand as type.
 
 ```ts
-const updatedValue = modifyImmutably({}, {
+const updatedValue = extendableUpdate({}, {
    'files.1.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({}, {
+const updatedValue2 = extendableUpdate({}, {
    '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 "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)
+- The type "UpdateDotPathObject" (the type of the object provided containing the updates, the one used as second parameter in the update function) if used to create new update objects using computed properties { [key]: value } (middlewares for example) 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>>(
@@ -69,7 +75,7 @@ const updateFieldStore = <TPath extends DotPaths<Store>>(
 - 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, {
+const updatedValue = update(data, {
    'files.0.nonOptionalProperty': 'new name',
    'files.1.nonOptionalProperty': undefined, //no ts error
    'files.0.nonOptionalProperty': set('new name'),
@@ -83,11 +89,15 @@ Arguments:
 
 - Original Object
 - Update Object
+- Options (to change JS behaviour on non existing props and indexes)
+  - 'add': Adds non existing property/index.
+  - 'skip': Skips the update in the non-existing prop/index and still applies the rest of the possible updates.
+  - 'throw': Throws a JS error, usefull working with indexes making sure there are no "empty" indexes created if a new index is added which is bigger than the length of the current array.
 
 ## Example
 
 ```js
-import { updateImmutably } from "maraj";
+import { update } from "maraj";
 
 const data = {
     profile: { name: "Lukasz" },
@@ -98,7 +108,7 @@ const data = {
     ]
 }
 
-const newUpdatedObject = updateImmutably(data, {
+const newUpdatedObject = update(data, {
     "profile.name": "Lucas", //update values
     "works.1": "gs", //nested array update
     "history.1.available": (currentValue) => (!currentValue), //functional update
@@ -116,7 +126,7 @@ Arguments:
 ## Example
 
 ```js
-import { modifyImmutably } from "maraj";
+import { extendableUpdate } from "maraj";
 
 const data = {
     profile: { name: "Lukasz" },
@@ -127,7 +137,7 @@ const data = {
     ]
 }
 
-const newUpdatedObject = modifyImmutably(data, {
+const newUpdatedObject = extendableUpdate(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"
@@ -136,12 +146,12 @@ const newUpdatedObject = modifyImmutably(data, {
 
 ## Remove Utility
 
-Removes the **key of an object** or the **index of an array** in the key provided in the **updateImmutably.**
+Removes the **key of an object** or the **index of an array** in the key provided in the **update.**
 
 ```js
 import {remove} from 'maraj'
 
-const newUpdatedObject = updateImmutably(person,{
+const newUpdatedObject = update(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)
@@ -185,7 +195,7 @@ const [remainingPath, lastKey] = splitPathAtLastKey(stringPath)
 In some unusual cases (usually when updating an optional object prop inside an array) typescript infers incorrectly the optional key vs a key with undefined value. To fix this typing issue, use the "set" function so it correctly infers the type in the field.
 
 ```ts
-const updatedValue = updateImmutably(data, {
+const updatedValue = update(data, {
    'files.0.optionalProperty': 'new name',
    'files.1.optionalProperty': undefined, //no ts error
    'files.0.optionalProperty': set('new name'),

package/dist/index.d.mts

@@ -1,24 +1,46 @@
+/** Returns only the optional keys of an object. */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+/** Removes properties or indexes, order doesn't matter. */
+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.
+ * @param keys Keys to remove.
+ * @returns New object/array without the provided keys/indexes.
+ */
+declare const remove: Remove;
+
 /** 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;
+type OptionValues = 'error' | 'skip' | 'add';
+type Options = {
+    onNewProps?: OptionValues;
+    onNewIndexes?: OptionValues;
+};
+type ImmutableUpdate = <TObject extends Record<PropertyKey, any>>(state: TObject, dotPathUpdateObject: UpdateObject<TObject>, options?: Options) => TObject;
 /**
- * Creates a new object applying strict immutable updates using dot-path syntax. Can't add new props or indexes.
+ * Creates a new object applying immutable updates using dot-path syntax.
+ * Can add or skip new props or indexes depending on options.
+ * TYPESCRIPT: Dot-Path Update Object type must STRICTLY match the type of state.
  * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @param dotPathUpdateObject Dot Path Update Object.
+ * @param options Options to change JS behaviour on 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;
+declare const update: ImmutableUpdate;
+type ExtendableImmutableUpdate = <TObject extends Record<PropertyKey, any>, TUpdateObject extends UpdateObject<TObject>>(state: TObject, dotPathUpdateObject: TUpdateObject) => ExtendedUpdate<TObject, TUpdateObject>;
 /**
- * Creates a new object applying immutable modifications using dot-path syntax. It will add non-existent props or indexes if provided.
+ * Creates a new object applying immutable updates using dot-path syntax.
+ * It will always add non-existent props or indexes if provided.
+ * TYPESCRIPT: Dot-Path Update Object type extends from the type of state and you can add new non-existent properties.
  * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @param dotPathUpdateObject Dot Path Update Object.
  * @returns New Updated Object.
  */
-declare const modifyImmutably: ModifyImmutably;
+declare const extendableUpdate: ExtendableImmutableUpdate;
 
 /**
  * --------------------------------------------
@@ -37,11 +59,11 @@ type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false
  * --------------------------------------------
  */
 /** Dot-paths of an array. */
-type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? `${ArrayIndexes}` : `${ArrayIndexes}` | `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}` : `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}`;
+type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? number | `${ArrayIndexes}` : number | `${ArrayIndexes}` | `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}` : `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}`;
 /** Dot-paths of an object. */
 type ObjectPaths<T, TAllowedTypes> = {
-    [Key in keyof T & string]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPaths<T[Key], TAllowedTypes>}` : `${Key}.${DotPaths<T[Key], TAllowedTypes>}`;
-}[keyof T & string];
+    [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPaths<T[Key], TAllowedTypes>}` : `${Key}.${DotPaths<T[Key], TAllowedTypes>}`;
+}[keyof T & (string | number)];
 /** Dot-paths of a tuple. */
 type TuplePaths<T, TAllowedTypes> = ObjectPaths<Omit<T, keyof any[]>, TAllowedTypes>;
 /** Literal union of all posible dot-paths which satisfy provided types as second argument (default: any). */
@@ -52,53 +74,70 @@ type DotPaths<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? IsTup
  * --------------------------------------------
  */
 /** Nested type implementation. */
-type NestedType<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedType<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? NestedType<U, R> : never : never : never;
-/** Value of a nested property of a given dot-path. */
-type ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedType<TObject, TPath>;
+type ValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ValueInPath<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? ValueInPath<U, R> : never : never : never;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
 /** Returned nested type implementation. */
-type ReturnedNestedValue<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ReturnedNestedValue<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (ReturnedNestedValue<U, R> | undefined) : never : never : never;
-/** Value of a RETURNED nested property of a given dot-path (so when accessing arrays can be undefined). */
-type ReturnedValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = ReturnedNestedValue<TObject, TPath>;
+type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TPath extends number ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : TObject[TPath] : TObject[TPath] : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : never : TPath extends LiteralIndex ? never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ReturnedValueInPath<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (ReturnedValueInPath<U, R> | undefined) : never : never : never;
 /**
  * --------------------------------------------
  *  UPDATE OBJECT WITH DOT PATH IMPLEMENTATION
  * --------------------------------------------
  */
 /** Value of a dot-path update object, can be the value or a function. */
-type DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+type UpdateValue<TObject, TPath> = ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => ValueInPath<TObject, TPath>);
 /** Dot-path update object, used to give updates to the updateImmutably function. */
-type DotPathUpdateObject<TObject> = {
-    [TPath in DotPaths<TObject>]?: ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+type UpdateObject<TObject> = {
+    [TPath in DotPaths<TObject>]?: ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => ValueInPath<TObject, TPath>);
 };
 /**
  * --------------------------------------------
- *  REQUIRED OR OPTIONAL KEYS
+ *  EXTRACT TYPE FROM DOT-PATH UPDATE OBJECT
  * --------------------------------------------
  */
-/** Returns only the optional keys of an object. */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+/** Merging two objects */
+/** Keys which arent dot-path keys */
+type NonDotPathKeys<T> = {
+    [Key in keyof T]: Key extends `${infer K}.${string}` ? K : Key;
 }[keyof T];
-/** Returns only the required keys of an object. */
-type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+/** Keys which are an index */
+type KeysRepresentingAnIndex<T> = {
+    [Key in keyof T]: Key extends `${number}.${string}` ? never : Key;
 }[keyof T];
+/** Keys which start with an index */
+type KeyPathsStartingWithAnIndex<T> = {
+    [Key in keyof T]: Key extends `${number}.${string}` ? Key : never;
+}[keyof T];
+/** Keys which are paths and its first key-path is removed */
+type NestedPathKeys<T, K extends string | number> = {
+    [Key in keyof T]: Key extends `${K}.${infer U}` ? U : never;
+}[keyof T];
+/** Extract value if its a function */
+type Value<T> = T extends (...args: any) => any ? ReturnType<T> : T;
+/** To check if an empty object is provided */
+type EmptyObject = Record<string | number | symbol, never>;
+/** Used to extract the type from a dot-path update object. */
+type ExtractTypeFromDotPathUpdateObject<T extends Record<string, any>> = T extends EmptyObject ? {} : keyof T extends LiteralIndex | number | `${number}` | `${number}.${infer U}` ? Value<T[KeyPathsStartingWithAnIndex<T>]> extends never ? Array<Value<T[KeysRepresentingAnIndex<T>]>> : Array<Value<T[KeysRepresentingAnIndex<T>]> | {
+    [Key2 in U]: Value<T[KeyPathsStartingWithAnIndex<T>]>;
+}> : {
+    [Key1 in NonDotPathKeys<T> & string]: Key1 extends keyof T ? Value<T[Key1]> extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }> extends Array<infer W> ? Array<U | W> : Array<U> & ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }> : Value<T[Key1]> : ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }>;
+} & unknown;
+/** New expanded value after aplying updates including new properties */
+type ExtendedUpdate<TObject extends Record<string | number | symbol, any>, TDotPathUpdateObject extends Record<string | number | symbol, any>> = TObject extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> extends Array<infer W> ? Array<U | W> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> : ExtractTypeFromDotPathUpdateObject<TObject & TDotPathUpdateObject>;
 
-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.
- * @param keys Keys to remove.
- * @returns New object/array without the provided keys/indexes.
- */
-declare const remove: Remove;
-
-type Select = <TObject, TPath extends DotPaths<TObject> | ''>(state: TObject, path: TPath) => ReturnedValueInDotPath<TObject, TPath>;
+type Select = {
+    <T, TPath extends DotPaths<T>>(state: T, path: TPath): ReturnedValueInPath<T, TPath>;
+    <T, TPath extends ''>(state: T, path: TPath): T;
+};
 /**
  * Returns the value from a given dot path of an object/array or undefined if doesn't exist.
  * @param state State from which retrieve the value.
@@ -131,4 +170,4 @@ 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 OptionalKeys, type PrimitivesAndNativeObjects, type RequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, isObjectLiteral, isStringIndex, modifyImmutably, parseStringIndex, remove, select, set, splitPathAtLastKey, updateImmutably };
+export { type DotPaths, type LiteralIndex, type ReturnedValueInPath, type UpdateObject, type UpdateValue, type ValueInPath, extendableUpdate, isObjectLiteral, isStringIndex, parseStringIndex, remove, select, set, splitPathAtLastKey, update };

package/dist/index.d.ts

@@ -1,24 +1,46 @@
+/** Returns only the optional keys of an object. */
+type OptionalKeys<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+/** Removes properties or indexes, order doesn't matter. */
+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.
+ * @param keys Keys to remove.
+ * @returns New object/array without the provided keys/indexes.
+ */
+declare const remove: Remove;
+
 /** 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;
+type OptionValues = 'error' | 'skip' | 'add';
+type Options = {
+    onNewProps?: OptionValues;
+    onNewIndexes?: OptionValues;
+};
+type ImmutableUpdate = <TObject extends Record<PropertyKey, any>>(state: TObject, dotPathUpdateObject: UpdateObject<TObject>, options?: Options) => TObject;
 /**
- * Creates a new object applying strict immutable updates using dot-path syntax. Can't add new props or indexes.
+ * Creates a new object applying immutable updates using dot-path syntax.
+ * Can add or skip new props or indexes depending on options.
+ * TYPESCRIPT: Dot-Path Update Object type must STRICTLY match the type of state.
  * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @param dotPathUpdateObject Dot Path Update Object.
+ * @param options Options to change JS behaviour on 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;
+declare const update: ImmutableUpdate;
+type ExtendableImmutableUpdate = <TObject extends Record<PropertyKey, any>, TUpdateObject extends UpdateObject<TObject>>(state: TObject, dotPathUpdateObject: TUpdateObject) => ExtendedUpdate<TObject, TUpdateObject>;
 /**
- * Creates a new object applying immutable modifications using dot-path syntax. It will add non-existent props or indexes if provided.
+ * Creates a new object applying immutable updates using dot-path syntax.
+ * It will always add non-existent props or indexes if provided.
+ * TYPESCRIPT: Dot-Path Update Object type extends from the type of state and you can add new non-existent properties.
  * @param state Original State Object.
- * @param updates Dot Path Update Object.
- * @param addNonExistentPropsAndIndexes If it should or not create non-existent fields.
+ * @param dotPathUpdateObject Dot Path Update Object.
  * @returns New Updated Object.
  */
-declare const modifyImmutably: ModifyImmutably;
+declare const extendableUpdate: ExtendableImmutableUpdate;
 
 /**
  * --------------------------------------------
@@ -37,11 +59,11 @@ type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false
  * --------------------------------------------
  */
 /** Dot-paths of an array. */
-type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? `${ArrayIndexes}` : `${ArrayIndexes}` | `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}` : `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}`;
+type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? number | `${ArrayIndexes}` : number | `${ArrayIndexes}` | `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}` : `${ArrayIndexes}.${DotPaths<TInnerType, TAllowedTypes>}`;
 /** Dot-paths of an object. */
 type ObjectPaths<T, TAllowedTypes> = {
-    [Key in keyof T & string]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPaths<T[Key], TAllowedTypes>}` : `${Key}.${DotPaths<T[Key], TAllowedTypes>}`;
-}[keyof T & string];
+    [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPaths<T[Key], TAllowedTypes>}` : `${Key}.${DotPaths<T[Key], TAllowedTypes>}`;
+}[keyof T & (string | number)];
 /** Dot-paths of a tuple. */
 type TuplePaths<T, TAllowedTypes> = ObjectPaths<Omit<T, keyof any[]>, TAllowedTypes>;
 /** Literal union of all posible dot-paths which satisfy provided types as second argument (default: any). */
@@ -52,53 +74,70 @@ type DotPaths<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? IsTup
  * --------------------------------------------
  */
 /** Nested type implementation. */
-type NestedType<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedType<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? NestedType<U, R> : never : never : never;
-/** Value of a nested property of a given dot-path. */
-type ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedType<TObject, TPath>;
+type ValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ValueInPath<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? ValueInPath<U, R> : never : never : never;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
 /** Returned nested type implementation. */
-type ReturnedNestedValue<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends LiteralIndex ? never : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ReturnedNestedValue<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (ReturnedNestedValue<U, R> | undefined) : never : never : never;
-/** Value of a RETURNED nested property of a given dot-path (so when accessing arrays can be undefined). */
-type ReturnedValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = ReturnedNestedValue<TObject, TPath>;
+type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TPath extends number ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : TObject[TPath] : TObject[TPath] : TPath extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : never : TPath extends LiteralIndex ? never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? ReturnedValueInPath<TObject[K], R> : K extends LiteralIndex ? never : K extends `${number}` ? TObject extends ReadonlyArray<infer U> ? (ReturnedValueInPath<U, R> | undefined) : never : never : never;
 /**
  * --------------------------------------------
  *  UPDATE OBJECT WITH DOT PATH IMPLEMENTATION
  * --------------------------------------------
  */
 /** Value of a dot-path update object, can be the value or a function. */
-type DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+type UpdateValue<TObject, TPath> = ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => ValueInPath<TObject, TPath>);
 /** Dot-path update object, used to give updates to the updateImmutably function. */
-type DotPathUpdateObject<TObject> = {
-    [TPath in DotPaths<TObject>]?: ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+type UpdateObject<TObject> = {
+    [TPath in DotPaths<TObject>]?: ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => ValueInPath<TObject, TPath>);
 };
 /**
  * --------------------------------------------
- *  REQUIRED OR OPTIONAL KEYS
+ *  EXTRACT TYPE FROM DOT-PATH UPDATE OBJECT
  * --------------------------------------------
  */
-/** Returns only the optional keys of an object. */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+/** Merging two objects */
+/** Keys which arent dot-path keys */
+type NonDotPathKeys<T> = {
+    [Key in keyof T]: Key extends `${infer K}.${string}` ? K : Key;
 }[keyof T];
-/** Returns only the required keys of an object. */
-type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
+/** Keys which are an index */
+type KeysRepresentingAnIndex<T> = {
+    [Key in keyof T]: Key extends `${number}.${string}` ? never : Key;
 }[keyof T];
+/** Keys which start with an index */
+type KeyPathsStartingWithAnIndex<T> = {
+    [Key in keyof T]: Key extends `${number}.${string}` ? Key : never;
+}[keyof T];
+/** Keys which are paths and its first key-path is removed */
+type NestedPathKeys<T, K extends string | number> = {
+    [Key in keyof T]: Key extends `${K}.${infer U}` ? U : never;
+}[keyof T];
+/** Extract value if its a function */
+type Value<T> = T extends (...args: any) => any ? ReturnType<T> : T;
+/** To check if an empty object is provided */
+type EmptyObject = Record<string | number | symbol, never>;
+/** Used to extract the type from a dot-path update object. */
+type ExtractTypeFromDotPathUpdateObject<T extends Record<string, any>> = T extends EmptyObject ? {} : keyof T extends LiteralIndex | number | `${number}` | `${number}.${infer U}` ? Value<T[KeyPathsStartingWithAnIndex<T>]> extends never ? Array<Value<T[KeysRepresentingAnIndex<T>]>> : Array<Value<T[KeysRepresentingAnIndex<T>]> | {
+    [Key2 in U]: Value<T[KeyPathsStartingWithAnIndex<T>]>;
+}> : {
+    [Key1 in NonDotPathKeys<T> & string]: Key1 extends keyof T ? Value<T[Key1]> extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }> extends Array<infer W> ? Array<U | W> : Array<U> & ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }> : Value<T[Key1]> : ExtractTypeFromDotPathUpdateObject<{
+        [Key2 in NestedPathKeys<T, Key1>]: Value<T[`${Key1}.${Key2}`]>;
+    }>;
+} & unknown;
+/** New expanded value after aplying updates including new properties */
+type ExtendedUpdate<TObject extends Record<string | number | symbol, any>, TDotPathUpdateObject extends Record<string | number | symbol, any>> = TObject extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> extends Array<infer W> ? Array<U | W> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> : ExtractTypeFromDotPathUpdateObject<TObject & TDotPathUpdateObject>;
 
-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.
- * @param keys Keys to remove.
- * @returns New object/array without the provided keys/indexes.
- */
-declare const remove: Remove;
-
-type Select = <TObject, TPath extends DotPaths<TObject> | ''>(state: TObject, path: TPath) => ReturnedValueInDotPath<TObject, TPath>;
+type Select = {
+    <T, TPath extends DotPaths<T>>(state: T, path: TPath): ReturnedValueInPath<T, TPath>;
+    <T, TPath extends ''>(state: T, path: TPath): T;
+};
 /**
  * Returns the value from a given dot path of an object/array or undefined if doesn't exist.
  * @param state State from which retrieve the value.
@@ -131,4 +170,4 @@ 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 OptionalKeys, type PrimitivesAndNativeObjects, type RequiredKeys, type ReturnedValueInDotPath, type ValueInDotPath, isObjectLiteral, isStringIndex, modifyImmutably, parseStringIndex, remove, select, set, splitPathAtLastKey, updateImmutably };
+export { type DotPaths, type LiteralIndex, type ReturnedValueInPath, type UpdateObject, type UpdateValue, type ValueInPath, extendableUpdate, isObjectLiteral, isStringIndex, parseStringIndex, remove, select, set, splitPathAtLastKey, update };

package/dist/index.js

@@ -1 +1 @@
-"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});
+"use strict";var m=Object.defineProperty;var R=Object.getOwnPropertyDescriptor;var $=Object.getOwnPropertyNames;var k=Object.prototype.hasOwnProperty;var v=(e,t)=>{for(var r in t)m(e,r,{get:t[r],enumerable:!0})},C=(e,t,r,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let o of $(t))!k.call(e,o)&&o!==r&&m(e,o,{get:()=>t[o],enumerable:!(n=R(t,o))||n.enumerable});return e};var N=e=>C(m({},"__esModule",{value:!0}),e);var W={};v(W,{extendableUpdate:()=>L,isObjectLiteral:()=>d,isStringIndex:()=>y,parseStringIndex:()=>U,remove:()=>I,select:()=>j,set:()=>K,splitPathAtLastKey:()=>w,update:()=>E});module.exports=N(W);var I=(e,t)=>{if(!Array.isArray(e)&&e?.constructor!==Object)throw'Wrong type provided in "remove" function';let r=Array.isArray(t)?t:[t];if(Array.isArray(e)){let o=Symbol(),p=[...e];return r.forEach(s=>{p[s]=o}),p.filter(s=>s!==o)}let n={...e};return r.forEach(o=>delete n[o]),n};var j=(e,t)=>{if(typeof t!="string")throw new Error("path is not a string");if(!t)return e;let r=t.split("."),n=e;for(;r.length;){let o=r.join(".");if(n?.hasOwnProperty(o))return n[o];if(!n?.hasOwnProperty(r[0]))return;n=n[r[0]],r.shift()}return n};var w=e=>{if(typeof e!="string")throw new Error(`Wrong dotPath type: ${e}`);let t=e.lastIndexOf(".")+1,r=t?e.slice(0,t-1):"",n=e.slice(t);return[r,n]};var K=e=>()=>e;var d=e=>!!e&&Object.getPrototypeOf(e)===Object.prototype;var U=e=>{let t=parseInt(e);return t.toString()===e?t:null},y=e=>parseInt(e).toString()===e;var A=e=>JSON.stringify(e),h=e=>Array.isArray(e),g=(e,t,r={})=>{if(!d(e)&&!h(e))throw new Error(`"${A(e)}" is not an literalObject/array`);if(!d(t))throw new Error('wrong "updateObject" type provided');let n=Array.isArray(e)?[...e]:{...e},o={};for(let[p,x]of Object.entries(t)){if(p==="")continue;let s=p.split("."),l=o,i=n;for(;s.length>1;){let b=s.join(".");if(Object.hasOwn(i,b)){s=[b];break}let a=s[0],f=i[a],S=d(f),T=h(f),O=f===void 0;if(!S&&!T&&!O)throw new Error(`Property "${a}" in "${p}" is a primitive`);if(!l[a]){if(O){let V=h(i)&&y(a),D=y(s[1]),P=V?r.onNewIndexes:r.onNewProps;if(P==="error")throw new Error(`${a} doesn't exist in "${p}"`);if(P==="skip")continue;i[a]=D?[]:{}}else i[a]=T?[...f]:{...f};l[a]={}}i=i[a],l=l[a],s.shift()}let c=s[0],u=i;if(!Object.hasOwn(u,c)){let a=h(u)&&y(c)?r.onNewIndexes:r.onNewProps;if(a==="error")throw new Error(`Property/Index "${c}" doesnt exist in the path "${p}". Its value is: "${A(u)}"`);if(a==="skip")continue}u[c]=typeof x=="function"?x(u[c]):x,delete l[c]}return n},E=(e,t,r)=>g(e,t,r),L=(e,t)=>g(e,t);0&&(module.exports={extendableUpdate,isObjectLiteral,isStringIndex,parseStringIndex,remove,select,set,splitPathAtLastKey,update});

package/dist/index.mjs

@@ -1 +1 @@
-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};
+var U=(e,t)=>{if(!Array.isArray(e)&&e?.constructor!==Object)throw'Wrong type provided in "remove" function';let r=Array.isArray(t)?t:[t];if(Array.isArray(e)){let s=Symbol(),p=[...e];return r.forEach(a=>{p[a]=s}),p.filter(a=>a!==s)}let n={...e};return r.forEach(s=>delete n[s]),n};var A=(e,t)=>{if(typeof t!="string")throw new Error("path is not a string");if(!t)return e;let r=t.split("."),n=e;for(;r.length;){let s=r.join(".");if(n?.hasOwnProperty(s))return n[s];if(!n?.hasOwnProperty(r[0]))return;n=n[r[0]],r.shift()}return n};var g=e=>{if(typeof e!="string")throw new Error(`Wrong dotPath type: ${e}`);let t=e.lastIndexOf(".")+1,r=t?e.slice(0,t-1):"",n=e.slice(t);return[r,n]};var E=e=>()=>e;var u=e=>!!e&&Object.getPrototypeOf(e)===Object.prototype;var L=e=>{let t=parseInt(e);return t.toString()===e?t:null},f=e=>parseInt(e).toString()===e;var P=e=>JSON.stringify(e),h=e=>Array.isArray(e),I=(e,t,r={})=>{if(!u(e)&&!h(e))throw new Error(`"${P(e)}" is not an literalObject/array`);if(!u(t))throw new Error('wrong "updateObject" type provided');let n=Array.isArray(e)?[...e]:{...e},s={};for(let[p,x]of Object.entries(t)){if(p==="")continue;let a=p.split("."),d=s,i=n;for(;a.length>1;){let b=a.join(".");if(Object.hasOwn(i,b)){a=[b];break}let o=a[0],l=i[o],j=u(l),m=h(l),T=l===void 0;if(!j&&!m&&!T)throw new Error(`Property "${o}" in "${p}" is a primitive`);if(!d[o]){if(T){let w=h(i)&&f(o),K=f(a[1]),O=w?r.onNewIndexes:r.onNewProps;if(O==="error")throw new Error(`${o} doesn't exist in "${p}"`);if(O==="skip")continue;i[o]=K?[]:{}}else i[o]=m?[...l]:{...l};d[o]={}}i=i[o],d=d[o],a.shift()}let c=a[0],y=i;if(!Object.hasOwn(y,c)){let o=h(y)&&f(c)?r.onNewIndexes:r.onNewProps;if(o==="error")throw new Error(`Property/Index "${c}" doesnt exist in the path "${p}". Its value is: "${P(y)}"`);if(o==="skip")continue}y[c]=typeof x=="function"?x(y[c]):x,delete d[c]}return n},S=(e,t,r)=>I(e,t,r),V=(e,t)=>I(e,t);export{V as extendableUpdate,u as isObjectLiteral,f as isStringIndex,L as parseStringIndex,U as remove,A as select,E as set,g as splitPathAtLastKey,S as update};

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "maraj",
-   "version": "2.5.1",
+   "version": "2.7.0",
    "description": "A lightweight 600 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
    "keywords": [
       "shallow",