@stackframe/stack-shared 2.8.27 → 2.8.30

package/dist/utils/promises.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/promises.tsx"],"sourcesContent":["import { KnownError } from \"..\";\nimport { StackAssertionError, captureError, concatStacktraces } from \"./errors\";\nimport { DependenciesMap } from \"./maps\";\nimport { Result } from \"./results\";\nimport { generateUuid } from \"./uuids\";\n\nexport type ReactPromise<T> = Promise<T> & (\n  | { status: \"rejected\", reason: unknown }\n  | { status: \"fulfilled\", value: T }\n  | { status: \"pending\" }\n);\n\ntype Resolve<T> = (value: T) => void;\ntype Reject = (reason: unknown) => void;\nexport function createPromise<T>(callback: (resolve: Resolve<T>, reject: Reject) => void): ReactPromise<T> {\n  let status = \"pending\" as \"fulfilled\" | \"rejected\" | \"pending\";\n  let valueOrReason: T | unknown | undefined = undefined;\n  let resolve: Resolve<T> | null = null;\n  let reject: Reject | null = null;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = (value) => {\n      if (status !== \"pending\") return;\n      status = \"fulfilled\";\n      valueOrReason = value;\n      res(value);\n    };\n    reject = (reason) => {\n      if (status !== \"pending\") return;\n      status = \"rejected\";\n      valueOrReason = reason;\n      rej(reason);\n    };\n  });\n\n  callback(resolve!, reject!);\n  return Object.assign(promise, {\n    status: status,\n    ...status === \"fulfilled\" ? { value: valueOrReason as T } : {},\n    ...status === \"rejected\" ? { reason: valueOrReason } : {},\n  } as any);\n}\nundefined?.test(\"createPromise\", async ({ expect }) => {\n  // Test resolved promise\n  const resolvedPromise = createPromise<number>((resolve) => {\n    resolve(42);\n  });\n  expect(resolvedPromise.status).toBe(\"fulfilled\");\n  expect((resolvedPromise as any).value).toBe(42);\n  expect(await resolvedPromise).toBe(42);\n\n  // Test rejected promise\n  const error = new Error(\"Test error\");\n  const rejectedPromise = createPromise<number>((_, reject) => {\n    reject(error);\n  });\n  expect(rejectedPromise.status).toBe(\"rejected\");\n  expect((rejectedPromise as any).reason).toBe(error);\n  await expect(rejectedPromise).rejects.toBe(error);\n\n  // Test pending promise\n  const pendingPromise = createPromise<number>(() => {\n    // Do nothing, leave it pending\n  });\n  expect(pendingPromise.status).toBe(\"pending\");\n  expect((pendingPromise as any).value).toBeUndefined();\n  expect((pendingPromise as any).reason).toBeUndefined();\n\n  // Test that resolving after already resolved does nothing\n  let resolveCount = 0;\n  const multiResolvePromise = createPromise<number>((resolve) => {\n    resolve(1);\n    resolveCount++;\n    resolve(2);\n    resolveCount++;\n  });\n  expect(resolveCount).toBe(2); // Both resolve calls executed\n  expect(multiResolvePromise.status).toBe(\"fulfilled\");\n  expect((multiResolvePromise as any).value).toBe(1); // Only first resolve took effect\n  expect(await multiResolvePromise).toBe(1);\n});\n\nlet resolvedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `resolved` twice returns the same promise.\n */\nexport function resolved<T>(value: T): ReactPromise<T> {\n  resolvedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (resolvedCache.has([value])) {\n    return resolvedCache.get([value]) as ReactPromise<T>;\n  }\n\n  const res = Object.assign(Promise.resolve(value), {\n    status: \"fulfilled\",\n    value,\n  } as const);\n  resolvedCache.set([value], res);\n  return res;\n}\nundefined?.test(\"resolved\", async ({ expect }) => {\n  // Test with primitive value\n  const promise1 = resolved(42);\n  expect(promise1.status).toBe(\"fulfilled\");\n  // Need to use type assertion since value is only available when status is \"fulfilled\"\n  expect((promise1 as { value: number }).value).toBe(42);\n  expect(await promise1).toBe(42);\n\n  // Test with object value\n  const obj = { test: true };\n  const promise2 = resolved(obj);\n  expect(promise2.status).toBe(\"fulfilled\");\n  expect((promise2 as { value: typeof obj }).value).toBe(obj);\n  expect(await promise2).toBe(obj);\n\n  // Test caching (same reference for same value)\n  const promise3 = resolved(42);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different value (different reference)\n  const promise4 = resolved(43);\n  expect(promise4).not.toBe(promise1);\n});\n\nlet rejectedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `rejected` twice returns the same promise.\n */\nexport function rejected<T>(reason: unknown): ReactPromise<T> {\n  rejectedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (rejectedCache.has([reason])) {\n    return rejectedCache.get([reason]) as ReactPromise<T>;\n  }\n\n  const promise = Promise.reject(reason);\n  ignoreUnhandledRejection(promise);\n  const res = Object.assign(promise, {\n    status: \"rejected\",\n    reason: reason,\n  } as const);\n  rejectedCache.set([reason], res);\n  return res;\n}\nundefined?.test(\"rejected\", ({ expect }) => {\n  // Test with error object\n  const error = new Error(\"Test error\");\n  const promise1 = rejected<number>(error);\n  expect(promise1.status).toBe(\"rejected\");\n  // Need to use type assertion since reason is only available when status is \"rejected\"\n  expect((promise1 as { reason: Error }).reason).toBe(error);\n\n  // Test with string reason\n  const promise2 = rejected<string>(\"error message\");\n  expect(promise2.status).toBe(\"rejected\");\n  expect((promise2 as { reason: string }).reason).toBe(\"error message\");\n\n  // Test caching (same reference for same reason)\n  const promise3 = rejected<number>(error);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different reason (different reference)\n  const differentError = new Error(\"Different error\");\n  const promise4 = rejected<number>(differentError);\n  expect(promise4).not.toBe(promise1);\n\n  // Note: We're not using await expect(promise).rejects to avoid unhandled rejections\n});\n\n// We'll skip the rejection test for pending() since it's causing unhandled rejections\n// The function is already well tested through other tests like rejected() and createPromise()\n\n\nconst neverResolvePromise = pending(new Promise<never>(() => {}));\nexport function neverResolve(): ReactPromise<never> {\n  return neverResolvePromise;\n}\nundefined?.test(\"neverResolve\", ({ expect }) => {\n  const promise = neverResolve();\n  expect(promise.status).toBe(\"pending\");\n  expect((promise as any).value).toBeUndefined();\n  expect((promise as any).reason).toBeUndefined();\n\n  // Test that multiple calls return the same promise\n  const promise2 = neverResolve();\n  expect(promise2).toBe(promise);\n});\n\nexport function pending<T>(promise: Promise<T>, options: { disableErrorWrapping?: boolean } = {}): ReactPromise<T> {\n  const res = promise.then(\n    value => {\n      res.status = \"fulfilled\";\n      (res as any).value = value;\n      return value;\n    },\n    actualReason => {\n      res.status = \"rejected\";\n      (res as any).reason = actualReason;\n      throw actualReason;\n    },\n  ) as ReactPromise<T>;\n  res.status = \"pending\";\n  return res;\n}\nundefined?.test(\"pending\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  const pendingPromise = pending(resolvePromise);\n\n  // Initially it should be pending\n  expect(pendingPromise.status).toBe(\"pending\");\n\n  // After resolution, it should be fulfilled\n  await resolvePromise;\n  // Need to wait a tick for the then handler to execute\n  await new Promise(resolve => setTimeout(resolve, 0));\n  expect(pendingPromise.status).toBe(\"fulfilled\");\n  expect((pendingPromise as { value: number }).value).toBe(42);\n\n  // For the rejection test, we'll use a separate test to avoid unhandled rejections\n});\n\n/**\n * Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection\n * error.\n *\n * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.\n */\nexport function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): void {\n  promise.catch(() => {});\n}\nundefined?.test(\"ignoreUnhandledRejection\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  ignoreUnhandledRejection(resolvePromise);\n  expect(await resolvePromise).toBe(42); // Should still resolve to the same value\n\n  // Test with a promise that rejects\n  // The promise should still reject, but the rejection is caught internally\n  // so it doesn't cause an unhandled rejection error\n  const error = new Error(\"Test error\");\n  const rejectPromise = Promise.reject(error);\n  ignoreUnhandledRejection(rejectPromise);\n  await expect(rejectPromise).rejects.toBe(error);\n});\n\nexport async function wait(ms: number) {\n  if (!Number.isFinite(ms) || ms < 0) {\n    throw new StackAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);\n  }\n  if (ms >= 2**31) {\n    throw new StackAssertionError(\"The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)\");\n  }\n  return await new Promise<void>(resolve => setTimeout(resolve, ms));\n}\nundefined?.test(\"wait\", async ({ expect }) => {\n  // Test with valid input\n  const start = Date.now();\n  await wait(10);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with zero\n  await expect(wait(0)).resolves.toBeUndefined();\n\n  // Test with negative number\n  await expect(wait(-10)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with non-finite number\n  await expect(wait(NaN)).rejects.toThrow(\"wait() requires a non-negative integer\");\n  await expect(wait(Infinity)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with too large number\n  await expect(wait(2**31)).rejects.toThrow(\"The maximum timeout for wait()\");\n});\n\nexport async function waitUntil(date: Date) {\n  return await wait(date.getTime() - Date.now());\n}\nundefined?.test(\"waitUntil\", async ({ expect }) => {\n  // Test with future date\n  const futureDate = new Date(Date.now() + 10);\n  const start = Date.now();\n  await waitUntil(futureDate);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with past date - this will throw because wait() requires non-negative time\n  // We need to verify it throws the correct error\n  try {\n    await waitUntil(new Date(Date.now() - 1000));\n    expect.fail(\"Should have thrown an error\");\n  } catch (error) {\n    expect(error).toBeInstanceOf(StackAssertionError);\n    expect((error as Error).message).toContain(\"wait() requires a non-negative integer\");\n  }\n});\n\nexport function runAsynchronouslyWithAlert(...args: Parameters<typeof runAsynchronously>) {\n  return runAsynchronously(\n    args[0],\n    {\n      ...args[1],\n      onError: error => {\n        if (KnownError.isKnownError(error) && typeof process !== \"undefined\" && (process.env.NODE_ENV as any)?.includes(\"production\")) {\n          alert(error.message);\n        } else {\n          alert(`An unhandled error occurred. Please ${process.env.NODE_ENV === \"development\" ? `check the browser console for the full error.` : \"report this to the developer.\"}\\n\\n${error}`);\n        }\n        args[1]?.onError?.(error);\n      },\n    },\n    ...args.slice(2) as [],\n  );\n}\nundefined?.test(\"runAsynchronouslyWithAlert\", ({ expect }) => {\n  // Simple test to verify the function calls runAsynchronously\n  // We can't easily test the alert functionality without mocking\n  const testFn = () => Promise.resolve(\"test\");\n  const testOptions = { noErrorLogging: true };\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronouslyWithAlert(testFn, testOptions)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called\n  expect(typeof runAsynchronouslyWithAlert).toBe(\"function\");\n});\n\nexport function runAsynchronously(\n  promiseOrFunc: void | Promise<unknown> | (() => void | Promise<unknown>) | undefined,\n  options: {\n    noErrorLogging?: boolean,\n    onError?: (error: Error) => void,\n  } = {},\n): void {\n  if (typeof promiseOrFunc === \"function\") {\n    promiseOrFunc = promiseOrFunc();\n  }\n  const duringError = new Error();\n  promiseOrFunc?.catch(error => {\n    options.onError?.(error);\n    const newError = new StackAssertionError(\n      \"Uncaught error in asynchronous function: \" + error.toString(),\n      { cause: error },\n    );\n    concatStacktraces(newError, duringError);\n    if (!options.noErrorLogging) {\n      captureError(\"runAsynchronously\", newError);\n    }\n  });\n}\nundefined?.test(\"runAsynchronously\", ({ expect }) => {\n  // Simple test to verify the function exists and can be called\n  const testFn = () => Promise.resolve(\"test\");\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronously(testFn)).not.toThrow();\n  expect(() => runAsynchronously(Promise.resolve(\"test\"))).not.toThrow();\n  expect(() => runAsynchronously(undefined)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called with options\n  expect(() => runAsynchronously(testFn, { noErrorLogging: true })).not.toThrow();\n  expect(() => runAsynchronously(testFn, { onError: () => {} })).not.toThrow();\n});\n\n\nclass TimeoutError extends Error {\n  constructor(public readonly ms: number) {\n    super(`Timeout after ${ms}ms`);\n    this.name = \"TimeoutError\";\n  }\n}\n\nexport async function timeout<T>(promise: Promise<T>, ms: number): Promise<Result<T, TimeoutError>> {\n  return await Promise.race([\n    promise.then(value => Result.ok(value)),\n    wait(ms).then(() => Result.error(new TimeoutError(ms))),\n  ]);\n}\nundefined?.test(\"timeout\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeout(fastPromise, 100);\n  expect(fastResult.status).toBe(\"ok\");\n  if (fastResult.status === \"ok\") {\n    expect(fastResult.data).toBe(42);\n  }\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  const slowResult = await timeout(slowPromise, 10);\n  expect(slowResult.status).toBe(\"error\");\n  if (slowResult.status === \"error\") {\n    expect(slowResult.error).toBeInstanceOf(TimeoutError);\n    expect((slowResult.error as TimeoutError).ms).toBe(10);\n  }\n});\n\nexport async function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T> {\n  return Result.orThrow(await timeout(promise, ms));\n}\nundefined?.test(\"timeoutThrow\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeoutThrow(fastPromise, 100);\n  expect(fastResult).toBe(42);\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toThrow(\"Timeout after 10ms\");\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toBeInstanceOf(TimeoutError);\n});\n\n\nexport type RateLimitOptions = {\n  /**\n   * The number of requests to process in parallel. Currently only 1 is supported.\n   */\n  concurrency: 1,\n\n  /**\n   * If true, multiple requests waiting at the same time will be reduced to just one. Default is false.\n   */\n  batchCalls?: boolean,\n\n  /**\n   * Waits for throttleMs since the start of last request before starting the next request. Default is 0.\n   */\n  throttleMs?: number,\n\n  /**\n   * Waits for gapMs since the end of last request before starting the next request. Default is 0.\n   */\n  gapMs?: number,\n\n  /**\n   * Waits until there have been no new requests for debounceMs before starting a new request. Default is 0.\n   */\n  debounceMs?: number,\n};\n\nexport function rateLimited<T>(\n  func: () => Promise<T>,\n  options: RateLimitOptions,\n): () => Promise<T> {\n  let waitUntil = performance.now();\n  let queue: [(t: T) => void, (e: unknown) => void][] = [];\n  let addedToQueueCallbacks = new Map<string, () => void>;\n\n  const next = async () => {\n    while (true) {\n      if (waitUntil > performance.now()) {\n        await wait(Math.max(1, waitUntil - performance.now() + 1));\n      } else if (queue.length === 0) {\n        const uuid = generateUuid();\n        await new Promise<void>(resolve => {\n          addedToQueueCallbacks.set(uuid, resolve);\n        });\n        addedToQueueCallbacks.delete(uuid);\n      } else {\n        break;\n      }\n    }\n    const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()!];\n\n    const start = performance.now();\n    const value = await Result.fromPromise(func());\n    const end = performance.now();\n\n    waitUntil = Math.max(\n      waitUntil,\n      start + (options.throttleMs ?? 0),\n      end + (options.gapMs ?? 0),\n    );\n\n    for (const nextFunc of nextFuncs) {\n      if (value.status === \"ok\") {\n        nextFunc[0](value.data);\n      } else {\n        nextFunc[1](value.error);\n      }\n    }\n  };\n\n  runAsynchronously(async () => {\n    while (true) {\n      await next();\n    }\n  });\n\n  return () => {\n    return new Promise<T>((resolve, reject) => {\n      waitUntil = Math.max(\n        waitUntil,\n        performance.now() + (options.debounceMs ?? 0),\n      );\n      queue.push([resolve, reject]);\n      addedToQueueCallbacks.forEach(cb => cb());\n    });\n  };\n}\n\nexport function throttled<T, A extends any[]>(func: (...args: A) => Promise<T>, delayMs: number): (...args: A) => Promise<T> {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let nextAvailable: Promise<T> | null = null;\n  return async (...args) => {\n    while (nextAvailable !== null) {\n      await nextAvailable;\n    }\n    nextAvailable = new Promise<T>(resolve => {\n      timeout = setTimeout(() => {\n        nextAvailable = null;\n        resolve(func(...args));\n      }, delayMs);\n    });\n    return await nextAvailable;\n  };\n}\n"],"mappings":"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","names":["waitUntil","timeout"]}
+{"version":3,"sources":["../../src/utils/promises.tsx"],"sourcesContent":["import { KnownError } from \"..\";\nimport { StackAssertionError, captureError, concatStacktraces, errorToNiceString } from \"./errors\";\nimport { DependenciesMap } from \"./maps\";\nimport { Result } from \"./results\";\nimport { generateUuid } from \"./uuids\";\n\nexport type ReactPromise<T> = Promise<T> & (\n  | { status: \"rejected\", reason: unknown }\n  | { status: \"fulfilled\", value: T }\n  | { status: \"pending\" }\n);\n\ntype Resolve<T> = (value: T) => void;\ntype Reject = (reason: unknown) => void;\nexport function createPromise<T>(callback: (resolve: Resolve<T>, reject: Reject) => void): ReactPromise<T> {\n  let status = \"pending\" as \"fulfilled\" | \"rejected\" | \"pending\";\n  let valueOrReason: T | unknown | undefined = undefined;\n  let resolve: Resolve<T> | null = null;\n  let reject: Reject | null = null;\n  const promise = new Promise<T>((res, rej) => {\n    resolve = (value) => {\n      if (status !== \"pending\") return;\n      status = \"fulfilled\";\n      valueOrReason = value;\n      res(value);\n    };\n    reject = (reason) => {\n      if (status !== \"pending\") return;\n      status = \"rejected\";\n      valueOrReason = reason;\n      rej(reason);\n    };\n  });\n\n  callback(resolve!, reject!);\n  return Object.assign(promise, {\n    status: status,\n    ...status === \"fulfilled\" ? { value: valueOrReason as T } : {},\n    ...status === \"rejected\" ? { reason: valueOrReason } : {},\n  } as any);\n}\nundefined?.test(\"createPromise\", async ({ expect }) => {\n  // Test resolved promise\n  const resolvedPromise = createPromise<number>((resolve) => {\n    resolve(42);\n  });\n  expect(resolvedPromise.status).toBe(\"fulfilled\");\n  expect((resolvedPromise as any).value).toBe(42);\n  expect(await resolvedPromise).toBe(42);\n\n  // Test rejected promise\n  const error = new Error(\"Test error\");\n  const rejectedPromise = createPromise<number>((_, reject) => {\n    reject(error);\n  });\n  expect(rejectedPromise.status).toBe(\"rejected\");\n  expect((rejectedPromise as any).reason).toBe(error);\n  await expect(rejectedPromise).rejects.toBe(error);\n\n  // Test pending promise\n  const pendingPromise = createPromise<number>(() => {\n    // Do nothing, leave it pending\n  });\n  expect(pendingPromise.status).toBe(\"pending\");\n  expect((pendingPromise as any).value).toBeUndefined();\n  expect((pendingPromise as any).reason).toBeUndefined();\n\n  // Test that resolving after already resolved does nothing\n  let resolveCount = 0;\n  const multiResolvePromise = createPromise<number>((resolve) => {\n    resolve(1);\n    resolveCount++;\n    resolve(2);\n    resolveCount++;\n  });\n  expect(resolveCount).toBe(2); // Both resolve calls executed\n  expect(multiResolvePromise.status).toBe(\"fulfilled\");\n  expect((multiResolvePromise as any).value).toBe(1); // Only first resolve took effect\n  expect(await multiResolvePromise).toBe(1);\n});\n\nlet resolvedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.resolve(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `resolved` twice returns the same promise.\n */\nexport function resolved<T>(value: T): ReactPromise<T> {\n  resolvedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (resolvedCache.has([value])) {\n    return resolvedCache.get([value]) as ReactPromise<T>;\n  }\n\n  const res = Object.assign(Promise.resolve(value), {\n    status: \"fulfilled\",\n    value,\n  } as const);\n  resolvedCache.set([value], res);\n  return res;\n}\nundefined?.test(\"resolved\", async ({ expect }) => {\n  // Test with primitive value\n  const promise1 = resolved(42);\n  expect(promise1.status).toBe(\"fulfilled\");\n  // Need to use type assertion since value is only available when status is \"fulfilled\"\n  expect((promise1 as { value: number }).value).toBe(42);\n  expect(await promise1).toBe(42);\n\n  // Test with object value\n  const obj = { test: true };\n  const promise2 = resolved(obj);\n  expect(promise2.status).toBe(\"fulfilled\");\n  expect((promise2 as { value: typeof obj }).value).toBe(obj);\n  expect(await promise2).toBe(obj);\n\n  // Test caching (same reference for same value)\n  const promise3 = resolved(42);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different value (different reference)\n  const promise4 = resolved(43);\n  expect(promise4).not.toBe(promise1);\n});\n\nlet rejectedCache: DependenciesMap<[unknown], ReactPromise<unknown>> | null = null;\n/**\n * Like Promise.reject(...), but also adds the status and value properties for use with React's `use` hook, and caches\n * the value so that invoking `rejected` twice returns the same promise.\n */\nexport function rejected<T>(reason: unknown): ReactPromise<T> {\n  rejectedCache ??= new DependenciesMap<[unknown], ReactPromise<unknown>>();\n  if (rejectedCache.has([reason])) {\n    return rejectedCache.get([reason]) as ReactPromise<T>;\n  }\n\n  const promise = Promise.reject(reason);\n  ignoreUnhandledRejection(promise);\n  const res = Object.assign(promise, {\n    status: \"rejected\",\n    reason: reason,\n  } as const);\n  rejectedCache.set([reason], res);\n  return res;\n}\nundefined?.test(\"rejected\", ({ expect }) => {\n  // Test with error object\n  const error = new Error(\"Test error\");\n  const promise1 = rejected<number>(error);\n  expect(promise1.status).toBe(\"rejected\");\n  // Need to use type assertion since reason is only available when status is \"rejected\"\n  expect((promise1 as { reason: Error }).reason).toBe(error);\n\n  // Test with string reason\n  const promise2 = rejected<string>(\"error message\");\n  expect(promise2.status).toBe(\"rejected\");\n  expect((promise2 as { reason: string }).reason).toBe(\"error message\");\n\n  // Test caching (same reference for same reason)\n  const promise3 = rejected<number>(error);\n  expect(promise3).toBe(promise1); // Same reference due to caching\n\n  // Test with different reason (different reference)\n  const differentError = new Error(\"Different error\");\n  const promise4 = rejected<number>(differentError);\n  expect(promise4).not.toBe(promise1);\n\n  // Note: We're not using await expect(promise).rejects to avoid unhandled rejections\n});\n\n// We'll skip the rejection test for pending() since it's causing unhandled rejections\n// The function is already well tested through other tests like rejected() and createPromise()\n\n\nconst neverResolvePromise = pending(new Promise<never>(() => {}));\nexport function neverResolve(): ReactPromise<never> {\n  return neverResolvePromise;\n}\nundefined?.test(\"neverResolve\", ({ expect }) => {\n  const promise = neverResolve();\n  expect(promise.status).toBe(\"pending\");\n  expect((promise as any).value).toBeUndefined();\n  expect((promise as any).reason).toBeUndefined();\n\n  // Test that multiple calls return the same promise\n  const promise2 = neverResolve();\n  expect(promise2).toBe(promise);\n});\n\nexport function pending<T>(promise: Promise<T>, options: { disableErrorWrapping?: boolean } = {}): ReactPromise<T> {\n  const res = promise.then(\n    value => {\n      res.status = \"fulfilled\";\n      (res as any).value = value;\n      return value;\n    },\n    actualReason => {\n      res.status = \"rejected\";\n      (res as any).reason = actualReason;\n      throw actualReason;\n    },\n  ) as ReactPromise<T>;\n  res.status = \"pending\";\n  return res;\n}\nundefined?.test(\"pending\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  const pendingPromise = pending(resolvePromise);\n\n  // Initially it should be pending\n  expect(pendingPromise.status).toBe(\"pending\");\n\n  // After resolution, it should be fulfilled\n  await resolvePromise;\n  // Need to wait a tick for the then handler to execute\n  await new Promise(resolve => setTimeout(resolve, 0));\n  expect(pendingPromise.status).toBe(\"fulfilled\");\n  expect((pendingPromise as { value: number }).value).toBe(42);\n\n  // For the rejection test, we'll use a separate test to avoid unhandled rejections\n});\n\n/**\n * Should be used to wrap Promises that are not immediately awaited, so they don't throw an unhandled promise rejection\n * error.\n *\n * Vercel kills serverless functions on unhandled promise rejection errors, so this is important.\n */\nexport function ignoreUnhandledRejection<T extends Promise<any>>(promise: T): void {\n  promise.catch(() => {});\n}\nundefined?.test(\"ignoreUnhandledRejection\", async ({ expect }) => {\n  // Test with a promise that resolves\n  const resolvePromise = Promise.resolve(42);\n  ignoreUnhandledRejection(resolvePromise);\n  expect(await resolvePromise).toBe(42); // Should still resolve to the same value\n\n  // Test with a promise that rejects\n  // The promise should still reject, but the rejection is caught internally\n  // so it doesn't cause an unhandled rejection error\n  const error = new Error(\"Test error\");\n  const rejectPromise = Promise.reject(error);\n  ignoreUnhandledRejection(rejectPromise);\n  await expect(rejectPromise).rejects.toBe(error);\n});\n\n/**\n * See concatStacktraces for more information.\n */\nexport function concatStacktracesIfRejected<T>(promise: Promise<T>): void {\n  const currentError = new Error();\n  promise.catch(error => {\n    if (error instanceof Error) {\n      concatStacktraces(error, currentError);\n    } else {\n      // we can only concatenate errors, so we'll just ignore the non-error\n    }\n  });\n}\n\nexport async function wait(ms: number) {\n  if (!Number.isFinite(ms) || ms < 0) {\n    throw new StackAssertionError(`wait() requires a non-negative integer number of milliseconds to wait. (found: ${ms}ms)`);\n  }\n  if (ms >= 2**31) {\n    throw new StackAssertionError(\"The maximum timeout for wait() is 2147483647ms (2**31 - 1). (found: ${ms}ms)\");\n  }\n  return await new Promise<void>(resolve => setTimeout(resolve, ms));\n}\nundefined?.test(\"wait\", async ({ expect }) => {\n  // Test with valid input\n  const start = Date.now();\n  await wait(10);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with zero\n  await expect(wait(0)).resolves.toBeUndefined();\n\n  // Test with negative number\n  await expect(wait(-10)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with non-finite number\n  await expect(wait(NaN)).rejects.toThrow(\"wait() requires a non-negative integer\");\n  await expect(wait(Infinity)).rejects.toThrow(\"wait() requires a non-negative integer\");\n\n  // Test with too large number\n  await expect(wait(2**31)).rejects.toThrow(\"The maximum timeout for wait()\");\n});\n\nexport async function waitUntil(date: Date) {\n  return await wait(date.getTime() - Date.now());\n}\nundefined?.test(\"waitUntil\", async ({ expect }) => {\n  // Test with future date\n  const futureDate = new Date(Date.now() + 10);\n  const start = Date.now();\n  await waitUntil(futureDate);\n  const elapsed = Date.now() - start;\n  expect(elapsed).toBeGreaterThanOrEqual(5); // Allow some flexibility in timing\n\n  // Test with past date - this will throw because wait() requires non-negative time\n  // We need to verify it throws the correct error\n  try {\n    await waitUntil(new Date(Date.now() - 1000));\n    expect.fail(\"Should have thrown an error\");\n  } catch (error) {\n    expect(error).toBeInstanceOf(StackAssertionError);\n    expect((error as Error).message).toContain(\"wait() requires a non-negative integer\");\n  }\n});\n\nexport function runAsynchronouslyWithAlert(...args: Parameters<typeof runAsynchronously>) {\n  return runAsynchronously(\n    args[0],\n    {\n      ...args[1],\n      onError: error => {\n        if (KnownError.isKnownError(error) && typeof process !== \"undefined\" && (process.env.NODE_ENV as any)?.includes(\"production\")) {\n          alert(error.message);\n        } else {\n          alert(`An unhandled error occurred. Please ${process.env.NODE_ENV === \"development\" ? `check the browser console for the full error.` : \"report this to the developer.\"}\\n\\n${error}`);\n        }\n        args[1]?.onError?.(error);\n      },\n    },\n    ...args.slice(2) as [],\n  );\n}\nundefined?.test(\"runAsynchronouslyWithAlert\", ({ expect }) => {\n  // Simple test to verify the function calls runAsynchronously\n  // We can't easily test the alert functionality without mocking\n  const testFn = () => Promise.resolve(\"test\");\n  const testOptions = { noErrorLogging: true };\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronouslyWithAlert(testFn, testOptions)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called\n  expect(typeof runAsynchronouslyWithAlert).toBe(\"function\");\n});\n\nexport function runAsynchronously(\n  promiseOrFunc: void | Promise<unknown> | (() => void | Promise<unknown>) | undefined,\n  options: {\n    noErrorLogging?: boolean,\n    onError?: (error: Error) => void,\n  } = {},\n): void {\n  if (typeof promiseOrFunc === \"function\") {\n    promiseOrFunc = promiseOrFunc();\n  }\n  if (promiseOrFunc) {\n    concatStacktracesIfRejected(promiseOrFunc);\n    promiseOrFunc.catch(error => {\n      options.onError?.(error);\n      const newError = new StackAssertionError(\n        \"Uncaught error in asynchronous function: \" + errorToNiceString(error),\n        { cause: error },\n      );\n      if (!options.noErrorLogging) {\n        captureError(\"runAsynchronously\", newError);\n      }\n    });\n  }\n}\nundefined?.test(\"runAsynchronously\", ({ expect }) => {\n  // Simple test to verify the function exists and can be called\n  const testFn = () => Promise.resolve(\"test\");\n\n  // Just verify it doesn't throw\n  expect(() => runAsynchronously(testFn)).not.toThrow();\n  expect(() => runAsynchronously(Promise.resolve(\"test\"))).not.toThrow();\n  expect(() => runAsynchronously(undefined)).not.toThrow();\n\n  // We can't easily test the error handling without mocking, so we'll\n  // just verify the function exists and can be called with options\n  expect(() => runAsynchronously(testFn, { noErrorLogging: true })).not.toThrow();\n  expect(() => runAsynchronously(testFn, { onError: () => {} })).not.toThrow();\n});\n\n\nclass TimeoutError extends Error {\n  constructor(public readonly ms: number) {\n    super(`Timeout after ${ms}ms`);\n    this.name = \"TimeoutError\";\n  }\n}\n\nexport async function timeout<T>(promise: Promise<T>, ms: number): Promise<Result<T, TimeoutError>> {\n  return await Promise.race([\n    promise.then(value => Result.ok(value)),\n    wait(ms).then(() => Result.error(new TimeoutError(ms))),\n  ]);\n}\nundefined?.test(\"timeout\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeout(fastPromise, 100);\n  expect(fastResult.status).toBe(\"ok\");\n  if (fastResult.status === \"ok\") {\n    expect(fastResult.data).toBe(42);\n  }\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  const slowResult = await timeout(slowPromise, 10);\n  expect(slowResult.status).toBe(\"error\");\n  if (slowResult.status === \"error\") {\n    expect(slowResult.error).toBeInstanceOf(TimeoutError);\n    expect((slowResult.error as TimeoutError).ms).toBe(10);\n  }\n});\n\nexport async function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T> {\n  return Result.orThrow(await timeout(promise, ms));\n}\nundefined?.test(\"timeoutThrow\", async ({ expect }) => {\n  // Test with a promise that resolves quickly\n  const fastPromise = Promise.resolve(42);\n  const fastResult = await timeoutThrow(fastPromise, 100);\n  expect(fastResult).toBe(42);\n\n  // Test with a promise that takes longer than the timeout\n  const slowPromise = new Promise(resolve => setTimeout(() => resolve(\"too late\"), 50));\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toThrow(\"Timeout after 10ms\");\n  await expect(timeoutThrow(slowPromise, 10)).rejects.toBeInstanceOf(TimeoutError);\n});\n\n\nexport type RateLimitOptions = {\n  /**\n   * The number of requests to process in parallel. Currently only 1 is supported.\n   */\n  concurrency: 1,\n\n  /**\n   * If true, multiple requests waiting at the same time will be reduced to just one. Default is false.\n   */\n  batchCalls?: boolean,\n\n  /**\n   * Waits for throttleMs since the start of last request before starting the next request. Default is 0.\n   */\n  throttleMs?: number,\n\n  /**\n   * Waits for gapMs since the end of last request before starting the next request. Default is 0.\n   */\n  gapMs?: number,\n\n  /**\n   * Waits until there have been no new requests for debounceMs before starting a new request. Default is 0.\n   */\n  debounceMs?: number,\n};\n\nexport function rateLimited<T>(\n  func: () => Promise<T>,\n  options: RateLimitOptions,\n): () => Promise<T> {\n  let waitUntil = performance.now();\n  let queue: [(t: T) => void, (e: unknown) => void][] = [];\n  let addedToQueueCallbacks = new Map<string, () => void>;\n\n  const next = async () => {\n    while (true) {\n      if (waitUntil > performance.now()) {\n        await wait(Math.max(1, waitUntil - performance.now() + 1));\n      } else if (queue.length === 0) {\n        const uuid = generateUuid();\n        await new Promise<void>(resolve => {\n          addedToQueueCallbacks.set(uuid, resolve);\n        });\n        addedToQueueCallbacks.delete(uuid);\n      } else {\n        break;\n      }\n    }\n    const nextFuncs = options.batchCalls ? queue.splice(0, queue.length) : [queue.shift()!];\n\n    const start = performance.now();\n    const value = await Result.fromPromise(func());\n    const end = performance.now();\n\n    waitUntil = Math.max(\n      waitUntil,\n      start + (options.throttleMs ?? 0),\n      end + (options.gapMs ?? 0),\n    );\n\n    for (const nextFunc of nextFuncs) {\n      if (value.status === \"ok\") {\n        nextFunc[0](value.data);\n      } else {\n        nextFunc[1](value.error);\n      }\n    }\n  };\n\n  runAsynchronously(async () => {\n    while (true) {\n      await next();\n    }\n  });\n\n  return () => {\n    return new Promise<T>((resolve, reject) => {\n      waitUntil = Math.max(\n        waitUntil,\n        performance.now() + (options.debounceMs ?? 0),\n      );\n      queue.push([resolve, reject]);\n      addedToQueueCallbacks.forEach(cb => cb());\n    });\n  };\n}\n\nexport function throttled<T, A extends any[]>(func: (...args: A) => Promise<T>, delayMs: number): (...args: A) => Promise<T> {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let nextAvailable: Promise<T> | null = null;\n  return async (...args) => {\n    while (nextAvailable !== null) {\n      await nextAvailable;\n    }\n    nextAvailable = new Promise<T>(resolve => {\n      timeout = setTimeout(() => {\n        nextAvailable = null;\n        resolve(func(...args));\n      }, delayMs);\n    });\n    return await nextAvailable;\n  };\n}\n"],"mappings":"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","names":["waitUntil","timeout"]}

package/dist/utils/telemetry.d.mts

@@ -0,0 +1,13 @@
+import { AttributeValue, Span, Attributes } from '@opentelemetry/api';
+
+declare function withTraceSpan<P extends any[], T>(optionsOrDescription: string | {
+    description: string;
+    attributes?: Record<string, AttributeValue>;
+}, fn: (...args: P) => Promise<T>): (...args: P) => Promise<T>;
+declare function traceSpan<T>(optionsOrDescription: string | {
+    description: string;
+    attributes?: Record<string, AttributeValue>;
+}, fn: (span: Span) => Promise<T>): Promise<T>;
+declare function log(message: string, attributes: Attributes): void;
+
+export { log, traceSpan, withTraceSpan };

package/dist/utils/telemetry.d.ts

@@ -0,0 +1,13 @@
+import { AttributeValue, Span, Attributes } from '@opentelemetry/api';
+
+declare function withTraceSpan<P extends any[], T>(optionsOrDescription: string | {
+    description: string;
+    attributes?: Record<string, AttributeValue>;
+}, fn: (...args: P) => Promise<T>): (...args: P) => Promise<T>;
+declare function traceSpan<T>(optionsOrDescription: string | {
+    description: string;
+    attributes?: Record<string, AttributeValue>;
+}, fn: (span: Span) => Promise<T>): Promise<T>;
+declare function log(message: string, attributes: Attributes): void;
+
+export { log, traceSpan, withTraceSpan };

package/dist/utils/telemetry.js

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/telemetry.tsx
+var telemetry_exports = {};
+__export(telemetry_exports, {
+  log: () => log,
+  traceSpan: () => traceSpan,
+  withTraceSpan: () => withTraceSpan
+});
+module.exports = __toCommonJS(telemetry_exports);
+var import_api = require("@opentelemetry/api");
+var import_env = require("./env.js");
+var import_errors = require("./errors.js");
+var tracer = import_api.trace.getTracer("stack-tracer");
+function withTraceSpan(optionsOrDescription, fn) {
+  return async (...args) => {
+    return await traceSpan(optionsOrDescription, (span) => fn(...args));
+  };
+}
+async function traceSpan(optionsOrDescription, fn) {
+  let options = typeof optionsOrDescription === "string" ? { description: optionsOrDescription } : optionsOrDescription;
+  return await tracer.startActiveSpan(`STACK: ${options.description}`, async (span) => {
+    if (options.attributes) {
+      for (const [key, value] of Object.entries(options.attributes)) {
+        span.setAttribute(key, value);
+      }
+    }
+    try {
+      return await fn(span);
+    } finally {
+      span.end();
+    }
+  });
+}
+function log(message, attributes) {
+  const span = import_api.trace.getActiveSpan();
+  if (span) {
+    span.addEvent(message, attributes);
+  } else if ((0, import_env.getEnvVariable)("STACK_SEED_MODE", "false") !== "true") {
+    throw new import_errors.StackAssertionError("No active span found");
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  log,
+  traceSpan,
+  withTraceSpan
+});
+//# sourceMappingURL=telemetry.js.map

package/dist/utils/telemetry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/telemetry.tsx"],"sourcesContent":["import { Attributes, AttributeValue, Span, trace } from \"@opentelemetry/api\";\nimport { getEnvVariable } from \"./env\";\nimport { StackAssertionError } from \"./errors\";\n\nconst tracer = trace.getTracer('stack-tracer');\n\nexport function withTraceSpan<P extends any[], T>(optionsOrDescription: string | { description: string, attributes?: Record<string, AttributeValue> }, fn: (...args: P) => Promise<T>): (...args: P) => Promise<T> {\n  return async (...args: P) => {\n    return await traceSpan(optionsOrDescription, (span) => fn(...args));\n  };\n}\n\nexport async function traceSpan<T>(optionsOrDescription: string | { description: string, attributes?: Record<string, AttributeValue> }, fn: (span: Span) => Promise<T>): Promise<T> {\n  let options = typeof optionsOrDescription === 'string' ? { description: optionsOrDescription } : optionsOrDescription;\n  return await tracer.startActiveSpan(`STACK: ${options.description}`, async (span) => {\n    if (options.attributes) {\n      for (const [key, value] of Object.entries(options.attributes)) {\n        span.setAttribute(key, value);\n      }\n    }\n    try {\n      return await fn(span);\n    } finally {\n      span.end();\n    }\n  });\n}\n\nexport function log(message: string, attributes: Attributes) {\n  const span = trace.getActiveSpan();\n  if (span) {\n    span.addEvent(message, attributes);\n    // Telemetry is not initialized while seeding, so we don't want to throw an error\n  } else if (getEnvVariable('STACK_SEED_MODE', 'false') !== 'true') {\n    throw new StackAssertionError('No active span found');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBAAwD;AACxD,iBAA+B;AAC/B,oBAAoC;AAEpC,IAAM,SAAS,iBAAM,UAAU,cAAc;AAEtC,SAAS,cAAkC,sBAAqG,IAA4D;AACjN,SAAO,UAAU,SAAY;AAC3B,WAAO,MAAM,UAAU,sBAAsB,CAAC,SAAS,GAAG,GAAG,IAAI,CAAC;AAAA,EACpE;AACF;AAEA,eAAsB,UAAa,sBAAqG,IAA4C;AAClL,MAAI,UAAU,OAAO,yBAAyB,WAAW,EAAE,aAAa,qBAAqB,IAAI;AACjG,SAAO,MAAM,OAAO,gBAAgB,UAAU,QAAQ,WAAW,IAAI,OAAO,SAAS;AACnF,QAAI,QAAQ,YAAY;AACtB,iBAAW,CAAC,KAAK,KAAK,KAAK,OAAO,QAAQ,QAAQ,UAAU,GAAG;AAC7D,aAAK,aAAa,KAAK,KAAK;AAAA,MAC9B;AAAA,IACF;AACA,QAAI;AACF,aAAO,MAAM,GAAG,IAAI;AAAA,IACtB,UAAE;AACA,WAAK,IAAI;AAAA,IACX;AAAA,EACF,CAAC;AACH;AAEO,SAAS,IAAI,SAAiB,YAAwB;AAC3D,QAAM,OAAO,iBAAM,cAAc;AACjC,MAAI,MAAM;AACR,SAAK,SAAS,SAAS,UAAU;AAAA,EAEnC,eAAW,2BAAe,mBAAmB,OAAO,MAAM,QAAQ;AAChE,UAAM,IAAI,kCAAoB,sBAAsB;AAAA,EACtD;AACF;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.27",
+  "version": "2.8.30",
   "files": [
     "README.md",
     "dist",
@@ -45,6 +45,7 @@
     }
   },
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
     "@simplewebauthn/browser": "^11.0.0",
     "async-mutex": "^0.5.0",
     "bcryptjs": "^3.0.2",