maraj 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,129 @@
+
+# Immutable Maraj
+
+A lightweight alternative for creating immutable updates of objects and arrays.
+4 times faster than the commonly used alternatives like Immer or ImmutableJS.
+Only 600 bytes gziped with 5 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.
+
+## Creating an Immutable Update
+
+The createImmutableUpdate function has two arguments:
+- First one: The original object we want to update non-destructively
+- Second one: An update object with key-value pairs representing the updates we want to make
+
+The updateObject has the following syntax:
+
+- It can accept multiple key-value pairs and the order of execution will be preserved.
+
+- Key: path name of the fiels, separated by commas (same syntax you use to access object properties)
+(for arrays just use its index value)
+(can accept conditional statements. If the key is falsy, undefined or null it will not update the new value into the new object.)
+
+- Value: can be any type, including a function, where its argument will be the current value and its return value has to be the new value to be updated
+
+
+## Example
+
+import createImmutableUpdate from 'maraj'
+
+const person = {
+    name: 'Lukasz',
+    country: 'Spain',
+    additionalInfo:{
+        info1: null,
+        info2: null,
+        info3: null,
+        info4: null
+    }
+    projects: [
+        {
+            title: 'portfolio',
+            languages: ['esp','eng'],
+            description: 'lorem ipsum',
+            available: false,
+            data:{
+                createdAt: '01-01-2000'
+                size: 20000
+            }
+        },
+        {
+            title: 'asia',
+            languages: ['esp','eng'],
+            description: 'lorem ipsum',
+            available: true,
+            data:{
+                createdAt: '01-01-2000'
+                size: 40000
+            }
+        },
+        {
+            title: 'pos',
+            languages: ['esp','eng'],
+            description: 'lorem ipsum',
+            available: false,
+            data:{
+                createdAt: '01-01-2000'
+                size: 100000
+            }
+        }
+    ]
+}
+
+createImmutableUpdate(person,{
+    'name': Maraj       //normal update
+    'projects.0.title': 'personal website'      //nested update
+    'projects.1.available': true     //nested update
+    'projects.1.available': (currentValue) => !currentValue     //functional update
+    'projects': (currentValue) => currentValue.filter(project => project.available)     //functional update
+    [condition && 'additionalInfo.info1']: 'some info'      //conditional update, only if the key is not false/undefined/null
+})
+
+
+## Other Utilities
+
+### spread
+
+Spreads its argument into the key provided in the createImmutableUpdate.
+Works with objects(updates its keys) and arrays(adds new values to the array)
+
+
+import {spread} from 'maraj'
+
+createImmutableUpdate(person,{
+    'additionalInfo.info1': spread({info1: 'new Info'})     //same as (newValue) => (value) => ({...value, ...newValue})
+    'projects': spread({title: 'new project'})      //same as (newValueToAdd) => (value) => ([...value, ...newValueToAdd])
+})
+
+
+### remove
+
+Removes the key of an object or the index of an array in the key provided in the createImmutableUpdate.
+
+import {spread} from 'maraj'
+
+createImmutableUpdate(person,{
+    'additionalInfo': remove('info1')     // returns new value (in this case "additionalInfo") without the provided key ("info1")
+    'projects': remove(1)      // returns new array (in this case "projects") 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.
+
+const stringPath = 'projects.1.data.size'
+
+createSelectorFromStringPath(stringPath) // will behave as (store) => store[projects][1][data][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')

package/index.js

@@ -1,4 +1,4 @@
-//creates 
+//creates a shallow deep copy with the only needed updated fields
 const createImmutableUpdate = (state, update = {}) => {
     const newState = Array.isArray(state) ? [...state] : { ...state }
     const visited = {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "maraj",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A lightweight 500 bytes alternative for immutable updates while dealing with objects and arrays",
   "main": "index.js",
   "scripts": {