atom.io 0.31.1 → 0.32.1

package/dist/chunk-VRJP2PCU.js

@@ -0,0 +1,631 @@
+import { IMPLICIT, getState, createReadonlySelectorFamily, createRegularAtomFamily, Subject, createSelectorFamily, createRegularAtom, createStandaloneSelector, deposit } from './chunk-UQEYZ3OI.js';
+
+// introspection/src/attach-atom-index.ts
+var attachAtomIndex = (store) => {
+  const atomTokenIndexState__INTERNAL = createRegularAtom(
+    store,
+    {
+      key: `\u{1F50D} Atom Token Index (Internal)`,
+      default: () => {
+        const base = /* @__PURE__ */ new Map();
+        for (const [key, val] of store.atoms) {
+          if (!key.includes(`\u{1F50D}`)) {
+            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{1F50D}`)) {
+              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.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;
+            });
+          });
+        }
+      ]
+    },
+    void 0
+  );
+  return createStandaloneSelector(store, {
+    key: `\u{1F50D} Atom Token Index`,
+    get: ({ get }) => get(atomTokenIndexState__INTERNAL)
+  });
+};
+
+// introspection/src/attach-selector-index.ts
+var attachSelectorIndex = (store) => {
+  const readonlySelectorTokenIndexState__INTERNAL = createRegularAtom(
+    store,
+    {
+      key: `\u{1F50D} Selector Token Index (Internal)`,
+      default: () => {
+        const base = /* @__PURE__ */ new Map();
+        for (const map of [store.readonlySelectors, store.selectors]) {
+          for (const [key, val] of map) {
+            if (!key.includes(`\u{1F50D}`)) {
+              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(
+            `introspection`,
+            (selectorToken) => {
+              if (selectorToken.key.includes(`\u{1F50D}`)) {
+                return;
+              }
+              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: /* @__PURE__ */ new Map()
+                    };
+                    self.set(familyKey, familyNode);
+                  }
+                  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;
+              });
+            }
+          );
+        }
+      ]
+    },
+    void 0
+  );
+  return createStandaloneSelector(store, {
+    key: `\u{1F50D} Selector Token Index`,
+    get: ({ get }) => get(readonlySelectorTokenIndexState__INTERNAL)
+  });
+};
+
+// introspection/src/attach-timeline-family.ts
+var attachTimelineFamily = (store) => {
+  const findTimelineLogState__INTERNAL = createRegularAtomFamily(store, {
+    key: `\u{1F50D} Timeline Update Log (Internal)`,
+    default: (key) => store.timelines.get(key) ?? {
+      type: `timeline`,
+      key: ``,
+      at: 0,
+      timeTraveling: null,
+      history: [],
+      selectorTime: null,
+      transactionKey: null,
+      install: () => {
+      },
+      subject: new Subject(),
+      subscriptions: /* @__PURE__ */ new Map()
+    },
+    effects: (key) => [
+      ({ setSelf }) => {
+        const tl = store.timelines.get(key);
+        tl?.subject.subscribe(`introspection`, (_) => {
+          setSelf({ ...tl });
+        });
+      }
+    ]
+  });
+  const findTimelineLogState = createSelectorFamily(
+    store,
+    {
+      key: `\u{1F50D} Timeline Update Log`,
+      get: (key) => ({ get }) => get(findTimelineLogState__INTERNAL, key)
+    }
+  );
+  return findTimelineLogState;
+};
+
+// introspection/src/attach-timeline-index.ts
+var attachTimelineIndex = (store) => {
+  const timelineTokenIndexState__INTERNAL = createRegularAtom(
+    store,
+    {
+      key: `\u{1F50D} Timeline Token Index (Internal)`,
+      default: () => [...store.timelines].map(([key]) => {
+        return { key, type: `timeline` };
+      }),
+      effects: [
+        ({ setSelf }) => {
+          store.on.timelineCreation.subscribe(
+            `introspection`,
+            (timelineToken) => {
+              setSelf((state) => [...state, timelineToken]);
+            }
+          );
+        }
+      ]
+    },
+    void 0
+  );
+  const timelineTokenIndex = createStandaloneSelector(store, {
+    key: `\u{1F50D} Timeline Token Index`,
+    get: ({ get }) => get(timelineTokenIndexState__INTERNAL)
+  });
+  return timelineTokenIndex;
+};
+
+// introspection/src/attach-transaction-index.ts
+var attachTransactionIndex = (store) => {
+  const transactionTokenIndexState__INTERNAL = createRegularAtom(
+    store,
+    {
+      key: `\u{1F50D} Transaction Token Index (Internal)`,
+      default: () => [...store.transactions].map(([key]) => {
+        return { key, type: `transaction` };
+      }),
+      effects: [
+        ({ setSelf }) => {
+          store.on.transactionCreation.subscribe(
+            `introspection`,
+            (transactionToken) => {
+              setSelf((state) => [...state, transactionToken]);
+            }
+          );
+        }
+      ]
+    },
+    void 0
+  );
+  const transactionTokenIndex = createStandaloneSelector(store, {
+    key: `\u{1F50D} Transaction Token Index`,
+    get: ({ get }) => get(transactionTokenIndexState__INTERNAL)
+  });
+  return transactionTokenIndex;
+};
+
+// introspection/src/attach-transaction-logs.ts
+var attachTransactionLogs = (store) => {
+  const transactionUpdateLogAtoms = createRegularAtomFamily(store, {
+    key: `\u{1F50D} Transaction Update Log (Internal)`,
+    default: () => [],
+    effects: (key) => [
+      ({ setSelf }) => {
+        const tx = store.transactions.get(key);
+        tx?.subject.subscribe(`introspection`, (transactionUpdate) => {
+          if (transactionUpdate.key === key) {
+            setSelf((state) => [...state, transactionUpdate]);
+          }
+        });
+      }
+    ]
+  });
+  const findTransactionUpdateLogState = createSelectorFamily(store, {
+    key: `\u{1F50D} Transaction Update Log`,
+    get: (key) => ({ get }) => get(transactionUpdateLogAtoms, key)
+  });
+  return findTransactionUpdateLogState;
+};
+
+// introspection/src/refinery.ts
+var Refinery = class {
+  supported;
+  constructor(supported) {
+    this.supported = supported;
+  }
+  refine(input) {
+    for (const [key, refiner] of Object.entries(this.supported)) {
+      try {
+        if (
+          // @ts-expect-error that's the point
+          refiner(input) === true && refiner !== Boolean
+        ) {
+          return { type: key, data: input };
+        }
+      } catch (_) {
+        try {
+          if (input instanceof refiner) {
+            return { type: key, data: input };
+          }
+        } catch (__) {
+        }
+      }
+    }
+    return null;
+  }
+};
+var primitiveRefinery = new Refinery({
+  number: (input) => typeof input === `number`,
+  string: (input) => typeof input === `string`,
+  boolean: (input) => typeof input === `boolean`,
+  null: (input) => input === null
+});
+function isPlainObject(input) {
+  if (!input) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(input);
+  return prototype === Object.prototype;
+}
+var jsonTreeRefinery = new Refinery({
+  object: isPlainObject,
+  array: (input) => Array.isArray(input)
+});
+var jsonRefinery = new Refinery({
+  ...primitiveRefinery.supported,
+  ...jsonTreeRefinery.supported
+});
+var discoverType = (input) => {
+  if (input === void 0) {
+    return `undefined`;
+  }
+  const refined = jsonRefinery.refine(input);
+  if (refined) {
+    return refined.type;
+  }
+  return Object.getPrototypeOf(input).constructor.name;
+};
+
+// introspection/src/attach-type-selectors.ts
+var attachTypeSelectors = (store) => {
+  const typeSelectors = createReadonlySelectorFamily(store, {
+    key: `\u{1F50D} State Type`,
+    get: (key) => ({ get }) => {
+      let state;
+      try {
+        const token = store.atoms.get(key) ?? store.selectors.get(key) ?? store.readonlySelectors.get(key);
+        if (token === void 0) {
+          throw new Error(`Could not find state with key "${key}"`);
+        }
+        state = get(token);
+      } catch (thrown) {
+        return `error`;
+      }
+      const typeOfState = discoverType(state);
+      return typeOfState;
+    }
+  });
+  return typeSelectors;
+};
+
+// introspection/src/attach-introspection-states.ts
+var attachIntrospectionStates = (store) => {
+  return {
+    atomIndex: attachAtomIndex(store),
+    selectorIndex: attachSelectorIndex(store),
+    transactionIndex: attachTransactionIndex(store),
+    transactionLogSelectors: attachTransactionLogs(store),
+    timelineIndex: attachTimelineIndex(store),
+    timelineSelectors: attachTimelineFamily(store),
+    typeSelectors: attachTypeSelectors(store)
+  };
+};
+
+// introspection/src/auditor.ts
+var Auditor = class _Auditor {
+  /**
+   * @param {Store} store - The store to audit.
+   */
+  constructor(store = IMPLICIT.STORE) {
+    this.store = store;
+    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);
+      }
+    );
+  }
+  auditorCreatedAt = performance.now();
+  statesCreatedAt = /* @__PURE__ */ new Map();
+  atomIndex;
+  selectorIndex;
+  disposed = false;
+  unsubscribeFromAtomCreation;
+  unsubscribeFromAtomDisposal;
+  unsubscribeFromSelectorCreation;
+  unsubscribeFromSelectorDisposal;
+  static 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 = _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 ?? 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 ?? 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;
+  }
+};
+
+// introspection/src/sprawl.ts
+var sprawl = (tree, inspector) => {
+  const walk = (path, node) => {
+    const inspect = (p, n) => {
+      const result2 = inspector(p, n);
+      if (result2) return result2;
+      return null;
+    };
+    const result = inspect(path, node);
+    if (result?.jobComplete ?? result?.pathComplete) {
+      return result;
+    }
+    const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
+    for (const [k, v] of childEntries) {
+      const subResult = walk([...path, k], v);
+      if (subResult?.jobComplete) {
+        return subResult;
+      }
+    }
+    return {};
+  };
+  walk([], tree);
+};
+
+// introspection/src/differ.ts
+function diffNumber(a, b) {
+  const sign = a < b ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a - b)} (${a} \u2192 ${b})`
+  };
+}
+function diffString(a, b) {
+  const sign = a.length < b.length ? `+` : `-`;
+  return {
+    summary: `${sign}${Math.abs(a.length - b.length)} ("${a}" \u2192 "${b}")`
+  };
+}
+function diffBoolean(a, b) {
+  return {
+    summary: `${a} \u2192 ${b}`
+  };
+}
+function diffObject(a, b, recurse) {
+  let summary = ``;
+  const added = [];
+  const removed = [];
+  const changed = [];
+  sprawl(a, (path, nodeA) => {
+    let key;
+    for (key of path) {
+      const nodeB = b[key];
+      if (nodeB === void 0) {
+        removed.push([key, JSON.stringify(nodeA)]);
+      } else {
+        const delta = recurse(nodeA, nodeB);
+        if (delta.summary !== `No Change`) {
+          changed.push([key, delta]);
+        }
+      }
+    }
+  });
+  sprawl(b, (path, nodeB) => {
+    let key;
+    for (key of path) {
+      const nodeA = a[key];
+      if (nodeA === void 0) {
+        added.push([key, JSON.stringify(nodeB)]);
+      }
+    }
+  });
+  summary = `\uFF5E${changed.length} \uFF0B${added.length} \uFF0D${removed.length}`;
+  return {
+    summary,
+    added,
+    removed,
+    changed
+  };
+}
+function diffArray(a, b, recurse) {
+  return diffObject(a, b, recurse);
+}
+var Differ = class {
+  leafRefinery;
+  treeRefinery;
+  leafDiffers;
+  treeDiffers;
+  constructor(leafRefinery, treeRefinery, diffFunctions) {
+    this.leafRefinery = leafRefinery;
+    this.treeRefinery = treeRefinery;
+    this.leafDiffers = {};
+    this.treeDiffers = {};
+    for (const key of Object.keys(leafRefinery.supported)) {
+      const diffFunction = diffFunctions[key];
+      this.leafDiffers[key] = diffFunction;
+    }
+    for (const key of Object.keys(treeRefinery.supported)) {
+      const diffFunction = diffFunctions[key];
+      this.treeDiffers[key] = diffFunction;
+    }
+  }
+  diff(a, b) {
+    if (a === b) {
+      return { summary: `No Change` };
+    }
+    const aRefined = this.leafRefinery.refine(a) ?? this.treeRefinery.refine(a);
+    const bRefined = this.leafRefinery.refine(b) ?? this.treeRefinery.refine(b);
+    if (aRefined !== null && bRefined !== null) {
+      if (aRefined.type === bRefined.type) {
+        if (aRefined.type in this.leafDiffers) {
+          const delta = this.leafDiffers[aRefined.type](
+            aRefined.data,
+            bRefined.data
+          );
+          return delta;
+        }
+        if (aRefined.type in this.treeDiffers) {
+          const delta = this.treeDiffers[aRefined.type](
+            aRefined.data,
+            bRefined.data,
+            (x, y) => this.diff(x, y)
+          );
+          return delta;
+        }
+      }
+    }
+    const typeA = discoverType(a);
+    const typeB = discoverType(b);
+    if (typeA === typeB) {
+      return {
+        summary: `${typeA} \u2192 ${typeB}`
+      };
+    }
+    return {
+      summary: `Type change: ${typeA} \u2192 ${typeB}`
+    };
+  }
+};
+var prettyJson = new Differ(primitiveRefinery, jsonTreeRefinery, {
+  number: diffNumber,
+  string: diffString,
+  boolean: diffBoolean,
+  null: () => ({ summary: `No Change` }),
+  object: diffObject,
+  array: diffArray
+});
+
+export { Auditor, Differ, Refinery, attachIntrospectionStates, diffArray, diffBoolean, diffNumber, diffObject, diffString, discoverType, isPlainObject, jsonRefinery, jsonTreeRefinery, prettyJson, primitiveRefinery, sprawl };