maraj 2.10.0 → 3.0.0

package/README.md

@@ -1,211 +1,249 @@
-
 # Maraj
 
-A fast lightweight utility for creating **immutable updates**. Fully typed. Only 600 bytes gziped. Includes usefull utilities for manipulating updates (like remove, select).
+A small utility for **immutable updates** of objects and arrays with dot paths. Fully typed, about 1.2 KB gzipped. Includes helpers to work with updates (`remove`, `select`, `set`, ...).
 
 ### Features
 
-- Update and ExtendableUpdate.
-- Usefull utilities like "remove", "select".
-- Full typescript support.
-- Correct type inference.
-- Multiple and concurrent updates.
-- Nested functional updates.
+- `update` with typed dot paths (`'files.0.name'`), checked by TypeScript.
+- Several updates in one call, sharing the copies of common parents.
+- Function updates that get the current value.
+- Only the objects and arrays along each path are copied; everything else keeps its reference.
+- Options to add, skip or throw on missing props and indexes.
+- Helpers: `remove`, `select`, `set`, `splitPathAtLastKey` and a few type helpers.
 
-<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?: ... } is not equal to { key: ... | undefined } )
+```sh
+npm install maraj
+```
 
 ```ts
-const originalValue = { name: 'one', lastname: 'two' modified: false, files: [{ filename: 'one' }] }
+import { update } from 'maraj'
 
-const updatedValue = update(orignalValue, {
+const original = { name: 'one', lastname: 'two', modified: false, files: [{ filename: 'one' }, { filename: 'two' }] }
+
+const updated = update(original, {
    'name': 'updated',
-   'modified': (value, fullObject) => !value,
+   'modified': (value) => !value,
    'files.0.filename': 'zero',
 })
-// updatedValue = { name: 'updated', lastname: 'two' modified: true, files: [{ filename: 'zero' }] }
-originalValue.files[1] === updatedValue.files[1] // true
-
-const newValue = extendableUpdate(orignalValue, {
-   'newProp': 'new',
-   'data.0.name': 'dataName'
-})
-// updatedValue = { ... , newProp: 'new', data: [{ name: 'dataName' }] }
-originalValue.files[1] === newValue.files[1] // true
+// updated = { name: 'updated', lastname: 'two', modified: true, files: [{ filename: 'zero' }, { filename: 'two' }] }
+original.files[1] === updated.files[1] // true, not copied
+original.files === updated.files // false, copied because 'files.0' changed
 ```
 
-### Limitations
+<u>**For TypeScript:**</u> set **"strictNullChecks"** and **"noUncheckedIndexedAccess"** to **true** in tsconfig.json, so optional props and props that can be `undefined` get the right type (`{ key?: string }` is not the same as `{ key: string | undefined }`). With **"exactOptionalPropertyTypes"** too, setting `undefined` on a prop that isn't optional is an error.
+
+## update
+
+```ts
+update(state, updateObject, options?)
+```
 
-- 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: ... } } } }
+- `state`: an object literal or array, anything else throws (`Date`, `Map`, class instances, `null`).
+- `updateObject`: an object literal of `{ 'dot.path': newValue }`, applied in order.
+- `options`: what to do with paths that don't exist yet (see [Options](#options)).
 
-  It can still work with dot-paths keys containing an object or array, however the paths targeting nested properties in this key are forbiden. For example having the following object { a: { "b.c": { d: ... } } } you can use the path "a" and "a.b.c", but you cant use "a.b.c.d", this path will create a new property "b" inside "a", then "c" and lastly "d" resulting in the following object { a: { "b.c": { d: ... } }, b: { c: { d: ... } } }
+Returns a new object with the updates; `state` is never changed.
 
-- 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.
+- A **function** as value is called with the current value (`undefined` if the prop doesn't exist) and its result is set. To set a function as the value, use [`set`](#set).
+- Missing parents are created: an array when the next key is an index (`'files.1.name'` on `{}` -> `{ files: [<empty>, { name }] }`), an object otherwise.
+- A primitive or `null` in the middle of a path is replaced by a new object (`'a.b'` on `{ a: 1 }` -> `{ a: { b } }`).
+- Only own props are read: `'toString.value'` creates a `toString` prop instead of reading `Object.prototype.toString`.
+- A path with `'__proto__'` throws (it would change the prototype of the copy).
+- An empty path (`''`) is skipped, and so are symbol keys.
 
 ```ts
-const updatedValue = extendableUpdate({}, {
-   'files.1.name': 'new name',
-})
-// The "files" prop is an array. updatedValue = { files: [<empty>, { name: 'new name' }] }
+import { update } from 'maraj'
 
-// To get an object instead of an array create an object beforehand
-const updatedValue2 = extendableUpdate({}, {
-   'files': {}, // add an object first, so then i can add props as numbers after it
-   'files.1.name': 'new name',
+const data = {
+   profile: { name: 'Lukasz' },
+   works: ['soum', 'fi'],
+   history: [
+      { title: 'soum', size: 90, available: true },
+      { title: 'fi', size: 30, available: false },
+   ],
+}
+
+const newData = update(data, {
+   'profile.name': 'Lucas',
+   'works.1': 'gs',
+   'history.1.available': (available) => !available,
+   'works': (works) => [...works, 'portfolio'], // runs after 'works.1', so it gets ['soum', 'gs']
 })
-// updatedValue2 = { files: { '1': { name: 'new name' } } }
 ```
 
-- The type "UpdateObject" (the type of the object provided containing the updates, used as second parameter in the update function) if used to create new update objects using computed properties in a inline syntax { [key]: value } will always throw a ts error even if the typing is correct, use the second syntax.
+TypeScript only accepts paths that exist in the type of `state`, with values of the same type. Use [`experimental_extendableUpdate`](#experimental_extendableupdate) to add new props.
+
+### Options
+
+Each option takes `'add'` (default), `'skip'` or `'error'`:
+
+- `onNewProps`: a prop doesn't exist, in an object, or a string key in an array.
+- `onNewIndexes`: an index doesn't exist in an array (`'works.5'` on a 2-item array). `'error'` makes sure no empty items are created.
+- `onPathsIntersectedByPrimitiveValues`: a primitive or `null` is in the middle of the path (`'a.b'` on `{ a: 1 }`). `'add'` replaces it with an object.
+
+`'skip'` skips only that path, at any depth, and still applies the rest. `'error'` throws an `Error` naming the key and the path.
 
 ```ts
-const updateFieldStore = <T, TPath extends DotPaths<T>>(
-   state: T,
-   path: TPath,
-   newValue: UpdateValue<T, TPath>
-) => {
-   // ts error even if the typing is correct (typescript issue)
-   const updateObject1: UpdateObject<T> = {
-      [path]: newValue
-   }
-
-   // All good, no ts error
-   const updateObject2: UpdateObject<T> = {}
-   updateObject[path] = newValue
-   
-}
+update({ a: { d: 1 } }, { 'a.b.c': 1, 'a.d': 2 }, { onNewProps: 'skip' })
+// { a: { d: 2 } }
+
+update({ list: [1, 2] }, { 'list.5': 3 }, { onNewIndexes: 'error' })
+// throws: Property/Index "5" doesnt exist in the path "list.5"...
 ```
 
-- 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 nested props inside arrays.
+## experimental_extendableUpdate
+
+Same as `update`, but TypeScript also accepts new paths and the returned type includes them. It has no options: new props and indexes are always added.
 
 ```ts
-const updatedValue = update(data, {
-   '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.
+import { experimental_extendableUpdate } from 'maraj'
+
+const newData = experimental_extendableUpdate(data, {
+   'profile.age': 28, // new prop
+   'profile.name': 'Lucas',
+   'works.10': 'gs', // new index, items 2 to 9 are left empty
 })
 ```
 
-## Creating a Strict Immutable Update
+A number in the path creates a mutable array when nothing exists there yet. To get an object instead, set it first:
+
+```ts
+experimental_extendableUpdate({}, { 'files.1.name': 'new name' })
+// { files: [<empty>, { name: 'new name' }] }
+
+experimental_extendableUpdate({}, {
+   'files': {},
+   'files.1.name': 'new name',
+})
+// { files: { '1': { name: 'new name' } } }
+```
 
-Arguments:
+## set
 
-- 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.
+Returns a function update that always returns the given value. Use it to:
 
-## Example
+- Set a function as a value (a plain function would be called as an update).
+- Get a stricter type when TypeScript mixes up an optional prop with one that can be `undefined` (usually props of items inside arrays): `set(undefined)` is an error.
 
-```js
-import { update } from "maraj";
+```ts
+import { update, set } 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 button = { label: 'Save', onClick: () => {}, files: [{ name: 'one' }] }
 
-const newUpdatedObject = update(data, {
-    "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
+update(button, {
+   'onClick': set(() => console.log('clicked')),
+   'files.0.name': set('new name'),
 })
 ```
 
-## Creating an Immutable Update allowing new props to be added
-
-Arguments:
+## remove
 
-- Original Object
-- Update Object
+Returns a copy of an object without the given keys, or of an array without the given indexes. Use it inside a function update.
 
-## Example
+- Objects: only optional keys can be removed (TypeScript).
+- Arrays: indexes as numbers or strings (`1`, `'1'`), in any order; repeated or out-of-range indexes are ignored.
+- Anything other than an object literal or array throws.
 
-```js
-import { extendableUpdate } from "maraj";
+```ts
+import { update, remove } 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"] },
-    ]
-}
+type Person = { profile: { name: string, nickname?: string }, works: string[] }
+const person: Person = { profile: { name: 'Lukasz', nickname: 'Luk' }, works: ['soum', 'fi', 'gs'] }
 
-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"
+update(person, {
+   'profile': (profile) => remove(profile, 'nickname'), // removes "nickname"
+   'works': (works) => remove(works, [1, '0']), // ['gs']
 })
 ```
 
-## Remove Utility
+## select
 
-Removes the **key of an object** or the **index of an array** in the key provided in the **update.**
+Returns the value in a dot path, or `undefined` if the path doesn't exist. `''` returns the whole state.
 
-```js
-import {remove} from 'maraj'
+- Only own props are read: `'profile.toString'` and `'tags.map'` give `undefined`, and so does `'size'` on a `Map`.
+- `null` or `undefined` in the middle of the path gives `undefined`.
+- A key with dots (`{ 'a.b': 1 }`) is found when it matches the whole rest of the path.
 
-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)
-    'works': (value) => remove(value, [1, "0"]), // returns new array without the provided index "0" and "1"
-})
+```ts
+import { select } from 'maraj'
+
+const work1SizeSelector = (state) => select(state, 'history.1.size') // state.history[1].size
 ```
 
-## Select Utility
+## splitPathAtLastKey
 
-Selects the value of an object/array from a string-dot-path. Usefull in state management libraries.
+Splits a dot path into the path before the last key and the last key (for example, to get an id).
 
-```js
-import {select} from 'maraj'
+```ts
+import { splitPathAtLastKey } from 'maraj'
 
-const stringPath = 'works.1.size'
+const [remainingPath, lastKey] = splitPathAtLastKey('projects.1.data.size')
+// remainingPath = 'projects.1.data', lastKey = 'size'
 
-const work1SizeSelector = (state) => select(state, stringPath) // will behave as (store) => store[works][1][size]
+splitPathAtLastKey('size') // ['', 'size']
 ```
 
-## SplitPathAtLastKey Utility
+## Type helpers
 
-Usefull when you want to retrieve the last key (for example an id).
+- `strictType<T, U>(value)`: returns `value` as `U`, and TypeScript errors when `value` has props `U` doesn't have (plain assignment allows them).
+- `strict(value)` (or `s`): returns `value` unchanged, typed as `Strict<T>`.
+- `isObjectLiteral(value)`: `true` when the prototype is `Object.prototype` (`{}`, `{ a: 1 }`); `false` for arrays, `null`, `Object.create(null)`, `Date`, `Map`, class instances and objects from another realm (`node:vm`, iframes).
+- `isStringIndex(key)`: `true` when `key` is an integer written as `parseInt` would write it (`'1'`); `false` for `'01'`, `'1.5'`, `''` and `'NaN'`. `parseStringIndex(key)` returns that number, or `null`.
+- `forEachEntry(object, (key, value) => ...)`: `Object.keys(object).forEach` with typed keys and values.
 
-Splits string path (example:'projects.1.data.size' ) into two:
+```ts
+import { strictType } from 'maraj'
 
-- remainingPath: the remaining path (in this case 'projects.1.data')
-- lastKey: the last key in the path (in this case 'size')
+type User = { name: string, age?: number }
+const saveUser = (user: User) => { /* ... */ }
 
-```js
-import { splitPathAtLastKey } from 'maraj'
+const user = { name: 'Ana', admin: true }
+saveUser(user) // no error
+saveUser(strictType<typeof user, User>(user)) // error: "admin" isn't in User
+```
 
-const stringPath = 'works.1.size'
+## Limitations
 
-const [remainingPath, lastKey] = splitPathAtLastKey(stringPath)
-// lastKey = 'size'
-// remainingPath = 'works.1'
-```
+- **Keys with dots** (`{ 'this.is.dotted.key': 123 }`) work only when they already exist and the path ends on them. The path `'a.b.c.d'` works on:
+  - `{ 'a.b.c.d': ... }`
+  - `{ a: { 'b.c.d': ... } }`
+  - `{ a: { b: { 'c.d': ... } } }`
+  - `{ a: { b: { c: { d: ... } } } }`
 
-## Set Utility
+  Paths into the value of a dotted key don't: with `{ a: { 'b.c': { d: 1 } } }`, `'a.b.c'` works but `'a.b.c.d'` creates `a.b.c.d` next to `'b.c'`: `{ a: { 'b.c': { d: 1 }, b: { c: { d: ... } } } }`.
 
-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.
+- **`UpdateObject` with a computed key** in an object literal is a TypeScript error even when the types are right. Assign the key after creating the object:
 
 ```ts
-const updatedValue = update(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.
-})
+import type { DotPaths, UpdateObject, UpdateValue } from 'maraj'
+
+const updateField = <T, TPath extends DotPaths<T>>(state: T, path: TPath, newValue: UpdateValue<T, TPath>) => {
+   // ts error, even if the typing is correct (TypeScript issue)
+   const updateObject1: UpdateObject<T> = { [path]: newValue }
+
+   // no ts error
+   const updateObject2: UpdateObject<T> = {}
+   updateObject2[path] = newValue
+   return update(state, updateObject2)
+}
 ```
+
+## Benchmarks
+
+<!-- bench:start -->
+Median speed against maraj in 11 scenarios (higher is faster)
+
+```text
+dot-prop-immutable     ██████████████████████████████  1.26x
+maraj                  ████████████████████████        1.00x
+timm                   ██████████████████              0.77x
+object-path-immutable  ██████████████                  0.58x
+immer (no autofreeze)  ████████████                    0.49x
+immutability-helper    ██████████                      0.41x
+lodash/fp              █████████                       0.38x
+mutative               ████████                        0.35x
+immer                  ███████                         0.30x
+```
+<!-- bench:end -->
+
+`1.50x` means 1.5 times as many updates per second as maraj. The scenarios go from one top-level prop to 100 paths in a 1,000-item array: see [benchmarks/README.md](benchmarks/README.md) for each one, the machine and how to run them.

package/dist/index.d.mts

@@ -6,13 +6,11 @@
 /** Dot-paths of an array. */
 type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? ExtendedArrayIndexes : ExtendedArrayIndexes | `${ExtendedArrayIndexes}.${DotPathsImplementation<TInnerType, TAllowedTypes>}` : `${ExtendedArrayIndexes}.${DotPathsImplementation<TInnerType, TAllowedTypes>}`;
 /** Dot-paths of an object. */
-type ObjectPaths<T, TAllowedTypes> = {
-    [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}` : `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}`;
-}[keyof T & (string | number)] & {};
+type ObjectPaths<T, TAllowedTypes> = { [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}` : `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}`; }[keyof T & (string | number)];
 /** Dot-paths of a tuple. */
-type TuplePaths<T, TAllowedTypes> = ObjectPaths<Omit<T, keyof any[]>, TAllowedTypes> & {};
-/** Dot-paths implementation */
-type DotPathsImplementation<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? T extends Tuple ? TuplePaths<T, TAllowedTypes> : ArrayPaths<U, TAllowedTypes> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T, TAllowedTypes>;
+type TuplePaths<T, TAllowedTypes> = ObjectPaths<Required<Omit<T, keyof any[]>>, TAllowedTypes>;
+/** Dot-paths implementation, Required<T> so optional props count as their type ('nickname?: string' is a string) */
+type DotPathsImplementation<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? T extends Tuple ? TuplePaths<T, TAllowedTypes> : ArrayPaths<U, TAllowedTypes> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<Required<T>, TAllowedTypes>;
 /** Literal union of all posible dot-paths which satisfy provided types as second argument (default: any). */
 type DotPaths<T, TAllowedTypes = any> = KeyOf<T, TAllowedTypes> | DotPathsImplementation<T, TAllowedTypes>;
 /**
@@ -20,15 +18,17 @@ type DotPaths<T, TAllowedTypes = any> = KeyOf<T, TAllowedTypes> | DotPathsImplem
  *  VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
-/** Nested type implementation. */
-type ValueInPath<TObject, TPath> = TPath extends keyof TObject ? TObject[TPath] : TPath extends '' ? TObject : 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;
+/** Tuple without rest items ([number, string], not [string, ...number[]]): an index that isn't a key is out of range. */
+type IsFixedTuple<T> = T extends Tuple ? number extends T['length'] ? false : true : false;
+/** Nested type implementation, goes into each object of a union ({ name } | null -> 'name' is string). */
+type ValueInPath<TObject, TPath> = TObject extends unknown ? TPath extends keyof TObject ? TObject[TPath] : TPath extends '' ? TObject : TPath extends LiteralIndex ? never : TPath extends `${number}` ? IsFixedTuple<TObject> extends true ? never : 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}` ? IsFixedTuple<TObject> extends true ? never : TObject extends ReadonlyArray<infer U> ? ValueInPath<U, R> : never : never : never : never;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
-/** Returned nested type implementation. */
-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;
+/** Returned nested type implementation, null or undefined inside the path -> undefined. */
+type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TObject extends null | undefined ? undefined : TPath extends keyof TObject ? TPath extends number ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : TObject[TPath] : TObject[TPath] : TPath extends `${number}` ? IsFixedTuple<TObject> extends true ? never : 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}` ? IsFixedTuple<TObject> extends true ? never : TObject extends ReadonlyArray<infer U> ? (ReturnedValueInPath<U, R> | undefined) : never : never : never;
 /**
  * --------------------------------------------
  *  UPDATE OBJECT WITH DOT PATH IMPLEMENTATION
@@ -37,9 +37,7 @@ type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath ex
 /** Value of a dot-path update object, can be the value or a function. */
 type UpdateValue<TObject, TPath> = ValueInPath<TObject, TPath> extends never ? never : ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => Strict<ValueInPath<TObject, TPath>>);
 /** Dot-path update object, used to give updates to the updateImmutably function. */
-type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>> = {
-    [Path in TPaths]?: UpdateValue<TObject, Path>;
-};
+type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>> = { [Path in TPaths]?: UpdateValue<TObject, Path>; };
 /**
  * --------------------------------------------
  *  EXTRACT TYPE FROM DOT-PATH UPDATE OBJECT
@@ -47,78 +45,54 @@ type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>>
  */
 /** 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];
+type NonDotPathKeys<T> = { [Key in keyof T]: Key extends `${infer K}.${string}` ? K : Key; }[keyof T];
 /** Keys which are an index */
-type KeysRepresentingAnIndex<T> = {
-    [Key in keyof T]: Key extends `${number}.${string}` ? never : Key;
-}[keyof T];
+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];
+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];
+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;
+type Value<T> = T extends ((...args: any) => any) ? ReturnType<T> : T;
 /** To check if an empty object is provided */
 type EmptyObject = Record<PropertyKey, 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;
+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, TDotPathUpdateObject extends Record<PropertyKey, any>> = TObject extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> extends Array<infer W> ? Array<U | W> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject>;
-
 /** Index literal type to improve DX at managing updates. */
 declare const LITERAL_INDEX = "${number}";
-
 /** Primitives and browser native objects. */
-type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
+type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File | Blob;
 /** Tuple type, it has to have at least property "0" */
 type Tuple = ReadonlyArray<any> & {
-    "0": any;
+  "0": any;
 };
 /** Array indexes type. */
 type LiteralIndex = typeof LITERAL_INDEX;
 type ExtendedArrayIndexes = number | `${number}` | LiteralIndex;
-/** Object Literal */
+/** Object Literal, File and Blob still match it (they have no symbol to reject them by) */
 type ObjectLiteral = {
-    [x: string]: any;
-    [x: number]: any;
-    [x: symbol]: any;
-    [Symbol.iterator]?: never;
-    [Symbol.toPrimitive]?: never;
-    [Symbol.hasInstance]?: never;
-    [Symbol.unscopables]?: never;
-    [Symbol.matchAll]?: never;
+  [x: string]: any;
+  [x: number]: any;
+  [x: symbol]: any;
+  [Symbol.iterator]?: never;
+  [Symbol.toPrimitive]?: never;
+  [Symbol.hasInstance]?: never;
+  [Symbol.unscopables]?: never;
+  [Symbol.matchAll]?: never;
+  [Symbol.toStringTag]?: never;
 };
 /** Strict key */
 declare const strictSymbol: unique symbol;
-type Strict<T> = T extends ObjectLiteral ? T & {
-    [strictSymbol]: DotPaths<T>;
+type Strict<T> = T extends PrimitivesAndNativeObjects ? T : T extends ObjectLiteral ? T & {
+  [strictSymbol]: DotPaths<T>;
 } : T;
 /** Smart KeyOf (doesnt include the "strict" key) */
-type KeyOf<T, TAllowedValuesInKeys = any> = T extends ObjectLiteral ? T extends Strict<infer U> ? KeysOfObject<U, TAllowedValuesInKeys> : KeysOfObject<T, TAllowedValuesInKeys> : T extends Tuple ? KeysOfObject<Omit<T, keyof any[]>, TAllowedValuesInKeys> : T extends ReadonlyArray<infer U> ? U extends TAllowedValuesInKeys ? ExtendedArrayIndexes : never : never;
-type KeysOfObject<T, TAllowedValuesInKeys> = {
-    [Key in keyof T]: T[Key] extends TAllowedValuesInKeys ? Key : never;
-}[keyof T];
-
+type KeyOf<T, TAllowedValuesInKeys = any> = T extends PrimitivesAndNativeObjects ? never : T extends ObjectLiteral ? T extends Strict<infer U> ? KeysOfObject<U, TAllowedValuesInKeys> : KeysOfObject<T, TAllowedValuesInKeys> : T extends Tuple ? KeysOfObject<Omit<T, keyof any[]>, TAllowedValuesInKeys> : T extends ReadonlyArray<infer U> ? U extends TAllowedValuesInKeys ? ExtendedArrayIndexes : never : never;
+type KeysOfObject<T, TAllowedValuesInKeys> = { [Key in keyof T]-?: Required<T>[Key] extends TAllowedValuesInKeys ? Key : never; }[keyof T];
 /** Returns only the optional keys of an object. */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
-}[keyof T];
+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 ObjectLiteral | any[]>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : OptionalKeys<T> | (OptionalKeys<T>)[]) => T;
 /**
@@ -127,11 +101,10 @@ type Remove = <T extends ObjectLiteral | any[]>(value: T, keys: T extends any[]
  * @param keys Keys to remove.
  * @returns New object/array without the provided keys/indexes.
  */
-declare const remove: Remove;
-
+export declare const remove: Remove;
 type Select = {
-    <T, TPath extends DotPaths<T>>(state: T, path: TPath): ReturnedValueInPath<T, TPath>;
-    <T, TPath extends ''>(state: T, path: TPath): T;
+  <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.
@@ -139,8 +112,7 @@ type Select = {
  * @param path Path indicating the value to extract.
  * @returns Value of the provided path or undefined.
  */
-declare const select: Select;
-
+export declare const select: Select;
 type PathWithoutLastKey = string;
 type LastKey = string;
 type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastKey, LastKey];
@@ -149,21 +121,19 @@ type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastK
  * @param dotPath A dot path.
  * @returns [pathWithoutLastKey, lastKey] or ['', lastKey].
  */
-declare const splitPathAtLastKey: SplitDotPathAtLastKey;
-
+export declare const splitPathAtLastKey: SplitDotPathAtLastKey;
 type Set = <T>(newValue: T) => (v: unknown) => T;
 /**
  * Allows to set strongly typed values (removing inacurate "undefined" inference) in nested values inside arrays.
  * @param newValue New value.
  * @returns The same value.
  */
-declare const set: Set;
-
+export declare const set: Set;
 type OptionValues = 'error' | 'skip' | 'add';
 type Options = {
-    onNewProps?: OptionValues;
-    onNewIndexes?: OptionValues;
-    onPathsIntersectedByPrimitiveValues?: OptionValues;
+  onNewProps?: OptionValues;
+  onNewIndexes?: OptionValues;
+  onPathsIntersectedByPrimitiveValues?: OptionValues;
 };
 type ImmutableUpdate = <TObject, TAllowedDotPathKeys extends DotPaths<TObject> = DotPaths<TObject>>(state: TObject, dotPathUpdateObject: UpdateObject<TObject, TAllowedDotPathKeys>, options?: Options) => TObject;
 /**
@@ -175,7 +145,7 @@ type ImmutableUpdate = <TObject, TAllowedDotPathKeys extends DotPaths<TObject> =
  * @param options Options to change JS behaviour on non-existent fields.
  * @returns New Updated Object.
  */
-declare const update: ImmutableUpdate;
+export declare const update: ImmutableUpdate;
 type ExtendableImmutableUpdate = <TObject, TUpdateObject extends UpdateObject<TObject> = UpdateObject<TObject>>(state: TObject, dotPathUpdateObject: TUpdateObject) => ExtendedUpdate<TObject, TUpdateObject>;
 /**
  * Creates a new object applying immutable updates using dot-path syntax.
@@ -185,26 +155,21 @@ type ExtendableImmutableUpdate = <TObject, TUpdateObject extends UpdateObject<TO
  * @param dotPathUpdateObject Dot Path Update Object.
  * @returns New Updated Object.
  */
-declare const experimental_extendableUpdate: ExtendableImmutableUpdate;
-
+export declare const experimental_extendableUpdate: ExtendableImmutableUpdate;
 type ForEachEntry = <T extends ObjectLiteral>(object: T, callbackfn: (key: keyof T, value: T[keyof T]) => void) => void;
-declare const forEachEntry: ForEachEntry;
-
+export declare const forEachEntry: ForEachEntry;
 /** Checks if any provided value is an object literal or not */
 type IsObjectLiteral = (valueToTest: unknown) => valueToTest is ObjectLiteral;
-declare const isObjectLiteral: IsObjectLiteral;
-
+export declare const isObjectLiteral: IsObjectLiteral;
 /** Adds strict property to an object literal */
 type StrictFn = <T>(value: T) => Strict<T>;
-declare const strict: StrictFn;
-declare const s: StrictFn;
+export declare const strict: StrictFn;
+export declare const s: StrictFn;
 /** Checks the strictness of a type passed to a function or callback without 3rd party implementation */
-type StrictValueWrapper = <T extends U, U>(v: T extends U ? DotPaths<T> extends DotPaths<U> ? T : Exclude<DotPaths<T>, DotPaths<U>> : never) => U;
-declare const strictValueWrapper: StrictValueWrapper;
-
+type StrictType = <T extends U, U>(v: T extends U ? DotPaths<T> extends DotPaths<U> ? T : Exclude<DotPaths<T>, DotPaths<U>> : never) => U;
+export declare const strictType: StrictType;
 type ParseStringIndex = (stringKey: string) => number | null;
-declare const parseStringIndex: ParseStringIndex;
+export declare const parseStringIndex: ParseStringIndex;
 type IsStringIndex = (stringKey: string) => stringKey is `${number}`;
-declare const isStringIndex: IsStringIndex;
-
-export { type DotPaths, type ExtendedArrayIndexes, type KeyOf, type LiteralIndex, type ObjectLiteral, type PrimitivesAndNativeObjects, type ReturnedValueInPath, type Strict, type Tuple, type UpdateObject, type UpdateValue, type ValueInPath, experimental_extendableUpdate, forEachEntry, isObjectLiteral, isStringIndex, parseStringIndex, remove, s, select, set, splitPathAtLastKey, strict, strictValueWrapper, update };
+export declare const isStringIndex: IsStringIndex;
+export type { DotPaths, ExtendedArrayIndexes, KeyOf, LiteralIndex, ObjectLiteral, PrimitivesAndNativeObjects, ReturnedValueInPath, Strict, Tuple, UpdateObject, UpdateValue, ValueInPath };

package/dist/index.d.ts

@@ -6,13 +6,11 @@
 /** Dot-paths of an array. */
 type ArrayPaths<TInnerType, TAllowedTypes> = TInnerType extends TAllowedTypes ? TInnerType extends PrimitivesAndNativeObjects ? ExtendedArrayIndexes : ExtendedArrayIndexes | `${ExtendedArrayIndexes}.${DotPathsImplementation<TInnerType, TAllowedTypes>}` : `${ExtendedArrayIndexes}.${DotPathsImplementation<TInnerType, TAllowedTypes>}`;
 /** Dot-paths of an object. */
-type ObjectPaths<T, TAllowedTypes> = {
-    [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}` : `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}`;
-}[keyof T & (string | number)] & {};
+type ObjectPaths<T, TAllowedTypes> = { [Key in keyof T & (string | number)]: T[Key] extends TAllowedTypes ? T[Key] extends PrimitivesAndNativeObjects ? `${Key}` : `${Key}` | `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}` : `${Key}.${DotPathsImplementation<T[Key], TAllowedTypes>}`; }[keyof T & (string | number)];
 /** Dot-paths of a tuple. */
-type TuplePaths<T, TAllowedTypes> = ObjectPaths<Omit<T, keyof any[]>, TAllowedTypes> & {};
-/** Dot-paths implementation */
-type DotPathsImplementation<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? T extends Tuple ? TuplePaths<T, TAllowedTypes> : ArrayPaths<U, TAllowedTypes> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T, TAllowedTypes>;
+type TuplePaths<T, TAllowedTypes> = ObjectPaths<Required<Omit<T, keyof any[]>>, TAllowedTypes>;
+/** Dot-paths implementation, Required<T> so optional props count as their type ('nickname?: string' is a string) */
+type DotPathsImplementation<T, TAllowedTypes = any> = T extends ReadonlyArray<infer U> ? T extends Tuple ? TuplePaths<T, TAllowedTypes> : ArrayPaths<U, TAllowedTypes> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<Required<T>, TAllowedTypes>;
 /** Literal union of all posible dot-paths which satisfy provided types as second argument (default: any). */
 type DotPaths<T, TAllowedTypes = any> = KeyOf<T, TAllowedTypes> | DotPathsImplementation<T, TAllowedTypes>;
 /**
@@ -20,15 +18,17 @@ type DotPaths<T, TAllowedTypes = any> = KeyOf<T, TAllowedTypes> | DotPathsImplem
  *  VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
-/** Nested type implementation. */
-type ValueInPath<TObject, TPath> = TPath extends keyof TObject ? TObject[TPath] : TPath extends '' ? TObject : 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;
+/** Tuple without rest items ([number, string], not [string, ...number[]]): an index that isn't a key is out of range. */
+type IsFixedTuple<T> = T extends Tuple ? number extends T['length'] ? false : true : false;
+/** Nested type implementation, goes into each object of a union ({ name } | null -> 'name' is string). */
+type ValueInPath<TObject, TPath> = TObject extends unknown ? TPath extends keyof TObject ? TObject[TPath] : TPath extends '' ? TObject : TPath extends LiteralIndex ? never : TPath extends `${number}` ? IsFixedTuple<TObject> extends true ? never : 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}` ? IsFixedTuple<TObject> extends true ? never : TObject extends ReadonlyArray<infer U> ? ValueInPath<U, R> : never : never : never : never;
 /**
  * --------------------------------------------
  *  RETURNED VALUE OF A NESTED PROPERTY PROVIDING A DOT PATH
  * --------------------------------------------
  */
-/** Returned nested type implementation. */
-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;
+/** Returned nested type implementation, null or undefined inside the path -> undefined. */
+type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TObject extends null | undefined ? undefined : TPath extends keyof TObject ? TPath extends number ? TObject extends ReadonlyArray<infer U> ? (U | undefined) : TObject[TPath] : TObject[TPath] : TPath extends `${number}` ? IsFixedTuple<TObject> extends true ? never : 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}` ? IsFixedTuple<TObject> extends true ? never : TObject extends ReadonlyArray<infer U> ? (ReturnedValueInPath<U, R> | undefined) : never : never : never;
 /**
  * --------------------------------------------
  *  UPDATE OBJECT WITH DOT PATH IMPLEMENTATION
@@ -37,9 +37,7 @@ type ReturnedValueInPath<TObject, TPath> = TPath extends '' ? TObject : TPath ex
 /** Value of a dot-path update object, can be the value or a function. */
 type UpdateValue<TObject, TPath> = ValueInPath<TObject, TPath> extends never ? never : ValueInPath<TObject, TPath> | ((fieldValue: ValueInPath<TObject, TPath>) => Strict<ValueInPath<TObject, TPath>>);
 /** Dot-path update object, used to give updates to the updateImmutably function. */
-type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>> = {
-    [Path in TPaths]?: UpdateValue<TObject, Path>;
-};
+type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>> = { [Path in TPaths]?: UpdateValue<TObject, Path>; };
 /**
  * --------------------------------------------
  *  EXTRACT TYPE FROM DOT-PATH UPDATE OBJECT
@@ -47,78 +45,54 @@ type UpdateObject<TObject, TPaths extends DotPaths<TObject> = DotPaths<TObject>>
  */
 /** 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];
+type NonDotPathKeys<T> = { [Key in keyof T]: Key extends `${infer K}.${string}` ? K : Key; }[keyof T];
 /** Keys which are an index */
-type KeysRepresentingAnIndex<T> = {
-    [Key in keyof T]: Key extends `${number}.${string}` ? never : Key;
-}[keyof T];
+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];
+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];
+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;
+type Value<T> = T extends ((...args: any) => any) ? ReturnType<T> : T;
 /** To check if an empty object is provided */
 type EmptyObject = Record<PropertyKey, 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;
+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, TDotPathUpdateObject extends Record<PropertyKey, any>> = TObject extends Array<infer U> ? ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> extends Array<infer W> ? Array<U | W> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject> : TObject & ExtractTypeFromDotPathUpdateObject<TDotPathUpdateObject>;
-
 /** Index literal type to improve DX at managing updates. */
 declare const LITERAL_INDEX = "${number}";
-
 /** Primitives and browser native objects. */
-type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File;
+type PrimitivesAndNativeObjects = null | undefined | string | number | boolean | symbol | bigint | Date | FileList | File | Blob;
 /** Tuple type, it has to have at least property "0" */
 type Tuple = ReadonlyArray<any> & {
-    "0": any;
+  "0": any;
 };
 /** Array indexes type. */
 type LiteralIndex = typeof LITERAL_INDEX;
 type ExtendedArrayIndexes = number | `${number}` | LiteralIndex;
-/** Object Literal */
+/** Object Literal, File and Blob still match it (they have no symbol to reject them by) */
 type ObjectLiteral = {
-    [x: string]: any;
-    [x: number]: any;
-    [x: symbol]: any;
-    [Symbol.iterator]?: never;
-    [Symbol.toPrimitive]?: never;
-    [Symbol.hasInstance]?: never;
-    [Symbol.unscopables]?: never;
-    [Symbol.matchAll]?: never;
+  [x: string]: any;
+  [x: number]: any;
+  [x: symbol]: any;
+  [Symbol.iterator]?: never;
+  [Symbol.toPrimitive]?: never;
+  [Symbol.hasInstance]?: never;
+  [Symbol.unscopables]?: never;
+  [Symbol.matchAll]?: never;
+  [Symbol.toStringTag]?: never;
 };
 /** Strict key */
 declare const strictSymbol: unique symbol;
-type Strict<T> = T extends ObjectLiteral ? T & {
-    [strictSymbol]: DotPaths<T>;
+type Strict<T> = T extends PrimitivesAndNativeObjects ? T : T extends ObjectLiteral ? T & {
+  [strictSymbol]: DotPaths<T>;
 } : T;
 /** Smart KeyOf (doesnt include the "strict" key) */
-type KeyOf<T, TAllowedValuesInKeys = any> = T extends ObjectLiteral ? T extends Strict<infer U> ? KeysOfObject<U, TAllowedValuesInKeys> : KeysOfObject<T, TAllowedValuesInKeys> : T extends Tuple ? KeysOfObject<Omit<T, keyof any[]>, TAllowedValuesInKeys> : T extends ReadonlyArray<infer U> ? U extends TAllowedValuesInKeys ? ExtendedArrayIndexes : never : never;
-type KeysOfObject<T, TAllowedValuesInKeys> = {
-    [Key in keyof T]: T[Key] extends TAllowedValuesInKeys ? Key : never;
-}[keyof T];
-
+type KeyOf<T, TAllowedValuesInKeys = any> = T extends PrimitivesAndNativeObjects ? never : T extends ObjectLiteral ? T extends Strict<infer U> ? KeysOfObject<U, TAllowedValuesInKeys> : KeysOfObject<T, TAllowedValuesInKeys> : T extends Tuple ? KeysOfObject<Omit<T, keyof any[]>, TAllowedValuesInKeys> : T extends ReadonlyArray<infer U> ? U extends TAllowedValuesInKeys ? ExtendedArrayIndexes : never : never;
+type KeysOfObject<T, TAllowedValuesInKeys> = { [Key in keyof T]-?: Required<T>[Key] extends TAllowedValuesInKeys ? Key : never; }[keyof T];
 /** Returns only the optional keys of an object. */
-type OptionalKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
-}[keyof T];
+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 ObjectLiteral | any[]>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : OptionalKeys<T> | (OptionalKeys<T>)[]) => T;
 /**
@@ -127,11 +101,10 @@ type Remove = <T extends ObjectLiteral | any[]>(value: T, keys: T extends any[]
  * @param keys Keys to remove.
  * @returns New object/array without the provided keys/indexes.
  */
-declare const remove: Remove;
-
+export declare const remove: Remove;
 type Select = {
-    <T, TPath extends DotPaths<T>>(state: T, path: TPath): ReturnedValueInPath<T, TPath>;
-    <T, TPath extends ''>(state: T, path: TPath): T;
+  <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.
@@ -139,8 +112,7 @@ type Select = {
  * @param path Path indicating the value to extract.
  * @returns Value of the provided path or undefined.
  */
-declare const select: Select;
-
+export declare const select: Select;
 type PathWithoutLastKey = string;
 type LastKey = string;
 type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastKey, LastKey];
@@ -149,21 +121,19 @@ type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [PathWithoutLastK
  * @param dotPath A dot path.
  * @returns [pathWithoutLastKey, lastKey] or ['', lastKey].
  */
-declare const splitPathAtLastKey: SplitDotPathAtLastKey;
-
+export declare const splitPathAtLastKey: SplitDotPathAtLastKey;
 type Set = <T>(newValue: T) => (v: unknown) => T;
 /**
  * Allows to set strongly typed values (removing inacurate "undefined" inference) in nested values inside arrays.
  * @param newValue New value.
  * @returns The same value.
  */
-declare const set: Set;
-
+export declare const set: Set;
 type OptionValues = 'error' | 'skip' | 'add';
 type Options = {
-    onNewProps?: OptionValues;
-    onNewIndexes?: OptionValues;
-    onPathsIntersectedByPrimitiveValues?: OptionValues;
+  onNewProps?: OptionValues;
+  onNewIndexes?: OptionValues;
+  onPathsIntersectedByPrimitiveValues?: OptionValues;
 };
 type ImmutableUpdate = <TObject, TAllowedDotPathKeys extends DotPaths<TObject> = DotPaths<TObject>>(state: TObject, dotPathUpdateObject: UpdateObject<TObject, TAllowedDotPathKeys>, options?: Options) => TObject;
 /**
@@ -175,7 +145,7 @@ type ImmutableUpdate = <TObject, TAllowedDotPathKeys extends DotPaths<TObject> =
  * @param options Options to change JS behaviour on non-existent fields.
  * @returns New Updated Object.
  */
-declare const update: ImmutableUpdate;
+export declare const update: ImmutableUpdate;
 type ExtendableImmutableUpdate = <TObject, TUpdateObject extends UpdateObject<TObject> = UpdateObject<TObject>>(state: TObject, dotPathUpdateObject: TUpdateObject) => ExtendedUpdate<TObject, TUpdateObject>;
 /**
  * Creates a new object applying immutable updates using dot-path syntax.
@@ -185,26 +155,21 @@ type ExtendableImmutableUpdate = <TObject, TUpdateObject extends UpdateObject<TO
  * @param dotPathUpdateObject Dot Path Update Object.
  * @returns New Updated Object.
  */
-declare const experimental_extendableUpdate: ExtendableImmutableUpdate;
-
+export declare const experimental_extendableUpdate: ExtendableImmutableUpdate;
 type ForEachEntry = <T extends ObjectLiteral>(object: T, callbackfn: (key: keyof T, value: T[keyof T]) => void) => void;
-declare const forEachEntry: ForEachEntry;
-
+export declare const forEachEntry: ForEachEntry;
 /** Checks if any provided value is an object literal or not */
 type IsObjectLiteral = (valueToTest: unknown) => valueToTest is ObjectLiteral;
-declare const isObjectLiteral: IsObjectLiteral;
-
+export declare const isObjectLiteral: IsObjectLiteral;
 /** Adds strict property to an object literal */
 type StrictFn = <T>(value: T) => Strict<T>;
-declare const strict: StrictFn;
-declare const s: StrictFn;
+export declare const strict: StrictFn;
+export declare const s: StrictFn;
 /** Checks the strictness of a type passed to a function or callback without 3rd party implementation */
-type StrictValueWrapper = <T extends U, U>(v: T extends U ? DotPaths<T> extends DotPaths<U> ? T : Exclude<DotPaths<T>, DotPaths<U>> : never) => U;
-declare const strictValueWrapper: StrictValueWrapper;
-
+type StrictType = <T extends U, U>(v: T extends U ? DotPaths<T> extends DotPaths<U> ? T : Exclude<DotPaths<T>, DotPaths<U>> : never) => U;
+export declare const strictType: StrictType;
 type ParseStringIndex = (stringKey: string) => number | null;
-declare const parseStringIndex: ParseStringIndex;
+export declare const parseStringIndex: ParseStringIndex;
 type IsStringIndex = (stringKey: string) => stringKey is `${number}`;
-declare const isStringIndex: IsStringIndex;
-
-export { type DotPaths, type ExtendedArrayIndexes, type KeyOf, type LiteralIndex, type ObjectLiteral, type PrimitivesAndNativeObjects, type ReturnedValueInPath, type Strict, type Tuple, type UpdateObject, type UpdateValue, type ValueInPath, experimental_extendableUpdate, forEachEntry, isObjectLiteral, isStringIndex, parseStringIndex, remove, s, select, set, splitPathAtLastKey, strict, strictValueWrapper, update };
+export declare const isStringIndex: IsStringIndex;
+export type { DotPaths, ExtendedArrayIndexes, KeyOf, LiteralIndex, ObjectLiteral, PrimitivesAndNativeObjects, ReturnedValueInPath, Strict, Tuple, UpdateObject, UpdateValue, ValueInPath };

package/dist/index.js

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

package/dist/index.mjs

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

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "maraj",
-   "version": "2.10.0",
-   "description": "A lightweight 600 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
+   "version": "3.0.0",
+   "description": "A lightweight (~1.2 KB gzipped) alternative for immutable updates while dealing with objects and arrays",
    "keywords": [
       "shallow",
       "shallow copy",
@@ -21,11 +21,11 @@
    "scripts": {
       "dev": "vitest",
       "test": "vitest run",
-      "build": "tsup src/index.ts --minify --format cjs,esm --dts",
+      "build": "tsdown",
       "lint": "tsc",
       "trace": "tsc --generateTrace trace",
       "ci": "npm run lint && npm run test && npm run build",
-      "release": "npm run lint && npm run test && npm run build && changeset publish"
+      "release": "node scripts/check-changelog.mjs && npm run build && changeset publish"
    },
    "repository": {
       "type": "git",
@@ -36,11 +36,11 @@
    },
    "homepage": "https://github.com/Lukasz17git/maraj#readme",
    "devDependencies": {
-      "@changesets/cli": "^2.27.1",
-      "@microsoft/api-extractor": "^7.38.5",
-      "@typescript/analyze-trace": "^0.10.1",
-      "tsup": "^8.0.1",
-      "typescript": "^5.3.3",
-      "vitest": "^0.28.4"
+      "@changesets/cli": "^3.0.3",
+      "@microsoft/api-extractor": "^7.59.4",
+      "@typescript/analyze-trace": "^0.11.1",
+      "tsdown": "^0.23.1",
+      "typescript": "^7.0.2",
+      "vitest": "^5.0.5"
    }
 }