maraj 2.5.0 → 2.6.0

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,22 +22,33 @@ 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 (3rd parameter in the updateImmutably function), **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.
+})
+// 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 "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)
@@ -53,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
 
@@ -87,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
@@ -95,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.**
@@ -104,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"
 })
 ```
 
@@ -135,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,24 +1,47 @@
+/** 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 ObjectOrArray = Record<string | number | symbol, any>;
+type OptionValues = 'error' | 'skip' | 'add';
+type Options = {
+    onNewProps?: OptionValues;
+    onNewIndexes?: OptionValues;
+};
+type ImmutableUpdate = <TObject extends ObjectOrArray>(state: TObject, dotPathUpdateObject: DotPathUpdateObject<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 ObjectOrArray, TUpdateObject extends DotPathUpdateObject<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,7 +60,7 @@ 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>}`;
@@ -54,7 +77,7 @@ 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 ExactValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedType<TObject, TPath>;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
@@ -70,33 +93,51 @@ type ReturnedValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = Ret
  * --------------------------------------------
  */
 /** 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 DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = ExactValueInDotPath<TObject, TPath> | ((fieldValue: ExactValueInDotPath<TObject, TPath>) => ExactValueInDotPath<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>);
+    [TPath in DotPaths<TObject>]?: ExactValueInDotPath<TObject, TPath> | ((fieldValue: ExactValueInDotPath<TObject, TPath>) => ExactValueInDotPath<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];
-
-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;
+/** 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 Select = <TObject, TPath extends DotPaths<TObject> | ''>(state: TObject, path: TPath) => ReturnedValueInDotPath<TObject, TPath>;
 /**
@@ -131,4 +172,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 DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type ExactValueInDotPath, type LiteralIndex, type ReturnedValueInDotPath, extendableUpdate, isObjectLiteral, isStringIndex, parseStringIndex, remove, select, set, splitPathAtLastKey, update };

package/dist/index.d.ts

@@ -1,24 +1,47 @@
+/** 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 ObjectOrArray = Record<string | number | symbol, any>;
+type OptionValues = 'error' | 'skip' | 'add';
+type Options = {
+    onNewProps?: OptionValues;
+    onNewIndexes?: OptionValues;
+};
+type ImmutableUpdate = <TObject extends ObjectOrArray>(state: TObject, dotPathUpdateObject: DotPathUpdateObject<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 ObjectOrArray, TUpdateObject extends DotPathUpdateObject<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,7 +60,7 @@ 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>}`;
@@ -54,7 +77,7 @@ 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 ExactValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedType<TObject, TPath>;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
@@ -70,33 +93,51 @@ type ReturnedValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = Ret
  * --------------------------------------------
  */
 /** 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 DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = ExactValueInDotPath<TObject, TPath> | ((fieldValue: ExactValueInDotPath<TObject, TPath>) => ExactValueInDotPath<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>);
+    [TPath in DotPaths<TObject>]?: ExactValueInDotPath<TObject, TPath> | ((fieldValue: ExactValueInDotPath<TObject, TPath>) => ExactValueInDotPath<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];
-
-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;
+/** 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 Select = <TObject, TPath extends DotPaths<TObject> | ''>(state: TObject, path: TPath) => ReturnedValueInDotPath<TObject, TPath>;
 /**
@@ -131,4 +172,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 DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type ExactValueInDotPath, type LiteralIndex, type ReturnedValueInDotPath, 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 $=Object.getOwnPropertyDescriptor;var R=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 a of R(t))!k.call(e,a)&&a!==r&&m(e,a,{get:()=>t[a],enumerable:!(n=$(t,a))||n.enumerable});return e};var W=e=>C(m({},"__esModule",{value:!0}),e);var q={};v(q,{extendableUpdate:()=>L,isObjectLiteral:()=>d,isStringIndex:()=>y,parseStringIndex:()=>K,remove:()=>j,select:()=>P,set:()=>w,splitPathAtLastKey:()=>A,update:()=>D});module.exports=W(q);var j=(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 a=Symbol(),l=[...e];return r.forEach(s=>{l[s]=a}),l.filter(s=>s!==a)}let n={...e};return r.forEach(a=>delete n[a]),n};var P=(e,t)=>!t||typeof t!="string"?e:t.split(".").reduce((r,n)=>{if(r?.hasOwnProperty(n))return r[n]},e);var A=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 w=e=>()=>e;var d=e=>!!e&&Object.getPrototypeOf(e)===Object.prototype;var K=e=>{let t=parseInt(e);return t.toString()===e?t:null},y=e=>parseInt(e).toString()===e;var U=e=>JSON.stringify(e),O=(e,t)=>e.slice(0,t).join("."),g=e=>Array.isArray(e),E=(e,t,r={})=>{if(r={onNewProps:"add",onNewIndexes:"error",...r},!d(e)&&!Array.isArray(e))throw new Error(`"${U(e)}" is not an literalObject/array`);if(!d(t))throw new Error('wrong "updates" type provided');let n=Array.isArray(e)?[...e]:{...e},a={};for(let[l,f]of Object.entries(t)){if(!l)continue;let s=l.split("."),p=s.pop(),u=a,i=n;for(let c=0;c<s.length;c++){let o=s[c],x=i[o],S=d(x),h=g(x),T=x===void 0;if(!S&&!h&&!T)throw new Error(`Property "${o}" in "${O(s,c)}" is a primitive`);if(!u[o]){if(T){let V=g(i)&&y(o),N=y(s[c+1]??p),I=V?r.onNewIndexes:r.onNewProps;if(I==="error")throw new Error(`${o} doesn't exist in "${O(s,c)}"`);if(I==="skip")continue;i[o]=N?[]:{}}else i[o]=h?[...x]:{...x};u[o]={}}i=i[o],u=u[o]}let b=i;if(!b.hasOwnProperty(p)){let o=Array.isArray(b)&&y(p)?r.onNewIndexes:r.onNewProps;if(o==="error")throw new Error(`Property/Index "${p}" doesnt exist in the path "${O([...s,p])}". Its value is: "${U(b)}"`);if(o==="skip")continue}b[p]=typeof f=="function"?f(b[p]):f,delete u[p]}return n},D=(e,t,r)=>E(e,t,r),L=(e,t)=>E(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 c=Symbol(),d=[...e];return r.forEach(o=>{d[o]=c}),d.filter(o=>o!==c)}let a={...e};return r.forEach(c=>delete a[c]),a};var g=(e,t)=>!t||typeof t!="string"?e:t.split(".").reduce((r,a)=>{if(r?.hasOwnProperty(a))return r[a]},e);var E=e=>{if(typeof e!="string")throw new Error(`Wrong dotPath type: ${e}`);let t=e.lastIndexOf(".")+1,r=t?e.slice(0,t-1):"",a=e.slice(t);return[r,a]};var D=e=>()=>e;var b=e=>!!e&&Object.getPrototypeOf(e)===Object.prototype;var L=e=>{let t=parseInt(e);return t.toString()===e?t:null},x=e=>parseInt(e).toString()===e;var I=e=>JSON.stringify(e),m=(e,t)=>e.slice(0,t).join("."),j=e=>Array.isArray(e),P=(e,t,r={})=>{if(r={onNewProps:"add",onNewIndexes:"error",...r},!b(e)&&!Array.isArray(e))throw new Error(`"${I(e)}" is not an literalObject/array`);if(!b(t))throw new Error('wrong "updates" type provided');let a=Array.isArray(e)?[...e]:{...e},c={};for(let[d,f]of Object.entries(t)){if(!d)continue;let o=d.split("."),s=o.pop(),y=c,p=a;for(let i=0;i<o.length;i++){let n=o[i],u=p[n],A=b(u),O=j(u),h=u===void 0;if(!A&&!O&&!h)throw new Error(`Property "${n}" in "${m(o,i)}" is a primitive`);if(!y[n]){if(h){let w=j(p)&&x(n),K=x(o[i+1]??s),T=w?r.onNewIndexes:r.onNewProps;if(T==="error")throw new Error(`${n} doesn't exist in "${m(o,i)}"`);if(T==="skip")continue;p[n]=K?[]:{}}else p[n]=O?[...u]:{...u};y[n]={}}p=p[n],y=y[n]}let l=p;if(!l.hasOwnProperty(s)){let n=Array.isArray(l)&&x(s)?r.onNewIndexes:r.onNewProps;if(n==="error")throw new Error(`Property/Index "${s}" doesnt exist in the path "${m([...o,s])}". Its value is: "${I(l)}"`);if(n==="skip")continue}l[s]=typeof f=="function"?f(l[s]):f,delete y[s]}return a},S=(e,t,r)=>P(e,t,r),V=(e,t)=>P(e,t);export{V as extendableUpdate,b as isObjectLiteral,x as isStringIndex,L as parseStringIndex,U as remove,g as select,D as set,E as splitPathAtLastKey,S as update};

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "maraj",
-   "version": "2.5.0",
-   "description": "A lightweight 500 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
+   "version": "2.6.0",
+   "description": "A lightweight 600 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
    "keywords": [
       "shallow",
       "shallow copy",