atomaric 0.0.45 → 0.0.60

package/src/test.tsx

@@ -0,0 +1,207 @@
+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);
+        }}
+      />
+    </>
+  );
+}

package/types/index.d.ts

@@ -3,6 +3,12 @@ import { Path, PathValue, PathValueDonor } from './paths';
 
 export interface Register {}
 
+export type ObjectActionsSetDeepPartial = Register extends {
+  keyPathSeparator: infer Separator extends string;
+}
+  ? Separator
+  : '.';
+
 type Sunscriber<Value> = (value: Value) => void;
 
 export type AtomStoreKey = `${string}${string}:${string}${string}`;
@@ -78,12 +84,6 @@ export type ObjectActions<Value> = UpdateAction<Value> & {
   ) => void;
 };
 
-export type ObjectActionsSetDeepPartial = Register extends {
-  keyPathSeparator: infer Separator extends string;
-}
-  ? Separator
-  : '.';
-
 export type BooleanActions = {
   /** toggle current value between true/false */
   toggle: () => void;

package/types/paths.ts

@@ -85,9 +85,9 @@ export type PathValueDonor<
         ? Required<Record<Key, PathValueDonor<Value[Key], Sep, KeyRest>>>
         : never
       : Value extends ReadonlyArray<infer V>
-      ? [PathValueDonor<V, Sep, KeyRest & Path<V, Sep>> | V]
+      ? [PathValueDonor<V, Sep, KeyRest & Path<V, Sep>>]
       : Value extends Partial<Record<infer K, infer V>> | Record<infer K, infer V>
-      ? Record<K, PathValueDonor<V, Sep, KeyRest & Path<V, Sep>>> | Value
+      ? Record<K, PathValueDonor<V, Sep, KeyRest & Path<V, Sep>>>
       : never
     : FullPath extends keyof Value
     ? FullPath extends `${string}${Sep}${string}${string}`
@@ -100,7 +100,7 @@ export type PathValueDonor<
       ? [V]
       : []
     : Value extends Partial<Record<infer K, infer V>> | Record<infer K, infer V>
-    ? Record<K, V> | Value
+    ? Record<K, V>
     : never
   : never;