maraj 2.0.0 → 2.2.0

package/README.md

@@ -1,102 +1,100 @@
 
 # Maraj
 
-A lightweight alternative for creating **immutable updates of objects and arrays** such as Immer or ImmutableJS.
+A fast lightweight utility for creating **immutable updates**. Full typescript support. Only 600 bytes gziped. Includes usefull utilities for manipulating updates (like remove, select).
 
-**4 times faster** and **over 10 times lighter**.
+### Features
 
-Fully typed.
+- Full typescript support.
+- Correct type inference.
+- Multiple updates at same time mantaining the order of execution.
+- Functional updates.
 
-Only **400 bytes** gziped and additional **300 bytes** for 4 common utilities that you will most likelly need in every project.
+**<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)
 
-Features:
+```ts
+const originalValue = { name: 'one', lastname: 'two' modified: false, files: [{ filename: 'one' }] }
 
-- Can accept multiple updates while mantaining the order of execution.
-- Easy syntax for conditional updates.
-- Functional updates.
+const updatedValue = updateImmutably(orignalValue, {
+   'name': 'updated',
+   'modified': (value, fullObject) => !value,
+   'files.0.filename': 'zero',
+})
 
-Set "strictNullChecks" and "noUncheckedIndexedAccess" to true in tsconfig.json for correct type inference in optional properties (so it can correctly differentiate between optional props and props with possible undefined value)
+// updatedValue = { name: 'updated', lastname: 'two' modified: true, files: [{ filename: 'zero' }] }
 
-## Creating an Immutable Update
+originalValue.files[1] === updatedValue.files[1] // true
+```
 
-The **updateImmutably** function has two arguments:
+### Limitations
 
-1. The **Original object**.
-2. An **Update object** (key-value pairs representing the updates we want to make)
+- If "addNonExistentPropsAndIndexes" is enabled, numbers will always create an array if the array/object doesnt exist beforehand.
 
-The **Update Object** has the following syntax:
+```ts
+const updatedValue = updateImmutably({}, {
+   'files.1.name': 'new name',
+}, true)
+// updatedValue = { files: [<empty>, { name: 'new name' }] }
+```
 
-```js
-{
-    'my.path.separated.by.dots': 'The new value',
-    'another.path': 'new value',
-    'myArray.0.name': 'new name in object inside array at index 0',
-    [false && 'path.conditionalUpdate']: true
+- 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)
+
+```ts
+const updateFieldStore = <TPath extends DotPaths<Store>>(
+   path: TPath,
+   newValue: UpdateDotPathValue<Store, TPath>
+) => {
+   const update: UpdateDotPathObject<Store> = {
+      // ^throws ts error even if the typing is correct
+      [path]: newValue
+   } // fix: coherce it with " as UpdateDotPathObject<Store>"
+   return update
 }
 ```
 
-Multiple key-value pairs that mantains the order of execution.
+- 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.
+
+```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.
+})
+```
+
+## Creating an Immutable Update
 
-- **Keys:** path name of the fiels, separated by dots.
-  - For arrays just use its index value
-  - Can accept conditional statements. (If the key = false or undefined or null it will skip that field update.)
+Arguments:
 
-- **Value:** new value, any type. If its a function it ll be called with the current value in that field.
+- Original Object
+- Update Object
+- If it should add non-existent properties/indexes
 
 ## Example
 
 ```js
-import updateImmutably, { spread } from "maraj";
+import { updateImmutably } from "maraj";
 
 const data = {
-    person: { name: "Lukasz", works: ["soum", "fi"] },
-    works: [
+    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 = updateImmutably(data, {
-    "age": 28, //add new values
-    "person.name": "Lucas", //update values
-    "person.works.1": "gs", //nested array update
-    "works.1.available": (currentValue) => (!currentValue), //functional update
-    [false && "works.0.size"]: 120, //conditional field update
-    "person.works": (v) => spread(v, "portfolio") //common utilities
+    "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
+    "works": (v) => [...v, 'portfolio'] //add new value to array
 })
-
-/** Does not make a deep copy and "falsy" fields are ignored */
-newUpdatedObject.works[0] === data.works[0] //true
-
-/** New Updated Object 
-{
-    person: { name: "Lucas", works: ["soum", "gs", "portfolio"], age: 28 },
-    works: [
-        { title: "soum", size: 90, available: true, info: ["info1"] },
-        { title: "fi", size: 30, available: true, info: ["infoA"] },
-    ]
-}
-*/
 ```
 
-## Other Utilities
-
-### spread
-
-**For Objects and Arrays: Spreads** its argument into the key provided in the updateImmutably.
-**For the rest: Sets** its argument into the key provided in the updateImmutably.
-
-```js
-import {spread} from 'maraj'
-
-const newUpdatedObject = updateImmutably(data,{
-    'person': (value) => spread(value, {info1: 'new Info'}), //same as (newValue) => (value) => ({...value, ...newValue})
-    'works': (value) => spread(value, {title: 'new project', size: 20}) //same as (newValueToAdd) => (value) => ([...value, ...newValueToAdd])
-    'person.works': (value) => spread(value, "portfolio") //same as (newValue) => (value) => (newValue)
-})
-```
-
-### remove
+## Remove Utility
 
 Removes the **key of an object** or the **index of an array** in the key provided in the **updateImmutably.**
 
@@ -104,36 +102,35 @@ Removes the **key of an object** or the **index of an array** in the key provide
 import {remove} from 'maraj'
 
 const newUpdatedObject = updateImmutably(person,{
-    'person': (value) => remove(value, 'works'), // returns new value (in this case "person") without the provided key ("works")
-    'works': (value) => remove(value, 1) // returns new array (in this case "works") without the provided index (1)
+    'profile': (value) => remove(value, 'name'), // returns new value without the "name" 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)
 })
 ```
 
-### select
-
-**Creates a store selector** from provided string path.
+## Select Utility
 
-Usefull in cases like getting data from Redux, Zustand, and so on. stores.
+Selects the value of an object/array from a string-dot-path. Usefull in state management libraries.
 
 ```js
 import {select} from 'maraj'
 
 const stringPath = 'works.1.size'
 
-const storeSelector = (state) => select(state, stringPath) // will behave as (store) => store[works][1][size]
+const work1SizeSelector = (state) => select(state, stringPath) // will behave as (store) => store[works][1][size]
 ```
 
-### splitPathAtLastKey
+## SplitPathAtLastKey Utility
 
-Usefull when you want to spread multiple values into objects dynamically
+Usefull when you want to retrieve the last key (for example an id).
 
 Splits string path (example:'projects.1.data.size' ) into two:
 
-- id: the last key in the path (in this case 'size')
 - remainingPath: the remaining path (in this case 'projects.1.data')
+- lastKey: the last key in the path (in this case 'size')
 
 ```js
-import {splitPathAtLastKey} from 'maraj'
+import { splitPathAtLastKey } from 'maraj'
 
 const stringPath = 'works.1.size'
 
@@ -141,3 +138,16 @@ const [remainingPath, last] = splitPathAtLastKey(stringPath)
 // last = 'size'
 // remainingPath = 'works.1'
 ```
+
+## Set Utility
+
+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, {
+   '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.
+})
+```

package/dist/index.d.mts

@@ -1,25 +1,17 @@
-type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (keyof T | (keyof T)[])) => T;
-/**
- * Removes properties or indexes, order doesn't matter.
- */
-declare const remove: Remove;
-
 /**
  * Paths implementation
  */
 type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
 type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
 type Index = '_INDEX_';
-type RootArrayPathEnum = `${number}` | Index;
-type ArrayPathEnum<TLength extends boolean> = TLength extends true ? RootArrayPathEnum | 'length' : RootArrayPathEnum;
-type ArrayPaths<TInnerType, TLength extends boolean> = `${ArrayPathEnum<TLength>}` | `${ArrayPathEnum<false>}.${RootFlatten<TInnerType, TLength>}`;
-type FilteredTuple<T, TLength> = TLength extends string ? Omit<T, Exclude<keyof any[], 'length'>> : Omit<T, keyof any[]>;
-type ObjectPaths<T, TLength extends boolean> = {
-    [Key in keyof T & string]: `${Key}` | `${Key}.${RootFlatten<T[Key], TLength>}`;
+type ArrayIndexPaths = `${number}` | Index;
+type ArrayPaths<TInnerType> = `${ArrayIndexPaths}` | `${ArrayIndexPaths}.${Flatten<TInnerType>}`;
+type ObjectPaths<T> = {
+    [Key in keyof T & string]: `${Key}` | `${Key}.${Flatten<T[Key]>}`;
 }[keyof T & string];
-type RootFlatten<T, TIncludeLength extends boolean> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? ObjectPaths<FilteredTuple<T, TIncludeLength>, TIncludeLength> : ArrayPaths<U, TIncludeLength> : T extends string ? TIncludeLength extends true ? 'length' : never : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T, TIncludeLength>;
-type DotPaths<T> = RootFlatten<T, false>;
-type DotPathsIncludingLength<T> = RootFlatten<T, true>;
+type TuplePaths<T> = ObjectPaths<Omit<T, keyof any[]>>;
+type Flatten<T> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? TuplePaths<T> : ArrayPaths<U> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T>;
+type DotPaths<T> = Flatten<T>;
 /**
  * Type to know when a path is indexing an array
  */
@@ -27,14 +19,31 @@ type PathIndexingArray<T extends string | number> = `${T}` | `${T}.${string}` |
 /**
  * Nested Property Type implementation
  */
-type NestedProperty<TObject, TPath extends string> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends (`${number}` | Index) ? TObject extends Array<infer U> ? TPath extends `${number}.${infer K}` ? K extends keyof U ? NestedProperty<U, K> : never : U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedProperty<Required<TObject>[K], R> : K extends `${number}` | Index ? TObject extends Array<infer U> ? NestedProperty<U, R> : never : never : never;
+type NestedProperty<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends (`${number}` | Index) ? TObject extends Array<infer U> ? TPath extends `${number}.${infer K}` ? K extends keyof U ? NestedProperty<U, K> : never : U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedProperty<Required<TObject>[K], R> : K extends `${number}` | Index ? TObject extends Array<infer U> ? NestedProperty<U, R> : never : never : never;
 type ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedProperty<TObject, TPath>;
+type DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = TPath extends PathIndexingArray<Index> ? [`PATH ERROR: replace _INDEX_ with a NUMBER`, ValueInDotPath<TObject, TPath>, ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>)] : ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
 /**
  * Update Object Type Implementation
  */
-type DotPathUpdateObject<T> = Partial<{
-    [K in DotPaths<T>]: K extends PathIndexingArray<Index> ? [`TS PATH ERROR: replace _INDEX_ with {NUMBER}`, ValueInDotPath<T, K>, ((value: ValueInDotPath<T, K>) => ValueInDotPath<T, K>)] : ValueInDotPath<T, K> | ((value: ValueInDotPath<T, K>) => ValueInDotPath<T, K>);
-}>;
+type DotPathUpdateObject<TObject> = {
+    [TKey in DotPaths<TObject>]?: DotPathUpdateValue<TObject, TKey>;
+};
+/**
+ * Optional and Required keys
+ */
+type NonPartialKeys = string | number | boolean | symbol | bigint | null | object;
+type OptionalKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
+}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
+}[keyof T & string];
+
+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.
+ */
+declare const remove: Remove;
 
 type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, path: TPath) => TPath extends PathIndexingArray<Index> ? never : TPath extends PathIndexingArray<number> ? ValueInDotPath<T, TPath> | undefined : ValueInDotPath<T, TPath>;
 /**
@@ -43,47 +52,26 @@ type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, pat
  */
 declare const select: Select;
 
-type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [string, string];
+type PathWithoutLastKey = string;
+type LastKey = string;
+type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastKey, LastKey];
 /**
  * Splits string dotPath into ID and RemainingPath
 */
 declare const splitPathAtLastKey: SplitDotPathAtLastKey;
 
-type Spread = <T extends object>(value: T, update: T extends Array<infer U> ? Array<U> : Partial<T>) => T;
-/**
- * Spreads if its an object or array to the target, if its not then returns same value
- */
-declare const spread: Spread;
-
 type Set = <T>(newValue: T) => (value: T) => T;
 /**
  * Allows to set strongly typed values (removing inacurate "undefined" inference) in nested values inside arrays
  */
 declare const set: Set;
 
-type SemiStrictMode = 'skip-non-existent-paths';
-type NonStrictMode = 'implement-non-existent-paths';
-type UpdateImmutably = {
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>): T;
-};
+type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
 /**
  * Creates a new updated object/array applying the changes provided in the update object.
  * It doesnt modify the original input.
  * If any of the paths doesnt exists it returns
  */
 declare const updateImmutably: UpdateImmutably;
-type PosibleExpandedProps<T> = {
-    [K in keyof T]?: T[K] extends object ? PosibleExpandedProps<T[K]> & Record<any, any> : T[K];
-};
-type UpdateImmutablyNonStrictly = {
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>, mode: SemiStrictMode): T;
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>, mode: NonStrictMode): PosibleExpandedProps<T>;
-};
-/**
- * Creates a new updated object/array applying the changes provided in the update object.
- * It doesnt modify the original input.
- * If any of the paths doesnt exists it adds it if possible.
- */
-declare const updateImmutablyAllowingNewProps: UpdateImmutablyNonStrictly;
 
-export { type DotPathUpdateObject, type DotPaths, type DotPathsIncludingLength, type ValueInDotPath, remove, select, set, splitPathAtLastKey, spread, updateImmutably, updateImmutablyAllowingNewProps };
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type RequiredKeys, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.d.ts

@@ -1,25 +1,17 @@
-type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (keyof T | (keyof T)[])) => T;
-/**
- * Removes properties or indexes, order doesn't matter.
- */
-declare const remove: Remove;
-
 /**
  * Paths implementation
  */
 type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
 type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
 type Index = '_INDEX_';
-type RootArrayPathEnum = `${number}` | Index;
-type ArrayPathEnum<TLength extends boolean> = TLength extends true ? RootArrayPathEnum | 'length' : RootArrayPathEnum;
-type ArrayPaths<TInnerType, TLength extends boolean> = `${ArrayPathEnum<TLength>}` | `${ArrayPathEnum<false>}.${RootFlatten<TInnerType, TLength>}`;
-type FilteredTuple<T, TLength> = TLength extends string ? Omit<T, Exclude<keyof any[], 'length'>> : Omit<T, keyof any[]>;
-type ObjectPaths<T, TLength extends boolean> = {
-    [Key in keyof T & string]: `${Key}` | `${Key}.${RootFlatten<T[Key], TLength>}`;
+type ArrayIndexPaths = `${number}` | Index;
+type ArrayPaths<TInnerType> = `${ArrayIndexPaths}` | `${ArrayIndexPaths}.${Flatten<TInnerType>}`;
+type ObjectPaths<T> = {
+    [Key in keyof T & string]: `${Key}` | `${Key}.${Flatten<T[Key]>}`;
 }[keyof T & string];
-type RootFlatten<T, TIncludeLength extends boolean> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? ObjectPaths<FilteredTuple<T, TIncludeLength>, TIncludeLength> : ArrayPaths<U, TIncludeLength> : T extends string ? TIncludeLength extends true ? 'length' : never : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T, TIncludeLength>;
-type DotPaths<T> = RootFlatten<T, false>;
-type DotPathsIncludingLength<T> = RootFlatten<T, true>;
+type TuplePaths<T> = ObjectPaths<Omit<T, keyof any[]>>;
+type Flatten<T> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? TuplePaths<T> : ArrayPaths<U> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T>;
+type DotPaths<T> = Flatten<T>;
 /**
  * Type to know when a path is indexing an array
  */
@@ -27,14 +19,31 @@ type PathIndexingArray<T extends string | number> = `${T}` | `${T}.${string}` |
 /**
  * Nested Property Type implementation
  */
-type NestedProperty<TObject, TPath extends string> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends (`${number}` | Index) ? TObject extends Array<infer U> ? TPath extends `${number}.${infer K}` ? K extends keyof U ? NestedProperty<U, K> : never : U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedProperty<Required<TObject>[K], R> : K extends `${number}` | Index ? TObject extends Array<infer U> ? NestedProperty<U, R> : never : never : never;
+type NestedProperty<TObject, TPath> = TPath extends '' ? TObject : TPath extends keyof TObject ? TObject[TPath] : TPath extends (`${number}` | Index) ? TObject extends Array<infer U> ? TPath extends `${number}.${infer K}` ? K extends keyof U ? NestedProperty<U, K> : never : U : never : TPath extends `${infer K}.${infer R}` ? K extends keyof TObject ? NestedProperty<Required<TObject>[K], R> : K extends `${number}` | Index ? TObject extends Array<infer U> ? NestedProperty<U, R> : never : never : never;
 type ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedProperty<TObject, TPath>;
+type DotPathUpdateValue<TObject, TPath extends DotPaths<TObject>> = TPath extends PathIndexingArray<Index> ? [`PATH ERROR: replace _INDEX_ with a NUMBER`, ValueInDotPath<TObject, TPath>, ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>)] : ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
 /**
  * Update Object Type Implementation
  */
-type DotPathUpdateObject<T> = Partial<{
-    [K in DotPaths<T>]: K extends PathIndexingArray<Index> ? [`TS PATH ERROR: replace _INDEX_ with {NUMBER}`, ValueInDotPath<T, K>, ((value: ValueInDotPath<T, K>) => ValueInDotPath<T, K>)] : ValueInDotPath<T, K> | ((value: ValueInDotPath<T, K>) => ValueInDotPath<T, K>);
-}>;
+type DotPathUpdateObject<TObject> = {
+    [TKey in DotPaths<TObject>]?: DotPathUpdateValue<TObject, TKey>;
+};
+/**
+ * Optional and Required keys
+ */
+type NonPartialKeys = string | number | boolean | symbol | bigint | null | object;
+type OptionalKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
+}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
+}[keyof T & string];
+
+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.
+ */
+declare const remove: Remove;
 
 type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, path: TPath) => TPath extends PathIndexingArray<Index> ? never : TPath extends PathIndexingArray<number> ? ValueInDotPath<T, TPath> | undefined : ValueInDotPath<T, TPath>;
 /**
@@ -43,47 +52,26 @@ type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, pat
  */
 declare const select: Select;
 
-type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [string, string];
+type PathWithoutLastKey = string;
+type LastKey = string;
+type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastKey, LastKey];
 /**
  * Splits string dotPath into ID and RemainingPath
 */
 declare const splitPathAtLastKey: SplitDotPathAtLastKey;
 
-type Spread = <T extends object>(value: T, update: T extends Array<infer U> ? Array<U> : Partial<T>) => T;
-/**
- * Spreads if its an object or array to the target, if its not then returns same value
- */
-declare const spread: Spread;
-
 type Set = <T>(newValue: T) => (value: T) => T;
 /**
  * Allows to set strongly typed values (removing inacurate "undefined" inference) in nested values inside arrays
  */
 declare const set: Set;
 
-type SemiStrictMode = 'skip-non-existent-paths';
-type NonStrictMode = 'implement-non-existent-paths';
-type UpdateImmutably = {
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>): T;
-};
+type UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
 /**
  * Creates a new updated object/array applying the changes provided in the update object.
  * It doesnt modify the original input.
  * If any of the paths doesnt exists it returns
  */
 declare const updateImmutably: UpdateImmutably;
-type PosibleExpandedProps<T> = {
-    [K in keyof T]?: T[K] extends object ? PosibleExpandedProps<T[K]> & Record<any, any> : T[K];
-};
-type UpdateImmutablyNonStrictly = {
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>, mode: SemiStrictMode): T;
-    <T extends object>(state: T, updates: DotPathUpdateObject<T>, mode: NonStrictMode): PosibleExpandedProps<T>;
-};
-/**
- * Creates a new updated object/array applying the changes provided in the update object.
- * It doesnt modify the original input.
- * If any of the paths doesnt exists it adds it if possible.
- */
-declare const updateImmutablyAllowingNewProps: UpdateImmutablyNonStrictly;
 
-export { type DotPathUpdateObject, type DotPaths, type DotPathsIncludingLength, type ValueInDotPath, remove, select, set, splitPathAtLastKey, spread, updateImmutably, updateImmutablyAllowingNewProps };
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type RequiredKeys, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.js

@@ -1 +1 @@
-"use strict";var u=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var S=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var D=(t,e)=>{for(var o in e)u(t,o,{get:e[o],enumerable:!0})},w=(t,e,o,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of S(e))!j.call(t,a)&&a!==o&&u(t,a,{get:()=>e[a],enumerable:!(n=I(e,a))||n.enumerable});return t};var K=t=>w(u({},"__esModule",{value:!0}),t);var g={};D(g,{remove:()=>h,select:()=>f,set:()=>x,splitPathAtLastKey:()=>m,spread:()=>T,updateImmutably:()=>P,updateImmutablyAllowingNewProps:()=>A});module.exports=K(g);var h=(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 a=Symbol(),p=[...t];return o.forEach(i=>{p[i]=a}),p.filter(i=>i!==a)}let n={...t};return o.forEach(a=>delete n[a]),n};var f=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((o,n)=>{if(o?.hasOwnProperty(n))return o[n]},t);var m=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,o=e?t.slice(0,e-1):"",n=t.slice(e);return[o,n]};var T=(t,e)=>t?.constructor===Object&&e?.constructor===Object?{...t,...e}:Array.isArray(t)&&Array.isArray(e)?[...t,...e]:t;var x=t=>()=>t;var b=(t,e,o="strict-paths")=>{if(t?.constructor!==Object&&!Array.isArray(t))throw new Error(`${t} is not an object/array so cant be updated immutably`);if(!e)return t;let n=Array.isArray(t)?[...t]:{...t},a={};for(let[p,l]of Object.entries(e)){if(!p||p==="false"||p==="undefined"||p==="null")continue;let i=p.split("."),y=i.pop(),c=a,s=n;for(let r of i){if(!s[r]||typeof s[r]!="object"||s[r].constructor!==Object&&!Array.isArray(s[r]))throw new Error(`Invalid path provided: "${r}" is not an object/array in "${p}"`);c[r]||(s[r]=Array.isArray(s[r])?[...s[r]]:{...s[r]},c[r]={}),s=s[r],c=c[r]}let d=s;if(o!=="implement-non-existent-paths"){let r=o==="skip-non-existent-paths";if(Array.isArray(d)&&!(y<d.length)){if(r)continue;throw new Error(`Use spread to add indexes in ${i.join(".")}, because index ${y} doesnt exist in ${y}`)}if(!d.hasOwnProperty(y)){if(r)continue;throw new Error(`Property ${y} doesnt exist in the path ${i.join(".")} because its current value is: ${d}`)}}d[y]=typeof l=="function"?l(d[y]):l,delete c[y]}return n},P=b,A=b;0&&(module.exports={remove,select,set,splitPathAtLastKey,spread,updateImmutably,updateImmutablyAllowingNewProps});
+"use strict";var f=Object.defineProperty;var I=Object.getOwnPropertyDescriptor;var D=Object.getOwnPropertyNames;var w=Object.prototype.hasOwnProperty;var j=(t,e)=>{for(var r in e)f(t,r,{get:e[r],enumerable:!0})},O=(t,e,r,a)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of D(e))!w.call(t,o)&&o!==r&&f(t,o,{get:()=>e[o],enumerable:!(a=I(e,o))||a.enumerable});return t};var g=t=>O(f({},"__esModule",{value:!0}),t);var v={};j(v,{remove:()=>x,select:()=>T,set:()=>b,splitPathAtLastKey:()=>m,updateImmutably:()=>A});module.exports=g(v);var x=(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 o=Symbol(),y=[...t];return r.forEach(n=>{y[n]=o}),y.filter(n=>n!==o)}let a={...t};return r.forEach(o=>delete a[o]),a};var T=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((r,a)=>{if(r?.hasOwnProperty(a))return r[a]},t);var m=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,r=e?t.slice(0,e-1):"",a=t.slice(e);return[r,a]};var b=t=>()=>t;var A=(t,e,r)=>{if(t?.constructor!==Object&&!Array.isArray(t))throw new Error(`${t} is not an object/array`);if(!e)return t;let a=Array.isArray(t)?[...t]:{...t},o={};for(let[y,l]of Object.entries(e)){if(!y)continue;let n=y.split("."),s=n.pop(),c=o,d=a;for(let u=0;u<n.length;u++){let i=n[u],p=d[i],K=typeof p=="object"&&(p.constructor===Object||Array.isArray(p)),P=r&&p===void 0;if(!K&&!P)throw new Error(`Invalid path provided: "${i}" is not an object/array in "${y}"`);c[i]||(P?d[i]=isNaN(n[u+1]??s)?{}:[]:d[i]=Array.isArray(p)?[...p]:{...p},c[i]={}),d=d[i],c=c[i]}let h=d;if(!r){if(Array.isArray(h)&&!(s<h.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(!h.hasOwnProperty(s))throw new Error(`Property ${s} doesnt exist in the path ${n.join(".")} because its value is ${h}`)}h[s]=typeof l=="function"?l(h[s],a):l,delete c[s]}return a};0&&(module.exports={remove,select,set,splitPathAtLastKey,updateImmutably});

package/dist/index.mjs

@@ -1 +1 @@
-var h=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let n=Array.isArray(e)?e:[e];if(Array.isArray(t)){let y=Symbol(),s=[...t];return n.forEach(p=>{s[p]=y}),s.filter(p=>p!==y)}let a={...t};return n.forEach(y=>delete a[y]),a};var f=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((n,a)=>{if(n?.hasOwnProperty(a))return n[a]},t);var m=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,n=e?t.slice(0,e-1):"",a=t.slice(e);return[n,a]};var T=(t,e)=>t?.constructor===Object&&e?.constructor===Object?{...t,...e}:Array.isArray(t)&&Array.isArray(e)?[...t,...e]:t;var x=t=>()=>t;var u=(t,e,n="strict-paths")=>{if(t?.constructor!==Object&&!Array.isArray(t))throw new Error(`${t} is not an object/array so cant be updated immutably`);if(!e)return t;let a=Array.isArray(t)?[...t]:{...t},y={};for(let[s,l]of Object.entries(e)){if(!s||s==="false"||s==="undefined"||s==="null")continue;let p=s.split("."),i=p.pop(),c=y,o=a;for(let r of p){if(!o[r]||typeof o[r]!="object"||o[r].constructor!==Object&&!Array.isArray(o[r]))throw new Error(`Invalid path provided: "${r}" is not an object/array in "${s}"`);c[r]||(o[r]=Array.isArray(o[r])?[...o[r]]:{...o[r]},c[r]={}),o=o[r],c=c[r]}let d=o;if(n!=="implement-non-existent-paths"){let r=n==="skip-non-existent-paths";if(Array.isArray(d)&&!(i<d.length)){if(r)continue;throw new Error(`Use spread to add indexes in ${p.join(".")}, because index ${i} doesnt exist in ${i}`)}if(!d.hasOwnProperty(i)){if(r)continue;throw new Error(`Property ${i} doesnt exist in the path ${p.join(".")} because its current value is: ${d}`)}}d[i]=typeof l=="function"?l(d[i]):l,delete c[i]}return a},b=u,P=u;export{h as remove,f as select,x as set,m as splitPathAtLastKey,T as spread,b as updateImmutably,P as updateImmutablyAllowingNewProps};
+var x=(t,e)=>{if(!Array.isArray(t)&&t?.constructor!==Object)throw'Wrong type provided in "remove" function';let a=Array.isArray(e)?e:[e];if(Array.isArray(t)){let p=Symbol(),y=[...t];return a.forEach(o=>{y[o]=p}),y.filter(o=>o!==p)}let r={...t};return a.forEach(p=>delete r[p]),r};var T=(t,e)=>!e||typeof e!="string"?t:e.split(".").reduce((a,r)=>{if(a?.hasOwnProperty(r))return a[r]},t);var m=t=>{if(typeof t!="string")throw new Error(`Wrong dotPath type: ${t}`);let e=t.lastIndexOf(".")+1,a=e?t.slice(0,e-1):"",r=t.slice(e);return[a,r]};var b=t=>()=>t;var A=(t,e,a)=>{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,l]of Object.entries(e)){if(!y)continue;let o=y.split("."),n=o.pop(),c=p,d=r;for(let u=0;u<o.length;u++){let s=o[u],i=d[s],P=typeof i=="object"&&(i.constructor===Object||Array.isArray(i)),f=a&&i===void 0;if(!P&&!f)throw new Error(`Invalid path provided: "${s}" is not an object/array in "${y}"`);c[s]||(f?d[s]=isNaN(o[u+1]??n)?{}:[]:d[s]=Array.isArray(i)?[...i]:{...i},c[s]={}),d=d[s],c=c[s]}let h=d;if(!a){if(Array.isArray(h)&&!(n<h.length))throw new Error(`Index ${n} doesnt exist in the path ${o.join(".")} because its value is ${n}, use spread operator for adding new indexes`);if(!h.hasOwnProperty(n))throw new Error(`Property ${n} doesnt exist in the path ${o.join(".")} because its value is ${h}`)}h[n]=typeof l=="function"?l(h[n],r):l,delete c[n]}return r};export{x as remove,T as select,b as set,m as splitPathAtLastKey,A as updateImmutably};

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "maraj",
-   "version": "2.0.0",
+   "version": "2.2.0",
    "description": "A lightweight 500 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
    "keywords": [
       "shallow",
@@ -38,7 +38,7 @@
       "@changesets/cli": "^2.27.1",
       "@microsoft/api-extractor": "^7.38.5",
       "tsup": "^8.0.1",
-      "typescript": "^4.9.5",
+      "typescript": "^5.3.3",
       "vitest": "^0.28.4"
    }
 }