atom.io 0.21.1 → 0.23.0

package/src/timeline.ts

@@ -1,7 +1,12 @@
+import type { MoleculeFamilyToken } from "atom.io/immortal"
 import type {
 	Timeline,
 	TimelineAtomUpdate,
+	TimelineMoleculeCreation,
+	TimelineMoleculeDisposal,
 	TimelineSelectorUpdate,
+	TimelineStateCreation,
+	TimelineStateDisposal,
 	TimelineTransactionUpdate,
 } from "atom.io/internal"
 import { createTimeline, IMPLICIT, timeTravel } from "atom.io/internal"
@@ -9,6 +14,14 @@ import { createTimeline, IMPLICIT, timeTravel } from "atom.io/internal"
 import type { AtomFamilyToken, AtomToken } from "."
 
 export type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>
+export type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<
+	any,
+	any
+>
+	? AtomToken<any>
+	: M extends AtomToken<any>
+		? M
+		: never
 
 export type TimelineToken<M> = {
 	key: string
@@ -18,7 +31,7 @@ export type TimelineToken<M> = {
 
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 	key: string
-	atoms: ManagedAtom[]
+	scope: (ManagedAtom | MoleculeFamilyToken<any, any, any>)[]
 	shouldCapture?: (
 		update: TimelineUpdate<ManagedAtom>,
 		timeline: Timeline<TimelineManageable>,
@@ -27,7 +40,11 @@ export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 
 export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 	| TimelineAtomUpdate<ManagedAtom>
+	| TimelineMoleculeCreation<any>
+	| TimelineMoleculeDisposal<any>
 	| TimelineSelectorUpdate<ManagedAtom>
+	| TimelineStateCreation<AtomOnly<ManagedAtom>>
+	| TimelineStateDisposal<AtomOnly<ManagedAtom>>
 	| TimelineTransactionUpdate
 
 export const timeline = <ManagedAtom extends TimelineManageable>(

package/src/transaction.ts

@@ -1,16 +1,28 @@
-import type { EnvironmentData } from "atom.io/internal"
+import type { findState } from "atom.io/ephemeral"
+import type {
+	makeMolecule,
+	MoleculeFamilyToken,
+	MoleculeToken,
+	seekState,
+} from "atom.io/immortal"
+import type { EnvironmentData, Transceiver } from "atom.io/internal"
 import {
 	actUponStore,
 	arbitrary,
 	createTransaction,
 	IMPLICIT,
 } from "atom.io/internal"
+import type { Json } from "atom.io/json"
 
 import type {
-	findState,
+	disposeState,
 	Func,
 	KeyedStateUpdate,
+	MutableAtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
+	TokenType,
+	WritableSelectorToken,
 	WritableToken,
 } from "."
 
@@ -20,11 +32,41 @@ export type TransactionToken<F extends Func> = {
 	__F?: F
 }
 
+export type StateCreation<Token extends ReadableToken<any>> = {
+	type: `state_creation`
+	token: Token
+}
+export type StateDisposal<Token extends ReadableToken<any>> = {
+	type: `state_disposal`
+	token: Token
+	value?: TokenType<Token>
+}
+
+export type MoleculeCreation<Key extends Json.Serializable> = {
+	type: `molecule_creation`
+	token: MoleculeToken<Key, any, any>
+	family: MoleculeFamilyToken<Key, any, any>
+	context: MoleculeToken<any, any, any>[]
+	params: any[]
+}
+export type MoleculeDisposal<Key extends Json.Serializable> = {
+	type: `molecule_disposal`
+	token: MoleculeToken<Key, any, any>
+	family: MoleculeFamilyToken<any, any, any>
+	context: MoleculeToken<any, any, any>[]
+	familyKeys: string[]
+}
+
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
+	| MoleculeCreation<any>
+	| MoleculeDisposal<any>
+	| StateCreation<ReadableToken<unknown>>
+	| StateDisposal<ReadableToken<unknown>>
 	| TransactionUpdate<Func>
 
 export type TransactionUpdate<F extends Func> = {
+	type: `transaction_update`
 	key: string
 	id: string
 	epoch: number
@@ -34,12 +76,16 @@ export type TransactionUpdate<F extends Func> = {
 }
 
 export type Transactors = Readonly<{
-	get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S
+	get: <S>(state: ReadableToken<S>) => S
 	set: <S, New extends S>(
 		state: WritableToken<S>,
 		newValue: New | ((oldValue: S) => New),
 	) => void
 	find: typeof findState
+	seek: typeof seekState
+	json: <T extends Transceiver<any>, J extends Json.Serializable>(
+		state: MutableAtomToken<T, J>,
+	) => WritableSelectorToken<J>
 }>
 export type TransactorsWithRunAndEnv = Readonly<{
 	get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S
@@ -48,10 +94,19 @@ export type TransactorsWithRunAndEnv = Readonly<{
 		newValue: New | ((oldValue: S) => New),
 	) => void
 	find: typeof findState
+	seek: typeof seekState
+	json: <T extends Transceiver<any>, J extends Json.Serializable>(
+		state: MutableAtomToken<T, J>,
+	) => WritableSelectorToken<J>
+	make: typeof makeMolecule
+	dispose: typeof disposeState
 	run: typeof runTransaction
 	env: () => EnvironmentData
 }>
-export type ReadonlyTransactors = Pick<Transactors, `find` | `get`>
+export type ReadonlyTransactors = Pick<
+	Transactors,
+	`find` | `get` | `json` | `seek`
+>
 
 export type Read<F extends Func> = (
 	transactors: ReadonlyTransactors,

package/dist/chunk-BF4MVQF6.js

@@ -1,44 +0,0 @@
-// ../anvl/src/json/json-interface.ts
-var stringSetJsonInterface = {
-  toJson: (stringSet) => Array.from(stringSet),
-  fromJson: (json) => new Set(json)
-};
-
-// ../anvl/src/json/index.ts
-var parseJson = (str) => JSON.parse(str);
-var stringifyJson = (json) => JSON.stringify(json);
-var JSON_TYPE_NAMES = [
-  `array`,
-  `boolean`,
-  `null`,
-  `number`,
-  `object`,
-  `string`
-];
-var JSON_DEFAULTS = {
-  array: [],
-  boolean: false,
-  null: null,
-  number: 0,
-  object: {},
-  string: ``
-};
-
-// ../anvl/src/primitive/index.ts
-var isString = (input) => {
-  return typeof input === `string`;
-};
-var isNumber = (input) => {
-  return typeof input === `number`;
-};
-var isBoolean = (input) => {
-  return typeof input === `boolean`;
-};
-var isNull = (input) => {
-  return input === null;
-};
-var isPrimitive = (input) => {
-  return isString(input) || isNumber(input) || isBoolean(input) || isNull(input);
-};
-
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson };

package/internal/src/store/withdraw-new-family-member.ts

@@ -1,69 +0,0 @@
-import type {
-	ReadableToken,
-	ReadonlySelectorToken,
-	RegularAtomToken,
-	WritableSelectorToken,
-	WritableToken,
-} from "atom.io"
-
-import type {
-	Atom,
-	ReadableState,
-	ReadonlySelector,
-	Store,
-	WritableSelector,
-	WritableState,
-} from ".."
-import { newest, NotFoundError, withdraw } from ".."
-
-export function withdrawOrCreate<T>(
-	token: RegularAtomToken<T>,
-	store: Store,
-): Atom<T>
-export function withdrawOrCreate<T>(
-	token: WritableSelectorToken<T>,
-	store: Store,
-): WritableSelector<T>
-export function withdrawOrCreate<T>(
-	token: ReadonlySelectorToken<T>,
-	store: Store,
-): ReadonlySelector<T>
-export function withdrawOrCreate<T>(
-	token: WritableToken<T>,
-	store: Store,
-): WritableState<T>
-export function withdrawOrCreate<T>(
-	token: ReadableToken<T>,
-	store: Store,
-): ReadableState<T>
-export function withdrawOrCreate<T>(
-	token: ReadableToken<T>,
-	store: Store,
-): ReadableState<T> {
-	try {
-		const state = withdraw(token, store)
-		return state
-	} catch (notFoundError) {
-		if (token.family) {
-			store.logger.info(
-				`👪`,
-				token.type,
-				token.key,
-				`creating new family member in store "${store.config.name}"`,
-			)
-			const target = newest(store)
-			const family = target.families.get(token.family.key)
-			if (family) {
-				const jsonSubKey = JSON.parse(token.family.subKey)
-				family(jsonSubKey)
-				const state = withdraw(token, store)
-				return state
-			}
-			throw new NotFoundError(
-				{ key: token.family.key, type: `${token.type}_family` },
-				store,
-			)
-		}
-		throw notFoundError
-	}
-}