@stackframe/stack-shared 2.8.36 → 2.8.40

package/dist/utils/paginated-lists.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/paginated-lists.tsx"],"sourcesContent":["import { range } from \"./arrays\";\nimport { StackAssertionError } from \"./errors\";\n\ntype QueryOptions<Type extends 'next' | 'prev', Cursor, Filter, OrderBy> =\n  & {\n    filter: Filter,\n    orderBy: OrderBy,\n    limit: number,\n    /**\n     * Whether the limit should be treated as an exact value, or an approximate value.\n     *\n     * If set to 'exact', less items will only be returned if the list item is the first or last item.\n     *\n     * If set to 'at-least' or 'approximate', the implementation may decide to return more items than the limit requested if doing so comes at no (or negligible) extra cost.\n     *\n     * If set to 'at-most' or 'approximate', the implementation may decide to return less items than the limit requested if requesting more items would come at a non-negligible extra cost. In this case, if limit > 0, the implementation must still make progress towards the end of the list and the returned cursor must be different from the one passed in.\n     *\n     * Defaults to 'exact'.\n     */\n    limitPrecision: 'exact' | 'at-least' | 'at-most' | 'approximate',\n  }\n  & ([Type] extends [never] ? unknown\n    : [Type] extends ['next'] ? { after: Cursor }\n    : [Type] extends ['prev'] ? { before: Cursor }\n    : { cursor: Cursor });\n\ntype ImplQueryOptions<Type extends 'next' | 'prev', Cursor, Filter, OrderBy> = QueryOptions<Type, Cursor, Filter, OrderBy> & { limitPrecision: 'approximate' }\n\ntype QueryResult<Item, Cursor> = { items: { item: Item, itemCursor: Cursor }[], isFirst: boolean, isLast: boolean, cursor: Cursor }\n\ntype ImplQueryResult<Item, Cursor> = { items: { item: Item, itemCursor: Cursor }[], isFirst: boolean, isLast: boolean, cursor: Cursor }\n\nexport abstract class PaginatedList<\n  Item,\n  Cursor extends string,\n  Filter extends unknown,\n  OrderBy extends unknown,\n> {\n  // Abstract methods\n\n  protected abstract _getFirstCursor(): Cursor;\n  protected abstract _getLastCursor(): Cursor;\n  protected abstract _compare(orderBy: OrderBy, a: Item, b: Item): number;\n  protected abstract _nextOrPrev(type: 'next' | 'prev', options: ImplQueryOptions<'next' | 'prev', Cursor, Filter, OrderBy>): Promise<ImplQueryResult<Item, Cursor>>;\n\n  // Implementations\n  public getFirstCursor(): Cursor { return this._getFirstCursor(); }\n  public getLastCursor(): Cursor { return this._getLastCursor(); }\n  public compare(orderBy: OrderBy, a: Item, b: Item): number { return this._compare(orderBy, a, b); }\n\n  async nextOrPrev(type: 'next' | 'prev', options: QueryOptions<'next' | 'prev', Cursor, Filter, OrderBy>): Promise<QueryResult<Item, Cursor>> {\n    let result: { item: Item, itemCursor: Cursor }[] = [];\n    let includesFirst = false;\n    let includesLast = false;\n    let cursor = options.cursor;\n    let limitRemaining = options.limit;\n    while (limitRemaining > 0 || (type === \"next\" && includesLast) || (type === \"prev\" && includesFirst)) {\n      const iterationRes = await this._nextOrPrev(type, {\n        cursor,\n        limit: options.limit,\n        limitPrecision: \"approximate\",\n        filter: options.filter,\n        orderBy: options.orderBy,\n      });\n      result[type === \"next\" ? \"push\" : \"unshift\"](...iterationRes.items);\n      limitRemaining -= iterationRes.items.length;\n      includesFirst ||= iterationRes.isFirst;\n      includesLast ||= iterationRes.isLast;\n      cursor = iterationRes.cursor;\n      if ([\"approximate\", \"at-most\"].includes(options.limitPrecision)) break;\n    }\n\n    // Assert that the result is sorted\n    for (let i = 1; i < result.length; i++) {\n      if (this._compare(options.orderBy, result[i].item, result[i - 1].item) < 0) {\n        throw new StackAssertionError(\"Paginated list result is not sorted; something is wrong with the implementation\", {\n          i,\n          options,\n          result,\n        });\n      }\n    }\n\n    if ([\"exact\", \"at-most\"].includes(options.limitPrecision) && result.length > options.limit) {\n      if (type === \"next\") {\n        result = result.slice(0, options.limit);\n        includesLast = false;\n        if (options.limit > 0) cursor = result[result.length - 1].itemCursor;\n      } else {\n        result = result.slice(result.length - options.limit);\n        includesFirst = false;\n        if (options.limit > 0) cursor = result[0].itemCursor;\n      }\n    }\n    return { items: result, isFirst: includesFirst, isLast: includesLast, cursor };\n  }\n  public async next({ after, ...rest }: QueryOptions<'next', Cursor, Filter, OrderBy>): Promise<QueryResult<Item, Cursor>> {\n    return await this.nextOrPrev(\"next\", {\n      ...rest,\n      cursor: after,\n    });\n  }\n  public async prev({ before, ...rest }: QueryOptions<'prev', Cursor, Filter, OrderBy>): Promise<QueryResult<Item, Cursor>> {\n    return await this.nextOrPrev(\"prev\", {\n      ...rest,\n      cursor: before,\n    });\n  }\n\n  // Utility methods below\n\n  flatMap<Item2, Cursor2 extends string, Filter2 extends unknown, OrderBy2 extends unknown>(options: {\n    itemMapper: (itemEntry: { item: Item, itemCursor: Cursor }, filter: Filter2, orderBy: OrderBy2) => { item: Item2, itemCursor: Cursor2 }[],\n    compare: (orderBy: OrderBy2, a: Item2, b: Item2) => number,\n    newCursorFromOldCursor: (cursor: Cursor) => Cursor2,\n    oldCursorFromNewCursor: (cursor: Cursor2) => Cursor,\n    oldFilterFromNewFilter: (filter: Filter2) => Filter,\n    oldOrderByFromNewOrderBy: (orderBy: OrderBy2) => OrderBy,\n    estimateItemsToFetch: (options: { filter: Filter2, orderBy: OrderBy2, limit: number }) => number,\n  }): PaginatedList<Item2, Cursor2, Filter2, OrderBy2> {\n    const that = this;\n    class FlatMapPaginatedList extends PaginatedList<Item2, Cursor2, Filter2, OrderBy2> {\n      override _getFirstCursor(): Cursor2 { return options.newCursorFromOldCursor(that.getFirstCursor()); }\n      override _getLastCursor(): Cursor2 { return options.newCursorFromOldCursor(that.getLastCursor()); }\n\n      override _compare(orderBy: OrderBy2, a: Item2, b: Item2): number {\n        return options.compare(orderBy, a, b);\n      }\n\n      override async _nextOrPrev(type: 'next' | 'prev', { limit, filter, orderBy, cursor }: ImplQueryOptions<'next' | 'prev', Cursor2, Filter2, OrderBy2>) {\n        const estimatedItems = options.estimateItemsToFetch({ limit, filter, orderBy });\n        const original = await that.nextOrPrev(type, {\n          limit: estimatedItems,\n          limitPrecision: \"approximate\",\n          cursor: options.oldCursorFromNewCursor(cursor),\n          filter: options.oldFilterFromNewFilter(filter),\n          orderBy: options.oldOrderByFromNewOrderBy(orderBy),\n        });\n        const mapped = original.items.flatMap(itemEntry => options.itemMapper(\n        itemEntry,\n        filter,\n        orderBy,\n      ));\n        return {\n          items: mapped,\n          isFirst: original.isFirst,\n          isLast: original.isLast,\n          cursor: options.newCursorFromOldCursor(original.cursor),\n        };\n      }\n    }\n    return new FlatMapPaginatedList();\n  }\n\n  map<Item2, Filter2 extends unknown, OrderBy2 extends unknown>(options: {\n    itemMapper: (item: Item) => Item2,\n    oldItemFromNewItem: (item: Item2) => Item,\n    oldFilterFromNewFilter: (filter: Filter2) => Filter,\n    oldOrderByFromNewOrderBy: (orderBy: OrderBy2) => OrderBy,\n  }): PaginatedList<Item2, Cursor, Filter2, OrderBy2> {\n    return this.flatMap({\n      itemMapper: (itemEntry, filter, orderBy) => {\n        return [{ item: options.itemMapper(itemEntry.item), itemCursor: itemEntry.itemCursor }];\n      },\n      compare: (orderBy, a, b) => this.compare(options.oldOrderByFromNewOrderBy(orderBy), options.oldItemFromNewItem(a), options.oldItemFromNewItem(b)),\n      newCursorFromOldCursor: (cursor) => cursor,\n      oldCursorFromNewCursor: (cursor) => cursor,\n      oldFilterFromNewFilter: (filter) => options.oldFilterFromNewFilter(filter),\n      oldOrderByFromNewOrderBy: (orderBy) => options.oldOrderByFromNewOrderBy(orderBy),\n      estimateItemsToFetch: (options) => options.limit,\n    });\n  }\n\n  filter<Filter2 extends unknown>(options: {\n    filter: (item: Item, filter: Filter2) => boolean,\n    oldFilterFromNewFilter: (filter: Filter2) => Filter,\n    estimateItemsToFetch: (options: { filter: Filter2, orderBy: OrderBy, limit: number }) => number,\n  }): PaginatedList<Item, Cursor, Filter2, OrderBy> {\n    return this.flatMap({\n      itemMapper: (itemEntry, filter, orderBy) => (options.filter(itemEntry.item, filter) ? [itemEntry] : []),\n      compare: (orderBy, a, b) => this.compare(orderBy, a, b),\n      newCursorFromOldCursor: (cursor) => cursor,\n      oldCursorFromNewCursor: (cursor) => cursor,\n      oldFilterFromNewFilter: (filter) => options.oldFilterFromNewFilter(filter),\n      oldOrderByFromNewOrderBy: (orderBy) => orderBy,\n      estimateItemsToFetch: (o) => options.estimateItemsToFetch(o),\n    });\n  }\n\n  addFilter<AddedFilter extends unknown>(options: {\n    filter: (item: Item, filter: Filter & AddedFilter) => boolean,\n    estimateItemsToFetch: (options: { filter: Filter & AddedFilter, orderBy: OrderBy, limit: number }) => number,\n  }): PaginatedList<Item, Cursor, Filter & AddedFilter, OrderBy> {\n    return this.filter({\n      filter: (item, filter) => options.filter(item, filter),\n      oldFilterFromNewFilter: (filter) => filter,\n      estimateItemsToFetch: (o) => options.estimateItemsToFetch(o),\n    });\n  }\n\n  static merge<\n    Item,\n    Filter extends unknown,\n    OrderBy extends unknown,\n  >(\n    ...lists: PaginatedList<Item, any, Filter, OrderBy>[]\n  ): PaginatedList<Item, string, Filter, OrderBy> {\n    class MergePaginatedList extends PaginatedList<Item, string, Filter, OrderBy> {\n      override _getFirstCursor() { return JSON.stringify(lists.map(list => list.getFirstCursor())); }\n      override _getLastCursor() { return JSON.stringify(lists.map(list => list.getLastCursor())); }\n      override _compare(orderBy: OrderBy, a: Item, b: Item): number {\n        const listsResults = lists.map(list => list.compare(orderBy, a, b));\n        if (!listsResults.every(result => result === listsResults[0])) {\n          throw new StackAssertionError(\"Lists have different compare results; make sure that they use the same compare function\", { lists, listsResults });\n        }\n        return listsResults[0];\n      }\n\n      override async _nextOrPrev(type: 'next' | 'prev', { limit, filter, orderBy, cursor }: ImplQueryOptions<'next' | 'prev', \"first\" | \"last\" | `[${string}]`, Filter, OrderBy>) {\n        const cursors = JSON.parse(cursor);\n        const fetchedLists = await Promise.all(lists.map(async (list, i) => {\n          return await list.nextOrPrev(type, {\n            limit,\n            filter,\n            orderBy,\n            cursor: cursors[i],\n            limitPrecision: \"at-least\",\n          });\n        }));\n        const combinedItems = fetchedLists.flatMap((list, i) => list.items.map((itemEntry) => ({ itemEntry, listIndex: i })));\n        const sortedItems = [...combinedItems].sort((a, b) => this._compare(orderBy, a.itemEntry.item, b.itemEntry.item));\n        const lastCursorForEachList = sortedItems.reduce((acc, item) => {\n          acc[item.listIndex] = item.itemEntry.itemCursor;\n          return acc;\n        }, range(lists.length).map((i) => cursors[i]));\n        return {\n          items: sortedItems.map((item) => item.itemEntry),\n          isFirst: sortedItems.every((item) => item.listIndex === 0),\n          isLast: sortedItems.every((item) => item.listIndex === lists.length - 1),\n          cursor: JSON.stringify(lastCursorForEachList),\n        };\n      }\n    }\n    return new MergePaginatedList();\n  }\n\n  static empty() {\n    class EmptyPaginatedList extends PaginatedList<never, \"first\" | \"last\", any, any> {\n      override _getFirstCursor() { return \"first\" as const; }\n      override _getLastCursor() { return \"last\" as const; }\n      override _compare(orderBy: any, a: any, b: any): number {\n        return 0;\n      }\n      override async _nextOrPrev(type: 'next' | 'prev', options: ImplQueryOptions<'next' | 'prev', string, any, any>) {\n        return { items: [], isFirst: true, isLast: true, cursor: \"first\" as const };\n      }\n    }\n    return new EmptyPaginatedList();\n  }\n}\n\nexport class ArrayPaginatedList<Item> extends PaginatedList<Item, `${number}`, (item: Item) => boolean, (a: Item, b: Item) => number> {\n  constructor(private readonly array: Item[]) {\n    super();\n  }\n\n  override _getFirstCursor() { return \"0\" as const; }\n  override _getLastCursor() { return `${this.array.length - 1}` as const; }\n  override _compare(orderBy: (a: Item, b: Item) => number, a: Item, b: Item): number {\n    return orderBy(a, b);\n  }\n\n  override async _nextOrPrev(type: 'next' | 'prev', options: ImplQueryOptions<'next' | 'prev', `${number}`, (item: Item) => boolean, (a: Item, b: Item) => number>) {\n    const filteredArray = this.array.filter(options.filter);\n    const sortedArray = [...filteredArray].sort((a, b) => this._compare(options.orderBy, a, b));\n    const itemEntriesArray = sortedArray.map((item, index) => ({ item, itemCursor: `${index}` as const }));\n    const oldCursor = Number(options.cursor);\n    const newCursor = Math.max(0, Math.min(this.array.length - 1, oldCursor + (type === \"next\" ? 1 : -1) * options.limit));\n    return {\n      items: itemEntriesArray.slice(Math.min(oldCursor, newCursor), Math.max(oldCursor, newCursor)),\n      isFirst: oldCursor === 0 || newCursor === 0,\n      isLast: oldCursor === this.array.length - 1 || newCursor === this.array.length - 1,\n      cursor: `${newCursor}` as const,\n    };\n  }\n}\n"],"mappings":"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","names":["options"]}

package/dist/utils/promises.d.mts

@@ -48,7 +48,7 @@ declare class TimeoutError extends Error {
     readonly ms: number;
     constructor(ms: number);
 }
-declare function timeout<T>(promise: Promise<T>, ms: number): Promise<Result<T, TimeoutError>>;
+declare function timeout<T>(promiseOrFunc: Promise<T> | (() => Promise<T>), ms: number): Promise<Result<T, TimeoutError>>;
 declare function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T>;
 type RateLimitOptions = {
     /**

package/dist/utils/promises.d.ts

@@ -48,7 +48,7 @@ declare class TimeoutError extends Error {
     readonly ms: number;
     constructor(ms: number);
 }
-declare function timeout<T>(promise: Promise<T>, ms: number): Promise<Result<T, TimeoutError>>;
+declare function timeout<T>(promiseOrFunc: Promise<T> | (() => Promise<T>), ms: number): Promise<Result<T, TimeoutError>>;
 declare function timeoutThrow<T>(promise: Promise<T>, ms: number): Promise<T>;
 type RateLimitOptions = {
     /**

package/dist/utils/promises.js

@@ -186,7 +186,8 @@ var TimeoutError = class extends Error {
     this.name = "TimeoutError";
   }
 };
-async function timeout(promise, ms) {
+async function timeout(promiseOrFunc, ms) {
+  const promise = typeof promiseOrFunc === "function" ? promiseOrFunc() : promiseOrFunc;
   return await Promise.race([
     promise.then((value) => import_results.Result.ok(value)),
     wait(ms).then(() => import_results.Result.error(new TimeoutError(ms)))

package/dist/utils/promises.js.map

@@ -1 +1 @@
-{"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"]}
+{"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>(promiseOrFunc: Promise<T> | (() => Promise<T>), ms: number): Promise<Result<T, TimeoutError>> {\n  const promise = typeof promiseOrFunc === \"function\" ? promiseOrFunc() : promiseOrFunc;\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/stores.d.mts

@@ -61,12 +61,6 @@ declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
     isAvailable(): boolean;
     isRejected(): boolean;
     get(): ({
-        status: "pending";
-    } & {
-        progress: void;
-    } & {
-        status: "pending";
-    }) | ({
         status: "error";
         error: unknown;
     } & {
@@ -76,6 +70,12 @@ declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
         data: T;
     } & {
         status: "ok";
+    }) | ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
     });
     getOrWait(): ReactPromise<T>;
     _setIfLatest(result: Result<T>, curCounter: number): boolean;

package/dist/utils/stores.d.ts

@@ -61,12 +61,6 @@ declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
     isAvailable(): boolean;
     isRejected(): boolean;
     get(): ({
-        status: "pending";
-    } & {
-        progress: void;
-    } & {
-        status: "pending";
-    }) | ({
         status: "error";
         error: unknown;
     } & {
@@ -76,6 +70,12 @@ declare class AsyncStore<T> implements ReadonlyAsyncStore<T> {
         data: T;
     } & {
         status: "ok";
+    }) | ({
+        status: "pending";
+    } & {
+        progress: void;
+    } & {
+        status: "pending";
     });
     getOrWait(): ReactPromise<T>;
     _setIfLatest(result: Result<T>, curCounter: number): boolean;

package/dist/utils/types.d.mts

@@ -51,6 +51,15 @@ type AllUnionKeys<T extends object> = T extends T ? keyof T : never;
 type SubtractType<T, U> = T extends object ? {
     [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K];
 } : (T extends U ? never : T);
+type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest] ? Rest extends [] ? (A & {
+    [K in keyof B]?: never;
+}) | (B & {
+    [K in keyof A]?: never;
+}) : XOR<[(A & {
+    [K in keyof B]?: never;
+}) | (B & {
+    [K in keyof A]?: never;
+}), ...Rest]> : T[0];
 type _AntiIntersectInner<T, U> = T extends object ? (Omit<U, keyof T> & {
     [K in keyof Pick<U, {
         [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never;
@@ -103,4 +112,4 @@ declare function typeAssertExtends<T, S>(): ([
 ] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>);
 declare function typeAssertIs<T, U>(): (IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`> : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>);
 
-export { type AllUnionKeys, type AntiIntersect, type CollapseObjectUnion, type DeepRemoveOptionalUndefined, type Expand, type IfAndOnlyIf, type IntersectAll, type IsAny, type IsNever, type IsNullish, type IsUnion, type KeyIntersect, type LastUnionElement, type NullishCoalesce, type OptionalKeys, type PrettifyType, type PseudoAntiIntersect, type RequiredKeys, type SubtractType, type TypeToString, type UnionToIntersection, type UnionToTuple, typeAssert, typeAssertExtends, typeAssertIs };
+export { type AllUnionKeys, type AntiIntersect, type CollapseObjectUnion, type DeepRemoveOptionalUndefined, type Expand, type IfAndOnlyIf, type IntersectAll, type IsAny, type IsNever, type IsNullish, type IsUnion, type KeyIntersect, type LastUnionElement, type NullishCoalesce, type OptionalKeys, type PrettifyType, type PseudoAntiIntersect, type RequiredKeys, type SubtractType, type TypeToString, type UnionToIntersection, type UnionToTuple, type XOR, typeAssert, typeAssertExtends, typeAssertIs };

package/dist/utils/types.d.ts

@@ -51,6 +51,15 @@ type AllUnionKeys<T extends object> = T extends T ? keyof T : never;
 type SubtractType<T, U> = T extends object ? {
     [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K];
 } : (T extends U ? never : T);
+type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest] ? Rest extends [] ? (A & {
+    [K in keyof B]?: never;
+}) | (B & {
+    [K in keyof A]?: never;
+}) : XOR<[(A & {
+    [K in keyof B]?: never;
+}) | (B & {
+    [K in keyof A]?: never;
+}), ...Rest]> : T[0];
 type _AntiIntersectInner<T, U> = T extends object ? (Omit<U, keyof T> & {
     [K in keyof Pick<U, {
         [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never;
@@ -103,4 +112,4 @@ declare function typeAssertExtends<T, S>(): ([
 ] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>);
 declare function typeAssertIs<T, U>(): (IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`> : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>);
 
-export { type AllUnionKeys, type AntiIntersect, type CollapseObjectUnion, type DeepRemoveOptionalUndefined, type Expand, type IfAndOnlyIf, type IntersectAll, type IsAny, type IsNever, type IsNullish, type IsUnion, type KeyIntersect, type LastUnionElement, type NullishCoalesce, type OptionalKeys, type PrettifyType, type PseudoAntiIntersect, type RequiredKeys, type SubtractType, type TypeToString, type UnionToIntersection, type UnionToTuple, typeAssert, typeAssertExtends, typeAssertIs };
+export { type AllUnionKeys, type AntiIntersect, type CollapseObjectUnion, type DeepRemoveOptionalUndefined, type Expand, type IfAndOnlyIf, type IntersectAll, type IsAny, type IsNever, type IsNullish, type IsUnion, type KeyIntersect, type LastUnionElement, type NullishCoalesce, type OptionalKeys, type PrettifyType, type PseudoAntiIntersect, type RequiredKeys, type SubtractType, type TypeToString, type UnionToIntersection, type UnionToTuple, type XOR, typeAssert, typeAssertExtends, typeAssertIs };

package/dist/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/types.tsx"],"sourcesContent":["import { DeepPartial } from \"./objects\";\nimport { Join } from \"./strings\";\n\nexport type IsAny<T> = 0 extends (1 & T) ? true : false;\nexport type IsNever<T> = [T] extends [never] ? true : false;\nexport type IsNullish<T> = [T] extends [null | undefined] ? true : false;\nexport type IsUnion<T, U = T> =\n  IsNever<T> extends true ? false\n  : IsAny<T> extends true ? false\n    : T extends U // distributive conditional https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n        ? /* if the *whole* original type (`U`) still fits inside the current variant, then `T` wasn’t a union */ ([U] extends [T] ? false : true)\n        : never;\n\nexport type NullishCoalesce<T, U> = T extends null | undefined ? U : T;\n\nexport type LastUnionElement<U> = UnionToIntersection<U extends any ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L & U : never;\n\ntype primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Makes a type prettier by recursively expanding all object types. For example, `Omit<{ a: 1 }, \"a\">` becomes just `{}`.\n */\nexport type Expand<T> = T extends (...args: infer A) => infer R\n  ? ((...args: A) => R) extends T\n    ? (...args: Expand<A>) => Expand<R>\n    : ((...args: Expand<A>) => Expand<R>) & { [K in keyof T]: Expand<T[K]> }\n  : T extends object\n    ? T extends primitive\n      ? T\n      : T extends infer O\n        ? { [K in keyof O]: Expand<O[K]> }\n        : never\n    : T;\n\n\n/**\n * Removes all optional undefined/never keys from an object.\n */\nexport type DeepRemoveOptionalUndefined<T> = T extends object ? { [K in keyof T]: DeepRemoveOptionalUndefined<T[K]> } : T;\n\n// why this works: https://stackoverflow.com/a/50375286\nexport type UnionToIntersection<U> =\n  (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never\n\ntype _UnionToTupleInner<U, R extends any[], Last> = UnionToTuple<Exclude<U, Last>, [...R, Last]>\nexport type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : _UnionToTupleInner<U, R, LastUnionElement<U>>;\n\nexport type CollapseObjectUnion<T extends object> = {\n  [K in AllUnionKeys<T>]?: T extends Record<K, infer V> ? V : never;\n};\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { b: number }>, { a?: string, b?: number }>()();\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { a: number }>, { a?: string | number }>()();\n\nexport type IntersectAll<T extends any[]> = UnionToIntersection<T[number]>;\n\nexport type OptionalKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? K : never;\n}[keyof T];\nexport type RequiredKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? never : K;\n}[keyof T];\n\n/**\n * Returns a type whose keys are the intersection of the keys of T and U, deeply.\n */\nexport type KeyIntersect<T, U> =\n  | { [K in keyof T & keyof U]?: T[K] & U[K] }\n  | { [K in RequiredKeys<T> & keyof U]: T[K] & U[K] }\n  | { [K in RequiredKeys<U> & keyof T]: U[K] & T[K] }\n\n/**\n * Returns ALL keys of all union elements.\n */\nexport type AllUnionKeys<T extends object> = T extends T ? keyof T : never;\ntypeAssertIs<AllUnionKeys<{ a: string } | { b: number }>, \"a\" | \"b\">()();\n\nexport type SubtractType<T, U> = T extends object ? { [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K] } : (T extends U ? never : T); // note: this only works due to the distributive property of conditional types https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n\n\ntype _AntiIntersectInner<T, U> = T extends object ? (\n  & Omit<U, keyof T>\n  & { [K in keyof Pick<U, { [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never }[keyof T & keyof U]>]: PseudoAntiIntersect<T[K], U[K]> }\n  & { [K in keyof Pick<U, keyof T & keyof U>]?: PseudoAntiIntersect<T[K], U[K]> }\n) : U;\n/**\n * Returns a type R such that T & R = U.\n */\nexport type AntiIntersect<T, U> = U extends T ? _AntiIntersectInner<T, U> : \"Cannot anti-intersect a type with a type that is not a subtype of it\"; // NOTE: This type is mostly untested — not sure how well it works on the edge cases\nexport type PseudoAntiIntersect<T, U> = _AntiIntersectInner<T, T & U>;\n\n/**\n * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:\n *\n * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.\n * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.\n * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.\n *\n * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which\n * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).\n */\nexport type IfAndOnlyIf<Value, Extends, Then, Otherwise> =\n  | (Value extends Extends ? never : Otherwise)\n  | (Value & Extends extends never ? never : Then);\n\n\n/**\n * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.\n */\nexport type PrettifyType<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T;\n\ntype _ToStringAndJoin<T extends any[], Separator extends string> =\n  T extends [infer U, ...infer Rest extends any[]]\n    ? `${TypeToString<U>}${Rest extends [any, ...any[]] ? `${Separator}${_ToStringAndJoin<Rest, Separator>}` : \"\"}`\n    : \"<error-joining-tuple-elements>\";\ntype _TypeToStringInner<T> =\n  IsAny<T> extends true ? \"any\"\n  : IsNever<T> extends true ? \"never\"\n  : IsUnion<T> extends true ? _ToStringAndJoin<UnionToTuple<T>, \" | \">\n  : [T] extends [number] ? (number extends T ? \"number\" : `${T}`)\n  : [T] extends [boolean] ? `${T}`\n  : [T] extends [undefined] ? \"undefined\"\n  : [T] extends [null] ? \"null\"\n  : [T] extends [string] ? (string extends T ? \"string\" : `'${T}'`)\n  : [T] extends [[]] ? \"[]\"\n  : [T] extends [[any, ...any[]]] ? `[${_ToStringAndJoin<T, \", \">}]`\n  : [T] extends [(infer E)[]] ? `${TypeToString<E>}[]`\n  : [T] extends [Function] ? \"function\"\n  : [T] extends [symbol] ? `symbol(${T['description']})`\n  : [T] extends [object] ? `{ ${Join<UnionToTuple<{ [K in keyof T]: `${TypeToString<K>}: ${TypeToString<T[K]>}` }[keyof T]>, \", \">} }`\n  : \"<unknown-type>\"\nexport type TypeToString<T> = _TypeToStringInner<T> extends `${infer S}` ? S : never;\n\n/**\n * Can be used to create assertions on types. For example, if passed any T other than `true`, the following will\n * show a type error:\n *\n * ```ts\n * typeAssert<T>()();  // the second pair of braces is important!\n * ```\n */\nexport function typeAssert<T>(): (\n  IsAny<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got any.`>\n    : IsNever<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got never.`>\n    : T extends true ? (() => undefined)\n    : TypeAssertionError<`Type assertion failed. Expected true, but got: ${TypeToString<T>}`>\n) {\n  return (() => undefined) as any;\n}\ntype TypeAssertionError<T> =\n  & [T]\n  & /* this promise makes sure that if we accidentally forget the second pair of braces, eslint will complain (if we have no-floating-promises enabled) */ Promise<any>;\n\n\ntypeAssertExtends<ReturnType<typeof typeAssert<true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<false>>, TypeAssertionError<`Type assertion failed. Expected true, but got: false`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<never>>, TypeAssertionError<`Type assertion failed. Expected true, but got never.`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<any>>, TypeAssertionError<`Type assertion failed. Expected true, but got any.`>>()();\n\n/**\n * Functionally equivalent to `typeAssert<T extends S ? true : false>()()`, but with better error messages.\n */\nexport function typeAssertExtends<T, S>(): (\n  [T] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, false>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<\"abc\", string>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: 1, b: 123}, {a: number}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<true, any>>, () => undefined>()();\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to extend { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, never>>, [\"Type assertion failed. Expected any to extend never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, true>>, [\"Type assertion failed. Expected false to extend true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, never>>, [\"Type assertion failed. Expected false to extend never\"]>()();\n\n\nexport function typeAssertIs<T, U>(): (\n  IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n    : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertIs<\"123\", \"123\">>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: 1}, {a: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<DeepPartial<{a: 1}>, {a?: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, any>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<1, any>>, [\"Type assertion failed. Expected 1 to be any\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, 1>>, [\"Type assertion failed. Expected any to be 1\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to be { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, never>>, [\"Type assertion failed. Expected any to be never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, never>>, [\"Type assertion failed. Expected false to be never\"]>()();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkDA,aAA6F,EAAE;AAC/F,aAA0F,EAAE;AAuB5F,aAAqE,EAAE;AAkEhE,SAAS,aAKd;AACA,SAAQ,MAAM;AAChB;AAMA,kBAAwE,EAAE;AAC1E,kBAAoI,EAAE;AACtI,kBAAoI,EAAE;AACtI,kBAAgI,EAAE;AAK3H,SAAS,oBAEd;AACA,SAAQ,MAAM;AAChB;AAEA,kBAAsF,EAAE;AACxF,kBAAoF,EAAE;AACtF,kBAAuF,EAAE;AACzF,kBAAwF,EAAE;AAC1F,kBAAsG,EAAE;AACxG,kBAAuF,EAAE;AACzF,kBAAoF,EAAE;AAEtF,kBAAuJ,EAAE;AACzJ,kBAA6H,EAAE;AAC/H,kBAA+H,EAAE;AACjI,kBAAiI,EAAE;AAG5H,SAAS,eAKd;AACA,SAAQ,MAAM;AAChB;AAEA,kBAAkF,EAAE;AACpF,kBAAoF,EAAE;AACtF,kBAAkG,EAAE;AACpG,kBAA8E,EAAE;AAChF,kBAAkF,EAAE;AACpF,kBAA4G,EAAE;AAC9G,kBAA4G,EAAE;AAC9G,kBAAsH,EAAE;AACxH,kBAA8I,EAAE;AAChJ,kBAAoH,EAAE;AACtH,kBAAsH,EAAE;AACxH,kBAAwH,EAAE;","names":[]}
+{"version":3,"sources":["../../src/utils/types.tsx"],"sourcesContent":["import { DeepPartial } from \"./objects\";\nimport { Join } from \"./strings\";\n\nexport type IsAny<T> = 0 extends (1 & T) ? true : false;\nexport type IsNever<T> = [T] extends [never] ? true : false;\nexport type IsNullish<T> = [T] extends [null | undefined] ? true : false;\nexport type IsUnion<T, U = T> =\n  IsNever<T> extends true ? false\n  : IsAny<T> extends true ? false\n    : T extends U // distributive conditional https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n        ? /* if the *whole* original type (`U`) still fits inside the current variant, then `T` wasn’t a union */ ([U] extends [T] ? false : true)\n        : never;\n\nexport type NullishCoalesce<T, U> = T extends null | undefined ? U : T;\n\nexport type LastUnionElement<U> = UnionToIntersection<U extends any ? (x: U) => 0 : never> extends (x: infer L) => 0 ? L & U : never;\n\ntype primitive = string | number | boolean | bigint | symbol | null | undefined;\n\n/**\n * Makes a type prettier by recursively expanding all object types. For example, `Omit<{ a: 1 }, \"a\">` becomes just `{}`.\n */\nexport type Expand<T> = T extends (...args: infer A) => infer R\n  ? ((...args: A) => R) extends T\n    ? (...args: Expand<A>) => Expand<R>\n    : ((...args: Expand<A>) => Expand<R>) & { [K in keyof T]: Expand<T[K]> }\n  : T extends object\n    ? T extends primitive\n      ? T\n      : T extends infer O\n        ? { [K in keyof O]: Expand<O[K]> }\n        : never\n    : T;\n\n\n/**\n * Removes all optional undefined/never keys from an object.\n */\nexport type DeepRemoveOptionalUndefined<T> = T extends object ? { [K in keyof T]: DeepRemoveOptionalUndefined<T[K]> } : T;\n\n// why this works: https://stackoverflow.com/a/50375286\nexport type UnionToIntersection<U> =\n  (U extends any ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never\n\ntype _UnionToTupleInner<U, R extends any[], Last> = UnionToTuple<Exclude<U, Last>, [...R, Last]>\nexport type UnionToTuple<U, R extends any[] = []> = [U] extends [never] ? R : _UnionToTupleInner<U, R, LastUnionElement<U>>;\n\nexport type CollapseObjectUnion<T extends object> = {\n  [K in AllUnionKeys<T>]?: T extends Record<K, infer V> ? V : never;\n};\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { b: number }>, { a?: string, b?: number }>()();\ntypeAssertIs<CollapseObjectUnion<{ a: string } | { a: number }>, { a?: string | number }>()();\n\nexport type IntersectAll<T extends any[]> = UnionToIntersection<T[number]>;\n\nexport type OptionalKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? K : never;\n}[keyof T];\nexport type RequiredKeys<T> = {\n  [K in keyof T]: {} extends Pick<T, K> ? never : K;\n}[keyof T];\n\n/**\n * Returns a type whose keys are the intersection of the keys of T and U, deeply.\n */\nexport type KeyIntersect<T, U> =\n  | { [K in keyof T & keyof U]?: T[K] & U[K] }\n  | { [K in RequiredKeys<T> & keyof U]: T[K] & U[K] }\n  | { [K in RequiredKeys<U> & keyof T]: U[K] & T[K] }\n\n/**\n * Returns ALL keys of all union elements.\n */\nexport type AllUnionKeys<T extends object> = T extends T ? keyof T : never;\ntypeAssertIs<AllUnionKeys<{ a: string } | { b: number }>, \"a\" | \"b\">()();\n\nexport type SubtractType<T, U> = T extends object ? { [K in keyof T]: K extends keyof U ? SubtractType<T[K], U[K]> : T[K] } : (T extends U ? never : T); // note: this only works due to the distributive property of conditional types https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types\n\nexport type XOR<T extends readonly any[]> = T extends readonly [infer A, infer B, ...infer Rest]\n  ? Rest extends []\n  ? (A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never })\n  : XOR<[(A & { [K in keyof B]?: never }) | (B & { [K in keyof A]?: never }), ...Rest]>\n  : T[0];\n\n\ntype _AntiIntersectInner<T, U> = T extends object ? (\n  & Omit<U, keyof T>\n  & { [K in keyof Pick<U, { [K in keyof T & keyof U]: U[K] extends T[K] ? (T[K] extends U[K] ? never : K) : never }[keyof T & keyof U]>]: PseudoAntiIntersect<T[K], U[K]> }\n  & { [K in keyof Pick<U, keyof T & keyof U>]?: PseudoAntiIntersect<T[K], U[K]> }\n) : U;\n/**\n * Returns a type R such that T & R = U.\n */\nexport type AntiIntersect<T, U> = U extends T ? _AntiIntersectInner<T, U> : \"Cannot anti-intersect a type with a type that is not a subtype of it\"; // NOTE: This type is mostly untested — not sure how well it works on the edge cases\nexport type PseudoAntiIntersect<T, U> = _AntiIntersectInner<T, T & U>;\n\n/**\n * A variation of TypeScript's conditionals with slightly different semantics. It is the perfect type for cases where:\n *\n * - If all possible values are contained in `Extends`, then it will be mapped to `Then`.\n * - If all possible values are not contained in `Extends`, then it will be mapped to `Otherwise`.\n * - If some possible values are contained in `Extends` and some are not, then it will be mapped to `Then | Otherwise`.\n *\n * This is different from TypeScript's built-in conditional types (`Value extends Extends ? Then : Otherwise`), which\n * returns `Otherwise` for the third case (causing unsoundness in many real-world cases).\n */\nexport type IfAndOnlyIf<Value, Extends, Then, Otherwise> =\n  | (Value extends Extends ? never : Otherwise)\n  | (Value & Extends extends never ? never : Then);\n\n\n/**\n * Can be used to prettify a type in the IDE; for example, some complicated intersected types can be flattened into a single type.\n */\nexport type PrettifyType<T> = T extends object ? { [K in keyof T]: T[K] } & {} : T;\n\ntype _ToStringAndJoin<T extends any[], Separator extends string> =\n  T extends [infer U, ...infer Rest extends any[]]\n    ? `${TypeToString<U>}${Rest extends [any, ...any[]] ? `${Separator}${_ToStringAndJoin<Rest, Separator>}` : \"\"}`\n    : \"<error-joining-tuple-elements>\";\ntype _TypeToStringInner<T> =\n  IsAny<T> extends true ? \"any\"\n  : IsNever<T> extends true ? \"never\"\n  : IsUnion<T> extends true ? _ToStringAndJoin<UnionToTuple<T>, \" | \">\n  : [T] extends [number] ? (number extends T ? \"number\" : `${T}`)\n  : [T] extends [boolean] ? `${T}`\n  : [T] extends [undefined] ? \"undefined\"\n  : [T] extends [null] ? \"null\"\n  : [T] extends [string] ? (string extends T ? \"string\" : `'${T}'`)\n  : [T] extends [[]] ? \"[]\"\n  : [T] extends [[any, ...any[]]] ? `[${_ToStringAndJoin<T, \", \">}]`\n  : [T] extends [(infer E)[]] ? `${TypeToString<E>}[]`\n  : [T] extends [Function] ? \"function\"\n  : [T] extends [symbol] ? `symbol(${T['description']})`\n  : [T] extends [object] ? `{ ${Join<UnionToTuple<{ [K in keyof T]: `${TypeToString<K>}: ${TypeToString<T[K]>}` }[keyof T]>, \", \">} }`\n  : \"<unknown-type>\"\nexport type TypeToString<T> = _TypeToStringInner<T> extends `${infer S}` ? S : never;\n\n/**\n * Can be used to create assertions on types. For example, if passed any T other than `true`, the following will\n * show a type error:\n *\n * ```ts\n * typeAssert<T>()();  // the second pair of braces is important!\n * ```\n */\nexport function typeAssert<T>(): (\n  IsAny<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got any.`>\n    : IsNever<T> extends true ? TypeAssertionError<`Type assertion failed. Expected true, but got never.`>\n    : T extends true ? (() => undefined)\n    : TypeAssertionError<`Type assertion failed. Expected true, but got: ${TypeToString<T>}`>\n) {\n  return (() => undefined) as any;\n}\ntype TypeAssertionError<T> =\n  & [T]\n  & /* this promise makes sure that if we accidentally forget the second pair of braces, eslint will complain (if we have no-floating-promises enabled) */ Promise<any>;\n\n\ntypeAssertExtends<ReturnType<typeof typeAssert<true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<false>>, TypeAssertionError<`Type assertion failed. Expected true, but got: false`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<never>>, TypeAssertionError<`Type assertion failed. Expected true, but got never.`>>()();\ntypeAssertExtends<ReturnType<typeof typeAssert<any>>, TypeAssertionError<`Type assertion failed. Expected true, but got any.`>>()();\n\n/**\n * Functionally equivalent to `typeAssert<T extends S ? true : false>()()`, but with better error messages.\n */\nexport function typeAssertExtends<T, S>(): (\n  [T] extends [S] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to extend ${TypeToString<S>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, true>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, false>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<\"abc\", string>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: 1, b: 123}, {a: number}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<true, any>>, () => undefined>()();\n\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to extend { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<any, never>>, [\"Type assertion failed. Expected any to extend never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, true>>, [\"Type assertion failed. Expected false to extend true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertExtends<false, never>>, [\"Type assertion failed. Expected false to extend never\"]>()();\n\n\nexport function typeAssertIs<T, U>(): (\n  IsAny<T> extends true ? (IsAny<U> extends true ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : IsAny<U> extends true ? TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n    : [T] extends [U] ? ([U] extends [T] ? (() => undefined) : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>)\n    : TypeAssertionError<`Type assertion failed. Expected ${TypeToString<T>} to be ${TypeToString<U>}`>\n) {\n  return (() => undefined) as any;\n}\n\ntypeAssertExtends<ReturnType<typeof typeAssertIs<\"123\", \"123\">>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: 1}, {a: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<DeepPartial<{a: 1}>, {a?: 1}>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, any>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<never, never>>, () => undefined>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<1, any>>, [\"Type assertion failed. Expected 1 to be any\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, 1>>, [\"Type assertion failed. Expected any to be 1\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<{a: number}, {a: 1}>>, [\"Type assertion failed. Expected { 'a': number } to be { 'a': 1 }\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<any, never>>, [\"Type assertion failed. Expected any to be never\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, true>>, [\"Type assertion failed. Expected false to be true\"]>()();\ntypeAssertExtends<ReturnType<typeof typeAssertIs<false, never>>, [\"Type assertion failed. Expected false to be never\"]>()();\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkDA,aAA6F,EAAE;AAC/F,aAA0F,EAAE;AAuB5F,aAAqE,EAAE;AAwEhE,SAAS,aAKd;AACA,SAAQ,MAAM;AAChB;AAMA,kBAAwE,EAAE;AAC1E,kBAAoI,EAAE;AACtI,kBAAoI,EAAE;AACtI,kBAAgI,EAAE;AAK3H,SAAS,oBAEd;AACA,SAAQ,MAAM;AAChB;AAEA,kBAAsF,EAAE;AACxF,kBAAoF,EAAE;AACtF,kBAAuF,EAAE;AACzF,kBAAwF,EAAE;AAC1F,kBAAsG,EAAE;AACxG,kBAAuF,EAAE;AACzF,kBAAoF,EAAE;AAEtF,kBAAuJ,EAAE;AACzJ,kBAA6H,EAAE;AAC/H,kBAA+H,EAAE;AACjI,kBAAiI,EAAE;AAG5H,SAAS,eAKd;AACA,SAAQ,MAAM;AAChB;AAEA,kBAAkF,EAAE;AACpF,kBAAoF,EAAE;AACtF,kBAAkG,EAAE;AACpG,kBAA8E,EAAE;AAChF,kBAAkF,EAAE;AACpF,kBAA4G,EAAE;AAC9G,kBAA4G,EAAE;AAC9G,kBAAsH,EAAE;AACxH,kBAA8I,EAAE;AAChJ,kBAAoH,EAAE;AACtH,kBAAsH,EAAE;AACxH,kBAAwH,EAAE;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackframe/stack-shared",
-  "version": "2.8.36",
+  "version": "2.8.40",
   "files": [
     "README.md",
     "dist",
@@ -48,6 +48,7 @@
     "@aws-sdk/client-kms": "^3.876.0",
     "@opentelemetry/api": "^1.9.0",
     "@simplewebauthn/browser": "^11.0.0",
+    "@vercel/functions": "^2.0.0",
     "async-mutex": "^0.5.0",
     "bcryptjs": "^3.0.2",
     "crc": "^4.3.2",
@@ -60,7 +61,7 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@sentry/nextjs": "^8.40.0",
+    "@sentry/nextjs": "^10.11.0",
     "@simplewebauthn/types": "^11.0.0",
     "@types/bcryptjs": "^3.0.0",
     "@types/elliptic": "^6.4.18",