atomaric 0.0.60 → 0.0.61

package/package.json

@@ -1,23 +1,21 @@
 {
   "name": "atomaric",
   "description": "Manage your project state",
-  "version": "0.0.60",
+  "version": "0.0.61",
   "type": "module",
-  "source": "./src/index.ts",
-  "main": "./src/index.ts",
-  "module": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./build/atomaric.umd.cjs",
+  "module": "./build/atomaric.js",
+  "types": "./types/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./types/index.d.ts",
+      "require": "./build/atomaric.umd.cjs",
+      "import": "./build/atomaric.js"
     }
   },
   "files": [
     "build",
-    "types",
-    "src"
+    "types"
   ],
   "keywords": [
     "react",

package/src/class.ts

@@ -1,295 +0,0 @@
-import {
-  AtomOptions,
-  AtomSetDeferredMethod,
-  AtomSetMethod,
-  AtomStoreKey,
-  AtomSubscribeMethod,
-  Atom as AtomType,
-  DefaultActions,
-} from '../types';
-import { makeDoFillerActions } from './makeDoFillerActions';
-
-type Subscriber<Value> = (value: Value) => void;
-
-type Tools = { exp?: number };
-
-export class Atom<Value, Actions extends Record<string, Function> = {}> implements AtomType<Value, Actions> {
-  get;
-  set: AtomSetMethod<Value>;
-  setDeferred: AtomSetDeferredMethod<Value>;
-  reset: () => void;
-  subscribe: AtomSubscribeMethod<Value>;
-  initialValue;
-  isInitialValue;
-  do!: Actions & DefaultActions<Value>;
-
-  constructor(initialValue: Value, storeKeyOrOptions: AtomStoreKey | AtomOptions<Value, Actions> | undefined) {
-    const updateCurrentValue = (value: Value) => (______current_value_____ = value);
-    const getCurrentValue = () => ______current_value_____;
-    const subscribers = new Set<Subscriber<Value>>();
-    const invokeSubscriber = (sub: Subscriber<Value>) => sub(get());
-
-    let isQueueWait = true;
-    let lastIsPreventSave = false as boolean | nil;
-
-    let ______current_value_____ = initialValue;
-    let debounceTimeout: ReturnType<typeof setTimeout> | number | undefined;
-    let save: (val: Value) => void = () => {};
-    let get = () => getCurrentValue();
-    let tools: Tools | null | undefined = null;
-
-    let doFiller = () => {
-      const doActions = makeDoFillerActions<Value, Actions>(initialValue, proxiedSelf, storeKeyOrOptions);
-      doFiller = () => doActions;
-      return doActions;
-    };
-
-    const proxiedSelf = new Proxy(this, {
-      get: (self, prop) => (prop === 'do' ? doFiller() : self[prop as 'do']),
-      set: retFalse,
-    });
-
-    const promiseResolver = () => {
-      isQueueWait = true;
-      if (lastIsPreventSave !== true) save(get());
-      lastIsPreventSave = false;
-
-      try {
-        updateHere.postMessage({ key, value: getCurrentValue() });
-      } catch (e) {}
-    };
-
-    const set: typeof this.set = (value, isPreventSave) => {
-      const nextValue = typeof value === 'function' ? (value as (value: Value) => Value)(get()) : value;
-
-      if (nextValue === get()) return;
-
-      updateCurrentValue(nextValue);
-      lastIsPreventSave = isPreventSave;
-
-      if (isQueueWait) {
-        isQueueWait = false;
-        subscribers.forEach(invokeSubscriber);
-
-        queueMicrotask(promiseResolver);
-      }
-    };
-
-    this.set = (value, isPreventSave) => set(value, isPreventSave);
-    this.get = () => get();
-    this.initialValue = initialValue;
-    this.isInitialValue = () => initialValue === getCurrentValue();
-
-    this.subscribe = sub => {
-      subscribers.add(sub);
-      return () => {
-        subscribers.delete(sub);
-      };
-    };
-
-    this.reset = () => {
-      set(initialValue, true);
-    };
-
-    const deferredTimeOut = (value: Value, isPreventSave: boolean) => {
-      set(value, isPreventSave);
-      debounceTimeout = undefined;
-    };
-
-    this.setDeferred = (value, debounceMs = 500, isPreventSave, isInitInvoke = true) => {
-      if (isInitInvoke && debounceTimeout === undefined) set(value, isPreventSave);
-      clearTimeout(debounceTimeout);
-      debounceTimeout = setTimeout(deferredTimeOut, debounceMs, value, isPreventSave);
-    };
-
-    if (storeKeyOrOptions == null) return proxiedSelf;
-
-    ////////////////////////
-    //////////////////////// storaged value
-    ////////////////////////
-
-    let storeKey = null;
-    let exp = null;
-    let warnOnDuplicateStoreKey = true;
-    let listenStorageChanges = true;
-    let isUnchangable = false;
-    let expTimeout = -1 as never as ReturnType<typeof setTimeout>;
-
-    let unzipValue: AtomOptions<Value, Actions>['unzipValue'] =
-      initialValue instanceof Set ? strValue => new Set(strValue) : val => val;
-
-    let zipValue: AtomOptions<Value, Actions>['zipValue'] =
-      initialValue instanceof Set
-        ? val => {
-            if (val instanceof Set) return Array.from(val);
-
-            console.error(val);
-            throw 'The value is not Set instance';
-          }
-        : val => val;
-
-    if (typeof storeKeyOrOptions === 'string') {
-      storeKey = storeKeyOrOptions;
-    } else if ('storeKey' in storeKeyOrOptions) {
-      warnOnDuplicateStoreKey = storeKeyOrOptions.warnOnDuplicateStoreKey ?? warnOnDuplicateStoreKey;
-      listenStorageChanges = storeKeyOrOptions.listenStorageChanges ?? listenStorageChanges;
-      storeKey = storeKeyOrOptions.storeKey;
-
-      unzipValue = storeKeyOrOptions.unzipValue ?? unzipValue;
-      zipValue = storeKeyOrOptions.zipValue ?? zipValue;
-      isUnchangable = storeKeyOrOptions.unchangable ?? isUnchangable;
-      exp = storeKeyOrOptions.exp ?? exp;
-    } else return proxiedSelf;
-
-    const key = `${prefix}${storeKey}`;
-    const stringifyValue =
-      exp === null || !(exp(proxiedSelf, key in localStorage) instanceof Date)
-        ? (value: Value) => JSON.stringify([zipValue(value)])
-        : (value: Value) => {
-            tools ??= {};
-            tools.exp = exp(proxiedSelf, key in localStorage).getTime();
-
-            if (tools.exp - Date.now() < 24 * 60 * 60 * 1000) {
-              clearTimeout(expTimeout);
-              clearTimeout(initResetTimeouts[key]);
-              expTimeout = setTimeout(() => this.reset(), tools.exp - Date.now());
-            }
-
-            tools.exp = Math.trunc(tools.exp / 1000);
-
-            return JSON.stringify([zipValue(value), tools]);
-          };
-
-    const parseValue = (value: string): Value => {
-      const val = JSON.parse(value);
-      tools = val[1];
-
-      return unzipValue(val[0]);
-    };
-
-    let isInactualValue = true;
-    registeredAtoms[key] = proxiedSelf;
-
-    if (localStorage[`atom/${storeKey}`]) {
-      localStorage[key] ||= `[${localStorage[`atom/${storeKey}`]}]`;
-      delete localStorage[`atom/${storeKey}`];
-    }
-
-    get = () => {
-      get = getCurrentValue;
-
-      if (isInactualValue) {
-        isInactualValue = false;
-        try {
-          updateCurrentValue(key in localStorage ? parseValue(localStorage[key]) : initialValue);
-        } catch (e) {
-          console.warn('Invalid json value', localStorage[key]);
-        }
-      }
-
-      return getCurrentValue();
-    };
-
-    save = value => {
-      if (value === initialValue) {
-        this.reset();
-        return;
-      }
-      localStorage[key] = stringifyValue(value);
-    };
-
-    this.reset = () => {
-      delete localStorage[key];
-      set(initialValue, true);
-    };
-
-    if (warnOnDuplicateStoreKey && update[key] !== undefined) console.warn('Duplicate Atom key', storeKey);
-
-    if (listenStorageChanges) {
-      if (isUnchangable) {
-        let isCantChange = false;
-        let timeout: ReturnType<typeof setTimeout>;
-
-        unchangableAtoms[key] = this as never;
-        update[key] = () => {
-          clearTimeout(timeout);
-          timeout = setTimeout(() => (isCantChange = false), 10);
-
-          if (isCantChange) return;
-          isCantChange = true;
-
-          localStorage[key] = stringifyValue(getCurrentValue());
-        };
-      } else
-        update[key] = event => {
-          if (event.newValue === null) {
-            this.reset();
-            return;
-          }
-
-          try {
-            set(parseValue(event.newValue));
-          } catch (_e) {
-            console.warn('Invalid json value', event.newValue);
-          }
-        };
-    }
-
-    return proxiedSelf;
-  }
-}
-
-let updateHere: BroadcastChannel;
-try {
-  updateHere = new BroadcastChannel('updateHere');
-  updateHere.addEventListener('message', event => {
-    unchangableAtoms[event.data.key]?.set(event.data.value, true);
-  });
-} catch (e) {}
-
-const localStorage = window.localStorage;
-const update: Partial<Record<string, (event: StorageEvent) => void>> = {};
-const unchangableAtoms: Partial<Record<string, Atom<unknown>>> = {};
-const retFalse = (_self: any, prop: string) => {
-  throw `${prop} is readonly property`;
-};
-
-window.addEventListener('storage', event => {
-  if (event.key === null || event.newValue === event.oldValue) return;
-  update[event.key]?.(event);
-});
-
-const setItem = localStorage.setItem.bind(localStorage);
-const removeItem = localStorage.removeItem.bind(localStorage);
-
-localStorage.setItem = (key, value) => {
-  if (unchangableAtoms[key] !== undefined) return;
-  setItem.call(localStorage, key, value);
-};
-localStorage.removeItem = key => {
-  if (unchangableAtoms[key] !== undefined) return;
-  removeItem.call(localStorage, key);
-};
-const expMatcherReg = /"exp":\s*(\d+)/;
-const prefix = `atom\\`;
-const registeredAtoms: Record<string, Atom<any>> = {};
-const initResetTimeouts: Record<string, ReturnType<typeof setTimeout>> = {};
-
-setTimeout(() => {
-  Object.keys(localStorage).forEach(key => {
-    if (!key.startsWith(prefix) || typeof localStorage[key] !== 'string') return;
-    const secTs = +localStorage[key].match(expMatcherReg)?.[1]!;
-
-    if (!secTs || secTs * 1000 - Date.now() > 24 * 60 * 60 * 1000) return;
-
-    const jsonValue = JSON.parse(localStorage[key]);
-
-    if (!Array.isArray(jsonValue) || jsonValue[1] == null || !('exp' in jsonValue[1]) || jsonValue[1].exp !== secTs)
-      return;
-
-    initResetTimeouts[key] = setTimeout(() => {
-      if (registeredAtoms[key]) registeredAtoms[key].reset();
-      else delete localStorage[key];
-    }, secTs * 1000 - Date.now());
-  });
-}, 1000);

package/src/globals.d.ts

@@ -1,52 +0,0 @@
-import { knownStameskaIconNames } from 'shared/values/index/known-icons';
-
-enum NotANumber {
-  nan = 'NaN',
-}
-
-declare global {
-  type num = 0 | 1;
-  type str = '' | '1';
-  type nil = null | undefined;
-  type und = undefined;
-  type TimeOut = ReturnType<typeof setTimeout> | und | number;
-  type intStr = `${'-' | ''}${number}`;
-  type doubleStr = `${'-' | ''}${intStr}.${number}`;
-  type numberStr = `${'-' | ''}${intStr}${`.${number}` | ''}`;
-  type StringBySlash = `${string}/${string}`;
-  type func = (arg: unknown, ...args: unknown[]) => unknown | void;
-
-  type KRecord<Key extends string | number, Value> = (Record<`${Key}`, Value> | Record<Key, Value>) &
-    Record<`${Key}` | Key, Value>;
-  type PRecord<Key extends string | number, Value> = Partial<KRecord<Key, Value>>;
-
-  /** Record with <Required key, Partial key, Value> */
-  type RPRecord<ReqiredKey extends string | number, Key extends string | number, Value> = KRecord<ReqiredKey, Value> &
-    Partial<KRecord<Exclude<Key, ReqiredKey>, Value>>;
-
-  type RKey<Key extends number> = Key | `${Key}`;
-
-  type OmitOwn<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-  type WithRewrites<T, P> = Pick<T, Exclude<keyof T, keyof P>> & Pick<P, keyof P>;
-
-  type NaN = NotANumber;
-  type NaNumber = number | NotANumber;
-  type FalsyValue = false | '' | 0 | nil;
-
-  type PropagationStopperEvent = { stopPropagation(): void };
-  type PropagationStopper = (event: PropagationStopperEvent) => void;
-
-  type DefaultPreventerEvent = { preventDefault(): void };
-  type DefaultPreventer = (event: DefaultPreventerEvent) => void;
-
-  type PreventerAndStopperCallback = (event: DefaultPreventerEvent & PropagationStopperEvent) => void;
-
-  type NonUndefined<T> = T extends undefined ? never : T;
-  type NonNull<T> = T extends null ? never : T;
-  type NonNil<T> = T extends nil ? never : T;
-
-  type Without<T, U> = { [P in Exclude<keyof T, keyof U>]?: never };
-  type XOR<T, U> = (Without<T, U> & U) | (Without<U, T> & T);
-
-  type KnownStameskaIconName = keyof typeof knownStameskaIconNames;
-}

package/src/index.ts

@@ -1,2 +0,0 @@
-export * from './class';
-export * from './lib';

package/src/lib.ts

@@ -1,36 +0,0 @@
-import { useSyncExternalStore } from 'react';
-import {
-  atom as atomType,
-  configureAtomaric as configureAtomaricType,
-  useAtomDo as useAtomDoType,
-  useAtomGet as useAtomGetType,
-  useAtomSetDeferred as useAtomSetDeferredType,
-  useAtomSet as useAtomSetType,
-  useAtom as useAtomType,
-  useAtomValue as useAtomValueType,
-} from '../types';
-import { Atom } from './class';
-
-let useSyncExtStore = (() => {
-  throw 'call configureAtomaric() before all!';
-}) as typeof useSyncExternalStore;
-
-export const configuredOptions: Partial<Parameters<typeof configureAtomaricType>[0]> = {};
-
-export const configureAtomaric: typeof configureAtomaricType = options => {
-  configuredOptions.useSyncExternalStore = useSyncExtStore = options.useSyncExternalStore;
-  configuredOptions.keyPathSeparator = options.keyPathSeparator;
-};
-
-export const useAtomValue: typeof useAtomValueType = atom => {
-  return useSyncExtStore(atom.subscribe, atom.get);
-};
-
-export const useAtomSet: typeof useAtomSetType = atom => atom.set;
-export const useAtomSetDeferred: typeof useAtomSetDeferredType = atom => atom.setDeferred;
-export const useAtomGet: typeof useAtomGetType = atom => atom.get;
-export const useAtomDo: typeof useAtomDoType = atom => atom.do;
-
-export const useAtom: typeof useAtomType = atom => [useAtomValue(atom), useAtomSet(atom)];
-
-export const atom: typeof atomType = (value, storeKeyOrOptions) => new Atom(value, storeKeyOrOptions);

package/src/makeDeepProxyObject.ts

@@ -1,35 +0,0 @@
-export const makeDeepProxyObject = <T extends object>(
-  target: T,
-  handler: ProxyHandler<T> & {
-    onSet: <I extends object>(
-      target: I,
-      path: (string | number)[],
-      setKey: number | string,
-      value: unknown,
-      prevValue: unknown,
-    ) => boolean;
-  },
-) => {
-  const proxer = <I extends object>(target: I, keys: (number | string)[], level: number) =>
-    new Proxy(target, {
-      get: (target, key, reciever) => {
-        const value =
-          level === 0 && handler.get != null ? handler.get(target as never, key, reciever) : target[key as never];
-
-        return typeof value === 'object' && value !== null
-          ? proxer(
-              Array.isArray(value) ? value.slice(0) : { ...value },
-              keys.concat(Array.isArray(target) ? +(key as never) : (key as never)),
-              level + 1,
-            )
-          : value;
-      },
-      set: (target, key, value) => {
-        if (!handler.onSet(target, keys, key as never, value, target[key as never])) return true;
-        target[key as never] = value as never;
-        return true;
-      },
-    });
-
-  return proxer(target, [], 0);
-};

package/src/makeDoFillerActions.ts

@@ -1,225 +0,0 @@
-import { AtomOptions, AtomStoreKey, DefaultActions } from '../types';
-import { Atom } from './class';
-import { configuredOptions } from './lib';
-import { makeDeepProxyObject } from './makeDeepProxyObject';
-
-type nil = null | undefined;
-
-export const makeDoFillerActions = <Value, Actions extends Record<string, Function>>(
-  initialValue: Value,
-  atom: Atom<Value, Actions>,
-  storeKeyOrOptions: AtomStoreKey | AtomOptions<Value, Actions> | undefined,
-) => {
-  let defaultActions: DefaultActions<any> | null = null;
-
-  if (typeof initialValue === 'number') {
-    defaultActions = fillActions<number>(
-      atom as never,
-      atom => ({
-        increment: delta => {
-          atom.set(+atom.get() + (delta ?? 0));
-        },
-      }),
-      initialValue,
-    );
-  } else if (typeof initialValue === 'boolean') {
-    defaultActions = fillActions<boolean>(
-      atom as never,
-      atom => ({
-        toggle: () => {
-          atom.set(!atom.get());
-        },
-      }),
-      initialValue,
-    );
-  } else if (Array.isArray(initialValue)) {
-    defaultActions = fillActions<any[]>(
-      atom as never,
-      atom => ({
-        push: (...values) => {
-          atom.set(atom.get().concat(values));
-        },
-        unshift: (...values) => {
-          atom.set(values.concat(atom.get()));
-        },
-        update: updater => {
-          const prev = atom.get();
-          const newValue = updateValue(prev, updater);
-          if (newValue === prev) return;
-          atom.set(newValue);
-        },
-        filter: filter => {
-          atom.set(atom.get().filter(filter ?? itIt));
-        },
-        add: value => {
-          if (atom.get().includes(value)) return;
-          atom.set(atom.get().concat([value]));
-        },
-        remove: value => {
-          const index = atom.get().indexOf(value);
-          if (index < 0) return;
-          const newArray = atom.get().slice(0);
-          newArray.splice(index, 1);
-          atom.set(newArray);
-        },
-        toggle: (value, isAddInStart) => {
-          const newArray = atom.get().slice();
-          const index = newArray.indexOf(value);
-          if (index < 0) {
-            if (isAddInStart) newArray.unshift(value);
-            else newArray.push(value);
-          } else newArray.splice(index, 1);
-          atom.set(newArray);
-        },
-      }),
-      initialValue,
-    );
-  } else if (initialValue instanceof Set) {
-    defaultActions = fillActions<Set<any>>(
-      atom as never,
-      atom => ({
-        add: value => {
-          atom.set(new Set(atom.get()).add(value));
-        },
-        delete: value => {
-          const newSet = new Set(atom.get());
-          newSet.delete(value);
-          atom.set(newSet);
-        },
-        toggle: value => {
-          const newSet = new Set(atom.get());
-
-          if (newSet.has(value)) newSet.delete(value);
-          else newSet.add(value);
-
-          atom.set(newSet);
-        },
-        clear: () => {
-          atom.set(new Set());
-        },
-      }),
-      initialValue,
-    );
-  } else if (initialValue instanceof Object) {
-    const keyPathSeparator = configuredOptions.keyPathSeparator || '.';
-
-    defaultActions = fillActions<object>(
-      atom as never,
-      atom => ({
-        setPartial: value =>
-          atom.set(prev => ({
-            ...prev,
-            ...(typeof value === 'function' ? value(atom.get()) : value),
-          })),
-        update: updater => {
-          const prev = atom.get();
-          const newValue = updateValue(prev, updater);
-          if (newValue === prev) return;
-          atom.set(newValue);
-        },
-        setDeepPartial: (path: string, value: any, donor, separator = 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 = { ...atom.get() };
-            let lastObject: Record<string, unknown> = newObject;
-            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(undefined) : value;
-
-                if (atom.get()[path as never] !== newValue) atom.do.setPartial({ [path]: newValue });
-                return;
-              }
-
-              lastObject = lastObject[makeKey(lastObject, key)] = (
-                Array.isArray(currentObject) ? [...currentObject] : { ...currentObject }
-              ) as never;
-            }
-
-            const prev = lastObject[lastKey];
-            lastObject[lastKey] = typeof value === 'function' ? value(lastObject[lastKey]) : value;
-
-            if (prev !== lastObject[lastKey]) atom.set(newObject);
-
-            return;
-          }
-
-          const prevValue = atom.get()[path as never];
-          const newValue = typeof value === 'function' ? value(prevValue) : value;
-          if (newValue !== prevValue) atom.do.setPartial({ [path]: newValue });
-        },
-      }),
-      initialValue,
-    );
-  }
-
-  const actions =
-    typeof storeKeyOrOptions === 'object' && storeKeyOrOptions != null && 'do' in storeKeyOrOptions
-      ? storeKeyOrOptions.do(
-          (value, isPreventSave) => atom.set(value, isPreventSave),
-          () => atom.get(),
-          atom,
-          (value, debounceMs, isPreventSave) => atom.setDeferred(value, debounceMs, isPreventSave),
-        )
-      : null;
-
-  const doActions = {};
-
-  if (actions) Object.keys(actions).forEach(key => Object.defineProperty(doActions, key, { get: () => actions[key] }));
-
-  if (defaultActions)
-    Object.keys(defaultActions).forEach(key =>
-      Object.defineProperty(doActions, key, { get: () => defaultActions[key as never] }),
-    );
-
-  return doActions;
-};
-
-const itIt = <It>(it: It) => it;
-const fillActions = <Value, ValAtom extends Atom<Value> = Atom<Value>>(
-  atom: ValAtom,
-  actions: (atom: ValAtom) => DefaultActions<Value>,
-  _value: Value,
-) => actions(atom);
-
-const 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;
-};
-
-const makeKey = (obj: object, key: string) => (Array.isArray(obj) ? `${+key}` : key);

package/src/test.tsx

@@ -1,207 +0,0 @@
-import React, { useEffect, useSyncExternalStore } from 'react';
-import { createRoot } from 'react-dom/client';
-import { atom, configureAtomaric, useAtomDo, useAtomValue } from './lib';
-
-configureAtomaric({ useSyncExternalStore, keyPathSeparator: '.' });
-
-createRoot(document.getElementById('root')!).render(
-  <React.StrictMode>
-    <App />
-  </React.StrictMode>,
-);
-
-const testAtom = atom(new Set<number>(), {
-  storeKey: 'test:set',
-  do: set => ({
-    update12: () => set(prev => new Set(prev).add(12)),
-  }),
-});
-
-const testTextAtom = atom('', {
-  storeKey: 'test:text',
-  unchangable: true,
-  exp: () => new Date(Date.now() + 3 * 1000),
-
-  zipValue: value => ({ value }),
-  unzipValue: val => val.value,
-
-  do: set => ({
-    addText: (text: string) => {
-      set(prev => prev + text);
-    },
-  }),
-});
-
-const array: (number | '')[] = [3, 1, 7, 4, 8, 9, 5];
-const arrayAtom = atom(array, {
-  do: () => ({
-    nothing: () => {},
-  }),
-});
-
-console.info(Object.keys(arrayAtom));
-// arrayAtom.do.filter = {};
-
-console.info(arrayAtom);
-arrayAtom.do.push(0);
-arrayAtom.do.nothing();
-console.info(arrayAtom.get());
-arrayAtom.do.unshift(-1);
-console.info(arrayAtom.get());
-arrayAtom.do.update(arr => arr.sort());
-console.info(arrayAtom.get());
-arrayAtom.do.filter();
-console.info(arrayAtom.get());
-
-atom(0, 'a:a');
-atom(0, { storeKey: 'a:a' });
-atom(0, { storeKey: 'a:a', warnOnDuplicateStoreKey: false });
-
-(function testDeepPartialChanges() {
-  const b = { c: [{ d: 8, e: 'e', f: 'F' }] };
-  const a = { f: { g: '' }, b };
-  const deepTest = atom({ a, b });
-
-  deepTest.do.setDeepPartial('b.c.0.d', 123, { b: { c: [{}] } });
-  deepTest.do.setDeepPartial('b+c+8+e', 'EE', null, '+');
-
-  console.info(deepTest.get(), deepTest.get().a.f === a.f, deepTest.get().b.c === b.c);
-})();
-
-(function testDeepPartialChanges() {
-  const enum Id {
-    def = 0,
-  }
-
-  const deepTest = atom(
-    {} as Record<
-      Id,
-      {
-        in: { inin: [{ ininin: number }] }[];
-        out: { some: { req: 0 } };
-        else: { if: {} };
-      }
-    >,
-  );
-
-  deepTest.do.setDeepPartial(`${Id.def}.in.${9}.inin.0`, { ininin: 9 }, { [Id.def]: { in: [{ inin: [] }] } });
-  console.info('Id.def', deepTest.get());
-
-  deepTest.do.setDeepPartial(`${Id.def}+in+ 4 +inin+0+ininin`, () => 7, { [Id.def]: { in: [{ inin: [{}] }] } }, '+');
-  console.info('Id.def', deepTest.get());
-
-  // will throw
-  // console.error(deepTest.get()[Id.def]?.out.some.req);
-})();
-
-(function testDeepPartialSetWithDonor() {
-  const a: {
-    val: {
-      b?: { c?: { f: { g?: { e: string } }[] }[] };
-      f: { l: number; g?: number };
-    };
-  } = { val: { f: { l: 9 } } };
-
-  const deepTest = atom(a);
-
-  deepTest.do.setDeepPartial('val.b.c.4.f', [{ g: { e: '^' } }], { val: { b: { c: [{}] } } });
-  deepTest.do.setDeepPartial('val.b.c.4.f.5.g', { e: '!!@' }, { val: { b: { c: [{ f: [{}] }] } } });
-  deepTest.do.setDeepPartial('val.b.c.4.f.2', { g: { e: '2' } }, { val: { b: { c: [{ f: [] }] } } });
-  deepTest.do.setDeepPartial('val.b.c.4.f.5.g.e', 'FIVE', { val: { b: { c: [{ f: [{ g: {} }] }] } } });
-  deepTest.do.setDeepPartial('val.f.l', 123, { val: { f: {} } });
-
-  deepTest.do.setDeepPartial('val***f***g', 777, { val: { f: {} } }, '***');
-
-  console.info(deepTest.get());
-})();
-
-(function testUpdate() {
-  const a: {
-    val: {
-      b: { c: { f: { g: { e: string } }[] }[] };
-    };
-    f: { l: { v: { r: number } }; g?: number };
-    num: number;
-  } = {
-    val: { b: { c: [{ f: [{ g: { e: '1' } }] }] } },
-    f: { l: { v: { r: 8 } } },
-    num: 8,
-  };
-
-  const updateTest = atom(a);
-
-  const prevF = a.val.b.c[0].f;
-  const prevV = a.f.l.v;
-
-  console.info(updateTest.get() === a);
-
-  updateTest.do.update(a => {
-    a.val.b.c[0].f[0].g.e = '2';
-    // a.num = 0;
-  });
-  console.info(
-    updateTest.get() === a,
-    prevF === a.val.b.c[0].f,
-    prevV === updateTest.get().f.l.v,
-    updateTest.get().val.b.c[0].f === a.val.b.c[0].f,
-    a.val.b.c[0].f[0].g,
-    updateTest.get().val.b.c[0].f[0].g,
-  );
-})();
-
-const numAtom = atom(0);
-
-const inputValueAtom = atom('');
-
-function App() {
-  const test = useAtomValue(testAtom);
-  const testText = useAtomValue(testTextAtom);
-  const testDo = useAtomDo(testAtom);
-  const value = useAtomValue(inputValueAtom);
-  console.log({ num: useAtomValue(numAtom) });
-
-  console.info(test);
-
-  useEffect(() => {
-    const onClick = () => {
-      testDo.add(Date.now());
-      testDo.update12();
-      testTextAtom.do.addText('1');
-
-      numAtom.set(num => {
-        console.log(num);
-        return 1;
-      });
-      numAtom.set(3);
-      numAtom.set(num => {
-        console.log(num);
-        return 4;
-      });
-      numAtom.set(num => {
-        console.log(num);
-        return 5;
-      });
-      numAtom.set(6);
-      numAtom.set(num => {
-        console.log(num);
-        return 7;
-      });
-    };
-
-    window.addEventListener('click', onClick);
-    return () => window.removeEventListener('click', onClick);
-  }, []);
-
-  return (
-    <>
-      {testText}
-      <input
-        value={value}
-        onChange={event => {
-          inputValueAtom.set(event.currentTarget.value + '*');
-          inputValueAtom.set(event.currentTarget.value);
-        }}
-      />
-    </>
-  );
-}