atom.io 0.27.4 → 0.28.0

package/internal/src/store/counterfeit.ts

@@ -0,0 +1,109 @@
+import type {
+	AtomFamilyToken,
+	AtomToken,
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	SelectorFamilyToken,
+	SelectorToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Canonical, Json } from "atom.io/json"
+import { stringifyJson } from "atom.io/json"
+
+import type { Transceiver } from "../mutable"
+
+export const FAMILY_MEMBER_TOKEN_TYPES = {
+	atom_family: `atom`,
+	mutable_atom_family: `mutable_atom`,
+	selector_family: `selector`,
+	readonly_selector_family: `readonly_selector`,
+	molecule_family: `molecule`,
+} as const
+
+export function counterfeit<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Canonical,
+	Key extends K,
+>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+): RegularAtomToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: AtomFamilyToken<T, K>,
+	key: Key,
+): AtomToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+): WritableSelectorToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+): ReadonlySelectorToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: SelectorFamilyToken<T, K>,
+	key: Key,
+): SelectorToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+): WritableToken<T>
+
+export function counterfeit<T, K extends Canonical, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+): ReadableToken<T>
+
+export function counterfeit<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+): MoleculeKey<M>
+
+export function counterfeit(
+	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	key: Canonical,
+): MoleculeToken<any> | ReadableToken<any> {
+	const subKey = stringifyJson(key)
+	const fullKey = `${token.key}(${subKey})`
+	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]
+	const stateToken = {
+		key: fullKey,
+		type,
+	} satisfies MoleculeToken<any> | ReadableToken<any>
+	if (type === `molecule`) {
+		Object.assign(stateToken, {
+			key,
+			family: token,
+		})
+	} else {
+		Object.assign(stateToken, {
+			family: {
+				key: token.key,
+				subKey,
+			},
+		})
+	}
+	Object.assign(stateToken, { counterfeit: true })
+	return stateToken
+}

package/internal/src/store/deposit.ts

@@ -1,31 +1,47 @@
 import type {
+	AtomFamilyToken,
 	AtomToken,
 	MoleculeConstructor,
 	MoleculeFamily,
 	MoleculeFamilyToken,
 	MoleculeToken,
+	MutableAtomFamilyToken,
 	MutableAtomToken,
+	ReadableFamilyToken,
 	ReadableToken,
+	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
 	RegularAtomToken,
+	SelectorFamilyToken,
 	SelectorToken,
 	TransactionToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
 	WritableSelectorToken,
 	WritableToken,
 } from "atom.io"
-import type { Canonical } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type {
 	Atom,
+	AtomFamily,
 	Func,
 	Molecule,
 	MutableAtom,
+	MutableAtomFamily,
+	ReadableFamily,
 	ReadableState,
 	ReadonlySelector,
+	ReadonlySelectorFamily,
 	RegularAtom,
+	RegularAtomFamily,
 	Selector,
+	SelectorFamily,
 	Transceiver,
+	WritableFamily,
 	WritableSelector,
+	WritableSelectorFamily,
 	WritableState,
 } from ".."
 import type { Transaction } from "../transaction"
@@ -39,37 +55,75 @@ export function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>
 export function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>
 export function deposit<T>(state: Selector<T>): SelectorToken<T>
 export function deposit<T>(state: WritableState<T>): WritableToken<T>
+export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+
+export function deposit<T, K extends Canonical>(
+	state: RegularAtomFamily<T, K>,
+): RegularAtomFamilyToken<T, K>
+export function deposit<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Canonical,
+>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>
+export function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableSelectorFamily<T, any>,
+): WritableSelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadonlySelectorFamily<T, any>,
+): ReadonlySelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: SelectorFamily<T, any>,
+): SelectorFamilyToken<T, any>
+export function deposit<T>(
+	state: WritableFamily<T, any>,
+): WritableFamilyToken<T, any>
+export function deposit<T>(
+	state: ReadableFamily<T, any>,
+): ReadableFamilyToken<T, any>
+
 export function deposit<M extends MoleculeConstructor>(
 	state: MoleculeFamily<M>,
 ): MoleculeFamilyToken<M>
 export function deposit<M extends MoleculeConstructor>(
 	state: Molecule<M>,
 ): MoleculeToken<M>
+
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
-export function deposit<T>(state: ReadableState<T>): ReadableToken<T>
+
 export function deposit(
 	state: Molecule<any> | ReadableState<any>,
 ): MoleculeToken<any> | ReadableToken<any>
 
-export function deposit<T>(
+export function deposit(
+	state:
+		| Molecule<any>
+		| MoleculeFamily<any>
+		| ReadableFamily<any, any>
+		| ReadableState<any>
+		| Transaction<Func>,
+):
+	| MoleculeFamilyToken<any>
+	| MoleculeToken<any>
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TransactionToken<Func>
+
+export function deposit(
 	state:
 		| Molecule<any>
 		| MoleculeFamily<any>
-		| ReadableState<T>
-		| ReadonlySelector<T>
-		| RegularAtom<T>
-		| Transaction<T extends Func ? T : never>
-		| WritableSelector<T>
-		| (T extends Transceiver<any> ? MutableAtom<T, any> : never),
+		| ReadableFamily<any, any>
+		| ReadableState<any>
+		| Transaction<Func>,
 ):
 	| MoleculeFamilyToken<any>
 	| MoleculeToken<any>
-	| MutableAtomToken<T extends Transceiver<any> ? T : never, any>
-	| RegularAtomToken<T>
-	| SelectorToken<T>
-	| TransactionToken<T extends Func ? T : never> {
+	| ReadableFamilyToken<any, any>
+	| ReadableToken<any>
+	| TransactionToken<Func> {
 	const token = {
 		key: state.key,
 		type: state.type,

package/internal/src/store/index.ts

@@ -1,3 +1,4 @@
+export * from "./counterfeit"
 export * from "./deposit"
 export * from "./store"
 export * from "./withdraw"

package/internal/src/store/store.ts

@@ -36,6 +36,7 @@ import type {
 	TransactionProgress,
 } from "../transaction"
 import { isRootStore } from "../transaction"
+import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {
 	public parent: Store | null = null
@@ -94,6 +95,8 @@ export class Store implements Lineage {
 		cardinality: `1:n`,
 	})
 
+	public disposalTraces = new CircularBuffer<{ key: string; trace: string }>(100)
+
 	public molecules = new Map<string, Molecule<any>>()
 	public moleculeFamilies = new Map<string, MoleculeFamily<any>>()
 	public moleculeInProgress: string | null = null
@@ -176,7 +179,7 @@ export class Store implements Lineage {
 				}
 				atom.install(this)
 				if (atom.type === `mutable_atom`) {
-					const originalJsonToken = getJsonToken(atom, store)
+					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
 					mutableHelpers.add(originalJsonToken.key)
 					mutableHelpers.add(originalUpdateToken.key)

package/internal/src/store/withdraw.ts

@@ -155,19 +155,24 @@ export function withdraw<T>(
 	token: TimelineToken<T>,
 	store: Store,
 ): Timeline<T extends TimelineManageable ? T : never>
-export function withdraw<T>(
+
+export function withdraw<T, M extends MoleculeConstructor>(
+	token: MoleculeToken<M> | ReadableToken<T>,
+	store: Store,
+): Molecule<M> | ReadableState<T>
+
+export function withdraw(
 	token:
 		| MoleculeFamilyToken<any>
 		| MoleculeToken<any>
-		| RegularAtomFamilyToken<T, any>
-		| RegularAtomToken<T>
-		| SelectorFamilyToken<T, any>
-		| SelectorToken<T>
-		| TimelineToken<T>
-		| TransactionToken<T extends Func ? T : never>
-		| (T extends Transceiver<any>
-				? MutableAtomFamilyToken<T, any, any> | MutableAtomToken<T, any>
-				: never),
+		| MutableAtomFamilyToken<any, any, any>
+		| MutableAtomToken<any, any>
+		| RegularAtomFamilyToken<any, any>
+		| RegularAtomToken<any>
+		| SelectorFamilyToken<any, any>
+		| SelectorToken<any>
+		| TimelineToken<any>
+		| TransactionToken<any>,
 	store: Store,
 ): Withdrawable {
 	let withdrawn: Withdrawable | undefined

package/internal/src/subscribe/index.ts

@@ -1,3 +1,5 @@
+export * from "./recall-state"
+export * from "./subscribe-in-store"
 export * from "./subscribe-to-root-atoms"
 export * from "./subscribe-to-state"
 export * from "./subscribe-to-timeline"

package/internal/src/subscribe/subscribe-in-store.ts

@@ -0,0 +1,62 @@
+import type {
+	ReadableToken,
+	TimelineManageable,
+	TimelineToken,
+	TimelineUpdate,
+	TransactionToken,
+	TransactionUpdateHandler,
+	UpdateHandler,
+} from "atom.io"
+import type { Func, Store } from "atom.io/internal"
+import {
+	arbitrary,
+	subscribeToState,
+	subscribeToTimeline,
+	subscribeToTransaction,
+} from "atom.io/internal"
+
+export function subscribeInStore<T>(
+	store: Store,
+	token: ReadableToken<T>,
+	handleUpdate: UpdateHandler<T>,
+	key?: string,
+): () => void
+export function subscribeInStore<F extends Func>(
+	store: Store,
+	token: TransactionToken<F>,
+	handleUpdate: TransactionUpdateHandler<F>,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: TimelineToken<M>,
+	handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void,
+	key?: string,
+): () => void
+export function subscribeInStore<M extends TimelineManageable>(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>,
+	handleUpdate:
+		| TransactionUpdateHandler<any>
+		| UpdateHandler<any>
+		| ((update: TimelineUpdate<M> | `redo` | `undo`) => void),
+	key?: string,
+): () => void
+export function subscribeInStore(
+	store: Store,
+	token: ReadableToken<any> | TimelineToken<any> | TransactionToken<any>,
+	handleUpdate: (update: any) => void,
+	key: string = arbitrary(),
+): () => void {
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `readonly_selector`:
+		case `selector`:
+			return subscribeToState(token, handleUpdate, key, store)
+		case `transaction`:
+			return subscribeToTransaction(token, handleUpdate, key, store)
+		case `timeline`:
+			return subscribeToTimeline(token, handleUpdate, key, store)
+	}
+}

package/internal/src/timeline/time-travel.ts

@@ -12,9 +12,9 @@ import {
 import type { Store } from "../store"
 
 export const timeTravel = (
+	store: Store,
 	action: `redo` | `undo`,
 	token: TimelineToken<any>,
-	store: Store,
 ): void => {
 	store.logger.info(
 		action === `redo` ? `⏩` : `⏪`,

package/internal/src/transaction/build-transaction.ts

@@ -49,6 +49,7 @@ export const buildTransaction = (
 		selectors: new LazyMap(parent.selectors),
 		valueMap: new LazyMap(parent.valueMap),
 		defaults: parent.defaults,
+		disposalTraces: store.disposalTraces.copy(),
 		molecules: new LazyMap(parent.molecules),
 		moleculeFamilies: new LazyMap(parent.moleculeFamilies),
 		moleculeInProgress: parent.moleculeInProgress,
@@ -68,19 +69,19 @@ export const buildTransaction = (
 		},
 		toolkit: {
 			get: ((...ps: Parameters<typeof getState>) =>
-				getFromStore(...ps, child)) as typeof getState,
+				getFromStore(child, ...ps)) as typeof getState,
 			set: ((...ps: Parameters<typeof setState>) => {
-				setIntoStore(...ps, child)
+				setIntoStore(child, ...ps)
 			}) as typeof setState,
 			run: (token, identifier = arbitrary()) =>
 				actUponStore(token, identifier, child),
-			find: ((token, k) => findInStore(token, k, child)) as typeof findState,
-			seek: ((token, k) => seekInStore(token, k, child)) as typeof seekState,
-			json: (token) => getJsonToken(token, child),
+			find: ((token, k) => findInStore(child, token, k)) as typeof findState,
+			seek: ((token, k) => seekInStore(child, token, k)) as typeof seekState,
+			json: (token) => getJsonToken(child, token),
 			make: (context, family, k, ...args) =>
 				makeMoleculeInStore(child, context, family, k, ...args),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
-				disposeFromStore(...ps, child)
+				disposeFromStore(child, ...ps)
 			}) as typeof disposeState,
 			env: () => getEnvironmentData(child),
 		},

package/introspection/dist/index.d.ts

@@ -1,6 +1,7 @@
 import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
-import { Func, Timeline } from 'atom.io/internal';
+import { Func, Timeline, Flat } from 'atom.io/internal';
+import { Json } from 'atom.io/json';
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
@@ -10,9 +11,10 @@ declare const attachIntrospectionStates: (store?: Internal.Store) => {
     atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
     selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
     transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
-    findTransactionLogState: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
+    transactionLogSelectors: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
     timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>;
-    findTimelineState: ReadonlySelectorFamilyToken<Timeline<any>, string>;
+    timelineSelectors: ReadonlySelectorFamilyToken<Timeline<any>, string>;
+    typeSelectors: ReadonlySelectorFamilyToken<string, string>;
 };
 
 type ListResourcesParam = {
@@ -52,10 +54,88 @@ declare class Auditor {
     [Symbol.dispose](): void;
 }
 
+type Refinement<A, B extends A> = (a: A) => a is B;
+type ClassSignature = abstract new (...args: any) => any;
+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<T>(input: T): Flat<{
+        [K in keyof SupportedTypes]: T extends Supported<SupportedTypes[K]> ? {
+            type: K;
+            data: Supported<SupportedTypes[K]>;
+        } : Supported<SupportedTypes[K]> extends T ? {
+            type: K;
+            data: Supported<SupportedTypes[K]>;
+        } : never;
+    }>[keyof SupportedTypes] | (T extends Supported<SupportedTypes[keyof SupportedTypes]> ? never : null);
+}
+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 Json.Tree.Object;
+    array: (input: unknown) => input is Json.Tree.Array;
+}>;
+declare const jsonRefinery: Refinery<{
+    object: (input: unknown) => input is Json.Tree.Object;
+    array: (input: unknown) => input is Json.Tree.Array;
+    number: (input: unknown) => input is number;
+    string: (input: unknown) => input is string;
+    boolean: (input: unknown) => input is boolean;
+    null: (input: unknown) => input is null;
+}>;
+type JsonType = keyof typeof jsonRefinery.supported;
+declare const discoverType: (input: unknown) => JsonType | `Map` | `Set` | `undefined` | (string & {});
+
+declare function diffNumber(a: number, b: number): Delta;
+declare function diffString(a: string, b: string): Delta;
+declare function diffBoolean(a: boolean, b: boolean): Delta;
+declare function diffObject(a: Json.Tree.Object, b: Json.Tree.Object, recurse: Diff<unknown>): Delta;
+declare function diffArray(a: Json.Tree.Array, b: Json.Tree.Array, recurse: Diff<unknown>): Delta;
+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 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 Json.Tree.Object;
+    array: (input: unknown) => input is Json.Tree.Array;
+}>;
+
 type FamilyNode<Token extends ReadableToken<unknown>> = {
     key: string;
     familyMembers: Map<string, Token>;
 };
 type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
 
-export { Auditor, type FamilyNode, type ListResourcesParam, type WritableTokenIndex, attachIntrospectionStates };
+export { Auditor, type ClassSignature, Differ, type FamilyNode, type JsonType, type ListResourcesParam, type Refinement, type RefinementStrategy, type RefinementSupport, Refinery, type Supported, type WritableTokenIndex, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery };