atom.io 0.18.2 → 0.19.0

package/dist/chunk-7ZR244C2.js

@@ -0,0 +1,489 @@
+import { Junction } from './chunk-WX2NCOZR.js';
+import { dispose } from 'atom.io';
+import { getFromStore, setIntoStore, findInStore, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { SetRTX } from 'atom.io/transceivers/set-rtx';
+
+function capitalize(string) {
+  return string[0].toUpperCase() + string.slice(1);
+}
+var Join = class _Join {
+  transact(transactors, run) {
+    const originalTransactors = this.transactors;
+    this.transactors = transactors;
+    run(this);
+    this.transactors = originalTransactors;
+  }
+  in(store) {
+    const key = store.config.name;
+    const alternate = this.alternates.get(key);
+    if (alternate) {
+      return alternate;
+    }
+    const join2 = new _Join(this.options, this.defaultContent, store);
+    this.alternates.set(key, join2);
+    join2.alternates = this.alternates;
+    return join2;
+  }
+  constructor(options, defaultContent, store = IMPLICIT.STORE) {
+    this.options = options;
+    this.defaultContent = defaultContent;
+    this.alternates = /* @__PURE__ */ new Map();
+    this.alternates.set(store.config.name, this);
+    this.transactors = {
+      get: (token) => getFromStore(token, store),
+      set: (token, value) => setIntoStore(token, value, store),
+      find: (token, key) => findInStore(token, key, store)
+    };
+    const a = options.between[0];
+    const b = options.between[1];
+    const relatedKeysAtoms = createMutableAtomFamily(
+      {
+        key: `${options.key}/relatedKeys`,
+        default: () => new SetRTX(),
+        mutable: true,
+        fromJson: (json) => SetRTX.fromJSON(json),
+        toJson: (set) => set.toJSON()
+      },
+      store
+    );
+    this.core = { findRelatedKeysState: relatedKeysAtoms };
+    const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
+    const addRelation = (transactors, a2, b2) => {
+      const { set, find } = transactors;
+      const aKeysState = find(relatedKeysAtoms, a2);
+      const bKeysState = find(relatedKeysAtoms, b2);
+      set(aKeysState, (aKeys) => aKeys.add(b2));
+      set(bKeysState, (bKeys) => bKeys.add(a2));
+    };
+    const deleteRelation = (transactors, a2, b2) => {
+      const { find, set } = transactors;
+      const aKeysState = find(relatedKeysAtoms, a2);
+      const bKeysState = find(relatedKeysAtoms, b2);
+      set(aKeysState, (aKeys) => (aKeys.delete(b2), aKeys));
+      set(bKeysState, (bKeys) => (bKeys.delete(a2), bKeys));
+    };
+    const replaceRelationsSafely = (transactors, a2, newRelationsOfA) => {
+      const { find, get, set } = transactors;
+      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const currentRelationsOfA = get(relationsOfAState);
+      for (const currentRelationB of currentRelationsOfA) {
+        const remainsRelated = newRelationsOfA.includes(currentRelationB);
+        if (remainsRelated) {
+          continue;
+        }
+        const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
+        set(relationsOfBState, (relationsOfB) => {
+          relationsOfB.delete(a2);
+          return relationsOfB;
+        });
+      }
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          nextRelationsOfA.clear();
+          for (const newRelationB of newRelationsOfA) {
+            const relationsOfB = getRelatedKeys(transactors, newRelationB);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a2);
+            if (this.relations.cardinality === `1:n`) {
+              for (const previousOwner of relationsOfB) {
+                if (previousOwner === a2) {
+                  continue;
+                }
+                const previousOwnerRelations = getRelatedKeys(
+                  transactors,
+                  previousOwner
+                );
+                previousOwnerRelations.delete(newRelationB);
+              }
+              if (!newRelationBIsAlreadyRelated && relationsOfB.size > 0) {
+                relationsOfB.clear();
+              }
+            }
+            if (!newRelationBIsAlreadyRelated) {
+              relationsOfB.add(a2);
+            }
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+    };
+    const replaceRelationsUnsafely = (transactors, a2, newRelationsOfA) => {
+      const { find, set } = transactors;
+      const relationsOfAState = find(relatedKeysAtoms, a2);
+      set(relationsOfAState, (relationsOfA) => {
+        relationsOfA.transaction((nextRelationsOfA) => {
+          for (const newRelationB of newRelationsOfA) {
+            nextRelationsOfA.add(newRelationB);
+          }
+          return true;
+        });
+        return relationsOfA;
+      });
+      for (const newRelationB of newRelationsOfA) {
+        const newRelationsBState = find(relatedKeysAtoms, newRelationB);
+        set(newRelationsBState, (newRelationsB) => {
+          newRelationsB.add(a2);
+          return newRelationsB;
+        });
+      }
+      return true;
+    };
+    const has = (transactors, a2, b2) => {
+      const aKeys = getRelatedKeys(transactors, a2);
+      return b2 ? aKeys.has(b2) : aKeys.size > 0;
+    };
+    const baseExternalStoreConfiguration = {
+      getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
+      addRelation: (a2, b2) => addRelation(this.transactors, a2, b2),
+      deleteRelation: (a2, b2) => deleteRelation(this.transactors, a2, b2),
+      replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(this.transactors, a2, bs),
+      replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(this.transactors, a2, bs),
+      has: (a2, b2) => has(this.transactors, a2, b2)
+    };
+    let externalStore;
+    let contentAtoms;
+    if (defaultContent) {
+      contentAtoms = createRegularAtomFamily(
+        {
+          key: `${options.key}/content`,
+          default: defaultContent
+        },
+        store
+      );
+      const getContent = ({ find, get }, key) => get(find(contentAtoms, key));
+      const setContent = ({ find, set }, key, content) => set(find(contentAtoms, key), content);
+      const deleteContent = ({ find }, key) => dispose(find(contentAtoms, key));
+      const externalStoreWithContentConfiguration = {
+        getContent: (contentKey) => {
+          const content = getContent(this.transactors, contentKey);
+          return content;
+        },
+        setContent: (contentKey, content) => {
+          setContent(this.transactors, contentKey, content);
+        },
+        deleteContent: (contentKey) => {
+          deleteContent(this.transactors, contentKey);
+        }
+      };
+      externalStore = Object.assign(
+        baseExternalStoreConfiguration,
+        externalStoreWithContentConfiguration
+      );
+    } else {
+      externalStore = baseExternalStoreConfiguration;
+    }
+    const relations = new Junction(options, {
+      externalStore,
+      makeContentKey: (...args) => args.sort().join(`:`)
+    });
+    const createSingleKeyStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedKey`,
+        get: (key) => ({ find, get }) => {
+          const relatedKeysState = find(relatedKeysAtoms, key);
+          const relatedKeys = get(relatedKeysState);
+          for (const relatedKey of relatedKeys) {
+            return relatedKey;
+          }
+          return null;
+        }
+      },
+      store
+    );
+    const getMultipleKeyStateFamily = () => {
+      return createSelectorFamily(
+        {
+          key: `${options.key}/multipleRelatedKeys`,
+          get: (key) => ({ find, get }) => {
+            const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+            const jsonState = find(jsonFamily, key);
+            const json = get(jsonState);
+            return json.members;
+          }
+        },
+        store
+      );
+    };
+    const createSingleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedEntry`,
+        get: (key) => ({ find, get }) => {
+          const relatedKeysState = find(relatedKeysAtoms, key);
+          const relatedKeys = get(relatedKeysState);
+          for (const relatedKey of relatedKeys) {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = find(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          }
+          return null;
+        }
+      },
+      store
+    );
+    const getMultipleEntryStateFamily = () => createSelectorFamily(
+      {
+        key: `${options.key}/multipleRelatedEntries`,
+        get: (key) => ({ find, get }) => {
+          const jsonFamily = getJsonFamily(relatedKeysAtoms, store);
+          const json = get(jsonFamily(key));
+          return json.members.map((relatedKey) => {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            const contentState = find(contentAtoms, contentKey);
+            const content = get(contentState);
+            return [relatedKey, content];
+          });
+        }
+      },
+      store
+    );
+    switch (options.cardinality) {
+      case `1:1`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findSingleRelatedKeyState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findSingleRelatedEntryState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      case `1:n`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+        break;
+      }
+      default: {
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const baseStates = {
+          [stateKeyA]: findMultipleRelatedKeysState,
+          [stateKeyB]: findMultipleRelatedKeysState
+        };
+        let states;
+        if (defaultContent) {
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const contentStates = {
+            [entriesStateKeyA]: findMultipleRelatedEntriesState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          states = Object.assign(baseStates, contentStates);
+        } else {
+          states = baseStates;
+        }
+        this.relations = relations;
+        this.states = states;
+      }
+    }
+  }
+};
+function join(options, defaultContent, store = IMPLICIT.STORE) {
+  const joins = getJoinMap(store);
+  joins.set(options.key, new Join(options, defaultContent, store));
+  const token = {
+    key: options.key,
+    type: `join`,
+    a: options.between[0],
+    b: options.between[1],
+    cardinality: options.cardinality
+  };
+  return token;
+}
+function getJoinMap(store) {
+  if (`joins` in store && store.joins instanceof Map) {
+    return store.joins;
+  }
+  const joins = /* @__PURE__ */ new Map();
+  store.joins = joins;
+  return joins;
+}
+function getJoin(token, store) {
+  var _a;
+  const joinMap = getJoinMap(store);
+  let join2 = joinMap.get(token.key);
+  if (join2 === void 0) {
+    const rootJoinMap = getJoinMap(IMPLICIT.STORE);
+    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (join2 === void 0) {
+      throw new Error(
+        `Join "${token.key}" not found in store "${store.config.name}"`
+      );
+    }
+    joinMap.set(token.key, join2);
+  }
+  return join2;
+}
+function findRelationsInStore(token, key, store) {
+  const join2 = getJoin(token, store);
+  let relations;
+  switch (token.cardinality) {
+    case `1:1`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keyBA]() {
+          const familyBA = join2.states[keyBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entryBA]() {
+            const familyBA = join2.states[entryBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `1:n`: {
+      const keyAB = `${token.a}KeyOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keyAB]() {
+          const familyAB = join2.states[keyAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
+      if (entryAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entryAB]() {
+            const familyAB = join2.states[entryAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+      break;
+    }
+    case `n:n`: {
+      const keysAB = `${token.a}KeysOf${capitalize(token.b)}`;
+      const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
+      relations = {
+        get [keysAB]() {
+          const familyAB = join2.states[keysAB];
+          const state = findInStore(familyAB, key, store);
+          return state;
+        },
+        get [keysBA]() {
+          const familyBA = join2.states[keysBA];
+          const state = findInStore(familyBA, key, store);
+          return state;
+        }
+      };
+      const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
+      if (entriesAB in join2.states) {
+        const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
+        Object.assign(relations, {
+          get [entriesAB]() {
+            const familyAB = join2.states[entriesAB];
+            const state = findInStore(familyAB, key, store);
+            return state;
+          },
+          get [entriesBA]() {
+            const familyBA = join2.states[entriesBA];
+            const state = findInStore(familyBA, key, store);
+            return state;
+          }
+        });
+      }
+    }
+  }
+  return relations;
+}
+function findRelations(token, key) {
+  return findRelationsInStore(token, key, IMPLICIT.STORE);
+}
+function editRelationsInStore(token, change, store) {
+  const join2 = getJoin(token, store);
+  const target = newest(store);
+  if (isChildStore(target)) {
+    const { transactors } = target.transactionMeta;
+    join2.transact(transactors, ({ relations }) => {
+      change(relations);
+    });
+  } else {
+    change(join2.relations);
+  }
+}
+function editRelations(token, change) {
+  editRelationsInStore(token, change, IMPLICIT.STORE);
+}
+function getInternalRelationsFromStore(token, store) {
+  const join2 = getJoin(token, store);
+  const family = join2.core.findRelatedKeysState;
+  return family;
+}
+function getInternalRelations(token) {
+  return getInternalRelationsFromStore(token, IMPLICIT.STORE);
+}
+
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join };

package/dist/{chunk-A4ZCNKWQ.js → chunk-BWWVY5O5.js}

@@ -14,5 +14,3 @@ var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, on
 var lazyLocalStorageEffect = persistAtom(window.localStorage)(JSON);
 
 export { lazyLocalStorageEffect };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-A4ZCNKWQ.js.map

package/dist/{chunk-NYCVSXQB.js → chunk-CVBEVTM5.js}

@@ -177,5 +177,3 @@ var delve = (obj, path) => {
 };
 
 export { addTo, become, comprises, delve, doNothing, doesExtend, entriesToRecord, fallback, hasExactProperties, ifDefined, isArray, isEmptyArray, isEmptyObject, isModifier, isOneOf, isPlainObject, isRecord, map, mapObject, pipe, raiseError, recordToEntries, sprawl, treeShake };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-NYCVSXQB.js.map

package/dist/{chunk-3J2EGSBE.js → chunk-O47EQUM6.js}

@@ -1,4 +1,4 @@
-import { lazyLocalStorageEffect } from './chunk-A4ZCNKWQ.js';
+import { lazyLocalStorageEffect } from './chunk-BWWVY5O5.js';
 import * as AtomIO from 'atom.io';
 
 var myIdState__INTERNAL = AtomIO.atom({
@@ -27,5 +27,3 @@ var confirmedUpdateQueue = AtomIO.atom(
 );
 
 export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-3J2EGSBE.js.map

package/dist/{chunk-PZLG2HP3.js → chunk-U2IICNHQ.js}

@@ -32,5 +32,3 @@ var __objRest = (source, exclude) => {
 };
 
 export { __objRest, __restKey, __spreadProps, __spreadValues };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-PZLG2HP3.js.map

package/dist/{chunk-XACXFU3B.js → chunk-VAE5OCKN.js}

@@ -42,5 +42,3 @@ var isPrimitive = (input) => {
 };
 
 export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-XACXFU3B.js.map

package/dist/{chunk-NYTGCPHB.js → chunk-WX2NCOZR.js}

@@ -257,5 +257,3 @@ var Junction = class {
 };
 
 export { Junction };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-NYTGCPHB.js.map

package/dist/{chunk-IZHOMSXA.js → chunk-YDOGCZ53.js}

@@ -327,5 +327,3 @@ function syncContinuity(continuity, socket, store) {
 }
 
 export { syncContinuity };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-IZHOMSXA.js.map

package/dist/index.cjs

@@ -177,5 +177,3 @@ exports.subscribe = subscribe;
 exports.timeline = timeline;
 exports.transaction = transaction;
 exports.undo = undo;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import './chunk-PZLG2HP3.js';
+import './chunk-U2IICNHQ.js';
 import * as Internal from 'atom.io/internal';
 import { createStandaloneAtom, IMPLICIT, createAtomFamily, findInStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 
@@ -136,5 +136,3 @@ function belongsTo(family, unknownToken) {
 }
 
 export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, dispose, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/internal/dist/index.cjs

@@ -2584,5 +2584,3 @@ exports.traceSelectorAtoms = traceSelectorAtoms;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
 exports.withdrawOrCreate = withdrawOrCreate;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/internal/dist/index.js

@@ -1,5 +1,5 @@
-import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
+import { Junction } from '../../dist/chunk-WX2NCOZR.js';
+import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
 import { stringifyJson, selectJson, parseJson, selectJsonFamily } from 'atom.io/json';
 import { AtomIOLogger } from 'atom.io';
 
@@ -2224,5 +2224,3 @@ function getEpochNumberOfAction(transactionKey, store) {
 var TRANSACTION_PHASES = [`idle`, `building`, `applying`];
 
 export { FamilyTracker, Future, IMPLICIT, LazyMap, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/introspection/dist/index.cjs

@@ -331,5 +331,3 @@ var attachIntrospectionStates = (store = Internal__namespace.IMPLICIT.STORE) =>
 };
 
 exports.attachIntrospectionStates = attachIntrospectionStates;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/introspection/dist/index.js

@@ -1,4 +1,4 @@
-import { __spreadValues, __spreadProps } from '../../dist/chunk-PZLG2HP3.js';
+import { __spreadValues, __spreadProps } from '../../dist/chunk-U2IICNHQ.js';
 import * as Internal from 'atom.io/internal';
 import { createRegularAtom, newest, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
 
@@ -292,5 +292,3 @@ var attachIntrospectionStates = (store = Internal.IMPLICIT.STORE) => {
 };
 
 export { attachIntrospectionStates };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/json/dist/index.cjs

@@ -86,5 +86,3 @@ exports.selectJson = selectJson;
 exports.selectJsonFamily = selectJsonFamily;
 exports.stringSetJsonInterface = stringSetJsonInterface;
 exports.stringifyJson = stringifyJson;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/json/dist/index.js

@@ -1,6 +1,6 @@
-import { parseJson } from '../../dist/chunk-XACXFU3B.js';
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-XACXFU3B.js';
-import '../../dist/chunk-PZLG2HP3.js';
+import { parseJson } from '../../dist/chunk-VAE5OCKN.js';
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-VAE5OCKN.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import { createStandaloneSelector, IMPLICIT, createSelectorFamily } from 'atom.io/internal';
 
 var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
@@ -34,5 +34,3 @@ function selectJsonFamily(atomFamily, transform, store = IMPLICIT.STORE) {
 }
 
 export { selectJson, selectJsonFamily };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "atom.io",
-	"version": "0.18.2",
+	"version": "0.19.0",
 	"description": "Composable and testable reactive data library.",
 	"homepage": "https://atom.io.fyi",
 	"sideEffects": false,
@@ -78,7 +78,7 @@
 		"@testing-library/react": "14.2.1",
 		"@types/http-proxy": "1.17.14",
 		"@types/npmlog": "7.0.0",
-		"@types/react": "18.2.61",
+		"@types/react": "18.2.62",
 		"@types/tmp": "0.2.6",
 		"@vitest/coverage-v8": "1.3.1",
 		"@vitest/ui": "1.3.1",
@@ -100,7 +100,7 @@
 		"tmp": "0.2.3",
 		"tsup": "8.0.2",
 		"typescript": "5.3.3",
-		"vite": "5.1.4",
+		"vite": "5.1.5",
 		"vite-tsconfig-paths": "4.3.1",
 		"vitest": "1.3.1"
 	},

package/react/dist/index.cjs

@@ -89,5 +89,3 @@ exports.useI = useI;
 exports.useJSON = useJSON;
 exports.useO = useO;
 exports.useTL = useTL;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/react/dist/index.js

@@ -1,4 +1,4 @@
-import '../../dist/chunk-PZLG2HP3.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import { IMPLICIT, findInStore, setIntoStore, subscribeToState, getFromStore, getJsonToken, withdraw, subscribeToTimeline } from 'atom.io/internal';
 import * as React5 from 'react';
 import { jsx } from 'react/jsx-runtime';
@@ -62,5 +62,3 @@ function useTL(token) {
 }
 
 export { StoreContext, StoreProvider, useI, useJSON, useO, useTL };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map