atom.io 0.14.8 → 0.15.0

package/README.md

@@ -49,8 +49,13 @@ bun i atom.io
   <a aria-label="NPM version" href="https://www.npmjs.com/package/atom.io">
     <img alt="NPM Version" src="https://img.shields.io/npm/v/atom.io?style=for-the-badge&labelColor=333">
   </a>
+  <a aria-label="Coverage" href="https://coveralls.io/github/jeremybanka/wayforge">
+    <img alt="Coverage" src="https://img.shields.io/coverallsCoverage/github/jeremybanka/wayforge?style=for-the-badge&labelColor=333">
+  </a>
+
 </p>
 
 
 
 
+

package/data/dist/index.cjs

@@ -285,263 +285,244 @@ var TRANSACTORS = { get: atom_io.getState, set: atom_io.setState };
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
 }
-function join(options, defaultContent, store = internal.IMPLICIT.STORE) {
-  const a = options.between[0];
-  const b = options.between[1];
-  const findRelatedKeysState = internal.createMutableAtomFamily(
-    {
-      key: `${options.key}/relatedKeys`,
-      default: () => new setRtx.SetRTX(),
-      mutable: true,
-      fromJson: (json) => new setRtx.SetRTX(json),
-      toJson: (set) => [...set]
-    },
-    store
-  );
-  const getRelatedKeys = ({ get }, key) => get(findRelatedKeysState(key));
-  const addRelation = (transactors, a2, b2) => {
-    const aKeys = getRelatedKeys(transactors, a2);
-    const bKeys = getRelatedKeys(transactors, b2);
-    if (aKeys) {
+var Join = class {
+  constructor(options, defaultContent, store = internal.IMPLICIT.STORE) {
+    this.transactors = TRANSACTORS;
+    const a = options.between[0];
+    const b = options.between[1];
+    const findRelatedKeysState = internal.createMutableAtomFamily(
+      {
+        key: `${options.key}/relatedKeys`,
+        default: () => new setRtx.SetRTX(),
+        mutable: true,
+        fromJson: (json) => new setRtx.SetRTX(json),
+        toJson: (set) => [...set]
+      },
+      store
+    );
+    const getRelatedKeys = ({ get }, key) => get(findRelatedKeysState(key));
+    const addRelation = (transactors, a2, b2) => {
+      const aKeys = getRelatedKeys(transactors, a2);
+      const bKeys = getRelatedKeys(transactors, b2);
       transactors.set(findRelatedKeysState(a2), aKeys.add(b2));
-    } else {
-      transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX([b2]));
-    }
-    if (bKeys) {
       transactors.set(findRelatedKeysState(b2), bKeys.add(a2));
-    } else {
-      transactors.set(findRelatedKeysState(b2), new setRtx.SetRTX([a2]));
-    }
-  };
-  const deleteRelation = (transactors, a2, b2) => {
-    const aKeys = getRelatedKeys(transactors, a2);
-    if (aKeys) {
+    };
+    const deleteRelation = (transactors, a2, b2) => {
+      const aKeys = getRelatedKeys(transactors, a2);
       aKeys.delete(b2);
       if (aKeys.size === 0) {
-        transactors.set(findRelatedKeysState(a2), void 0);
+        atom_io.dispose(findRelatedKeysState(a2));
       }
       const bKeys = getRelatedKeys(transactors, b2);
-      if (bKeys) {
-        bKeys.delete(a2);
-        if (bKeys.size === 0) {
-          transactors.set(findRelatedKeysState(b2), void 0);
-        }
+      bKeys.delete(a2);
+      if (bKeys.size === 0) {
+        atom_io.dispose(findRelatedKeysState(b2));
       }
-    }
-  };
-  const replaceRelationsSafely = (transactors, a2, bs) => {
-    const aRelations = getRelatedKeys(transactors, a2);
-    if (aRelations) {
+    };
+    const replaceRelationsSafely = (transactors, a2, bs) => {
+      const aRelations = getRelatedKeys(transactors, a2);
       for (const b2 of aRelations) {
         const bKeys = getRelatedKeys(transactors, b2);
         if (bKeys) {
           bKeys.delete(a2);
           if (bKeys.size === 0) {
-            transactors.set(findRelatedKeysState(b2), void 0);
+            atom_io.dispose(findRelatedKeysState(b2));
           }
         }
       }
-    }
-    transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
-    for (const b2 of bs) {
-      const bKeys = getRelatedKeys(transactors, b2);
-      if (bKeys) {
+      transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
+      for (const b2 of bs) {
+        const bKeys = getRelatedKeys(transactors, b2);
         bKeys.add(a2);
-      } else {
-        transactors.set(findRelatedKeysState(b2), new setRtx.SetRTX([a2]));
       }
-    }
-  };
-  const replaceRelationsUnsafely = (transactors, a2, bs) => {
-    transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
-    for (const b2 of bs) {
-      let bKeys = getRelatedKeys(transactors, b2);
-      if (bKeys) {
+    };
+    const replaceRelationsUnsafely = (transactors, a2, bs) => {
+      transactors.set(findRelatedKeysState(a2), new setRtx.SetRTX(bs));
+      for (const b2 of bs) {
+        const bKeys = getRelatedKeys(transactors, b2);
         bKeys.add(a2);
-      } else {
-        bKeys = new setRtx.SetRTX([a2]);
-        transactors.set(findRelatedKeysState(b2), bKeys);
       }
+    };
+    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 findContentState;
+    if (defaultContent) {
+      findContentState = internal.createRegularAtomFamily(
+        {
+          key: `${options.key}/content`,
+          default: defaultContent
+        },
+        store
+      );
+      const getContent = ({ get }, key) => get(findContentState(key));
+      const setContent = (transactors, key, content) => transactors.set(findContentState(key), content);
+      const deleteContent = (_, key) => atom_io.dispose(findContentState(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 has = (transactors, a2, b2) => {
-    var _a, _b;
-    const aKeys = getRelatedKeys(transactors, a2);
-    return b2 ? (_a = aKeys == null ? void 0 : aKeys.has(b2)) != null ? _a : false : ((_b = aKeys == null ? void 0 : aKeys.size) != null ? _b : 0) > 0;
-  };
-  const baseExternalStoreConfiguration = {
-    getRelatedKeys: (key) => getRelatedKeys(TRANSACTORS, key),
-    addRelation: (a2, b2) => addRelation(TRANSACTORS, a2, b2),
-    deleteRelation: (a2, b2) => deleteRelation(TRANSACTORS, a2, b2),
-    replaceRelationsSafely: (a2, bs) => replaceRelationsSafely(TRANSACTORS, a2, bs),
-    replaceRelationsUnsafely: (a2, bs) => replaceRelationsUnsafely(TRANSACTORS, a2, bs),
-    has: (a2, b2) => has(TRANSACTORS, a2, b2)
-  };
-  let externalStore;
-  let findContentState;
-  if (defaultContent) {
-    findContentState = internal.createAtomFamily(
+    const relations = new Junction(options, {
+      externalStore,
+      makeContentKey: (...args) => args.sort().join(`:`)
+    });
+    const createSingleKeyStateFamily = () => internal.createSelectorFamily(
       {
-        key: `${options.key}/content`,
-        default: defaultContent
+        key: `${options.key}/singleRelatedKey`,
+        get: (key) => ({ get }) => {
+          const relatedKeys = get(findRelatedKeysState(key));
+          for (const relatedKey of relatedKeys) {
+            return relatedKey;
+          }
+        }
       },
       store
     );
-    const getContent = ({ get }, key) => get(findContentState(key));
-    const setContent = (transactors, key, content) => transactors.set(findContentState(key), content);
-    const deleteContent = (transactors, key) => transactors.set(findContentState(key), void 0);
-    const externalStoreWithContentConfiguration = {
-      getContent: (contentKey) => {
-        const content = getContent(TRANSACTORS, contentKey);
-        return content;
-      },
-      setContent: (contentKey, content) => {
-        setContent(TRANSACTORS, contentKey, content);
+    const getMultipleKeyStateFamily = () => internal.getJsonFamily(findRelatedKeysState, store);
+    const createSingleEntryStateFamily = () => internal.createSelectorFamily(
+      {
+        key: `${options.key}/singleRelatedEntry`,
+        get: (key) => ({ get }) => {
+          const relatedKeys = get(findRelatedKeysState(key));
+          for (const relatedKey of relatedKeys) {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            return [relatedKey, get(findContentState(contentKey))];
+          }
+        }
       },
-      deleteContent: (contentKey) => {
-        deleteContent(TRANSACTORS, contentKey);
-      }
-    };
-    externalStore = Object.assign(
-      baseExternalStoreConfiguration,
-      externalStoreWithContentConfiguration
+      store
     );
-  } else {
-    externalStore = baseExternalStoreConfiguration;
-  }
-  const relations = new Junction(options, {
-    externalStore,
-    makeContentKey: (...args) => args.sort().join(`:`)
-  });
-  const createSingleKeyStateFamily = () => internal.createSelectorFamily(
-    {
-      key: `${options.key}/singleRelatedKey`,
-      get: (key) => ({ get }) => {
-        const relatedKeys = get(findRelatedKeysState(key));
-        for (const relatedKey of relatedKeys) {
-          return relatedKey;
-        }
-      }
-    },
-    store
-  );
-  const getMultipleKeyStateFamily = () => internal.getJsonFamily(findRelatedKeysState, store);
-  const createSingleEntryStateFamily = () => internal.createSelectorFamily(
-    {
-      key: `${options.key}/singleRelatedEntry`,
-      get: (key) => ({ get }) => {
-        const relatedKeys = get(findRelatedKeysState(key));
-        for (const relatedKey of relatedKeys) {
-          const contentKey = relations.makeContentKey(key, relatedKey);
-          return [relatedKey, get(findContentState(contentKey))];
+    const getMultipleEntryStateFamily = () => internal.createSelectorFamily(
+      {
+        key: `${options.key}/multipleRelatedEntries`,
+        get: (key) => ({ get }) => {
+          const relatedKeys = get(findRelatedKeysState(key));
+          return [...relatedKeys].map((relatedKey) => {
+            const contentKey = relations.makeContentKey(key, relatedKey);
+            return [relatedKey, get(findContentState(contentKey))];
+          });
         }
-      }
-    },
-    store
-  );
-  const getMultipleEntryStateFamily = () => internal.createSelectorFamily(
-    {
-      key: `${options.key}/multipleRelatedEntries`,
-      get: (key) => ({ get }) => {
-        const relatedKeys = get(findRelatedKeysState(key));
-        return [...relatedKeys].map((relatedKey) => {
-          const contentKey = relations.makeContentKey(key, relatedKey);
-          return [relatedKey, get(findContentState(contentKey))];
-        });
-      }
-    },
-    store
-  );
-  switch (options.cardinality) {
-    case `1:1`: {
-      const findSingleRelatedKeyState = createSingleKeyStateFamily();
-      const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-      const stateKeyB = `${b}KeyOf${capitalize(a)}`;
-      const findStateBase = {
-        [stateKeyA]: findSingleRelatedKeyState,
-        [stateKeyB]: findSingleRelatedKeyState
-      };
-      let findState;
-      if (defaultContent) {
-        const findSingleRelatedEntryState = createSingleEntryStateFamily();
-        const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-        const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
-        const findStateWithContent = {
-          [entriesStateKeyA]: findSingleRelatedEntryState,
-          [entriesStateKeyB]: findSingleRelatedEntryState
+      },
+      store
+    );
+    switch (options.cardinality) {
+      case `1:1`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const findStateBase = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findSingleRelatedKeyState
         };
-        findState = Object.assign(findStateBase, findStateWithContent);
-      } else {
-        findState = findStateBase;
+        let findState;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const findStateWithContent = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findSingleRelatedEntryState
+          };
+          findState = Object.assign(findStateBase, findStateWithContent);
+        } else {
+          findState = findStateBase;
+        }
+        this.relations = relations;
+        this.findState = findState;
+        break;
       }
-      return {
-        relations,
-        findState
-      };
-    }
-    case `1:n`: {
-      const findSingleRelatedKeyState = createSingleKeyStateFamily();
-      const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-      const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-      const stateKeyB = `${b}KeysOf${capitalize(a)}`;
-      const findStateBase = {
-        [stateKeyA]: findSingleRelatedKeyState,
-        [stateKeyB]: findMultipleRelatedKeysState
-      };
-      let findState;
-      if (defaultContent) {
-        const findSingleRelatedEntryState = createSingleEntryStateFamily();
-        const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-        const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-        const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
-        const findStateWithContent = {
-          [entriesStateKeyA]: findSingleRelatedEntryState,
-          [entriesStateKeyB]: findMultipleRelatedEntriesState
+      case `1:n`: {
+        const findSingleRelatedKeyState = createSingleKeyStateFamily();
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const findStateBase = {
+          [stateKeyA]: findSingleRelatedKeyState,
+          [stateKeyB]: findMultipleRelatedKeysState
         };
-        findState = Object.assign(findStateBase, findStateWithContent);
-      } else {
-        findState = findStateBase;
+        let findState;
+        if (defaultContent) {
+          const findSingleRelatedEntryState = createSingleEntryStateFamily();
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const findStateWithContent = {
+            [entriesStateKeyA]: findSingleRelatedEntryState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          findState = Object.assign(findStateBase, findStateWithContent);
+        } else {
+          findState = findStateBase;
+        }
+        this.relations = relations;
+        this.findState = findState;
+        break;
       }
-      return {
-        relations,
-        findState
-      };
-    }
-    case `n:n`: {
-      const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-      const stateKeyA = `${a}KeysOf${capitalize(b)}`;
-      const stateKeyB = `${b}KeysOf${capitalize(a)}`;
-      const findStateBase = {
-        [stateKeyA]: findMultipleRelatedKeysState,
-        [stateKeyB]: findMultipleRelatedKeysState
-      };
-      let findState;
-      if (defaultContent) {
-        const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-        const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
-        const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
-        const findStateWithContent = {
-          [entriesStateKeyA]: findMultipleRelatedEntriesState,
-          [entriesStateKeyB]: findMultipleRelatedEntriesState
+      default: {
+        const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
+        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
+        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const findStateBase = {
+          [stateKeyA]: findMultipleRelatedKeysState,
+          [stateKeyB]: findMultipleRelatedKeysState
         };
-        findState = Object.assign(findStateBase, findStateWithContent);
-      } else {
-        findState = findStateBase;
+        let findState;
+        if (defaultContent) {
+          const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
+          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
+          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const findStateWithContent = {
+            [entriesStateKeyA]: findMultipleRelatedEntriesState,
+            [entriesStateKeyB]: findMultipleRelatedEntriesState
+          };
+          findState = Object.assign(findStateBase, findStateWithContent);
+        } else {
+          findState = findStateBase;
+        }
+        this.relations = relations;
+        this.findState = findState;
       }
-      return {
-        relations,
-        findState
-      };
     }
-    default:
-      throw new Error(`Invalid cardinality: ${options.cardinality}`);
   }
+  transact(transactors, run) {
+    this.transactors = transactors;
+    run(this);
+    this.transactors = TRANSACTORS;
+  }
+};
+function join(options, defaultContent, store = internal.IMPLICIT.STORE) {
+  return new Join(options, defaultContent, store);
 }
 var capitalize2 = (str) => str[0].toUpperCase() + str.slice(1);
 function struct(options, store = internal.IMPLICIT.STORE) {
   const atoms = Object.keys(options.default).reduce((acc, key) => {
     const atomName = options.key + capitalize2(key) + `State`;
-    acc[atomName] = internal.createAtom(
+    acc[atomName] = internal.createRegularAtom(
       {
         key: `${options.key}.${key}`,
         default: options.default[key]
@@ -571,7 +552,7 @@ var nameFamily = (topKey, subKey) => `find` + capitalize3(topKey) + capitalize3(
 function structFamily(options) {
   const atoms = Object.keys(options.default).reduce((acc, subKey) => {
     const atomFamilyName = nameFamily(options.key, subKey);
-    acc[atomFamilyName] = internal.createAtomFamily(
+    acc[atomFamilyName] = internal.createRegularAtomFamily(
       {
         key: `${options.key}.${subKey}`,
         default: options.default[subKey]
@@ -605,6 +586,7 @@ function until(loadable, fallback) {
   return loadable;
 }
 
+exports.Join = Join;
 exports.dict = dict;
 exports.join = join;
 exports.struct = struct;