on-zero 0.7.10 → 0.8.0

package/src/helpers/NullToOptional.ts

@@ -0,0 +1,5 @@
+export type NullToOptional<T> = {
+  [K in keyof T as null extends T[K] ? K : never]?: Exclude<T[K], null> | undefined | null
+} & {
+  [K in keyof T as null extends T[K] ? never : K]: T[K]
+}

package/src/helpers/asyncContext.native.ts

@@ -0,0 +1,90 @@
+interface AsyncContext<T> {
+  get(): T | undefined
+  run<R>(value: T, fn: () => R | Promise<R>): Promise<R>
+}
+
+export function setupAsyncLocalStorage(_AsyncLocalStorage: unknown): void {}
+
+// react native implementation - no node:async_hooks available
+export function createAsyncContext<T>(): AsyncContext<T> {
+  let currentContext: T | undefined
+  const contextStack: (T | undefined)[] = []
+
+  return {
+    get(): T | undefined {
+      return currentContext
+    },
+    async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {
+      const prevContext = currentContext
+      currentContext = value
+      contextStack.push(prevContext)
+
+      // store original Promise methods
+      const OriginalPromise = Promise
+      const OriginalThen = OriginalPromise.prototype.then
+      const OriginalCatch = OriginalPromise.prototype.catch
+      const OriginalFinally = OriginalPromise.prototype.finally
+
+      function wrapCallback(
+        callback: Function | undefined | null,
+        context: T | undefined
+      ): Function | undefined | null {
+        if (!callback) return callback
+        return (...args: any[]) => {
+          const prevContext = currentContext
+          currentContext = context
+          try {
+            return callback(...args)
+          } finally {
+            currentContext = prevContext
+          }
+        }
+      }
+
+      // patch Promise methods to capture and restore context
+      // eslint-disable-next-line no-then-property -- intentional patching for context propagation
+      OriginalPromise.prototype.then = function (
+        this: Promise<any>,
+        onFulfilled?: any,
+        onRejected?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalThen.call(
+          this,
+          wrapCallback(onFulfilled, context) as any,
+          wrapCallback(onRejected, context) as any
+        )
+      }
+
+      OriginalPromise.prototype.catch = function (
+        this: Promise<any>,
+        onRejected?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalCatch.call(this, wrapCallback(onRejected, context) as any)
+      }
+
+      OriginalPromise.prototype.finally = function (
+        this: Promise<any>,
+        onFinally?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalFinally.call(this, wrapCallback(onFinally, context) as any)
+      }
+
+      try {
+        const result = await fn()
+        return result
+      } finally {
+        // restore original Promise methods
+        // eslint-disable-next-line no-then-property -- restoring original methods
+        OriginalPromise.prototype.then = OriginalThen
+        OriginalPromise.prototype.catch = OriginalCatch
+        OriginalPromise.prototype.finally = OriginalFinally
+
+        contextStack.pop()
+        currentContext = prevContext
+      }
+    },
+  }
+}

package/src/helpers/asyncContext.ts

@@ -0,0 +1,159 @@
+import { IS_SERVER_RUNTIME } from './platform'
+
+interface AsyncContext<T> {
+  get(): T | undefined
+  run<R>(value: T, fn: () => R | Promise<R>): Promise<R>
+}
+
+interface NodeAsyncLocalStorage<T> {
+  getStore(): T | undefined
+  run<R>(store: T, callback: () => R): R
+}
+
+interface AsyncLocalStorageConstructor {
+  new <T>(): NodeAsyncLocalStorage<T>
+}
+
+let nodeAsyncLocalStorageCache: AsyncLocalStorageConstructor | null = null
+let configuredAsyncLocalStorage: AsyncLocalStorageConstructor | null = null
+
+// hide from vite/esbuild static analysis to avoid browser compat warning
+const nodeModuleId = ['node', 'async_hooks'].join(':')
+
+export function setupAsyncLocalStorage(
+  AsyncLocalStorage: AsyncLocalStorageConstructor | null
+): void {
+  configuredAsyncLocalStorage = AsyncLocalStorage
+}
+
+async function getNodeAsyncLocalStorage(): Promise<AsyncLocalStorageConstructor | null> {
+  if (!nodeAsyncLocalStorageCache) {
+    try {
+      const module = await import(/* @vite-ignore */ nodeModuleId)
+      nodeAsyncLocalStorageCache =
+        module.AsyncLocalStorage as AsyncLocalStorageConstructor
+    } catch {
+      return null
+    }
+  }
+  return nodeAsyncLocalStorageCache
+}
+
+export function createAsyncContext<T>(): AsyncContext<T> {
+  if (IS_SERVER_RUNTIME) {
+    let storage: NodeAsyncLocalStorage<T> | null = null
+
+    const storageReady = Promise.resolve(configuredAsyncLocalStorage)
+      .then((AsyncLocalStorage) => AsyncLocalStorage || getNodeAsyncLocalStorage())
+      .then((AsyncLocalStorage) => {
+        if (AsyncLocalStorage && !storage) {
+          storage = new AsyncLocalStorage<T>()
+        }
+      })
+
+    return {
+      get(): T | undefined {
+        if (!storage) {
+          throw new Error(`AsyncContext storage not initialized`)
+        }
+        return storage.getStore()
+      },
+
+      async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {
+        if (!storage) {
+          await storageReady
+        }
+        if (!storage) {
+          throw new Error(`AsyncContext storage unavailable in server runtime`)
+        }
+        return storage.run(value, fn)
+      },
+    }
+  } else {
+    // browser implementation using promise patching
+    return createBrowserAsyncContext<T>()
+  }
+}
+
+function createBrowserAsyncContext<T>(): AsyncContext<T> {
+  let currentContext: T | undefined
+  const contextStack: (T | undefined)[] = []
+
+  return {
+    get(): T | undefined {
+      return currentContext
+    },
+    async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {
+      const prevContext = currentContext
+      currentContext = value
+      contextStack.push(prevContext)
+
+      // store original Promise methods
+      const OriginalPromise = Promise
+      const OriginalThen = OriginalPromise.prototype.then
+      const OriginalCatch = OriginalPromise.prototype.catch
+      const OriginalFinally = OriginalPromise.prototype.finally
+
+      function wrapCallback(
+        callback: Function | undefined | null,
+        context: T | undefined
+      ): Function | undefined | null {
+        if (!callback) return callback
+        return (...args: any[]) => {
+          const prevContext = currentContext
+          currentContext = context
+          try {
+            return callback(...args)
+          } finally {
+            currentContext = prevContext
+          }
+        }
+      }
+
+      // patch Promise methods to capture and restore context
+      // eslint-disable-next-line no-then-property -- intentional patching for context propagation
+      OriginalPromise.prototype.then = function (
+        this: Promise<any>,
+        onFulfilled?: any,
+        onRejected?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalThen.call(
+          this,
+          wrapCallback(onFulfilled, context) as any,
+          wrapCallback(onRejected, context) as any
+        )
+      }
+
+      OriginalPromise.prototype.catch = function (
+        this: Promise<any>,
+        onRejected?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalCatch.call(this, wrapCallback(onRejected, context) as any)
+      }
+
+      OriginalPromise.prototype.finally = function (
+        this: Promise<any>,
+        onFinally?: any
+      ): Promise<any> {
+        const context = currentContext
+        return OriginalFinally.call(this, wrapCallback(onFinally, context) as any)
+      }
+
+      try {
+        const result = await fn()
+        return result
+      } finally {
+        // restore original Promise methods
+        // eslint-disable-next-line no-then-property -- restoring original methods
+        OriginalPromise.prototype.then = OriginalThen
+        OriginalPromise.prototype.catch = OriginalCatch
+        OriginalPromise.prototype.finally = OriginalFinally
+
+        contextStack.pop()
+        currentContext = prevContext
+      }
+    },
+  }
+}

package/src/helpers/batchQuery.ts

@@ -1,4 +1,4 @@
-import { sleep } from '@take-out/helpers'
+import { sleep } from './sleep'
 
 import type { Query, Row } from '@rocicorp/zero'
 
@@ -18,7 +18,7 @@ export function createBatchQuery(server: ServerWithQuery) {
       chunk: number
       pause?: number
       stopAfter?: number
-    } = { chunk: 20 },
+    } = { chunk: 20 }
   ) {
     let hasMore = true
     let last: Item | null = null

package/src/helpers/createMutators.ts

@@ -1,7 +1,7 @@
-import { mapObject, time } from '@take-out/helpers'
-
 import { getAuthData } from '../state'
+import { mapObject } from './mapObject'
 import { runWithContext } from './mutatorContext'
+import { time } from './time'
 
 import type {
   AuthData,
@@ -26,6 +26,7 @@ export function createMutators<Models extends GenericModels>({
   authData,
   createServerActions,
   enqueueTask = () => {},
+  enqueueAction = () => {},
   can,
   models,
   validateMutation,
@@ -37,6 +38,7 @@ export function createMutators<Models extends GenericModels>({
   can: Can
   models: Models
   enqueueTask?: NonNullable<MutatorContext['server']>['enqueueTask']
+  enqueueAction?: NonNullable<MutatorContext['server']>['enqueueAction']
   createServerActions?: () => Record<string, any>
   validateMutation?: ValidateMutationFn
   /** valibot schemas keyed by model.mutationName, auto-validates args before running */
@@ -65,6 +67,7 @@ export function createMutators<Models extends GenericModels>({
             ? ({
                 actions: serverActions || {},
                 enqueueTask,
+                enqueueAction,
               } as MutatorContext['server'])
             : undefined,
       }
@@ -80,7 +83,7 @@ export function createMutators<Models extends GenericModels>({
 
   function withDevelopmentLogging<Args extends any[]>(
     name: string,
-    fn: (...args: Args) => Promise<void>,
+    fn: (...args: Args) => Promise<void>
   ) {
     if (process.env.NODE_ENV !== 'development' && !process.env.IS_TESTING) {
       return fn
@@ -131,7 +134,7 @@ export function createMutators<Models extends GenericModels>({
     fn: (...args: Args) => Promise<void>,
     // don't want this too high - zero runs mutations in order and waits for the last to finish it seems
     // so if one mutation gets stuck it will just sit there
-    timeoutMs: number = time.ms.minutes(1),
+    timeoutMs: number = time.ms.minutes(1)
   ) {
     return async (...args: Args): Promise<void> => {
       let timeoutId: ReturnType<typeof setTimeout> | undefined
@@ -152,7 +155,7 @@ export function createMutators<Models extends GenericModels>({
   function withValidation<Args extends any[]>(
     tableName: string,
     mutatorName: string,
-    fn: (...args: Args) => Promise<void>,
+    fn: (...args: Args) => Promise<void>
   ) {
     const validator = mutationValidators?.[tableName]?.[mutatorName]
 
@@ -200,9 +203,9 @@ export function createMutators<Models extends GenericModels>({
             withValidation(
               moduleName,
               name,
-              withContext((...args: any[]) => getDynamicFn()(...args)),
-            ),
-          ),
+              withContext((...args: any[]) => getDynamicFn()(...args))
+            )
+          )
         )
       }
     }

package/src/helpers/ellipsis.ts

@@ -0,0 +1,9 @@
+export const ellipsis = (str: string, maxLength: number): string => {
+  // avoid running replace on huge string if its long
+  const shortened = str.length > 500 ? str.slice(0, 500) : str
+  const cleaned = shortened.replace(/\s+/g, ' ').trim()
+  if (cleaned.length > maxLength) {
+    return cleaned.substring(0, maxLength - 3) + '…'
+  }
+  return cleaned
+}

package/src/helpers/emitter.tsx

@@ -0,0 +1,106 @@
+import { dequal } from 'dequal'
+import { useLayoutEffect, useState } from 'react'
+
+type EmitterOptions<T> = {
+  name: string
+  silent?: boolean
+  comparator?: (a: T, b: T) => boolean
+}
+
+type CreateEmitterOptions<T> = Omit<EmitterOptions<T>, 'name'>
+
+export class Emitter<const T> {
+  private listeners = new Set<(value: T) => void>()
+  value: T
+  options?: EmitterOptions<T>
+
+  constructor(value: T, options?: EmitterOptions<T>) {
+    this.value = value
+    this.options = options
+  }
+
+  listen = (listener: (value: T) => void): (() => void) => {
+    this.listeners.add(listener)
+    return () => {
+      this.listeners.delete(listener)
+    }
+  }
+
+  emit = (next: T): void => {
+    if (process.env.NODE_ENV === 'development') {
+      setCache(this, next)
+    }
+    const compare = this.options?.comparator
+    if (compare) {
+      if (this.value && compare(this.value, next)) {
+        return
+      }
+    } else if (this.value === next && process.env.NODE_ENV === 'development') {
+      console.warn(
+        `[emitter] ${this.options?.name} no comparator option but received same value`
+      )
+    }
+    this.value = next
+    this.listeners.forEach((listener) => listener(next))
+  }
+}
+
+export function createEmitter<T>(
+  name: string,
+  defaultValue: T,
+  options?: CreateEmitterOptions<T>
+): Emitter<T> {
+  const existing = createOrUpdateCache(name, defaultValue) as T
+  return new Emitter(existing || defaultValue, { name, ...options })
+}
+
+type EmitterValue<E extends Emitter<any>> = E extends Emitter<infer Value> ? Value : never
+
+export function useEmitterValue<E extends Emitter<any>>(
+  emitter: E,
+  options?: { disable?: boolean }
+): EmitterValue<E> {
+  const disabled = options?.disable
+  const [state, setState] = useState<EmitterValue<E>>(() => emitter.value)
+
+  useLayoutEffect(() => {
+    if (disabled) return
+
+    if (emitter.value !== state) {
+      setState(emitter.value)
+    }
+
+    return emitter.listen(setState)
+  }, [disabled, emitter])
+
+  return state
+}
+
+const hmrCache =
+  process.env.NODE_ENV === 'development'
+    ? new Map<string, { originalDefaultValue: unknown; currentValue: unknown }>()
+    : null
+
+function setCache(emitter: Emitter<any>, value: unknown) {
+  const name = emitter.options?.name
+  if (!name) return
+  const cache = hmrCache?.get(name)
+  if (!cache) return
+  cache.currentValue = value
+}
+
+function createOrUpdateCache(name: string, defaultValueProp: unknown) {
+  const existing = hmrCache?.get(name)
+  const defaultValue = dequal(existing?.originalDefaultValue, defaultValueProp)
+    ? existing?.currentValue
+    : defaultValueProp
+
+  if (!existing) {
+    hmrCache?.set(name, {
+      originalDefaultValue: defaultValueProp,
+      currentValue: defaultValue,
+    })
+  }
+
+  return defaultValue
+}

package/src/helpers/ensure.ts

@@ -0,0 +1,10 @@
+import { EnsureError } from './errors'
+
+export function ensure<T>(
+  value: T,
+  msg = ''
+): asserts value is Exclude<T, null | undefined | false> {
+  if (!value) {
+    throw new EnsureError(`ensure() invalid: (${value}): ${msg} ${new Error().stack}`)
+  }
+}

package/src/helpers/ensureLoggedIn.ts

@@ -1,5 +1,4 @@
-import { ensure } from '@take-out/helpers'
-
+import { ensure } from './ensure'
 import { mutatorContext } from './mutatorContext'
 
 import type { AuthData } from '../types'

package/src/helpers/errors.ts

@@ -0,0 +1,13 @@
+export class AbortError extends Error {
+  constructor(message = '') {
+    super(message)
+    this.name = 'AbortError'
+  }
+}
+
+export class EnsureError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'EnsureError'
+  }
+}

package/src/helpers/getCurrentComponentStack.ts

@@ -0,0 +1,56 @@
+import React from 'react'
+
+export const getCurrentComponentStack = (format?: 'short'): string => {
+  if (process.env.NODE_ENV === 'development') {
+    // react 19.1+ exposes captureOwnerStack as a public api
+    const captureOwnerStack = (React as Record<string, any>).captureOwnerStack
+    const stack = typeof captureOwnerStack === 'function' ? captureOwnerStack() : null
+
+    if (!stack) return ''
+
+    if (format === 'short') {
+      return formatStackToShort(stack)
+    }
+
+    return stack
+  }
+
+  return `(prod, no stack)`
+}
+
+const formatStackToShort = (stack: string): string => {
+  if (process.env.NODE_ENV === 'development') {
+    const lines = stack
+      // huge stack was causing issues
+      .slice(0, 6000)
+      .split('\n')
+
+    const componentNames: string[] = []
+
+    for (const line of lines) {
+      // Extract component names from patterns like "at ComponentName ("
+      // Also handle cases like "at Route((chat))" or "Route() ("
+      const match = line.match(/\s*at\s+([A-Z][a-zA-Z0-9_]*)\s*\(/)
+      if (match) {
+        const componentName = match[1]
+        // Filter out framework internals and keep user components
+        if (
+          componentName &&
+          componentName !== 'Array' &&
+          componentName !== 'Root' &&
+          componentName !== 'Route'
+        ) {
+          componentNames.push(componentName)
+          if (componentNames.length > 10) {
+            // avoid too many
+            break
+          }
+        }
+      }
+    }
+
+    return componentNames.join(' < ')
+  }
+
+  return stack
+}

package/src/helpers/globalValue.ts

@@ -0,0 +1,40 @@
+/**
+ * Helper to store a value that's not duplicated within the global context Uses
+ * a symbol stored on `globalThis` to achieve it.
+ *
+ * There's two main uses for this (for us, so far):
+ *
+ *   - in dev mode, HMR re-runs files, but you may want to preserve globals
+ *
+ *   - in published node modules, sometimes Vite or other bundlers can cause
+ *     duplicate dependencies either through bad setup or heuristics, they may
+ *     compile a module but then another code path doesn't compile it, so you
+ *     have duplicate modules. in this case it can be good to just use a
+ *     globalValue and warn the end-user. because you can't account for ever
+ *     possible weird configuration, and often fixing that config can be a
+ *     massive pain in the ass, it's better to retain functionality while
+ *     warning them so they can fix it at their own pace. this often happens
+ *     with WeakMaps.
+ *
+ */
+
+export function globalValue<T>(
+  key: string,
+  factory: () => T,
+  opts?: {
+    warnMessage?: string
+  }
+): T {
+  const symbolKey = Symbol.for(key)
+  const g = globalThis as Record<symbol, unknown>
+
+  if (!g[symbolKey]) {
+    g[symbolKey] = factory()
+  } else {
+    if (opts?.warnMessage) {
+      console.warn(`[globalValue] ${opts.warnMessage}`)
+    }
+  }
+
+  return g[symbolKey] as T
+}

package/src/helpers/mapObject.ts

@@ -0,0 +1,14 @@
+export function mapObject<T extends Record<string, any>, R>(
+  obj: T,
+  fn: <K extends keyof T>(value: T[K], key: K) => R
+): { [K in keyof T]: R } {
+  const result = {} as { [K in keyof T]: R }
+
+  for (const key in obj) {
+    if (Object.hasOwn(obj, key)) {
+      result[key] = fn(obj[key], key)
+    }
+  }
+
+  return result
+}