npm - @tanstack/store - Versions diffs - 0.5.5 → 0.7.0 - Mend

@tanstack/store 0.5.5 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (39) hide show

package/dist/cjs/derived.cjs +119 -0
package/dist/cjs/derived.cjs.map +1 -0
package/dist/cjs/derived.d.cts +47 -0
package/dist/cjs/effect.cjs +24 -0
package/dist/cjs/effect.cjs.map +1 -0
package/dist/cjs/effect.d.cts +18 -0
package/dist/cjs/index.cjs +12 -41
package/dist/cjs/index.cjs.map +1 -1
package/dist/cjs/index.d.cts +5 -19
package/dist/cjs/scheduler.cjs +107 -0
package/dist/cjs/scheduler.cjs.map +1 -0
package/dist/cjs/scheduler.d.cts +27 -0
package/dist/cjs/store.cjs +29 -0
package/dist/cjs/store.cjs.map +1 -0
package/dist/cjs/store.d.cts +26 -0
package/dist/cjs/types.d.cts +15 -0
package/dist/esm/derived.d.ts +47 -0
package/dist/esm/derived.js +119 -0
package/dist/esm/derived.js.map +1 -0
package/dist/esm/effect.d.ts +18 -0
package/dist/esm/effect.js +24 -0
package/dist/esm/effect.js.map +1 -0
package/dist/esm/index.d.ts +5 -19
package/dist/esm/index.js +12 -41
package/dist/esm/index.js.map +1 -1
package/dist/esm/scheduler.d.ts +27 -0
package/dist/esm/scheduler.js +107 -0
package/dist/esm/scheduler.js.map +1 -0
package/dist/esm/store.d.ts +26 -0
package/dist/esm/store.js +29 -0
package/dist/esm/store.js.map +1 -0
package/dist/esm/types.d.ts +15 -0
package/package.json +8 -2
package/src/derived.ts +198 -0
package/src/effect.ts +42 -0
package/src/index.ts +5 -70
package/src/scheduler.ts +155 -0
package/src/store.ts +63 -0
package/src/types.ts +17 -0

package/src/derived.ts ADDED Viewed

@@ -0,0 +1,198 @@
+import { Store } from './store'
+import { __derivedToStore, __storeToDerived } from './scheduler'
+import type { Listener } from './types'
+export type UnwrapDerivedOrStore<T> =
+  T extends Derived<infer InnerD>
+    ? InnerD
+    : T extends Store<infer InnerS>
+      ? InnerS
+      : never
+type UnwrapReadonlyDerivedOrStoreArray<
+  TArr extends ReadonlyArray<Derived<any> | Store<any>>,
+> = TArr extends readonly [infer Head, ...infer Tail]
+  ? Head extends Derived<any> | Store<any>
+    ? Tail extends ReadonlyArray<Derived<any> | Store<any>>
+      ? [UnwrapDerivedOrStore<Head>, ...UnwrapReadonlyDerivedOrStoreArray<Tail>]
+      : []
+    : []
+  : []
+// Can't have currVal, as it's being evaluated from the current derived fn
+export interface DerivedFnProps<
+  TArr extends ReadonlyArray<Derived<any> | Store<any>> = ReadonlyArray<any>,
+  TUnwrappedArr extends
+    UnwrapReadonlyDerivedOrStoreArray<TArr> = UnwrapReadonlyDerivedOrStoreArray<TArr>,
+> {
+  // `undefined` if it's the first run
+  /**
+   * `undefined` if it's the first run
+   * @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
+   */
+  prevVal: unknown | undefined
+  prevDepVals: TUnwrappedArr | undefined
+  currDepVals: TUnwrappedArr
+}
+export interface DerivedOptions<
+  TState,
+  TArr extends ReadonlyArray<Derived<any> | Store<any>> = ReadonlyArray<any>,
+> {
+  onSubscribe?: (
+    listener: Listener<TState>,
+    derived: Derived<TState>,
+  ) => () => void
+  onUpdate?: () => void
+  deps: TArr
+  /**
+   * Values of the `deps` from before and after the current invocation of `fn`
+   */
+  fn: (props: DerivedFnProps<TArr>) => TState
+}
+export class Derived<
+  TState,
+  const TArr extends ReadonlyArray<
+    Derived<any> | Store<any>
+  > = ReadonlyArray<any>,
+> {
+  listeners = new Set<Listener<TState>>()
+  state: TState
+  prevState: TState | undefined
+  options: DerivedOptions<TState, TArr>
+  /**
+   * Functions representing the subscriptions. Call a function to cleanup
+   * @private
+   */
+  _subscriptions: Array<() => void> = []
+  lastSeenDepValues: Array<unknown> = []
+  getDepVals = () => {
+    const prevDepVals = [] as Array<unknown>
+    const currDepVals = [] as Array<unknown>
+    for (const dep of this.options.deps) {
+      prevDepVals.push(dep.prevState)
+      currDepVals.push(dep.state)
+    }
+    this.lastSeenDepValues = currDepVals
+    return {
+      prevDepVals,
+      currDepVals,
+      prevVal: this.prevState ?? undefined,
+    }
+  }
+  constructor(options: DerivedOptions<TState, TArr>) {
+    this.options = options
+    this.state = options.fn({
+      prevDepVals: undefined,
+      prevVal: undefined,
+      currDepVals: this.getDepVals().currDepVals as never,
+    })
+  }
+  registerOnGraph(
+    deps: ReadonlyArray<Derived<any> | Store<any>> = this.options.deps,
+  ) {
+    for (const dep of deps) {
+      if (dep instanceof Derived) {
+        // First register the intermediate derived value if it's not already registered
+        dep.registerOnGraph()
+        // Then register this derived with the dep's underlying stores
+        this.registerOnGraph(dep.options.deps)
+      } else if (dep instanceof Store) {
+        // Register the derived as related derived to the store
+        let relatedLinkedDerivedVals = __storeToDerived.get(dep)
+        if (!relatedLinkedDerivedVals) {
+          relatedLinkedDerivedVals = new Set()
+          __storeToDerived.set(dep, relatedLinkedDerivedVals)
+        }
+        relatedLinkedDerivedVals.add(this as never)
+        // Register the store as a related store to this derived
+        let relatedStores = __derivedToStore.get(this as never)
+        if (!relatedStores) {
+          relatedStores = new Set()
+          __derivedToStore.set(this as never, relatedStores)
+        }
+        relatedStores.add(dep)
+      }
+    }
+  }
+  unregisterFromGraph(
+    deps: ReadonlyArray<Derived<any> | Store<any>> = this.options.deps,
+  ) {
+    for (const dep of deps) {
+      if (dep instanceof Derived) {
+        this.unregisterFromGraph(dep.options.deps)
+      } else if (dep instanceof Store) {
+        const relatedLinkedDerivedVals = __storeToDerived.get(dep)
+        if (relatedLinkedDerivedVals) {
+          relatedLinkedDerivedVals.delete(this as never)
+        }
+        const relatedStores = __derivedToStore.get(this as never)
+        if (relatedStores) {
+          relatedStores.delete(dep)
+        }
+      }
+    }
+  }
+  recompute = () => {
+    this.prevState = this.state
+    const { prevDepVals, currDepVals, prevVal } = this.getDepVals()
+    this.state = this.options.fn({
+      prevDepVals: prevDepVals as never,
+      currDepVals: currDepVals as never,
+      prevVal,
+    })
+    this.options.onUpdate?.()
+  }
+  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()
+    }
+  }
+  mount = () => {
+    this.registerOnGraph()
+    this.checkIfRecalculationNeededDeeply()
+    return () => {
+      this.unregisterFromGraph()
+      for (const cleanup of this._subscriptions) {
+        cleanup()
+      }
+    }
+  }
+  subscribe = (listener: Listener<TState>) => {
+    this.listeners.add(listener)
+    const unsub = this.options.onSubscribe?.(listener, this)
+    return () => {
+      this.listeners.delete(listener)
+      unsub?.()
+    }
+  }
+}

package/src/effect.ts ADDED Viewed

@@ -0,0 +1,42 @@
+import { Derived } from './derived'
+import type { DerivedOptions } from './derived'
+interface EffectOptions
+  extends Omit<
+    DerivedOptions<unknown>,
+    'onUpdate' | 'onSubscribe' | 'lazy' | 'fn'
+  > {
+  /**
+   * Should the effect trigger immediately?
+   * @default false
+   */
+  eager?: boolean
+  fn: () => void
+}
+export class Effect {
+  /**
+   * @private
+   */
+  _derived: Derived<void>
+  constructor(opts: EffectOptions) {
+    const { eager, fn, ...derivedProps } = opts
+    this._derived = new Derived({
+      ...derivedProps,
+      fn: () => {},
+      onUpdate() {
+        fn()
+      },
+    })
+    if (eager) {
+      fn()
+    }
+  }
+  mount() {
+    return this._derived.mount()
+  }
+}

package/src/index.ts CHANGED Viewed

@@ -1,70 +1,5 @@
-export type AnyUpdater = (...args: Array<any>) => any
-export type Listener = () => void
-export interface StoreOptions<
-  TState,
-  TUpdater extends AnyUpdater = (cb: TState) => TState,
-> {
-  updateFn?: (previous: TState) => (updater: TUpdater) => TState
-  onSubscribe?: (
-    listener: Listener,
-    store: Store<TState, TUpdater>,
-  ) => () => void
-  onUpdate?: () => void
-}
-export class Store<
-  TState,
-  TUpdater extends AnyUpdater = (cb: TState) => TState,
-> {
-  listeners = new Set<Listener>()
-  state: TState
-  options?: StoreOptions<TState, TUpdater>
-  _batching = false
-  _flushing = 0
-  constructor(initialState: TState, options?: StoreOptions<TState, TUpdater>) {
-    this.state = initialState
-    this.options = options
-  }
-  subscribe = (listener: Listener) => {
-    this.listeners.add(listener)
-    const unsub = this.options?.onSubscribe?.(listener, this)
-    return () => {
-      this.listeners.delete(listener)
-      unsub?.()
-    }
-  }
-  setState = (updater: TUpdater) => {
-    const previous = this.state
-    this.state = this.options?.updateFn
-      ? this.options.updateFn(previous)(updater)
-      : (updater as any)(previous)
-    // Always run onUpdate, regardless of batching
-    this.options?.onUpdate?.()
-    // Attempt to flush
-    this._flush()
-  }
-  _flush = () => {
-    if (this._batching) return
-    const flushId = ++this._flushing
-    this.listeners.forEach((listener) => {
-      if (this._flushing !== flushId) return
-      listener()
-    })
-  }
-  batch = (cb: () => void) => {
-    if (this._batching) return cb()
-    this._batching = true
-    cb()
-    this._batching = false
-    this._flush()
-  }
-}
+export * from './derived'
+export * from './effect'
+export * from './store'
+export * from './types'
+export * from './scheduler'

package/src/scheduler.ts ADDED Viewed

@@ -0,0 +1,155 @@
+import { Derived } from './derived'
+import type { Store } from './store'
+/**
+ * This is here to solve the pyramid dependency problem where:
+ *       A
+ *      / \
+ *     B   C
+ *      \ /
+ *       D
+ *
+ * Where we deeply traverse this tree, how do we avoid D being recomputed twice; once when B is updated, once when C is.
+ *
+ * To solve this, we create linkedDeps that allows us to sync avoid writes to the state until all of the deps have been
+ * resolved.
+ *
+ * This is a record of stores, because derived stores are not able to write values to, but stores are
+ */
+export const __storeToDerived = new WeakMap<
+  Store<unknown>,
+  Set<Derived<unknown>>
+>()
+export const __derivedToStore = new WeakMap<
+  Derived<unknown>,
+  Set<Store<unknown>>
+>()
+export const __depsThatHaveWrittenThisTick = {
+  current: [] as Array<Derived<unknown> | Store<unknown>>,
+}
+let __isFlushing = false
+let __batchDepth = 0
+const __pendingUpdates = new Set<Store<unknown>>()
+// Add a map to store initial values before batch
+const __initialBatchValues = new Map<Store<unknown>, unknown>()
+function __flush_internals(relatedVals: Set<Derived<unknown>>) {
+  // First sort deriveds by dependency order
+  const sorted = Array.from(relatedVals).sort((a, b) => {
+    // If a depends on b, b should go first
+    if (a instanceof Derived && a.options.deps.includes(b)) return 1
+    // If b depends on a, a should go first
+    if (b instanceof Derived && b.options.deps.includes(a)) return -1
+    return 0
+  })
+  for (const derived of sorted) {
+    if (__depsThatHaveWrittenThisTick.current.includes(derived)) {
+      continue
+    }
+    __depsThatHaveWrittenThisTick.current.push(derived)
+    derived.recompute()
+    const stores = __derivedToStore.get(derived)
+    if (stores) {
+      for (const store of stores) {
+        const relatedLinkedDerivedVals = __storeToDerived.get(store)
+        if (!relatedLinkedDerivedVals) continue
+        __flush_internals(relatedLinkedDerivedVals)
+      }
+    }
+  }
+}
+function __notifyListeners(store: Store<unknown>) {
+  store.listeners.forEach((listener) =>
+    listener({
+      prevVal: store.prevState as never,
+      currentVal: store.state as never,
+    }),
+  )
+}
+function __notifyDerivedListeners(derived: Derived<unknown>) {
+  derived.listeners.forEach((listener) =>
+    listener({
+      prevVal: derived.prevState as never,
+      currentVal: derived.state as never,
+    }),
+  )
+}
+/**
+ * @private only to be called from `Store` on write
+ */
+export function __flush(store: Store<unknown>) {
+  // If we're starting a batch, store the initial values
+  if (__batchDepth > 0 && !__initialBatchValues.has(store)) {
+    __initialBatchValues.set(store, store.prevState)
+  }
+  __pendingUpdates.add(store)
+  if (__batchDepth > 0) return
+  if (__isFlushing) return
+  try {
+    __isFlushing = true
+    while (__pendingUpdates.size > 0) {
+      const stores = Array.from(__pendingUpdates)
+      __pendingUpdates.clear()
+      // First notify listeners with updated values
+      for (const store of stores) {
+        // Use initial batch values for prevState if we have them
+        const prevState = __initialBatchValues.get(store) ?? store.prevState
+        store.prevState = prevState
+        __notifyListeners(store)
+      }
+      // Then update all derived values
+      for (const store of stores) {
+        const derivedVals = __storeToDerived.get(store)
+        if (!derivedVals) continue
+        __depsThatHaveWrittenThisTick.current.push(store)
+        __flush_internals(derivedVals)
+      }
+      // Notify derived listeners after recomputing
+      for (const store of stores) {
+        const derivedVals = __storeToDerived.get(store)
+        if (!derivedVals) continue
+        for (const derived of derivedVals) {
+          __notifyDerivedListeners(derived)
+        }
+      }
+    }
+  } finally {
+    __isFlushing = false
+    __depsThatHaveWrittenThisTick.current = []
+    __initialBatchValues.clear()
+  }
+}
+export function batch(fn: () => void) {
+  __batchDepth++
+  try {
+    fn()
+  } finally {
+    __batchDepth--
+    if (__batchDepth === 0) {
+      const pendingUpdateToFlush = Array.from(__pendingUpdates)[0] as
+        | Store<unknown>
+        | undefined
+      if (pendingUpdateToFlush) {
+        __flush(pendingUpdateToFlush) // Trigger flush of all pending updates
+      }
+    }
+  }
+}

package/src/store.ts ADDED Viewed

@@ -0,0 +1,63 @@
+import { __flush } from './scheduler'
+import type { AnyUpdater, Listener } 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<
+  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
+  }
+  subscribe = (listener: Listener<TState>) => {
+    this.listeners.add(listener)
+    const unsub = this.options?.onSubscribe?.(listener, this)
+    return () => {
+      this.listeners.delete(listener)
+      unsub?.()
+    }
+  }
+  setState = (updater: TUpdater) => {
+    this.prevState = this.state
+    this.state = this.options?.updateFn
+      ? this.options.updateFn(this.prevState)(updater)
+      : (updater as any)(this.prevState)
+    // Always run onUpdate, regardless of batching
+    this.options?.onUpdate?.()
+    // Attempt to flush
+    __flush(this as never)
+  }
+}

package/src/types.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * @private
+ */
+export type AnyUpdater = (prev: any) => any
+/**
+ * @private
+ */
+export interface ListenerValue<T> {
+  prevVal: T
+  currentVal: T
+}
+/**
+ * @private
+ */
+export type Listener<T> = (value: ListenerValue<T>) => void