@take-out/helpers 0.0.28

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

@@ -0,0 +1,22 @@
+{
+  "mappings": "UASU,oBAAoB;CAC5B;CACA;;;;CAKA;AACD;AAED,OAAO,iBAAS;CAAmB;CAAkB;EACnDA,cACA,EAAE,QAAgB,kBAA0B,cAAmC,GAAnB;CA0C1D,MAAMC,KAAK,MAAI;CAcf,MAAMA,KAAK,GAAGC,OAAO;CAyBrB,SAASD,KAAK;CA6Bd,SAASA,KAAK;CAKd;CAmCA,YAAYE,aAAaC,WAAWC,OAAO;CAoB3C;;AAoBJ,OAAO,iBAAS,wBAAwB,GACtCF,aACAG,UAAS;CAMP,WAAS;CAIT,MAAMC,OAAO;CAIb;CAIA;CAIA;CAIA,YAAYC,WAAWC,OAAO",
+  "names": [
+    "name: string",
+    "key: K",
+    "value: V",
+    "key: string",
+    "listener: (value: V | undefined) => void",
+    "value: V | undefined",
+    "options: LocalStorageOptions",
+    "value: T",
+    "listener: (value: T | undefined) => void",
+    "value: T | undefined"
+  ],
+  "sources": [
+    "src/browser/localStorage.ts"
+  ],
+  "sourcesContent": [
+    "const created = new Set<string>()\n\nconst STORAGE_TRACKING_KEY = '__localStorage_tracking__'\nconst STORAGE_ORDER_KEY = '__localStorage_order__'\n\ninterface StorageTracking {\n  [key: string]: number // key -> size in bytes\n}\n\ninterface LocalStorageOptions {\n  synced?: boolean\n  disableSetOnBlur?: boolean\n\n  /**\n   * Limit in kB\n   */\n  storageLimit?: number\n}\n\nexport function createLocalStorage<K extends string, V>(\n  name: string,\n  { synced = false, disableSetOnBlur = false, storageLimit }: LocalStorageOptions = {}\n) {\n  if (created.has(name)) {\n    throw new Error(`Already defined this localStorage namespace: ${name}`)\n  }\n  created.add(name)\n\n  let isWindowActive = true\n  if (typeof window !== 'undefined' && disableSetOnBlur) {\n    const handleFocus = () => {\n      isWindowActive = true\n    }\n    const handleBlur = () => {\n      isWindowActive = false\n    }\n\n    window.addEventListener('focus', handleFocus)\n    window.addEventListener('blur', handleBlur)\n\n    isWindowActive = document.hasFocus()\n  }\n\n  const listeners = new Map<string, Set<(value: any) => void>>()\n\n  if (synced && typeof window !== 'undefined') {\n    const handleStorageChange = (event: StorageEvent) => {\n      if (event.key?.startsWith(`${name}:`) && event.storageArea === localStorage) {\n        const key = event.key.slice(name.length + 1)\n        const newValue = event.newValue ? JSON.parse(event.newValue) : undefined\n        const keyListeners = listeners.get(key)\n        if (keyListeners) {\n          keyListeners.forEach((listener) => listener(newValue))\n        }\n      }\n    }\n\n    window.addEventListener('storage', handleStorageChange)\n  }\n\n  const getFullKey = (key: string) => `${name}:${key}`\n\n  return {\n    get: (key: K): V | undefined => {\n      if (typeof localStorage === 'undefined') {\n        console.warn(`No localStorage`)\n        return\n      }\n\n      const fullKey = getFullKey(key)\n      const item = localStorage.getItem(fullKey)\n      if (item && storageLimit) {\n        updateKeyAccess(fullKey)\n      }\n      return item ? JSON.parse(item) : undefined\n    },\n\n    set: (key: K, value: V): void => {\n      if (typeof localStorage === 'undefined') {\n        console.warn(`No localStorage`)\n        return\n      }\n\n      if (disableSetOnBlur && !isWindowActive) {\n        return\n      }\n\n      const fullKey = getFullKey(key)\n      const serializedValue = JSON.stringify(value)\n\n      if (storageLimit) {\n        const newSize = getStringSizeInBytes(serializedValue)\n        enforceStorageLimit(fullKey, newSize, storageLimit)\n        const tracking = getStorageTracking()\n        tracking[fullKey] = newSize\n        setStorageTracking(tracking)\n        updateKeyAccess(fullKey)\n      }\n\n      localStorage.setItem(fullKey, serializedValue)\n    },\n\n    remove: (key: K): void => {\n      if (typeof localStorage === 'undefined') {\n        console.warn(`No localStorage`)\n        return\n      }\n\n      // don't remove if window is not active and disablesetonblur is true\n      if (disableSetOnBlur && !isWindowActive) {\n        return\n      }\n\n      const fullKey = getFullKey(key)\n      localStorage.removeItem(fullKey)\n\n      // clean up tracking data if storage limit is enabled\n      if (storageLimit) {\n        const tracking = getStorageTracking()\n        delete tracking[fullKey]\n        setStorageTracking(tracking)\n\n        const order = getStorageOrder()\n        const index = order.indexOf(fullKey)\n        if (index > -1) {\n          order.splice(index, 1)\n          setStorageOrder(order)\n        }\n      }\n    },\n\n    exists: (key: K): boolean => {\n      const fullKey = getFullKey(key)\n      return localStorage.getItem(fullKey) != null\n    },\n\n    clear: (): void => {\n      if (typeof localStorage === 'undefined') {\n        console.warn(`No localStorage`)\n        return\n      }\n\n      // Remove all keys with this namespace\n      const keysToRemove: string[] = []\n      for (let i = 0; i < localStorage.length; i++) {\n        const key = localStorage.key(i)\n        if (key?.startsWith(`${name}:`)) {\n          keysToRemove.push(key)\n        }\n      }\n\n      keysToRemove.forEach((key) => localStorage.removeItem(key))\n\n      // Clean up tracking data\n      if (storageLimit) {\n        const tracking = getStorageTracking()\n        const order = getStorageOrder()\n\n        keysToRemove.forEach((key) => {\n          delete tracking[key]\n          const index = order.indexOf(key)\n          if (index > -1) {\n            order.splice(index, 1)\n          }\n        })\n\n        setStorageTracking(tracking)\n        setStorageOrder(order)\n      }\n    },\n\n    subscribe: (key: string, listener: (value: V | undefined) => void): (() => void) => {\n      if (!synced) {\n        console.warn(`Subscribe only works when synced option is enabled`)\n        return () => {}\n      }\n\n      if (!listeners.has(key)) {\n        listeners.set(key, new Set())\n      }\n      const keyListeners = listeners.get(key)!\n      keyListeners.add(listener)\n\n      return () => {\n        keyListeners.delete(listener)\n        if (keyListeners.size === 0) {\n          listeners.delete(key)\n        }\n      }\n    },\n\n    keys: (): string[] => {\n      if (typeof localStorage === 'undefined') {\n        return []\n      }\n\n      const keys: string[] = []\n      const prefix = `${name}:`\n\n      for (let i = 0; i < localStorage.length; i++) {\n        const key = localStorage.key(i)\n        if (key?.startsWith(prefix)) {\n          keys.push(key.slice(prefix.length))\n        }\n      }\n\n      return keys\n    },\n  }\n}\n\nexport function createLocalStorageValue<T>(\n  key: string,\n  options: LocalStorageOptions = {}\n) {\n  const storage = createLocalStorage<string, T>(`single:${key}`, options)\n  const storageKey = 'value'\n\n  return {\n    get: (): T | undefined => {\n      return storage.get(storageKey)\n    },\n\n    set: (value: T): void => {\n      storage.set(storageKey, value)\n    },\n\n    remove: (): void => {\n      storage.remove(storageKey)\n    },\n\n    exists: (): boolean => {\n      return storage.exists(storageKey)\n    },\n\n    clear: (): void => {\n      storage.clear()\n    },\n\n    subscribe: (listener: (value: T | undefined) => void): (() => void) => {\n      return storage.subscribe(storageKey, listener)\n    },\n  }\n}\n\nfunction getStorageTracking(): StorageTracking {\n  if (typeof localStorage === 'undefined') return {}\n  const tracking = localStorage.getItem(STORAGE_TRACKING_KEY)\n  return tracking ? JSON.parse(tracking) : {}\n}\n\nfunction setStorageTracking(tracking: StorageTracking): void {\n  if (typeof localStorage === 'undefined') return\n  localStorage.setItem(STORAGE_TRACKING_KEY, JSON.stringify(tracking))\n}\n\nfunction getStorageOrder(): string[] {\n  if (typeof localStorage === 'undefined') return []\n  const order = localStorage.getItem(STORAGE_ORDER_KEY)\n  return order ? JSON.parse(order) : []\n}\n\nfunction setStorageOrder(order: string[]): void {\n  if (typeof localStorage === 'undefined') return\n  localStorage.setItem(STORAGE_ORDER_KEY, JSON.stringify(order))\n}\n\nfunction getStringSizeInBytes(str: string): number {\n  return new Blob([str]).size\n}\n\nfunction updateKeyAccess(key: string): void {\n  const order = getStorageOrder()\n  const index = order.indexOf(key)\n  if (index > -1) {\n    order.splice(index, 1)\n  }\n  order.push(key) // move to end (most recent)\n  setStorageOrder(order)\n}\n\nfunction enforceStorageLimit(newKey: string, newSize: number, limitKB: number): void {\n  const tracking = getStorageTracking()\n  const order = getStorageOrder()\n\n  let totalSize = Object.values(tracking).reduce((sum, size) => sum + size, 0)\n  totalSize += newSize // add the new item size\n\n  const limitBytes = limitKB * 1024\n\n  while (totalSize > limitBytes && order.length > 0) {\n    const oldestKey = order.shift()!\n\n    if (\n      oldestKey === newKey ||\n      oldestKey === STORAGE_TRACKING_KEY ||\n      oldestKey === STORAGE_ORDER_KEY\n    ) {\n      continue\n    }\n\n    const oldSize = tracking[oldestKey] || 0\n    totalSize -= oldSize\n\n    localStorage.removeItem(oldestKey)\n    delete tracking[oldestKey]\n  }\n\n  setStorageTracking(tracking)\n  setStorageOrder(order)\n}\n"
+  ],
+  "version": 3
+}

package/types/browser/openPopup.d.ts

@@ -0,0 +1,4 @@
+// note safari enhanced privacy will break this as it reports screen height as smaller
+export declare function openCenteredPopup(url: string, title: string, width: number, height: number);
+
+//# sourceMappingURL=openPopup.d.ts.map

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

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

package/types/client-only.d.ts

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=client-only.d.ts.map

package/types/client-only.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "",
+  "names": [],
+  "sources": [
+    "src/client-only.ts"
+  ],
+  "sourcesContent": [
+    "if (process.env.VITE_ENVIRONMENT !== 'client') {\n  console.error(`This file should only be imported on the client!`)\n}\n"
+  ],
+  "version": 3
+}

package/types/constants.d.ts

@@ -0,0 +1,11 @@
+export declare const isTauri: boolean;
+export declare const isNative: boolean;
+// TODO move to probably ~/interface/constants
+export declare const IS_MAC_DESKTOP: boolean;
+export declare const IS_SAFARI: boolean;
+export { isAndroid, isClient, isIos, isServer, isWeb } from "@tamagui/constants";
+export declare const EMPTY_ARRAY: never;
+export declare const EMPTY_OBJECT: never;
+export declare const DEBUG_LEVEL: number;
+
+//# sourceMappingURL=constants.d.ts.map

package/types/constants.d.ts.map

@@ -0,0 +1,17 @@
+{
+  "mappings": "AAEA,OAAO,cAAMA;AAKb,OAAO,cAAMC;;AAIb,OAAO,cAAMC;AAGb,OAAO,cAAMC;AAMb,SAAS,WAAW,UAAU,OAAO,UAAU,aAAa;AAE5D,OAAO,cAAM;AACb,OAAO,cAAM;AAQb,OAAO,cAAMC",
+  "names": [
+    "isTauri: boolean",
+    "isNative: boolean",
+    "IS_MAC_DESKTOP: boolean",
+    "IS_SAFARI: boolean",
+    "DEBUG_LEVEL: number"
+  ],
+  "sources": [
+    "src/constants.ts"
+  ],
+  "sourcesContent": [
+    "import { isWeb } from '@tamagui/constants'\n\nexport const isTauri: boolean =\n  typeof window !== 'undefined' &&\n  // @ts-expect-error\n  window['__TAURI__'] !== undefined\n\nexport const isNative: boolean = !isWeb && !isTauri\n\n// TODO move to probably ~/interface/constants\n\nexport const IS_MAC_DESKTOP: boolean =\n  typeof navigator !== 'undefined' && /Macintosh|MacIntel/.test(navigator.platform)\n\nexport const IS_SAFARI: boolean =\n  isTauri ||\n  (typeof navigator !== 'undefined' &&\n    /Version\\/[\\d.]+.*Safari/.test(navigator.userAgent) &&\n    /Apple Computer/.test(navigator.vendor))\n\nexport { isAndroid, isClient, isIos, isServer, isWeb } from '@tamagui/constants'\n\nexport const EMPTY_ARRAY = [] as never\nexport const EMPTY_OBJECT = {} as never\n\nconst getDebugLevelFromUrl = (): number | null => {\n  if (typeof window === 'undefined') return null\n  const match = window.location?.search?.match(/debug=(\\d+)/)\n  return match?.[1] ? parseInt(match[1], 10) : null\n}\n\nexport const DEBUG_LEVEL: number = process.env.DEBUG_LEVEL\n  ? +process.env.DEBUG_LEVEL\n  : (getDebugLevelFromUrl() ?? (process.env.NODE_ENV === 'development' ? 1 : 0))\n"
+  ],
+  "version": 3
+}

package/types/debug/debugLog.d.ts

@@ -0,0 +1,11 @@
+/**
+* Debug utility that logs a value and passes it through unchanged.
+* Useful for debugging chains of operations without breaking the flow.
+*
+* @param value - The value to log and pass through
+* @param label - Optional label to prefix the log output
+* @returns The original value unchanged
+*/
+export declare function debugLog<T>(value: T, label?: string): T;
+
+//# sourceMappingURL=debugLog.d.ts.map

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

@@ -0,0 +1,14 @@
+{
+  "mappings": ";;;;;;;;AAQA,OAAO,iBAAS,SAAS,GAAGA,OAAO,GAAGC,iBAAiB",
+  "names": [
+    "value: T",
+    "label?: string"
+  ],
+  "sources": [
+    "src/debug/debugLog.ts"
+  ],
+  "sourcesContent": [
+    "/**\n * Debug utility that logs a value and passes it through unchanged.\n * Useful for debugging chains of operations without breaking the flow.\n *\n * @param value - The value to log and pass through\n * @param label - Optional label to prefix the log output\n * @returns The original value unchanged\n */\nexport function debugLog<T>(value: T, label?: string): T {\n  const output = label ? `[${label}]` : '[DEBUG]'\n  console.info(output, value)\n  return value\n}\n"
+  ],
+  "version": 3
+}

package/types/debug/debugUseState.d.ts

@@ -0,0 +1,3 @@
+export declare function debugUseState<T>(useState: [T, React.Dispatch<React.SetStateAction<T>>]): [T, React.Dispatch<React.SetStateAction<T>>];
+
+//# sourceMappingURL=debugUseState.d.ts.map

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

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAEA,OAAO,iBAAS,cAAc,GAC5BA,WAAW,GAAG,MAAM,SAAS,MAAM,eAAe,QAChD,GAAG,MAAM,SAAS,MAAM,eAAe",
+  "names": [
+    "useState: [T, React.Dispatch<React.SetStateAction<T>>]"
+  ],
+  "sources": [
+    "src/debug/debugUseState.ts"
+  ],
+  "sourcesContent": [
+    "import { useCallback } from 'react'\n\nexport function debugUseState<T>(\n  useState: [T, React.Dispatch<React.SetStateAction<T>>]\n): [T, React.Dispatch<React.SetStateAction<T>>] {\n  const [state, setState] = useState\n\n  const wrappedSetState = useCallback(\n    (newValue: T | ((prevState: T) => T)) => {\n      if (typeof newValue === 'function') {\n        // Handle callback style\n        setState((prevState: T) => {\n          const nextState = (newValue as (prevState: T) => T)(prevState)\n          console.trace('State update (callback):', {\n            prevState,\n            nextState,\n            stack: new Error().stack,\n          })\n          return nextState\n        })\n      } else {\n        // Handle direct value style\n        console.trace('State update (direct):', {\n          prevState: state,\n          nextState: newValue,\n          stack: new Error().stack,\n        })\n        setState(newValue)\n      }\n    },\n    [setState, state]\n  )\n\n  return [state, wrappedSetState]\n}\n"
+  ],
+  "version": 3
+}

package/types/emitter.d.ts

@@ -0,0 +1,78 @@
+import type { JSX, PropsWithChildren } from "react";
+type EmitterOptions<T> = CreateEmitterOpts<T> & {
+	name: string;
+};
+type CreateEmitterOpts<T> = {
+	silent?: boolean;
+	comparator?: (a: T, b: T) => boolean;
+};
+export declare class Emitter<const T> {
+	private disposables;
+	value: T;
+	options?: EmitterOptions<T>;
+	constructor(value: T, options?: EmitterOptions<T>);
+	listen: (disposable: (cb: T) => void) => (() => void);
+	emit: (next: T) => void;
+	nextValue: () => Promise<T>;
+}
+// just createEmitter but ensures it doesn't mess up on HMR
+export declare function createGlobalEmitter<T>(name: string, defaultValue: T, options?: CreateEmitterOpts<T>): Emitter<T>;
+export declare function createEmitter<T>(name: string, defaultValue: T, options?: CreateEmitterOpts<T>): Emitter<T>;
+export type EmitterType<E extends Emitter<any>> = E extends Emitter<infer Val> ? Val : never;
+export declare const useEmitter: <E extends Emitter<any>>(emitter: E, cb: (cb: EmitterType<E>) => void, args?: any[]) => void;
+export declare const useEmitterValue: <E extends Emitter<any>>(emitter: E, options?: {
+	disable?: boolean;
+}) => EmitterType<E>;
+/**
+* By default selectors run every render, as well as when emitters update. This is a change
+* from the previous behavior where they only ran when emitters changed value.
+*
+* The reason for this is because emitters capture the variables in scope of the component
+* each render already by using "useGet" by default, which makes them easier to use - you
+* don't need to pass an args[] array except for edge cases.
+*
+* Before explaining why we switched to the default, understand the different uses:
+*
+* - Default behavior - selector is updated every render, and ran every render, as well as
+*   when emitter value changes, so you basically are always up to date.
+*
+* - Set an args[] array as the fourth argument - this will stop the automatic capturing
+*   and instead update selector only when you change args[] yourself. This is good for when you
+*   want explicit control over re-selection and rendering.
+*
+* - With { lazy: true }, the selector only runs when the emitter value changes. If used with
+*   args[], you capture the context of the selector based on args[], if not, it's based on the
+*   current render.
+*
+* I made this change when we had 16 usages of useEmitterSelector and 100% of them are doing very
+* cheap calculations, so this feels like the right pattern. For the rare case of a heavy selector,
+* you have the option to control it.
+*
+*/
+export declare const useEmitterSelector: <
+	E extends Emitter<any>,
+	T extends EmitterType<E>,
+	R
+>(emitter: E, selector: (value: T) => R, options?: {
+	disable?: boolean;
+	lazy?: boolean;
+}, args?: any[]) => R;
+export declare const useEmittersSelector: <
+	const E extends readonly Emitter<any>[],
+	R
+>(emitters: E, selector: (values: { [K in keyof E] : EmitterType<E[K]> }) => R, options?: {
+	disable?: boolean;
+	isEqual?: (a: R, b: R) => boolean;
+}) => R;
+export declare const createUseEmitter: <E extends Emitter<any>>(emitter: E) => ((cb: (val: EmitterType<E>) => void, args?: any[]) => void);
+export declare const createUseSelector: <E extends Emitter<any>>(emitter: E) => (<R>(selector: (value: EmitterType<E>) => R, options?: {
+	disable?: boolean;
+	lazy?: boolean;
+}, args?: any[]) => R);
+export declare function createContextualEmitter<T>(name: string, defaultValue: T, defaultOptions?: Omit<EmitterOptions<T>, "name">): readonly [() => Emitter<T>, (props: PropsWithChildren<{
+	value?: T;
+	silent?: boolean;
+}>) => JSX.Element];
+export {};
+
+//# sourceMappingURL=emitter.d.ts.map

package/types/emitter.d.ts.map

@@ -0,0 +1,43 @@
+{
+  "mappings": "AACA,cAAc,KAAK,yBAAyB,OAAO;KA+B9C,eAAe,KAAK,kBAAkB,KAAK;CAC9C;AACD;KAEI,kBAAkB,KAAK;CAC1B;CACA,cAAcA,GAAG,GAAGC,GAAG;AACxB;AAED,OAAO,cAAM,cAAc,GAAG;CAC5B,QAAQ;CACR,OAAO;CACP,UAAU,eAAe;CAEzB,YAAYC,OAAO,GAAGC,UAAU,eAAe;CAK/C,SAAUC,aAAaC,IAAI;CAO3B,OAAQC,MAAM;CAqCd,iBAAgB,QAAQ;AAQzB;;AAGD,OAAO,iBAAS,oBAAoB,GAClCC,cACAC,cAAc,GACdC,UAAU,kBAAkB,KAC3B,QAAQ;AAIX,OAAO,iBAAS,cAAc,GAC5BF,cACAC,cAAc,GACdC,UAAU,kBAAkB,KAC3B,QAAQ;AAKX,YAAY,YAAY,UAAU,gBAAgB,UAAU,cAAc,OACtE;AAGJ,OAAO,cAAM,aAAc,UAAU,cACnCC,SAAS,GACTC,KAAKC,IAAI,YAAY,aACrBC;AAeF,OAAO,cAAM,kBAAmB,UAAU,cACxCH,SAAS,GACTI,UAAU;CAAE;AAAmB,MAC9B,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCf,OAAO,cAAM;CAAsB,UAAU;CAAc,UAAU,YAAY;CAAI;EACnFJ,SAAS,GACTK,WAAWb,OAAO,MAAM,GACxBc,UAAU;CACR;CACA;AACD,GACDC,iBACC;AAgCH,OAAO,cAAM;OAA6B,mBAAmB;CAAgB;EAC3EC,UAAU,GACVC,WAAWC,WAAW,WAAW,KAAI,YAAY,EAAE,UAAU,GAC7DC,UAAU;CAAE;CAAmB,WAAWC,GAAG,GAAGC,GAAG;AAAe,MACjE;AAgDH,OAAO,cAAM,mBAAoB,UAAU,cACzCb,SAAS,QACNc,KAAKC,KAAK,YAAY,aAAaZ;AAKxC,OAAO,cAAM,oBAAqB,UAAU,cAC1CH,SAAS,QACN,GACHgB,WAAWC,OAAO,YAAY,OAAO,GACrCC,UAAU;CAAE;CAAmB;AAAgB,GAC/Cf,iBACG;AAUL,OAAO,iBAAS,wBAAwB,GACtCN,cACAC,cAAc,GACdqB,iBAAiB,KAAK,eAAe,IAAI,0BAEnC,QAAQ,KACbC,OAAO,kBAAkB;CAAE,QAAQ;CAAG;AAAkB,OAAM,IAAI",
+  "names": [
+    "a: T",
+    "b: T",
+    "value: T",
+    "options?: EmitterOptions<T>",
+    "disposable: (cb: T) => void",
+    "cb: T",
+    "next: T",
+    "name: string",
+    "defaultValue: T",
+    "options?: CreateEmitterOpts<T>",
+    "emitter: E",
+    "cb: (cb: EmitterType<E>) => void",
+    "cb: EmitterType<E>",
+    "args?: any[]",
+    "options?: { disable?: boolean }",
+    "selector: (value: T) => R",
+    "options?: {\n    disable?: boolean\n    lazy?: boolean\n  }",
+    "args: any[]",
+    "emitters: E",
+    "selector: (values: { [K in keyof E]: EmitterType<E[K]> }) => R",
+    "values: { [K in keyof E]: EmitterType<E[K]> }",
+    "options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean }",
+    "a: R",
+    "b: R",
+    "cb: (val: EmitterType<E>) => void",
+    "val: EmitterType<E>",
+    "selector: (value: EmitterType<E>) => R",
+    "value: EmitterType<E>",
+    "options?: { disable?: boolean; lazy?: boolean }",
+    "defaultOptions?: Omit<EmitterOptions<T>, 'name'>",
+    "props: PropsWithChildren<{ value?: T; silent?: boolean }>"
+  ],
+  "sources": [
+    "src/emitter.tsx"
+  ],
+  "sourcesContent": [
+    "import { dequal } from 'dequal'\nimport type { JSX, PropsWithChildren } from 'react'\nimport * as React from 'react'\nimport { use, useLayoutEffect, useState } from 'react'\nimport { handleAbortError } from './async/abortable'\nimport { DEBUG_LEVEL, EMPTY_ARRAY } from './constants'\nimport { AbortError } from './error/errors'\nimport { createGlobalContext } from './react/createGlobalContext'\nimport { globalValue } from './global/globalValue'\n\n// keeps a reference to the current value easily\n\n// TODO can replace with useEffectEvent\nfunction useGet<A>(\n  currentValue: A,\n  initialValue?: any,\n  forwardToFunction?: boolean\n): () => A {\n  const curRef = React.useRef<any>(initialValue ?? currentValue)\n\n  useLayoutEffect(() => {\n    curRef.current = currentValue\n  })\n\n  return React.useCallback(\n    forwardToFunction\n      ? (...args) => curRef.current?.apply(null, args)\n      : () => curRef.current,\n    []\n  )\n}\n\ntype EmitterOptions<T> = CreateEmitterOpts<T> & {\n  name: string\n}\n\ntype CreateEmitterOpts<T> = {\n  silent?: boolean\n  comparator?: (a: T, b: T) => boolean\n}\n\nexport class Emitter<const T> {\n  private disposables = new Set<(cb: any) => void>()\n  value: T\n  options?: EmitterOptions<T>\n\n  constructor(value: T, options?: EmitterOptions<T>) {\n    this.value = value\n    this.options = options\n  }\n\n  listen = (disposable: (cb: T) => void): (() => void) => {\n    this.disposables.add(disposable)\n    return (): void => {\n      this.disposables.delete(disposable)\n    }\n  }\n\n  emit = (next: T): void => {\n    if (process.env.NODE_ENV === 'development') {\n      setCache(this, next)\n    }\n    const compare = this.options?.comparator\n    if (compare) {\n      if (this.value && compare(this.value, next)) {\n        return\n      }\n    } else {\n      if (this.value === next) {\n        if (process.env.NODE_ENV === 'development') {\n          console.warn(\n            `[emitter] ${this.options?.name} no comparator option but received same value!\n            \nthis will emit the same value again, which can be desirable, but we warn to ensure it's not unintended:\n\n- if you want this behavior, add { comparator: isEqualNever }\n- if you want only non-equal values: { comparator: isEqualIdentity }\n- if you want only deeply non-equal values: { comparator: isEqualDeep }`\n          )\n        }\n      }\n    }\n    this.value = next\n    if (DEBUG_LEVEL > 1) {\n      if (!this.options?.silent) {\n        const name = this.options?.name\n        console.groupCollapsed(`📣 ${name}`)\n        console.info(next)\n        console.trace(`trace >`)\n        console.groupEnd()\n      }\n    }\n    this.disposables.forEach((cb) => cb(next))\n  }\n\n  nextValue = (): Promise<T> => {\n    return new Promise<T>((res) => {\n      const dispose = this.listen((val) => {\n        dispose()\n        res(val)\n      })\n    })\n  }\n}\n\n// just createEmitter but ensures it doesn't mess up on HMR\nexport function createGlobalEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>\n): Emitter<T> {\n  return globalValue(name, () => createEmitter(name, defaultValue, options))\n}\n\nexport function createEmitter<T>(\n  name: string,\n  defaultValue: T,\n  options?: CreateEmitterOpts<T>\n): Emitter<T> {\n  const existing = createOrUpdateCache(name, defaultValue) as T\n  return new Emitter<T>(existing || defaultValue, { name, ...options })\n}\n\nexport type EmitterType<E extends Emitter<any>> = E extends Emitter<infer Val>\n  ? Val\n  : never\n\nexport const useEmitter = <E extends Emitter<any>>(\n  emitter: E,\n  cb: (cb: EmitterType<E>) => void,\n  args?: any[]\n): void => {\n  const getCallback = useGet(cb)\n\n  useLayoutEffect(() => {\n    return emitter.listen((val) => {\n      try {\n        getCallback()(val)\n      } catch (err) {\n        handleAbortError(err)\n      }\n    })\n  }, [emitter, getCallback])\n}\n\nexport const useEmitterValue = <E extends Emitter<any>>(\n  emitter: E,\n  options?: { disable?: boolean }\n): EmitterType<E> => {\n  const [state, setState] = useState<EmitterType<E>>(emitter.value)\n  const disabled = options?.disable\n\n  useLayoutEffect(() => {\n    if (disabled) return\n    if (emitter.value !== state) {\n      setState(emitter.value)\n    }\n    return emitter.listen(setState)\n  }, [disabled, emitter, state])\n\n  return state\n}\n\n/**\n * By default selectors run every render, as well as when emitters update. This is a change\n * from the previous behavior where they only ran when emitters changed value.\n *\n * The reason for this is because emitters capture the variables in scope of the component\n * each render already by using \"useGet\" by default, which makes them easier to use - you\n * don't need to pass an args[] array except for edge cases.\n *\n * Before explaining why we switched to the default, understand the different uses:\n *\n * - Default behavior - selector is updated every render, and ran every render, as well as\n *   when emitter value changes, so you basically are always up to date.\n *\n * - Set an args[] array as the fourth argument - this will stop the automatic capturing\n *   and instead update selector only when you change args[] yourself. This is good for when you\n *   want explicit control over re-selection and rendering.\n *\n * - With { lazy: true }, the selector only runs when the emitter value changes. If used with\n *   args[], you capture the context of the selector based on args[], if not, it's based on the\n *   current render.\n *\n * I made this change when we had 16 usages of useEmitterSelector and 100% of them are doing very\n * cheap calculations, so this feels like the right pattern. For the rare case of a heavy selector,\n * you have the option to control it.\n *\n */\nexport const useEmitterSelector = <E extends Emitter<any>, T extends EmitterType<E>, R>(\n  emitter: E,\n  selector: (value: T) => R,\n  options?: {\n    disable?: boolean\n    lazy?: boolean\n  },\n  args: any[] = EMPTY_ARRAY\n): R => {\n  const [state, setState] = useState<R>(() => selector(emitter.value))\n  const disabled = options?.disable\n  const getSelector = useGet(selector)\n\n  if (options?.lazy !== true) {\n    const next = selector(emitter.value)\n    if (next !== state) {\n      setState(next)\n    }\n  }\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: we are using args fine\n  useLayoutEffect(() => {\n    if (disabled) return\n    return emitter.listen((val) => {\n      try {\n        const selectorFn = args !== EMPTY_ARRAY ? selector : getSelector()\n        const next = selectorFn(val)\n        setState(next)\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    })\n  }, [disabled, emitter, getSelector, ...args])\n\n  return state\n}\n\nexport const useEmittersSelector = <const E extends readonly Emitter<any>[], R>(\n  emitters: E,\n  selector: (values: { [K in keyof E]: EmitterType<E[K]> }) => R,\n  options?: { disable?: boolean; isEqual?: (a: R, b: R) => boolean }\n): R => {\n  const getSelector = useGet(selector)\n  const disabled = options?.disable\n\n  const [state, setState] = useState<R>(() => {\n    const values = emitters.map((e) => e.value) as { [K in keyof E]: EmitterType<E[K]> }\n    return getSelector()(values)\n  })\n\n  // biome-ignore lint/correctness/useExhaustiveDependencies: ignore\n  useLayoutEffect(() => {\n    if (disabled) {\n      return\n    }\n\n    const handler = () => {\n      const values = emitters.map((e) => e.value) as {\n        [K in keyof E]: EmitterType<E[K]>\n      }\n      try {\n        const next = getSelector()(values)\n        setState((prev) => {\n          if (options?.isEqual?.(prev, next)) {\n            return prev\n          }\n          if (dequal(prev, next)) {\n            return prev\n          }\n          return next\n        })\n      } catch (error) {\n        if (error instanceof AbortError) {\n          return\n        }\n        throw error\n      }\n    }\n\n    const disposals = emitters.map((emitter) => emitter.listen(handler))\n\n    return () => {\n      disposals.forEach((d) => d())\n    }\n  }, [disabled, getSelector, ...emitters])\n\n  return state\n}\n\nexport const createUseEmitter = <E extends Emitter<any>>(\n  emitter: E\n): ((cb: (val: EmitterType<E>) => void, args?: any[]) => void) => {\n  return (cb: (val: EmitterType<E>) => void, args?: any[]) =>\n    useEmitter(emitter, cb, args)\n}\n\nexport const createUseSelector = <E extends Emitter<any>>(\n  emitter: E\n): (<R>(\n  selector: (value: EmitterType<E>) => R,\n  options?: { disable?: boolean; lazy?: boolean },\n  args?: any[]\n) => R) => {\n  return <R,>(\n    selector: (value: EmitterType<E>) => R,\n    options?: { disable?: boolean; lazy?: boolean },\n    args?: any[]\n  ): R => {\n    return useEmitterSelector(emitter, selector, options, args)\n  }\n}\n\nexport function createContextualEmitter<T>(\n  name: string,\n  defaultValue: T,\n  defaultOptions?: Omit<EmitterOptions<T>, 'name'>\n): readonly [\n  () => Emitter<T>,\n  (props: PropsWithChildren<{ value?: T; silent?: boolean }>) => JSX.Element,\n] {\n  const id = Math.random().toString(36)\n  const EmitterContext = createGlobalContext<Emitter<T> | null>(\n    `contextual-emitter/${id}`,\n    null\n  )\n\n  const useContextEmitter = () => {\n    const emitter = use(EmitterContext)\n    if (!emitter) {\n      throw new Error('useContextEmitter must be used within an EmitterProvider')\n    }\n    return emitter\n  }\n\n  type ProvideEmitterProps = PropsWithChildren<{\n    value?: T\n    silent?: boolean\n  }>\n\n  const ProvideEmitter = (props: ProvideEmitterProps) => {\n    const { children, value, silent } = props\n    const [emitter] = useState(\n      () => new Emitter<T>(value ?? defaultValue, { name, silent, ...defaultOptions })\n    )\n\n    useLayoutEffect(() => {\n      if (value !== undefined && value !== emitter.value) {\n        emitter.emit(value)\n      }\n    }, [value, emitter])\n\n    return <EmitterContext.Provider value={emitter}>{children}</EmitterContext.Provider>\n  }\n\n  return [useContextEmitter, ProvideEmitter] as const\n}\n\nconst HMRCache =\n  process.env.NODE_ENV === 'development'\n    ? new Map<string, { originalDefaultValue: unknown; currentValue: unknown }>()\n    : null\n\nfunction setCache(emitter: Emitter<any>, value: unknown) {\n  const name = emitter.options?.name\n  if (!name) return\n  const cache = HMRCache?.get(name)\n  if (!cache) return\n  cache.currentValue = value\n}\n\nfunction createOrUpdateCache(name: string, defaultValueProp: unknown) {\n  const existing = HMRCache?.get(name)\n  const defaultValue = dequal(existing?.originalDefaultValue, defaultValueProp)\n    ? existing?.currentValue\n    : defaultValueProp\n\n  if (!existing) {\n    HMRCache?.set(name, {\n      originalDefaultValue: defaultValueProp,\n      currentValue: defaultValue,\n    })\n  }\n\n  return defaultValue\n}\n"
+  ],
+  "version": 3
+}

package/types/ensure/catchEnsureErrors.d.ts

@@ -0,0 +1,3 @@
+export declare function catchEnsureErrors<T extends Function>(fn: T): T;
+
+//# sourceMappingURL=catchEnsureErrors.d.ts.map

package/types/ensure/catchEnsureErrors.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAEA,OAAO,iBAAS,kBAAkB,UAAU,UAAUA,IAAI,IAAI",
+  "names": [
+    "fn: T"
+  ],
+  "sources": [
+    "src/ensure/catchEnsureErrors.ts"
+  ],
+  "sourcesContent": [
+    "import { EnsureError } from '../error/errors'\n\nexport function catchEnsureErrors<T extends Function>(fn: T): T {\n  return ((...args: any[]) => {\n    try {\n      return fn(...args)\n    } catch (error) {\n      if (error instanceof EnsureError) {\n        console.error(`EnsureError: ${error.message}`)\n        return\n      }\n      throw error\n    }\n  }) as unknown as T\n}\n"
+  ],
+  "version": 3
+}

package/types/ensure/ensure.d.ts

@@ -0,0 +1,6 @@
+export declare function ensureExists<T>(value: T | undefined | null, msg?: string): asserts value is T;
+export declare function ensure<T>(value: T, msg?: string): asserts value is Exclude<T, null | undefined | false>;
+export declare function ensureError(val: unknown): asserts val is Error;
+export declare function ensureString(val: unknown, name?: string): asserts val is string;
+
+//# sourceMappingURL=ensure.d.ts.map

package/types/ensure/ensure.d.ts.map

@@ -0,0 +1,15 @@
+{
+  "mappings": "AAEA,OAAO,iBAAS,aAAa,GAC3BA,OAAO,sBACP,uBACS,SAAS;AAMpB,OAAO,iBAAS,OAAO,GACrBC,OAAO,GACP,uBACS,SAAS,QAAQ,sBAAsB;AAMlD,OAAO,iBAAS,YAAYC,uBAAuB,OAAO;AAM1D,OAAO,iBAAS,aAAaA,cAAc,wBAA6B",
+  "names": [
+    "value: T | undefined | null",
+    "value: T",
+    "val: unknown"
+  ],
+  "sources": [
+    "src/ensure/ensure.ts"
+  ],
+  "sourcesContent": [
+    "import { EnsureError } from '../error/errors'\n\nexport function ensureExists<T>(\n  value: T | undefined | null,\n  msg = ''\n): asserts value is T {\n  if (value === undefined || value === null) {\n    throw new EnsureError(`Invalid nullish value (${value}): ${msg}`)\n  }\n}\n\nexport function ensure<T>(\n  value: T,\n  msg = ''\n): asserts value is Exclude<T, null | undefined | false> {\n  if (!value) {\n    throw new EnsureError(`ensure() invalid: (${value}): ${msg} ${new Error().stack}`)\n  }\n}\n\nexport function ensureError(val: unknown): asserts val is Error {\n  if (!(val instanceof Error)) {\n    throw val\n  }\n}\n\nexport function ensureString(val: unknown, name = '(unnamed)'): asserts val is string {\n  if (typeof val !== 'string') {\n    throw new EnsureError(`No string ${name}`)\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/ensure/ensureOne.d.ts

@@ -0,0 +1,3 @@
+export declare function ensureOne<T>(key: string, factory: (signal: AbortSignal) => T): T;
+
+//# sourceMappingURL=ensureOne.d.ts.map

package/types/ensure/ensureOne.d.ts.map

@@ -0,0 +1,15 @@
+{
+  "mappings": "AAIA,OAAO,iBAAS,UAAU,GAAGA,aAAaC,UAAUC,QAAQ,gBAAgB,IAAI",
+  "names": [
+    "key: string",
+    "factory: (signal: AbortSignal) => T",
+    "signal: AbortSignal"
+  ],
+  "sources": [
+    "src/ensure/ensureOne.ts"
+  ],
+  "sourcesContent": [
+    "// Ensures only one instance ever exists, but replaces it every time it's called\n\nconst Controllers = new WeakMap<symbol, AbortController>()\n\nexport function ensureOne<T>(key: string, factory: (signal: AbortSignal) => T): T {\n  const symbolKey = Symbol.for(key)\n  const g = globalThis as Record<symbol, unknown>\n\n  if (g[symbolKey]) {\n    Controllers.get(symbolKey)?.abort()\n  }\n\n  const controller = new AbortController()\n  g[symbolKey] = factory(controller.signal)\n\n  return g[symbolKey] as T\n}\n"
+  ],
+  "version": 3
+}

package/types/ensure/ensureSingleton.d.ts

@@ -0,0 +1,7 @@
+// Ensures a singleton value is stored on `globalThis` using a symbol key.
+// This creates a stable singleton that survives hot-reloads during development.
+// We store values on globalThis using `Symbol.for` keys to avoid collisions
+// across independently bundled modules.
+export declare function ensureSingleton<T>(key: string, factory: () => T): T;
+
+//# sourceMappingURL=ensureSingleton.d.ts.map

package/types/ensure/ensureSingleton.d.ts.map

@@ -0,0 +1,14 @@
+{
+  "mappings": ";;;;AAMA,OAAO,iBAAS,gBAAgB,GAAGA,aAAaC,eAAe,IAAI",
+  "names": [
+    "key: string",
+    "factory: () => T"
+  ],
+  "sources": [
+    "src/ensure/ensureSingleton.ts"
+  ],
+  "sourcesContent": [
+    "// Ensures a singleton value is stored on `globalThis` using a symbol key.\n// This creates a stable singleton that survives hot-reloads during development.\n\n// We store values on globalThis using `Symbol.for` keys to avoid collisions\n// across independently bundled modules.\n\nexport function ensureSingleton<T>(key: string, factory: () => T): T {\n  const symbolKey = Symbol.for(key)\n  const g = globalThis as Record<symbol, unknown>\n\n  if (!g[symbolKey]) {\n    g[symbolKey] = factory()\n  }\n\n  return g[symbolKey] as T\n}\n"
+  ],
+  "version": 3
+}

package/types/error/errors.d.ts

@@ -0,0 +1,8 @@
+export declare class AbortError extends Error {
+	constructor(message?: string);
+}
+export declare class EnsureError extends Error {
+	constructor(message: string);
+}
+
+//# sourceMappingURL=errors.d.ts.map

package/types/error/errors.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,OAAO,cAAM,mBAAmB,MAAM;CACpC,YAAY;AAIb;AAED,OAAO,cAAM,oBAAoB,MAAM;CACrC,YAAYA;AAIb",
+  "names": [
+    "message: string"
+  ],
+  "sources": [
+    "src/error/errors.ts"
+  ],
+  "sourcesContent": [
+    "export class AbortError extends Error {\n  constructor(message = '') {\n    super(message)\n    this.name = 'AbortError'\n  }\n}\n\nexport class EnsureError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'EnsureError'\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/files/download.d.ts

@@ -0,0 +1,4 @@
+export declare function downloadFile(data: string, filename: string, mimeType?: string);
+export declare function downloadFromUrl(url: string, filename?: string);
+
+//# sourceMappingURL=download.d.ts.map

package/types/files/download.d.ts.map

@@ -0,0 +1,16 @@
+{
+  "mappings": "AAuCA,OAAO,iBAAe,aACpBA,cACAC,kBACA;AAYF,OAAO,iBAAe,gBAAgBC,aAAaC",
+  "names": [
+    "data: string",
+    "filename: string",
+    "url: string",
+    "filename?: string"
+  ],
+  "sources": [
+    "src/files/download.ts"
+  ],
+  "sourcesContent": [
+    "import { isTauri } from '../constants'\n\nasync function saveInTauri(data: string | Blob, filename: string) {\n  // @ts-ignore - tauri plugins only available in tauri environment\n  const { save } = await import('@tauri-apps/plugin-dialog')\n  // @ts-ignore - tauri plugins only available in tauri environment\n  const { writeTextFile, writeBinaryFile } = await import('@tauri-apps/plugin-fs')\n\n  const extension = filename.split('.').pop() || ''\n  const filePath = await save({\n    defaultPath: filename,\n    filters: [\n      {\n        name: `${extension.toUpperCase()} files`,\n        extensions: [extension],\n      },\n    ],\n  })\n\n  if (filePath) {\n    if (typeof data === 'string') {\n      await writeTextFile(filePath, data)\n    } else {\n      const arrayBuffer = await data.arrayBuffer()\n      await writeBinaryFile(filePath, new Uint8Array(arrayBuffer))\n    }\n  }\n}\n\nfunction downloadInBrowser(url: string, filename: string) {\n  const a = document.createElement('a')\n  a.href = url\n  a.download = filename\n  a.target = '_blank'\n  document.body.appendChild(a)\n  a.click()\n  document.body.removeChild(a)\n}\n\nexport async function downloadFile(\n  data: string,\n  filename: string,\n  mimeType = 'application/json'\n) {\n  if (isTauri) {\n    await saveInTauri(data, filename)\n  } else {\n    const blob = new Blob([data], { type: mimeType })\n    const url = URL.createObjectURL(blob)\n    downloadInBrowser(url, filename)\n    URL.revokeObjectURL(url)\n  }\n}\n\nexport async function downloadFromUrl(url: string, filename?: string) {\n  const resolvedFilename = filename || url.split('/').pop() || 'download'\n\n  if (isTauri) {\n    try {\n      const response = await fetch(url)\n      const blob = await response.blob()\n      await saveInTauri(blob, resolvedFilename)\n    } catch (error) {\n      console.error('Failed to download file:', error)\n      downloadInBrowser(url, resolvedFilename)\n    }\n  } else {\n    downloadInBrowser(url, resolvedFilename)\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/function/emptyFn.d.ts

@@ -0,0 +1,3 @@
+export declare const emptyFn: () => void;
+
+//# sourceMappingURL=emptyFn.d.ts.map

package/types/function/emptyFn.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,OAAO,cAAM",
+  "names": [],
+  "sources": [
+    "src/function/emptyFn.ts"
+  ],
+  "sourcesContent": [
+    "export const emptyFn = (): void => {}\n"
+  ],
+  "version": 3
+}

package/types/function/identityFn.d.ts

@@ -0,0 +1,3 @@
+export declare const identityFn: <A>(item: A) => A;
+
+//# sourceMappingURL=identityFn.d.ts.map

package/types/function/identityFn.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAAA,OAAO,cAAM,aAAc,GAAGA,MAAM,MAAI",
+  "names": [
+    "item: A"
+  ],
+  "sources": [
+    "src/function/identityFn.ts"
+  ],
+  "sourcesContent": [
+    "export const identityFn = <A>(item: A): A => item\n"
+  ],
+  "version": 3
+}

package/types/function/throttle.d.ts

@@ -0,0 +1,22 @@
+export interface ThrottleOptions {
+	/**
+	* Fire immediately on the first call.
+	*/
+	start?: boolean;
+	/**
+	* Fire as soon as `wait` has passed.
+	*/
+	middle?: boolean;
+	/**
+	* Cancel after the first successful call.
+	*/
+	once?: boolean;
+}
+interface Throttler<T extends unknown[]> {
+	(...args: T): void;
+	cancel(): void;
+}
+export declare function throttle<T extends unknown[]>(callback: (...args: T) => unknown, wait?: number, { start, middle, once }?: ThrottleOptions): Throttler<T>;
+export {};
+
+//# sourceMappingURL=throttle.d.ts.map

package/types/function/throttle.d.ts.map

@@ -0,0 +1,13 @@
+{
+  "mappings": "AAIA,iBAAiB,gBAAgB;;;;CAI/B;;;;CAIA;;;;CAIA;AACD;UAES,UAAU,qBAAqB;EACtC,GAAG,MAAM;CACV;AACD;AAED,OAAO,iBAAS,SAAS,qBACvBA,WAAW,GAAG,MAAM,eACpB,eACA,EAAE,OAAc,QAAe,MAA+B,GAAf,kBAC9C,UAAU",
+  "names": [
+    "callback: (...args: T) => unknown"
+  ],
+  "sources": [
+    "src/function/throttle.ts"
+  ],
+  "sourcesContent": [
+    "// via @github/mini-throttle https://raw.githubusercontent.com/github/mini-throttle/refs/heads/main/index.ts\n\nimport type { Timer } from '../types/timer'\n\nexport interface ThrottleOptions {\n  /**\n   * Fire immediately on the first call.\n   */\n  start?: boolean\n  /**\n   * Fire as soon as `wait` has passed.\n   */\n  middle?: boolean\n  /**\n   * Cancel after the first successful call.\n   */\n  once?: boolean\n}\n\ninterface Throttler<T extends unknown[]> {\n  (...args: T): void\n  cancel(): void\n}\n\nexport function throttle<T extends unknown[]>(\n  callback: (...args: T) => unknown,\n  wait = 0,\n  { start = true, middle = true, once = false }: ThrottleOptions = {}\n): Throttler<T> {\n  let innerStart = start\n  let last = 0\n  let timer: Timer\n  let cancelled = false\n  function fn(this: unknown, ...args: T) {\n    if (cancelled) return\n    const delta = Date.now() - last\n    last = Date.now()\n\n    if (start && middle && delta >= wait) {\n      innerStart = true\n    }\n\n    if (innerStart) {\n      innerStart = false\n      callback.apply(this, args)\n      if (once) fn.cancel()\n    } else if ((middle && delta < wait) || !middle) {\n      clearTimeout(timer)\n      timer = setTimeout(\n        () => {\n          last = Date.now()\n          callback.apply(this, args)\n          if (once) fn.cancel()\n        },\n        !middle ? wait : wait - delta\n      )\n    }\n  }\n  fn.cancel = () => {\n    clearTimeout(timer)\n    cancelled = true\n  }\n  return fn\n}\n\n// we have debounce from tamagui already\n// export function debounce<T extends unknown[]>(\n//   callback: (...args: T) => unknown,\n//   wait = 0,\n//   { start = false, middle = false, once = false }: ThrottleOptions = {}\n// ): Throttler<T> {\n//   return throttle(callback, wait, { start, middle, once })\n// }\n"
+  ],
+  "version": 3
+}

package/types/global/globalContext.d.ts

@@ -0,0 +1,6 @@
+import { type Context } from "react";
+// create or retrieve a React context that is stored on `globalThis`.
+// this ensures a stable singleton that survives hot-reloads during development.
+export declare function createGlobalContext<T>(key: string, defaultValue: T): Context<T>;
+
+//# sourceMappingURL=globalContext.d.ts.map

package/types/global/globalContext.d.ts.map

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAAA,cAAc,eAA8B,OAAO;;;AAMnD,OAAO,iBAAS,oBAAoB,GAAGA,aAAaC,cAAc,IAAI,QAAQ",
+  "names": [
+    "key: string",
+    "defaultValue: T"
+  ],
+  "sources": [
+    "src/global/globalContext.ts"
+  ],
+  "sourcesContent": [
+    "import { type Context, createContext } from 'react'\nimport { ensureSingleton } from '../ensure/ensureSingleton'\n\n// create or retrieve a React context that is stored on `globalThis`.\n// this ensures a stable singleton that survives hot-reloads during development.\n\nexport function createGlobalContext<T>(key: string, defaultValue: T): Context<T> {\n  return ensureSingleton(key, () => createContext<T>(defaultValue))\n}\n"
+  ],
+  "version": 3
+}

package/types/global/globalEffect.d.ts

@@ -0,0 +1,3 @@
+export declare function globalEffect(key: string, factory: () => void | (() => void)): void;
+
+//# sourceMappingURL=globalEffect.d.ts.map

package/types/global/globalEffect.d.ts.map

@@ -0,0 +1,14 @@
+{
+  "mappings": "AAAA,OAAO,iBAAS,aAAaA,aAAaC",
+  "names": [
+    "key: string",
+    "factory: () => void | (() => void)"
+  ],
+  "sources": [
+    "src/global/globalEffect.ts"
+  ],
+  "sourcesContent": [
+    "export function globalEffect(key: string, factory: () => void | (() => void)): void {\n  const disposeKey = Symbol.for(key)\n  const g = globalThis as Record<symbol, () => void>\n\n  if (g[disposeKey]) {\n    g[disposeKey]?.()\n  }\n\n  const dispose = factory()\n\n  if (dispose) {\n    g[disposeKey] = dispose\n  }\n}\n"
+  ],
+  "version": 3
+}

package/types/global/globalValue.d.ts

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

package/types/global/globalValue.d.ts.map

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