atom.io 0.27.4 → 0.28.0

package/react/dist/index.js

@@ -12,13 +12,13 @@ function parseStateOverloads(store, ...rest) {
     const family = rest[0];
     const key = rest[1];
     if (store.config.lifespan === `immortal`) {
-      const maybeToken = seekInStore(family, key, store);
+      const maybeToken = seekInStore(store, family, key);
       if (!maybeToken) {
         throw new NotFoundError(family, key, store);
       }
       token = maybeToken;
     } else {
-      token = findInStore(family, key, store);
+      token = findInStore(store, family, key);
     }
   } else {
     token = rest[0];
@@ -33,7 +33,7 @@ function useI(...params) {
   const setter = React5.useRef(null);
   if (setter.current === null) {
     setter.current = (next) => {
-      setIntoStore(token, next, store);
+      setIntoStore(store, token, next);
     };
   }
   return setter.current;
@@ -44,16 +44,16 @@ function useO(...params) {
   const id = React5.useId();
   return React5.useSyncExternalStore(
     (dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
-    () => getFromStore(token, store),
-    () => getFromStore(token, store)
+    () => getFromStore(store, token),
+    () => getFromStore(store, token)
   );
 }
 
 // react/src/use-json.ts
 function useJSON(token, key) {
   const store = React5.useContext(StoreContext);
-  const stateToken = token.type === `mutable_atom_family` ? findInStore(token, key, store) : token;
-  const jsonToken = getJsonToken(stateToken, store);
+  const stateToken = token.type === `mutable_atom_family` ? findInStore(store, token, key) : token;
+  const jsonToken = getJsonToken(store, stateToken);
   return useO(jsonToken);
 }
 function useTL(token) {

package/react/src/parse-state-overloads.ts

@@ -28,13 +28,13 @@ export function parseStateOverloads<T, K extends Canonical>(
 		const key = rest[1]
 
 		if (store.config.lifespan === `immortal`) {
-			const maybeToken = seekInStore(family, key, store)
+			const maybeToken = seekInStore(store, family, key)
 			if (!maybeToken) {
 				throw new NotFoundError(family, key, store)
 			}
 			token = maybeToken
 		} else {
-			token = findInStore(family, key, store)
+			token = findInStore(store, family, key)
 		}
 	} else {
 		token = rest[0]

package/react/src/use-i.ts

@@ -25,7 +25,7 @@ export function useI<T, K extends Canonical>(
 	> = React.useRef(null)
 	if (setter.current === null) {
 		setter.current = (next) => {
-			setIntoStore(token, next, store)
+			setIntoStore(store, token, next)
 		}
 	}
 	return setter.current

package/react/src/use-json.ts

@@ -31,8 +31,8 @@ export function useJSON<
 	const store = React.useContext(StoreContext)
 	const stateToken: ReadableToken<any> =
 		token.type === `mutable_atom_family`
-			? findInStore(token, key as Key, store)
+			? findInStore(store, token, key as Key)
 			: token
-	const jsonToken = getJsonToken(stateToken, store)
+	const jsonToken = getJsonToken(store, stateToken)
 	return useO(jsonToken)
 }

package/react/src/use-o.ts

@@ -21,7 +21,7 @@ export function useO<T, K extends Canonical>(
 	const id = React.useId()
 	return React.useSyncExternalStore<T>(
 		(dispatch) => subscribeToState(token, dispatch, `use-o:${id}`, store),
-		() => getFromStore(token, store),
-		() => getFromStore(token, store),
+		() => getFromStore(store, token),
+		() => getFromStore(store, token),
 	)
 }

package/react-devtools/dist/index.d.ts

@@ -1,93 +1,3 @@
-import * as Internal from 'atom.io/internal';
-import * as atom_io from 'atom.io';
-import { AtomToken, ReadableToken, SelectorToken } from 'atom.io';
-
-type ClassSignature = abstract new (...args: any) => any;
-
-type Refinement<A, B extends A> = (a: A) => a is B;
-
-type RefinementStrategy = ClassSignature | Refinement<unknown, any>;
-type Supported<Refine extends RefinementStrategy> = Refine extends Refinement<unknown, infer T> ? T : Refine extends ClassSignature ? InstanceType<Refine> : never;
-type RefinementSupport = Record<string, RefinementStrategy>;
-declare class Refinery<SupportedTypes extends RefinementSupport> {
-    supported: SupportedTypes;
-    constructor(supported: SupportedTypes);
-    refine(input: unknown): {
-        [K in keyof SupportedTypes]: {
-            type: K;
-            data: Supported<SupportedTypes[K]>;
-        };
-    }[keyof SupportedTypes] | null;
-}
-
-type PlainObject = Record<keyof any, unknown>;
-
-type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
-
-type FamilyNode<Token extends ReadableToken<unknown>> = {
-    key: string;
-    familyMembers: Map<string, Token>;
-};
-type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
-
-type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
-
-type Delta = {
-    summary: string;
-    added?: [path: string, addedStringifiedValue: string][];
-    removed?: [path: string, removedStringifiedValue: string][];
-    changed?: [path: string, delta: Delta][];
-};
-type Diff<T> = (a: T, b: T) => Delta;
-type DiffTree<T> = (a: T, b: T, recurse: Differ<any, any>[`diff`]) => Delta;
-declare class Differ<Leaf extends Record<string, any>, Tree extends Record<string, any>> {
-    leafRefinery: Refinery<Leaf>;
-    treeRefinery: Refinery<Tree>;
-    leafDiffers: {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    };
-    treeDiffers: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    };
-    constructor(leafRefinery: Refinery<Leaf>, treeRefinery: Refinery<Tree>, diffFunctions: {
-        [KT in keyof Tree]: DiffTree<Supported<Tree[KT]>>;
-    } & {
-        [KL in keyof Leaf]: Diff<Supported<Leaf[KL]>>;
-    });
-    diff(a: unknown, b: unknown): Delta;
-}
-
 declare const AtomIODevtools: () => JSX.Element;
 
-declare const atomIndex: atom_io.ReadonlySelectorToken<AtomTokenIndex>;
-declare const selectorIndex: atom_io.ReadonlySelectorToken<SelectorTokenIndex>;
-declare const transactionIndex: atom_io.ReadonlySelectorToken<atom_io.TransactionToken<Internal.Func>[]>;
-declare const findTransactionLogState: atom_io.ReadonlySelectorFamilyToken<atom_io.TransactionUpdate<Internal.Func>[], string>;
-declare const timelineIndex: atom_io.ReadonlySelectorToken<atom_io.TimelineToken<any>[]>;
-declare const findTimelineState: atom_io.ReadonlySelectorFamilyToken<Internal.Timeline<any>, string>;
-declare const devtoolsAreOpenState: atom_io.RegularAtomToken<boolean>;
-type DevtoolsView = `atoms` | `selectors` | `timelines` | `transactions`;
-declare const devtoolsViewSelectionState: atom_io.RegularAtomToken<DevtoolsView>;
-declare const devtoolsViewOptionsState: atom_io.RegularAtomToken<DevtoolsView[]>;
-declare const findViewIsOpenState: atom_io.RegularAtomFamilyToken<boolean, string>;
-declare const primitiveRefinery: Refinery<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}>;
-declare const jsonTreeRefinery: Refinery<{
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-declare const prettyJson: Differ<{
-    number: (input: unknown) => input is number;
-    string: (input: unknown) => input is string;
-    boolean: (input: unknown) => input is boolean;
-    null: (input: unknown) => input is null;
-}, {
-    object: (input: unknown) => input is PlainObject;
-    array: (input: unknown) => input is unknown[];
-}>;
-
-export { AtomIODevtools, atomIndex, devtoolsAreOpenState, devtoolsViewOptionsState, devtoolsViewSelectionState, findTimelineState, findTransactionLogState, findViewIsOpenState, jsonTreeRefinery, prettyJson, primitiveRefinery, selectorIndex, timelineIndex, transactionIndex };
+export { AtomIODevtools };