atomaric 0.0.68 → 0.0.69

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "atomaric",
   "description": "Manage your project state",
-  "version": "0.0.68",
+  "version": "0.0.69",
   "type": "module",
   "main": "./build/atomaric.umd.cjs",
   "module": "./build/atomaric.js",
@@ -15,7 +15,8 @@
   },
   "files": [
     "build",
-    "types"
+    "types",
+    "src/do.classes"
   ],
   "keywords": [
     "react",

package/src/do.classes/Array.test.ts

@@ -0,0 +1,103 @@
+import { useSyncExternalStore } from 'react';
+import { atom, configureAtomaric } from '../lib';
+import { wait } from '../utils';
+
+configureAtomaric({
+  useSyncExternalStore,
+  keyPathSeparator: '.',
+});
+
+describe('Array', () => {
+  test('simple init', async () => {
+    const initArray: number[] = [];
+    const testAtom = atom(initArray);
+    testAtom.set([]);
+
+    expect(testAtom.get() !== initArray).toBeTruthy();
+  });
+
+  test('do actions', async () => {
+    const testAtom = atom((): (number | nil | string | { nums: number[] })[] => [], {
+      do: (_set, _get, self) => ({
+        switch30(toggleValue: string) {
+          self.do.toggle(30);
+          self.do.toggle(toggleValue);
+        },
+      }),
+    });
+
+    testAtom.do.push(1, 2, 5, 2, 5, 5, 5, 5, 1, null, '', '#');
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 5, 2, 5, 5, 5, 5, 1, null, '', '#']);
+
+    testAtom.do.add(0);
+    testAtom.do.add(5);
+    testAtom.do.add(8);
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 5, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8]);
+
+    testAtom.do.remove(5);
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8]);
+
+    testAtom.do.toggle('+');
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8, '+']);
+
+    testAtom.do.toggle('+');
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8]);
+
+    testAtom.do.switch30('@');
+    await wait();
+
+    expect(testAtom.get()).toEqual([1, 2, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8, 30, '@']);
+
+    testAtom.do.unshift('**');
+    await wait();
+
+    expect(testAtom.get()).toEqual(['**', 1, 2, 2, 5, 5, 5, 5, 1, null, '', '#', 0, 8, 30, '@']);
+
+    testAtom.do.filter();
+    await wait();
+
+    expect(testAtom.get()).toEqual(['**', 1, 2, 2, 5, 5, 5, 5, 1, '#', 8, 30, '@']);
+
+    testAtom.do.filter(val => typeof val === 'string');
+    await wait();
+
+    expect(testAtom.get()).toEqual(['**', '#', '@']);
+
+    testAtom.do.update(val => val.reverse());
+    await wait();
+
+    expect(testAtom.get()).toEqual(['@', '#', '**']);
+
+    const nums555 = { nums: [5, 5, 5] };
+    const nums123 = { nums: [1, 2, 3] };
+
+    testAtom.do.add(nums123);
+    testAtom.do.add(nums555);
+    await wait();
+
+    expect(testAtom.get()).toEqual(['@', '#', '**', nums123, nums555]);
+
+    testAtom.do.update(val => {
+      if (val[3] && typeof val[3] === 'object' && 'nums' in val[3]) val[3].nums.reverse();
+    });
+    await wait();
+
+    expect(testAtom.get()).toEqual(['@', '#', '**', { nums: [3, 2, 1] }, nums555]);
+
+    expect(testAtom.get()[4] === nums555).toBeTruthy();
+    expect(testAtom.get()[3] !== nums123).toBeTruthy();
+
+    const value = testAtom.get();
+    expect(value[3] && typeof value[3] === 'object' && value[3].nums !== nums123.nums).toBeTruthy();
+  });
+});

package/src/do.classes/Array.ts

@@ -0,0 +1,59 @@
+import { Atom } from '../../types';
+import { AtomUpdateDoAction } from './_Update';
+
+export class AtomArrayDoActions<Value> extends AtomUpdateDoAction {
+  constructor(private atom: Atom<Value[]>, actions: Record<string, Function> | nil) {
+    super(actions);
+  }
+
+  /** like the Array.prototype.push() method */
+  push = (...values: Value[]) => {
+    this.atom.set(this.atom.get().concat(values));
+  };
+
+  /** like the Array.prototype.unshift() method */
+  unshift = (...values: Value[]) => {
+    this.atom.set(values.concat(this.atom.get()));
+  };
+
+  /** transform current taken value */
+  update = (updater: (value: Value[]) => void) => {
+    const prev = this.atom.get();
+    const newValue = this.updateValue(prev, updater);
+    if (newValue === prev) return;
+    this.atom.set(newValue);
+  };
+
+  /** like the Array.prototype.filter() method, but callback is optional - (it) => !!it */
+  filter = (filter?: (value: Value, index: number, Array: Value[]) => any) => {
+    this.atom.set(this.atom.get().filter(filter ?? itIt));
+  };
+
+  /** will add value if not exists */
+  add = (value: Value) => {
+    if (this.atom.get().includes(value)) return;
+    this.atom.set(this.atom.get().concat([value]));
+  };
+
+  /** will delete value from array */
+  remove = (value: Value) => {
+    const index = this.atom.get().indexOf(value);
+    if (index < 0) return;
+    const newArray = this.atom.get().slice(0);
+    newArray.splice(index, 1);
+    this.atom.set(newArray);
+  };
+
+  /** will add value if it doesn't exist, otherwise delete */
+  toggle = (value: Value, isAddToStart?: boolean) => {
+    const newArray = this.atom.get().slice();
+    const index = newArray.indexOf(value);
+    if (index < 0) {
+      if (isAddToStart) newArray.unshift(value);
+      else newArray.push(value);
+    } else newArray.splice(index, 1);
+    this.atom.set(newArray);
+  };
+}
+
+const itIt = <It>(it: It) => it;

package/src/do.classes/Boolean.test.ts

@@ -0,0 +1,27 @@
+import { useSyncExternalStore } from 'react';
+import { atom, configureAtomaric } from '../lib';
+import { wait } from '../utils';
+
+configureAtomaric({
+  useSyncExternalStore,
+  keyPathSeparator: '.',
+});
+
+describe('Boolean', () => {
+  test('do actions', async () => {
+    const testAtom = atom(false, {
+      do: (set, get) => ({
+        switch(news?: boolean) {
+          set(news ?? !get());
+        },
+      }),
+    });
+
+    testAtom.do.switch(true);
+    testAtom.do.switch();
+    testAtom.do.toggle();
+    await wait();
+
+    expect(testAtom.get() === true).toBeTruthy();
+  });
+});

package/src/do.classes/Boolean.ts

@@ -0,0 +1,13 @@
+import { Atom } from '../../types';
+import { AtomDoActionsBasic } from './_Basic';
+
+export class AtomBooleanDoActions extends AtomDoActionsBasic {
+  constructor(private atom: Atom<boolean>, actions: Record<string, Function> | nil) {
+    super(actions);
+  }
+
+  /** toggle current value between true/false */
+  toggle = () => {
+    this.atom.set(!this.atom.get());
+  };
+}

package/src/do.classes/Number.test.ts

@@ -0,0 +1,25 @@
+import { useSyncExternalStore } from 'react';
+import { atom, configureAtomaric } from '../lib';
+import { wait } from '../utils';
+
+configureAtomaric({
+  useSyncExternalStore,
+  keyPathSeparator: '.',
+});
+
+describe('Number', () => {
+  test('do actions', async () => {
+    const testAtom = atom(100, { do: (set, get) => ({ switchSign: () => set(-get()) }) });
+    const testFuncAtom = atom(() => 200, { do: (set, get) => ({ switchSign: () => set(-get()) }) });
+
+    testAtom.do.increment();
+    testAtom.do.switchSign();
+
+    testFuncAtom.do.increment(-3);
+    testFuncAtom.do.switchSign();
+    await wait();
+
+    expect(testAtom.get()).toEqual(-101);
+    expect(testFuncAtom.get()).toEqual(-197);
+  });
+});

package/src/do.classes/Number.ts

@@ -0,0 +1,15 @@
+import { Atom } from '../../types';
+import { AtomDoActionsBasic } from './_Basic';
+
+export class AtomNumberDoActions extends AtomDoActionsBasic {
+  constructor(private atom: Atom<number>, actions: Record<string, Function> | nil) {
+    super(actions);
+  }
+
+  /** pass the 2 to increment on 2, pass the -2 to decrement on 2
+   * **default: 1**
+   */
+  increment = (delta?: number) => {
+    this.atom.set(+this.atom.get() + (delta ?? 1));
+  };
+}

package/src/do.classes/Object.test.ts

@@ -0,0 +1,57 @@
+import { useSyncExternalStore } from 'react';
+import { atom, configureAtomaric } from '../lib';
+import { wait } from '../utils';
+
+configureAtomaric({
+  useSyncExternalStore,
+  keyPathSeparator: '.',
+});
+
+describe('Object', () => {
+  test('setDeepPartial()', async () => {
+    const b = { c: [{ d: 8, e: 'e', f: 'F', g: { h: 'HHH' } }] };
+    const a = { f: { g: '' }, b };
+    const testAtom = atom({ a, b });
+
+    testAtom.do.setDeepPartial('b.c.0.d', 123, { b: { c: [{}] } });
+
+    await wait();
+
+    expect(testAtom.get().b).not.toEqual(b);
+    expect(testAtom.get().b.c[0].d).toEqual(123);
+    expect(testAtom.get().b.c).not.toEqual(b.c);
+    expect(testAtom.get().a).toEqual(a);
+
+    testAtom.do.setDeepPartial('b+c+8+e', 'EE', null, '+');
+
+    await wait();
+
+    expect(testAtom.get().b.c[8].e).toEqual('EE');
+  });
+
+  test('setDeepPartial() with first numeric prop', async () => {
+    enum Num {
+      num = 123,
+    }
+    const testAtom = atom({ [Num.num]: { a: 'A' } });
+
+    testAtom.do.setDeepPartial(`${Num.num}.a`, 'AA', { [Num.num]: {} });
+
+    await wait();
+
+    expect(testAtom.get()[Num.num].a).toEqual('AA');
+  });
+
+  test('update()', async () => {
+    const init = { a: { b: { c: { d: { e: 'E' } }, f: { g: {} } }, h: { i: { j: {} } } } };
+    const testAtom = atom(init);
+
+    testAtom.do.update(obj => (obj.a.b.c.d.e = 'eE'));
+
+    await wait();
+
+    expect(testAtom.get().a.b.c.d.e).toEqual('eE');
+    expect(testAtom.get().a.b.c).not.toEqual(init.a.b.c);
+    expect(testAtom.get().a.h.i).toEqual(init.a.h.i);
+  });
+});

package/src/do.classes/Object.ts

@@ -0,0 +1,75 @@
+import { Atom, ObjectActionsSetDeepPartialDoAction } from '../../types';
+import { configuredOptions } from '../lib';
+import { AtomUpdateDoAction } from './_Update';
+
+export class AtomObjectDoActions<Value extends object> extends AtomUpdateDoAction {
+  constructor(private atom: Atom<Value>, actions: Record<string, Function> | nil) {
+    super(actions);
+  }
+
+  /** pass partial object to update some field values */
+  setPartial = (value: Partial<Value> | ((value: Value) => Partial<Value>)) =>
+    this.atom.set(prev => ({
+      ...prev,
+      ...(typeof value === 'function' ? value(this.atom.get()) : value),
+    }));
+
+  /** transform current taken value */
+  update = (updater: (value: Value) => void) => {
+    const prev = this.atom.get();
+    const newValue = this.updateValue(prev, updater);
+    if (newValue === prev) return;
+    this.atom.set(newValue);
+  };
+
+  /** pass partial value to update some deep values by flat path */
+  setDeepPartial: ObjectActionsSetDeepPartialDoAction<Value> = (
+    path,
+    value,
+    donor,
+    separator = (configuredOptions.keyPathSeparator || '.') as never,
+  ) => {
+    if (!separator) return;
+
+    if (path.includes(separator)) {
+      let keys = path.split(separator);
+      const lastKey = keys[keys.length - 1];
+      keys = keys.slice(0, -1);
+      const newObject = { ...this.atom.get() };
+      let lastObject = newObject as Record<string, unknown>;
+      let lastDonorObject = donor as Record<string, unknown> | nil;
+
+      for (const key of keys) {
+        lastDonorObject = lastDonorObject?.[Array.isArray(lastDonorObject) ? '0' : key] as never;
+        const currentObject = lastObject[makeKey(lastObject, key)] ?? (Array.isArray(lastDonorObject) ? [] : {});
+
+        if (currentObject == null || typeof currentObject !== 'object') {
+          if (donor == null) throw 'Incorrect path for setDeepPartial';
+
+          const newValue = typeof value === 'function' ? (value as (val: undefined) => Value)(undefined) : value;
+
+          if (this.atom.get()[path as never] !== newValue) this.setPartial({ [path]: newValue } as never);
+          return;
+        }
+
+        lastObject = lastObject[makeKey(lastObject, key)] = (
+          Array.isArray(currentObject) ? [...currentObject] : { ...currentObject }
+        ) as never;
+      }
+
+      const prev = lastObject[lastKey];
+      lastObject[lastKey] =
+        typeof value === 'function' ? (value as (val: unknown) => Value)(lastObject[lastKey]) : value;
+
+      if (prev !== lastObject[lastKey]) this.atom.set(newObject);
+
+      return;
+    }
+
+    const prevValue = this.atom.get()[path as never];
+    const newValue = typeof value === 'function' ? (value as (val: Value) => Value)(prevValue) : value;
+    if (newValue !== prevValue) this.setPartial({ [path]: newValue } as never);
+  };
+}
+
+const makeKey = (obj: object, key: string) => (Array.isArray(obj) ? `${+key}` : key);

package/src/do.classes/Set.test.ts

@@ -0,0 +1,46 @@
+import { useSyncExternalStore } from 'react';
+import { atom, configureAtomaric } from '../lib';
+import { makeFullKey, wait } from '../utils';
+
+configureAtomaric({
+  useSyncExternalStore,
+  keyPathSeparator: '.',
+});
+
+describe('Set', () => {
+  test('do actions', async () => {
+    const testAtom = atom(new Set<string>(), {
+      storeKey: 'set:test',
+      do: (set, get) => ({
+        filterValues: () => {
+          const array = Array.from(get());
+          set(new Set(array.filter(it => it)));
+        },
+      }),
+    });
+
+    testAtom.do.add('!');
+    testAtom.do.add('@');
+    testAtom.do.add('#');
+    testAtom.do.add('');
+    await wait();
+
+    expect(localStorage[makeFullKey('set:test')]).toEqual('[["!","@","#",""]]');
+
+    testAtom.do.filterValues();
+    await wait();
+
+    expect(localStorage[makeFullKey('set:test')]).toEqual('[["!","@","#"]]');
+
+    testAtom.do.toggle('@');
+    await wait();
+
+    expect(localStorage[makeFullKey('set:test')]).toEqual('[["!","#"]]');
+
+    testAtom.do.toggle('@');
+    testAtom.do.delete('!');
+    await wait();
+
+    expect(localStorage[makeFullKey('set:test')]).toEqual('[["#","@"]]');
+  });
+});

package/src/do.classes/Set.ts

@@ -0,0 +1,36 @@
+import { Atom } from '../../types';
+import { AtomDoActionsBasic } from './_Basic';
+
+export class AtomSetDoActions<Value> extends AtomDoActionsBasic {
+  constructor(private atom: Atom<Set<Value>>, actions: Record<string, Function> | nil) {
+    super(actions);
+    this.atom = atom;
+  }
+
+  /** like the Set.prototype.add() method */
+  add = (value: Value) => {
+    this.atom.set(new Set(this.atom.get()).add(value));
+  };
+
+  /** like the Set.prototype.delete() method */
+  delete = (value: Value) => {
+    const newSet = new Set(this.atom.get());
+    newSet.delete(value);
+    this.atom.set(newSet);
+  };
+
+  /** will add value if it doesn't exist, otherwise delete */
+  toggle = (value: Value) => {
+    const newSet = new Set(this.atom.get());
+
+    if (newSet.has(value)) newSet.delete(value);
+    else newSet.add(value);
+
+    this.atom.set(newSet);
+  };
+
+  /** like the Set.prototype.clear() method */
+  clear = () => {
+    this.atom.set(new Set());
+  };
+}

package/src/do.classes/_Basic.ts

@@ -0,0 +1,11 @@
+export class AtomDoActionsBasic {
+  constructor(actions: Record<string, Function> | nil) {
+    if (actions)
+      return new Proxy(this, {
+        get: (self, p) => {
+          if (p in this) return self[p as never];
+          return actions[p as never];
+        },
+      });
+  }
+}

package/src/do.classes/_Update.ts

@@ -0,0 +1,37 @@
+import { makeDeepProxyObject } from '../makeDeepProxyObject';
+import { AtomDoActionsBasic } from './_Basic';
+
+export class AtomUpdateDoAction extends AtomDoActionsBasic {
+  protected updateValue = <Object extends object | unknown[]>(
+    object: Object,
+    updater: (object: Object) => void,
+  ): Object => {
+    const newObject = Array.isArray(object) ? object.slice(0) : { ...object };
+    let isSomeSetted = false;
+
+    const pro = makeDeepProxyObject(object, {
+      onSet: (_, keys, setKey, value, prevValue) => {
+        if (value === prevValue) return true;
+        let currentObject = newObject as Record<string, unknown> | unknown[];
+
+        isSomeSetted = true;
+
+        for (const key of keys) {
+          const nextObject = currentObject[key as never] as object;
+
+          currentObject = currentObject[key as never] = (
+            Array.isArray(nextObject) ? nextObject.slice(0) : { ...nextObject }
+          ) as never;
+        }
+
+        currentObject[setKey as never] = value as never;
+
+        return true;
+      },
+    });
+
+    updater(pro);
+
+    return isSomeSetted ? (newObject as never) : object;
+  };
+}