atom.io 0.19.1 → 0.19.3

package/data/dist/index.cjs

@@ -190,16 +190,16 @@ var Junction = class {
     if (a === void 0 && typeof b === `string`) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        for (const a2 of bRelations) {
-          this.delete(a2, b);
+        for (const bRelation of bRelations) {
+          this.delete(bRelation, b);
         }
       }
     }
     if (typeof a === `string` && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        for (const b2 of aRelations) {
-          this.delete(a, b2);
+        for (const aRelation of aRelations) {
+          this.delete(a, aRelation);
         }
       }
     }
@@ -252,18 +252,18 @@ var Junction = class {
     if (a !== void 0 && b === void 0) {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
-        return [...aRelations].map((b2) => {
+        return [...aRelations].map((aRelation) => {
           var _a;
-          return [b2, (_a = this.getContent(a, b2)) != null ? _a : null];
+          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
         });
       }
     }
     if (a === void 0 && b !== void 0) {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
-        return [...bRelations].map((a2) => {
+        return [...bRelations].map((bRelation) => {
           var _a;
-          return [a2, (_a = this.getContent(a2, b)) != null ? _a : null];
+          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
         });
       }
     }
@@ -308,11 +308,13 @@ var Join = class _Join {
     this.alternates.set(store.config.name, this);
     this.transactors = {
       get: (token) => internal.getFromStore(token, store),
-      set: (token, value) => internal.setIntoStore(token, value, store),
+      set: (token, value) => {
+        internal.setIntoStore(token, value, store);
+      },
       find: (token, key) => internal.findInStore(token, key, store)
     };
-    const a = options.between[0];
-    const b = options.between[1];
+    const aSide = options.between[0];
+    const bSide = options.between[1];
     const relatedKeysAtoms = internal.createMutableAtomFamily(
       {
         key: `${options.key}/relatedKeys`,
@@ -325,23 +327,23 @@ var Join = class _Join {
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
     const getRelatedKeys = ({ find, get }, key) => get(find(relatedKeysAtoms, key));
-    const addRelation = (transactors, a2, b2) => {
+    const addRelation = (transactors, a, b) => {
       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 aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => aKeys.add(b));
+      set(bKeysState, (bKeys) => bKeys.add(a));
     };
-    const deleteRelation = (transactors, a2, b2) => {
+    const deleteRelation = (transactors, a, b) => {
       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 aKeysState = find(relatedKeysAtoms, a);
+      const bKeysState = find(relatedKeysAtoms, b);
+      set(aKeysState, (aKeys) => (aKeys.delete(b), aKeys));
+      set(bKeysState, (bKeys) => (bKeys.delete(a), bKeys));
     };
-    const replaceRelationsSafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsSafely = (transactors, a, newRelationsOfA) => {
       const { find, get, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       const currentRelationsOfA = get(relationsOfAState);
       for (const currentRelationB of currentRelationsOfA) {
         const remainsRelated = newRelationsOfA.includes(currentRelationB);
@@ -350,7 +352,7 @@ var Join = class _Join {
         }
         const relationsOfBState = find(relatedKeysAtoms, currentRelationB);
         set(relationsOfBState, (relationsOfB) => {
-          relationsOfB.delete(a2);
+          relationsOfB.delete(a);
           return relationsOfB;
         });
       }
@@ -359,10 +361,10 @@ var Join = class _Join {
           nextRelationsOfA.clear();
           for (const newRelationB of newRelationsOfA) {
             const relationsOfB = getRelatedKeys(transactors, newRelationB);
-            const newRelationBIsAlreadyRelated = relationsOfB.has(a2);
+            const newRelationBIsAlreadyRelated = relationsOfB.has(a);
             if (this.relations.cardinality === `1:n`) {
               for (const previousOwner of relationsOfB) {
-                if (previousOwner === a2) {
+                if (previousOwner === a) {
                   continue;
                 }
                 const previousOwnerRelations = getRelatedKeys(
@@ -376,7 +378,7 @@ var Join = class _Join {
               }
             }
             if (!newRelationBIsAlreadyRelated) {
-              relationsOfB.add(a2);
+              relationsOfB.add(a);
             }
             nextRelationsOfA.add(newRelationB);
           }
@@ -385,9 +387,9 @@ var Join = class _Join {
         return relationsOfA;
       });
     };
-    const replaceRelationsUnsafely = (transactors, a2, newRelationsOfA) => {
+    const replaceRelationsUnsafely = (transactors, a, newRelationsOfA) => {
       const { find, set } = transactors;
-      const relationsOfAState = find(relatedKeysAtoms, a2);
+      const relationsOfAState = find(relatedKeysAtoms, a);
       set(relationsOfAState, (relationsOfA) => {
         relationsOfA.transaction((nextRelationsOfA) => {
           for (const newRelationB of newRelationsOfA) {
@@ -400,23 +402,31 @@ var Join = class _Join {
       for (const newRelationB of newRelationsOfA) {
         const newRelationsBState = find(relatedKeysAtoms, newRelationB);
         set(newRelationsBState, (newRelationsB) => {
-          newRelationsB.add(a2);
+          newRelationsB.add(a);
           return newRelationsB;
         });
       }
       return true;
     };
-    const has = (transactors, a2, b2) => {
-      const aKeys = getRelatedKeys(transactors, a2);
-      return b2 ? aKeys.has(b2) : aKeys.size > 0;
+    const has = (transactors, a, b) => {
+      const aKeys = getRelatedKeys(transactors, a);
+      return b ? aKeys.has(b) : 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)
+      addRelation: (a, b) => {
+        addRelation(this.transactors, a, b);
+      },
+      deleteRelation: (a, b) => {
+        deleteRelation(this.transactors, a, b);
+      },
+      replaceRelationsSafely: (a, bs) => {
+        replaceRelationsSafely(this.transactors, a, bs);
+      },
+      replaceRelationsUnsafely: (a, bs) => {
+        replaceRelationsUnsafely(this.transactors, a, bs);
+      },
+      has: (a, b) => has(this.transactors, a, b)
     };
     let externalStore;
     let contentAtoms;
@@ -429,8 +439,12 @@ var Join = class _Join {
         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) => atom_io.dispose(find(contentAtoms, key));
+      const setContent = ({ find, set }, key, content) => {
+        set(find(contentAtoms, key), content);
+      };
+      const deleteContent = ({ find }, key) => {
+        atom_io.dispose(find(contentAtoms, key));
+      };
       const externalStoreWithContentConfiguration = {
         getContent: (contentKey) => {
           const content = getContent(this.transactors, contentKey);
@@ -518,8 +532,8 @@ var Join = class _Join {
     switch (options.cardinality) {
       case `1:1`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeyOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeyOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findSingleRelatedKeyState
@@ -527,8 +541,8 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntryOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntryOf${capitalize(aSide)}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findSingleRelatedEntryState
@@ -544,8 +558,8 @@ var Join = class _Join {
       case `1:n`: {
         const findSingleRelatedKeyState = createSingleKeyStateFamily();
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeyOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeyOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findSingleRelatedKeyState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -554,8 +568,10 @@ var Join = class _Join {
         if (defaultContent) {
           const findSingleRelatedEntryState = createSingleEntryStateFamily();
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntryOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntryOf${capitalize(bSide)}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findSingleRelatedEntryState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -570,8 +586,8 @@ var Join = class _Join {
       }
       default: {
         const findMultipleRelatedKeysState = getMultipleKeyStateFamily();
-        const stateKeyA = `${a}KeysOf${capitalize(b)}`;
-        const stateKeyB = `${b}KeysOf${capitalize(a)}`;
+        const stateKeyA = `${aSide}KeysOf${capitalize(bSide)}`;
+        const stateKeyB = `${bSide}KeysOf${capitalize(aSide)}`;
         const baseStates = {
           [stateKeyA]: findMultipleRelatedKeysState,
           [stateKeyB]: findMultipleRelatedKeysState
@@ -579,8 +595,12 @@ var Join = class _Join {
         let states;
         if (defaultContent) {
           const findMultipleRelatedEntriesState = getMultipleEntryStateFamily();
-          const entriesStateKeyA = `${a}EntriesOf${capitalize(b)}`;
-          const entriesStateKeyB = `${b}EntriesOf${capitalize(a)}`;
+          const entriesStateKeyA = `${aSide}EntriesOf${capitalize(
+            bSide
+          )}`;
+          const entriesStateKeyB = `${bSide}EntriesOf${capitalize(
+            aSide
+          )}`;
           const contentStates = {
             [entriesStateKeyA]: findMultipleRelatedEntriesState,
             [entriesStateKeyB]: findMultipleRelatedEntriesState
@@ -618,21 +638,21 @@ function getJoinMap(store) {
 function getJoin(token, store) {
   var _a;
   const joinMap = getJoinMap(store);
-  let join2 = joinMap.get(token.key);
-  if (join2 === void 0) {
+  let myJoin = joinMap.get(token.key);
+  if (myJoin === void 0) {
     const rootJoinMap = getJoinMap(internal.IMPLICIT.STORE);
-    join2 = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
-    if (join2 === void 0) {
+    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    if (myJoin === void 0) {
       throw new Error(
         `Join "${token.key}" not found in store "${store.config.name}"`
       );
     }
-    joinMap.set(token.key, join2);
+    joinMap.set(token.key, myJoin);
   }
-  return join2;
+  return myJoin;
 }
 function findRelationsInStore(token, key, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   let relations;
   switch (token.cardinality) {
     case `1:1`: {
@@ -640,27 +660,27 @@ function findRelationsInStore(token, key, store) {
       const keyBA = `${token.b}KeyOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = internal.findInStore(familyAB, key, store);
           return state;
         },
         get [keyBA]() {
-          const familyBA = join2.states[keyBA];
+          const familyBA = myJoin.states[keyBA];
           const state = internal.findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entryBA = `${token.b}EntryOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = internal.findInStore(familyAB, key, store);
             return state;
           },
           get [entryBA]() {
-            const familyBA = join2.states[entryBA];
+            const familyBA = myJoin.states[entryBA];
             const state = internal.findInStore(familyBA, key, store);
             return state;
           }
@@ -673,27 +693,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keyAB]() {
-          const familyAB = join2.states[keyAB];
+          const familyAB = myJoin.states[keyAB];
           const state = internal.findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = internal.findInStore(familyBA, key, store);
           return state;
         }
       };
       const entryAB = `${token.a}EntryOf${capitalize(token.b)}`;
-      if (entryAB in join2.states) {
+      if (entryAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entryAB]() {
-            const familyAB = join2.states[entryAB];
+            const familyAB = myJoin.states[entryAB];
             const state = internal.findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = internal.findInStore(familyBA, key, store);
             return state;
           }
@@ -706,27 +726,27 @@ function findRelationsInStore(token, key, store) {
       const keysBA = `${token.b}KeysOf${capitalize(token.a)}`;
       relations = {
         get [keysAB]() {
-          const familyAB = join2.states[keysAB];
+          const familyAB = myJoin.states[keysAB];
           const state = internal.findInStore(familyAB, key, store);
           return state;
         },
         get [keysBA]() {
-          const familyBA = join2.states[keysBA];
+          const familyBA = myJoin.states[keysBA];
           const state = internal.findInStore(familyBA, key, store);
           return state;
         }
       };
       const entriesAB = `${token.a}EntriesOf${capitalize(token.b)}`;
-      if (entriesAB in join2.states) {
+      if (entriesAB in myJoin.states) {
         const entriesBA = `${token.b}EntriesOf${capitalize(token.a)}`;
         Object.assign(relations, {
           get [entriesAB]() {
-            const familyAB = join2.states[entriesAB];
+            const familyAB = myJoin.states[entriesAB];
             const state = internal.findInStore(familyAB, key, store);
             return state;
           },
           get [entriesBA]() {
-            const familyBA = join2.states[entriesBA];
+            const familyBA = myJoin.states[entriesBA];
             const state = internal.findInStore(familyBA, key, store);
             return state;
           }
@@ -740,23 +760,23 @@ function findRelations(token, key) {
   return findRelationsInStore(token, key, internal.IMPLICIT.STORE);
 }
 function editRelationsInStore(token, change, store) {
-  const join2 = getJoin(token, store);
+  const myJoin = getJoin(token, store);
   const target = internal.newest(store);
   if (internal.isChildStore(target)) {
     const { transactors } = target.transactionMeta;
-    join2.transact(transactors, ({ relations }) => {
+    myJoin.transact(transactors, ({ relations }) => {
       change(relations);
     });
   } else {
-    change(join2.relations);
+    change(myJoin.relations);
   }
 }
 function editRelations(token, change) {
   editRelationsInStore(token, change, internal.IMPLICIT.STORE);
 }
 function getInternalRelationsFromStore(token, store) {
-  const join2 = getJoin(token, store);
-  const family = join2.core.findRelatedKeysState;
+  const myJoin = getJoin(token, store);
+  const family = myJoin.core.findRelatedKeysState;
   return family;
 }
 function getInternalRelations(token) {

package/data/dist/index.js

@@ -1,6 +1,6 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-7ZR244C2.js';
-import '../../dist/chunk-WX2NCOZR.js';
-import '../../dist/chunk-U2IICNHQ.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-MSCJWACE.js';
+import '../../dist/chunk-FTONNX2R.js';
+import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';
 
 function dict(findState, index, store = IMPLICIT.STORE) {

package/data/package.json

@@ -3,7 +3,7 @@
 	"type": "module",
 	"private": true,
 	"main": "dist/index.cjs",
-	"module": "dist/index.mjs",
+	"module": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"exports": {
 		".": {