@tanstack/store 0.8.1 → 0.9.1

package/src/atom.ts

@@ -0,0 +1,298 @@
+import { ReactiveFlags, createReactiveSystem, getBatchDepth } from './alien'
+
+import type { ReactiveNode } from './alien'
+import type {
+  Atom,
+  AtomOptions,
+  Observer,
+  ReadonlyAtom,
+  Subscription,
+} from './types'
+
+export function toObserver<T>(
+  nextHandler?: Observer<T> | ((value: T) => void),
+  errorHandler?: (error: any) => void,
+  completionHandler?: () => void,
+): Observer<T> {
+  const isObserver = typeof nextHandler === 'object'
+  const self = isObserver ? nextHandler : undefined
+
+  return {
+    next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+    error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+    complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(
+      self,
+    ),
+  }
+}
+
+interface InternalAtom<T> extends ReactiveNode {
+  _snapshot: T
+  _update: (getValue?: T | ((snapshot: T) => T)) => boolean
+  get: () => T
+  subscribe: (observerOrFn: Observer<T> | ((value: T) => void)) => Subscription
+}
+
+const queuedEffects: Array<Effect | undefined> = []
+let cycle = 0
+const { link, unlink, propagate, checkDirty, shallowPropagate } =
+  createReactiveSystem({
+    update(atom: InternalAtom<any>): boolean {
+      return atom._update()
+    },
+    // eslint-disable-next-line no-shadow
+    notify(effect: Effect): void {
+      queuedEffects[queuedEffectsLength++] = effect
+      effect.flags &= ~ReactiveFlags.Watching
+    },
+    unwatched(atom: InternalAtom<any>): void {
+      if (atom.depsTail !== undefined) {
+        atom.depsTail = undefined
+        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty
+        purgeDeps(atom)
+      }
+    },
+  })
+
+let notifyIndex = 0
+let queuedEffectsLength = 0
+let activeSub: ReactiveNode | undefined
+
+function purgeDeps(sub: ReactiveNode) {
+  const depsTail = sub.depsTail
+  let dep = depsTail !== undefined ? depsTail.nextDep : sub.deps
+  while (dep !== undefined) {
+    dep = unlink(dep, sub)
+  }
+}
+
+export function flush(): void {
+  if (getBatchDepth() > 0) {
+    return
+  }
+  while (notifyIndex < queuedEffectsLength) {
+    // eslint-disable-next-line no-shadow
+    const effect = queuedEffects[notifyIndex]!
+    queuedEffects[notifyIndex++] = undefined
+    effect.notify()
+  }
+  notifyIndex = 0
+  queuedEffectsLength = 0
+}
+
+type AsyncAtomState<TData, TError = unknown> =
+  | { status: 'pending' }
+  | { status: 'done'; data: TData }
+  | { status: 'error'; error: TError }
+
+export function createAsyncAtom<T>(
+  getValue: () => Promise<T>,
+  options?: AtomOptions<AsyncAtomState<T>>,
+): ReadonlyAtom<AsyncAtomState<T>> {
+  const ref: { current?: InternalAtom<AsyncAtomState<T>> } = {}
+  const atom = createAtom<AsyncAtomState<T>>(() => {
+    getValue().then(
+      (data) => {
+        const internalAtom = ref.current!
+        if (internalAtom._update({ status: 'done', data })) {
+          const subs = internalAtom.subs
+          if (subs !== undefined) {
+            propagate(subs)
+            shallowPropagate(subs)
+            flush()
+          }
+        }
+      },
+      (error) => {
+        const internalAtom = ref.current!
+        if (internalAtom._update({ status: 'error', error })) {
+          const subs = internalAtom.subs
+          if (subs !== undefined) {
+            propagate(subs)
+            shallowPropagate(subs)
+            flush()
+          }
+        }
+      },
+    )
+
+    return { status: 'pending' }
+  }, options)
+  ref.current = atom as unknown as InternalAtom<AsyncAtomState<T>>
+
+  return atom
+}
+
+export function createAtom<T>(
+  getValue: (prev?: NoInfer<T>) => T,
+  options?: AtomOptions<T>,
+): ReadonlyAtom<T>
+export function createAtom<T>(
+  initialValue: T,
+  options?: AtomOptions<T>,
+): Atom<T>
+export function createAtom<T>(
+  valueOrFn: T | ((prev?: T) => T),
+  options?: AtomOptions<T>,
+): Atom<T> | ReadonlyAtom<T> {
+  const isComputed = typeof valueOrFn === 'function'
+  const getter = valueOrFn as (prev?: T) => T
+
+  // Create plain object atom
+  const atom: InternalAtom<T> = {
+    _snapshot: isComputed ? undefined! : valueOrFn,
+
+    subs: undefined,
+    subsTail: undefined,
+    deps: undefined,
+    depsTail: undefined,
+    flags: isComputed ? ReactiveFlags.None : ReactiveFlags.Mutable,
+
+    get(): T {
+      if (activeSub !== undefined) {
+        link(atom, activeSub, cycle)
+      }
+      return atom._snapshot
+    },
+
+    subscribe(observerOrFn: Observer<T> | ((value: T) => void)) {
+      const obs = toObserver(observerOrFn)
+      const observed = { current: false }
+      const e = effect(() => {
+        atom.get()
+        if (!observed.current) {
+          observed.current = true
+        } else {
+          obs.next?.(atom._snapshot)
+        }
+      })
+
+      return {
+        unsubscribe: () => {
+          e.stop()
+        },
+      }
+    },
+    _update(getValue?: T | ((snapshot: T) => T)): boolean {
+      const prevSub = activeSub
+      const compare = options?.compare ?? Object.is
+      activeSub = atom
+      ++cycle
+      atom.depsTail = undefined
+      if (isComputed) {
+        atom.flags = ReactiveFlags.Mutable | ReactiveFlags.RecursedCheck
+      }
+      try {
+        const oldValue = atom._snapshot
+        const newValue =
+          typeof getValue === 'function'
+            ? (getValue as (snapshot: T) => T)(oldValue)
+            : getValue === undefined && isComputed
+              ? getter(oldValue)
+              : getValue!
+        if (oldValue === undefined || !compare(oldValue, newValue)) {
+          atom._snapshot = newValue
+          return true
+        }
+        return false
+      } finally {
+        activeSub = prevSub
+        if (isComputed) {
+          atom.flags &= ~ReactiveFlags.RecursedCheck
+        }
+        purgeDeps(atom)
+      }
+    },
+  }
+
+  if (isComputed) {
+    atom.flags = ReactiveFlags.Mutable | ReactiveFlags.Dirty
+    atom.get = function (): T {
+      const flags = atom.flags
+      if (
+        flags & ReactiveFlags.Dirty ||
+        (flags & ReactiveFlags.Pending && checkDirty(atom.deps!, atom))
+      ) {
+        if (atom._update()) {
+          const subs = atom.subs
+          if (subs !== undefined) {
+            shallowPropagate(subs)
+          }
+        }
+      } else if (flags & ReactiveFlags.Pending) {
+        atom.flags = flags & ~ReactiveFlags.Pending
+      }
+      if (activeSub !== undefined) {
+        link(atom, activeSub, cycle)
+      }
+      return atom._snapshot
+    }
+  } else {
+    ;(atom as unknown as Atom<T>).set = function (
+      // eslint-disable-next-line no-shadow
+      valueOrFn: T | ((prev: T) => T),
+    ): void {
+      if (atom._update(valueOrFn)) {
+        const subs = atom.subs
+        if (subs !== undefined) {
+          propagate(subs)
+          shallowPropagate(subs)
+          flush()
+        }
+      }
+    }
+  }
+
+  return atom as unknown as Atom<T> | ReadonlyAtom<T>
+}
+
+interface Effect extends ReactiveNode {
+  notify: () => void
+  stop: () => void
+}
+
+function effect<T>(fn: () => T): Effect {
+  const run = (): T => {
+    const prevSub = activeSub
+    activeSub = effectObj
+    ++cycle
+    effectObj.depsTail = undefined
+    effectObj.flags = ReactiveFlags.Watching | ReactiveFlags.RecursedCheck
+    try {
+      return fn()
+    } finally {
+      activeSub = prevSub
+      effectObj.flags &= ~ReactiveFlags.RecursedCheck
+      purgeDeps(effectObj)
+    }
+  }
+  const effectObj: Effect = {
+    deps: undefined,
+    depsTail: undefined,
+    subs: undefined,
+    subsTail: undefined,
+    flags: ReactiveFlags.Watching | ReactiveFlags.RecursedCheck,
+
+    notify(): void {
+      const flags = this.flags
+      if (
+        flags & ReactiveFlags.Dirty ||
+        (flags & ReactiveFlags.Pending && checkDirty(this.deps!, this))
+      ) {
+        run()
+      } else {
+        this.flags = ReactiveFlags.Watching
+      }
+    },
+
+    stop(): void {
+      this.flags = ReactiveFlags.None
+      this.depsTail = undefined
+      purgeDeps(this)
+    },
+  }
+
+  run()
+
+  return effectObj
+}

package/src/batch.ts

@@ -0,0 +1,12 @@
+import { endBatch, startBatch } from './alien'
+import { flush } from './atom'
+
+export function batch(fn: () => void) {
+  try {
+    startBatch()
+    fn()
+  } finally {
+    endBatch()
+    flush()
+  }
+}

package/src/index.ts

@@ -1,5 +1,4 @@
-export * from './derived'
-export * from './effect'
-export * from './store'
 export * from './types'
-export * from './scheduler'
+export * from './atom'
+export * from './store'
+export * from './batch'

package/src/store.ts

@@ -1,77 +1,66 @@
-import { __flush } from './scheduler'
-import { isUpdaterFunction } from './types'
-import type { AnyUpdater, Listener, Updater } from './types'
+import { createAtom, toObserver } from './atom'
+import type { Atom, Observer, Subscription } from './types'
 
-export interface StoreOptions<
-  TState,
-  TUpdater extends AnyUpdater = (cb: TState) => TState,
-> {
-  /**
-   * Replace the default update function with a custom one.
-   */
-  updateFn?: (previous: TState) => (updater: TUpdater) => TState
-  /**
-   * Called when a listener subscribes to the store.
-   *
-   * @return a function to unsubscribe the listener
-   */
-  onSubscribe?: (
-    listener: Listener<TState>,
-    store: Store<TState, TUpdater>,
-  ) => () => void
-  /**
-   * Called after the state has been updated, used to derive other state.
-   */
-  onUpdate?: () => void
+export class Store<T> {
+  private atom: Atom<T>
+  constructor(getValue: (prev?: NoInfer<T>) => T)
+  constructor(initialValue: T)
+  constructor(valueOrFn: T | ((prev?: T) => T)) {
+    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values
+    // Store always needs Atom<T> for setState, so we assert the return type
+    this.atom = createAtom(
+      valueOrFn as T | ((prev?: NoInfer<T>) => T),
+    ) as Atom<T>
+  }
+  public setState(updater: (prev: T) => T) {
+    this.atom.set(updater)
+  }
+  public get state() {
+    return this.atom.get()
+  }
+  public get() {
+    return this.state
+  }
+  public subscribe(
+    observerOrFn: Observer<T> | ((value: T) => void),
+  ): Subscription {
+    return this.atom.subscribe(toObserver(observerOrFn))
+  }
 }
 
-export class Store<
-  TState,
-  TUpdater extends AnyUpdater = (cb: TState) => TState,
-> {
-  listeners = new Set<Listener<TState>>()
-  state: TState
-  prevState: TState
-  options?: StoreOptions<TState, TUpdater>
-
-  constructor(initialState: TState, options?: StoreOptions<TState, TUpdater>) {
-    this.prevState = initialState
-    this.state = initialState
-    this.options = options
+export class ReadonlyStore<T> implements Omit<Store<T>, 'setState'> {
+  private atom: Atom<T>
+  constructor(getValue: (prev?: NoInfer<T>) => T)
+  constructor(initialValue: T)
+  constructor(valueOrFn: T | ((prev?: T) => T)) {
+    // createAtom has overloads that return ReadonlyAtom<T> for functions and Atom<T> for values
+    // Store always needs Atom<T> for setState, so we assert the return type
+    this.atom = createAtom(
+      valueOrFn as T | ((prev?: NoInfer<T>) => T),
+    ) as Atom<T>
   }
-
-  subscribe = (listener: Listener<TState>) => {
-    this.listeners.add(listener)
-    const unsub = this.options?.onSubscribe?.(listener, this)
-    return () => {
-      this.listeners.delete(listener)
-      unsub?.()
-    }
+  public get state() {
+    return this.atom.get()
   }
+  public get() {
+    return this.state
+  }
+  public subscribe(
+    observerOrFn: Observer<T> | ((value: T) => void),
+  ): Subscription {
+    return this.atom.subscribe(toObserver(observerOrFn))
+  }
+}
 
-  /**
-   * Update the store state safely with improved type checking
-   */
-  setState(updater: (prevState: TState) => TState): void
-  setState(updater: TState): void
-  setState(updater: TUpdater): void
-  setState(updater: Updater<TState> | TUpdater): void {
-    this.prevState = this.state
-
-    if (this.options?.updateFn) {
-      this.state = this.options.updateFn(this.prevState)(updater as TUpdater)
-    } else {
-      if (isUpdaterFunction(updater)) {
-        this.state = updater(this.prevState)
-      } else {
-        this.state = updater as TState
-      }
-    }
-
-    // Always run onUpdate, regardless of batching
-    this.options?.onUpdate?.()
-
-    // Attempt to flush
-    __flush(this as never)
+export function createStore<T>(
+  getValue: (prev?: NoInfer<T>) => T,
+): ReadonlyStore<T>
+export function createStore<T>(initialValue: T): Store<T>
+export function createStore<T>(
+  valueOrFn: T | ((prev?: T) => T),
+): Store<T> | ReadonlyStore<T> {
+  if (typeof valueOrFn === 'function') {
+    return new ReadonlyStore(valueOrFn as (prev?: NoInfer<T>) => T)
   }
+  return new Store(valueOrFn)
 }

package/src/types.ts

@@ -1,31 +1,67 @@
-/**
- * @private
- */
-export type AnyUpdater = (prev: any) => any
+import type { ReactiveNode } from './alien'
 
-/**
- * Type-safe updater that can be either a function or direct value
- */
-export type Updater<T> = ((prev: T) => T) | T
+export type Selection<TSelected> = Readable<TSelected>
 
-/**
- * @private
- */
-export interface ListenerValue<T> {
-  readonly prevVal: T
-  readonly currentVal: T
+export interface InteropSubscribable<T> {
+  subscribe: (observer: Observer<T>) => Subscription
 }
 
-/**
- * @private
- */
-export type Listener<T> = (value: ListenerValue<T>) => void
+// Based on RxJS types
+export type Observer<T> = {
+  next?: (value: T) => void
+  error?: (err: unknown) => void
+  complete?: () => void
+}
+
+export interface Subscription {
+  unsubscribe: () => void
+}
+
+export interface Subscribable<T> extends InteropSubscribable<T> {
+  subscribe: ((observer: Observer<T>) => Subscription) &
+    ((
+      next: (value: T) => void,
+      error?: (error: any) => void,
+      complete?: () => void,
+    ) => Subscription)
+}
+
+export interface Readable<T> extends Subscribable<T> {
+  get: () => T
+}
+
+export interface BaseAtom<T> extends Subscribable<T>, Readable<T> {}
+
+export interface InternalBaseAtom<T> extends Subscribable<T>, Readable<T> {
+  /** @internal */
+  _snapshot: T
+  /** @internal */
+  _update: (getValue?: T | ((snapshot: T) => T)) => boolean
+}
+
+export interface Atom<T> extends BaseAtom<T> {
+  /** Sets the value of the atom using a function. */
+  set: ((fn: (prevVal: T) => T) => void) & ((value: T) => void)
+}
+
+export interface AtomOptions<T> {
+  compare?: (prev: T, next: T) => boolean
+}
+
+export type AnyAtom = BaseAtom<any>
+
+export interface InternalReadonlyAtom<T>
+  extends InternalBaseAtom<T>, ReactiveNode {}
 
 /**
- * Type guard to check if updater is a function
+ * An atom that is read-only and cannot be set.
+ *
+ * @example
+ *
+ * ```ts
+ * const atom = createAtom(() => 42);
+ * // @ts-expect-error - Cannot set a readonly atom
+ * atom.set(43);
+ * ```
  */
-export function isUpdaterFunction<T>(
-  updater: Updater<T>,
-): updater is (prev: T) => T {
-  return typeof updater === 'function'
-}
+export interface ReadonlyAtom<T> extends BaseAtom<T> {}

package/dist/cjs/derived.cjs

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const store = require("./store.cjs");
-const scheduler = require("./scheduler.cjs");
-class Derived {
-  constructor(options) {
-    this.listeners = /* @__PURE__ */ new Set();
-    this._subscriptions = [];
-    this.lastSeenDepValues = [];
-    this.getDepVals = () => {
-      const l = this.options.deps.length;
-      const prevDepVals = new Array(l);
-      const currDepVals = new Array(l);
-      for (let i = 0; i < l; i++) {
-        const dep = this.options.deps[i];
-        prevDepVals[i] = dep.prevState;
-        currDepVals[i] = dep.state;
-      }
-      this.lastSeenDepValues = currDepVals;
-      return {
-        prevDepVals,
-        currDepVals,
-        prevVal: this.prevState ?? void 0
-      };
-    };
-    this.recompute = () => {
-      var _a, _b;
-      this.prevState = this.state;
-      const depVals = this.getDepVals();
-      this.state = this.options.fn(depVals);
-      (_b = (_a = this.options).onUpdate) == null ? void 0 : _b.call(_a);
-    };
-    this.checkIfRecalculationNeededDeeply = () => {
-      for (const dep of this.options.deps) {
-        if (dep instanceof Derived) {
-          dep.checkIfRecalculationNeededDeeply();
-        }
-      }
-      let shouldRecompute = false;
-      const lastSeenDepValues = this.lastSeenDepValues;
-      const { currDepVals } = this.getDepVals();
-      for (let i = 0; i < currDepVals.length; i++) {
-        if (currDepVals[i] !== lastSeenDepValues[i]) {
-          shouldRecompute = true;
-          break;
-        }
-      }
-      if (shouldRecompute) {
-        this.recompute();
-      }
-    };
-    this.mount = () => {
-      this.registerOnGraph();
-      this.checkIfRecalculationNeededDeeply();
-      return () => {
-        this.unregisterFromGraph();
-        for (const cleanup of this._subscriptions) {
-          cleanup();
-        }
-      };
-    };
-    this.subscribe = (listener) => {
-      var _a, _b;
-      this.listeners.add(listener);
-      const unsub = (_b = (_a = this.options).onSubscribe) == null ? void 0 : _b.call(_a, listener, this);
-      return () => {
-        this.listeners.delete(listener);
-        unsub == null ? void 0 : unsub();
-      };
-    };
-    this.options = options;
-    this.state = options.fn({
-      prevDepVals: void 0,
-      prevVal: void 0,
-      currDepVals: this.getDepVals().currDepVals
-    });
-  }
-  registerOnGraph(deps = this.options.deps) {
-    for (const dep of deps) {
-      if (dep instanceof Derived) {
-        dep.registerOnGraph();
-        this.registerOnGraph(dep.options.deps);
-      } else if (dep instanceof store.Store) {
-        let relatedLinkedDerivedVals = scheduler.__storeToDerived.get(dep);
-        if (!relatedLinkedDerivedVals) {
-          relatedLinkedDerivedVals = /* @__PURE__ */ new Set();
-          scheduler.__storeToDerived.set(dep, relatedLinkedDerivedVals);
-        }
-        relatedLinkedDerivedVals.add(this);
-        let relatedStores = scheduler.__derivedToStore.get(this);
-        if (!relatedStores) {
-          relatedStores = /* @__PURE__ */ new Set();
-          scheduler.__derivedToStore.set(this, relatedStores);
-        }
-        relatedStores.add(dep);
-      }
-    }
-  }
-  unregisterFromGraph(deps = this.options.deps) {
-    for (const dep of deps) {
-      if (dep instanceof Derived) {
-        this.unregisterFromGraph(dep.options.deps);
-      } else if (dep instanceof store.Store) {
-        const relatedLinkedDerivedVals = scheduler.__storeToDerived.get(dep);
-        if (relatedLinkedDerivedVals) {
-          relatedLinkedDerivedVals.delete(this);
-        }
-        const relatedStores = scheduler.__derivedToStore.get(this);
-        if (relatedStores) {
-          relatedStores.delete(dep);
-        }
-      }
-    }
-  }
-}
-exports.Derived = Derived;
-//# sourceMappingURL=derived.cjs.map

package/dist/cjs/derived.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"derived.cjs","sources":["../../src/derived.ts"],"sourcesContent":["import { Store } from './store'\nimport { __derivedToStore, __storeToDerived } from './scheduler'\nimport type { Listener } from './types'\n\nexport type UnwrapDerivedOrStore<T> =\n  T extends Derived<infer InnerD>\n    ? InnerD\n    : T extends Store<infer InnerS>\n      ? InnerS\n      : never\n\ntype UnwrapReadonlyDerivedOrStoreArray<\n  TArr extends ReadonlyArray<Derived<any> | Store<any>>,\n> = TArr extends readonly []\n  ? []\n  : TArr extends readonly [infer Head, ...infer Tail]\n    ? Head extends Derived<any> | Store<any>\n      ? Tail extends ReadonlyArray<Derived<any> | Store<any>>\n        ? [\n            UnwrapDerivedOrStore<Head>,\n            ...UnwrapReadonlyDerivedOrStoreArray<Tail>,\n          ]\n        : [UnwrapDerivedOrStore<Head>]\n      : []\n    : TArr extends ReadonlyArray<Derived<any> | Store<any>>\n      ? Array<UnwrapDerivedOrStore<TArr[number]>>\n      : []\n\n// Can't have currVal, as it's being evaluated from the current derived fn\nexport interface DerivedFnProps<\n  TArr extends ReadonlyArray<Derived<any> | Store<any>> = ReadonlyArray<any>,\n  TUnwrappedArr extends\n    UnwrapReadonlyDerivedOrStoreArray<TArr> = UnwrapReadonlyDerivedOrStoreArray<TArr>,\n> {\n  // `undefined` if it's the first run\n  /**\n   * `undefined` if it's the first run\n   * @privateRemarks this also cannot be typed as TState, as it breaks the inferencing of the function's return type when an argument is used - even with `NoInfer` usage\n   */\n  prevVal: unknown | undefined\n  prevDepVals: TUnwrappedArr | undefined\n  currDepVals: TUnwrappedArr\n}\n\nexport interface DerivedOptions<\n  TState,\n  TArr extends ReadonlyArray<Derived<any> | Store<any>> = ReadonlyArray<any>,\n> {\n  onSubscribe?: (\n    listener: Listener<TState>,\n    derived: Derived<TState>,\n  ) => () => void\n  onUpdate?: () => void\n  deps: TArr\n  /**\n   * Values of the `deps` from before and after the current invocation of `fn`\n   */\n  fn: (props: DerivedFnProps<TArr>) => TState\n}\n\nexport class Derived<\n  TState,\n  const TArr extends ReadonlyArray<\n    Derived<any> | Store<any>\n  > = ReadonlyArray<any>,\n> {\n  listeners = new Set<Listener<TState>>()\n  state: TState\n  prevState: TState | undefined\n  options: DerivedOptions<TState, TArr>\n\n  /**\n   * Functions representing the subscriptions. Call a function to cleanup\n   * @private\n   */\n  _subscriptions: Array<() => void> = []\n\n  lastSeenDepValues: Array<unknown> = []\n  getDepVals = () => {\n    const l = this.options.deps.length\n    const prevDepVals = new Array<unknown>(l)\n    const currDepVals = new Array<unknown>(l)\n    for (let i = 0; i < l; i++) {\n      const dep = this.options.deps[i]!\n      prevDepVals[i] = dep.prevState\n      currDepVals[i] = dep.state\n    }\n    this.lastSeenDepValues = currDepVals\n    return {\n      prevDepVals,\n      currDepVals,\n      prevVal: this.prevState ?? undefined,\n    }\n  }\n\n  constructor(options: DerivedOptions<TState, TArr>) {\n    this.options = options\n    this.state = options.fn({\n      prevDepVals: undefined,\n      prevVal: undefined,\n      currDepVals: this.getDepVals().currDepVals as never,\n    })\n  }\n\n  registerOnGraph(\n    deps: ReadonlyArray<Derived<any> | Store<any>> = this.options.deps,\n  ) {\n    for (const dep of deps) {\n      if (dep instanceof Derived) {\n        // First register the intermediate derived value if it's not already registered\n        dep.registerOnGraph()\n        // Then register this derived with the dep's underlying stores\n        this.registerOnGraph(dep.options.deps)\n      } else if (dep instanceof Store) {\n        // Register the derived as related derived to the store\n        let relatedLinkedDerivedVals = __storeToDerived.get(dep)\n        if (!relatedLinkedDerivedVals) {\n          relatedLinkedDerivedVals = new Set()\n          __storeToDerived.set(dep, relatedLinkedDerivedVals)\n        }\n        relatedLinkedDerivedVals.add(this as never)\n\n        // Register the store as a related store to this derived\n        let relatedStores = __derivedToStore.get(this as never)\n        if (!relatedStores) {\n          relatedStores = new Set()\n          __derivedToStore.set(this as never, relatedStores)\n        }\n        relatedStores.add(dep)\n      }\n    }\n  }\n\n  unregisterFromGraph(\n    deps: ReadonlyArray<Derived<any> | Store<any>> = this.options.deps,\n  ) {\n    for (const dep of deps) {\n      if (dep instanceof Derived) {\n        this.unregisterFromGraph(dep.options.deps)\n      } else if (dep instanceof Store) {\n        const relatedLinkedDerivedVals = __storeToDerived.get(dep)\n        if (relatedLinkedDerivedVals) {\n          relatedLinkedDerivedVals.delete(this as never)\n        }\n\n        const relatedStores = __derivedToStore.get(this as never)\n        if (relatedStores) {\n          relatedStores.delete(dep)\n        }\n      }\n    }\n  }\n\n  recompute = () => {\n    this.prevState = this.state\n    const depVals = this.getDepVals()\n    this.state = this.options.fn(depVals as never)\n\n    this.options.onUpdate?.()\n  }\n\n  checkIfRecalculationNeededDeeply = () => {\n    for (const dep of this.options.deps) {\n      if (dep instanceof Derived) {\n        dep.checkIfRecalculationNeededDeeply()\n      }\n    }\n    let shouldRecompute = false\n    const lastSeenDepValues = this.lastSeenDepValues\n    const { currDepVals } = this.getDepVals()\n    for (let i = 0; i < currDepVals.length; i++) {\n      if (currDepVals[i] !== lastSeenDepValues[i]) {\n        shouldRecompute = true\n        break\n      }\n    }\n\n    if (shouldRecompute) {\n      this.recompute()\n    }\n  }\n\n  mount = () => {\n    this.registerOnGraph()\n    this.checkIfRecalculationNeededDeeply()\n\n    return () => {\n      this.unregisterFromGraph()\n      for (const cleanup of this._subscriptions) {\n        cleanup()\n      }\n    }\n  }\n\n  subscribe = (listener: Listener<TState>) => {\n    this.listeners.add(listener)\n    const unsub = this.options.onSubscribe?.(listener, this)\n    return () => {\n      this.listeners.delete(listener)\n      unsub?.()\n    }\n  }\n}\n"],"names":["Store","__storeToDerived","__derivedToStore"],"mappings":"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"}