atom.io 0.21.0 → 0.22.0

package/introspection/dist/index.js

@@ -31,55 +31,45 @@ var attachAtomIndex = (store = IMPLICIT.STORE) => {
       },
       effects: [
         ({ setSelf }) => {
-          const unsubscribeFromAtomCreation = store.on.atomCreation.subscribe(
-            `introspection`,
-            (atomToken) => {
-              if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-                return;
-              }
-              setSelf((self) => {
-                if (atomToken.family) {
-                  const { key: familyKey, subKey } = atomToken.family;
-                  let familyNode = self.get(familyKey);
-                  if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
-                    familyNode = {
-                      key: familyKey,
-                      familyMembers: /* @__PURE__ */ new Map()
-                    };
-                    self.set(familyKey, familyNode);
-                  }
-                  familyNode.familyMembers.set(subKey, atomToken);
-                } else {
-                  self.set(atomToken.key, atomToken);
-                }
-                return self;
-              });
+          store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
+            if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+              return;
             }
-          );
-          const unsubscribeFromAtomDisposal = store.on.atomDisposal.subscribe(
-            `introspection`,
-            (atomToken) => {
-              setSelf((self) => {
-                if (atomToken.family) {
-                  const { key: familyKey, subKey } = atomToken.family;
-                  const familyNode = self.get(familyKey);
-                  if (familyNode && `familyMembers` in familyNode) {
-                    familyNode.familyMembers.delete(subKey);
-                    if (familyNode.familyMembers.size === 0) {
-                      self.delete(familyKey);
-                    }
+            setSelf((self) => {
+              if (atomToken.family) {
+                const { key: familyKey, subKey } = atomToken.family;
+                let familyNode = self.get(familyKey);
+                if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
+                  familyNode = {
+                    key: familyKey,
+                    familyMembers: /* @__PURE__ */ new Map()
+                  };
+                  self.set(familyKey, familyNode);
+                }
+                familyNode.familyMembers.set(subKey, atomToken);
+              } else {
+                self.set(atomToken.key, atomToken);
+              }
+              return self;
+            });
+          });
+          store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
+            setSelf((self) => {
+              if (atomToken.family) {
+                const { key: familyKey, subKey } = atomToken.family;
+                const familyNode = self.get(familyKey);
+                if (familyNode && `familyMembers` in familyNode) {
+                  familyNode.familyMembers.delete(subKey);
+                  if (familyNode.familyMembers.size === 0) {
+                    self.delete(familyKey);
                   }
-                } else {
-                  self.delete(atomToken.key);
                 }
-                return self;
-              });
-            }
-          );
-          return () => {
-            unsubscribeFromAtomCreation();
-            unsubscribeFromAtomDisposal();
-          };
+              } else {
+                self.delete(atomToken.key);
+              }
+              return self;
+            });
+          });
         }
       ]
     },
@@ -124,7 +114,7 @@ var attachSelectorIndex = (store = IMPLICIT.STORE) => {
       },
       effects: [
         ({ setSelf }) => {
-          const unsubscribeFromSelectorCreation = store.on.selectorCreation.subscribe(
+          store.on.selectorCreation.subscribe(
             `introspection`,
             (selectorToken) => {
               if (selectorToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
@@ -149,7 +139,7 @@ var attachSelectorIndex = (store = IMPLICIT.STORE) => {
               });
             }
           );
-          const unsubscribeFromSelectorDisposal = store.on.selectorDisposal.subscribe(
+          store.on.selectorDisposal.subscribe(
             `introspection`,
             (selectorToken) => {
               setSelf((self) => {
@@ -169,10 +159,6 @@ var attachSelectorIndex = (store = IMPLICIT.STORE) => {
               });
             }
           );
-          return () => {
-            unsubscribeFromSelectorCreation();
-            unsubscribeFromSelectorDisposal();
-          };
         }
       ]
     },
@@ -210,19 +196,7 @@ var attachTimelineFamily = (store = IMPLICIT.STORE) => {
         ({ setSelf }) => {
           const tl = store.timelines.get(key);
           tl == null ? void 0 : tl.subject.subscribe(`introspection`, (_) => {
-            if (store.operation.open === true) {
-              const unsubscribe = store.on.operationClose.subscribe(
-                `introspection`,
-                (operationClose) => {
-                  if (operationClose.open === false) {
-                    unsubscribe();
-                    setSelf(__spreadValues({}, tl));
-                  }
-                }
-              );
-            } else {
-              setSelf(__spreadValues({}, tl));
-            }
+            setSelf(__spreadValues({}, tl));
           });
         }
       ]

package/introspection/src/attach-atom-index.ts

@@ -41,59 +41,49 @@ export const attachAtomIndex = (
 			},
 			effects: [
 				({ setSelf }) => {
-					const unsubscribeFromAtomCreation = store.on.atomCreation.subscribe(
-						`introspection`,
-						(atomToken) => {
-							if (atomToken.key.includes(`👁‍🗨`)) {
-								return
-							}
+					store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
+						if (atomToken.key.includes(`👁‍🗨`)) {
+							return
+						}
 
-							setSelf((self) => {
-								if (atomToken.family) {
-									const { key: familyKey, subKey } = atomToken.family
-									let familyNode = self.get(familyKey)
-									if (
-										familyNode === undefined ||
-										!(`familyMembers` in familyNode)
-									) {
-										familyNode = {
-											key: familyKey,
-											familyMembers: new Map(),
-										}
-										self.set(familyKey, familyNode)
+						setSelf((self) => {
+							if (atomToken.family) {
+								const { key: familyKey, subKey } = atomToken.family
+								let familyNode = self.get(familyKey)
+								if (
+									familyNode === undefined ||
+									!(`familyMembers` in familyNode)
+								) {
+									familyNode = {
+										key: familyKey,
+										familyMembers: new Map(),
 									}
-									familyNode.familyMembers.set(subKey, atomToken)
-								} else {
-									self.set(atomToken.key, atomToken)
+									self.set(familyKey, familyNode)
 								}
-								return self
-							})
-						},
-					)
-					const unsubscribeFromAtomDisposal = store.on.atomDisposal.subscribe(
-						`introspection`,
-						(atomToken) => {
-							setSelf((self) => {
-								if (atomToken.family) {
-									const { key: familyKey, subKey } = atomToken.family
-									const familyNode = self.get(familyKey)
-									if (familyNode && `familyMembers` in familyNode) {
-										familyNode.familyMembers.delete(subKey)
-										if (familyNode.familyMembers.size === 0) {
-											self.delete(familyKey)
-										}
+								familyNode.familyMembers.set(subKey, atomToken)
+							} else {
+								self.set(atomToken.key, atomToken)
+							}
+							return self
+						})
+					})
+					store.on.atomDisposal.subscribe(`introspection`, (atomToken) => {
+						setSelf((self) => {
+							if (atomToken.family) {
+								const { key: familyKey, subKey } = atomToken.family
+								const familyNode = self.get(familyKey)
+								if (familyNode && `familyMembers` in familyNode) {
+									familyNode.familyMembers.delete(subKey)
+									if (familyNode.familyMembers.size === 0) {
+										self.delete(familyKey)
 									}
-								} else {
-									self.delete(atomToken.key)
 								}
-								return self
-							})
-						},
-					)
-					return () => {
-						unsubscribeFromAtomCreation()
-						unsubscribeFromAtomDisposal()
-					}
+							} else {
+								self.delete(atomToken.key)
+							}
+							return self
+						})
+					})
 				},
 			],
 		},

package/introspection/src/attach-introspection-states.ts

@@ -1,6 +1,5 @@
 import type {
 	Func,
-	ReadonlySelectorFamily,
 	ReadonlySelectorFamilyToken,
 	ReadonlySelectorToken,
 	TimelineToken,

package/introspection/src/attach-selector-index.ts

@@ -44,61 +44,56 @@ export const attachSelectorIndex = (
 				},
 				effects: [
 					({ setSelf }) => {
-						const unsubscribeFromSelectorCreation =
-							store.on.selectorCreation.subscribe(
-								`introspection`,
-								(selectorToken) => {
-									if (selectorToken.key.includes(`👁‍🗨`)) {
-										return
-									}
+						store.on.selectorCreation.subscribe(
+							`introspection`,
+							(selectorToken) => {
+								if (selectorToken.key.includes(`👁‍🗨`)) {
+									return
+								}
 
-									setSelf((self) => {
-										if (selectorToken.family) {
-											const { key: familyKey, subKey } = selectorToken.family
-											let familyNode = self.get(familyKey)
-											if (
-												familyNode === undefined ||
-												!(`familyMembers` in familyNode)
-											) {
-												familyNode = {
-													key: familyKey,
-													familyMembers: new Map(),
-												}
-												self.set(familyKey, familyNode)
+								setSelf((self) => {
+									if (selectorToken.family) {
+										const { key: familyKey, subKey } = selectorToken.family
+										let familyNode = self.get(familyKey)
+										if (
+											familyNode === undefined ||
+											!(`familyMembers` in familyNode)
+										) {
+											familyNode = {
+												key: familyKey,
+												familyMembers: new Map(),
 											}
-											familyNode.familyMembers.set(subKey, selectorToken)
-										} else {
-											self.set(selectorToken.key, selectorToken)
+											self.set(familyKey, familyNode)
 										}
-										return self
-									})
-								},
-							)
-						const unsubscribeFromSelectorDisposal =
-							store.on.selectorDisposal.subscribe(
-								`introspection`,
-								(selectorToken) => {
-									setSelf((self) => {
-										if (selectorToken.family) {
-											const { key: familyKey, subKey } = selectorToken.family
-											const familyNode = self.get(familyKey)
-											if (familyNode && `familyMembers` in familyNode) {
-												familyNode.familyMembers.delete(subKey)
-												if (familyNode.familyMembers.size === 0) {
-													self.delete(familyKey)
-												}
+										familyNode.familyMembers.set(subKey, selectorToken)
+									} else {
+										self.set(selectorToken.key, selectorToken)
+									}
+									return self
+								})
+							},
+						)
+
+						store.on.selectorDisposal.subscribe(
+							`introspection`,
+							(selectorToken) => {
+								setSelf((self) => {
+									if (selectorToken.family) {
+										const { key: familyKey, subKey } = selectorToken.family
+										const familyNode = self.get(familyKey)
+										if (familyNode && `familyMembers` in familyNode) {
+											familyNode.familyMembers.delete(subKey)
+											if (familyNode.familyMembers.size === 0) {
+												self.delete(familyKey)
 											}
-										} else {
-											self.delete(selectorToken.key)
 										}
-										return self
-									})
-								},
-							)
-						return () => {
-							unsubscribeFromSelectorCreation()
-							unsubscribeFromSelectorDisposal()
-						}
+									} else {
+										self.delete(selectorToken.key)
+									}
+									return self
+								})
+							},
+						)
 					},
 				],
 			},

package/introspection/src/attach-timeline-family.ts

@@ -1,7 +1,4 @@
-import type {
-	ReadonlySelectorFamily,
-	ReadonlySelectorFamilyToken,
-} from "atom.io"
+import type { ReadonlySelectorFamilyToken } from "atom.io"
 import type { Store, Timeline } from "atom.io/internal"
 import {
 	createRegularAtomFamily,
@@ -35,19 +32,7 @@ export const attachTimelineFamily = (
 				({ setSelf }) => {
 					const tl = store.timelines.get(key)
 					tl?.subject.subscribe(`introspection`, (_) => {
-						if (store.operation.open === true) {
-							const unsubscribe = store.on.operationClose.subscribe(
-								`introspection`,
-								(operationClose) => {
-									if (operationClose.open === false) {
-										unsubscribe()
-										setSelf({ ...tl })
-									}
-								},
-							)
-						} else {
-							setSelf({ ...tl })
-						}
+						setSelf({ ...tl })
 					})
 				},
 			],

package/json/dist/index.cjs

@@ -19,9 +19,43 @@ function selectJsonFamily(family, transform, store = internal.IMPLICIT.STORE) {
   const jsonFamily = internal.createSelectorFamily(
     {
       key: `${family.key}:JSON`,
-      get: (key) => ({ get }) => transform.toJson(get(family(key))),
-      set: (key) => ({ set }, newValue) => {
-        set(family(key), transform.fromJson(newValue));
+      get: (key) => ({ seek, get }) => {
+        const existingState = seek(family, key);
+        if (existingState) {
+          return transform.toJson(get(existingState));
+        }
+        const stringKey = stringifyJson(key);
+        const molecule = store.molecules.get(stringKey);
+        if (molecule) {
+          const atom = molecule.bond(family);
+          return transform.toJson(get(atom));
+        }
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${stringKey}"`);
+        }
+        const newToken = internal.initFamilyMember(family, key, store);
+        return transform.toJson(get(newToken));
+      },
+      set: (key) => ({ seek, set }, newValue) => {
+        const existingState = seek(family, key);
+        if (existingState) {
+          set(existingState, transform.fromJson(newValue));
+        } else {
+          const stringKey = stringifyJson(key);
+          const molecule = store.molecules.get(stringKey);
+          if (molecule) {
+            const atom = molecule.bond(family);
+            set(atom, transform.fromJson(newValue));
+          } else {
+            if (store.config.lifespan === `immortal`) {
+              throw new Error(`No molecule found for key "${stringKey}"`);
+            }
+            set(
+              internal.initFamilyMember(family, key, store),
+              transform.fromJson(newValue)
+            );
+          }
+        }
       }
     },
     store
@@ -30,7 +64,7 @@ function selectJsonFamily(family, transform, store = internal.IMPLICIT.STORE) {
     `store=${store.config.name}::json-selector-family`,
     (token) => {
       if (token.family) {
-        jsonFamily(parseJson(token.family.subKey));
+        internal.seekInStore(jsonFamily, parseJson(token.family.subKey), store);
       }
     }
   );

package/json/dist/index.js

@@ -1,7 +1,7 @@
-import { parseJson } from '../../dist/chunk-BF4MVQF6.js';
+import { stringifyJson, parseJson } from '../../dist/chunk-BF4MVQF6.js';
 export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-BF4MVQF6.js';
 import '../../dist/chunk-F2X4B4VY.js';
-import { createStandaloneSelector, IMPLICIT, createSelectorFamily } from 'atom.io/internal';
+import { createStandaloneSelector, IMPLICIT, createSelectorFamily, initFamilyMember, seekInStore } from 'atom.io/internal';
 
 var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
   return createStandaloneSelector(
@@ -19,9 +19,43 @@ function selectJsonFamily(family, transform, store = IMPLICIT.STORE) {
   const jsonFamily = createSelectorFamily(
     {
       key: `${family.key}:JSON`,
-      get: (key) => ({ get }) => transform.toJson(get(family(key))),
-      set: (key) => ({ set }, newValue) => {
-        set(family(key), transform.fromJson(newValue));
+      get: (key) => ({ seek, get }) => {
+        const existingState = seek(family, key);
+        if (existingState) {
+          return transform.toJson(get(existingState));
+        }
+        const stringKey = stringifyJson(key);
+        const molecule = store.molecules.get(stringKey);
+        if (molecule) {
+          const atom = molecule.bond(family);
+          return transform.toJson(get(atom));
+        }
+        if (store.config.lifespan === `immortal`) {
+          throw new Error(`No molecule found for key "${stringKey}"`);
+        }
+        const newToken = initFamilyMember(family, key, store);
+        return transform.toJson(get(newToken));
+      },
+      set: (key) => ({ seek, set }, newValue) => {
+        const existingState = seek(family, key);
+        if (existingState) {
+          set(existingState, transform.fromJson(newValue));
+        } else {
+          const stringKey = stringifyJson(key);
+          const molecule = store.molecules.get(stringKey);
+          if (molecule) {
+            const atom = molecule.bond(family);
+            set(atom, transform.fromJson(newValue));
+          } else {
+            if (store.config.lifespan === `immortal`) {
+              throw new Error(`No molecule found for key "${stringKey}"`);
+            }
+            set(
+              initFamilyMember(family, key, store),
+              transform.fromJson(newValue)
+            );
+          }
+        }
       }
     },
     store
@@ -30,7 +64,7 @@ function selectJsonFamily(family, transform, store = IMPLICIT.STORE) {
     `store=${store.config.name}::json-selector-family`,
     (token) => {
       if (token.family) {
-        jsonFamily(parseJson(token.family.subKey));
+        seekInStore(jsonFamily, parseJson(token.family.subKey), store);
       }
     }
   );

package/json/src/select-json-family.ts

@@ -1,9 +1,14 @@
 import type * as AtomIO from "atom.io"
 import type { Store, Transceiver } from "atom.io/internal"
-import { createSelectorFamily, IMPLICIT } from "atom.io/internal"
+import {
+	createSelectorFamily,
+	IMPLICIT,
+	initFamilyMember,
+	seekInStore,
+} from "atom.io/internal"
 
 import type { Json, JsonInterface } from "."
-import { parseJson } from "."
+import { parseJson, stringifyJson } from "."
 
 export function selectJsonFamily<
 	T extends Transceiver<any>,
@@ -39,12 +44,46 @@ export function selectJsonFamily<
 			key: `${family.key}:JSON`,
 			get:
 				(key) =>
-				({ get }) =>
-					transform.toJson(get(family(key))),
+				({ seek, get }) => {
+					const existingState = seek(family, key)
+					if (existingState) {
+						return transform.toJson(get(existingState))
+					}
+					const stringKey = stringifyJson(key)
+					const molecule = store.molecules.get(stringKey)
+					if (molecule) {
+						const atom = molecule.bond(family)
+						return transform.toJson(get(atom))
+					}
+					if (store.config.lifespan === `immortal`) {
+						throw new Error(`No molecule found for key "${stringKey}"`)
+					}
+					const newToken = initFamilyMember(family, key, store)
+					return transform.toJson(get(newToken))
+				},
 			set:
 				(key) =>
-				({ set }, newValue) => {
-					set(family(key), transform.fromJson(newValue))
+				({ seek, set }, newValue) => {
+					// set(seek(family, key), transform.fromJson(newValue))
+					const existingState = seek(family, key)
+					if (existingState) {
+						set(existingState, transform.fromJson(newValue))
+					} else {
+						const stringKey = stringifyJson(key)
+						const molecule = store.molecules.get(stringKey)
+						if (molecule) {
+							const atom = molecule.bond(family)
+							set(atom, transform.fromJson(newValue))
+						} else {
+							if (store.config.lifespan === `immortal`) {
+								throw new Error(`No molecule found for key "${stringKey}"`)
+							}
+							set(
+								initFamilyMember(family, key, store),
+								transform.fromJson(newValue),
+							)
+						}
+					}
 				},
 		},
 		store,
@@ -53,7 +92,7 @@ export function selectJsonFamily<
 		`store=${store.config.name}::json-selector-family`,
 		(token) => {
 			if (token.family) {
-				jsonFamily(parseJson(token.family.subKey) as K)
+				seekInStore(jsonFamily, parseJson(token.family.subKey) as K, store)
 			}
 		},
 	)