maraj 1.1.2 → 2.1.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,153 @@
-
-# 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 fast lightweight utility for creating **immutable updates**. Full typescript support. Only 600 bytes gziped. Includes usefull utilities for manipulating updates (like remove, select).
+
+### Features
+
+- Full typescript support.
+- Correct type inference.
+- Multiple updates at same time mantaining the order of execution.
+- Functional updates.
+
+**<u>For Typescript:</u>** in tsconfig.json set **"strictNullChecks"** and **"noUncheckedIndexedAccess"** to true for correct type inference of optional properties (so it can correctly differentiate between optional props and props with possible undefined value)
+
+```ts
+const originalValue = { name: 'one', lastname: 'two' modified: false, files: [{ filename: 'one' }] }
+
+const updatedValue = updateImmutably(orignalValue, {
+   'name': 'updated',
+   'modified': (value, fullObject) => !value,
+   'files.0.filename': 'zero',
+})
+
+// updatedValue = { name: 'updated', lastname: 'two' modified: true, files: [{ filename: 'zero' }] }
+
+originalValue.files[1] === updatedValue.files[1] // true
+```
+
+### Limitations
+
+- If "addNonExistentPropsAndIndexes" is enabled, numbers will always create an array if the array/object doesnt exist beforehand.
+
+```ts
+const updatedValue = updateImmutably({}, {
+   'files.1.name': 'new name',
+}, true)
+// updatedValue = { files: [<empty>, { name: 'new name' }] }
+```
+
+- The type "UpdateDotObject" using computed properties ( [key] ) will always throw a ts error even if the typing is correct. [Playground simple explanation](https://www.typescriptlang.org/play?ts=5.3.2#code/LAKALgngDgpgBAGQJYGcxwLxwOQENtwA+cABgCQDeAdgK4C2ARjAE4C+JooksiqYASjADGAe2YATTHApwA2gGk4SKrzQBdAPwAuOItacQoqmjhDmMXGBiDREqQB4AKnBgAPK1XEpVYAHwAKAGsYCB1HAEpMX2lQODijE3MhHWQ0GzFJLApYuNyAejy4AD0wbxZmMR0UZSF4ADcAFgA6AGYmgFYldAB3JAAbPrgwAAsK7rhcFXKxCfQhYeFA5QBzUxE6KBorSWCIb0nJOtw+mhhvGmqqVasNvst4PqQrZmOyupgVJAAzIYWh6BWSm8tiSYByuTkuzUOl24P0IFy5jANGYKiSoFYQA)
+
+```ts
+const updateFieldStore = <TPath extends DotPaths<Store>>(
+   path: TPath,
+   newValue: UpdateDotPathValue<Store, TPath>
+) => {
+   const update: UpdateDotPathObject<Store> = {
+      // ^throws ts error even if the typing is correct
+      [path]: newValue
+   } // fix: coherce it with " as UpdateDotPathObject<Store>"
+   return update
+}
+```
+
+- Use the "set" utility if typescript doesn't distinguish properly _"an optional field"_ vs a _"field which can have 'undefined' as type"_. Usually happens in optional nested props inside arrays.
+
+```ts
+const updatedValue = updateImmutably(data, {
+   'files.0.optionalProperty': 'new name',
+   'files.1.optionalProperty': undefined, //no ts error
+   'files.0.optionalProperty': set('new name'),
+   'files.1.optionalProperty': set(undefined), //throws ts error, undefined cant be a value.
+})
+```
+
+## Creating an Immutable Update
+
+Arguments:
+
+- Original Object
+- Update Object
+- If it should add non-existent properties/indexes
+
+## Example
+
+```js
+import { updateImmutably } from "maraj";
+
+const data = {
+    profile: { name: "Lukasz" },
+    works: ["soum", "fi"],
+    history: [
+        { title: "soum", size: 90, available: true, info: ["info1"] },
+        { title: "fi", size: 30, available: false, info: ["infoA"] },
+    ]
+}
+
+const newUpdatedObject = updateImmutably(data, {
+    "profile.age": 28, //add new properties if "addNonExistentPropsAndIndexes" is enabled
+    "profile.name": "Lucas", //update values
+    "works.1": "gs", //nested array update
+    "history.1.available": (currentValue) => (!currentValue), //functional update
+    "works": (v) => [...v, 'portfolio'] //add new value to array
+})
+```
+
+## Remove Utility
+
+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,{
+    'profile': (value) => remove(value, 'name'), // returns new value without the "name" prop
+    'works': (value) => remove(value, 1), // returns new array without the provided index (1)
+    'works': (value) => remove(value, [1, "0"]), // returns new array without the provided index (0,1)
+})
+```
+
+## Select Utility
+
+Selects the value of an object/array from a string-dot-path. Usefull in state management libraries.
+
+```js
+import {select} from 'maraj'
+
+const stringPath = 'works.1.size'
+
+const work1SizeSelector = (state) => select(state, stringPath) // will behave as (store) => store[works][1][size]
+```
+
+## SplitPathAtLastKey Utility
+
+Usefull when you want to retrieve the last key (for example an id).
+
+Splits string path (example:'projects.1.data.size' ) into two:
+
+- remainingPath: the remaining path (in this case 'projects.1.data')
+- lastKey: the last key in the path (in this case 'size')
+
+```js
+import { splitPathAtLastKey } from 'maraj'
+
+const stringPath = 'works.1.size'
+
+const [remainingPath, last] = splitPathAtLastKey(stringPath)
+// last = 'size'
+// remainingPath = 'works.1'
+```
+
+## Set Utility
+
+In some unusual cases (usually when updating an optional object prop inside an array) typescript infers incorrectly the optional key vs a key with undefined value. To fix this typing issue, use the "set" function so it correctly infers the type in the field.
+
+```ts
+const updatedValue = updateImmutably(data, {
+   'files.0.optionalProperty': 'new name',
+   'files.1.optionalProperty': undefined, //no ts error
+   'files.0.optionalProperty': set('new name'),
+   'files.1.optionalProperty': set(undefined), //throws ts error, undefined cant be a value.
+})
+```

package/dist/index.d.mts

@@ -0,0 +1,75 @@
+/**
+ * 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 ArrayIndexPaths = `${number}` | Index;
+type ArrayPaths<TInnerType> = `${ArrayIndexPaths}` | `${ArrayIndexPaths}.${Flatten<TInnerType>}`;
+type ObjectPaths<T> = {
+    [Key in keyof T & string]: `${Key}` | `${Key}.${Flatten<T[Key]>}`;
+}[keyof T & string];
+type TuplePaths<T> = ObjectPaths<Omit<T, keyof any[]>>;
+type Flatten<T> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? TuplePaths<T> : ArrayPaths<U> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T>;
+type DotPaths<T extends object> = Flatten<T>;
+/**
+ * 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 extends object, TPath extends DotPaths<TObject> | ''> = NestedProperty<TObject, TPath>;
+type DotPathUpdateValue<TObject extends object, TPath extends DotPaths<TObject>> = TPath extends PathIndexingArray<Index> ? [`PATH ERROR: replace _INDEX_ with a NUMBER`, ValueInDotPath<TObject, TPath>, ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>)] : ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+/**
+ * Update Object Type Implementation
+ */
+type DotPathUpdateObject<TObject extends object> = {
+    [TKey in DotPaths<TObject>]?: DotPathUpdateValue<TObject, TKey>;
+};
+/**
+ * Optional and Required keys
+ */
+type NonPartialKeys = string | number | boolean | symbol | bigint | null | object;
+type OptionalKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
+}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
+}[keyof T & string];
+
+type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (OptionalKeys<T> | (OptionalKeys<T>)[])) => T;
+/**
+ * Removes properties or indexes, order doesn't matter.
+ */
+declare const remove: Remove;
+
+type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, path: TPath) => TPath extends PathIndexingArray<Index> ? never : TPath extends PathIndexingArray<number> ? ValueInDotPath<T, TPath> | undefined : ValueInDotPath<T, TPath>;
+/**
+ * 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 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 UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
+/**
+ * Creates a new updated object/array applying the changes provided in the update object.
+ * It doesnt modify the original input.
+ * If any of the paths doesnt exists it returns
+ */
+declare const updateImmutably: UpdateImmutably;
+
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type RequiredKeys, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+/**
+ * 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 ArrayIndexPaths = `${number}` | Index;
+type ArrayPaths<TInnerType> = `${ArrayIndexPaths}` | `${ArrayIndexPaths}.${Flatten<TInnerType>}`;
+type ObjectPaths<T> = {
+    [Key in keyof T & string]: `${Key}` | `${Key}.${Flatten<T[Key]>}`;
+}[keyof T & string];
+type TuplePaths<T> = ObjectPaths<Omit<T, keyof any[]>>;
+type Flatten<T> = T extends ReadonlyArray<infer U> ? IsTuple<T> extends true ? TuplePaths<T> : ArrayPaths<U> : T extends PrimitivesAndNativeObjects ? never : ObjectPaths<T>;
+type DotPaths<T extends object> = Flatten<T>;
+/**
+ * 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 extends object, TPath extends DotPaths<TObject> | ''> = NestedProperty<TObject, TPath>;
+type DotPathUpdateValue<TObject extends object, TPath extends DotPaths<TObject>> = TPath extends PathIndexingArray<Index> ? [`PATH ERROR: replace _INDEX_ with a NUMBER`, ValueInDotPath<TObject, TPath>, ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>)] : ValueInDotPath<TObject, TPath> | ((fieldValue: ValueInDotPath<TObject, TPath>, fullObject: TObject) => ValueInDotPath<TObject, TPath>);
+/**
+ * Update Object Type Implementation
+ */
+type DotPathUpdateObject<TObject extends object> = {
+    [TKey in DotPaths<TObject>]?: DotPathUpdateValue<TObject, TKey>;
+};
+/**
+ * Optional and Required keys
+ */
+type NonPartialKeys = string | number | boolean | symbol | bigint | null | object;
+type OptionalKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? never : K;
+}[keyof T & string];
+type RequiredKeys<T> = {
+    [K in keyof T & string]: T[K] extends NonPartialKeys ? K : never;
+}[keyof T & string];
+
+type Remove = <T extends object>(value: T, keys: T extends any[] ? (number | `${number}` | (number | `${number}`)[]) : (OptionalKeys<T> | (OptionalKeys<T>)[])) => T;
+/**
+ * Removes properties or indexes, order doesn't matter.
+ */
+declare const remove: Remove;
+
+type Select = <T extends object, TPath extends (DotPaths<T> | '')>(state: T, path: TPath) => TPath extends PathIndexingArray<Index> ? never : TPath extends PathIndexingArray<number> ? ValueInDotPath<T, TPath> | undefined : ValueInDotPath<T, TPath>;
+/**
+ * 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 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 UpdateImmutably = <T extends object>(state: T, updates: DotPathUpdateObject<T>, addNonExistentPropsAndIndexes?: true) => T;
+/**
+ * Creates a new updated object/array applying the changes provided in the update object.
+ * It doesnt modify the original input.
+ * If any of the paths doesnt exists it returns
+ */
+declare const updateImmutably: UpdateImmutably;
+
+export { type DotPathUpdateObject, type DotPathUpdateValue, type DotPaths, type OptionalKeys, type RequiredKeys, type ValueInDotPath, remove, select, set, splitPathAtLastKey, updateImmutably };

package/dist/index.js

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

package/dist/index.mjs

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

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.1.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": "^5.3.3",
+      "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. */
-  }
-}