maraj 1.1.2 → 2.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2023 Lukasz Maraj
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,138 +1,143 @@
-
-# Maraj
-
-A lightweight alternative for creating **immutable updates of objects and arrays** such as Immer or ImmutableJS.
-
-**4 times faster** and **over 10 times lighter**.
-
-Only **400 bytes** gziped and additional **300 bytes** for 4 common utilities that you will most likelly need in every project.
-
-Features:
-- Can accept multiple updates while mantaining the order of execution.
-- Easy syntax for conditional updates.
-- Functional updates.
-
-Vitest: https://www.npmjs.com/package/maraj-test
-
-## Creating an Immutable Update
-
-The **createImmutableUpdate** function has two arguments:
-1. The **Original object**.
-2. An **Update object** (key-value pairs representing the updates we want to make)
-
-The **Update Object** has the following syntax:
-```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
-}
-```
-Multiple key-value pairs that mantains the order of execution.
-
-- **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.)
-
-- **Value:** new value, any type. If its a function it ll be called with the current value in that field.
-
-
-## Example
-
-```js
-import createImmutableUpdate, { spread } from "maraj";
-
-const data = {
-    person: { name: "Lukasz", works: ["soum", "fi"] },
-    works: [
-        { title: "soum", size: 90, available: true, info: ["info1"] },
-        { title: "fi", size: 30, available: false, info: ["infoA"] },
-    ]
-}
-
-const newUpdatedObject = createImmutableUpdate(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": spread("portfolio") //common utilities
-})
-
-/** 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 createImmutableUpdate.
-**For the rest: Sets** its argument into the key provided in the createImmutableUpdate.
-
-```js
-import {spread} from 'maraj'
-
-const newUpdatedObject = createImmutableUpdate(data,{
-    'person': spread({info1: 'new Info'}), //same as (newValue) => (value) => ({...value, ...newValue})
-    'works': spread({title: 'new project', size: 20}) //same as (newValueToAdd) => (value) => ([...value, ...newValueToAdd])
-    'person.works': spread("portfolio") //same as (newValue) => (value) => (newValue)
-})
-```
-
-### remove
-
-Removes the **key of an object** or the **index of an array** in the key provided in the **createImmutableUpdate.**
-
-```js
-import {remove} from 'maraj'
-
-const newUpdatedObject = createImmutableUpdate(person,{
-    'person': remove('works'), // returns new value (in this case "person") without the provided key ("works")
-    'works': remove(1) // returns new array (in this case "works") without the provided index (1)
-})
-```
-
-### createSelectorFromStringPath
-
-**Creates a store selector** from provided string path.
-
-Usefull in cases like getting data from Redux, Zustand, and so on. stores.
-
-```js
-import {createSelectorFromStringPath} from 'maraj'
-
-const stringPath = 'works.1.size'
-
-const storeSelector = createSelectorFromStringPath(stringPath) // will behave as (store) => store[works][1][size]
-```
-
-### splitPath
-
-Usefull when you want to spread multiple values into objects dynamically
-
-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')
-
-
-```js
-import {splitPath} from 'maraj'
-
-const stringPath = 'works.1.size'
-
-const { id, remainingPath } = splitPath(stringPath)
-// id = 'size'
-// remainingPath = 'works.1'
-```
+
+# Maraj
+
+A lightweight alternative for creating **immutable updates of objects and arrays** such as Immer or ImmutableJS.
+
+**4 times faster** and **over 10 times lighter**.
+
+Fully typed.
+
+Only **400 bytes** gziped and additional **300 bytes** for 4 common utilities that you will most likelly need in every project.
+
+Features:
+
+- Can accept multiple updates while mantaining the order of execution.
+- Easy syntax for conditional updates.
+- Functional updates.
+
+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)
+
+## Creating an Immutable Update
+
+The **updateImmutably** function has two arguments:
+
+1. The **Original object**.
+2. An **Update object** (key-value pairs representing the updates we want to make)
+
+The **Update Object** has the following syntax:
+
+```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
+}
+```
+
+Multiple key-value pairs that mantains the order of execution.
+
+- **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.)
+
+- **Value:** new value, any type. If its a function it ll be called with the current value in that field.
+
+## Example
+
+```js
+import updateImmutably, { spread } from "maraj";
+
+const data = {
+    person: { name: "Lukasz", works: ["soum", "fi"] },
+    works: [
+        { 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
+})
+
+/** 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
+
+Removes the **key of an object** or the **index of an array** in the key provided in the **updateImmutably.**
+
+```js
+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)
+})
+```
+
+### select
+
+**Creates a store selector** from provided string path.
+
+Usefull in cases like getting data from Redux, Zustand, and so on. stores.
+
+```js
+import {select} from 'maraj'
+
+const stringPath = 'works.1.size'
+
+const storeSelector = (state) => select(state, stringPath) // will behave as (store) => store[works][1][size]
+```
+
+### splitPathAtLastKey
+
+Usefull when you want to spread multiple values into objects dynamically
+
+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')
+
+```js
+import {splitPathAtLastKey} from 'maraj'
+
+const stringPath = 'works.1.size'
+
+const [remainingPath, last] = splitPathAtLastKey(stringPath)
+// last = 'size'
+// remainingPath = 'works.1'
+```

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+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>}`;
+}[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 to know when a path is indexing an array
+ */
+type PathIndexingArray<T extends string | number> = `${T}` | `${T}.${string}` | `${string}.${T}` | `${string}.${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 ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedProperty<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 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>;
+/**
+ * Returns the value from a given dot path of an object/array.
+ * Returns undefined if the provided path doesnt exist.
+ */
+declare const select: Select;
+
+type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [string, string];
+/**
+ * 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;
+};
+/**
+ * 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 };

package/dist/index.d.ts

@@ -0,0 +1,89 @@
+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>}`;
+}[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 to know when a path is indexing an array
+ */
+type PathIndexingArray<T extends string | number> = `${T}` | `${T}.${string}` | `${string}.${T}` | `${string}.${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 ValueInDotPath<TObject, TPath extends DotPaths<TObject> | ''> = NestedProperty<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 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>;
+/**
+ * Returns the value from a given dot path of an object/array.
+ * Returns undefined if the provided path doesnt exist.
+ */
+declare const select: Select;
+
+type SplitDotPathAtLastKey = <T extends string>(dotPath: T) => [string, string];
+/**
+ * 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;
+};
+/**
+ * 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 };

package/dist/index.js

@@ -0,0 +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});

package/dist/index.mjs

@@ -0,0 +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};

package/package.json

@@ -1,16 +1,44 @@
 {
-  "name": "maraj",
-  "version": "1.1.2",
-  "description": "A lightweight 500 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
-  "main": "maraj.js",
-  "type": "module",
-  "scripts": {
-    "test": "vitest"
-  },
-  "author": "Lukasz Maraj",
-  "license": "MIT",
-  "devDependencies": {
-    "typescript": "^4.9.5",
-    "vitest": "^0.28.4"
-  }
-}
+   "name": "maraj",
+   "version": "2.0.0",
+   "description": "A lightweight 500 bytes gzipped alternative for immutable updates while dealing with objects and arrays",
+   "keywords": [
+      "shallow",
+      "shallow copy",
+      "nested copy"
+   ],
+   "author": "Lukasz Maraj",
+   "license": "MIT",
+   "private": false,
+   "main": "dist/index.js",
+   "module": "dist/index.mjs",
+   "types": "dist/index.d.ts",
+   "files": [
+      "dist",
+      "README.md",
+      "LICENSE"
+   ],
+   "scripts": {
+      "dev": "vitest",
+      "test": "vitest run",
+      "build": "tsup src/index.ts --minify --format cjs,esm --dts",
+      "lint": "tsc",
+      "ci": "npm run lint && npm run test && npm run build",
+      "release": "npm run lint && npm run test && npm run build && changeset publish"
+   },
+   "repository": {
+      "type": "git",
+      "url": "git+https://github.com/Lukasz17git/maraj.git"
+   },
+   "bugs": {
+      "url": "https://github.com/Lukasz17git/maraj/issues"
+   },
+   "homepage": "https://github.com/Lukasz17git/maraj#readme",
+   "devDependencies": {
+      "@changesets/cli": "^2.27.1",
+      "@microsoft/api-extractor": "^7.38.5",
+      "tsup": "^8.0.1",
+      "typescript": "^4.9.5",
+      "vitest": "^0.28.4"
+   }
+}

package/maraj.d.ts

@@ -1,40 +0,0 @@
-/**
- * @file maraj.js is the root file for this example app
- * @author Lukasz Maraj
- * @see <a href="https://lukaszmaraj.com">Lukasz Maraj</a>
- */
-/**
- * Returns a new updated state (new object/array)
- * @param {object} state - object or array to update immutably
- * @param {object} update - update object
- * @returns - new updated state
- */
-declare const createImmutableUpdate: (state: any, update?: {}) => any;
-export default createImmutableUpdate;
-/**
- * Spreads if its an object or array to the target, if its not then it sets its value
- * @param {*} update - any
- * @returns - updated value; spreaded if object/array, overwritted for the rest of the cases
- */
-export declare const spread: (update: any) => (value: any) => any;
-/**
- * Removes properties or indexes; skips the ones dont exist
- * @param {string | number | string[] | number[]} keys - properties or indexes to be removed
- * @returns - new updated value
- */
-export declare const remove: (keys: string | number | string[] | number[]) => (value: any) => any;
-/**
- * Creates a selector with a string path
- * @param {string} path - path, ex: 'login.form.username.value'
- * @returns - store selector
- */
-export declare const createSelectorFromStringPath: (path: string) => (state: any) => any;
-/**
- * Splits string path into ID and RemainingPath
- * @param {string} path - Path separated by dots
- * @returns {id: string, remainingPath: string} - {id: string, remainingPath: string | ''}
- */
-export declare const splitPath: (path: string) => {
-    id: string;
-    remainingPath: string;
-};

package/maraj.js

@@ -1,99 +0,0 @@
-/**
- * @file maraj.js is the root file for this example app
- * @author Lukasz Maraj
- * @see <a href="https://lukaszmaraj.com">Lukasz Maraj</a>
- */
-
-
-/**
- * Returns a new updated state (new object/array)
- * @param {object} state - object or array to update immutably
- * @param {object} update - update object
- * @returns - new updated state
- */
-const createImmutableUpdate = (state, update = {}) => {
-    if (state?.constructor !== Object && !Array.isArray(state)) return state
-    const newState = Array.isArray(state) ? [...state] : { ...state }
-    const visited = {}
-    for (const [path, value] of Object.entries(update)) {
-        if (!path || path === 'false' || path === 'undefined' || path === 'null') continue
-        let keys = path.split(".")
-        let lastkey = keys.pop()
-        let tracker = visited
-        let current = newState
-        for (let key of keys) {
-            if (typeof current[key] !== 'object') throw new Error(`Destructure "${key}" in "${path}" with value: ${current[key]}`)
-            if (!tracker[key]) {
-                current[key] = Array.isArray(current[key]) ? [...current[key]] : { ...current[key] }
-                tracker[key] = {}
-            }
-            current = current[key]
-            tracker = tracker[key]
-        }
-        delete tracker[lastkey]
-        current[lastkey] = typeof value === 'function' ? value(current[lastkey]) : value
-    }
-    return newState
-}
-export default createImmutableUpdate
-
-
-/**
- * Spreads if its an object or array to the target, if its not then it sets its value
- * @param {*} update - any
- * @returns - updated value; spreaded if object/array, overwritted for the rest of the cases
- */
-export const spread = (update) => (value) => {
-    if (value?.constructor === Object && update?.constructor === Object) return { ...value, ...update }
-    if (Array.isArray(value) && Array.isArray(update)) return [...value, ...update]
-    return update
-}
-
-
-/**
- * Removes properties or indexes; skips the ones dont exist
- * @param {string | number | string[] | number[]} keys - properties or indexes to be removed
- * @returns - new updated value
- */
-export const remove = (keys) => (value) => {
-    if (typeof value !== 'object') return value
-    if (typeof keys !== 'object' || keys === null) keys = [keys]
-    if (Array.isArray(value)) {
-        const values = keys.map(key => value[key])
-        return value.filter(v => (!values.includes(v) || (values.splice(values.indexOf(v), 1) && false)))
-    }
-    const update = { ...value }
-    keys.forEach(key => delete update[key])
-    return update
-}
-
-
-/**
- * Creates a selector with a string path
- * @param {string} path - path, ex: 'login.form.username.value'
- * @returns - store selector || undefined
- */
-export const createSelectorFromStringPath = (path) => (state) => {
-    if (typeof path !== 'string') throw new Error('Path should be string')
-    if (!path) return state
-    return path.split(".").reduce((current, key) => {
-        if (current?.hasOwnProperty(key)) return current[key]
-        return undefined
-    }, state)
-}
-
-
-/**
- * Splits string path into ID and RemainingPath
- * @param {string} path - Path separated by dots
- * @returns {id: string, remainingPath: string} - {id: string, remainingPath: string | ''}
- */
-// splits a string id path
-export const splitPath = (path) => {
-    if (typeof path !== 'string') throw new Error(`Provided path is not a string ${path}`)
-    const lastDot = path.lastIndexOf(".") + 1
-    return {
-        id: path.slice(lastDot),
-        remainingPath: lastDot ? path.slice(0, lastDot - 1) : ''
-    }
-}

package/tsconfig.json

@@ -1,104 +0,0 @@
-{
-  "include": ["./"],
-  "compilerOptions": {
-    /* Visit https://aka.ms/tsconfig to read more about this file */
-
-    /* Projects */
-    // "incremental": true,                              /* Save .tsbuildinfo files to allow for incremental compilation of projects. */
-    // "composite": true,                                /* Enable constraints that allow a TypeScript project to be used with project references. */
-    // "tsBuildInfoFile": "./.tsbuildinfo",              /* Specify the path to .tsbuildinfo incremental compilation file. */
-    // "disableSourceOfProjectReferenceRedirect": true,  /* Disable preferring source files instead of declaration files when referencing composite projects. */
-    // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
-    // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
-
-    /* Language and Environment */
-    "target": "ES2017",                                  /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
-    // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
-    // "jsx": "preserve",                                /* Specify what JSX code is generated. */
-    // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
-    // "emitDecoratorMetadata": true,                    /* Emit design-type metadata for decorated declarations in source files. */
-    // "jsxFactory": "",                                 /* Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'. */
-    // "jsxFragmentFactory": "",                         /* Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'. */
-    // "jsxImportSource": "",                            /* Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'. */
-    // "reactNamespace": "",                             /* Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit. */
-    // "noLib": true,                                    /* Disable including any library files, including the default lib.d.ts. */
-    // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
-    // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
-
-    /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
-    // "rootDir": "./",                                  /* Specify the root folder within your source files. */
-    // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
-    // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
-    // "paths": {},                                      /* Specify a set of entries that re-map imports to additional lookup locations. */
-    // "rootDirs": [],                                   /* Allow multiple folders to be treated as one when resolving modules. */
-    // "typeRoots": [],                                  /* Specify multiple folders that act like './node_modules/@types'. */
-    // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
-    // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    // "moduleSuffixes": [],                             /* List of file name suffixes to search when resolving a module. */
-    // "resolveJsonModule": true,                        /* Enable importing .json files. */
-    // "noResolve": true,                                /* Disallow 'import's, 'require's or '<reference>'s from expanding the number of files TypeScript should add to a project. */
-
-    /* JavaScript Support */
-    "allowJs": true,                                  /* Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files. */
-    // "checkJs": true,                                  /* Enable error reporting in type-checked JavaScript files. */
-    // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'. */
-
-    /* Emit */
-    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
-    "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
-    "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
-    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "dist",                                   /* Specify an output folder for all emitted files. */
-    // "removeComments": true,                           /* Disable emitting comments. */
-    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
-    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
-    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
-    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
-    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
-    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
-    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
-    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
-    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
-    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
-    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
-    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
-    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
-    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
-    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
-
-    /* Interop Constraints */
-    // "isolatedModules": true,                          /* Ensure that each file can be safely transpiled without relying on other imports. */
-    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
-    "esModuleInterop": true,                             /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */
-    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
-    "forceConsistentCasingInFileNames": true,            /* Ensure that casing is correct in imports. */
-
-    /* Type Checking */
-    "strict": true,                                      /* Enable all strict type-checking options. */
-    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
-    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
-    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
-    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
-    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
-    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
-    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
-    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
-    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
-    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
-    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
-    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
-    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
-    // "noUncheckedIndexedAccess": true,                 /* Add 'undefined' to a type when accessed using an index. */
-    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
-    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
-    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
-    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
-
-    /* Completeness */
-    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
-    "skipLibCheck": true                                 /* Skip type checking all .d.ts files. */
-  }
-}