atom.io 0.22.0 → 0.23.1

package/src/index.ts

@@ -23,6 +23,10 @@ export * from "./validators"
 
 export type Func = (...parameters: any[]) => any
 
+export type Flat<R extends { [K in PropertyKey]: any }> = {
+	[K in keyof R]: R[K]
+}
+
 export type RegularAtomToken<T> = {
 	key: string
 	type: `atom`

package/src/selector.ts

@@ -7,7 +7,7 @@ import {
 import type { Json } from "atom.io/json"
 
 import type { ReadonlySelectorToken, WritableSelectorToken } from "."
-import type { Read, Write } from "./transaction"
+import type { Read, StateCreation, StateDisposal, Write } from "./transaction"
 
 export type WritableSelectorOptions<T> = {
 	key: string
@@ -63,7 +63,7 @@ export type WritableSelectorFamily<T, K extends Json.Serializable> =
 	& WritableSelectorFamilyToken<T, K> 
 	& {
 		(key: K): WritableSelectorToken<T>
-		subject: Subject<WritableSelectorToken<T>>
+		subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>
 		install: (store: Store) => void
 	}
 
@@ -90,7 +90,7 @@ export type ReadonlySelectorFamily<T, K extends Json.Serializable> =
 	& {
 		key: string
 		type: `readonly_selector_family`
-		subject: Subject<ReadonlySelectorToken<T>>
+		subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>
 		install: (store: Store) => void
 		__T?: T
 		__K?: K

package/src/subscribe.ts

@@ -9,6 +9,7 @@ import {
 
 import type {
 	FamilyMetadata,
+	Flat,
 	Func,
 	ReadableToken,
 	TimelineManageable,
@@ -19,10 +20,13 @@ import type {
 } from "."
 
 export type StateUpdate<T> = { newValue: T; oldValue: T }
-export type KeyedStateUpdate<T> = StateUpdate<T> & {
-	key: string
-	family?: FamilyMetadata
-}
+export type KeyedStateUpdate<T> = Flat<
+	StateUpdate<T> & {
+		key: string
+		type: `atom_update` | `selector_update`
+		family?: FamilyMetadata
+	}
+>
 export type UpdateHandler<T> = (update: StateUpdate<T>) => void
 
 export type TransactionUpdateHandler<F extends Func> = (

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,17 +1,28 @@
 import type { findState } from "atom.io/ephemeral"
-import type { EnvironmentData } from "atom.io/internal"
+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 { seekState } from "../immortal/src/seek-state"
 import type {
+	disposeState,
 	Func,
 	KeyedStateUpdate,
+	MutableAtomToken,
+	ReadableToken,
 	ReadonlySelectorToken,
+	TokenType,
+	WritableSelectorToken,
 	WritableToken,
 } from "."
 
@@ -21,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
@@ -35,13 +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
@@ -51,10 +95,18 @@ export type TransactorsWithRunAndEnv = Readonly<{
 	) => 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` | `seek`>
+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 };