atom.io 0.27.4 → 0.27.5

package/data/dist/index.js

@@ -5,19 +5,16 @@ import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
 function dict(family, index, store = IMPLICIT.STORE) {
-  return createStandaloneSelector(
-    {
-      key: `${family.key}Dict`,
-      get: ({ get }) => {
-        const keys = get(index);
-        return keys.reduce((acc, key) => {
-          acc[key] = get(findInStore(family, key, store));
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
+  return createStandaloneSelector(store, {
+    key: `${family.key}Dict`,
+    get: ({ get }) => {
+      const keys = get(index);
+      return keys.reduce((acc, key) => {
+        acc[key] = get(findInStore(store, family, key));
+        return acc;
+      }, {});
+    }
+  });
 }
 function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
@@ -61,15 +58,15 @@ var Join = class _Join {
     this.alternates.set(store.config.name, this);
     this.store.miscResources.set(`join:${options.key}`, this);
     this.toolkit = {
-      get: (...ps) => getFromStore(...ps, store),
+      get: (...ps) => getFromStore(store, ...ps),
       set: (...ps) => {
-        setIntoStore(...ps, store);
+        setIntoStore(store, ...ps);
       },
-      find: (token, key) => findInStore(token, key, store),
-      seek: (token, key) => seekInStore(token, key, store),
-      json: (token) => getJsonToken(token, store),
+      find: (...ps) => findInStore(store, ...ps),
+      seek: (...ps) => seekInStore(store, ...ps),
+      json: (token) => getJsonToken(store, token),
       dispose: (...ps) => {
-        disposeFromStore(...ps, store);
+        disposeFromStore(store, ...ps);
       }
     };
     this.retrieve = (token, key) => {
@@ -85,11 +82,12 @@ var Join = class _Join {
       if (store.config.lifespan === `immortal`) {
         throw new NotFoundError(token, key, store);
       }
-      return initFamilyMemberInStore(token, key, store);
+      return initFamilyMemberInStore(store, token, key);
     };
     const aSide = options.between[0];
     const bSide = options.between[1];
     const relatedKeysAtoms = createMutableAtomFamily(
+      store,
       {
         key: `${options.key}/relatedKeys`,
         default: () => new SetRTX(),
@@ -97,7 +95,6 @@ var Join = class _Join {
         fromJson: (json) => SetRTX.fromJSON(json),
         toJson: (set) => set.toJSON()
       },
-      store,
       [`join`, `relations`]
     );
     this.core = { findRelatedKeysState: relatedKeysAtoms };
@@ -228,11 +225,11 @@ var Join = class _Join {
     let contentMolecules;
     if (defaultContent) {
       contentAtoms = createRegularAtomFamily(
+        store,
         {
           key: `${options.key}/content`,
           default: defaultContent
         },
-        store,
         [`join`, `content`]
       );
       const joinToken = {
@@ -242,18 +239,15 @@ var Join = class _Join {
         b: options.between[1],
         cardinality: options.cardinality
       };
-      contentMolecules = createMoleculeFamily(
-        {
-          key: `${options.key}/content-molecules`,
-          new: class ContentMolecule {
-            constructor(toolkit, key) {
-              this.key = key;
-              toolkit.bond(joinToken, { as: null });
-            }
+      contentMolecules = createMoleculeFamily(store, {
+        key: `${options.key}/content-molecules`,
+        new: class ContentMolecule {
+          constructor(toolkit, key) {
+            this.key = key;
+            toolkit.bond(joinToken, { as: null });
           }
-        },
-        store
-      );
+        }
+      });
       const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
       const setContent = ({ set }, key, content) => {
         set(this.retrieve(contentAtoms, key), content);
@@ -309,6 +303,7 @@ var Join = class _Join {
       }
     });
     const createSingleKeyStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/singleRelatedKey`,
         get: (key) => ({ get }) => {
@@ -320,11 +315,11 @@ var Join = class _Join {
           return null;
         }
       },
-      store,
       [`join`, `keys`]
     );
     const getMultipleKeyStateFamily = () => {
       return createReadonlySelectorFamily(
+        store,
         {
           key: `${options.key}/multipleRelatedKeys`,
           get: (key) => ({ get }) => {
@@ -334,11 +329,11 @@ var Join = class _Join {
             return json.members;
           }
         },
-        store,
         [`join`, `keys`]
       );
     };
     const createSingleEntryStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/singleRelatedEntry`,
         get: (key) => ({ get }) => {
@@ -353,10 +348,10 @@ var Join = class _Join {
           return null;
         }
       },
-      store,
       [`join`, `entries`]
     );
     const getMultipleEntryStateFamily = () => createReadonlySelectorFamily(
+      store,
       {
         key: `${options.key}/multipleRelatedEntries`,
         get: (key) => ({ get }) => {
@@ -371,7 +366,6 @@ var Join = class _Join {
           });
         }
       },
-      store,
       [`join`, `entries`]
     );
     switch (options.cardinality) {
@@ -631,27 +625,24 @@ function struct(options, store = IMPLICIT.STORE) {
   const atoms = Object.keys(options.default).reduce((acc, key) => {
     const atomName = options.key + capitalize2(key) + `State`;
     acc[atomName] = createRegularAtom(
+      store,
       {
         key: `${options.key}.${key}`,
         default: options.default[key]
       },
-      void 0,
-      store
+      void 0
     );
     return acc;
   }, {});
-  const structState = createStandaloneSelector(
-    {
-      key: options.key,
-      get: ({ get }) => {
-        return Object.keys(options.default).reduce((acc, key) => {
-          acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
-          return acc;
-        }, {});
-      }
-    },
-    store
-  );
+  const structState = createStandaloneSelector(store, {
+    key: options.key,
+    get: ({ get }) => {
+      return Object.keys(options.default).reduce((acc, key) => {
+        acc[key] = get(atoms[options.key + capitalize2(key) + `State`]);
+        return acc;
+      }, {});
+    }
+  });
   return [atoms, structState];
 }
 var capitalize3 = (str) => str[0].toUpperCase() + str.slice(1);
@@ -659,29 +650,23 @@ 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] = createRegularAtomFamily(
-      {
-        key: `${options.key}.${subKey}`,
-        default: options.default[subKey]
-      },
-      IMPLICIT.STORE
-    );
+    acc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {
+      key: `${options.key}.${subKey}`,
+      default: options.default[subKey]
+    });
     return acc;
   }, {});
-  const findStructState = createSelectorFamily(
-    {
-      key: options.key,
-      get: (id) => ({ find, get }) => {
-        return Object.keys(options.default).reduce((acc, subKey) => {
-          acc[subKey] = get(
-            find(atoms[nameFamily(options.key, subKey)], id)
-          );
-          return acc;
-        }, {});
-      }
-    },
-    IMPLICIT.STORE
-  );
+  const findStructState = createSelectorFamily(IMPLICIT.STORE, {
+    key: options.key,
+    get: (id) => ({ find, get }) => {
+      return Object.keys(options.default).reduce((acc, subKey) => {
+        acc[subKey] = get(
+          find(atoms[nameFamily(options.key, subKey)], id)
+        );
+        return acc;
+      }, {});
+    }
+  });
   return [atoms, findStructState];
 }
 

package/data/src/dict.ts

@@ -18,17 +18,14 @@ export function dict<State, Key extends Canonical>(
 		| AtomIO.WritableSelectorToken<Key[]>,
 	store: Store = IMPLICIT.STORE,
 ): AtomIO.ReadonlySelectorToken<{ [K in stringified<Key>]: State }> {
-	return createStandaloneSelector(
-		{
-			key: `${family.key}Dict`,
-			get: ({ get }) => {
-				const keys = get(index)
-				return keys.reduce((acc, key) => {
-					acc[key] = get(findInStore(family, key, store))
-					return acc
-				}, {} as any)
-			},
+	return createStandaloneSelector(store, {
+		key: `${family.key}Dict`,
+		get: ({ get }) => {
+			const keys = get(index)
+			return keys.reduce((acc, key) => {
+				acc[key] = get(findInStore(store, family, key))
+				return acc
+			}, {} as any)
 		},
-		store,
-	)
+	})
 }

package/data/src/join.ts

@@ -197,15 +197,17 @@ export class Join<
 
 		this.toolkit = {
 			get: ((...ps: Parameters<typeof getState>) =>
-				getFromStore(...ps, store)) as typeof getState,
+				getFromStore(store, ...ps)) as typeof getState,
 			set: ((...ps: Parameters<typeof setState>) => {
-				setIntoStore(...ps, store)
+				setIntoStore(store, ...ps)
 			}) as typeof setState,
-			find: ((token, key) => findInStore(token, key, store)) as typeof findState,
-			seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
-			json: (token) => getJsonToken(token, store),
+			find: ((...ps: Parameters<typeof findState>) =>
+				findInStore(store, ...ps)) as typeof findState,
+			seek: ((...ps: Parameters<typeof seekState>) =>
+				seekInStore(store, ...ps)) as typeof seekState,
+			json: (token) => getJsonToken(store, token),
 			dispose: ((...ps: Parameters<typeof disposeState>) => {
-				disposeFromStore(...ps, store)
+				disposeFromStore(store, ...ps)
 			}) as typeof disposeState,
 		}
 		this.retrieve = ((
@@ -224,7 +226,7 @@ export class Join<
 			if (store.config.lifespan === `immortal`) {
 				throw new NotFoundError(token, key, store)
 			}
-			return initFamilyMemberInStore(token, key, store)
+			return initFamilyMemberInStore(store, token, key)
 		}) as typeof findState
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
@@ -233,6 +235,7 @@ export class Join<
 			SetRTXJson<string>,
 			string
 		>(
+			store,
 			{
 				key: `${options.key}/relatedKeys`,
 				default: () => new SetRTX(),
@@ -240,7 +243,6 @@ export class Join<
 				fromJson: (json) => SetRTX.fromJSON(json),
 				toJson: (set) => set.toJSON(),
 			},
-			store,
 			[`join`, `relations`],
 		)
 		this.core = { findRelatedKeysState: relatedKeysAtoms }
@@ -396,11 +398,11 @@ export class Join<
 		>
 		if (defaultContent) {
 			contentAtoms = createRegularAtomFamily<Content, string>(
+				store,
 				{
 					key: `${options.key}/content`,
 					default: defaultContent,
 				},
-				store,
 				[`join`, `content`],
 			)
 			const joinToken = {
@@ -410,20 +412,17 @@ export class Join<
 				b: options.between[1],
 				cardinality: options.cardinality,
 			} as const satisfies JoinToken<ASide, BSide, Cardinality, Content>
-			contentMolecules = createMoleculeFamily(
-				{
-					key: `${options.key}/content-molecules`,
-					new: class ContentMolecule {
-						public constructor(
-							toolkit: CtorToolkit<string>,
-							public key: string,
-						) {
-							toolkit.bond(joinToken, { as: null } as any)
-						}
-					},
+			contentMolecules = createMoleculeFamily(store, {
+				key: `${options.key}/content-molecules`,
+				new: class ContentMolecule {
+					public constructor(
+						toolkit: CtorToolkit<string>,
+						public key: string,
+					) {
+						toolkit.bond(joinToken, { as: null } as any)
+					}
 				},
-				store,
-			)
+			})
 			const getContent: Read<(key: string) => Content | null> = ({ get }, key) =>
 				get(this.retrieve(contentAtoms, key))
 			const setContent: Write<(key: string, content: Content) => void> = (
@@ -490,6 +489,7 @@ export class Join<
 
 		const createSingleKeyStateFamily = () =>
 			createReadonlySelectorFamily<string | null, string>(
+				store,
 				{
 					key: `${options.key}/singleRelatedKey`,
 					get:
@@ -503,11 +503,11 @@ export class Join<
 							return null
 						},
 				},
-				store,
 				[`join`, `keys`],
 			)
 		const getMultipleKeyStateFamily = () => {
 			return createReadonlySelectorFamily<string[], string>(
+				store,
 				{
 					key: `${options.key}/multipleRelatedKeys`,
 					get:
@@ -519,12 +519,12 @@ export class Join<
 							return json.members
 						},
 				},
-				store,
 				[`join`, `keys`],
 			)
 		}
 		const createSingleEntryStateFamily = () =>
 			createReadonlySelectorFamily<[string, Content] | null, string>(
+				store,
 				{
 					key: `${options.key}/singleRelatedEntry`,
 					get:
@@ -541,11 +541,11 @@ export class Join<
 							return null
 						},
 				},
-				store,
 				[`join`, `entries`],
 			)
 		const getMultipleEntryStateFamily = () =>
 			createReadonlySelectorFamily<[string, Content][], string>(
+				store,
 				{
 					key: `${options.key}/multipleRelatedEntries`,
 					get:
@@ -562,7 +562,6 @@ export class Join<
 							})
 						},
 				},
-				store,
 				[`join`, `entries`],
 			)
 

package/data/src/struct-family.ts

@@ -29,31 +29,25 @@ export function structFamily<
 		>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>
 	} = Object.keys(options.default).reduce((acc, subKey) => {
 		const atomFamilyName = nameFamily(options.key, subKey)
-		acc[atomFamilyName] = createRegularAtomFamily(
-			{
-				key: `${options.key}.${subKey}`,
-				default: (options.default as any)[subKey],
-			},
-			IMPLICIT.STORE,
-		)
+		acc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {
+			key: `${options.key}.${subKey}`,
+			default: (options.default as any)[subKey],
+		})
 		return acc
 	}, {} as any)
 	const findStructState: AtomIO.ReadonlySelectorFamilyToken<Struct, string> =
-		createSelectorFamily(
-			{
-				key: options.key,
-				get:
-					(id) =>
-					({ find, get }) => {
-						return Object.keys(options.default).reduce((acc, subKey) => {
-							acc[subKey] = get(
-								find((atoms as any)[nameFamily(options.key, subKey)], id),
-							)
-							return acc
-						}, {} as any)
-					},
-			},
-			IMPLICIT.STORE,
-		)
+		createSelectorFamily(IMPLICIT.STORE, {
+			key: options.key,
+			get:
+				(id) =>
+				({ find, get }) => {
+					return Object.keys(options.default).reduce((acc, subKey) => {
+						acc[subKey] = get(
+							find((atoms as any)[nameFamily(options.key, subKey)], id),
+						)
+						return acc
+					}, {} as any)
+				},
+		})
 	return [atoms, findStructState]
 }

package/data/src/struct.ts

@@ -32,26 +32,23 @@ export function struct<
 	} = Object.keys(options.default).reduce((acc, key) => {
 		const atomName = options.key + capitalize(key) + `State`
 		acc[atomName] = createRegularAtom(
+			store,
 			{
 				key: `${options.key}.${key}`,
 				default: options.default[key],
 			},
 			undefined,
-			store,
 		)
 		return acc
 	}, {} as any)
-	const structState = createStandaloneSelector(
-		{
-			key: options.key,
-			get: ({ get }) => {
-				return Object.keys(options.default).reduce((acc, key) => {
-					acc[key] = get(atoms[options.key + capitalize(key) + `State`])
-					return acc
-				}, {} as any)
-			},
+	const structState = createStandaloneSelector(store, {
+		key: options.key,
+		get: ({ get }) => {
+			return Object.keys(options.default).reduce((acc, key) => {
+				acc[key] = get(atoms[options.key + capitalize(key) + `State`])
+				return acc
+			}, {} as any)
 		},
-		store,
-	)
+	})
 	return [atoms, structState]
 }