atom.io 0.24.8 → 0.25.0

package/internal/dist/index.js

@@ -2,7 +2,7 @@ import { Junction } from '../../dist/chunk-HYXKCFVY.js';
 import { __spreadValues, __spreadProps } from '../../dist/chunk-S4N6XNPH.js';
 import { stringifyJson, parseJson, selectJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
-import { getJoin } from 'atom.io/data';
+import { getJoin, findRelations } from 'atom.io/data';
 
 // internal/src/arbitrary.ts
 function arbitrary(random = Math.random) {
@@ -132,8 +132,6 @@ var abortTransaction = (store) => {
   );
   target.parent.child = null;
 };
-
-// internal/src/not-found-error.ts
 var capitalize = (str) => str[0].toUpperCase() + str.slice(1);
 function prettyPrintTokenType(token) {
   switch (token.type) {
@@ -152,10 +150,19 @@ function prettyPrintTokenType(token) {
   }
 }
 var NotFoundError = class extends Error {
-  constructor(token, store) {
-    super(
-      `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
-    );
+  constructor(...params) {
+    const token = params[0];
+    const store = params.length === 2 ? params[1] : params[2];
+    if (params.length === 2) {
+      super(
+        `${prettyPrintTokenType(token)} "${token.key}" not found in store "${store.config.name}".`
+      );
+    } else {
+      const key = params[1];
+      super(
+        `${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${store.config.name}".`
+      );
+    }
   }
 };
 
@@ -415,41 +422,6 @@ var setAtomOrSelector = (state, value, store) => {
       break;
   }
 };
-
-// internal/src/set-state/set-into-store.ts
-function setIntoStore(token, value, store) {
-  const rejectionTime = openOperation(token, store);
-  if (rejectionTime) {
-    const unsubscribe = store.on.operationClose.subscribe(
-      `waiting to set "${token.key}" at T-${rejectionTime}`,
-      () => {
-        unsubscribe();
-        store.logger.info(
-          `\u{1F7E2}`,
-          token.type,
-          token.key,
-          `resuming deferred setState from T-${rejectionTime}`
-        );
-        setIntoStore(token, value, store);
-      }
-    );
-    return;
-  }
-  const state = withdraw(token, store);
-  setAtomOrSelector(state, value, store);
-  closeOperation(store);
-}
-
-// internal/src/ingest-updates/ingest-atom-update.ts
-function ingestAtomUpdate(applying, atomUpdate, store) {
-  const { key, newValue, oldValue } = atomUpdate;
-  const value = applying === `newValue` ? newValue : oldValue;
-  const token = { key, type: `atom` };
-  if (atomUpdate.family) {
-    Object.assign(token, { family: atomUpdate.family });
-  }
-  setIntoStore(token, value, store);
-}
 function createRegularAtomFamily(options, store) {
   const subject = new Subject();
   const atomFamily = Object.assign(
@@ -491,17 +463,31 @@ function createAtomFamily(options, store) {
 }
 
 // internal/src/get-state/get-from-store.ts
-function getFromStore(token, store) {
-  if (token.type === `molecule`) {
-    try {
-      const molecule = withdraw(token, store);
-      return molecule.instance;
-    } catch (_) {
-      return void 0;
+function getFromStore(...params) {
+  let token;
+  let store;
+  if (params.length === 2) {
+    token = params[0];
+    store = params[1];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    store = params[2];
+    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
     }
+    token = maybeToken;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+    case `selector`:
+    case `readonly_selector`:
+      return readOrComputeValue(withdraw(token, store), store);
+    case `molecule`:
+      return withdraw(token, store).instance;
   }
-  const state = withdraw(token, store);
-  return readOrComputeValue(state, store);
 }
 
 // internal/src/keys.ts
@@ -582,8 +568,16 @@ var updateSelectorAtoms = (selectorKey, dependency, covered, store) => {
 
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, covered, store) => ({
-  get: (dependency) => {
+  get: (dependency, key) => {
     const target = newest(store);
+    if (key) {
+      switch (dependency.type) {
+        case `molecule_family`:
+          return getFromStore(dependency, key, store);
+        case `atom_family`:
+          dependency = seekInStore(dependency, key, store);
+      }
+    }
     if (dependency.type === `molecule`) {
       return getFromStore(dependency, store);
     }
@@ -609,10 +603,25 @@ var registerSelector = (selectorKey, covered, store) => ({
     updateSelectorAtoms(selectorKey, dependency, covered, store);
     return dependencyValue;
   },
-  set: (WritableToken, newValue) => {
+  set: (...params) => {
+    let token;
+    let value;
+    if (params.length === 2) {
+      token = params[0];
+      value = params[1];
+    } else {
+      const family = params[0];
+      const key = params[1];
+      value = params[2];
+      const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+      if (!maybeToken) {
+        throw new NotFoundError(family, key, store);
+      }
+      token = maybeToken;
+    }
     const target = newest(store);
-    const state = withdraw(WritableToken, target);
-    setAtomOrSelector(state, newValue, target);
+    const state = withdraw(token, target);
+    setAtomOrSelector(state, value, target);
   },
   find: (token, key) => findInStore(token, key, store),
   seek: (token, key) => seekInStore(token, key, store),
@@ -665,11 +674,11 @@ var createWritableSelector = (options, family, store) => {
   const target = newest(store);
   const subject = new Subject();
   const covered = /* @__PURE__ */ new Set();
-  const transactors = registerSelector(options.key, covered, target);
-  const { find, get, seek, json } = transactors;
-  const readonlyTransactors = { find, get, seek, json };
+  const toolkit = registerSelector(options.key, covered, target);
+  const { find, get, seek, json } = toolkit;
+  const getterToolkit = { find, get, seek, json };
   const getSelf = (innerTarget = newest(store)) => {
-    const value = options.get(readonlyTransactors);
+    const value = options.get(getterToolkit);
     cacheValue(options.key, value, subject, innerTarget);
     covered.clear();
     return value;
@@ -693,7 +702,7 @@ var createWritableSelector = (options, family, store) => {
     if (isRootStore(innerTarget)) {
       subject.next({ newValue, oldValue });
     }
-    options.set(transactors, newValue);
+    options.set(toolkit, newValue);
   };
   const mySelector = __spreadValues(__spreadProps(__spreadValues({}, options), {
     subject,
@@ -947,23 +956,6 @@ function disposeMolecule(token, store) {
   }
 }
 
-// internal/src/families/dispose-from-store.ts
-function disposeFromStore(token, store = IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      disposeSelector(token, store);
-      break;
-    case `molecule`:
-      disposeMolecule(token, store);
-      break;
-  }
-}
-
 // internal/src/families/init-family-member.ts
 function initFamilyMemberInStore(token, key, store) {
   const familyKey = token.key;
@@ -1037,6 +1029,91 @@ function findInStore(token, key, store) {
   return state;
 }
 
+// internal/src/families/dispose-from-store.ts
+function disposeFromStore(...params) {
+  let token;
+  let store;
+  if (params.length === 2) {
+    token = params[0];
+    store = params[1];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    store = params[2];
+    const maybeToken = family.type === `molecule_family` ? seekInStore(family, key, store) : store.config.lifespan === `immortal` ? seekInStore(family, key, store) : findInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
+    }
+    token = maybeToken;
+  }
+  switch (token.type) {
+    case `atom`:
+    case `mutable_atom`:
+      disposeAtom(token, store);
+      break;
+    case `selector`:
+    case `readonly_selector`:
+      disposeSelector(token, store);
+      break;
+    case `molecule`:
+      disposeMolecule(token, store);
+      break;
+  }
+}
+
+// internal/src/set-state/set-into-store.ts
+function setIntoStore(...params) {
+  let token;
+  let value;
+  let store;
+  if (params.length === 3) {
+    token = params[0];
+    value = params[1];
+    store = params[2];
+  } else {
+    const family = params[0];
+    const key = params[1];
+    value = params[2];
+    store = params[3];
+    const maybeToken = store.config.lifespan === `ephemeral` ? findInStore(family, key, store) : seekInStore(family, key, store);
+    if (!maybeToken) {
+      throw new NotFoundError(family, key, store);
+    }
+    token = maybeToken;
+  }
+  const rejectionTime = openOperation(token, store);
+  if (rejectionTime) {
+    const unsubscribe = store.on.operationClose.subscribe(
+      `waiting to set "${token.key}" at T-${rejectionTime}`,
+      () => {
+        unsubscribe();
+        store.logger.info(
+          `\u{1F7E2}`,
+          token.type,
+          token.key,
+          `resuming deferred setState from T-${rejectionTime}`
+        );
+        setIntoStore(token, value, store);
+      }
+    );
+    return;
+  }
+  const state = withdraw(token, store);
+  setAtomOrSelector(state, value, store);
+  closeOperation(store);
+}
+
+// internal/src/ingest-updates/ingest-atom-update.ts
+function ingestAtomUpdate(applying, atomUpdate, store) {
+  const { key, newValue, oldValue } = atomUpdate;
+  const value = applying === `newValue` ? newValue : oldValue;
+  const token = { key, type: `atom` };
+  if (atomUpdate.family) {
+    Object.assign(token, { family: atomUpdate.family });
+  }
+  setIntoStore(token, value, store);
+}
+
 // internal/src/molecule/create-molecule-family.ts
 function createMoleculeFamily(options, store) {
   var _a;
@@ -1098,30 +1175,34 @@ var Molecule = class {
 };
 
 // internal/src/molecule/make-molecule-in-store.ts
+function capitalize2(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
 function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   const target = newest(store);
-  target.moleculeInProgress = key;
+  const stringKey = stringifyJson(key);
+  target.moleculeInProgress = stringKey;
   const contextArray = Array.isArray(context) ? context : [context];
   const owners = contextArray.map((ctx) => {
     if (ctx instanceof Molecule) {
       return ctx;
     }
-    const stringKey = stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(stringKey);
+    const ctxStringKey = stringifyJson(ctx.key);
+    const molecule2 = store.molecules.get(ctxStringKey);
     if (!molecule2) {
       throw new Error(
-        `Molecule ${stringKey} not found in store "${store.config.name}"`
+        `Molecule ${ctxStringKey} not found in store "${store.config.name}"`
       );
     }
     return molecule2;
   });
   const molecule = new Molecule(owners, key, familyToken);
-  target.molecules.set(stringifyJson(key), molecule);
+  target.molecules.set(stringKey, molecule);
   for (const owner of owners) {
     owner.below.set(molecule.stringKey, molecule);
   }
-  const transactors = {
-    get: (t) => getFromStore(t, newest(store)),
+  const toolkit = {
+    get: (t) => getFromStore(t, void 0, newest(store)),
     set: (t, newValue) => {
       setIntoStore(t, newValue, newest(store));
     },
@@ -1133,11 +1214,36 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
       disposeFromStore(t, newest(store));
     },
     env: () => getEnvironmentData(newest(store)),
-    bond: (f) => growMoleculeInStore(
-      molecule,
-      withdraw(f, store),
-      newest(store)
-    ),
+    bond: (token2, maybeRole) => {
+      if (token2.type === `join`) {
+        const { as: role } = maybeRole;
+        const join = getJoin(token2, store);
+        join.molecules.set(stringKey, molecule);
+        molecule.joins.set(token2.key, join);
+        const unsubFromFamily = family.subject.subscribe(
+          `join:${token2.key}-${stringKey}`,
+          (event) => {
+            if (event.type === `molecule_disposal` && stringifyJson(event.token.key) === stringKey) {
+              unsubFromFamily();
+              join.molecules.delete(stringKey);
+            }
+          }
+        );
+        if (role === null) {
+          return;
+        }
+        const otherRole = token2.a === role ? token2.b : token2.a;
+        const relations = findRelations(token2, key);
+        const relatedKeys = relations[`${otherRole}KeysOf${capitalize2(role)}`];
+        const relatedEntries = relations[`${otherRole}EntriesOf${capitalize2(role)}`];
+        let tokens = { relatedKeys };
+        if (relatedEntries) {
+          tokens = Object.assign(tokens, { relatedEntries });
+        }
+        return tokens;
+      }
+      return growMoleculeInStore(molecule, withdraw(token2, store), newest(store));
+    },
     claim: (below, options) => {
       const { exclusive } = options;
       const belowMolecule = newest(store).molecules.get(stringifyJson(below.key));
@@ -1155,12 +1261,6 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
         }
       }
     },
-    join: (joinToken) => {
-      const join = getJoin(joinToken, store);
-      join.molecules.set(stringifyJson(key), molecule);
-      molecule.joins.set(joinToken.key, join);
-      return joinToken;
-    },
     spawn: (f, k, ...p) => makeMoleculeInStore(
       newest(store),
       [molecule],
@@ -1171,7 +1271,7 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
   };
   const family = withdraw(familyToken, store);
   const Constructor = family.new;
-  molecule.instance = new Constructor(transactors, key, ...params);
+  molecule.instance = new Constructor(toolkit, key, ...params);
   const token = {
     type: `molecule`,
     key,
@@ -1472,18 +1572,18 @@ var buildTransaction = (key, params, store, id) => {
       params,
       output: void 0
     },
-    transactors: {
-      get: (token) => getFromStore(token, child),
-      set: (token, value) => {
-        setIntoStore(token, value, child);
+    toolkit: {
+      get: (...ps) => getFromStore(...ps, child),
+      set: (...ps) => {
+        setIntoStore(...ps, child);
       },
       run: (token, identifier = arbitrary()) => actUponStore(token, identifier, child),
       find: (token, k) => findInStore(token, k, child),
       seek: (token, k) => seekInStore(token, k, child),
       json: (token) => getJsonToken(token, child),
       make: (context, family, k, ...args) => makeMoleculeInStore(child, context, family, k, ...args),
-      dispose: (token) => {
-        disposeFromStore(token, child);
+      dispose: (...ps) => {
+        disposeFromStore(...ps, child);
       },
       env: () => getEnvironmentData(child)
     }
@@ -1511,8 +1611,8 @@ function createTransaction(options, store) {
       const childStore = buildTransaction(options.key, params, store, id);
       try {
         const target2 = newest(store);
-        const { transactors } = childStore.transactionMeta;
-        const output = options.do(transactors, ...params);
+        const { toolkit } = childStore.transactionMeta;
+        const output = options.do(toolkit, ...params);
         applyTransaction(output, target2);
         return output;
       } catch (thrown) {
@@ -1628,6 +1728,7 @@ var Store = class {
         for (const logger of this.loggers) logger.warn(...messages);
       }
     };
+    this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
     if (store !== null) {
       this.valueMap = new Map(store == null ? void 0 : store.valueMap);
       this.operation = __spreadValues({}, store == null ? void 0 : store.operation);
@@ -1639,7 +1740,6 @@ var Store = class {
           )
         };
       }
-      this.config = __spreadValues(__spreadValues({}, store == null ? void 0 : store.config), config);
       for (const [, family] of store.families) {
         family.install(this);
       }

package/internal/src/families/dispose-from-store.ts

@@ -1,15 +1,68 @@
-import type { MoleculeToken, ReadableToken } from "atom.io"
+import type {
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
+	ReadableFamilyToken,
+	ReadableToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
 
 import { disposeAtom } from "../atom"
 import { disposeMolecule } from "../molecule/dispose-molecule"
+import { NotFoundError } from "../not-found-error"
 import { disposeSelector } from "../selector"
 import type { Store } from "../store"
-import { IMPLICIT } from "../store"
+import { findInStore } from "./find-in-store"
+import { seekInStore } from "./seek-in-store"
 
 export function disposeFromStore(
 	token: MoleculeToken<any> | ReadableToken<any>,
-	store: Store = IMPLICIT.STORE,
+	store: Store,
+): void
+
+export function disposeFromStore<K extends Json.Serializable>(
+	token: ReadableFamilyToken<any, K>,
+	key: K,
+	store: Store,
+): void
+
+export function disposeFromStore<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+	store: Store,
+): void
+
+export function disposeFromStore(
+	...params:
+		| [
+				token: ReadableFamilyToken<any, any>,
+				key: Json.Serializable,
+				store: Store,
+		  ]
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
+		| [token: MoleculeToken<any> | ReadableToken<any>, store: Store]
 ): void {
+	let token: MoleculeToken<any> | ReadableToken<any>
+	let store: Store
+	if (params.length === 2) {
+		token = params[0]
+		store = params[1]
+	} else {
+		const family = params[0]
+		const key = params[1]
+		store = params[2]
+		const maybeToken =
+			family.type === `molecule_family`
+				? seekInStore(family, key, store)
+				: store.config.lifespan === `immortal`
+					? seekInStore(family, key, store)
+					: findInStore(family, key, store)
+		if (!maybeToken) {
+			throw new NotFoundError(family, key, store)
+		}
+		token = maybeToken
+	}
 	switch (token.type) {
 		case `atom`:
 		case `mutable_atom`:

package/internal/src/get-state/get-from-store.ts

@@ -1,39 +1,72 @@
-import type { MoleculeConstructor, MoleculeToken, ReadableToken } from "atom.io"
+import type {
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
+	ReadableFamilyToken,
+	ReadableToken,
+} from "atom.io"
+import type { Json } from "atom.io/json"
 
+import { findInStore, seekInStore } from "../families"
+import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
 export function getFromStore<T>(token: ReadableToken<T>, store: Store): T
+
 export function getFromStore<M extends MoleculeConstructor>(
 	token: MoleculeToken<M>,
 	store: Store,
 ): InstanceType<M> | undefined
-export function getFromStore<
-	T,
-	M extends MoleculeConstructor,
-	Token extends MoleculeToken<M> | ReadableToken<T>,
->(token: Token, store: Store): InstanceType<M> | T | undefined
-export function getFromStore<
-	Token extends MoleculeToken<any> | ReadableToken<any>,
->(
-	token: Token,
+
+export function getFromStore<T, K extends Json.Serializable>(
+	token: ReadableFamilyToken<T, K>,
+	key: K,
 	store: Store,
-):
-	| (Token extends MoleculeToken<infer M>
-			? InstanceType<M>
-			: Token extends ReadableToken<infer T>
-				? T
-				: never)
-	| undefined {
-	if (token.type === `molecule`) {
-		try {
-			const molecule = withdraw(token, store)
-			return molecule.instance
-		} catch (_) {
-			return undefined
+): T
+
+export function getFromStore<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+	store: Store,
+): InstanceType<M>
+
+export function getFromStore<T>(
+	...params:
+		| [token: MoleculeFamilyToken<any>, key: MoleculeKey<any>, store: Store]
+		| [token: MoleculeToken<any>, store: Store]
+		| [token: ReadableFamilyToken<T, any>, key: Json.Serializable, store: Store]
+		| [token: ReadableToken<T>, store: Store]
+): any {
+	let token: MoleculeToken<any> | ReadableToken<T>
+	let store: Store
+	if (params.length === 2) {
+		token = params[0]
+		store = params[1]
+	} else {
+		const family = params[0]
+		const key = params[1]
+		store = params[2]
+		const maybeToken =
+			family.type === `molecule_family`
+				? seekInStore(family, key, store)
+				: store.config.lifespan === `immortal`
+					? seekInStore(family, key, store)
+					: findInStore(family, key, store)
+		if (!maybeToken) {
+			throw new NotFoundError(family, key, store)
 		}
+		token = maybeToken
+	}
+	switch (token.type) {
+		case `atom`:
+		case `mutable_atom`:
+		case `selector`:
+		case `readonly_selector`:
+			return readOrComputeValue(withdraw(token, store), store)
+		case `molecule`:
+			return withdraw(token, store).instance
 	}
-	const state = withdraw(token, store)
-	return readOrComputeValue(state, store)
 }