atomaric 0.0.76 → 0.0.77

package/package.json

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

package/types/do.classes.model/Array.ts

@@ -0,0 +1,24 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export interface IAtomArrayDoActions<Value> {
+  /** like the Array.prototype.push() method */
+  push: (...values: Value[]) => void;
+
+  /** like the Array.prototype.unshift() method */
+  unshift: (...values: Value[]) => void;
+
+  /** transform current taken value */
+  update: (updater: (value: Value[]) => void) => void;
+
+  /** like the Array.prototype.filter() method, but callback is optional - (it) => !!it */
+  filter: (filter?: (value: Value, index: number, Array: Value[]) => any) => void;
+
+  /** will add value if not exists */
+  add: (value: Value) => void;
+
+  /** will delete value from array */
+  removeFirst: (value: Value) => void;
+
+  /** will add value if it doesn't exist, otherwise delete */
+  toggle: (value: Value, isAddToStart?: boolean) => void;
+}

package/types/do.classes.model/Boolean.ts

@@ -0,0 +1,4 @@
+export interface IAtomBooleanDoActions {
+  /** toggle current value between true/false */
+  toggle: () => void;
+}

package/types/do.classes.model/Map.ts

@@ -0,0 +1,22 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+export interface IAtomMapDoActions<
+  MapValue extends Map<any, any>,
+  Key extends MapValue extends Map<infer K, any> ? K : never,
+  Value extends MapValue extends Map<any, infer V> ? V : never,
+> {
+  /** like the Map.prototype.set() method, when value is new for key in current atom value */
+  setValue: (key: Key, value: Value) => void;
+
+  /** like the Map.prototype.set() method, when key is not exists */
+  setIfNo: (key: Key, value: Value) => void;
+
+  /** like the Map.prototype.delete() method */
+  delete: (key: Key) => void;
+
+  /** will add value if it doesn't exist, otherwise delete */
+  toggle: (key: Key, value: Value) => void;
+
+  /** like the Map.prototype.clear() method */
+  clear: () => void;
+}

package/types/do.classes.model/Number.ts

@@ -0,0 +1,6 @@
+export interface IAtomNumberDoActions {
+  /** pass the 2 to increment on 2, pass the -2 to decrement on 2
+   * **default: 1**
+   */
+  increment: (delta?: number) => void;
+}

package/types/do.classes.model/Object.ts

@@ -0,0 +1,12 @@
+import { ObjectActionsSetDeepPartialDoAction } from '..';
+
+export interface IAtomObjectDoActions<Value extends object> {
+  /** pass partial object to update some field values */
+  setPartial: (value: Partial<Value> | ((value: Value) => Partial<Value>)) => void;
+
+  /** transform current taken value */
+  update: (updater: (value: Value) => void) => void;
+
+  /** pass partial value to update some deep values by flat path */
+  setDeepPartial: ObjectActionsSetDeepPartialDoAction<Value>;
+}

package/types/do.classes.model/Set.ts

@@ -0,0 +1,13 @@
+export interface IAtomSetDoActions<Value> {
+  /** like the Set.prototype.add() method */
+  add: (value: Value) => void;
+
+  /** like the Set.prototype.delete() method */
+  delete: (value: Value) => void;
+
+  /** will add value if it doesn't exist, otherwise delete */
+  toggle: (value: Value) => void;
+
+  /** like the Set.prototype.clear() method */
+  clear: () => void;
+}

package/types/index.d.ts

@@ -1,11 +1,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { useSyncExternalStore } from 'react';
-import { AtomArrayDoActions } from '../src/do.classes/Array';
-import { AtomBooleanDoActions } from '../src/do.classes/Boolean';
-import { AtomMapDoActions } from '../src/do.classes/Map';
-import { AtomNumberDoActions } from '../src/do.classes/Number';
-import { AtomObjectDoActions } from '../src/do.classes/Object';
-import { AtomSetDoActions } from '../src/do.classes/Set';
+import { IAtomArrayDoActions } from './do.classes.model/Array';
+import { IAtomBooleanDoActions } from './do.classes.model/Boolean';
+import { IAtomMapDoActions } from './do.classes.model/Map';
+import { IAtomNumberDoActions } from './do.classes.model/Number';
+import { IAtomObjectDoActions } from './do.classes.model/Object';
+import { IAtomSetDoActions } from './do.classes.model/Set';
 import { Path, PathValue, PathValueDonor } from './paths';
 
 export type AtomSecureLevel = 0 | 1 | 2 | 3;
@@ -80,17 +80,17 @@ export type ObjectActionsSetDeepPartialDoAction<Value> = <
 ) => void;
 
 export type DefaultActions<Value> = Value extends Set<infer Val>
-  ? AtomSetDoActions<Val>
+  ? IAtomSetDoActions<Val>
   : Value extends Map<infer Key, infer Val>
-  ? AtomMapDoActions<Value, Key, Val>
+  ? IAtomMapDoActions<Value, Key, Val>
   : Value extends boolean
-  ? AtomBooleanDoActions
+  ? IAtomBooleanDoActions
   : Value extends (infer Val)[]
-  ? AtomArrayDoActions<Val>
+  ? IAtomArrayDoActions<Val>
   : Value extends number
-  ? AtomNumberDoActions
+  ? IAtomNumberDoActions
   : Value extends object
-  ? AtomObjectDoActions<Value>
+  ? IAtomObjectDoActions<Value>
   : object;
 
 declare class Atom<Value, Actions extends Record<string, AnyFunc> = Record<string, AnyFunc>> {

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

@@ -1,103 +0,0 @@
-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.removeFirst(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

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

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

@@ -1,27 +0,0 @@
-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

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

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

@@ -1,77 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import { atom, configureAtomaric } from '../lib';
-import { makeFullKey, wait } from '../utils';
-
-configureAtomaric({
-  useSyncExternalStore,
-  keyPathSeparator: '.',
-});
-
-describe('Map', () => {
-  type Value = number | { asasa: '' };
-  const testAtom = atom(new Map<string, Value>(), {
-    storeKey: 'map:test',
-    do: (set, get) => ({
-      filterKeyValues: () => {
-        const newMap = new Map();
-        get().forEach((value, key) => {
-          if (value) newMap.set(key, value);
-        });
-        set(newMap);
-      },
-    }),
-  });
-
-  test('do.setValue()', async () => {
-    testAtom.do.setValue('!', 1);
-    testAtom.do.setValue('@', 0);
-    testAtom.do.setValue('#', { asasa: '' });
-    testAtom.do.setValue('', 123);
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[["!",1],["@",0],["#",{"asasa":""}],["",123]]]');
-
-    expect(testAtom.get()).toEqual(
-      new Map<string, Value>([
-        ['!', 1],
-        ['@', 0],
-        ['#', { asasa: '' }],
-        ['', 123],
-      ]),
-    );
-  });
-
-  test('do.<filterKeyValues>()', async () => {
-    testAtom.do.filterKeyValues();
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[["!",1],["#",{"asasa":""}],["",123]]]');
-  });
-
-  test('do.delete()', async () => {
-    testAtom.do.delete('#');
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[["!",1],["",123]]]');
-  });
-
-  test('do.toggle()', async () => {
-    testAtom.do.toggle('#', 555);
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[["!",1],["",123],["#",555]]]');
-
-    testAtom.do.toggle('', 999);
-    testAtom.do.toggle('!', 1234567890);
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[["#",555]]]');
-  });
-
-  test('do.clear()', async () => {
-    testAtom.do.clear();
-    await wait();
-
-    expect(localStorage[makeFullKey('map:test')]).toEqual('[[]]');
-  });
-});

package/src/do.classes/Map.ts

@@ -1,59 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Atom } from '../../types';
-import { AtomDoActionsBasic } from './_Basic';
-
-export class AtomMapDoActions<
-  MapValue extends Map<any, any>,
-  Key extends MapValue extends Map<infer K, any> ? K : never,
-  Value extends MapValue extends Map<any, infer V> ? V : never,
-> extends AtomDoActionsBasic {
-  constructor(private a: Atom<MapValue>, actions: Record<string, AnyFunc> | nil) {
-    super(actions);
-    this.a = a;
-  }
-
-  /** like the Map.prototype.set() method, when value is new for key in current atom value */
-  setValue = (key: Key, value: Value) => {
-    if (this.a.get().get(key) === value) return;
-
-    const newMap = new Map(this.a.get());
-    newMap.set(key, value);
-
-    this.a.set(newMap as never);
-  };
-
-  /** like the Map.prototype.set() method, when key is not exists */
-  setIfNo = (key: Key, value: Value) => {
-    if (this.a.get().has(key)) return;
-
-    const newMap = new Map(this.a.get());
-    newMap.set(key, value);
-
-    this.a.set(newMap as never);
-  };
-
-  /** like the Map.prototype.delete() method */
-  delete = (key: Key) => {
-    if (!this.a.get().has(key)) return;
-
-    const newMap = new Map(this.a.get());
-    newMap.delete(key);
-
-    this.a.set(newMap as never);
-  };
-
-  /** will add value if it doesn't exist, otherwise delete */
-  toggle = (key: Key, value: Value) => {
-    const newMap = new Map(this.a.get());
-
-    if (newMap.has(key)) newMap.delete(key);
-    else newMap.set(key, value);
-
-    this.a.set(newMap as never);
-  };
-
-  /** like the Map.prototype.clear() method */
-  clear = () => {
-    this.a.set(new Map() as never);
-  };
-}

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

@@ -1,25 +0,0 @@
-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

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

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

@@ -1,67 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import { atom, configureAtomaric } from '../lib';
-import { wait } from '../utils';
-
-configureAtomaric({
-  useSyncExternalStore,
-  keyPathSeparator: '.',
-});
-
-describe('Object', () => {
-  test('do.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('do.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('do.setPartial()', async () => {
-    const testAtom = atom((): Record<number, unknown> => ({ 2: { a: 'A' } }));
-
-    testAtom.do.setPartial({ 3: { b: 'B' } });
-    testAtom.do.setPartial({ 4: [] });
-    await wait();
-
-    expect(testAtom.get()).toEqual({ 2: { a: 'A' }, 3: { b: 'B' }, 4: [] });
-  });
-
-  test('do.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

@@ -1,75 +0,0 @@
-import { Atom, ObjectActionsSetDeepPartialDoAction } from '../../types';
-import { configuredOptions } from '../lib';
-import { AtomUpdateDoAction } from './_Update';
-
-export class AtomObjectDoActions<Value extends object> extends AtomUpdateDoAction {
-  constructor(private a: Atom<Value>, actions: Record<string, AnyFunc> | nil) {
-    super(actions);
-  }
-
-  /** pass partial object to update some field values */
-  setPartial = (value: Partial<Value> | ((value: Value) => Partial<Value>)) =>
-    this.a.set(prev => ({
-      ...prev,
-      ...(typeof value === 'function' ? value(this.a.get()) : value),
-    }));
-
-  /** transform current taken value */
-  update = (updater: (value: Value) => void) => {
-    const prev = this.a.get();
-    const newValue = this.updateValue(prev, updater);
-    if (newValue === prev) return;
-    this.a.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.a.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.a.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.a.set(newObject);
-
-      return;
-    }
-
-    const prevValue = this.a.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

@@ -1,46 +0,0 @@
-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

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

package/src/do.classes/_Basic.ts

@@ -1,11 +0,0 @@
-export class AtomDoActionsBasic {
-  constructor(actions: Record<string, AnyFunc> | 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

@@ -1,37 +0,0 @@
-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() : { ...nextObject }
-          ) as never;
-        }
-
-        currentObject[setKey as never] = value as never;
-
-        return true;
-      },
-    });
-
-    updater(pro);
-
-    return isSomeSetted ? (newObject as never) : object;
-  };
-}