atom.io 0.20.3 → 0.21.0

package/introspection/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var Internal = require('atom.io/internal');
+var Internal2 = require('atom.io/internal');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -20,11 +20,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
+var Internal2__namespace = /*#__PURE__*/_interopNamespace(Internal2);
 
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -40,67 +38,90 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
-  console.log(store.config);
-  const atomTokenIndexState__INTERNAL = Internal.createRegularAtom(
+var attachAtomIndex = (store = Internal2.IMPLICIT.STORE) => {
+  const atomTokenIndexState__INTERNAL = Internal2.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 = Internal2.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 (Internal.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();
+          };
         }
       ]
     },
     void 0,
     store
   );
-  return Internal.createStandaloneSelector(
+  return Internal2.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index`,
       get: ({ get }) => get(atomTokenIndexState__INTERNAL)
@@ -108,80 +129,101 @@ var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
     store
   );
 };
-var attachSelectorIndex = (store = Internal.IMPLICIT.STORE) => {
-  const readonlySelectorTokenIndexState__INTERNAL = Internal.createRegularAtom(
+var attachSelectorIndex = (store = Internal2.IMPLICIT.STORE) => {
+  const readonlySelectorTokenIndexState__INTERNAL = Internal2.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 = Internal2.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 (Internal.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();
+          };
         }
       ]
     },
     void 0,
     store
   );
-  return Internal.createStandaloneSelector(
+  return Internal2.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Selector Token Index`,
       get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
     },
-    Internal.IMPLICIT.STORE
+    Internal2.IMPLICIT.STORE
   );
 };
-var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
-  const findTimelineLogState__INTERNAL = Internal.createRegularAtomFamily(
+var attachTimelineFamily = (store = Internal2.IMPLICIT.STORE) => {
+  const findTimelineLogState__INTERNAL = Internal2.createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log (Internal)`,
       default: (key) => {
@@ -196,7 +238,7 @@ var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
           transactionKey: null,
           install: () => {
           },
-          subject: new Internal.Subject()
+          subject: new Internal2.Subject()
         };
       },
       effects: (key) => [
@@ -222,7 +264,7 @@ var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
     },
     store
   );
-  const findTimelineLogState = Internal.createSelectorFamily(
+  const findTimelineLogState = Internal2.createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Update Log`,
       get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL(key))
@@ -231,8 +273,8 @@ var attachTimelineFamily = (store = Internal.IMPLICIT.STORE) => {
   );
   return findTimelineLogState;
 };
-var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
-  const timelineTokenIndexState__INTERNAL = Internal.createRegularAtom(
+var attachTimelineIndex = (store = Internal2.IMPLICIT.STORE) => {
+  const timelineTokenIndexState__INTERNAL = Internal2.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index (Internal)`,
       default: () => [...store.timelines].map(([key]) => {
@@ -252,7 +294,7 @@ var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  const timelineTokenIndex = Internal.createStandaloneSelector(
+  const timelineTokenIndex = Internal2.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Timeline Token Index`,
       get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
@@ -261,8 +303,8 @@ var attachTimelineIndex = (store = Internal.IMPLICIT.STORE) => {
   );
   return timelineTokenIndex;
 };
-var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
-  const transactionTokenIndexState__INTERNAL = Internal.createRegularAtom(
+var attachTransactionIndex = (store = Internal2.IMPLICIT.STORE) => {
+  const transactionTokenIndexState__INTERNAL = Internal2.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index (Internal)`,
       default: () => [...store.transactions].map(([key]) => {
@@ -282,7 +324,7 @@ var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
     void 0,
     store
   );
-  const transactionTokenIndex = Internal.createStandaloneSelector(
+  const transactionTokenIndex = Internal2.createStandaloneSelector(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Token Index`,
       get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
@@ -291,8 +333,8 @@ var attachTransactionIndex = (store = Internal.IMPLICIT.STORE) => {
   );
   return transactionTokenIndex;
 };
-var attachTransactionLogs = (store = Internal.IMPLICIT.STORE) => {
-  const findTransactionUpdateLog = Internal.createRegularAtomFamily(
+var attachTransactionLogs = (store = Internal2.IMPLICIT.STORE) => {
+  const findTransactionUpdateLog = Internal2.createRegularAtomFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log (Internal)`,
       default: () => [],
@@ -309,7 +351,7 @@ var attachTransactionLogs = (store = Internal.IMPLICIT.STORE) => {
     },
     store
   );
-  const findTransactionUpdateLogState = Internal.createSelectorFamily(
+  const findTransactionUpdateLogState = Internal2.createSelectorFamily(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Transaction Update Log`,
       get: (key) => ({ get }) => get(findTransactionUpdateLog(key))
@@ -320,7 +362,7 @@ var attachTransactionLogs = (store = Internal.IMPLICIT.STORE) => {
 };
 
 // introspection/src/attach-introspection-states.ts
-var attachIntrospectionStates = (store = Internal__namespace.IMPLICIT.STORE) => {
+var attachIntrospectionStates = (store = Internal2__namespace.IMPLICIT.STORE) => {
   return {
     atomIndex: attachAtomIndex(store),
     selectorIndex: attachSelectorIndex(store),
@@ -330,5 +372,107 @@ var attachIntrospectionStates = (store = Internal__namespace.IMPLICIT.STORE) =>
     findTimelineState: attachTimelineFamily(store)
   };
 };
+function getState(token) {
+  return Internal2__namespace.getFromStore(token, Internal2__namespace.IMPLICIT.STORE);
+}
+
+// introspection/src/auditor.ts
+var _Auditor = class _Auditor {
+  /**
+   * @param {Store} store - The store to audit.
+   */
+  constructor(store = Internal2__namespace.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;
 
+exports.Auditor = Auditor;
 exports.attachIntrospectionStates = attachIntrospectionStates;

package/introspection/dist/index.d.ts

@@ -1,10 +1,10 @@
-import { AtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, Func, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
+import { AtomToken, SelectorToken, ReadonlySelectorToken, TransactionToken, Func, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken, ReadableToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
 import { Timeline } from 'atom.io/internal';
 
 type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
-type SelectorTokenIndex = WritableTokenIndex<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+type SelectorTokenIndex = WritableTokenIndex<SelectorToken<unknown>>;
 
 declare const attachIntrospectionStates: (store?: Internal.Store) => {
     atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
@@ -15,10 +15,47 @@ declare const attachIntrospectionStates: (store?: Internal.Store) => {
     findTimelineState: ReadonlySelectorFamilyToken<Timeline<any>, string>;
 };
 
-type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = {
+type ListResourcesParam = {
+    atomFamilies: boolean;
+    selectorFamilies: boolean;
+};
+/**
+ * Auditor is a tool for identifying lingering resources in your store that may result in memory leaks.
+ * @experimental
+ */
+declare class Auditor {
+    readonly store: Internal.Store;
+    auditorCreatedAt: number;
+    statesCreatedAt: Map<string, number>;
+    readonly atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
+    readonly selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
+    disposed: boolean;
+    private readonly unsubscribeFromAtomCreation;
+    private readonly unsubscribeFromAtomDisposal;
+    private readonly unsubscribeFromSelectorCreation;
+    private readonly unsubscribeFromSelectorDisposal;
+    /**
+     * @param {Store} store - The store to audit.
+     */
+    constructor(store?: Internal.Store);
+    static readonly DEFAULT_LIST_RESOURCES_PARAM: {
+        atomFamilies: true;
+        selectorFamilies: true;
+    };
+    /**
+     * 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?: ListResourcesParam): (readonly [ReadableToken<unknown>, number])[];
+    [Symbol.dispose](): void;
+}
+
+type FamilyNode<Token extends ReadableToken<unknown>> = {
     key: string;
-    familyMembers: Record<string, Token>;
+    familyMembers: Map<string, Token>;
 };
-type WritableTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type WritableTokenIndex<Token extends ReadableToken<unknown>> = Map<string, FamilyNode<Token> | Token>;
 
-export { type FamilyNode, type WritableTokenIndex, attachIntrospectionStates };
+export { Auditor, type FamilyNode, type ListResourcesParam, type WritableTokenIndex, attachIntrospectionStates };