@take-out/helpers 0.0.28

package/src/time/time.ts

@@ -0,0 +1,51 @@
+interface MsFunction {
+  (n: number): number
+  seconds: (n: number) => number
+  minutes: (n: number) => number
+  hours: (n: number) => number
+  days: (n: number) => number
+  weeks: (n: number) => number
+}
+
+interface SecondFunction {
+  (n: number): number
+  minutes: (n: number) => number
+  hours: (n: number) => number
+  days: (n: number) => number
+  weeks: (n: number) => number
+}
+
+interface MinuteFunction {
+  (n: number): number
+  hours: (n: number) => number
+  days: (n: number) => number
+  weeks: (n: number) => number
+}
+
+const ms = ((n: number) => n) as MsFunction
+ms.seconds = (n: number) => n * 1000
+ms.minutes = (n: number) => ms.seconds(n * 60)
+ms.hours = (n: number) => ms.minutes(n * 60)
+ms.days = (n: number) => ms.hours(n * 24)
+ms.weeks = (n: number) => ms.days(n * 7)
+
+const second = ((n: number) => n) as SecondFunction
+second.minutes = (n: number) => n * 60
+second.hours = (n: number) => second.minutes(n * 60)
+second.days = (n: number) => second.hours(n * 24)
+second.weeks = (n: number) => second.days(n * 7)
+
+const minute = ((n: number) => n * 60) as MinuteFunction
+minute.hours = (n: number) => minute(n * 60)
+minute.days = (n: number) => minute.hours(n * 24)
+minute.weeks = (n: number) => minute.days(n * 7)
+
+export const time: {
+  ms: MsFunction
+  second: SecondFunction
+  minute: MinuteFunction
+} = {
+  ms,
+  second,
+  minute,
+}

package/src/types/NullToOptional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NullToOptional.d.ts","sourceRoot":"","sources":["NullToOptional.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;KAC7B,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,SAAS,GAAG,IAAI;CACzF,GAAG;KACD,CAAC,IAAI,MAAM,CAAC,IAAI,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACtD,CAAA"}

package/src/types/NullToOptional.ts

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

package/src/types/object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.d.ts","sourceRoot":"","sources":["object.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAC/B,CAAA;AAED,MAAM,MAAM,WAAW,GACnB,CAAC,WAAW,EAAE,OAAO,CAAC,EAAE,GACxB,aAAa,CAAC,SAAS,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC,CAAA;AAElD,KAAK,YAAY,CAAC,KAAK,IAAI;IAAE,CAAC,UAAU,CAAC,IAAI,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;CAAE,CAAA;AACnF,KAAK,mBAAmB,CAAC,OAAO,IAC9B,CAAC,OAAO,SAAS,GAAG,GAAG,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,IAAI,GAC7E,CAAC,GACD,KAAK,CAAA;AAEX,KAAK,2BAA2B,CAAC,KAAK,SAAS,WAAW,IACxD,YAAY,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GACnC,CAAC,SAAS,CAAC,MAAM,GAAG,EAAE,MAAM,GAAG,CAAC,GAC9B;KAAG,IAAI,IAAI,GAAG,GAAG,WAAW,GAAG,GAAG;CAAE,GACpC,KAAK,GACP,KAAK,CAAA;AAEX,KAAK,wBAAwB,CAAC,IAAI,IAAI;KAAG,GAAG,IAAI,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC;CAAE,CAAA;AAExE,MAAM,MAAM,eAAe,CAAC,KAAK,SAAS,WAAW,IAAI,wBAAwB,CAC/E,mBAAmB,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC,CACxD,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;AAErD,KAAK,WAAW,CAAC,KAAK,EAAE,OAAO,IAC7B,IAAI,CAAC,KAAK,EAAE;KAAG,CAAC,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS,OAAO,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,KAAK,CAAC,CAAC,CAAA;AAExF,MAAM,MAAM,aAAa,CAAC,KAAK,IAC7B;KAAG,CAAC,IAAI,MAAM,KAAK,GAAG,CAAC,MAAM,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC,MAAM,KAAK,CAAC,EAAE,CAAA"}

package/src/types/object.ts

@@ -0,0 +1,38 @@
+// note - TS doesn't support higher kinded types, so this doesn't work well
+
+// --- utils ---
+
+export type Mutable<T> = {
+  -readonly [K in keyof T]: T[K] // the ‘-readonly’ mapped-type modifier
+}
+
+export type EntriesType =
+  | [PropertyKey, unknown][]
+  | ReadonlyArray<readonly [PropertyKey, unknown]>
+
+type DeepWritable<OBJ_T> = { -readonly [P in keyof OBJ_T]: DeepWritable<OBJ_T[P]> }
+type UnionToIntersection<UNION_T> = // From https://stackoverflow.com/a/50375286
+  (UNION_T extends any ? (k: UNION_T) => void : never) extends (k: infer I) => void
+    ? I
+    : never
+
+type UnionObjectFromArrayOfPairs<ARR_T extends EntriesType> =
+  DeepWritable<ARR_T> extends (infer R)[]
+    ? R extends [infer key, infer val]
+      ? { [prop in key & PropertyKey]: val }
+      : never
+    : never
+
+type MergeIntersectingObjects<ObjT> = { [key in keyof ObjT]: ObjT[key] }
+
+export type EntriesToObject<ARR_T extends EntriesType> = MergeIntersectingObjects<
+  UnionToIntersection<UnionObjectFromArrayOfPairs<ARR_T>>
+>
+
+export type ObjectType = Record<PropertyKey, unknown>
+
+type PickByValue<OBJ_T, VALUE_T> = // From https://stackoverflow.com/a/55153000
+  Pick<OBJ_T, { [K in keyof OBJ_T]: OBJ_T[K] extends VALUE_T ? K : never }[keyof OBJ_T]>
+
+export type ObjectEntries<OBJ_T> = // From https://stackoverflow.com/a/60142095
+  { [K in keyof OBJ_T]: [keyof PickByValue<OBJ_T, OBJ_T[K]>, OBJ_T[K]] }[keyof OBJ_T][]

package/src/types/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["react.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA"}

package/src/types/react.ts

@@ -0,0 +1 @@
+export type RefProp<T> = React.RefObject<T> | React.RefCallback<T>

package/src/types/timer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["timer.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/src/types/timer.ts

@@ -0,0 +1 @@
+export type Timer = ReturnType<typeof setTimeout>

package/src/types/tuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple.d.ts","sourceRoot":"","sources":["tuple.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,GAAG,EAAE,IAAI,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/src/types/tuple.ts

@@ -0,0 +1 @@
+export type TupleToUnion<T extends any[]> = T[number]

package/src/url/urlSanitize.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const protocols = new Set(['http:', 'https:', 'mailto:', 'tel:', 'sms:'])
+
+export function urlSanitize(url: string) {
+  try {
+    const parsedUrl = new URL(url)
+    if (!protocols.has(parsedUrl.protocol)) {
+      return 'about:blank'
+    }
+  } catch {
+    return url
+  }
+  return url
+}

package/src/url/urlValidate.ts

@@ -0,0 +1,11 @@
+// Source: https://stackoverflow.com/a/8234912/2013580
+
+const urlRegExp = new RegExp(
+  /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[-;:&=+$,\w]+@)?[A-Za-z0-9.-]+|(?:www.|[-;:&=+$,\w]+@)[A-Za-z0-9.-]+)((?:\/[+~%/.\w-_]*)?\??(?:[-+=&;%@.\w_]*)#?(?:[\w]*))?)/
+)
+
+export function urlValidate(url: string) {
+  // TODO Fix UI for link insertion; it should never default to an invalid URL such as https://.
+  // Maybe show a dialog where they user can type the URL before inserting it.
+  return url === 'https://' || urlRegExp.test(url)
+}

package/types/array/fuzzy.d.ts

@@ -0,0 +1,10 @@
+import { type FuseSearchOptions, type IFuseOptions } from "fuse.js";
+export type FuzzyOptions = IFuseOptions<unknown>;
+export declare function createFuzzy<
+	A extends Record<string, any>,
+	Results extends A[] | readonly A[]
+>(items: Results, options?: IFuseOptions<A>): {
+	search: (val: string, options?: FuseSearchOptions) => Results;
+};
+
+//# sourceMappingURL=fuzzy.d.ts.map

package/types/array/fuzzy.d.ts.map

@@ -0,0 +1,16 @@
+{
+  "mappings": "AAAA,cAAoB,wBAAwB,oBAAoB,SAAS;AAEzE,YAAY,eAAe;AAK3B,OAAO,iBAAS;CACd,UAAU;CACV,gBAAgB,eAAe;EAE/BA,OAAO,SACPC,UAAU,aAAa,KACtB;CACD,SAASC,aAAaC,UAAU,sBAAsB;AACvD",
+  "names": [
+    "items: Results",
+    "options?: IFuseOptions<A>",
+    "val: string",
+    "options?: FuseSearchOptions"
+  ],
+  "sources": [
+    "src/array/fuzzy.ts"
+  ],
+  "sourcesContent": [
+    "import Fuse, { type FuseSearchOptions, type IFuseOptions } from 'fuse.js'\n\nexport type FuzzyOptions = IFuseOptions<unknown>\n\n// fuse does some insane staleness in getFn that doesn't make sense so pulled it all the way out here\nlet lastSearch = ''\n\nexport function createFuzzy<\n  A extends Record<string, any>,\n  Results extends A[] | readonly A[],\n>(\n  items: Results,\n  options?: IFuseOptions<A>\n): {\n  search: (val: string, options?: FuseSearchOptions) => Results\n} {\n  const fuse = new Fuse(items, {\n    isCaseSensitive: false,\n    threshold: 0.5,\n    ...options,\n    getFn(obj, path, ...rest) {\n      if (obj.skipFuzzy) {\n        return lastSearch\n      }\n      return Fuse.config.getFn(obj, path)\n    },\n  })\n\n  return {\n    search: (val: string, options?: FuseSearchOptions): Results => {\n      if (!val) {\n        return items\n      }\n      lastSearch = val\n      const results = fuse.search(val, options).map((result) => result.item)\n      return results as Results\n    },\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/array/getRandomItem.d.ts

@@ -0,0 +1,3 @@
+export declare const getRandomItem: <T>(items: T[]) => T | undefined;
+
+//# sourceMappingURL=getRandomItem.d.ts.map

package/types/array/getRandomItem.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,OAAO,cAAM,gBAAiB,GAAGA,OAAO,QAAM",
+  "names": [
+    "items: T[]"
+  ],
+  "sources": [
+    "src/array/getRandomItem.ts"
+  ],
+  "sourcesContent": [
+    "export const getRandomItem = <T>(items: T[]): T | undefined => {\n  if (items.length === 0) return\n  const randomIndex = Math.floor(Math.random() * items.length)\n  return items[randomIndex]\n}\n"
+  ],
+  "version": 3
+}

package/types/array/takeLast.d.ts

@@ -0,0 +1,3 @@
+export declare const takeLast: <T>(arr: T[], n: number) => T[];
+
+//# sourceMappingURL=takeLast.d.ts.map

package/types/array/takeLast.d.ts.map

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAAA,OAAO,cAAM,WAAY,GAAGA,KAAK,KAAKC,cAAY",
+  "names": [
+    "arr: T[]",
+    "n: number"
+  ],
+  "sources": [
+    "src/array/takeLast.ts"
+  ],
+  "sourcesContent": [
+    "export const takeLast = <T>(arr: T[], n: number): T[] => {\n  return arr.slice(-n)\n}\n"
+  ],
+  "version": 3
+}

package/types/array/uniqBy.d.ts

@@ -0,0 +1,12 @@
+/**
+* Returns a new array with duplicate elements removed based on a key selector function.
+* @param array The input array to remove duplicates from
+* @param keyFn Function that returns the key to compare elements by
+* @returns A new array with duplicates removed
+*/
+export declare function uniqBy<
+	T,
+	K
+>(array: T[], keyFn: (item: T) => K): T[];
+
+//# sourceMappingURL=uniqBy.d.ts.map

package/types/array/uniqBy.d.ts.map

@@ -0,0 +1,15 @@
+{
+  "mappings": ";;;;;;AAOA,OAAO,iBAAS;CAAO;CAAG;EAAGA,OAAO,KAAKC,QAAQC,MAAM,MAAM,IAAI",
+  "names": [
+    "array: T[]",
+    "keyFn: (item: T) => K",
+    "item: T"
+  ],
+  "sources": [
+    "src/array/uniqBy.ts"
+  ],
+  "sourcesContent": [
+    "/**\n * Returns a new array with duplicate elements removed based on a key selector function.\n * @param array The input array to remove duplicates from\n * @param keyFn Function that returns the key to compare elements by\n * @returns A new array with duplicates removed\n */\n\nexport function uniqBy<T, K>(array: T[], keyFn: (item: T) => K): T[] {\n  const seen = new Map<K, T>()\n\n  for (const item of array) {\n    const key = keyFn(item)\n    if (!seen.has(key)) {\n      seen.set(key, item)\n    }\n  }\n\n  return Array.from(seen.values())\n}\n"
+  ],
+  "version": 3
+}

package/types/assert.d.ts

@@ -0,0 +1,6 @@
+export declare function assertExists<T>(value: T | undefined | null, msg?: string): T;
+export declare function assert<T>(value: T, msg?: string): Exclude<T, null | undefined | false>;
+export declare function assertError(val: unknown): Error;
+export declare function assertString(val: unknown, name?: string): string;
+
+//# sourceMappingURL=assert.d.ts.map

package/types/assert.d.ts.map

@@ -0,0 +1,15 @@
+{
+  "mappings": "AAEA,OAAO,iBAAS,aAAa,GAAGA,OAAO,sBAAsB,eAAW;AAOxE,OAAO,iBAAS,OAAO,GAAGC,OAAO,GAAG,eAAW,QAAQ,sBAAsB;AAO7E,OAAO,iBAAS,YAAYC,eAAe;AAO3C,OAAO,iBAAS,aAAaA,cAAc",
+  "names": [
+    "value: T | undefined | null",
+    "value: T",
+    "val: unknown"
+  ],
+  "sources": [
+    "src/assert.ts"
+  ],
+  "sourcesContent": [
+    "import { AbortError } from './error/errors'\n\nexport function assertExists<T>(value: T | undefined | null, msg = ''): T {\n  if (value === undefined || value === null) {\n    throw new AbortError(`Invalid nullish value (${value}): ${msg}`)\n  }\n  return value\n}\n\nexport function assert<T>(value: T, msg = ''): Exclude<T, null | undefined | false> {\n  if (!value) {\n    throw new AbortError(`Invalid falsy value (${value}): ${msg}`)\n  }\n  return value as Exclude<T, null | undefined | false>\n}\n\nexport function assertError(val: unknown): Error {\n  if (!(val instanceof Error)) {\n    throw val\n  }\n  return val\n}\n\nexport function assertString(val: unknown, name = '(unnamed)'): string {\n  if (typeof val !== 'string') {\n    throw new AbortError(`No string ${name}`)\n  }\n  return val\n}\n"
+  ],
+  "version": 3
+}

package/types/async/abortable.d.ts

@@ -0,0 +1,10 @@
+type AbortableOptions = {
+	message?: string;
+};
+export declare function abortable<T>(cb: () => T, options?: AbortableOptions): T | undefined;
+export declare function abortable<T>(cb: () => Promise<T>, options?: AbortableOptions): Promise<T | undefined>;
+export declare function didAbort(err: unknown, options?: AbortableOptions): boolean;
+export declare function handleAbortError(error: any, debug?: boolean): void;
+export {};
+
+//# sourceMappingURL=abortable.d.ts.map

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

@@ -0,0 +1,18 @@
+{
+  "mappings": "KAEK,mBAAmB;CAAE;AAAkB;AAE5C,OAAO,iBAAS,UAAU,GAAGA,UAAU,GAAGC,UAAU,mBAAmB;AACvE,OAAO,iBAAS,UAAU,GACxBC,UAAU,QAAQ,IAClBD,UAAU,mBACT,QAAQ;AA0BX,OAAO,iBAAS,SAASE,cAAcF,UAAU;AAUjD,OAAO,iBAAS,iBAAiBG,YAAYC",
+  "names": [
+    "cb: () => T",
+    "options?: AbortableOptions",
+    "cb: () => Promise<T>",
+    "err: unknown",
+    "error: any",
+    "debug?: boolean"
+  ],
+  "sources": [
+    "src/async/abortable.ts"
+  ],
+  "sourcesContent": [
+    "import { AbortError, EnsureError } from '../error/errors'\n\ntype AbortableOptions = { message?: string }\n\nexport function abortable<T>(cb: () => T, options?: AbortableOptions): T | undefined\nexport function abortable<T>(\n  cb: () => Promise<T>,\n  options?: AbortableOptions\n): Promise<T | undefined>\nexport function abortable<T>(\n  cb: () => T | Promise<T>,\n  options?: AbortableOptions\n): T | undefined | Promise<T | undefined> {\n  try {\n    const value = cb()\n\n    if (value instanceof Promise) {\n      return value.catch((err) => {\n        if (didAbort(err, options)) {\n          return undefined\n        }\n        throw err\n      })\n    }\n\n    return value\n  } catch (err) {\n    if (didAbort(err, options)) {\n      return undefined\n    }\n    throw err\n  }\n}\n\nexport function didAbort(err: unknown, options?: AbortableOptions): boolean {\n  if (err instanceof AbortError || err instanceof EnsureError) {\n    if (options?.message) {\n      console.warn(`Aborted: ${options.message}`)\n    }\n    return true\n  }\n  return false\n}\n\nexport function handleAbortError(error: any, debug?: boolean): void {\n  if (error instanceof AbortError || error instanceof EnsureError) {\n    if (debug || process.env.DEBUG) {\n      console.info(`🐛 useAsyncEffect aborted: ${error.message}`)\n    }\n    return\n  }\n\n  // js handles aborting a promise as an error. ignore them since they're\n  // a normal part of the expected async workflow\n  if (typeof error === 'object' && error.name === 'AbortError') {\n    return\n  }\n\n  throw error\n}\n"
+  ],
+  "version": 3
+}

package/types/async/asyncContext.d.ts

@@ -0,0 +1,8 @@
+interface AsyncContext<T> {
+	get(): T | undefined;
+	run<R>(value: T, fn: () => R | Promise<R>): Promise<R>;
+}
+export declare function createAsyncContext<T>(): AsyncContext<T>;
+export {};
+
+//# sourceMappingURL=asyncContext.d.ts.map

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

@@ -0,0 +1,14 @@
+{
+  "mappings": "UAAU,aAAa,GAAG;CACxB,OAAO;CACP,IAAI,GAAGA,OAAO,GAAGC,UAAU,IAAI,QAAQ,KAAK,QAAQ;AACrD;AA0BD,OAAO,iBAAS,mBAAmB,MAAM,aAAa",
+  "names": [
+    "value: T",
+    "fn: () => R | Promise<R>"
+  ],
+  "sources": [
+    "src/async/asyncContext.ts"
+  ],
+  "sourcesContent": [
+    "interface AsyncContext<T> {\n  get(): T | undefined\n  run<R>(value: T, fn: () => R | Promise<R>): Promise<R>\n}\n\ninterface NodeAsyncLocalStorage<T> {\n  getStore(): T | undefined\n  run<R>(store: T, callback: () => R): R\n}\n\ninterface AsyncLocalStorageConstructor {\n  new <T>(): NodeAsyncLocalStorage<T>\n}\n\nlet nodeAsyncLocalStorageCache: AsyncLocalStorageConstructor | null = null\n\nasync function getNodeAsyncLocalStorage(): Promise<AsyncLocalStorageConstructor | null> {\n  if (!nodeAsyncLocalStorageCache) {\n    try {\n      const module = await import('node:async_hooks')\n      nodeAsyncLocalStorageCache =\n        module.AsyncLocalStorage as AsyncLocalStorageConstructor\n    } catch {\n      return null\n    }\n  }\n  return nodeAsyncLocalStorageCache\n}\n\nexport function createAsyncContext<T>(): AsyncContext<T> {\n  if (process.env.VITE_ENVIRONMENT === 'ssr') {\n    let storage: NodeAsyncLocalStorage<T> | null = null\n\n    getNodeAsyncLocalStorage().then((AsyncLocalStorage) => {\n      if (AsyncLocalStorage && !storage) {\n        storage = new AsyncLocalStorage<T>()\n      }\n    })\n\n    return {\n      get(): T | undefined {\n        if (!storage) {\n          console.warn(`⚠️ called AsyncContext before load!`)\n          return\n        }\n\n        return storage.getStore()\n      },\n\n      async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n        if (!storage) {\n          throw new Error(`⚠️ called AsyncContext before load!`)\n        }\n        return storage.run(value, fn)\n      },\n    }\n  } else {\n    // browser implementation using promise patching\n    return createBrowserAsyncContext<T>()\n  }\n}\n\nfunction createBrowserAsyncContext<T>(): AsyncContext<T> {\n  let currentContext: T | undefined\n  const contextStack: (T | undefined)[] = []\n\n  return {\n    get(): T | undefined {\n      return currentContext\n    },\n    async run<R>(value: T, fn: () => R | Promise<R>): Promise<R> {\n      const prevContext = currentContext\n      currentContext = value\n      contextStack.push(prevContext)\n\n      // store original Promise methods\n      const OriginalPromise = Promise\n      const OriginalThen = OriginalPromise.prototype.then\n      const OriginalCatch = OriginalPromise.prototype.catch\n      const OriginalFinally = OriginalPromise.prototype.finally\n\n      function wrapCallback(\n        callback: Function | undefined | null,\n        context: T | undefined\n      ): Function | undefined | null {\n        if (!callback) return callback\n        return (...args: any[]) => {\n          const prevContext = currentContext\n          currentContext = context\n          try {\n            return callback(...args)\n          } finally {\n            currentContext = prevContext\n          }\n        }\n      }\n\n      // patch Promise methods to capture and restore context\n      // biome-ignore lint/suspicious/noThenProperty: intentional patching for context propagation\n      OriginalPromise.prototype.then = function (\n        this: Promise<any>,\n        onFulfilled?: any,\n        onRejected?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalThen.call(\n          this,\n          wrapCallback(onFulfilled, context) as any,\n          wrapCallback(onRejected, context) as any\n        )\n      }\n\n      OriginalPromise.prototype.catch = function (\n        this: Promise<any>,\n        onRejected?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalCatch.call(this, wrapCallback(onRejected, context) as any)\n      }\n\n      OriginalPromise.prototype.finally = function (\n        this: Promise<any>,\n        onFinally?: any\n      ): Promise<any> {\n        const context = currentContext\n        return OriginalFinally.call(this, wrapCallback(onFinally, context) as any)\n      }\n\n      try {\n        const result = await fn()\n        return result\n      } finally {\n        // restore original Promise methods\n        // biome-ignore lint/suspicious/noThenProperty: restoring original methods\n        OriginalPromise.prototype.then = OriginalThen\n        OriginalPromise.prototype.catch = OriginalCatch\n        OriginalPromise.prototype.finally = OriginalFinally\n\n        contextStack.pop()\n        currentContext = prevContext\n      }\n    },\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/async/idle.d.ts

@@ -0,0 +1,8 @@
+export type IdleOptions = {
+	max?: number;
+	min?: number;
+	fully?: boolean;
+};
+export declare const idle: (options?: IdleOptions, signal?: AbortSignal) => Promise<void>;
+
+//# sourceMappingURL=idle.d.ts.map

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

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

package/types/async/interval.d.ts

@@ -0,0 +1,3 @@
+export declare const interval: (callback: () => void, ms: number, signal?: AbortSignal) => Promise<never>;
+
+//# sourceMappingURL=interval.d.ts.map

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

@@ -0,0 +1,15 @@
+{
+  "mappings": "AAEA,OAAO,cAAM,WACXA,sBACAC,YACAC,SAAS,gBACR",
+  "names": [
+    "callback: () => void",
+    "ms: number",
+    "signal?: AbortSignal"
+  ],
+  "sources": [
+    "src/async/interval.ts"
+  ],
+  "sourcesContent": [
+    "import { sleep } from './sleep'\n\nexport const interval = async (\n  callback: () => void,\n  ms: number,\n  signal?: AbortSignal\n): Promise<never> => {\n  while (true) {\n    callback()\n    await sleep(ms, signal)\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/async/isAborted.d.ts

@@ -0,0 +1,3 @@
+export declare const isAborted: (controller?: AbortController) => boolean;
+
+//# sourceMappingURL=isAborted.d.ts.map

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

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,OAAO,cAAM,YAAaA,aAAa",
+  "names": [
+    "controller?: AbortController"
+  ],
+  "sources": [
+    "src/async/isAborted.ts"
+  ],
+  "sourcesContent": [
+    "export const isAborted = (controller?: AbortController): boolean =>\n  !!controller?.signal.aborted\n"
+  ],
+  "version": 3
+}

package/types/async/sleep.d.ts

@@ -0,0 +1,3 @@
+export declare const sleep: (ms: number, signal?: AbortSignal) => Promise<void>;
+
+//# sourceMappingURL=sleep.d.ts.map

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

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAEA,OAAO,cAAM,QAAeA,YAAYC,SAAS,gBAAc",
+  "names": [
+    "ms: number",
+    "signal?: AbortSignal"
+  ],
+  "sources": [
+    "src/async/sleep.ts"
+  ],
+  "sourcesContent": [
+    "import { AbortError } from '../error/errors'\n\nexport const sleep = async (ms: number, signal?: AbortSignal): Promise<void> => {\n  await new Promise((res) => setTimeout(res, ms))\n  if (signal?.aborted) {\n    throw new AbortError()\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/async/useAsync.d.ts

@@ -0,0 +1,3 @@
+export declare function useAsync<T>(promiseFn: () => Promise<T>, args: any[]): [T, "loading" | "idle" | "error", Error | null];
+
+//# sourceMappingURL=useAsync.d.ts.map

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

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAEA,OAAO,iBAAS,SAAS,GACvBA,iBAAiB,QAAQ,IACzBC,eACE,GAAG,YAAY,SAAS,SAAS",
+  "names": [
+    "promiseFn: () => Promise<T>",
+    "args: any[]"
+  ],
+  "sources": [
+    "src/async/useAsync.ts"
+  ],
+  "sourcesContent": [
+    "import { useState, useEffect } from 'react'\n\nexport function useAsync<T>(\n  promiseFn: () => Promise<T>,\n  args: any[]\n): [T, 'loading' | 'idle' | 'error', Error | null] {\n  const [data, setData] = useState<T | null>(null)\n  const [error, setError] = useState<Error | null>(null)\n  const [loading, setLoading] = useState<boolean>(true)\n\n  useEffect(() => {\n    let isMounted = true\n\n    const fetchData = async () => {\n      try {\n        const result = await promiseFn()\n        if (isMounted) {\n          setData(result)\n          setLoading(false)\n        }\n      } catch (err) {\n        if (isMounted) {\n          setError(err as Error)\n          setLoading(false)\n        }\n      }\n    }\n\n    fetchData()\n\n    return () => {\n      isMounted = false\n    }\n    // biome-ignore lint/correctness/useExhaustiveDependencies: ignore\n  }, args)\n\n  return [data as T, error ? 'error' : loading ? 'loading' : 'idle', error]\n}\n"
+  ],
+  "version": 3
+}

package/types/async/useAsyncEffect.d.ts

@@ -0,0 +1,12 @@
+type Cleanup = () => void;
+type AsyncEffectCallback = (signal: AbortSignal, ...deps: any[]) => Promise<Cleanup | void> | void;
+type AsyncEffectOptions = {
+	circuitBreakAfter?: number;
+	circuitBreakPeriod?: number;
+	debug?: boolean;
+};
+export declare function useAsyncEffect(cb: AsyncEffectCallback, deps?: any[], options?: AsyncEffectOptions): void;
+export declare function useAsyncLayoutEffect(cb: AsyncEffectCallback, deps?: any[], options?: AsyncEffectOptions): void;
+export {};
+
+//# sourceMappingURL=useAsyncEffect.d.ts.map

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

@@ -0,0 +1,16 @@
+{
+  "mappings": "KAMK;KAEA,uBACHA,QAAQ,aACR,GAAG,gBACA,QAAQ;KAER,qBAAqB;CACxB;CACA;CACA;AACD;AAED,OAAO,iBAAS,eACdC,IAAI,qBACJC,cACAC,UAAU;AAKZ,OAAO,iBAAS,qBACdF,IAAI,qBACJC,cACAC,UAAU",
+  "names": [
+    "signal: AbortSignal",
+    "cb: AsyncEffectCallback",
+    "deps: any[]",
+    "options?: AsyncEffectOptions"
+  ],
+  "sources": [
+    "src/async/useAsyncEffect.ts"
+  ],
+  "sourcesContent": [
+    "// adopted from https://github.com/franciscop/use-async/blob/master/src/index.js\n\nimport { useEffect, useId, useLayoutEffect } from 'react'\nimport { EMPTY_OBJECT } from '../constants'\nimport { handleAbortError } from './abortable'\n\ntype Cleanup = () => void\n\ntype AsyncEffectCallback = (\n  signal: AbortSignal,\n  ...deps: any[]\n) => Promise<Cleanup | void> | void\n\ntype AsyncEffectOptions = {\n  circuitBreakAfter?: number\n  circuitBreakPeriod?: number\n  debug?: boolean\n}\n\nexport function useAsyncEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions\n): void {\n  useAsyncEffectImpl(false, cb, deps, options)\n}\n\nexport function useAsyncLayoutEffect(\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options?: AsyncEffectOptions\n): void {\n  useAsyncEffectImpl(true, cb, deps, options)\n}\n\nfunction useAsyncEffectImpl(\n  isLayoutEffect: boolean,\n  cb: AsyncEffectCallback,\n  deps: any[] = [],\n  options: AsyncEffectOptions = EMPTY_OBJECT\n): void {\n  const effectHook = isLayoutEffect ? useLayoutEffect : useEffect\n  // biome-ignore lint/correctness/useHookAtTopLevel: ignore\n  const effectId = process.env.NODE_ENV === 'development' ? useId() : ''\n\n  effectHook(() => {\n    // Generate a unique ID for this effect instance for loop detection\n    checkEffectLoop(effectId, options.circuitBreakAfter, options.circuitBreakPeriod)\n    const controller = new AbortController()\n    const signal = controller.signal\n\n    // wrap in try in case its not async (for simple use cases)\n    try {\n      const value = cb(signal, ...deps)\n\n      Promise.resolve(value)\n        .then(async (res) => {\n          if (res && typeof res === 'function') {\n            if (signal.aborted) return res()\n            signal.addEventListener('abort', res)\n          }\n        })\n        .catch(handleAbortError)\n    } catch (error) {\n      handleAbortError(error, options.debug)\n    }\n\n    return () => {\n      if (signal.aborted) return\n      controller.abort()\n    }\n  }, deps)\n}\n\n// loop detection in dev mode\nlet effectRunCounts: Map<string, number[]>\nlet checkEffectLoop: (\n  effectId: string,\n  circuitBreakAfter?: number,\n  circuitBreakPeriod?: number\n) => void\n\nif (process.env.NODE_ENV === 'development') {\n  effectRunCounts = new Map<string, number[]>()\n\n  checkEffectLoop = (\n    effectId: string,\n    circuitBreakAfter: number = 20,\n    circuitBreakPeriod: number = 1000\n  ) => {\n    const now = Date.now()\n    const runs = effectRunCounts.get(effectId) || []\n\n    runs.push(now)\n\n    // keep only runs from the specified period\n    const recentRuns = runs.filter((time) => now - time < circuitBreakPeriod)\n    effectRunCounts.set(effectId, recentRuns)\n\n    const runCount = recentRuns.length\n\n    if (runCount > circuitBreakAfter) {\n      const message = `🚨 useAsyncEffect infinite loop detected! Effect ran ${runCount} times in <${circuitBreakPeriod}ms`\n      if (process.env.NODE_ENV === 'development') {\n        console.error(message)\n        // biome-ignore lint/suspicious/noDebugger: ignore\n        debugger\n      } else {\n        alert(message)\n        throw new Error(message)\n      }\n    } else if (runCount > circuitBreakAfter / 2) {\n      console.warn(\n        `⚠️ useAsyncEffect potential loop: Effect ran ${runCount} times in <${circuitBreakPeriod}ms`\n      )\n    }\n  }\n} else {\n  checkEffectLoop = () => {}\n}\n"
+  ],
+  "version": 3
+}

package/types/async/useLazyMount.d.ts

@@ -0,0 +1,9 @@
+import type React from "react";
+import { type IdleOptions } from "./idle";
+export type LazyMountProps = IdleOptions;
+export declare const useLazyMount: (props?: LazyMountProps) => boolean;
+export declare const LazyMount: ({ children,...idleProps }: LazyMountProps & {
+	children: any;
+}) => React.ReactNode;
+
+//# sourceMappingURL=useLazyMount.d.ts.map

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

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,YAAY,WAAW,OAAO;AAE9B,cAAoB,mBAAmB,QAAQ;AAG/C,YAAY,iBAAiB;AAE7B,OAAO,cAAM,eAAgBA,QAAO;AAkBpC,OAAO,cAAM,YAAa,EACxB,SACA,GAAG,WACgC,EAAlC,iBAAiB;CAAE;AAAe,MAAG,MAAM",
+  "names": [
+    "props: LazyMountProps"
+  ],
+  "sources": [
+    "src/async/useLazyMount.ts"
+  ],
+  "sourcesContent": [
+    "import type React from 'react'\nimport { startTransition, useState } from 'react'\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nexport type LazyMountProps = IdleOptions\n\nexport const useLazyMount = (props: LazyMountProps = { max: 100 }): boolean => {\n  const [mounted, setMounted] = useState(false)\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(props, signal)\n      startTransition(() => {\n        setMounted(true)\n      })\n    },\n    [\n      // no need for deps it only ever mounts once\n    ]\n  )\n\n  return mounted\n}\n\nexport const LazyMount = ({\n  children,\n  ...idleProps\n}: LazyMountProps & { children: any }): React.ReactNode => {\n  const mounted = useLazyMount(idleProps)\n  return mounted ? children : null\n}\n"
+  ],
+  "version": 3
+}

package/types/async/useLazyValue.d.ts

@@ -0,0 +1,6 @@
+import { type IdleOptions } from "./idle";
+export declare const useLazyValue: <T>(value: T, { immediateFirstUpdate,...idleOptions }?: IdleOptions & {
+	immediateFirstUpdate?: boolean;
+}) => T;
+
+//# sourceMappingURL=useLazyValue.d.ts.map

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

@@ -0,0 +1,13 @@
+{
+  "mappings": "AACA,cAAoB,mBAAmB,QAAQ;AAG/C,OAAO,cAAM,eAAgB,GAC3BA,OAAO,GACP,EACE,qBACA,GAAG,aAC8C,GAAhD,cAAc;CAAE;AAAgC,MAClD",
+  "names": [
+    "value: T"
+  ],
+  "sources": [
+    "src/async/useLazyValue.ts"
+  ],
+  "sourcesContent": [
+    "import { startTransition, useState } from 'react'\nimport { idle, type IdleOptions } from './idle'\nimport { useAsyncEffect } from './useAsyncEffect'\n\nexport const useLazyValue = <T>(\n  value: T,\n  {\n    immediateFirstUpdate,\n    ...idleOptions\n  }: IdleOptions & { immediateFirstUpdate?: boolean } = {}\n): T => {\n  const [lazyValue, setLazyValue] = useState(value)\n\n  // first update to a real value immediate\n  if (value && lazyValue === undefined && lazyValue !== value && immediateFirstUpdate) {\n    setLazyValue(value)\n  }\n\n  useAsyncEffect(\n    async (signal) => {\n      await idle(idleOptions, signal)\n      startTransition(() => {\n        setLazyValue(value)\n      })\n    },\n    [value]\n  )\n\n  return lazyValue\n}\n"
+  ],
+  "version": 3
+}

package/types/browser/clearIndexedDB.d.ts

@@ -0,0 +1,3 @@
+export declare function clearIndexedDB(): Promise<void>;
+
+//# sourceMappingURL=clearIndexedDB.d.ts.map

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

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,OAAO,iBAAe,kBAAkB",
+  "names": [],
+  "sources": [
+    "src/browser/clearIndexedDB.ts"
+  ],
+  "sourcesContent": [
+    "export async function clearIndexedDB(): Promise<void> {\n  if ('indexedDB' in window) {\n    const databases = await indexedDB.databases()\n    await Promise.all(\n      databases.map((db) => {\n        if (db.name) {\n          return new Promise<void>((resolve, reject) => {\n            const deleteReq = indexedDB.deleteDatabase(db.name!)\n            deleteReq.onsuccess = () => resolve()\n            deleteReq.onerror = () => reject(deleteReq.error)\n            deleteReq.onblocked = () => reject(new Error('database deletion blocked'))\n          })\n        }\n        return Promise.resolve()\n      })\n    )\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/browser/isActiveElementFormField.d.ts

@@ -0,0 +1,3 @@
+export declare function isActiveElementFormField(): boolean;
+
+//# sourceMappingURL=isActiveElementFormField.d.ts.map

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

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,OAAO,iBAAS",
+  "names": [],
+  "sources": [
+    "src/browser/isActiveElementFormField.ts"
+  ],
+  "sourcesContent": [
+    "export function isActiveElementFormField(): boolean {\n  return (\n    typeof document !== 'undefined' &&\n    document.activeElement !== null &&\n    (document.activeElement.tagName === 'INPUT' ||\n      document.activeElement.tagName === 'TEXTAREA' ||\n      document.activeElement.tagName === 'SELECT' ||\n      document.activeElement.tagName === 'FORM')\n  )\n}\n"
+  ],
+  "version": 3
+}

package/types/browser/localStorage.d.ts

@@ -0,0 +1,31 @@
+interface LocalStorageOptions {
+	synced?: boolean;
+	disableSetOnBlur?: boolean;
+	/**
+	* Limit in kB
+	*/
+	storageLimit?: number;
+}
+export declare function createLocalStorage<
+	K extends string,
+	V
+>(name: string, { synced, disableSetOnBlur, storageLimit }?: LocalStorageOptions): {
+	get: (key: K) => V | undefined;
+	set: (key: K, value: V) => void;
+	remove: (key: K) => void;
+	exists: (key: K) => boolean;
+	clear: () => void;
+	subscribe: (key: string, listener: (value: V | undefined) => void) => (() => void);
+	keys: () => string[];
+};
+export declare function createLocalStorageValue<T>(key: string, options?: LocalStorageOptions): {
+	get: () => T | undefined;
+	set: (value: T) => void;
+	remove: () => void;
+	exists: () => boolean;
+	clear: () => void;
+	subscribe: (listener: (value: T | undefined) => void) => (() => void);
+};
+export {};
+
+//# sourceMappingURL=localStorage.d.ts.map