atom.io 0.20.3 → 0.21.1

package/introspection/dist/index.js

@@ -1,60 +1,85 @@
-import { __spreadValues, __spreadProps } from '../../dist/chunk-F2X4B4VY.js';
+import { getState } from '../../dist/chunk-PNIHPILQ.js';
+import { __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
-import { createRegularAtom, newest, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
+import { createRegularAtom, deposit, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
 
 var attachAtomIndex = (store = IMPLICIT.STORE) => {
-  console.log(store.config);
   const atomTokenIndexState__INTERNAL = createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
-        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key, atom]) => {
-          acc[key] = { key, type: atom.type };
-          return acc;
-        }, {});
-        return defaultAtomIndex;
+        const base = /* @__PURE__ */ new Map();
+        for (const [key, val] of store.atoms) {
+          if (!key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+            const token = deposit(val);
+            if (val.family) {
+              let familyNode = base.get(val.family.key);
+              if (!familyNode || !(`familyMembers` in familyNode)) {
+                familyNode = {
+                  key: val.family.key,
+                  familyMembers: /* @__PURE__ */ new Map()
+                };
+                base.set(val.family.key, familyNode);
+              }
+              familyNode.familyMembers.set(val.family.subKey, token);
+            } else {
+              base.set(key, token);
+            }
+          }
+        }
+        return base;
       },
       effects: [
         ({ setSelf }) => {
-          store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
-            if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
-              return;
-            }
-            const set = () => setSelf((state) => {
-              const { key, family } = atomToken;
-              if (family) {
-                const { key: familyKey, subKey } = family;
-                const current = state[familyKey];
-                if (current === void 0 || `familyMembers` in current) {
-                  const familyKeyState = current || {
-                    key: familyKey,
-                    familyMembers: {}
-                  };
-                  return __spreadProps(__spreadValues({}, state), {
-                    [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
-                      familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
-                        [subKey]: atomToken
-                      })
-                    })
-                  });
-                }
+          const unsubscribeFromAtomCreation = store.on.atomCreation.subscribe(
+            `introspection`,
+            (atomToken) => {
+              if (atomToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+                return;
               }
-              return __spreadProps(__spreadValues({}, state), {
-                [key]: atomToken
+              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;
               });
-            });
-            if (newest(store).operation.open) {
-              const unsubscribe = store.on.operationClose.subscribe(
-                `introspection: waiting to update atom index`,
-                () => {
-                  unsubscribe();
-                  set();
+            }
+          );
+          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);
+                    }
+                  }
+                } else {
+                  self.delete(atomToken.key);
                 }
-              );
-            } else {
-              set();
+                return self;
+              });
             }
-          });
+          );
+          return () => {
+            unsubscribeFromAtomCreation();
+            unsubscribeFromAtomDisposal();
+          };
         }
       ]
     },
@@ -73,60 +98,81 @@ var attachSelectorIndex = (store = IMPLICIT.STORE) => {
   const readonlySelectorTokenIndexState__INTERNAL = createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index (Internal)`,
-      default: () => Object.assign(
-        [...store.readonlySelectors].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
-          acc[key] = { key, type: `readonly_selector` };
-          return acc;
-        }, {}),
-        [...store.selectors].reduce((acc, [key]) => {
-          acc[key] = { key, type: `selector` };
-          return acc;
-        }, {})
-      ),
+      default: () => {
+        const base = /* @__PURE__ */ new Map();
+        for (const map of [store.readonlySelectors, store.selectors]) {
+          for (const [key, val] of map) {
+            if (!key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
+              const token = deposit(val);
+              if (val.family) {
+                let familyNode = base.get(val.family.key);
+                if (!familyNode || !(`familyMembers` in familyNode)) {
+                  familyNode = {
+                    key: val.family.key,
+                    familyMembers: /* @__PURE__ */ new Map()
+                  };
+                  base.set(val.family.key, familyNode);
+                }
+                familyNode.familyMembers.set(val.family.subKey, token);
+              } else {
+                base.set(key, token);
+              }
+            }
+          }
+        }
+        return base;
+      },
       effects: [
         ({ setSelf }) => {
-          store.on.selectorCreation.subscribe(
+          const unsubscribeFromSelectorCreation = store.on.selectorCreation.subscribe(
             `introspection`,
             (selectorToken) => {
               if (selectorToken.key.includes(`\u{1F441}\u200D\u{1F5E8}`)) {
                 return;
               }
-              const set = () => setSelf((state) => {
-                const { key, family } = selectorToken;
-                if (family) {
-                  const { key: familyKey, subKey } = family;
-                  const current = state[familyKey];
-                  if (current === void 0 || `familyMembers` in current) {
-                    const familyKeyState = current || {
+              setSelf((self) => {
+                if (selectorToken.family) {
+                  const { key: familyKey, subKey } = selectorToken.family;
+                  let familyNode = self.get(familyKey);
+                  if (familyNode === void 0 || !(`familyMembers` in familyNode)) {
+                    familyNode = {
                       key: familyKey,
-                      familyMembers: {}
+                      familyMembers: /* @__PURE__ */ new Map()
                     };
-                    return __spreadProps(__spreadValues({}, state), {
-                      [familyKey]: __spreadProps(__spreadValues({}, familyKeyState), {
-                        familyMembers: __spreadProps(__spreadValues({}, familyKeyState.familyMembers), {
-                          [subKey]: selectorToken
-                        })
-                      })
-                    });
+                    self.set(familyKey, familyNode);
                   }
+                  familyNode.familyMembers.set(subKey, selectorToken);
+                } else {
+                  self.set(selectorToken.key, selectorToken);
                 }
-                return __spreadProps(__spreadValues({}, state), {
-                  [key]: selectorToken
-                });
+                return self;
               });
-              if (newest(store).operation.open) {
-                const unsubscribe = store.on.operationClose.subscribe(
-                  `introspection: waiting to update selector index`,
-                  () => {
-                    unsubscribe();
-                    set();
+            }
+          );
+          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);
+                    }
                   }
-                );
-              } else {
-                set();
-              }
+                } else {
+                  self.delete(selectorToken.key);
+                }
+                return self;
+              });
             }
           );
+          return () => {
+            unsubscribeFromSelectorCreation();
+            unsubscribeFromSelectorDisposal();
+          };
         }
       ]
     },
@@ -164,19 +210,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));
           });
         }
       ]
@@ -291,5 +325,101 @@ var attachIntrospectionStates = (store = Internal.IMPLICIT.STORE) => {
     findTimelineState: attachTimelineFamily(store)
   };
 };
+var _Auditor = class _Auditor {
+  /**
+   * @param {Store} store - The store to audit.
+   */
+  constructor(store = Internal.IMPLICIT.STORE) {
+    this.store = store;
+    this.auditorCreatedAt = performance.now();
+    this.statesCreatedAt = /* @__PURE__ */ new Map();
+    this.disposed = false;
+    this.atomIndex = attachAtomIndex(this.store);
+    this.selectorIndex = attachSelectorIndex(this.store);
+    this.unsubscribeFromAtomCreation = this.store.on.atomCreation.subscribe(
+      `auditor-${this.auditorCreatedAt}`,
+      ({ key }) => {
+        this.statesCreatedAt.set(key, performance.now() - this.auditorCreatedAt);
+      }
+    );
+    this.unsubscribeFromAtomDisposal = this.store.on.atomDisposal.subscribe(
+      `auditor-${this.auditorCreatedAt}`,
+      ({ key }) => {
+        this.statesCreatedAt.delete(key);
+      }
+    );
+    this.unsubscribeFromSelectorCreation = this.store.on.selectorCreation.subscribe(
+      `auditor-${this.auditorCreatedAt}`,
+      ({ key }) => {
+        this.statesCreatedAt.set(
+          key,
+          performance.now() - this.auditorCreatedAt
+        );
+      }
+    );
+    this.unsubscribeFromSelectorDisposal = this.store.on.selectorDisposal.subscribe(
+      `auditor-${this.auditorCreatedAt}`,
+      ({ key }) => {
+        this.statesCreatedAt.delete(key);
+      }
+    );
+  }
+  /**
+   * Lists all resources in the store, along with their creation time.
+   *
+   * @param {ListResourcesParam} [param] - Optional parameters for filtering the list of resources.
+   * @returns {readonly [ReadableToken<unknown>, number]}[] - An array of tuples, where each tuple contains a state token belonging to a family in the store and that state's creation time.
+   */
+  listResources(param = _Auditor.DEFAULT_LIST_RESOURCES_PARAM) {
+    if (this.disposed) {
+      throw new Error(`This Auditor has been disposed`);
+    }
+    const atoms = getState(this.atomIndex);
+    const selectors = getState(this.selectorIndex);
+    const atomFamilyNodes = [...atoms.values()].filter(
+      (node) => `familyMembers` in node
+    );
+    const selectorFamilyNodes = [...selectors.values()].filter(
+      (node) => `familyMembers` in node
+    );
+    const currentTime = performance.now();
+    const resources = [];
+    if (param.atomFamilies) {
+      for (const familyNode of atomFamilyNodes) {
+        const tokens = familyNode.familyMembers.values();
+        for (const token of tokens) {
+          const storedTime = this.statesCreatedAt.get(token.key);
+          const creationTime = storedTime != null ? storedTime : this.auditorCreatedAt;
+          const age = currentTime - creationTime;
+          resources.push([token, age]);
+        }
+      }
+    }
+    if (param.selectorFamilies) {
+      for (const familyNode of selectorFamilyNodes) {
+        const tokens = familyNode.familyMembers.values();
+        for (const token of tokens) {
+          const storedTime = this.statesCreatedAt.get(token.key);
+          const creationTime = storedTime != null ? storedTime : this.auditorCreatedAt;
+          const age = currentTime - creationTime;
+          resources.push([token, age]);
+        }
+      }
+    }
+    return resources;
+  }
+  [Symbol.dispose]() {
+    this.unsubscribeFromAtomCreation();
+    this.unsubscribeFromAtomDisposal();
+    this.unsubscribeFromSelectorCreation();
+    this.unsubscribeFromSelectorDisposal();
+    this.disposed = true;
+  }
+};
+_Auditor.DEFAULT_LIST_RESOURCES_PARAM = {
+  atomFamilies: true,
+  selectorFamilies: true
+};
+var Auditor = _Auditor;
 
-export { attachIntrospectionStates };
+export { Auditor, attachIntrospectionStates };

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

@@ -3,8 +3,8 @@ import type { Store } from "atom.io/internal"
 import {
 	createRegularAtom,
 	createStandaloneSelector,
+	deposit,
 	IMPLICIT,
-	newest,
 } from "atom.io/internal"
 
 import type { WritableTokenIndex } from "."
@@ -14,65 +14,86 @@ export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
 export const attachAtomIndex = (
 	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<AtomTokenIndex> => {
-	console.log(store.config)
 	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
 		{
 			key: `👁‍🗨 Atom Token Index (Internal)`,
 			default: () => {
-				const defaultAtomIndex = [...store.atoms]
-					.filter(([key]) => !key.includes(`👁‍🗨`))
-					.reduce<AtomTokenIndex>((acc, [key, atom]) => {
-						acc[key] = { key, type: atom.type }
-						return acc
-					}, {})
-				return defaultAtomIndex
+				const base: AtomTokenIndex = new Map()
+				for (const [key, val] of store.atoms) {
+					if (!key.includes(`👁‍🗨`)) {
+						const token = deposit(val)
+						if (val.family) {
+							let familyNode = base.get(val.family.key)
+							if (!familyNode || !(`familyMembers` in familyNode)) {
+								familyNode = {
+									key: val.family.key,
+									familyMembers: new Map(),
+								}
+								base.set(val.family.key, familyNode)
+							}
+							familyNode.familyMembers.set(val.family.subKey, token)
+						} else {
+							base.set(key, token)
+						}
+					}
+				}
+				return base
 			},
 			effects: [
 				({ setSelf }) => {
-					store.on.atomCreation.subscribe(`introspection`, (atomToken) => {
-						if (atomToken.key.includes(`👁‍🗨`)) {
-							return
-						}
-						const set = () =>
-							setSelf((state) => {
-								const { key, family } = atomToken
-								if (family) {
-									const { key: familyKey, subKey } = family
-									const current = state[familyKey]
-									if (current === undefined || `familyMembers` in current) {
-										const familyKeyState = current || {
+					const unsubscribeFromAtomCreation = 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: {},
-										}
-										return {
-											...state,
-											[familyKey]: {
-												...familyKeyState,
-												familyMembers: {
-													...familyKeyState.familyMembers,
-													[subKey]: atomToken,
-												},
-											},
+											familyMembers: new Map(),
 										}
+										self.set(familyKey, familyNode)
 									}
+									familyNode.familyMembers.set(subKey, atomToken)
+								} else {
+									self.set(atomToken.key, atomToken)
 								}
-								return {
-									...state,
-									[key]: atomToken,
+								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)
+										}
+									}
+								} else {
+									self.delete(atomToken.key)
 								}
+								return self
 							})
-						if (newest(store).operation.open) {
-							const unsubscribe = store.on.operationClose.subscribe(
-								`introspection: waiting to update atom index`,
-								() => {
-									unsubscribe()
-									set()
-								},
-							)
-						} else {
-							set()
-						}
-					})
+						},
+					)
+					return () => {
+						unsubscribeFromAtomCreation()
+						unsubscribeFromAtomDisposal()
+					}
 				},
 			],
 		},

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

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