atom.io 0.30.7 → 0.31.1

package/dist/index.js

@@ -1,7 +1,7 @@
-export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm } from './chunk-ADMEAXYU.js';
+import { newest, isChildStore, withdraw } from './chunk-Y5MBNTVU.js';
 import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, createMoleculeFamily, makeMoleculeInStore, actUponStore, arbitrary } from 'atom.io/internal';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, makeRootMoleculeInStore, allocateIntoStore, fuseWithinStore, deallocateFromStore, claimWithinStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
 
 function atom(options) {
   return createStandaloneAtom(IMPLICIT.STORE, options);
@@ -9,7 +9,7 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(IMPLICIT.STORE, options);
 }
-function disposeState(token, key) {
+function disposeState(...[token, key]) {
   if (key) {
     Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
   } else {
@@ -58,6 +58,54 @@ var AtomIOLogger = class {
     }
   };
 };
+var $claim = Symbol(`claim`);
+var Realm = class {
+  store;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    makeRootMoleculeInStore(`root`, store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    return allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
+    );
+  }
+  fuse(type, reagentA, reagentB) {
+    return fuseWithinStore(this.store, type, reagentA, reagentB);
+  }
+  deallocate(claim) {
+    deallocateFromStore(this.store, claim);
+  }
+  claim(newProvenance, claim, exclusive) {
+    return claimWithinStore(this.store, newProvenance, claim, exclusive);
+  }
+};
+var Anarchy = class {
+  store;
+  realm;
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    this.realm = new Realm(store);
+  }
+  allocate(provenance, key, attachmentStyle) {
+    allocateIntoStore(
+      this.store,
+      provenance,
+      key,
+      attachmentStyle
+    );
+  }
+  deallocate(key) {
+    deallocateFromStore(this.store, key);
+  }
+  claim(newProvenance, key, exclusive) {
+    claimWithinStore(this.store, newProvenance, key, exclusive);
+  }
+};
+var T$ = `T$`;
 function selector(options) {
   return createStandaloneSelector(IMPLICIT.STORE, options);
 }
@@ -71,6 +119,40 @@ function setState(...params) {
     Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
   }
 }
+
+// internal/src/install-into-store.ts
+function installIntoStore(tokens, target, source) {
+  const sourceNewest = newest(source);
+  if (isChildStore(sourceNewest)) {
+    source.logger.error(
+      `\u274C`,
+      `transaction`,
+      sourceNewest.transactionMeta.update.key,
+      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+      tokens,
+      `${sourceNewest.config.name} is undergoing a transaction.`
+    );
+    return;
+  }
+  const targetNewest = newest(target);
+  if (isChildStore(targetNewest)) {
+    target.logger.error(
+      `\u274C`,
+      `transaction`,
+      targetNewest.transactionMeta.update.key,
+      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
+      tokens,
+      `${targetNewest.config.name} is undergoing a transaction.`
+    );
+    return;
+  }
+  for (const token of tokens) {
+    const resource = withdraw(token, source);
+    resource.install(target);
+  }
+}
+
+// src/silo.ts
 var Silo = class {
   store;
   atom;
@@ -86,12 +168,10 @@ var Silo = class {
   subscribe;
   undo;
   redo;
-  moleculeFamily;
-  makeMolecule;
   runTransaction;
+  install;
   constructor(config, fromStore = null) {
-    const s = new Store(config, fromStore);
-    this.store = s;
+    const s = this.store = new Store(config, fromStore);
     this.atom = (options) => createStandaloneAtom(s, options);
     this.atomFamily = (options) => createAtomFamily(s, options);
     this.selector = (options) => createStandaloneSelector(s, options);
@@ -113,13 +193,10 @@ var Silo = class {
     this.redo = (token) => {
       timeTravel(s, `redo`, token);
     };
-    this.moleculeFamily = (options) => {
-      return createMoleculeFamily(s, options);
-    };
-    this.makeMolecule = (...params) => {
-      return makeMoleculeInStore(s, ...params);
-    };
     this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
+    this.install = (tokens, source = IMPLICIT.STORE) => {
+      installIntoStore(tokens, s, source);
+    };
   }
 };
 function subscribe(token, handleUpdate, key = arbitrary()) {
@@ -149,4 +226,4 @@ function belongsTo(family, unknownToken) {
   return family.key === unknownToken.family?.key;
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { $claim, Anarchy, AtomIOLogger, LOG_LEVELS, Realm, Silo, T$, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/ephemeral/dist/index.d.ts

@@ -3,54 +3,64 @@ import { Transceiver } from 'atom.io/internal';
 import { Json, Canonical } from 'atom.io/json';
 
 /**
- * @overload Mutable Atom
- * Finds a {@link MutableAtomToken} in the store.
- * @param token - A {@link MutableAtomFamilyToken}.
- * @param key - The key of the state.
+ * @public
+ * Finds a {@link MutableAtomToken} in the store
+ * @param token - A {@link MutableAtomFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Mutable Atom
  */
 declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Regular Atom
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable Selector
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Readonly Selector
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable State
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 /**
  * @public
- * Finds a {@link ReadableToken} in the store.
- * @param token - A {@link ReadableFamilyToken}.
- * @param key - The key of the state.
+ * Finds a {@link ReadableToken} in the store
+ * @param token - A {@link ReadableFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
  * @overload Unknown
+ * @default
  */
 declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
 

package/ephemeral/src/find-state.ts

@@ -17,12 +17,13 @@ import { findInStore, IMPLICIT } from "atom.io/internal"
 import type { Canonical, Json } from "atom.io/json"
 
 /**
- * @overload Mutable Atom
- * Finds a {@link MutableAtomToken} in the store.
- * @param token - A {@link MutableAtomFamilyToken}.
- * @param key - The key of the state.
+ * @public
+ * Finds a {@link MutableAtomToken} in the store
+ * @param token - A {@link MutableAtomFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Mutable Atom
  */
 export function findState<
 	T extends Transceiver<any>,
@@ -31,44 +32,52 @@ export function findState<
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Regular Atom
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Readonly Selector
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T, K>
 /**
- * Finds a state in the store.
- * @param token - The token of the state family.
- * @param key - The key of the state.
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
+ * @overload Writable State
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
@@ -76,12 +85,13 @@ export function findState<T, K extends Canonical, Key extends K>(
 ): WritableToken<T, K>
 /**
  * @public
- * Finds a {@link ReadableToken} in the store.
- * @param token - A {@link ReadableFamilyToken}.
- * @param key - The key of the state.
+ * Finds a {@link ReadableToken} in the store
+ * @param token - A {@link ReadableFamilyToken}
+ * @param key - The key of the state
  * @returns
- * The current value of the state.
+ * The current value of the state
  * @overload Unknown
+ * @default
  */
 export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,

package/eslint-plugin/dist/index.d.ts

@@ -1,3 +1,4 @@
+import * as _eslint_core from '@eslint/core';
 import * as ESTree from 'estree';
 import * as eslint from 'eslint';
 import { Rule } from 'eslint';
@@ -20,7 +21,13 @@ declare const lifespan: {
             default: string;
         }[];
     };
-    create(context: Rule.RuleContext): {
+    create(context: _eslint_core.RuleContext<{
+        LangOptions: eslint.Linter.LanguageOptions;
+        Code: eslint.SourceCode;
+        RuleOptions: any[];
+        Node: ESTree.Node;
+        MessageIds: string;
+    }>): {
         ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
         CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
     };
@@ -37,7 +44,13 @@ declare const synchronousSelectorDependencies: {
         };
         schema: never[];
     };
-    create(context: Rule.RuleContext): {
+    create(context: _eslint_core.RuleContext<{
+        LangOptions: eslint.Linter.LanguageOptions;
+        Code: eslint.SourceCode;
+        RuleOptions: any[];
+        Node: ESTree.Node;
+        MessageIds: string;
+    }>): {
         CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
     };
 };
@@ -64,7 +77,13 @@ declare const _default: {
                 };
                 schema: never[];
             };
-            create(context: eslint.Rule.RuleContext): {
+            create(context: _eslint_core.RuleContext<{
+                LangOptions: eslint.Linter.LanguageOptions;
+                Code: eslint.SourceCode;
+                RuleOptions: any[];
+                Node: ESTree.Node;
+                MessageIds: string;
+            }>): {
                 CallExpression(node: ESTree.CallExpression & eslint.Rule.NodeParentExtension): void;
             };
         };

package/eslint-plugin/dist/index.js

@@ -172,10 +172,10 @@ var lifespan = {
         if (storeLifespan === `ephemeral`) {
           return;
         }
-        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
-        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : undefined;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : undefined;
         const callee = functionCallee ?? methodCallee;
-        if (callee === void 0) {
+        if (callee === undefined) {
           return;
         }
         if (callee.name === `findState`) {
@@ -247,7 +247,7 @@ var lifespan = {
         }
         for (const storeProcedure of storeProcedures) {
           const transactorsParam = storeProcedure.params[0];
-          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : undefined;
           walk(storeProcedure.body, (n) => {
             if (n.type === `CallExpression`) {
               let willReport = false;
@@ -327,14 +327,14 @@ var synchronousSelectorDependencies = {
           }
         }
         if (selectorComputation?.type === `FunctionExpression` || selectorComputation?.type === `ArrowFunctionExpression`) {
-          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : void 0;
+          const nonDestructuredTransactorsName = selectorComputation.params[0] && `name` in selectorComputation.params[0] ? selectorComputation.params[0].name : undefined;
           let awaited;
           let awaitNode;
           walk(selectorComputation, (n, depth) => {
             if (typeof awaited === `number`) {
               if (awaited > depth) {
-                awaited = void 0;
-                awaitNode = void 0;
+                awaited = undefined;
+                awaitNode = undefined;
               }
             }
             switch (n.type) {

package/immortal/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, MoleculeToken } from 'atom.io';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
 import { Transceiver } from 'atom.io/internal';
 import { Json, Canonical } from 'atom.io/json';
 
@@ -8,6 +8,5 @@ declare function seekState<T, K extends Canonical, Key extends K>(token: Writabl
 declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
 declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
 declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
-declare function seekState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeToken<M> | undefined;
 
 export { seekState };

package/immortal/dist/index.js

@@ -2,9 +2,6 @@ import '../../dist/chunk-XWL6SNVU.js';
 import { seekInStore, IMPLICIT } from 'atom.io/internal';
 
 function seekState(token, key) {
-  if (token.type === `molecule_family`) {
-    return seekInStore(IMPLICIT.STORE, token, key);
-  }
   const state = seekInStore(IMPLICIT.STORE, token, key);
   return state;
 }

package/immortal/src/seek-state.ts

@@ -1,8 +1,4 @@
 import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -55,18 +51,10 @@ export function seekState<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ReadableToken<T, K> | undefined
 
-export function seekState<M extends MoleculeConstructor>(
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): MoleculeToken<M> | undefined
-
 export function seekState(
-	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any>,
 	key: Canonical,
-): MoleculeToken<any> | ReadableToken<any> | undefined {
-	if (token.type === `molecule_family`) {
-		return seekInStore(IMPLICIT.STORE, token, key)
-	}
+): ReadableToken<any> | undefined {
 	const state = seekInStore(IMPLICIT.STORE, token, key)
 	return state
 }