@take-out/helpers 0.2.9 → 0.3.0

package/src/emitter.tsx

@@ -16,7 +16,7 @@ import type { JSX, PropsWithChildren } from 'react'
 function useGet<A>(
   currentValue: A,
   initialValue?: any,
-  forwardToFunction?: boolean
+  forwardToFunction?: boolean,
 ): () => A {
   const curRef = React.useRef<any>(initialValue ?? currentValue)
 
@@ -29,7 +29,7 @@ function useGet<A>(
     forwardToFunction
       ? (...args) => curRef.current?.apply(null, args)
       : () => curRef.current,
-    [curRef, forwardToFunction]
+    [curRef, forwardToFunction],
   )
 }
 
@@ -78,7 +78,7 @@ this will emit the same value again, which can be desirable, but we warn to ensu
 
 - if you want this behavior, add { comparator: isEqualNever }
 - if you want only non-equal values: { comparator: isEqualIdentity }
-- if you want only deeply non-equal values: { comparator: isEqualDeep }`
+- if you want only deeply non-equal values: { comparator: isEqualDeep }`,
           )
         }
       }
@@ -110,7 +110,7 @@ this will emit the same value again, which can be desirable, but we warn to ensu
 export function createGlobalEmitter<T>(
   name: string,
   defaultValue: T,
-  options?: CreateEmitterOpts<T>
+  options?: CreateEmitterOpts<T>,
 ): Emitter<T> {
   return globalValue(name, () => createEmitter(name, defaultValue, options))
 }
@@ -118,7 +118,7 @@ export function createGlobalEmitter<T>(
 export function createEmitter<T>(
   name: string,
   defaultValue: T,
-  options?: CreateEmitterOpts<T>
+  options?: CreateEmitterOpts<T>,
 ): Emitter<T> {
   const existing = createOrUpdateCache(name, defaultValue) as T
   return new Emitter<T>(existing || defaultValue, { name, ...options })
@@ -130,7 +130,7 @@ export type EmitterType<E extends Emitter<any>> =
 export const useEmitter = <E extends Emitter<any>>(
   emitter: E,
   cb: (cb: EmitterType<E>) => void,
-  args?: any[]
+  args?: any[],
 ): void => {
   const getCallback = useGet(cb)
 
@@ -150,7 +150,7 @@ export const useEmitter = <E extends Emitter<any>>(
 
 export const useEmitterValue = <E extends Emitter<any>>(
   emitter: E,
-  options?: { disable?: boolean }
+  options?: { disable?: boolean },
 ): EmitterType<E> => {
   const disabled = options?.disable
 
@@ -204,7 +204,7 @@ export const useEmitterSelector = <E extends Emitter<any>, T extends EmitterType
     disable?: boolean
     lazy?: boolean
   },
-  args: any[] = EMPTY_ARRAY
+  args: any[] = EMPTY_ARRAY,
 ): R => {
   const [state, setState] = useState<R>(() => selector(emitter.value))
   const disabled = options?.disable
@@ -240,7 +240,7 @@ export const useEmitterSelector = <E extends Emitter<any>, T extends EmitterType
 export const useEmittersSelector = <const E extends readonly Emitter<any>[], R>(
   emitters: E,
   selector: (values: { [K in keyof E]: EmitterType<E[K]> }) => R,
-  options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean }
+  options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean },
 ): R => {
   const getSelector = useGet(selector)
   const disabled = options?.disable
@@ -290,23 +290,23 @@ export const useEmittersSelector = <const E extends readonly Emitter<any>[], R>(
 }
 
 export const createUseEmitter = <E extends Emitter<any>>(
-  emitter: E
+  emitter: E,
 ): ((cb: (val: EmitterType<E>) => void, args?: any[]) => void) => {
   return (cb: (val: EmitterType<E>) => void, args?: any[]) =>
     useEmitter(emitter, cb, args)
 }
 
 export const createUseSelector = <E extends Emitter<any>>(
-  emitter: E
+  emitter: E,
 ): (<R>(
   selector: (value: EmitterType<E>) => R,
   options?: { disable?: boolean; lazy?: boolean },
-  args?: any[]
+  args?: any[],
 ) => R) => {
   return <R,>(
     selector: (value: EmitterType<E>) => R,
     options?: { disable?: boolean; lazy?: boolean },
-    args?: any[]
+    args?: any[],
   ): R => {
     return useEmitterSelector(emitter, selector, options, args)
   }
@@ -315,7 +315,7 @@ export const createUseSelector = <E extends Emitter<any>>(
 export function createContextualEmitter<T>(
   name: string,
   defaultValue: T,
-  defaultOptions?: Omit<EmitterOptions<T>, 'name'>
+  defaultOptions?: Omit<EmitterOptions<T>, 'name'>,
 ): readonly [
   () => Emitter<T>,
   (props: PropsWithChildren<{ value?: T; silent?: boolean }>) => JSX.Element,
@@ -323,7 +323,7 @@ export function createContextualEmitter<T>(
   const id = Math.random().toString(36)
   const EmitterContext = createGlobalContext<Emitter<T> | null>(
     `contextual-emitter/${id}`,
-    null
+    null,
   )
 
   const useContextEmitter = () => {
@@ -342,7 +342,7 @@ export function createContextualEmitter<T>(
   const ProvideEmitter = (props: ProvideEmitterProps) => {
     const { children, value, silent } = props
     const [emitter] = useState(
-      () => new Emitter<T>(value ?? defaultValue, { name, silent, ...defaultOptions })
+      () => new Emitter<T>(value ?? defaultValue, { name, silent, ...defaultOptions }),
     )
 
     useLayoutEffect(() => {

package/src/ensure/ensure.ts

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

package/src/function/throttle.ts

@@ -25,7 +25,7 @@ interface Throttler<T extends unknown[]> {
 export function throttle<T extends unknown[]>(
   callback: (...args: T) => unknown,
   wait = 0,
-  { start = true, middle = true, once = false }: ThrottleOptions = {}
+  { start = true, middle = true, once = false }: ThrottleOptions = {},
 ): Throttler<T> {
   let innerStart = start
   let last = 0
@@ -52,7 +52,7 @@ export function throttle<T extends unknown[]>(
           callback.apply(this, args)
           if (once) fn.cancel()
         },
-        !middle ? wait : wait - delta
+        !middle ? wait : wait - delta,
       )
     }
   }
@@ -66,7 +66,7 @@ export function throttle<T extends unknown[]>(
 export function debounce<T extends unknown[]>(
   callback: (...args: T) => unknown,
   wait = 0,
-  { start = false, middle = false, once = false }: ThrottleOptions = {}
+  { start = false, middle = false, once = false }: ThrottleOptions = {},
 ): Throttler<T> {
   return throttle(callback, wait, { start, middle, once })
 }

package/src/global/globalValue.ts

@@ -23,7 +23,7 @@ export function globalValue<T>(
   factory: () => T,
   opts?: {
     warnMessage?: string
-  }
+  },
 ): T {
   const symbolKey = Symbol.for(key)
   const g = globalThis as Record<symbol, unknown>

package/src/object/decorateObject.ts

@@ -1,6 +1,6 @@
 export function decorateObject<T extends Record<string, any>>(
   obj: T,
-  decorator: (fn: Function) => Function
+  decorator: (fn: Function) => Function,
 ): T {
   const decorated = {} as T
 

package/src/object/mapObject.ts

@@ -1,6 +1,6 @@
 export function mapObject<T extends Record<string, any>, R>(
   obj: T,
-  fn: <K extends keyof T>(value: T[K], key: K) => R
+  fn: <K extends keyof T>(value: T[K], key: K) => R,
 ): { [K in keyof T]: R } {
   const result = {} as { [K in keyof T]: R }
 

package/src/object/object.ts

@@ -7,17 +7,17 @@ import type {
 
 export function postfixObjKeys<A extends { [key: string]: string }, B extends string>(
   obj: A,
-  postfix: B
+  postfix: B,
 ): {
   [Key in `${keyof A extends string ? keyof A : never}${B}`]: string
 } {
   return Object.fromEntries(
-    Object.entries(obj).map(([k, v]) => [`${k}${postfix}`, v])
+    Object.entries(obj).map(([k, v]) => [`${k}${postfix}`, v]),
   ) as any
 }
 
 export function objectFromEntries<ARR_T extends EntriesType>(
-  arr: ARR_T
+  arr: ARR_T,
 ): EntriesToObject<ARR_T> {
   return Object.fromEntries(arr) as EntriesToObject<ARR_T>
 }
@@ -27,7 +27,7 @@ export function objectKeys<O extends object>(obj: O) {
 }
 
 export function objectEntries<OBJ_T extends ObjectType>(
-  obj: OBJ_T
+  obj: OBJ_T,
 ): ObjectEntries<OBJ_T> {
   return Object.entries(obj) as ObjectEntries<OBJ_T>
 }

package/src/storage/storage.test.ts

@@ -65,7 +65,7 @@ describe('storage driver system', () => {
 
     it('should handle JSON serialization', () => {
       const storage = createStorage<'obj', { name: string; count: number }>(
-        `test-${Date.now()}-3`
+        `test-${Date.now()}-3`,
       )
       const obj = { name: 'test', count: 42 }
       storage.set('obj', obj)

package/src/string/pickLast.ts

@@ -1,6 +1,6 @@
 export function pickLast<T extends string | null | undefined>(
   a: T,
-  b: T
+  b: T,
 ): T extends string ? string : T {
   if (a == null && b == null) return undefined as any
   if (a == null) return b as any

package/src/string/pluralize.ts

@@ -7,9 +7,12 @@ export function pluralize(count: number, singular: string, plural: string): stri
       return `${count} ${singular}`
     case 'other':
       return `${count} ${plural}`
-    default:
+    case 'zero':
+    case 'two':
+    case 'few':
+    case 'many':
       throw new Error(
-        `Can't pluralize: ${grammaticalNumber} for ${count} / ${singular} / ${plural}`
+        `Can't pluralize: ${grammaticalNumber} for ${count} / ${singular} / ${plural}`,
       )
   }
 }

package/src/string/truncateList.ts

@@ -15,7 +15,7 @@
 export const truncateList = (
   items: string[],
   maxItems: number,
-  separator: string = ', '
+  separator: string = ', ',
 ): string => {
   if (items.length <= maxItems) {
     return items.join(separator)

package/src/time/formatDate.tsx

@@ -2,7 +2,7 @@ const currentYear = new Date().getFullYear()
 
 export function formatDate(
   date: Date,
-  options?: { daySuffix?: boolean }
+  options?: { daySuffix?: boolean },
 ): [string, string] | [string, string, string] {
   const months = [
     'January',

package/src/time/formatDateRelative.ts

@@ -33,7 +33,7 @@ export function formatDateRelative(date: Date | string | number): string {
       new Intl.DateTimeFormat('en', {
         hour: 'numeric',
         minute: 'numeric',
-      }).format(messageDate)
+      }).format(messageDate),
     )
   }
 
@@ -43,7 +43,7 @@ export function formatDateRelative(date: Date | string | number): string {
       new Intl.DateTimeFormat('en', {
         hour: 'numeric',
         minute: 'numeric',
-      }).format(messageDate)
+      }).format(messageDate),
     )
   }
 
@@ -55,7 +55,7 @@ export function formatDateRelative(date: Date | string | number): string {
         day: 'numeric',
         hour: 'numeric',
         minute: 'numeric',
-      }).format(messageDate)
+      }).format(messageDate),
     )
   }
 
@@ -67,6 +67,6 @@ export function formatDateRelative(date: Date | string | number): string {
       year: 'numeric',
       hour: 'numeric',
       minute: 'numeric',
-    }).format(messageDate)
+    }).format(messageDate),
   )
 }

package/src/time/useTimer.ts

@@ -36,7 +36,7 @@ export const useTimer = (): UseTimerReturn => {
         }, 1000)
       }
     },
-    [clearTimer]
+    [clearTimer],
   )
 
   const pauseTimer = useCallback(() => {
@@ -75,6 +75,6 @@ export const useTimer = (): UseTimerReturn => {
       resume: resumeTimer,
       clear: clearTimer,
     }),
-    [timerCount, clearTimer, pauseTimer, resetTimer, resumeTimer]
+    [timerCount, clearTimer, pauseTimer, resetTimer, resumeTimer],
   )
 }

package/src/url/urlValidate.ts

@@ -1,7 +1,7 @@
 // Source: https://stackoverflow.com/a/8234912/2013580
 
 const urlRegExp = new RegExp(
-  /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
+  /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/,
 )
 
 export function urlValidate(url: string): boolean {

package/types/async/abortable.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { AbortError, EnsureError } from '../error/errors'\n\ntype AbortableOptions = { message?: string }\n\nexport function abortable<T>(cb: () => T, options?: AbortableOptions): T | undefined\nexport function abortable<T>(\n  cb: () => Promise<T>,\n  options?: AbortableOptions\n): Promise<T | undefined>\nexport function abortable<T>(\n  cb: () => T | Promise<T>,\n  options?: AbortableOptions\n): T | undefined | Promise<T | undefined> {\n  try {\n    const value = cb()\n\n    if (value instanceof Promise) {\n      return value.catch((err) => {\n        if (didAbort(err, options)) {\n          return undefined\n        }\n        throw err\n      })\n    }\n\n    return value\n  } catch (err) {\n    if (didAbort(err, options)) {\n      return undefined\n    }\n    throw err\n  }\n}\n\nexport function didAbort(err: unknown, options?: AbortableOptions): boolean {\n  if (err instanceof AbortError || err instanceof EnsureError) {\n    if (options?.message) {\n      console.warn(`Aborted: ${options.message}`)\n    }\n    return true\n  }\n  return false\n}\n\nexport function handleAbortError(error: any, debug?: boolean): void {\n  if (error instanceof AbortError || error instanceof EnsureError) {\n    if (debug || process.env.DEBUG) {\n      console.info(`🐛 useAsyncEffect aborted: ${error.message}`)\n    }\n    return\n  }\n\n  // js handles aborting a promise as an error. ignore them since they're\n  // a normal part of the expected async workflow\n  if (typeof error === 'object' && error.name === 'AbortError') {\n    return\n  }\n\n  throw error\n}\n"
+    "import { AbortError, EnsureError } from '../error/errors'\n\ntype AbortableOptions = { message?: string }\n\nexport function abortable<T>(cb: () => T, options?: AbortableOptions): T | undefined\nexport function abortable<T>(\n  cb: () => Promise<T>,\n  options?: AbortableOptions,\n): Promise<T | undefined>\nexport function abortable<T>(\n  cb: () => T | Promise<T>,\n  options?: AbortableOptions,\n): T | undefined | Promise<T | undefined> {\n  try {\n    const value = cb()\n\n    if (value instanceof Promise) {\n      return value.catch((err: unknown) => {\n        if (didAbort(err, options)) {\n          return undefined\n        }\n        throw err\n      })\n    }\n\n    return value\n  } catch (err) {\n    if (didAbort(err, options)) {\n      return undefined\n    }\n    throw err\n  }\n}\n\nexport function didAbort(err: unknown, options?: AbortableOptions): boolean {\n  if (err instanceof AbortError || err instanceof EnsureError) {\n    if (options?.message) {\n      console.warn(`Aborted: ${options.message}`)\n    }\n    return true\n  }\n  return false\n}\n\nexport function handleAbortError(error: any, debug?: boolean): void {\n  if (error instanceof AbortError || error instanceof EnsureError) {\n    if (debug || process.env.DEBUG) {\n      console.info(`🐛 useAsyncEffect aborted: ${error.message}`)\n    }\n    return\n  }\n\n  // js handles aborting a promise as an error. ignore them since they're\n  // a normal part of the expected async workflow\n  if (typeof error === 'object' && error.name === 'AbortError') {\n    return\n  }\n\n  throw error\n}\n"
   ]
 }

package/types/async/asyncContext.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { isServerRuntime } from '../server/isServerRuntime'\n\ninterface AsyncContext<T> {\n  get(): T | undefined\n  run<R>(value: T, fn: () => R | Promise<R>): Promise<R>\n}\n\ninterface NodeAsyncLocalStorage<T> {\n  getStore(): T | undefined\n  run<R>(store: T, callback: () => R): R\n}\n\ninterface AsyncLocalStorageConstructor {\n  new <T>(): NodeAsyncLocalStorage<T>\n}\n\nlet nodeAsyncLocalStorageCache: AsyncLocalStorageConstructor | null = null\n\n// hide from vite/esbuild static analysis to avoid browser compat warning\nconst nodeModuleId = ['node', 'async_hooks'].join(':')\n\nasync function getNodeAsyncLocalStorage(): Promise<AsyncLocalStorageConstructor | null> {\n  if (!nodeAsyncLocalStorageCache) {\n    try {\n      const module = await import(/* @vite-ignore */ nodeModuleId)\n      nodeAsyncLocalStorageCache =\n        module.AsyncLocalStorage as AsyncLocalStorageConstructor\n    } catch {\n      return null\n    }\n  }\n  return nodeAsyncLocalStorageCache\n}\n\nexport function createAsyncContext<T>(): AsyncContext<T> {\n  if (isServerRuntime()) {\n    let storage: NodeAsyncLocalStorage<T> | null = null\n\n    getNodeAsyncLocalStorage().then((AsyncLocalStorage) => {\n      if (AsyncLocalStorage && !storage) {\n        storage = new AsyncLocalStorage<T>()\n      }\n    })\n\n    return {\n      get(): T | undefined {\n        if (!storage) {\n          console.warn(`⚠️ called AsyncContext before load!`)\n          return\n        }\n\n        return storage.getStore()\n      },\n\n      async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n        if (!storage) {\n          throw new Error(`⚠️ called AsyncContext before load!`)\n        }\n        return storage.run(value, fn)\n      },\n    }\n  } else {\n    // browser implementation using promise patching\n    return createBrowserAsyncContext<T>()\n  }\n}\n\nfunction createBrowserAsyncContext<T>(): AsyncContext<T> {\n  let currentContext: T | undefined\n  const contextStack: (T | undefined)[] = []\n\n  return {\n    get(): T | undefined {\n      return currentContext\n    },\n    async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n      const prevContext = currentContext\n      currentContext = value\n      contextStack.push(prevContext)\n\n      // store original Promise methods\n      const OriginalPromise = Promise\n      const OriginalThen = OriginalPromise.prototype.then\n      const OriginalCatch = OriginalPromise.prototype.catch\n      const OriginalFinally = OriginalPromise.prototype.finally\n\n      function wrapCallback(\n        callback: Function | undefined | null,\n        context: T | undefined\n      ): Function | undefined | null {\n        if (!callback) return callback\n        return (...args: any[]) => {\n          const prevContext = currentContext\n          currentContext = context\n          try {\n            return callback(...args)\n          } finally {\n            currentContext = prevContext\n          }\n        }\n      }\n\n      // patch Promise methods to capture and restore context\n      // eslint-disable-next-line no-then-property -- intentional patching for context propagation\n      OriginalPromise.prototype.then = function (\n        this: Promise<any>,\n        onFulfilled?: any,\n        onRejected?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalThen.call(\n          this,\n          wrapCallback(onFulfilled, context) as any,\n          wrapCallback(onRejected, context) as any\n        )\n      }\n\n      OriginalPromise.prototype.catch = function (\n        this: Promise<any>,\n        onRejected?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalCatch.call(this, wrapCallback(onRejected, context) as any)\n      }\n\n      OriginalPromise.prototype.finally = function (\n        this: Promise<any>,\n        onFinally?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalFinally.call(this, wrapCallback(onFinally, context) as any)\n      }\n\n      try {\n        const result = await fn()\n        return result\n      } finally {\n        // restore original Promise methods\n        // eslint-disable-next-line no-then-property -- restoring original methods\n        OriginalPromise.prototype.then = OriginalThen\n        OriginalPromise.prototype.catch = OriginalCatch\n        OriginalPromise.prototype.finally = OriginalFinally\n\n        contextStack.pop()\n        currentContext = prevContext\n      }\n    },\n  }\n}\n"
+    "import { isServerRuntime } from '../server/isServerRuntime'\n\ninterface AsyncContext<T> {\n  get(): T | undefined\n  run<R>(value: T, fn: () => R | Promise<R>): Promise<R>\n}\n\ninterface NodeAsyncLocalStorage<T> {\n  getStore(): T | undefined\n  run<R>(store: T, callback: () => R): R\n}\n\ninterface AsyncLocalStorageConstructor {\n  new <T>(): NodeAsyncLocalStorage<T>\n}\n\nlet nodeAsyncLocalStorageCache: AsyncLocalStorageConstructor | null = null\n\n// hide from vite/esbuild static analysis to avoid browser compat warning\nconst nodeModuleId = ['node', 'async_hooks'].join(':')\n\nasync function getNodeAsyncLocalStorage(): Promise<AsyncLocalStorageConstructor | null> {\n  if (!nodeAsyncLocalStorageCache) {\n    try {\n      const module = await import(/* @vite-ignore */ nodeModuleId)\n      nodeAsyncLocalStorageCache =\n        module.AsyncLocalStorage as AsyncLocalStorageConstructor\n    } catch {\n      return null\n    }\n  }\n  return nodeAsyncLocalStorageCache\n}\n\nexport function createAsyncContext<T>(): AsyncContext<T> {\n  if (isServerRuntime()) {\n    let storage: NodeAsyncLocalStorage<T> | null = null\n\n    getNodeAsyncLocalStorage().then((AsyncLocalStorage) => {\n      if (AsyncLocalStorage && !storage) {\n        storage = new AsyncLocalStorage<T>()\n      }\n    })\n\n    return {\n      get(): T | undefined {\n        if (!storage) {\n          console.warn(`⚠️ called AsyncContext before load!`)\n          return\n        }\n\n        return storage.getStore()\n      },\n\n      async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n        if (!storage) {\n          throw new Error(`⚠️ called AsyncContext before load!`)\n        }\n        return storage.run(value, fn)\n      },\n    }\n  } else {\n    // browser implementation using promise patching\n    return createBrowserAsyncContext<T>()\n  }\n}\n\nfunction createBrowserAsyncContext<T>(): AsyncContext<T> {\n  let currentContext: T | undefined\n  const contextStack: (T | undefined)[] = []\n\n  return {\n    get(): T | undefined {\n      return currentContext\n    },\n    async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n      const prevContext = currentContext\n      currentContext = value\n      contextStack.push(prevContext)\n\n      // store original Promise methods\n      const OriginalPromise = Promise\n      const OriginalThen = OriginalPromise.prototype.then\n      const OriginalCatch = OriginalPromise.prototype.catch\n      const OriginalFinally = OriginalPromise.prototype.finally\n\n      function wrapCallback(\n        callback: Function | undefined | null,\n        context: T | undefined,\n      ): Function | undefined | null {\n        if (!callback) return callback\n        return (...args: any[]) => {\n          const prevContext = currentContext\n          currentContext = context\n          try {\n            return callback(...args)\n          } finally {\n            currentContext = prevContext\n          }\n        }\n      }\n\n      // patch Promise methods to capture and restore context\n      // eslint-disable-next-line no-then-property -- intentional patching for context propagation\n      OriginalPromise.prototype.then = function (\n        this: Promise<any>,\n        onFulfilled?: any,\n        onRejected?: any,\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalThen.call(\n          this,\n          wrapCallback(onFulfilled, context) as any,\n          wrapCallback(onRejected, context) as any,\n        )\n      }\n\n      OriginalPromise.prototype.catch = function (\n        this: Promise<any>,\n        onRejected?: any,\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalCatch.call(this, wrapCallback(onRejected, context) as any)\n      }\n\n      OriginalPromise.prototype.finally = function (\n        this: Promise<any>,\n        onFinally?: any,\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalFinally.call(this, wrapCallback(onFinally, context) as any)\n      }\n\n      try {\n        const result = await fn()\n        return result\n      } finally {\n        // restore original Promise methods\n        // eslint-disable-next-line no-then-property -- restoring original methods\n        OriginalPromise.prototype.then = OriginalThen\n        OriginalPromise.prototype.catch = OriginalCatch\n        OriginalPromise.prototype.finally = OriginalFinally\n\n        contextStack.pop()\n        currentContext = prevContext\n      }\n    },\n  }\n}\n"
   ]
 }

package/types/async/asyncContext.native.d.ts.map

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

package/types/async/idle.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { AbortError } from '../error/errors'\nimport { sleep } from './sleep'\n\n/**\n * Two helpers wrapping requestIdleCallback in async, abortable.\n */\n\ntype CallbackFn = (...args: any[]) => any | (() => any)\ntype CallbackerFn = (cb: CallbackFn) => void\n\nconst idleCb: CallbackerFn =\n  typeof requestIdleCallback === 'undefined'\n    ? (cb: CallbackFn) => setTimeout(cb, 1)\n    : requestIdleCallback\n\nconst idleAsync = () => {\n  return new Promise((res) => {\n    idleCb(res)\n  })\n}\n\nexport type IdleOptions = {\n  max?: number\n  min?: number\n  fully?: boolean\n}\n\nexport const idle = async (\n  options?: IdleOptions,\n  signal?: AbortSignal\n): Promise<void> => {\n  const { max, min, fully } = options || {}\n\n  const idleFn = fully ? fullyIdle : idleAsync\n\n  if (max && min && min < max) {\n    await Promise.race([Promise.all([idleFn(), sleep(min)]), sleep(max)])\n  } else if (max) {\n    await Promise.race([idleFn(), sleep(max)])\n  } else if (min) {\n    await Promise.all([idleFn(), sleep(min)])\n  } else {\n    await idleFn()\n  }\n\n  if (signal?.aborted) {\n    throw new AbortError()\n  }\n}\n\nconst fullyIdle = async (signal?: AbortSignal): Promise<void> => {\n  while (true) {\n    const startTime = Date.now()\n    await idle({}, signal)\n    const endTime = Date.now()\n    const duration = endTime - startTime\n\n    // If idle callback took less than 15ms, consider it truly idle\n    if (duration < 15) {\n      break\n    }\n\n    // Check for abort signal after each iteration\n    if (signal?.aborted) {\n      throw new AbortError()\n    }\n  }\n}\n"
+    "import { AbortError } from '../error/errors'\nimport { sleep } from './sleep'\n\n/**\n * Two helpers wrapping requestIdleCallback in async, abortable.\n */\n\ntype CallbackFn = (...args: any[]) => any\ntype CallbackerFn = (cb: CallbackFn) => void\n\nconst idleCb: CallbackerFn =\n  typeof requestIdleCallback === 'undefined'\n    ? (cb: CallbackFn) => setTimeout(cb, 1)\n    : requestIdleCallback\n\nconst idleAsync = () => {\n  return new Promise((res) => {\n    idleCb(res)\n  })\n}\n\nexport type IdleOptions = {\n  max?: number\n  min?: number\n  fully?: boolean\n}\n\nexport const idle = async (\n  options?: IdleOptions,\n  signal?: AbortSignal,\n): Promise<void> => {\n  const { max, min, fully } = options || {}\n\n  const idleFn = fully ? fullyIdle : idleAsync\n\n  if (max && min && min < max) {\n    await Promise.race([Promise.all([idleFn(), sleep(min)]), sleep(max)])\n  } else if (max) {\n    await Promise.race([idleFn(), sleep(max)])\n  } else if (min) {\n    await Promise.all([idleFn(), sleep(min)])\n  } else {\n    await idleFn()\n  }\n\n  if (signal?.aborted) {\n    throw new AbortError()\n  }\n}\n\nconst fullyIdle = async (signal?: AbortSignal): Promise<void> => {\n  while (true) {\n    const startTime = Date.now()\n    await idle({}, signal)\n    const endTime = Date.now()\n    const duration = endTime - startTime\n\n    // If idle callback took less than 15ms, consider it truly idle\n    if (duration < 15) {\n      break\n    }\n\n    // Check for abort signal after each iteration\n    if (signal?.aborted) {\n      throw new AbortError()\n    }\n  }\n}\n"
   ]
 }

package/types/async/interval.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { sleep } from './sleep'\n\nexport const interval = async (\n  callback: () => void,\n  ms: number,\n  signal?: AbortSignal\n): Promise<never> => {\n  while (true) {\n    callback()\n    await sleep(ms, signal)\n  }\n}\n"
+    "import { sleep } from './sleep'\n\nexport const interval = async (\n  callback: () => void,\n  ms: number,\n  signal?: AbortSignal,\n): Promise<never> => {\n  while (true) {\n    callback()\n    await sleep(ms, signal)\n  }\n}\n"
   ]
 }

package/types/async/useAsync.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { useState, useEffect } from 'react'\n\nexport function useAsync<T>(\n  promiseFn: () => Promise<T>,\n  args: any[]\n): [T, 'loading' | 'idle' | 'error', Error | null] {\n  const [data, setData] = useState<T | null>(null)\n  const [error, setError] = useState<Error | null>(null)\n  const [loading, setLoading] = useState<boolean>(true)\n\n  useEffect(() => {\n    let isMounted = true\n\n    const fetchData = async () => {\n      try {\n        const result = await promiseFn()\n        if (isMounted) {\n          setData(result)\n          setLoading(false)\n        }\n      } catch (err) {\n        if (isMounted) {\n          setError(err as Error)\n          setLoading(false)\n        }\n      }\n    }\n\n    fetchData()\n\n    return () => {\n      isMounted = false\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, args)\n\n  return [data as T, error ? 'error' : loading ? 'loading' : 'idle', error]\n}\n"
+    "import { useState, useEffect } from 'react'\n\nexport function useAsync<T>(\n  promiseFn: () => Promise<T>,\n  args: any[],\n): [T, 'loading' | 'idle' | 'error', Error | null] {\n  const [data, setData] = useState<T | null>(null)\n  const [error, setError] = useState<Error | null>(null)\n  const [loading, setLoading] = useState<boolean>(true)\n\n  useEffect(() => {\n    let isMounted = true\n\n    const fetchData = async () => {\n      try {\n        const result = await promiseFn()\n        if (isMounted) {\n          setData(result)\n          setLoading(false)\n        }\n      } catch (err) {\n        if (isMounted) {\n          setError(err as Error)\n          setLoading(false)\n        }\n      }\n    }\n\n    fetchData()\n\n    return () => {\n      isMounted = false\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, args)\n\n  return [data as T, error ? 'error' : loading ? 'loading' : 'idle', error]\n}\n"
   ]
 }

package/types/async/useAsyncEffect.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "// adopted from https://github.com/franciscop/use-async/blob/master/src/index.js\n\nimport { useEffect, useId, useLayoutEffect } from 'react'\n\nimport { EMPTY_OBJECT } from '../constants'\nimport { getCurrentComponentStack } from '../react/getCurrentComponentStack'\nimport { handleAbortError } from './abortable'\n\ntype Cleanup = () => void\n\ntype AsyncEffectCallback = (\n  signal: AbortSignal,\n  ...deps: any[]\n) => Promise<Cleanup | void> | void\n\ntype AsyncEffectOptions = {\n  circuitBreakAfter?: number\n  circuitBreakPeriod?: number\n  debug?: boolean\n}\n\nexport function useAsyncEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions\n): void {\n  useAsyncEffectImpl(false, cb, deps, options)\n}\n\nexport function useAsyncLayoutEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions\n): void {\n  useAsyncEffectImpl(true, cb, deps, options)\n}\n\nfunction useAsyncEffectImpl(\n  isLayoutEffect: boolean,\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options: AsyncEffectOptions = EMPTY_OBJECT\n): void {\n  const effectHook = isLayoutEffect ? useLayoutEffect : useEffect\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const effectId = process.env.NODE_ENV === 'development' ? useId() : ''\n\n  effectHook(() => {\n    // Generate a unique ID for this effect instance for loop detection\n    checkEffectLoop(\n      effectId,\n      cb,\n      deps,\n      options.circuitBreakAfter,\n      options.circuitBreakPeriod\n    )\n    const controller = new AbortController()\n    const signal = controller.signal\n\n    // wrap in try in case its not async (for simple use cases)\n    try {\n      const value = cb(signal, ...deps)\n\n      Promise.resolve(value)\n        .then(async (res) => {\n          if (res && typeof res === 'function') {\n            if (signal.aborted) return res()\n            signal.addEventListener('abort', res)\n          }\n        })\n        .catch(handleAbortError)\n    } catch (error) {\n      handleAbortError(error, options.debug)\n    }\n\n    return () => {\n      if (signal.aborted) return\n      controller.abort()\n    }\n  }, deps)\n}\n\n// loop detection in dev mode\nlet effectRunCounts: Map<string, number[]>\nlet checkEffectLoop: (\n  effectId: string,\n  cb: AsyncEffectCallback,\n  deps: any[],\n  circuitBreakAfter?: number,\n  circuitBreakPeriod?: number\n) => void\n\nfunction formatDeps(deps: any[]): string {\n  try {\n    return JSON.stringify(\n      deps,\n      (_, v) => {\n        if (typeof v === 'function') return `[Function: ${v.name || 'anonymous'}]`\n        if (typeof v === 'symbol') return v.toString()\n        if (v instanceof Error) return `[Error: ${v.message}]`\n        return v\n      },\n      2\n    )\n  } catch {\n    return `[${deps.length} deps - not serializable]`\n  }\n}\n\nif (process.env.NODE_ENV === 'development') {\n  effectRunCounts = new Map<string, number[]>()\n\n  checkEffectLoop = (\n    effectId: string,\n    cb: AsyncEffectCallback,\n    deps: any[],\n    circuitBreakAfter: number = 20,\n    circuitBreakPeriod: number = 1000\n  ) => {\n    const now = Date.now()\n    const runs = effectRunCounts.get(effectId) || []\n\n    runs.push(now)\n\n    // keep only runs from the specified period\n    const recentRuns = runs.filter((time) => now - time < circuitBreakPeriod)\n    effectRunCounts.set(effectId, recentRuns)\n\n    const runCount = recentRuns.length\n\n    if (runCount > circuitBreakAfter) {\n      const message = `🚨 useAsyncEffect infinite loop detected! Effect ran ${runCount} times in <${circuitBreakPeriod}ms`\n      if (process.env.NODE_ENV === 'development') {\n        console.error(message)\n        console.error('Effect function:', cb.toString().slice(0, 500))\n        console.error('Dependencies:', formatDeps(deps))\n        console.error('Stack:', getCurrentComponentStack())\n        // eslint-disable-next-line no-debugger\n        debugger\n      } else {\n        alert(message)\n        throw new Error(message)\n      }\n    } else if (runCount > circuitBreakAfter / 2) {\n      console.warn(\n        `⚠️ useAsyncEffect potential loop: Effect ran ${runCount} times in <${circuitBreakPeriod}ms`\n      )\n      console.warn('Effect function:', cb.toString().slice(0, 500))\n      console.warn('Dependencies:', formatDeps(deps))\n      console.warn('Stack:', getCurrentComponentStack())\n    }\n  }\n} else {\n  checkEffectLoop = (_id, _cb, _deps, _after, _period) => {}\n}\n"
+    "// adopted from https://github.com/franciscop/use-async/blob/master/src/index.js\n\nimport { useEffect, useId, useLayoutEffect } from 'react'\n\nimport { EMPTY_OBJECT } from '../constants'\nimport { getCurrentComponentStack } from '../react/getCurrentComponentStack'\nimport { handleAbortError } from './abortable'\n\ntype Cleanup = () => void\n\ntype AsyncEffectCallback = (\n  signal: AbortSignal,\n  ...deps: any[]\n) => Promise<Cleanup | void> | void\n\ntype AsyncEffectOptions = {\n  circuitBreakAfter?: number\n  circuitBreakPeriod?: number\n  debug?: boolean\n}\n\nexport function useAsyncEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions,\n): void {\n  useAsyncEffectImpl(false, cb, deps, options)\n}\n\nexport function useAsyncLayoutEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions,\n): void {\n  useAsyncEffectImpl(true, cb, deps, options)\n}\n\nfunction useAsyncEffectImpl(\n  isLayoutEffect: boolean,\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options: AsyncEffectOptions = EMPTY_OBJECT,\n): void {\n  const effectHook = isLayoutEffect ? useLayoutEffect : useEffect\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  const effectId = process.env.NODE_ENV === 'development' ? useId() : ''\n\n  effectHook(() => {\n    // Generate a unique ID for this effect instance for loop detection\n    checkEffectLoop(\n      effectId,\n      cb,\n      deps,\n      options.circuitBreakAfter,\n      options.circuitBreakPeriod,\n    )\n    const controller = new AbortController()\n    const signal = controller.signal\n\n    // wrap in try in case its not async (for simple use cases)\n    try {\n      const value = cb(signal, ...deps)\n\n      Promise.resolve(value)\n        .then(async (res) => {\n          if (res && typeof res === 'function') {\n            if (signal.aborted) return res()\n            signal.addEventListener('abort', res)\n          }\n        })\n        .catch(handleAbortError)\n    } catch (error) {\n      handleAbortError(error, options.debug)\n    }\n\n    return () => {\n      if (signal.aborted) return\n      controller.abort()\n    }\n  }, deps)\n}\n\n// loop detection in dev mode\nlet effectRunCounts: Map<string, number[]>\nlet checkEffectLoop: (\n  effectId: string,\n  cb: AsyncEffectCallback,\n  deps: any[],\n  circuitBreakAfter?: number,\n  circuitBreakPeriod?: number,\n) => void\n\nfunction formatDeps(deps: any[]): string {\n  try {\n    return JSON.stringify(\n      deps,\n      (_, v) => {\n        if (typeof v === 'function') return `[Function: ${v.name || 'anonymous'}]`\n        if (typeof v === 'symbol') return v.toString()\n        if (v instanceof Error) return `[Error: ${v.message}]`\n        return v\n      },\n      2,\n    )\n  } catch {\n    return `[${deps.length} deps - not serializable]`\n  }\n}\n\nif (process.env.NODE_ENV === 'development') {\n  effectRunCounts = new Map<string, number[]>()\n\n  checkEffectLoop = (\n    effectId: string,\n    cb: AsyncEffectCallback,\n    deps: any[],\n    circuitBreakAfter: number = 20,\n    circuitBreakPeriod: number = 1000,\n  ) => {\n    const now = Date.now()\n    const runs = effectRunCounts.get(effectId) || []\n\n    runs.push(now)\n\n    // keep only runs from the specified period\n    const recentRuns = runs.filter((time) => now - time < circuitBreakPeriod)\n    effectRunCounts.set(effectId, recentRuns)\n\n    const runCount = recentRuns.length\n\n    if (runCount > circuitBreakAfter) {\n      const message = `🚨 useAsyncEffect infinite loop detected! Effect ran ${runCount} times in <${circuitBreakPeriod}ms`\n      if (process.env.NODE_ENV === 'development') {\n        console.error(message)\n        console.error('Effect function:', cb.toString().slice(0, 500))\n        console.error('Dependencies:', formatDeps(deps))\n        console.error('Stack:', getCurrentComponentStack())\n        // eslint-disable-next-line no-debugger\n        debugger\n      } else {\n        alert(message)\n        throw new Error(message)\n      }\n    } else if (runCount > circuitBreakAfter / 2) {\n      console.warn(\n        `⚠️ useAsyncEffect potential loop: Effect ran ${runCount} times in <${circuitBreakPeriod}ms`,\n      )\n      console.warn('Effect function:', cb.toString().slice(0, 500))\n      console.warn('Dependencies:', formatDeps(deps))\n      console.warn('Stack:', getCurrentComponentStack())\n    }\n  }\n} else {\n  checkEffectLoop = (_id, _cb, _deps, _after, _period) => {}\n}\n"
   ]
 }

package/types/async/useLazyMount.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { startTransition, useState } from 'react'\n\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nimport type React from 'react'\n\nexport type LazyMountProps = IdleOptions\n\nexport const useLazyMount = (props: LazyMountProps = { max: 100 }): boolean => {\n  const [mounted, setMounted] = useState(false)\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(props, signal)\n      startTransition(() => {\n        setMounted(true)\n      })\n    },\n    [\n      // no need for deps it only ever mounts once\n    ]\n  )\n\n  return mounted\n}\n\nexport const LazyMount = ({\n  children,\n  ...idleProps\n}: LazyMountProps & { children: any }): React.ReactNode => {\n  const mounted = useLazyMount(idleProps)\n  return mounted ? children : null\n}\n"
+    "import { startTransition, useState } from 'react'\n\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nimport type React from 'react'\n\nexport type LazyMountProps = IdleOptions\n\nexport const useLazyMount = (props: LazyMountProps = { max: 100 }): boolean => {\n  const [mounted, setMounted] = useState(false)\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(props, signal)\n      startTransition(() => {\n        setMounted(true)\n      })\n    },\n    [\n      // no need for deps it only ever mounts once\n    ],\n  )\n\n  return mounted\n}\n\nexport const LazyMount = ({\n  children,\n  ...idleProps\n}: LazyMountProps & { children: any }): React.ReactNode => {\n  const mounted = useLazyMount(idleProps)\n  return mounted ? children : null\n}\n"
   ]
 }

package/types/async/useLazyValue.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { startTransition, useState } from 'react'\n\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nexport const useLazyValue = <T>(\n  value: T,\n  {\n    immediateFirstUpdate,\n    ...idleOptions\n  }: IdleOptions & { immediateFirstUpdate?: boolean } = {}\n): T => {\n  const [lazyValue, setLazyValue] = useState(value)\n\n  // first update to a real value immediate\n  if (value && lazyValue === undefined && lazyValue !== value && immediateFirstUpdate) {\n    setLazyValue(value)\n  }\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(idleOptions, signal)\n      startTransition(() => {\n        setLazyValue(value)\n      })\n    },\n    [value]\n  )\n\n  return lazyValue\n}\n"
+    "import { startTransition, useState } from 'react'\n\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nexport const useLazyValue = <T>(\n  value: T,\n  {\n    immediateFirstUpdate,\n    ...idleOptions\n  }: IdleOptions & { immediateFirstUpdate?: boolean } = {},\n): T => {\n  const [lazyValue, setLazyValue] = useState(value)\n\n  // first update to a real value immediate\n  if (value && lazyValue === undefined && lazyValue !== value && immediateFirstUpdate) {\n    setLazyValue(value)\n  }\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(idleOptions, signal)\n      startTransition(() => {\n        setLazyValue(value)\n      })\n    },\n    [value],\n  )\n\n  return lazyValue\n}\n"
   ]
 }

package/types/browser/clearIndexedDB.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "export async function clearIndexedDB(): Promise<void> {\n  if ('indexedDB' in window) {\n    const databases = await indexedDB.databases()\n    await Promise.all(\n      databases.map((db) => {\n        if (db.name) {\n          return new Promise<void>((resolve, reject) => {\n            const deleteReq = indexedDB.deleteDatabase(db.name!)\n            deleteReq.onsuccess = () => resolve()\n            deleteReq.onerror = () => reject(deleteReq.error)\n            deleteReq.onblocked = () => reject(new Error('database deletion blocked'))\n          })\n        }\n        return Promise.resolve()\n      })\n    )\n  }\n}\n"
+    "export async function clearIndexedDB(): Promise<void> {\n  if ('indexedDB' in window) {\n    const databases = await indexedDB.databases()\n    await Promise.all(\n      databases.map((db) => {\n        if (db.name) {\n          return new Promise<void>((resolve, reject) => {\n            const deleteReq = indexedDB.deleteDatabase(db.name!)\n            deleteReq.onsuccess = () => resolve()\n            deleteReq.onerror = () => reject(deleteReq.error)\n            deleteReq.onblocked = () => reject(new Error('database deletion blocked'))\n          })\n        }\n        return Promise.resolve()\n      }),\n    )\n  }\n}\n"
   ]
 }

package/types/browser/openPopup.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "// note safari enhanced privacy will break this as it reports screen height as smaller\n\nexport function openCenteredPopup(\n  url: string,\n  title: string,\n  width: number,\n  height: number\n): Window | null {\n  // availWidth/availHeight accounts for taskbars, docks, and other UI elements\n  const screenWidth = screen.availWidth || screen.width\n  const screenHeight = screen.availHeight || screen.height\n\n  const shouldGuess = screenHeight < height\n\n  // if we are guessing, at least make it a bit more likely to be centered\n  // and not just touching the top which looks broken\n  const left = Math.max(0, (screenWidth - width) / 2) + (shouldGuess ? 100 : 0)\n  const top = Math.max(150, shouldGuess ? 150 : Math.max(0, (screenHeight - height) / 2))\n\n  const windowFeatures = `\n    width=${width},\n    height=${height},\n    left=${left},\n    top=${top},\n    scrollbars=yes,\n    resizable=yes\n  `\n\n  return window.open(url, title, windowFeatures)\n}\n"
+    "// note safari enhanced privacy will break this as it reports screen height as smaller\n\nexport function openCenteredPopup(\n  url: string,\n  title: string,\n  width: number,\n  height: number,\n): Window | null {\n  // availWidth/availHeight accounts for taskbars, docks, and other UI elements\n  const screenWidth = screen.availWidth || screen.width\n  const screenHeight = screen.availHeight || screen.height\n\n  const shouldGuess = screenHeight < height\n\n  // if we are guessing, at least make it a bit more likely to be centered\n  // and not just touching the top which looks broken\n  const left = Math.max(0, (screenWidth - width) / 2) + (shouldGuess ? 100 : 0)\n  const top = Math.max(150, shouldGuess ? 150 : Math.max(0, (screenHeight - height) / 2))\n\n  const windowFeatures = `\n    width=${width},\n    height=${height},\n    left=${left},\n    top=${top},\n    scrollbars=yes,\n    resizable=yes\n  `\n\n  return window.open(url, title, windowFeatures)\n}\n"
   ]
 }

package/types/constants.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { isWeb } from '@tamagui/constants'\n\nexport const isTauri: boolean = typeof window !== 'undefined' && '__TAURI__' in window\n\nexport const isNative: boolean = !isWeb && !isTauri\n\n// TODO move to probably ~/interface/constants\n\nexport const IS_MAC_DESKTOP: boolean =\n  typeof navigator !== 'undefined' && /Macintosh|MacIntel/.test(navigator.platform)\n\nexport const IS_SAFARI: boolean =\n  isTauri ||\n  (typeof navigator !== 'undefined' &&\n    /Version\\/[\\d.]+.*Safari/.test(navigator.userAgent) &&\n    /Apple Computer/.test(navigator.vendor))\n\nexport { isAndroid, isBrowser, isIos, isServer, isWeb } from '@tamagui/constants'\n\nexport const EMPTY_ARRAY = [] as never\nexport const EMPTY_OBJECT = {} as never\n\nconst getDebugLevelFromUrl = (): number | null => {\n  if (typeof window === 'undefined') return null\n  const match = window.location?.search?.match(/debug=(\\d+)/)\n  return match?.[1] ? parseInt(match[1], 10) : null\n}\n\nexport const DEBUG_LEVEL: number = process.env.DEBUG_LEVEL\n  ? +process.env.DEBUG_LEVEL\n  : (getDebugLevelFromUrl() ?? (process.env.NODE_ENV === 'development' ? 1 : 0))\n"
+    "import { isWeb } from '@tamagui/constants'\n\nexport const isTauri: boolean = typeof window !== 'undefined' && '__TAURI__' in window\n\nexport const isNative: boolean = !isWeb && !isTauri\n\n// TODO move to probably ~/interface/constants\n\nexport const IS_MAC_DESKTOP: boolean =\n  typeof navigator !== 'undefined' && /Macintosh|MacIntel/.test(navigator.platform)\n\nexport const IS_SAFARI: boolean =\n  isTauri ||\n  (typeof navigator !== 'undefined' &&\n    /Version\\/[\\d.]+.*Safari/.test(navigator.userAgent) &&\n    navigator.vendor.includes('Apple Computer'))\n\nexport { isAndroid, isBrowser, isIos, isServer, isWeb } from '@tamagui/constants'\n\nexport const EMPTY_ARRAY = [] as never\nexport const EMPTY_OBJECT = {} as never\n\nconst getDebugLevelFromUrl = (): number | null => {\n  if (typeof window === 'undefined') return null\n  const match = window.location?.search?.match(/debug=(\\d+)/)\n  return match?.[1] ? parseInt(match[1], 10) : null\n}\n\nexport const DEBUG_LEVEL: number = process.env.DEBUG_LEVEL\n  ? +process.env.DEBUG_LEVEL\n  : (getDebugLevelFromUrl() ?? (process.env.NODE_ENV === 'development' ? 1 : 0))\n"
   ]
 }

package/types/debug/debugUseState.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { useCallback } from 'react'\n\nexport function useDebugState<T>(\n  useState: [T, React.Dispatch<React.SetStateAction<T>>]\n): [T, React.Dispatch<React.SetStateAction<T>>] {\n  const [state, setState] = useState\n\n  const wrappedSetState = useCallback(\n    (newValue: T | ((prevState: T) => T)) => {\n      if (typeof newValue === 'function') {\n        // Handle callback style\n        setState((prevState: T) => {\n          const nextState = (newValue as (prevState: T) => T)(prevState)\n          console.trace('State update (callback):', {\n            prevState,\n            nextState,\n            stack: new Error().stack,\n          })\n          return nextState\n        })\n      } else {\n        // Handle direct value style\n        console.trace('State update (direct):', {\n          prevState: state,\n          nextState: newValue,\n          stack: new Error().stack,\n        })\n        setState(newValue)\n      }\n    },\n    [setState, state]\n  )\n\n  return [state, wrappedSetState]\n}\n"
+    "import { useCallback } from 'react'\n\nexport function useDebugState<T>(\n  useState: [T, React.Dispatch<React.SetStateAction<T>>],\n): [T, React.Dispatch<React.SetStateAction<T>>] {\n  const [state, setState] = useState\n\n  const wrappedSetState = useCallback(\n    (newValue: T | ((prevState: T) => T)) => {\n      if (typeof newValue === 'function') {\n        // Handle callback style\n        setState((prevState: T) => {\n          const nextState = (newValue as (prevState: T) => T)(prevState)\n          console.trace('State update (callback):', {\n            prevState,\n            nextState,\n            stack: new Error().stack,\n          })\n          return nextState\n        })\n      } else {\n        // Handle direct value style\n        console.trace('State update (direct):', {\n          prevState: state,\n          nextState: newValue,\n          stack: new Error().stack,\n        })\n        setState(newValue)\n      }\n    },\n    [setState, state],\n  )\n\n  return [state, wrappedSetState]\n}\n"
   ]
 }

package/types/emitter.d.ts.map

@@ -6,6 +6,6 @@
   ],
   "version": 3,
   "sourcesContent": [
-    "import { dequal } from 'dequal'\nimport * as React from 'react'\nimport { use, useLayoutEffect, useState } from 'react'\n\nimport { handleAbortError } from './async/abortable'\nimport { DEBUG_LEVEL, EMPTY_ARRAY } from './constants'\nimport { AbortError } from './error/errors'\nimport { globalValue } from './global/globalValue'\nimport { createGlobalContext } from './react/createGlobalContext'\n\nimport type { JSX, PropsWithChildren } from 'react'\n\n// keeps a reference to the current value easily\n\n// TODO can replace with useEffectEvent\nfunction useGet<A>(\n  currentValue: A,\n  initialValue?: any,\n  forwardToFunction?: boolean\n): () => A {\n  const curRef = React.useRef<any>(initialValue ?? currentValue)\n\n  useLayoutEffect(() => {\n    curRef.current = currentValue\n  })\n\n  // oxlint-disable-next-line exhaustive-deps\n  return React.useCallback(\n    forwardToFunction\n      ? (...args) => curRef.current?.apply(null, args)\n      : () => curRef.current,\n    [curRef, forwardToFunction]\n  )\n}\n\ntype EmitterOptions<T> = CreateEmitterOpts<T> & {\n  name: string\n}\n\ntype CreateEmitterOpts<T> = {\n  silent?: boolean\n  comparator?: (a: T, b: T) => boolean\n}\n\nexport class Emitter<const T> {\n  private disposables = new Set<(cb: any) => void>()\n  value: T\n  options?: EmitterOptions<T>\n\n  constructor(value: T, options?: EmitterOptions<T>) {\n    this.value = value\n    this.options = options\n  }\n\n  listen = (disposable: (cb: T) => void): (() => void) => {\n    this.disposables.add(disposable)\n    return (): void => {\n      this.disposables.delete(disposable)\n    }\n  }\n\n  emit = (next: T): void => {\n    if (process.env.NODE_ENV === 'development') {\n      setCache(this, next)\n    }\n    const compare = this.options?.comparator\n    if (compare) {\n      if (this.value && compare(this.value, next)) {\n        return\n      }\n    } else {\n      if (this.value === next) {\n        if (process.env.NODE_ENV === 'development') {\n          console.warn(\n            `[emitter] ${this.options?.name} no comparator option but received same value!\n            \nthis will emit the same value again, which can be desirable, but we warn to ensure it's not unintended:\n\n- if you want this behavior, add { comparator: isEqualNever }\n- if you want only non-equal values: { comparator: isEqualIdentity }\n- if you want only deeply non-equal values: { comparator: isEqualDeep }`\n          )\n        }\n      }\n    }\n    this.value = next\n    if (DEBUG_LEVEL > 1) {\n      if (!this.options?.silent) {\n        const name = this.options?.name\n        console.groupCollapsed(`📣 ${name}`)\n        console.info(next)\n        console.trace(`trace >`)\n        console.groupEnd()\n      }\n    }\n    this.disposables.forEach((cb) => cb(next))\n  }\n\n  nextValue = (): Promise<T> => {\n    return new Promise<T>((res) => {\n      const dispose = this.listen((val) => {\n        dispose()\n        res(val)\n      })\n    })\n  }\n}\n\n// just createEmitter but ensures it doesn't mess up on HMR\nexport function createGlobalEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>\n): Emitter<T> {\n  return globalValue(name, () => createEmitter(name, defaultValue, options))\n}\n\nexport function createEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>\n): Emitter<T> {\n  const existing = createOrUpdateCache(name, defaultValue) as T\n  return new Emitter<T>(existing || defaultValue, { name, ...options })\n}\n\nexport type EmitterType<E extends Emitter<any>> =\n  E extends Emitter<infer Val> ? Val : never\n\nexport const useEmitter = <E extends Emitter<any>>(\n  emitter: E,\n  cb: (cb: EmitterType<E>) => void,\n  args?: any[]\n): void => {\n  const getCallback = useGet(cb)\n\n  useLayoutEffect(() => {\n    return emitter.listen((val) => {\n      try {\n        getCallback()(val)\n      } catch (err) {\n        handleAbortError(err)\n      }\n    })\n  }, [emitter, getCallback])\n}\n\n// i think this was useSyncExternalStore but removed for concurrent rendering improvements\n// wondering if we could just always return a deferred value? or default to it?\n\nexport const useEmitterValue = <E extends Emitter<any>>(\n  emitter: E,\n  options?: { disable?: boolean }\n): EmitterType<E> => {\n  const disabled = options?.disable\n\n  // use a function initializer to get current emitter value\n  const [state, setState] = useState<EmitterType<E>>(() => emitter.value)\n\n  useLayoutEffect(() => {\n    if (disabled) return\n\n    // sync immediately in case emitter changed between render and effect\n    if (emitter.value !== state) {\n      setState(emitter.value)\n    }\n\n    return emitter.listen(setState)\n  }, [state, disabled, emitter])\n\n  return state\n}\n\n/**\n * By default selectors run every render, as well as when emitters update. This is a change\n * from the previous behavior where they only ran when emitters changed value.\n *\n * The reason for this is because emitters capture the variables in scope of the component\n * each render already by using \"useGet\" by default, which makes them easier to use - you\n * don't need to pass an args[] array except for edge cases.\n *\n * Before explaining why we switched to the default, understand the different uses:\n *\n * - Default behavior - selector is updated every render, and ran every render, as well as\n *   when emitter value changes, so you basically are always up to date.\n *\n * - Set an args[] array as the fourth argument - this will stop the automatic capturing\n *   and instead update selector only when you change args[] yourself. This is good for when you\n *   want explicit control over re-selection and rendering.\n *\n * - With { lazy: true }, the selector only runs when the emitter value changes. If used with\n *   args[], you capture the context of the selector based on args[], if not, it's based on the\n *   current render.\n *\n * I made this change when we had 16 usages of useEmitterSelector and 100% of them are doing very\n * cheap calculations, so this feels like the right pattern. For the rare case of a heavy selector,\n * you have the option to control it.\n *\n */\nexport const useEmitterSelector = <E extends Emitter<any>, T extends EmitterType<E>, R>(\n  emitter: E,\n  selector: (value: T) => R,\n  options?: {\n    disable?: boolean\n    lazy?: boolean\n  },\n  args: any[] = EMPTY_ARRAY\n): R => {\n  const [state, setState] = useState<R>(() => selector(emitter.value))\n  const disabled = options?.disable\n  const getSelector = useGet(selector)\n\n  if (options?.lazy !== true) {\n    const next = selector(emitter.value)\n    if (next !== state) {\n      setState(next)\n    }\n  }\n\n  useLayoutEffect(() => {\n    if (disabled) return\n    return emitter.listen((val) => {\n      try {\n        const selectorFn = args !== EMPTY_ARRAY ? selector : getSelector()\n        const next = selectorFn(val)\n        setState(next)\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    })\n    // oxlint-disable-next-line exhaustive-deps\n  }, [disabled, emitter, getSelector, ...args])\n\n  return state\n}\n\nexport const useEmittersSelector = <const E extends readonly Emitter<any>[], R>(\n  emitters: E,\n  selector: (values: { [K in keyof E]: EmitterType<E[K]> }) => R,\n  options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean }\n): R => {\n  const getSelector = useGet(selector)\n  const disabled = options?.disable\n\n  const [state, setState] = useState<R>(() => {\n    const values = emitters.map((e) => e.value) as { [K in keyof E]: EmitterType<E[K]> }\n    return getSelector()(values)\n  })\n\n  useLayoutEffect(() => {\n    if (disabled) {\n      return\n    }\n\n    const handler = () => {\n      const values = emitters.map((e) => e.value) as {\n        [K in keyof E]: EmitterType<E[K]>\n      }\n      try {\n        const next = getSelector()(values)\n        setState((prev) => {\n          if (options?.isEqual?.(prev, next)) {\n            return prev\n          }\n          if (dequal(prev, next)) {\n            return prev\n          }\n          return next\n        })\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    }\n\n    const disposals = emitters.map((emitter) => emitter.listen(handler))\n\n    return () => {\n      disposals.forEach((d) => d())\n    }\n    // oxlint-disable-next-line exhaustive-deps\n  }, [disabled, getSelector, ...emitters])\n\n  return state\n}\n\nexport const createUseEmitter = <E extends Emitter<any>>(\n  emitter: E\n): ((cb: (val: EmitterType<E>) => void, args?: any[]) => void) => {\n  return (cb: (val: EmitterType<E>) => void, args?: any[]) =>\n    useEmitter(emitter, cb, args)\n}\n\nexport const createUseSelector = <E extends Emitter<any>>(\n  emitter: E\n): (<R>(\n  selector: (value: EmitterType<E>) => R,\n  options?: { disable?: boolean; lazy?: boolean },\n  args?: any[]\n) => R) => {\n  return <R,>(\n    selector: (value: EmitterType<E>) => R,\n    options?: { disable?: boolean; lazy?: boolean },\n    args?: any[]\n  ): R => {\n    return useEmitterSelector(emitter, selector, options, args)\n  }\n}\n\nexport function createContextualEmitter<T>(\n  name: string,\n  defaultValue: T,\n  defaultOptions?: Omit<EmitterOptions<T>, 'name'>\n): readonly [\n  () => Emitter<T>,\n  (props: PropsWithChildren<{ value?: T; silent?: boolean }>) => JSX.Element,\n] {\n  const id = Math.random().toString(36)\n  const EmitterContext = createGlobalContext<Emitter<T> | null>(\n    `contextual-emitter/${id}`,\n    null\n  )\n\n  const useContextEmitter = () => {\n    const emitter = use(EmitterContext)\n    if (!emitter) {\n      throw new Error('useContextEmitter must be used within an EmitterProvider')\n    }\n    return emitter\n  }\n\n  type ProvideEmitterProps = PropsWithChildren<{\n    value?: T\n    silent?: boolean\n  }>\n\n  const ProvideEmitter = (props: ProvideEmitterProps) => {\n    const { children, value, silent } = props\n    const [emitter] = useState(\n      () => new Emitter<T>(value ?? defaultValue, { name, silent, ...defaultOptions })\n    )\n\n    useLayoutEffect(() => {\n      if (value !== undefined && value !== emitter.value) {\n        emitter.emit(value)\n      }\n    }, [value, emitter])\n\n    return <EmitterContext.Provider value={emitter}>{children}</EmitterContext.Provider>\n  }\n\n  return [useContextEmitter, ProvideEmitter] as const\n}\n\nconst HMRCache =\n  process.env.NODE_ENV === 'development'\n    ? new Map<string, { originalDefaultValue: unknown; currentValue: unknown }>()\n    : null\n\nfunction setCache(emitter: Emitter<any>, value: unknown) {\n  const name = emitter.options?.name\n  if (!name) return\n  const cache = HMRCache?.get(name)\n  if (!cache) return\n  cache.currentValue = value\n}\n\nfunction createOrUpdateCache(name: string, defaultValueProp: unknown) {\n  const existing = HMRCache?.get(name)\n  const defaultValue = dequal(existing?.originalDefaultValue, defaultValueProp)\n    ? existing?.currentValue\n    : defaultValueProp\n\n  if (!existing) {\n    HMRCache?.set(name, {\n      originalDefaultValue: defaultValueProp,\n      currentValue: defaultValue,\n    })\n  }\n\n  return defaultValue\n}\n"
+    "import { dequal } from 'dequal'\nimport * as React from 'react'\nimport { use, useLayoutEffect, useState } from 'react'\n\nimport { handleAbortError } from './async/abortable'\nimport { DEBUG_LEVEL, EMPTY_ARRAY } from './constants'\nimport { AbortError } from './error/errors'\nimport { globalValue } from './global/globalValue'\nimport { createGlobalContext } from './react/createGlobalContext'\n\nimport type { JSX, PropsWithChildren } from 'react'\n\n// keeps a reference to the current value easily\n\n// TODO can replace with useEffectEvent\nfunction useGet<A>(\n  currentValue: A,\n  initialValue?: any,\n  forwardToFunction?: boolean,\n): () => A {\n  const curRef = React.useRef<any>(initialValue ?? currentValue)\n\n  useLayoutEffect(() => {\n    curRef.current = currentValue\n  })\n\n  // oxlint-disable-next-line exhaustive-deps\n  return React.useCallback(\n    forwardToFunction\n      ? (...args) => curRef.current?.apply(null, args)\n      : () => curRef.current,\n    [curRef, forwardToFunction],\n  )\n}\n\ntype EmitterOptions<T> = CreateEmitterOpts<T> & {\n  name: string\n}\n\ntype CreateEmitterOpts<T> = {\n  silent?: boolean\n  comparator?: (a: T, b: T) => boolean\n}\n\nexport class Emitter<const T> {\n  private disposables = new Set<(cb: any) => void>()\n  value: T\n  options?: EmitterOptions<T>\n\n  constructor(value: T, options?: EmitterOptions<T>) {\n    this.value = value\n    this.options = options\n  }\n\n  listen = (disposable: (cb: T) => void): (() => void) => {\n    this.disposables.add(disposable)\n    return (): void => {\n      this.disposables.delete(disposable)\n    }\n  }\n\n  emit = (next: T): void => {\n    if (process.env.NODE_ENV === 'development') {\n      setCache(this, next)\n    }\n    const compare = this.options?.comparator\n    if (compare) {\n      if (this.value && compare(this.value, next)) {\n        return\n      }\n    } else {\n      if (this.value === next) {\n        if (process.env.NODE_ENV === 'development') {\n          console.warn(\n            `[emitter] ${this.options?.name} no comparator option but received same value!\n            \nthis will emit the same value again, which can be desirable, but we warn to ensure it's not unintended:\n\n- if you want this behavior, add { comparator: isEqualNever }\n- if you want only non-equal values: { comparator: isEqualIdentity }\n- if you want only deeply non-equal values: { comparator: isEqualDeep }`,\n          )\n        }\n      }\n    }\n    this.value = next\n    if (DEBUG_LEVEL > 1) {\n      if (!this.options?.silent) {\n        const name = this.options?.name\n        console.groupCollapsed(`📣 ${name}`)\n        console.info(next)\n        console.trace(`trace >`)\n        console.groupEnd()\n      }\n    }\n    this.disposables.forEach((cb) => cb(next))\n  }\n\n  nextValue = (): Promise<T> => {\n    return new Promise<T>((res) => {\n      const dispose = this.listen((val) => {\n        dispose()\n        res(val)\n      })\n    })\n  }\n}\n\n// just createEmitter but ensures it doesn't mess up on HMR\nexport function createGlobalEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>,\n): Emitter<T> {\n  return globalValue(name, () => createEmitter(name, defaultValue, options))\n}\n\nexport function createEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>,\n): Emitter<T> {\n  const existing = createOrUpdateCache(name, defaultValue) as T\n  return new Emitter<T>(existing || defaultValue, { name, ...options })\n}\n\nexport type EmitterType<E extends Emitter<any>> =\n  E extends Emitter<infer Val> ? Val : never\n\nexport const useEmitter = <E extends Emitter<any>>(\n  emitter: E,\n  cb: (cb: EmitterType<E>) => void,\n  args?: any[],\n): void => {\n  const getCallback = useGet(cb)\n\n  useLayoutEffect(() => {\n    return emitter.listen((val) => {\n      try {\n        getCallback()(val)\n      } catch (err) {\n        handleAbortError(err)\n      }\n    })\n  }, [emitter, getCallback])\n}\n\n// i think this was useSyncExternalStore but removed for concurrent rendering improvements\n// wondering if we could just always return a deferred value? or default to it?\n\nexport const useEmitterValue = <E extends Emitter<any>>(\n  emitter: E,\n  options?: { disable?: boolean },\n): EmitterType<E> => {\n  const disabled = options?.disable\n\n  // use a function initializer to get current emitter value\n  const [state, setState] = useState<EmitterType<E>>(() => emitter.value)\n\n  useLayoutEffect(() => {\n    if (disabled) return\n\n    // sync immediately in case emitter changed between render and effect\n    if (emitter.value !== state) {\n      setState(emitter.value)\n    }\n\n    return emitter.listen(setState)\n  }, [state, disabled, emitter])\n\n  return state\n}\n\n/**\n * By default selectors run every render, as well as when emitters update. This is a change\n * from the previous behavior where they only ran when emitters changed value.\n *\n * The reason for this is because emitters capture the variables in scope of the component\n * each render already by using \"useGet\" by default, which makes them easier to use - you\n * don't need to pass an args[] array except for edge cases.\n *\n * Before explaining why we switched to the default, understand the different uses:\n *\n * - Default behavior - selector is updated every render, and ran every render, as well as\n *   when emitter value changes, so you basically are always up to date.\n *\n * - Set an args[] array as the fourth argument - this will stop the automatic capturing\n *   and instead update selector only when you change args[] yourself. This is good for when you\n *   want explicit control over re-selection and rendering.\n *\n * - With { lazy: true }, the selector only runs when the emitter value changes. If used with\n *   args[], you capture the context of the selector based on args[], if not, it's based on the\n *   current render.\n *\n * I made this change when we had 16 usages of useEmitterSelector and 100% of them are doing very\n * cheap calculations, so this feels like the right pattern. For the rare case of a heavy selector,\n * you have the option to control it.\n *\n */\nexport const useEmitterSelector = <E extends Emitter<any>, T extends EmitterType<E>, R>(\n  emitter: E,\n  selector: (value: T) => R,\n  options?: {\n    disable?: boolean\n    lazy?: boolean\n  },\n  args: any[] = EMPTY_ARRAY,\n): R => {\n  const [state, setState] = useState<R>(() => selector(emitter.value))\n  const disabled = options?.disable\n  const getSelector = useGet(selector)\n\n  if (options?.lazy !== true) {\n    const next = selector(emitter.value)\n    if (next !== state) {\n      setState(next)\n    }\n  }\n\n  useLayoutEffect(() => {\n    if (disabled) return\n    return emitter.listen((val) => {\n      try {\n        const selectorFn = args !== EMPTY_ARRAY ? selector : getSelector()\n        const next = selectorFn(val)\n        setState(next)\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    })\n    // oxlint-disable-next-line exhaustive-deps\n  }, [disabled, emitter, getSelector, ...args])\n\n  return state\n}\n\nexport const useEmittersSelector = <const E extends readonly Emitter<any>[], R>(\n  emitters: E,\n  selector: (values: { [K in keyof E]: EmitterType<E[K]> }) => R,\n  options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean },\n): R => {\n  const getSelector = useGet(selector)\n  const disabled = options?.disable\n\n  const [state, setState] = useState<R>(() => {\n    const values = emitters.map((e) => e.value) as { [K in keyof E]: EmitterType<E[K]> }\n    return getSelector()(values)\n  })\n\n  useLayoutEffect(() => {\n    if (disabled) {\n      return\n    }\n\n    const handler = () => {\n      const values = emitters.map((e) => e.value) as {\n        [K in keyof E]: EmitterType<E[K]>\n      }\n      try {\n        const next = getSelector()(values)\n        setState((prev) => {\n          if (options?.isEqual?.(prev, next)) {\n            return prev\n          }\n          if (dequal(prev, next)) {\n            return prev\n          }\n          return next\n        })\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    }\n\n    const disposals = emitters.map((emitter) => emitter.listen(handler))\n\n    return () => {\n      disposals.forEach((d) => d())\n    }\n    // oxlint-disable-next-line exhaustive-deps\n  }, [disabled, getSelector, ...emitters])\n\n  return state\n}\n\nexport const createUseEmitter = <E extends Emitter<any>>(\n  emitter: E,\n): ((cb: (val: EmitterType<E>) => void, args?: any[]) => void) => {\n  return (cb: (val: EmitterType<E>) => void, args?: any[]) =>\n    useEmitter(emitter, cb, args)\n}\n\nexport const createUseSelector = <E extends Emitter<any>>(\n  emitter: E,\n): (<R>(\n  selector: (value: EmitterType<E>) => R,\n  options?: { disable?: boolean; lazy?: boolean },\n  args?: any[],\n) => R) => {\n  return <R,>(\n    selector: (value: EmitterType<E>) => R,\n    options?: { disable?: boolean; lazy?: boolean },\n    args?: any[],\n  ): R => {\n    return useEmitterSelector(emitter, selector, options, args)\n  }\n}\n\nexport function createContextualEmitter<T>(\n  name: string,\n  defaultValue: T,\n  defaultOptions?: Omit<EmitterOptions<T>, 'name'>,\n): readonly [\n  () => Emitter<T>,\n  (props: PropsWithChildren<{ value?: T; silent?: boolean }>) => JSX.Element,\n] {\n  const id = Math.random().toString(36)\n  const EmitterContext = createGlobalContext<Emitter<T> | null>(\n    `contextual-emitter/${id}`,\n    null,\n  )\n\n  const useContextEmitter = () => {\n    const emitter = use(EmitterContext)\n    if (!emitter) {\n      throw new Error('useContextEmitter must be used within an EmitterProvider')\n    }\n    return emitter\n  }\n\n  type ProvideEmitterProps = PropsWithChildren<{\n    value?: T\n    silent?: boolean\n  }>\n\n  const ProvideEmitter = (props: ProvideEmitterProps) => {\n    const { children, value, silent } = props\n    const [emitter] = useState(\n      () => new Emitter<T>(value ?? defaultValue, { name, silent, ...defaultOptions }),\n    )\n\n    useLayoutEffect(() => {\n      if (value !== undefined && value !== emitter.value) {\n        emitter.emit(value)\n      }\n    }, [value, emitter])\n\n    return <EmitterContext.Provider value={emitter}>{children}</EmitterContext.Provider>\n  }\n\n  return [useContextEmitter, ProvideEmitter] as const\n}\n\nconst HMRCache =\n  process.env.NODE_ENV === 'development'\n    ? new Map<string, { originalDefaultValue: unknown; currentValue: unknown }>()\n    : null\n\nfunction setCache(emitter: Emitter<any>, value: unknown) {\n  const name = emitter.options?.name\n  if (!name) return\n  const cache = HMRCache?.get(name)\n  if (!cache) return\n  cache.currentValue = value\n}\n\nfunction createOrUpdateCache(name: string, defaultValueProp: unknown) {\n  const existing = HMRCache?.get(name)\n  const defaultValue = dequal(existing?.originalDefaultValue, defaultValueProp)\n    ? existing?.currentValue\n    : defaultValueProp\n\n  if (!existing) {\n    HMRCache?.set(name, {\n      originalDefaultValue: defaultValueProp,\n      currentValue: defaultValue,\n    })\n  }\n\n  return defaultValue\n}\n"
   ]
 }