atom.io 0.27.4 → 0.28.0

package/dist/chunk-EUVKUTW3.js

@@ -0,0 +1,89 @@
+import { createWritableSelectorFamily } from './chunk-BX3MTH2Z.js';
+import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';
+
+// json/src/entries.ts
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+function toEntries(obj) {
+  return Object.entries(obj);
+}
+var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
+  return createStandaloneSelector(store, {
+    key: `${atom.key}:JSON`,
+    get: ({ get }) => transform.toJson(get(atom)),
+    set: ({ set }, newValue) => {
+      set(atom, transform.fromJson(newValue));
+    }
+  });
+};
+function selectJsonFamily(atomFamilyToken, transform, store = IMPLICIT.STORE) {
+  const jsonFamily = createWritableSelectorFamily(
+    store,
+    {
+      key: `${atomFamilyToken.key}:JSON`,
+      get: (key) => ({ seek, get }) => {
+        const existingState = seek(atomFamilyToken, key);
+        if (existingState) {
+          return transform.toJson(get(existingState));
+        }
+        const stringKey = stringifyJson(key);
+        const molecule = store.molecules.get(stringKey);
+        if (molecule) {
+          const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
+          return transform.toJson(get(atom));
+        }
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${stringKey}"`);
+        }
+        const newToken = initFamilyMemberInStore(store, atomFamilyToken, key);
+        return transform.toJson(get(newToken));
+      },
+      set: (key) => ({ seek, set }, newValue) => {
+        const existingState = seek(atomFamilyToken, key);
+        if (existingState) {
+          set(existingState, transform.fromJson(newValue));
+        } else {
+          const stringKey = stringifyJson(key);
+          const molecule = store.molecules.get(stringKey);
+          if (molecule) {
+            const atom = growMoleculeInStore(molecule, atomFamilyToken, store);
+            set(atom, transform.fromJson(newValue));
+          } else {
+            if (store.config.lifespan === `immortal`) {
+              throw new Error(`No molecule found for key "${stringKey}"`);
+            }
+            set(
+              initFamilyMemberInStore(store, atomFamilyToken, key),
+              transform.fromJson(newValue)
+            );
+          }
+        }
+      }
+    },
+    [`mutable`, `json`]
+  );
+  const atomFamily = withdraw(atomFamilyToken, store);
+  atomFamily.subject.subscribe(
+    `store=${store.config.name}::json-selector-family`,
+    (event) => {
+      if (event.token.family) {
+        seekInStore(store, jsonFamily, parseJson(event.token.family.subKey));
+      }
+    }
+  );
+  return jsonFamily;
+}
+
+// json/src/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_PROTOTYPES = [Array, Boolean, Number, Object, String];
+var isJson = (input) => {
+  if (input === null) return true;
+  if (input === void 0) return false;
+  const prototype = Object.getPrototypeOf(input);
+  return JSON_PROTOTYPES.includes(prototype);
+};
+
+export { fromEntries, isJson, parseJson, selectJson, selectJsonFamily, stringifyJson, toEntries };

package/dist/index.d.ts

@@ -341,6 +341,7 @@ declare class Silo {
     redo: typeof redo;
     moleculeFamily: typeof moleculeFamily;
     makeMolecule: typeof makeMolecule;
+    runTransaction: typeof runTransaction;
     constructor(config: Store[`config`], fromStore?: Store | null);
 }
 
@@ -355,9 +356,9 @@ type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
 }>;
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
 type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
-declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store): () => void;
-declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string, store?: Store): () => void;
-declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string, store?: Store): () => void;
+declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
 
 type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
 type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;

package/dist/index.js

@@ -1,30 +1,26 @@
 import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 
 function atom(options) {
-  return createStandaloneAtom(options, IMPLICIT.STORE);
+  return createStandaloneAtom(IMPLICIT.STORE, options);
 }
 function atomFamily(options) {
-  return createAtomFamily(options, IMPLICIT.STORE);
+  return createAtomFamily(IMPLICIT.STORE, options);
 }
 function disposeState(token, key) {
   if (key) {
-    Internal.disposeFromStore(token, key, Internal.IMPLICIT.STORE);
+    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
   } else {
-    Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
+    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token);
   }
 }
-function getState(token, key) {
-  if (key) {
-    return Internal.getFromStore(
-      token,
-      key,
-      Internal.IMPLICIT.STORE
-    );
+function getState(...params) {
+  if (params.length === 2) {
+    return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
   }
-  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
+  return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
 }
 
 // src/logger.ts
@@ -63,7 +59,7 @@ var AtomIOLogger = class {
   };
 };
 function moleculeFamily(options) {
-  return createMoleculeFamily(options, IMPLICIT.STORE);
+  return createMoleculeFamily(IMPLICIT.STORE, options);
 }
 function makeMolecule(context, family, key, ...params) {
   return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
@@ -77,16 +73,16 @@ function makeRootMolecule(key, store = IMPLICIT.STORE) {
   };
 }
 function selector(options) {
-  return createStandaloneSelector(options, IMPLICIT.STORE);
+  return createStandaloneSelector(IMPLICIT.STORE, options);
 }
 function selectorFamily(options) {
-  return createSelectorFamily(options, IMPLICIT.STORE);
+  return createSelectorFamily(IMPLICIT.STORE, options);
 }
-function setState(token, p1, p2) {
-  if (p2) {
-    Internal.setIntoStore(token, p1, p2, Internal.IMPLICIT.STORE);
+function setState(...params) {
+  if (params.length === 2) {
+    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
   } else {
-    Internal.setIntoStore(token, p1, Internal.IMPLICIT.STORE);
+    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
   }
 }
 var Silo = class {
@@ -106,65 +102,51 @@ var Silo = class {
   redo;
   moleculeFamily;
   makeMolecule;
+  runTransaction;
   constructor(config, fromStore = null) {
     const s = new Store(config, fromStore);
-    function _atom(options) {
-      return createStandaloneAtom(options, s);
-    }
-    function _atomFamily(options) {
-      return createAtomFamily(options, s);
-    }
     this.store = s;
-    this.atom = _atom;
-    this.atomFamily = _atomFamily;
-    this.selector = (options) => createStandaloneSelector(options, s);
-    this.selectorFamily = (options) => createSelectorFamily(options, s);
+    this.atom = (options) => createStandaloneAtom(s, options);
+    this.atomFamily = (options) => createAtomFamily(s, options);
+    this.selector = (options) => createStandaloneSelector(s, options);
+    this.selectorFamily = (options) => createSelectorFamily(s, options);
     this.transaction = (options) => createTransaction(options, s);
     this.timeline = (options) => createTimeline(options, s);
-    this.findState = (token, key) => findInStore(token, key, s);
-    this.getState = (...params) => getFromStore(...params, s);
+    this.findState = (...params) => findInStore(s, ...params);
+    this.getState = (...params) => getFromStore(s, ...params);
     this.setState = (...params) => {
-      setIntoStore(...params, s);
+      setIntoStore(s, ...params);
     };
     this.disposeState = (...params) => {
-      disposeFromStore(...params, s);
+      disposeFromStore(s, ...params);
     };
-    this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
+    this.subscribe = (...params) => subscribeInStore(s, ...params);
     this.undo = (token) => {
-      timeTravel(`undo`, token, s);
+      timeTravel(s, `undo`, token);
     };
     this.redo = (token) => {
-      timeTravel(`redo`, token, s);
+      timeTravel(s, `redo`, token);
     };
-    this.moleculeFamily = (...params) => {
-      return createMoleculeFamily(...params, s);
+    this.moleculeFamily = (options) => {
+      return createMoleculeFamily(s, options);
     };
     this.makeMolecule = (...params) => {
       return makeMoleculeInStore(s, ...params);
     };
+    this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
   }
 };
-function subscribe(token, handleUpdate, key = arbitrary(), store = IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-    case `readonly_selector`:
-    case `selector`:
-      return subscribeToState(token, handleUpdate, key, store);
-    case `transaction`:
-      return subscribeToTransaction(token, handleUpdate, key, store);
-    case `timeline`:
-      return subscribeToTimeline(token, handleUpdate, key, store);
-  }
+function subscribe(token, handleUpdate, key = arbitrary()) {
+  return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key);
 }
 var timeline = (options) => {
   return createTimeline(options, IMPLICIT.STORE);
 };
 var redo = (tl) => {
-  timeTravel(`redo`, tl, IMPLICIT.STORE);
+  timeTravel(IMPLICIT.STORE, `redo`, tl);
 };
 var undo = (tl) => {
-  timeTravel(`undo`, tl, IMPLICIT.STORE);
+  timeTravel(IMPLICIT.STORE, `undo`, tl);
 };
 function transaction(options) {
   return createTransaction(options, IMPLICIT.STORE);

package/ephemeral/dist/index.js

@@ -2,7 +2,7 @@ import '../../dist/chunk-XWL6SNVU.js';
 import { findInStore, IMPLICIT } from 'atom.io/internal';
 
 function findState(token, key) {
-  const state = findInStore(token, key, IMPLICIT.STORE);
+  const state = findInStore(IMPLICIT.STORE, token, key);
   return state;
 }
 

package/ephemeral/src/find-state.ts

@@ -92,6 +92,6 @@ export function findState(
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 ): ReadableToken<any> {
-	const state = findInStore(token, key, IMPLICIT.STORE)
+	const state = findInStore(IMPLICIT.STORE, token, key)
 	return state
 }

package/immortal/dist/index.js

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

package/immortal/src/seek-state.ts

@@ -65,8 +65,8 @@ export function seekState(
 	key: Canonical,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	if (token.type === `molecule_family`) {
-		return seekInStore(token, key, IMPLICIT.STORE)
+		return seekInStore(IMPLICIT.STORE, token, key)
 	}
-	const state = seekInStore(token, key, IMPLICIT.STORE)
+	const state = seekInStore(IMPLICIT.STORE, token, key)
 	return state
 }