atom.io 0.21.1 → 0.23.0

package/immortal/dist/index.js

@@ -0,0 +1,212 @@
+import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
+import * as Internal from 'atom.io/internal';
+import { Subject, initFamilyMember, getJsonFamily, disposeFromStore, newest, seekInStore, IMPLICIT } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
+import { getJoin } from 'atom.io/data';
+
+var Molecule = class _Molecule {
+  constructor(store, above, token) {
+    this.store = store;
+    this.token = token;
+    this.type = `molecule`;
+    this.below = [];
+    this.tokens = [];
+    this.joins = [];
+    this.subject = new Subject();
+    this.dispose = this[Symbol.dispose];
+    if (above) {
+      if (Array.isArray(above)) {
+        this.above = above;
+        for (const parent of above) {
+          parent.below.push(this);
+        }
+      } else {
+        this.above = [above];
+        above.below.push(this);
+      }
+    } else {
+      this.above = [];
+    }
+  }
+  get key() {
+    return this.token.key;
+  }
+  bond(token) {
+    const state = initFamilyMember(token, this.token.key, this.store);
+    if (token.type === `mutable_atom_family`) {
+      const jsonFamily = getJsonFamily(token, this.store);
+      const jsonState = initFamilyMember(jsonFamily, this.token.key, this.store);
+      this.tokens.push(jsonState);
+    }
+    this.tokens.push(state);
+    this.subject.next({ type: `state_creation`, token: state });
+    return state;
+  }
+  spawn(key) {
+    const child = new _Molecule(this.store, this, { key, type: `molecule` });
+    return child;
+  }
+  with(molecule) {
+    return (key) => {
+      const child = new _Molecule(this.store, [this, molecule], {
+        key,
+        type: `molecule`
+      });
+      return child;
+    };
+  }
+  detach(child) {
+    const childIndex = this.below.indexOf(child);
+    if (childIndex !== void 0) {
+      this.below.splice(childIndex, 1);
+    }
+    const parentIndex = child.above.indexOf(this);
+    if (parentIndex !== void 0) {
+      child.above.splice(parentIndex, 1);
+    }
+  }
+  claim(child) {
+    if (child === this) {
+      return;
+    }
+    for (const parent of child.above) {
+      parent.detach(child);
+    }
+    this.below.push(child);
+    child.above.push(this);
+  }
+  clear() {
+    var _a;
+    while (this.below.length > 0) {
+      (_a = this.below.pop()) == null ? void 0 : _a.dispose();
+    }
+    while (this.tokens.length > 0) {
+      const token = this.tokens.pop();
+      if (token) {
+        disposeFromStore(token, this.store);
+      }
+    }
+    while (this.joins.length > 0) {
+      const join = this.joins.pop();
+      if (join) {
+        join.molecules.delete(stringifyJson(this.token.key));
+      }
+    }
+  }
+  join(token) {
+    const join = getJoin(token, this.store);
+    join.molecules.set(stringifyJson(this.token.key), this);
+    this.joins.push(join);
+  }
+  [Symbol.dispose]() {
+    this.clear();
+    const target = newest(this.store);
+    target.molecules.delete(stringifyJson(this.token.key));
+    for (const parent of this.above) {
+      parent.detach(this);
+    }
+  }
+};
+
+// immortal/src/make-molecule.ts
+function createMoleculeFamily(options, store) {
+  const subject = new Internal.Subject();
+  const token = {
+    key: options.key,
+    type: `molecule_family`
+  };
+  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
+  store.moleculeFamilies.set(options.key, family);
+  return token;
+}
+function moleculeFamily(options) {
+  return createMoleculeFamily(options, Internal.IMPLICIT.STORE);
+}
+function makeMoleculeInStore(store, context, family, key, ...params) {
+  const target = Internal.newest(store);
+  const token = {
+    type: `molecule`,
+    key,
+    family
+  };
+  const contextArray = Array.isArray(context) ? context : [context];
+  const owners = contextArray.map((ctx) => store.molecules.get(stringifyJson(ctx.key))).filter((m) => m !== void 0);
+  const Formula = Internal.withdraw(family, store);
+  const molecule = new Formula(owners, token, ...params);
+  target.molecules.set(stringifyJson(key), molecule);
+  const update = {
+    type: `molecule_creation`,
+    token,
+    family,
+    context: contextArray,
+    params
+  };
+  const isTransaction = Internal.isChildStore(target) && target.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    target.transactionMeta.update.updates.push(update);
+  } else {
+    Formula.subject.next(update);
+  }
+  return token;
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(
+    Internal.IMPLICIT.STORE,
+    context,
+    family,
+    key,
+    ...params
+  );
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(stringifyJson(token.key));
+  return molecule;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, Internal.IMPLICIT.STORE);
+}
+function disposeMolecule(token, store) {
+  const mole = useMoleculeFromStore(token, store);
+  if (!mole || !token.family) {
+    return;
+  }
+  const { family } = token;
+  const Formula = Internal.withdraw(family, store);
+  const disposalEvent = {
+    type: `molecule_disposal`,
+    token,
+    family,
+    context: mole.above,
+    familyKeys: mole.tokens.map((t) => {
+      var _a;
+      return (_a = t.family) == null ? void 0 : _a.key;
+    }).filter((k) => typeof k === `string`)
+  };
+  if (token.family) {
+    disposalEvent.family = token.family;
+  }
+  const isTransaction = Internal.isChildStore(store) && store.transactionMeta.phase === `building`;
+  if (isTransaction) {
+    store.transactionMeta.update.updates.push(disposalEvent);
+  } else {
+    Formula.subject.next(disposalEvent);
+  }
+  mole.dispose();
+}
+function makeRootMolecule(key, store = Internal.IMPLICIT.STORE) {
+  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
+  store.molecules.set(stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
+function seekState(token, key) {
+  if (token.type === `molecule_family`) {
+    return seekInStore(token, key, IMPLICIT.STORE);
+  }
+  const state = seekInStore(token, key, IMPLICIT.STORE);
+  return state;
+}
+
+export { Molecule, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };

package/immortal/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "atom.io-immortal",
+	"type": "module",
+	"private": true,
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"browser": "./dist/index.js",
+			"require": "./dist/index.cjs",
+			"types": "./dist/index.d.ts"
+		}
+	}
+}

package/immortal/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./make-molecule"
+export * from "./molecule"
+export * from "./seek-state"

package/immortal/src/make-molecule.ts

@@ -0,0 +1,222 @@
+import type { Flat, MoleculeCreation, MoleculeDisposal } from "atom.io"
+import * as Internal from "atom.io/internal"
+import { type Json, stringifyJson } from "atom.io/json"
+
+import { Molecule } from "./molecule"
+
+export type MoleculeConstructor<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+> = new (
+	context: Molecule<any>[],
+	token: MoleculeToken<Key, Struct, Params>,
+	...params: Params
+) => Molecule<Key> & Struct
+
+export type MoleculeFamilyToken<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+> = {
+	key: string
+	type: `molecule_family`
+	__K?: Key
+	__S?: Struct
+	__P?: Params
+}
+export type MoleculeFamily<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+> = Flat<
+	MoleculeFamilyToken<Key, Struct, Params> & {
+		subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>
+	}
+> &
+	MoleculeConstructor<Key, Struct, Params>
+
+export type MoleculeToken<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+> = {
+	key: Key
+	type: `molecule`
+	family?: MoleculeFamilyToken<Key, Struct, Params>
+	__S?: Struct
+	__P?: Params
+}
+
+export type MoleculeFamilyOptions<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+> = {
+	key: string
+	new: (store: Internal.Store) => MoleculeConstructor<Key, Struct, Params>
+}
+
+export function createMoleculeFamily<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	options: MoleculeFamilyOptions<Key, Struct, Params>,
+	store: Internal.Store,
+): MoleculeFamilyToken<Key, Struct, Params> {
+	const subject = new Internal.Subject<
+		MoleculeCreation<Key> | MoleculeDisposal<Key>
+	>()
+	const token = {
+		key: options.key,
+		type: `molecule_family`,
+	} as const satisfies MoleculeFamilyToken<Key, Struct, Params>
+	const family = Object.assign(options.new(store), { ...token, subject })
+	store.moleculeFamilies.set(options.key, family)
+	return token
+}
+
+export function moleculeFamily<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	options: MoleculeFamilyOptions<Key, Struct, Params>,
+): MoleculeFamilyToken<Key, Struct, Params> {
+	return createMoleculeFamily(options, Internal.IMPLICIT.STORE)
+}
+
+export function makeMoleculeInStore<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	store: Internal.Store,
+	context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[],
+	family: MoleculeFamilyToken<Key, Struct, Params>,
+	key: Key,
+	...params: Params
+): MoleculeToken<Key, Struct, Params> {
+	const target = Internal.newest(store)
+
+	const token = {
+		type: `molecule`,
+		key,
+		family,
+	} as const satisfies MoleculeToken<Key, Struct, Params>
+
+	const contextArray = Array.isArray(context) ? context : [context]
+	const owners = contextArray
+		.map((ctx) => store.molecules.get(stringifyJson(ctx.key)))
+		.filter((m): m is Molecule<Key> => m !== undefined)
+	const Formula = Internal.withdraw(family, store)
+	const molecule = new Formula(owners, token, ...params)
+	target.molecules.set(stringifyJson(key), molecule)
+
+	const update = {
+		type: `molecule_creation`,
+		token,
+		family,
+		context: contextArray,
+		params,
+	} satisfies MoleculeCreation<Key>
+
+	const isTransaction =
+		Internal.isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(update)
+	} else {
+		Formula.subject.next(update)
+	}
+
+	return token
+}
+export function makeMolecule<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[],
+	family: MoleculeFamilyToken<Key, Struct, Params>,
+	key: Key,
+	...params: Params
+): MoleculeToken<Key, Struct, Params> {
+	return makeMoleculeInStore(
+		Internal.IMPLICIT.STORE,
+		context,
+		family,
+		key,
+		...params,
+	)
+}
+
+export function useMoleculeFromStore<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	token: MoleculeToken<Key, Struct, Params>,
+	store: Internal.Store,
+): (Molecule<Key> & Struct) | undefined {
+	const molecule = store.molecules.get(stringifyJson(token.key))
+	return molecule as Molecule<Key> & Struct
+}
+export function useMolecule<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(
+	token: MoleculeToken<Key, Struct, Params>,
+): (Molecule<Key> & Struct) | undefined {
+	return useMoleculeFromStore(token, Internal.IMPLICIT.STORE)
+}
+
+export function disposeMolecule<
+	Key extends Json.Serializable,
+	Struct extends { [key: string]: any },
+	Params extends any[],
+>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): void {
+	const mole = useMoleculeFromStore(token, store)
+	if (!mole || !token.family) {
+		return // add error log
+	}
+	const { family } = token
+	const Formula = Internal.withdraw(family, store)
+	const disposalEvent: MoleculeDisposal<Key> = {
+		type: `molecule_disposal`,
+		token,
+		family,
+		context: mole.above,
+		familyKeys: mole.tokens
+			.map((t) => t.family?.key)
+			.filter((k): k is string => typeof k === `string`),
+	}
+	if (token.family) {
+		disposalEvent.family = token.family
+	}
+	const isTransaction =
+		Internal.isChildStore(store) && store.transactionMeta.phase === `building`
+	if (isTransaction) {
+		store.transactionMeta.update.updates.push(disposalEvent)
+	} else {
+		Formula.subject.next(disposalEvent)
+	}
+
+	mole.dispose()
+}
+
+export type MoleculeType<M extends MoleculeFamilyToken<any, any, any>> =
+	M extends MoleculeFamilyToken<any, infer T, any> ? T : never
+
+export function makeRootMolecule(
+	key: Json.Serializable,
+	store: Internal.Store = Internal.IMPLICIT.STORE,
+): MoleculeToken<Json.Serializable, { [key: string]: unknown }, []> {
+	const molecule = new Molecule(store, undefined, { key, type: `molecule` })
+	store.molecules.set(stringifyJson(key), molecule)
+	return {
+		key,
+		type: `molecule`,
+	} as const
+}

package/immortal/src/molecule.ts

@@ -0,0 +1,167 @@
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	StateCreation,
+	StateDisposal,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Join, JoinToken } from "atom.io/data"
+import { getJoin } from "atom.io/data"
+import type { Store, Transceiver } from "atom.io/internal"
+import {
+	disposeFromStore,
+	getJsonFamily,
+	initFamilyMember,
+	newest,
+	Subject,
+} from "atom.io/internal"
+import { type Json, stringifyJson } from "atom.io/json"
+
+import type { MoleculeFamilyToken, MoleculeToken } from "./make-molecule"
+
+export class Molecule<Key extends Json.Serializable> {
+	public readonly type = `molecule`
+	public get key(): Key {
+		return this.token.key
+	}
+	public readonly family?: MoleculeFamilyToken<Key, any, any>
+	public readonly above: Molecule<any>[]
+	public readonly below: Molecule<any>[] = []
+	public readonly tokens: ReadableToken<any>[] = []
+	public readonly joins: Join<any, any, any, any>[] = []
+	public readonly subject = new Subject<
+		StateCreation<any> | StateDisposal<any>
+	>()
+	public constructor(
+		public readonly store: Store,
+		above: Molecule<any> | Molecule<any>[] | undefined,
+		public readonly token: MoleculeToken<Key, any, any>,
+	) {
+		// store.molecules.set(stringifyJson(key), this) // consider removing this
+		if (above) {
+			if (Array.isArray(above)) {
+				this.above = above
+				for (const parent of above) {
+					parent.below.push(this)
+				}
+			} else {
+				this.above = [above]
+				above.below.push(this)
+			}
+		} else {
+			this.above = []
+		}
+	}
+
+	public bond<
+		T extends Transceiver<any>,
+		J extends Json.Serializable,
+		K extends string,
+	>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>
+	public bond<T, K extends Key>(
+		token: RegularAtomFamilyToken<T, K>,
+	): RegularAtomToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: WritableSelectorFamilyToken<T, K>,
+	): WritableSelectorToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: ReadonlySelectorFamilyToken<T, K>,
+	): ReadonlySelectorToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: WritableFamilyToken<T, K>,
+	): WritableToken<T>
+	public bond<T, K extends Json.Serializable>(
+		token: ReadableFamilyToken<T, K>,
+	): ReadableToken<T>
+	public bond(token: ReadableFamilyToken<any, any>): ReadableToken<any> {
+		const state = initFamilyMember(token, this.token.key, this.store)
+		if (token.type === `mutable_atom_family`) {
+			const jsonFamily = getJsonFamily(token, this.store)
+			const jsonState = initFamilyMember(jsonFamily, this.token.key, this.store)
+			this.tokens.push(jsonState)
+		}
+		this.tokens.push(state)
+		this.subject.next({ type: `state_creation`, token: state })
+		return state
+	}
+
+	public spawn<K extends Json.Serializable>(key: K): Molecule<K> {
+		const child = new Molecule(this.store, this, { key, type: `molecule` })
+		return child
+	}
+
+	public with(molecule: Molecule<any>): (key: string) => Molecule<any> {
+		return (key) => {
+			const child = new Molecule(this.store, [this, molecule], {
+				key,
+				type: `molecule`,
+			})
+			return child
+		}
+	}
+
+	public detach(child: Molecule<any>): void {
+		const childIndex = this.below.indexOf(child)
+		if (childIndex !== undefined) {
+			this.below.splice(childIndex, 1)
+		}
+		const parentIndex = child.above.indexOf(this)
+		if (parentIndex !== undefined) {
+			child.above.splice(parentIndex, 1)
+		}
+	}
+
+	public claim(child: Molecule<any>): void {
+		if (child === this) {
+			return
+		}
+		for (const parent of child.above) {
+			parent.detach(child)
+		}
+		this.below.push(child)
+		child.above.push(this)
+	}
+
+	public clear(): void {
+		while (this.below.length > 0) {
+			this.below.pop()?.dispose()
+		}
+		while (this.tokens.length > 0) {
+			const token = this.tokens.pop()
+			if (token) {
+				disposeFromStore(token, this.store)
+			}
+		}
+		while (this.joins.length > 0) {
+			const join = this.joins.pop()
+			if (join) {
+				join.molecules.delete(stringifyJson(this.token.key))
+			}
+		}
+	}
+
+	public join(token: JoinToken<any, any, any, any>): void {
+		const join = getJoin(token, this.store)
+		join.molecules.set(stringifyJson(this.token.key), this)
+		this.joins.push(join)
+	}
+
+	private [Symbol.dispose](): void {
+		this.clear()
+		const target = newest(this.store)
+		target.molecules.delete(stringifyJson(this.token.key))
+		for (const parent of this.above) {
+			parent.detach(this)
+		}
+	}
+	public dispose = this[Symbol.dispose]
+}

package/immortal/src/seek-state.ts

@@ -0,0 +1,73 @@
+import type {
+	MutableAtomFamilyToken,
+	MutableAtomToken,
+	ReadableFamilyToken,
+	ReadableToken,
+	ReadonlySelectorFamilyToken,
+	ReadonlySelectorToken,
+	RegularAtomFamilyToken,
+	RegularAtomToken,
+	WritableFamilyToken,
+	WritableSelectorFamilyToken,
+	WritableSelectorToken,
+	WritableToken,
+} from "atom.io"
+import type { Transceiver } from "atom.io/internal"
+import { IMPLICIT, seekInStore } from "atom.io/internal"
+import type { Json } from "atom.io/json"
+
+import type { MoleculeFamilyToken, MoleculeToken } from "./make-molecule"
+
+export function seekState<
+	T extends Transceiver<any>,
+	J extends Json.Serializable,
+	K extends Json.Serializable,
+	Key extends K,
+>(
+	token: MutableAtomFamilyToken<T, J, K>,
+	key: Key,
+): MutableAtomToken<T, J> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: RegularAtomFamilyToken<T, K>,
+	key: Key,
+): RegularAtomToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: WritableSelectorFamilyToken<T, K>,
+	key: Key,
+): WritableSelectorToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: ReadonlySelectorFamilyToken<T, K>,
+	key: Key,
+): ReadonlySelectorToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: WritableFamilyToken<T, K>,
+	key: Key,
+): WritableToken<T> | undefined
+
+export function seekState<T, K extends Json.Serializable, Key extends K>(
+	token: ReadableFamilyToken<T, K>,
+	key: Key,
+): ReadableToken<T> | undefined
+
+export function seekState<
+	K extends Json.Serializable,
+	S extends { [key: string]: any },
+>(
+	token: MoleculeFamilyToken<K, S, any[]>,
+	key: K,
+): MoleculeToken<K, S, any[]> | undefined
+
+export function seekState(
+	token: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
+	key: Json.Serializable,
+): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
+	if (token.type === `molecule_family`) {
+		return seekInStore(token, key, IMPLICIT.STORE)
+	}
+	const state = seekInStore(token, key, IMPLICIT.STORE)
+	return state
+}