@entwico/dash 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 entwico GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,95 @@
+# @entwico/dash
+
+Typical reusable utilities shared across projects — the canonical home for the small helpers.
+
+- **ESM-only**, `sideEffects: false`, fully tree-shakable
+- **Zero-dependency core** — heavier worlds (React, Tailwind) are isolated behind subpath exports with optional peer dependencies
+
+## Installation
+
+```sh
+pnpm add @entwico/dash
+```
+
+## Entry points
+
+| Entry                 | Contents                             | Peer dependencies              |
+| --------------------- | ------------------------------------ | ------------------------------ |
+| `@entwico/dash`       | zero-dependency utilities and types  | —                              |
+| `@entwico/dash/async` | AsyncIterable primitives and backoff | —                              |
+| `@entwico/dash/match` | performant string pattern matching   | —                              |
+| `@entwico/dash/cn`    | `cn()` class name merging            | `clsx` ≥2, `tailwind-merge` ≥2 |
+| `@entwico/dash/react` | React hooks                          | `react` ≥18                    |
+
+All peer dependencies are optional — install only what the entry points you use need.
+
+## Core (`@entwico/dash`)
+
+| Export                                           | Purpose                                                                                                        |
+| ------------------------------------------------ | -------------------------------------------------------------------------------------------------------------- |
+| `assert(expr, message?)`                         | assertion with `asserts expr` narrowing; `message` may be a string or an `Error`                               |
+| `capitalize(str)`                                | uppercase the first letter                                                                                     |
+| `createBatcher(onFlush, delayMs)`                | batch calls into one flush after a delay                                                                       |
+| `debounce(fn, wait)`                             | classic trailing debounce                                                                                      |
+| `deepFreeze(value)`                              | recursive `Object.freeze`, returns `ReadonlyDeep<T>`                                                           |
+| `defined(val)` / `truthy(val)`                   | type-guard filters for `null` / `undefined` / falsy                                                            |
+| `indexBy(array, keyFn, valueFn?)`                | index an array into a `Map`; key/value selectors are property names or functions                               |
+| `mapConcurrent(items, fn, concurrency)`          | order-preserving concurrent map with a bounded worker pool                                                     |
+| `maybeThen(value, fn)` / `maybeCatch(value, fn)` | chain transformations on `MaybePromise` values without unwrapping                                              |
+| `maybeAll(values)` / `maybeAllSettled(values)`   | `Promise.all` / `Promise.allSettled` over `MaybePromise` values, synchronous when all values are               |
+| `noop` / `markAsUsed`                            | no-op functions                                                                                                |
+| `omitUndefined(obj, recursive?)`                 | strip `undefined` properties (deep by default)                                                                 |
+| `optionalize(fn, options?)`                      | lift a function to accept `null` / `undefined`; `defaultValue` / `strategy` (`'nullish'` \| `'falsy'`) options |
+| `retry(fn, options?)`                            | retry with a fixed delay; `retries` / `delayMs` / `signal` / `onError` options                                 |
+| `sleep(ms, signal?)`                             | promise-based delay, abortable via `AbortSignal`                                                               |
+
+Types: `MaybePromise<T>`, `ReadonlyDeep<T>`.
+
+## Async (`@entwico/dash/async`)
+
+Zero-dependency streaming and retry primitives — the rxjs patterns without rxjs:
+
+| Export                                                     | Purpose                                                                                                             |
+| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------- |
+| `createAsyncIterableSubject()` / `AsyncIterableSubject<T>` | multicast source with `next` / `error` / `complete`, consumable via `for await` or `subscribe(observerOrNext)`      |
+| `firstAsync(iter)`                                         | first yielded value, then disposes the iterator; throws if the iterable completes empty (≈ `firstValueFrom`)        |
+| `mapAsync(iter, fn)` / `filterAsync(iter, predicate)`      | lazy operators over an `AsyncIterable`                                                                              |
+| `concatAsync(iter)`                                        | concatenate all yielded arrays into one (plain collection: `Array.fromAsync`)                                       |
+| `exponentialBackoff(attempt, options?)`                    | jittered exponential delay, abortable; bounds configurable via `maxDelayMs` / `jitterMinMs` / `jitterMaxMs`         |
+| `retryWithBackoff(fn, options?)`                           | retry `fn` with exponential backoff indefinitely until it resolves, abortable via `signal`                          |
+| `keepalive(factory, options?)`                             | keep a long-running `AsyncIterable` alive: re-subscribe with backoff on error or completion, stop on `signal` abort |
+
+## Match (`@entwico/dash/match`)
+
+A pattern union that keeps cheap checks cheap — `startsWith` beats a regex when a prefix is all you need:
+
+```ts
+import { type StringPattern, createMatcher } from "@entwico/dash/match";
+
+const isExcluded = createMatcher([{ exact: "/favicon.ico" }, { prefix: "/_astro/" }, { suffix: ".map" }, { includes: "/internal/" }, { pattern: /^\/api\/v\d+\// }, (path) => path.length > 2000]);
+
+isExcluded("/_astro/chunk.js"); // true
+```
+
+`createMatcher` buckets patterns by check cost at creation time: all `exact` patterns collapse into a single `Set` lookup, then prefixes / suffixes / substrings, then regexps and functions. For one-shot checks there are `matches(value, pattern)` and `matchesAny(value, patterns)`.
+
+## cn (`@entwico/dash/cn`)
+
+```ts
+import { type Classable, cn } from "@entwico/dash/cn";
+
+cn("p-2", condition && "p-4"); // tailwind conflicts resolved in favor of the last class
+```
+
+`Classable` is the `{ className?: string }` contract for component props designed to be merged via `cn()`.
+
+## React (`@entwico/dash/react`)
+
+- `useDebouncedValue(value, delay)` — the value, updated only after it has stayed unchanged for the given delay
+- `useEffectAfterMount(effect, deps?)` — run the effect on updates, skip the initial mount
+- `useEffectOnce(effect)` — run the effect exactly once on mount
+- `useIsMobile()` — whether the viewport is below the mobile breakpoint (768px); `false` during SSR
+
+## License
+
+MIT

package/dist/async.d.ts

@@ -0,0 +1,87 @@
+//#region src/async/async-iterable-subject.d.ts
+/**
+ * Multicast event source with `next` / `error` / `complete` (Subject semantics) plus an
+ * `AsyncIterable` view. Two consumption modes that fan out from the same source:
+ *
+ * - `for await (const v of subject)` — iteration. Each `[Symbol.asyncIterator]()` call returns
+ *   a fresh per-iterator queue. Stop by `break`ing the loop. On `.error(err)` the iterator's
+ *   pending `next()` rejects, propagating into the for-await as a thrown exception.
+ *
+ * - `subject.subscribe(observerOrNext)` — observer style. Pass either a full/partial observer
+ *   `{ next?, error?, complete? }` or just an `(value) => …` function as the `next`-only shortcut.
+ *   Returns an unsubscribe function. Missing handlers default to no-ops.
+ *
+ * Producer side: call `.next(value)` to emit, `.error(err)` to fail the subject (all consumers
+ * see the error and are detached), `.complete()` to close cleanly (all consumers see done and
+ * are detached). After either `error` or `complete`, further `.next()` calls are dropped and
+ * new `.subscribe(...)` calls register a no-op unsubscribe.
+ *
+ * Backpressure: unbounded queue per pending iterator. Intended for low-frequency events.
+ */
+type AsyncIterableSubject<T> = AsyncIterable<T> & {
+  next: (value: T) => void;
+  error: (err: unknown) => void;
+  complete: () => void;
+  subscribe: (observerOrNext: ((value: T) => void) | {
+    next?: (value: T) => void;
+    error?: (err: unknown) => void;
+    complete?: () => void;
+  }) => () => void;
+};
+declare function createAsyncIterableSubject<T>(): AsyncIterableSubject<T>;
+//#endregion
+//#region src/async/backoff.d.ts
+type BackoffOptions = {
+  /** upper bound for the exponential delay, before jitter (default 30_000) */
+  maxDelayMs?: number | undefined;
+  /** lower bound of the random jitter added to every delay (default 300) */
+  jitterMinMs?: number | undefined;
+  /** upper bound of the random jitter added to every delay (default 3000) */
+  jitterMaxMs?: number | undefined;
+  /** aborts the backoff wait (and, where applicable, the retry loop) */
+  signal?: AbortSignal | undefined;
+};
+/**
+ * Exponential backoff with jitter. `attempt` starts at 0 → ~1s+jitter, 1 → ~2s+jitter, etc.,
+ * capped at `maxDelayMs`. Returns a Promise that resolves after the delay.
+ */
+declare function exponentialBackoff(attempt: number, options?: BackoffOptions | undefined): Promise<void>;
+/**
+ * Runs `fn` with exponential-backoff retry on rejection, indefinitely, resolving with the first
+ * successful result. `options.signal` aborts both the in-flight `fn` (if it observes the signal)
+ * and the backoff wait.
+ */
+declare function retryWithBackoff<T>(fn: () => Promise<T>, options?: BackoffOptions | undefined): Promise<T>;
+//#endregion
+//#region src/async/concat-async.d.ts
+/**
+ * Concatenates all elements of all arrays yielded by `iter` into a single array. Used to support
+ * subscriptions that emit chunks of items before completing.
+ */
+declare function concatAsync<T>(iter: AsyncIterable<T[]>): Promise<T[]>;
+//#endregion
+//#region src/async/filter-async.d.ts
+/** Lazy filter over an async iterable. */
+declare function filterAsync<T>(iter: AsyncIterable<T>, predicate: (value: T) => boolean): AsyncIterable<T>;
+//#endregion
+//#region src/async/first-async.d.ts
+/**
+ * Returns the first value yielded by `iter`, then disposes the iterator. Throws if the iterable
+ * completes without yielding. Equivalent of rxjs's `firstValueFrom` for AsyncIterables.
+ */
+declare function firstAsync<T>(iter: AsyncIterable<T>): Promise<T>;
+//#endregion
+//#region src/async/keepalive.d.ts
+/**
+ * Long-running stream wrapper: subscribes via `factory()`, yields every value, and on error or
+ * unexpected completion re-subscribes with exponential backoff. Stops only when `options.signal`
+ * aborts. Designed for subscriptions that should stay open across reconnects.
+ */
+declare function keepalive<T>(factory: () => AsyncIterable<T>, options?: BackoffOptions | undefined): AsyncIterable<T>;
+//#endregion
+//#region src/async/map-async.d.ts
+/** Lazy map over an async iterable. Cleanup propagates: breaking the outer iter disposes the inner. */
+declare function mapAsync<T, R>(iter: AsyncIterable<T>, fn: (value: T) => R): AsyncIterable<R>;
+//#endregion
+export { AsyncIterableSubject, BackoffOptions, concatAsync, createAsyncIterableSubject, exponentialBackoff, filterAsync, firstAsync, keepalive, mapAsync, retryWithBackoff };
+//# sourceMappingURL=async.d.ts.map

package/dist/async.js

@@ -0,0 +1,225 @@
+import { t as sleep } from "./sleep-J71HYu7n.js";
+//#region src/async/async-iterable-subject.ts
+function createAsyncIterableSubject() {
+	const consumers = /* @__PURE__ */ new Set();
+	let status = { state: "open" };
+	const next = (value) => {
+		if (status.state !== "open") return;
+		for (const consumer of consumers) if (consumer.kind === "listener") consumer.next?.(value);
+		else if (consumer.pending) {
+			const p = consumer.pending;
+			consumer.pending = void 0;
+			p.resolve({
+				value,
+				done: false
+			});
+		} else consumer.queue.push(value);
+	};
+	const error = (err) => {
+		if (status.state !== "open") return;
+		status = {
+			state: "errored",
+			err
+		};
+		for (const consumer of consumers) if (consumer.kind === "listener") consumer.error?.(err);
+		else if (consumer.pending) {
+			const p = consumer.pending;
+			consumer.pending = void 0;
+			p.reject(err);
+		}
+		consumers.clear();
+	};
+	const complete = () => {
+		if (status.state !== "open") return;
+		status = { state: "completed" };
+		for (const consumer of consumers) if (consumer.kind === "listener") consumer.complete?.();
+		else if (consumer.pending) {
+			const p = consumer.pending;
+			consumer.pending = void 0;
+			p.resolve({
+				value: void 0,
+				done: true
+			});
+		}
+		consumers.clear();
+	};
+	const subscribe = (observerOrNext) => {
+		if (status.state !== "open") return () => {};
+		const consumer = {
+			kind: "listener",
+			...typeof observerOrNext === "function" ? { next: observerOrNext } : observerOrNext
+		};
+		consumers.add(consumer);
+		return () => {
+			consumers.delete(consumer);
+		};
+	};
+	return Object.assign({ [Symbol.asyncIterator]() {
+		if (status.state === "errored") {
+			const err = status.err;
+			return {
+				next: () => Promise.reject(err),
+				return: () => Promise.resolve({
+					value: void 0,
+					done: true
+				})
+			};
+		}
+		if (status.state === "completed") return {
+			next: () => Promise.resolve({
+				value: void 0,
+				done: true
+			}),
+			return: () => Promise.resolve({
+				value: void 0,
+				done: true
+			})
+		};
+		const consumer = {
+			kind: "iterator",
+			queue: []
+		};
+		consumers.add(consumer);
+		return {
+			next() {
+				if (consumer.queue.length > 0) return Promise.resolve({
+					value: consumer.queue.shift(),
+					done: false
+				});
+				if (status.state === "errored") return Promise.reject(status.err);
+				if (status.state === "completed") return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+				return new Promise((resolve, reject) => {
+					consumer.pending = {
+						resolve,
+						reject
+					};
+				});
+			},
+			return() {
+				consumers.delete(consumer);
+				if (consumer.pending) {
+					const p = consumer.pending;
+					consumer.pending = void 0;
+					p.resolve({
+						value: void 0,
+						done: true
+					});
+				}
+				return Promise.resolve({
+					value: void 0,
+					done: true
+				});
+			},
+			throw(err) {
+				consumers.delete(consumer);
+				return Promise.reject(err);
+			}
+		};
+	} }, {
+		next,
+		error,
+		complete,
+		subscribe
+	});
+}
+//#endregion
+//#region src/async/backoff.ts
+const DEFAULT_MAX_DELAY_MS = 3e4;
+const DEFAULT_JITTER_MIN_MS = 300;
+const DEFAULT_JITTER_MAX_MS = 3e3;
+/**
+* Exponential backoff with jitter. `attempt` starts at 0 → ~1s+jitter, 1 → ~2s+jitter, etc.,
+* capped at `maxDelayMs`. Returns a Promise that resolves after the delay.
+*/
+function exponentialBackoff(attempt, options) {
+	const maxDelayMs = options?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;
+	const jitterMinMs = options?.jitterMinMs ?? DEFAULT_JITTER_MIN_MS;
+	const jitterMaxMs = options?.jitterMaxMs ?? DEFAULT_JITTER_MAX_MS;
+	return sleep(Math.min(Math.pow(2, attempt) * 1e3, maxDelayMs) + Math.floor(Math.random() * (jitterMaxMs - jitterMinMs) + jitterMinMs), options?.signal);
+}
+/**
+* Runs `fn` with exponential-backoff retry on rejection, indefinitely, resolving with the first
+* successful result. `options.signal` aborts both the in-flight `fn` (if it observes the signal)
+* and the backoff wait.
+*/
+async function retryWithBackoff(fn, options) {
+	let attempt = 0;
+	for (;;) {
+		if (options?.signal?.aborted) throw options.signal.reason;
+		try {
+			return await fn();
+		} catch {
+			await exponentialBackoff(attempt, options);
+			attempt++;
+		}
+	}
+}
+//#endregion
+//#region src/async/concat-async.ts
+/**
+* Concatenates all elements of all arrays yielded by `iter` into a single array. Used to support
+* subscriptions that emit chunks of items before completing.
+*/
+async function concatAsync(iter) {
+	const out = [];
+	for await (const chunk of iter) out.push(...chunk);
+	return out;
+}
+//#endregion
+//#region src/async/filter-async.ts
+/** Lazy filter over an async iterable. */
+async function* filterAsync(iter, predicate) {
+	for await (const value of iter) if (predicate(value)) yield value;
+}
+//#endregion
+//#region src/async/first-async.ts
+/**
+* Returns the first value yielded by `iter`, then disposes the iterator. Throws if the iterable
+* completes without yielding. Equivalent of rxjs's `firstValueFrom` for AsyncIterables.
+*/
+async function firstAsync(iter) {
+	const it = iter[Symbol.asyncIterator]();
+	try {
+		const result = await it.next();
+		if (result.done) throw new Error("firstAsync: async iterable completed without yielding a value");
+		return result.value;
+	} finally {
+		await it.return?.();
+	}
+}
+//#endregion
+//#region src/async/keepalive.ts
+/**
+* Long-running stream wrapper: subscribes via `factory()`, yields every value, and on error or
+* unexpected completion re-subscribes with exponential backoff. Stops only when `options.signal`
+* aborts. Designed for subscriptions that should stay open across reconnects.
+*/
+async function* keepalive(factory, options) {
+	let attempt = 0;
+	const signal = options?.signal;
+	while (!signal?.aborted) try {
+		for await (const value of factory()) {
+			if (signal?.aborted) return;
+			yield value;
+			attempt = 0;
+		}
+		attempt = 0;
+	} catch (error) {
+		if (signal?.aborted) return;
+		await exponentialBackoff(attempt, options);
+		attempt++;
+	}
+}
+//#endregion
+//#region src/async/map-async.ts
+/** Lazy map over an async iterable. Cleanup propagates: breaking the outer iter disposes the inner. */
+async function* mapAsync(iter, fn) {
+	for await (const value of iter) yield fn(value);
+}
+//#endregion
+export { concatAsync, createAsyncIterableSubject, exponentialBackoff, filterAsync, firstAsync, keepalive, mapAsync, retryWithBackoff };
+
+//# sourceMappingURL=async.js.map

package/dist/async.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async.js","names":[],"sources":["../src/async/async-iterable-subject.ts","../src/async/backoff.ts","../src/async/concat-async.ts","../src/async/filter-async.ts","../src/async/first-async.ts","../src/async/keepalive.ts","../src/async/map-async.ts"],"sourcesContent":["/**\n * Multicast event source with `next` / `error` / `complete` (Subject semantics) plus an\n * `AsyncIterable` view. Two consumption modes that fan out from the same source:\n *\n * - `for await (const v of subject)` — iteration. Each `[Symbol.asyncIterator]()` call returns\n *   a fresh per-iterator queue. Stop by `break`ing the loop. On `.error(err)` the iterator's\n *   pending `next()` rejects, propagating into the for-await as a thrown exception.\n *\n * - `subject.subscribe(observerOrNext)` — observer style. Pass either a full/partial observer\n *   `{ next?, error?, complete? }` or just an `(value) => …` function as the `next`-only shortcut.\n *   Returns an unsubscribe function. Missing handlers default to no-ops.\n *\n * Producer side: call `.next(value)` to emit, `.error(err)` to fail the subject (all consumers\n * see the error and are detached), `.complete()` to close cleanly (all consumers see done and\n * are detached). After either `error` or `complete`, further `.next()` calls are dropped and\n * new `.subscribe(...)` calls register a no-op unsubscribe.\n *\n * Backpressure: unbounded queue per pending iterator. Intended for low-frequency events.\n */\nexport type AsyncIterableSubject<T> = AsyncIterable<T> & {\n  next: (value: T) => void;\n  error: (err: unknown) => void;\n  complete: () => void;\n  subscribe: (\n    observerOrNext:\n      | ((value: T) => void)\n      | {\n        next?: (value: T) => void;\n        error?: (err: unknown) => void;\n        complete?: () => void;\n      },\n  ) => () => void;\n};\n\ntype IteratorConsumer<T> = {\n  kind: 'iterator';\n  queue: T[];\n  pending?: { resolve: (r: IteratorResult<T>) => void; reject: (e: unknown) => void } | undefined;\n};\n\ntype ListenerConsumer<T> = {\n  kind: 'listener';\n  next?: (value: T) => void;\n  error?: (err: unknown) => void;\n  complete?: () => void;\n};\n\ntype Consumer<T> = IteratorConsumer<T> | ListenerConsumer<T>;\n\ntype Status = { state: 'open' } | { state: 'errored'; err: unknown } | { state: 'completed' };\n\nexport function createAsyncIterableSubject<T>(): AsyncIterableSubject<T> {\n  const consumers = new Set<Consumer<T>>();\n  let status: Status = { state: 'open' };\n\n  const next = (value: T): void => {\n    if (status.state !== 'open') {\n      return;\n    }\n\n    for (const consumer of consumers) {\n      if (consumer.kind === 'listener') {\n        consumer.next?.(value);\n      } else if (consumer.pending) {\n        const p = consumer.pending;\n\n        consumer.pending = undefined;\n        p.resolve({ value, done: false });\n      } else {\n        consumer.queue.push(value);\n      }\n    }\n  };\n\n  const error = (err: unknown): void => {\n    if (status.state !== 'open') {\n      return;\n    }\n\n    status = { state: 'errored', err };\n\n    for (const consumer of consumers) {\n      if (consumer.kind === 'listener') {\n        consumer.error?.(err);\n      } else if (consumer.pending) {\n        const p = consumer.pending;\n\n        consumer.pending = undefined;\n        p.reject(err);\n      }\n    }\n\n    consumers.clear();\n  };\n\n  const complete = (): void => {\n    if (status.state !== 'open') {\n      return;\n    }\n\n    status = { state: 'completed' };\n\n    for (const consumer of consumers) {\n      if (consumer.kind === 'listener') {\n        consumer.complete?.();\n      } else if (consumer.pending) {\n        const p = consumer.pending;\n\n        consumer.pending = undefined;\n        p.resolve({ value: undefined as unknown as T, done: true });\n      }\n    }\n\n    consumers.clear();\n  };\n\n  const subscribe = (\n    observerOrNext:\n      | ((value: T) => void)\n      | {\n        next?: (value: T) => void;\n        error?: (err: unknown) => void;\n        complete?: () => void;\n      },\n  ): (() => void) => {\n    if (status.state !== 'open') {\n      return () => {};\n    }\n\n    const observer = typeof observerOrNext === 'function' ? { next: observerOrNext } : observerOrNext;\n    const consumer: ListenerConsumer<T> = { kind: 'listener', ...observer };\n\n    consumers.add(consumer);\n\n    return () => {\n      consumers.delete(consumer);\n    };\n  };\n\n  const iterable: AsyncIterable<T> = {\n    [Symbol.asyncIterator](): AsyncIterator<T> {\n      if (status.state === 'errored') {\n        const err = status.err;\n\n        return {\n          next: () => Promise.reject(err),\n          return: () => Promise.resolve({ value: undefined as unknown as T, done: true }),\n        };\n      }\n\n      if (status.state === 'completed') {\n        return {\n          next: () => Promise.resolve({ value: undefined as unknown as T, done: true }),\n          return: () => Promise.resolve({ value: undefined as unknown as T, done: true }),\n        };\n      }\n\n      const consumer: IteratorConsumer<T> = { kind: 'iterator', queue: [] };\n\n      consumers.add(consumer);\n\n      return {\n        next(): Promise<IteratorResult<T>> {\n          if (consumer.queue.length > 0) {\n            return Promise.resolve({ value: consumer.queue.shift()!, done: false });\n          }\n\n          if (status.state === 'errored') {\n            return Promise.reject(status.err);\n          }\n\n          if (status.state === 'completed') {\n            return Promise.resolve({ value: undefined as unknown as T, done: true });\n          }\n\n          return new Promise<IteratorResult<T>>((resolve, reject) => {\n            consumer.pending = { resolve, reject };\n          });\n        },\n        return(): Promise<IteratorResult<T>> {\n          consumers.delete(consumer);\n\n          if (consumer.pending) {\n            const p = consumer.pending;\n\n            consumer.pending = undefined;\n            p.resolve({ value: undefined as unknown as T, done: true });\n          }\n\n          return Promise.resolve({ value: undefined as unknown as T, done: true });\n        },\n        throw(err): Promise<IteratorResult<T>> {\n          consumers.delete(consumer);\n\n          return Promise.reject(err);\n        },\n      };\n    },\n  };\n\n  return Object.assign(iterable, { next, error, complete, subscribe });\n}\n","import { sleep } from '../core/sleep';\n\nconst DEFAULT_MAX_DELAY_MS = 30_000;\nconst DEFAULT_JITTER_MIN_MS = 300;\nconst DEFAULT_JITTER_MAX_MS = 3000;\n\nexport type BackoffOptions = {\n  /** upper bound for the exponential delay, before jitter (default 30_000) */\n  maxDelayMs?: number | undefined;\n\n  /** lower bound of the random jitter added to every delay (default 300) */\n  jitterMinMs?: number | undefined;\n\n  /** upper bound of the random jitter added to every delay (default 3000) */\n  jitterMaxMs?: number | undefined;\n\n  /** aborts the backoff wait (and, where applicable, the retry loop) */\n  signal?: AbortSignal | undefined;\n};\n\n/**\n * Exponential backoff with jitter. `attempt` starts at 0 → ~1s+jitter, 1 → ~2s+jitter, etc.,\n * capped at `maxDelayMs`. Returns a Promise that resolves after the delay.\n */\nexport function exponentialBackoff(attempt: number, options?: BackoffOptions | undefined): Promise<void> {\n  const maxDelayMs = options?.maxDelayMs ?? DEFAULT_MAX_DELAY_MS;\n  const jitterMinMs = options?.jitterMinMs ?? DEFAULT_JITTER_MIN_MS;\n  const jitterMaxMs = options?.jitterMaxMs ?? DEFAULT_JITTER_MAX_MS;\n\n  const base = Math.min(Math.pow(2, attempt) * 1000, maxDelayMs);\n  const jitter = Math.floor(Math.random() * (jitterMaxMs - jitterMinMs) + jitterMinMs);\n\n  return sleep(base + jitter, options?.signal);\n}\n\n/**\n * Runs `fn` with exponential-backoff retry on rejection, indefinitely, resolving with the first\n * successful result. `options.signal` aborts both the in-flight `fn` (if it observes the signal)\n * and the backoff wait.\n */\nexport async function retryWithBackoff<T>(fn: () => Promise<T>, options?: BackoffOptions | undefined): Promise<T> {\n  let attempt = 0;\n\n  for (;;) {\n    if (options?.signal?.aborted) {\n      throw options.signal.reason;\n    }\n\n    try {\n      return await fn();\n    } catch {\n      await exponentialBackoff(attempt, options);\n      attempt++;\n    }\n  }\n}\n","/**\n * Concatenates all elements of all arrays yielded by `iter` into a single array. Used to support\n * subscriptions that emit chunks of items before completing.\n */\nexport async function concatAsync<T>(iter: AsyncIterable<T[]>): Promise<T[]> {\n  const out: T[] = [];\n\n  for await (const chunk of iter) {\n    out.push(...chunk);\n  }\n\n  return out;\n}\n","/** Lazy filter over an async iterable. */\nexport async function* filterAsync<T>(iter: AsyncIterable<T>, predicate: (value: T) => boolean): AsyncIterable<T> {\n  for await (const value of iter) {\n    if (predicate(value)) {\n      yield value;\n    }\n  }\n}\n","/**\n * Returns the first value yielded by `iter`, then disposes the iterator. Throws if the iterable\n * completes without yielding. Equivalent of rxjs's `firstValueFrom` for AsyncIterables.\n */\nexport async function firstAsync<T>(iter: AsyncIterable<T>): Promise<T> {\n  const it = iter[Symbol.asyncIterator]();\n\n  try {\n    const result = await it.next();\n\n    if (result.done) {\n      throw new Error('firstAsync: async iterable completed without yielding a value');\n    }\n\n    return result.value;\n  } finally {\n    await it.return?.();\n  }\n}\n","import { type BackoffOptions, exponentialBackoff } from './backoff';\n\n/**\n * Long-running stream wrapper: subscribes via `factory()`, yields every value, and on error or\n * unexpected completion re-subscribes with exponential backoff. Stops only when `options.signal`\n * aborts. Designed for subscriptions that should stay open across reconnects.\n */\nexport async function* keepalive<T>(\n  factory: () => AsyncIterable<T>,\n  options?: BackoffOptions | undefined,\n): AsyncIterable<T> {\n  let attempt = 0;\n  const signal = options?.signal;\n\n  while (!signal?.aborted) {\n    try {\n      for await (const value of factory()) {\n        if (signal?.aborted) {\n          return;\n        }\n\n        yield value;\n        attempt = 0;\n      }\n\n      // source completed cleanly — re-subscribe immediately\n      attempt = 0;\n    } catch (error) {\n      if (signal?.aborted) {\n        return;\n      }\n\n      // swallow + back off, then retry. callers that want the error to surface should not use keepalive\n      void error;\n      await exponentialBackoff(attempt, options);\n      attempt++;\n    }\n  }\n}\n","/** Lazy map over an async iterable. Cleanup propagates: breaking the outer iter disposes the inner. */\nexport async function* mapAsync<T, R>(iter: AsyncIterable<T>, fn: (value: T) => R): AsyncIterable<R> {\n  for await (const value of iter) {\n    yield fn(value);\n  }\n}\n"],"mappings":"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"}

package/dist/cn.d.ts

@@ -0,0 +1,11 @@
+import { ClassValue } from "clsx";
+//#region src/cn/classable.d.ts
+type Classable = {
+  readonly className?: string | undefined;
+};
+//#endregion
+//#region src/cn/cn.d.ts
+declare function cn(...inputs: ClassValue[]): string;
+//#endregion
+export { Classable, cn };
+//# sourceMappingURL=cn.d.ts.map

package/dist/cn.js

@@ -0,0 +1,10 @@
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+//#region src/cn/cn.ts
+function cn(...inputs) {
+	return twMerge(clsx(inputs));
+}
+//#endregion
+export { cn };
+
+//# sourceMappingURL=cn.js.map

package/dist/cn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cn.js","names":[],"sources":["../src/cn/cn.ts"],"sourcesContent":["import { type ClassValue, clsx } from 'clsx';\nimport { twMerge } from 'tailwind-merge';\n\nexport function cn(...inputs: ClassValue[]): string {\n  return twMerge(clsx(inputs));\n}\n"],"mappings":";;;AAGA,SAAgB,GAAG,GAAG,QAA8B;CAClD,OAAO,QAAQ,KAAK,MAAM,CAAC;AAC7B"}

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+//#region src/core/assert.d.ts
+declare function assert<T>(expr: T, message?: string | Error): asserts expr;
+//#endregion
+//#region src/core/capitalize.d.ts
+declare function capitalize(str: string): string;
+//#endregion
+//#region src/core/create-batcher.d.ts
+/**
+ * Buffers function calls and executes them together after a specified delay.
+ * Useful for batching multiple events into a single operation.
+ *
+ * @param onFlush - Function to execute with all buffered items
+ * @param delayMs - Delay in milliseconds before flushing the buffer
+ * @returns Function that adds items to the buffer
+ */
+declare function createBatcher<T>(onFlush: (items: T[]) => void, delayMs: number): (item: T) => void;
+//#endregion
+//#region src/core/debounce.d.ts
+declare const debounce: <A extends unknown[]>(func: (...args: A) => unknown, wait: number) => (...args: A) => void;
+//#endregion
+//#region src/core/readonly-deep.d.ts
+/**
+ * Recursively makes a type and all its nested properties readonly.
+ *
+ * Adapted from type-fest's `ReadonlyDeep` taken under CC0:
+ * https://github.com/sindresorhus/type-fest/blob/main/source/readonly-deep.d.ts
+ */
+type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+type BuiltIns = Primitive | void | Date | RegExp;
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> = T extends {
+  (...arguments_: infer A): unknown;
+  (...arguments_: infer B): unknown;
+} ? B extends A ? A extends B ? false : true : true : false;
+type EmptyObject = {};
+type ReadonlyDeep<T> = T extends BuiltIns ? T : T extends (new (...arguments_: any[]) => unknown) ? T : T extends ((...arguments_: any[]) => unknown) ? EmptyObject extends ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> : T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [infer U, ...infer V] ? readonly [ReadonlyDeep<U>, ...ReadonlyDeep<V>] : T extends readonly [...infer U, infer V] ? readonly [...ReadonlyDeep<U>, ReadonlyDeep<V>] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? ReadonlyObjectDeep<T> : unknown;
+type ReadonlyMapDeep<KeyType, ValueType> = EmptyObject & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
+type ReadonlySetDeep<ItemType> = EmptyObject & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
+type ReadonlyObjectDeep<ObjectType extends object> = { readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>; };
+//#endregion
+//#region src/core/deep-freeze.d.ts
+/**
+ * Runtime companion of {@link ReadonlyDeep}: recursively Object.freeze()s a value and returns it
+ * typed as deeply readonly. Safe on cyclic structures; already-frozen values are assumed to be
+ * deep-frozen and are not descended into.
+ *
+ * Runtime limits (the type still forbids mutation in all these cases): Map / Set contents are
+ * frozen, but the containers themselves stay mutable; Date internals cannot be frozen; functions
+ * are left untouched.
+ */
+declare function deepFreeze<T>(value: T): ReadonlyDeep<T>;
+//#endregion
+//#region src/core/defined.d.ts
+declare function defined<T>(val: T | undefined | null | void): val is T;
+declare function truthy<T>(val: T | undefined | null | void): val is T;
+//#endregion
+//#region src/core/index-by.d.ts
+declare function indexBy<T>(array: readonly T[], keyFn: keyof T | ((value: T) => string)): Map<string, T>;
+declare function indexBy<T, K extends keyof T>(array: readonly T[], keyFn: keyof T | ((value: T) => string), valueFn: K): Map<string, T[K]>;
+declare function indexBy<T, V>(array: readonly T[], keyFn: keyof T | ((value: T) => string), valueFn: (value: T) => V): Map<string, V>;
+//#endregion
+//#region src/core/map-concurrent.d.ts
+/**
+ * Order-preserving concurrent map: runs `fn` over the items with a sliding pool of at most
+ * `concurrency` workers, so a slow item never stalls the others. Errors propagate via Promise.all.
+ */
+declare function mapConcurrent<T, R>(items: readonly T[], fn: (item: T, index: number) => Promise<R>, concurrency: number): Promise<R[]>;
+//#endregion
+//#region src/core/maybe-promise.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type MaybeAwaitedAll<T extends readonly MaybePromise<unknown>[]> = { -readonly [K in keyof T]: Awaited<T[K]>; };
+type MaybeSettledAll<T extends readonly MaybePromise<unknown>[]> = { -readonly [K in keyof T]: PromiseSettledResult<Awaited<T[K]>>; };
+/**
+ * Chains a transformation on a MaybePromise value.
+ * If the value is a Promise, uses .then(). Otherwise, calls fn directly.
+ *
+ * @example
+ * ```ts
+ * const result = maybeThen(map.get('key'), (value) => value.name);
+ * // result is MaybePromise<string>
+ * ```
+ */
+declare function maybeThen<T, R>(value: MaybePromise<T>, fn: (v: T) => MaybePromise<R>): MaybePromise<R>;
+/**
+ * Adds error handling to a MaybePromise value.
+ * If the value is a Promise, uses .catch(). Otherwise, returns value as-is.
+ *
+ * @example
+ * ```ts
+ * const result = maybeCatch(map.get('key'), (err) => defaultValue);
+ * // result is MaybePromise<T>
+ * ```
+ */
+declare function maybeCatch<T>(value: MaybePromise<T>, fn: (e: unknown) => MaybePromise<T>): MaybePromise<T>;
+/**
+ * Combines MaybePromise values.
+ * If any value is a Promise, behaves like Promise.all(). Otherwise, returns the values synchronously.
+ *
+ * @example
+ * ```ts
+ * const [user, config] = await maybeAll([cache.get('user'), cache.get('config')]);
+ * // no microtask hop when both were cached synchronously
+ * ```
+ */
+declare function maybeAll<T extends readonly MaybePromise<unknown>[]>(values: T): MaybePromise<MaybeAwaitedAll<T>>;
+/**
+ * Settles MaybePromise values.
+ * If any value is a Promise, behaves like Promise.allSettled(). Otherwise, returns the values
+ * synchronously, each wrapped as a fulfilled result.
+ */
+declare function maybeAllSettled<T extends readonly MaybePromise<unknown>[]>(values: T): MaybePromise<MaybeSettledAll<T>>;
+//#endregion
+//#region src/core/noop.d.ts
+declare const noop: (..._: any[]) => void;
+declare const markAsUsed: (..._: any[]) => void;
+//#endregion
+//#region src/core/omit-undefined.d.ts
+type DeepNonUndefined<T> = T extends Record<string, unknown> ? { [P in keyof T as undefined extends T[P] ? never : P]: T[P] extends (infer U)[] ? DeepNonUndefined<U>[] : T[P] extends Record<string, unknown> ? DeepNonUndefined<T[P]> : Exclude<T[P], undefined>; } : Exclude<T, undefined>;
+type ShallowNonUndefined<T> = { [P in keyof T as undefined extends T[P] ? never : P]: Exclude<T[P], undefined>; };
+/**
+ * Removes undefined properties from an object.
+ * Optionally processes nested objects and arrays recursively.
+ *
+ * @param obj object to clean
+ * @param recursive whether to recursively process nested objects and arrays (default: true)
+ */
+declare function omitUndefined<T extends Record<string, unknown>>(obj: T, recursive?: true): DeepNonUndefined<T>;
+declare function omitUndefined<T extends Record<string, unknown>>(obj: T, recursive: false): ShallowNonUndefined<T>;
+//#endregion
+//#region src/core/optionalize.d.ts
+declare function optionalize<T, U, D = undefined>(fn: (v: T) => U, options?: {
+  defaultValue?: D | undefined;
+  strategy?: 'falsy' | 'nullish' | undefined;
+} | undefined): (v: T | null | undefined) => U | D;
+//#endregion
+//#region src/core/retry.d.ts
+type RetryOptions = {
+  /** total number of attempts before the last error is rethrown (default 3) */
+  retries?: number | undefined;
+  /** fixed delay between attempts (default 1000) */
+  delayMs?: number | undefined;
+  /** aborts the delay between attempts */
+  signal?: AbortSignal | undefined;
+  /** called after every failed attempt with the error and the 1-based attempt number */
+  onError?: ((error: unknown, attempt: number) => void) | undefined;
+};
+/**
+ * Runs `fn`, retrying with a fixed delay on failure. Resolves with the first successful result;
+ * rethrows the last error once the attempts are exhausted.
+ */
+declare function retry<T>(fn: () => T, options?: RetryOptions | undefined): Promise<T>;
+//#endregion
+//#region src/core/sleep.d.ts
+declare function sleep(ms: number, signal?: AbortSignal | undefined): Promise<void>;
+//#endregion
+export { MaybePromise, ReadonlyDeep, RetryOptions, assert, capitalize, createBatcher, debounce, deepFreeze, defined, indexBy, mapConcurrent, markAsUsed, maybeAll, maybeAllSettled, maybeCatch, maybeThen, noop, omitUndefined, optionalize, retry, sleep, truthy };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,225 @@
+import { t as sleep } from "./sleep-J71HYu7n.js";
+//#region src/core/assert.ts
+function assert(expr, message) {
+	message ||= "unknown assertion error";
+	message = typeof message === "string" ? new Error(message) : message;
+	if (!expr) throw message;
+}
+//#endregion
+//#region src/core/capitalize.ts
+function capitalize(str) {
+	if (!str) return str;
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//#endregion
+//#region src/core/create-batcher.ts
+/**
+* Buffers function calls and executes them together after a specified delay.
+* Useful for batching multiple events into a single operation.
+*
+* @param onFlush - Function to execute with all buffered items
+* @param delayMs - Delay in milliseconds before flushing the buffer
+* @returns Function that adds items to the buffer
+*/
+function createBatcher(onFlush, delayMs) {
+	let buffer = [];
+	let timeoutId = null;
+	return (item) => {
+		buffer.push(item);
+		if (timeoutId) clearTimeout(timeoutId);
+		timeoutId = setTimeout(() => {
+			onFlush(buffer);
+			buffer = [];
+			timeoutId = null;
+		}, delayMs);
+	};
+}
+//#endregion
+//#region src/core/debounce.ts
+const debounce = (func, wait) => {
+	let timeout;
+	return function executedFunction(...args) {
+		const later = () => {
+			timeout = void 0;
+			func(...args);
+		};
+		clearTimeout(timeout);
+		timeout = setTimeout(later, wait);
+	};
+};
+//#endregion
+//#region src/core/deep-freeze.ts
+/**
+* Runtime companion of {@link ReadonlyDeep}: recursively Object.freeze()s a value and returns it
+* typed as deeply readonly. Safe on cyclic structures; already-frozen values are assumed to be
+* deep-frozen and are not descended into.
+*
+* Runtime limits (the type still forbids mutation in all these cases): Map / Set contents are
+* frozen, but the containers themselves stay mutable; Date internals cannot be frozen; functions
+* are left untouched.
+*/
+function deepFreeze(value) {
+	freeze(value);
+	return value;
+}
+function freeze(value) {
+	if (value === null || typeof value !== "object" || Object.isFrozen(value)) return;
+	if (ArrayBuffer.isView(value)) return;
+	Object.freeze(value);
+	if (value instanceof Map) {
+		for (const [key, item] of value) {
+			freeze(key);
+			freeze(item);
+		}
+		return;
+	}
+	if (value instanceof Set) {
+		for (const item of value) freeze(item);
+		return;
+	}
+	for (const key of Reflect.ownKeys(value)) freeze(value[key]);
+}
+//#endregion
+//#region src/core/defined.ts
+function defined(val) {
+	return val !== void 0 && val !== null;
+}
+function truthy(val) {
+	return !!val;
+}
+//#endregion
+//#region src/core/index-by.ts
+function indexBy(array, keyFn, valueFn) {
+	return array.reduce((map, item) => {
+		const key = typeof keyFn === "function" ? keyFn(item) : String(item[keyFn]);
+		if (valueFn) {
+			const value = typeof valueFn === "function" ? valueFn(item) : item[valueFn];
+			map.set(key, value);
+		} else map.set(key, item);
+		return map;
+	}, /* @__PURE__ */ new Map());
+}
+//#endregion
+//#region src/core/map-concurrent.ts
+/**
+* Order-preserving concurrent map: runs `fn` over the items with a sliding pool of at most
+* `concurrency` workers, so a slow item never stalls the others. Errors propagate via Promise.all.
+*/
+async function mapConcurrent(items, fn, concurrency) {
+	const results = Array.from({ length: items.length });
+	let nextIndex = 0;
+	async function worker() {
+		while (true) {
+			const i = nextIndex++;
+			if (i >= items.length) return;
+			results[i] = await fn(items[i], i);
+		}
+	}
+	const workerCount = Math.max(1, Math.min(concurrency, items.length));
+	const workers = Array.from({ length: workerCount }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
+//#endregion
+//#region src/core/maybe-promise.ts
+/**
+* Chains a transformation on a MaybePromise value.
+* If the value is a Promise, uses .then(). Otherwise, calls fn directly.
+*
+* @example
+* ```ts
+* const result = maybeThen(map.get('key'), (value) => value.name);
+* // result is MaybePromise<string>
+* ```
+*/
+function maybeThen(value, fn) {
+	if (value instanceof Promise) return value.then(fn);
+	return fn(value);
+}
+/**
+* Adds error handling to a MaybePromise value.
+* If the value is a Promise, uses .catch(). Otherwise, returns value as-is.
+*
+* @example
+* ```ts
+* const result = maybeCatch(map.get('key'), (err) => defaultValue);
+* // result is MaybePromise<T>
+* ```
+*/
+function maybeCatch(value, fn) {
+	if (value instanceof Promise) return value.catch(fn);
+	return value;
+}
+/**
+* Combines MaybePromise values.
+* If any value is a Promise, behaves like Promise.all(). Otherwise, returns the values synchronously.
+*
+* @example
+* ```ts
+* const [user, config] = await maybeAll([cache.get('user'), cache.get('config')]);
+* // no microtask hop when both were cached synchronously
+* ```
+*/
+function maybeAll(values) {
+	if (values.some((value) => value instanceof Promise)) return Promise.all(values);
+	return [...values];
+}
+/**
+* Settles MaybePromise values.
+* If any value is a Promise, behaves like Promise.allSettled(). Otherwise, returns the values
+* synchronously, each wrapped as a fulfilled result.
+*/
+function maybeAllSettled(values) {
+	if (values.some((value) => value instanceof Promise)) return Promise.allSettled(values);
+	return values.map((value) => ({
+		status: "fulfilled",
+		value
+	}));
+}
+//#endregion
+//#region src/core/noop.ts
+const noop = (..._) => {};
+const markAsUsed = (..._) => {};
+//#endregion
+//#region src/core/omit-undefined.ts
+function omitUndefined(obj, recursive = true) {
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) if (value !== void 0) if (recursive && value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date)) result[key] = omitUndefined(value, recursive);
+	else if (recursive && Array.isArray(value)) result[key] = value.filter((item) => item !== void 0).map((item) => {
+		if (item && typeof item === "object" && !Array.isArray(item) && !(item instanceof Date)) return omitUndefined(item, recursive);
+		return item;
+	});
+	else result[key] = value;
+	return result;
+}
+//#endregion
+//#region src/core/optionalize.ts
+function optionalize(fn, options) {
+	const defaultValue = options?.defaultValue;
+	const emptyMode = options?.strategy ?? "nullish";
+	return (v) => {
+		if (v === null || v === void 0 || emptyMode === "falsy" && !v) return defaultValue;
+		return fn(v);
+	};
+}
+//#endregion
+//#region src/core/retry.ts
+/**
+* Runs `fn`, retrying with a fixed delay on failure. Resolves with the first successful result;
+* rethrows the last error once the attempts are exhausted.
+*/
+async function retry(fn, options) {
+	const retries = options?.retries ?? 3;
+	const delayMs = options?.delayMs ?? 1e3;
+	for (let attempt = 1;; attempt++) try {
+		return await fn();
+	} catch (error) {
+		options?.onError?.(error, attempt);
+		if (attempt >= retries) throw error;
+		await sleep(delayMs, options?.signal);
+	}
+}
+//#endregion
+export { assert, capitalize, createBatcher, debounce, deepFreeze, defined, indexBy, mapConcurrent, markAsUsed, maybeAll, maybeAllSettled, maybeCatch, maybeThen, noop, omitUndefined, optionalize, retry, sleep, truthy };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/core/assert.ts","../src/core/capitalize.ts","../src/core/create-batcher.ts","../src/core/debounce.ts","../src/core/deep-freeze.ts","../src/core/defined.ts","../src/core/index-by.ts","../src/core/map-concurrent.ts","../src/core/maybe-promise.ts","../src/core/noop.ts","../src/core/omit-undefined.ts","../src/core/optionalize.ts","../src/core/retry.ts"],"sourcesContent":["export function assert<T>(expr: T, message?: string | Error): asserts expr {\n  message ||= 'unknown assertion error';\n  message = typeof message === 'string' ? new Error(message) : message;\n\n  if (!expr) {\n    throw message;\n  }\n}\n","export function capitalize(str: string): string {\n  if (!str) return str;\n\n  return str.charAt(0).toUpperCase() + str.slice(1);\n}\n","/**\n * Buffers function calls and executes them together after a specified delay.\n * Useful for batching multiple events into a single operation.\n *\n * @param onFlush - Function to execute with all buffered items\n * @param delayMs - Delay in milliseconds before flushing the buffer\n * @returns Function that adds items to the buffer\n */\nexport function createBatcher<T>(onFlush: (items: T[]) => void, delayMs: number) {\n  let buffer: T[] = [];\n  let timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n  return (item: T) => {\n    buffer.push(item);\n\n    if (timeoutId) {\n      clearTimeout(timeoutId);\n    }\n\n    timeoutId = setTimeout(() => {\n      onFlush(buffer);\n      buffer = [];\n      timeoutId = null;\n    }, delayMs);\n  };\n}\n","export const debounce = <A extends unknown[]>(func: (...args: A) => unknown, wait: number) => {\n  let timeout: ReturnType<typeof setTimeout> | undefined;\n\n  return function executedFunction(...args: A) {\n    const later = () => {\n      timeout = undefined;\n      func(...args);\n    };\n\n    clearTimeout(timeout);\n\n    timeout = setTimeout(later, wait);\n  };\n};\n","import type { ReadonlyDeep } from './readonly-deep';\n\n/**\n * Runtime companion of {@link ReadonlyDeep}: recursively Object.freeze()s a value and returns it\n * typed as deeply readonly. Safe on cyclic structures; already-frozen values are assumed to be\n * deep-frozen and are not descended into.\n *\n * Runtime limits (the type still forbids mutation in all these cases): Map / Set contents are\n * frozen, but the containers themselves stay mutable; Date internals cannot be frozen; functions\n * are left untouched.\n */\nexport function deepFreeze<T>(value: T): ReadonlyDeep<T> {\n  freeze(value);\n\n  return value as ReadonlyDeep<T>;\n}\n\nfunction freeze(value: unknown): void {\n  if (value === null || typeof value !== 'object' || Object.isFrozen(value)) {\n    return;\n  }\n\n  // freezing typed arrays with elements throws\n  if (ArrayBuffer.isView(value)) {\n    return;\n  }\n\n  Object.freeze(value);\n\n  if (value instanceof Map) {\n    for (const [key, item] of value) {\n      freeze(key);\n      freeze(item);\n    }\n\n    return;\n  }\n\n  if (value instanceof Set) {\n    for (const item of value) {\n      freeze(item);\n    }\n\n    return;\n  }\n\n  for (const key of Reflect.ownKeys(value)) {\n    freeze((value as Record<PropertyKey, unknown>)[key]);\n  }\n}\n","export function defined<T>(val: T | undefined | null | void): val is T {\n  return val !== undefined && val !== null;\n}\n\nexport function truthy<T>(val: T | undefined | null | void): val is T {\n  return !!val;\n}\n","export function indexBy<T>(array: readonly T[], keyFn: keyof T | ((value: T) => string)): Map<string, T>;\nexport function indexBy<T, K extends keyof T>(\n  array: readonly T[],\n  keyFn: keyof T | ((value: T) => string),\n  valueFn: K,\n): Map<string, T[K]>;\nexport function indexBy<T, V>(\n  array: readonly T[],\n  keyFn: keyof T | ((value: T) => string),\n  valueFn: (value: T) => V,\n): Map<string, V>;\nexport function indexBy<T, V = T>(\n  array: readonly T[],\n  keyFn: keyof T | ((value: T) => string),\n  valueFn?: keyof T | ((value: T) => V),\n): Map<string, V | T> {\n  return array.reduce((map, item) => {\n    const key = typeof keyFn === 'function' ? keyFn(item) : String(item[keyFn]); // eslint-disable-line unicorn/no-unsafe-property-key\n\n    if (valueFn) {\n      const value = typeof valueFn === 'function' ? valueFn(item) : item[valueFn]; // eslint-disable-line unicorn/no-unsafe-property-key\n      map.set(key, value as V | T);\n    } else {\n      map.set(key, item as V | T);\n    }\n\n    return map;\n  }, new Map<string, V | T>());\n}\n","/**\n * Order-preserving concurrent map: runs `fn` over the items with a sliding pool of at most\n * `concurrency` workers, so a slow item never stalls the others. Errors propagate via Promise.all.\n */\nexport async function mapConcurrent<T, R>(\n  items: readonly T[],\n  fn: (item: T, index: number) => Promise<R>,\n  concurrency: number,\n): Promise<R[]> {\n  const results: R[] = Array.from({ length: items.length });\n  let nextIndex = 0;\n\n  async function worker(): Promise<void> {\n    while (true) {\n      const i = nextIndex++;\n\n      if (i >= items.length) {\n        return;\n      }\n\n      results[i] = await fn(items[i]!, i);\n    }\n  }\n\n  const workerCount = Math.max(1, Math.min(concurrency, items.length));\n  const workers = Array.from({ length: workerCount }, () => worker());\n\n  await Promise.all(workers);\n\n  return results;\n}\n","export type MaybePromise<T> = T | Promise<T>;\n\ntype MaybeAwaitedAll<T extends readonly MaybePromise<unknown>[]> = { -readonly [K in keyof T]: Awaited<T[K]> };\n\ntype MaybeSettledAll<T extends readonly MaybePromise<unknown>[]> = {\n  -readonly [K in keyof T]: PromiseSettledResult<Awaited<T[K]>>;\n};\n\n/**\n * Chains a transformation on a MaybePromise value.\n * If the value is a Promise, uses .then(). Otherwise, calls fn directly.\n *\n * @example\n * ```ts\n * const result = maybeThen(map.get('key'), (value) => value.name);\n * // result is MaybePromise<string>\n * ```\n */\nexport function maybeThen<T, R>(value: MaybePromise<T>, fn: (v: T) => MaybePromise<R>): MaybePromise<R> {\n  if (value instanceof Promise) {\n    return value.then(fn); // eslint-disable-line unicorn/prefer-await\n  }\n\n  return fn(value);\n}\n\n/**\n * Adds error handling to a MaybePromise value.\n * If the value is a Promise, uses .catch(). Otherwise, returns value as-is.\n *\n * @example\n * ```ts\n * const result = maybeCatch(map.get('key'), (err) => defaultValue);\n * // result is MaybePromise<T>\n * ```\n */\nexport function maybeCatch<T>(value: MaybePromise<T>, fn: (e: unknown) => MaybePromise<T>): MaybePromise<T> {\n  if (value instanceof Promise) {\n    return value.catch(fn); // eslint-disable-line unicorn/prefer-await\n  }\n\n  return value;\n}\n\n/**\n * Combines MaybePromise values.\n * If any value is a Promise, behaves like Promise.all(). Otherwise, returns the values synchronously.\n *\n * @example\n * ```ts\n * const [user, config] = await maybeAll([cache.get('user'), cache.get('config')]);\n * // no microtask hop when both were cached synchronously\n * ```\n */\nexport function maybeAll<T extends readonly MaybePromise<unknown>[]>(values: T): MaybePromise<MaybeAwaitedAll<T>> {\n  if (values.some((value) => value instanceof Promise)) {\n    return Promise.all(values) as Promise<MaybeAwaitedAll<T>>;\n  }\n\n  return [...values] as MaybeAwaitedAll<T>;\n}\n\n/**\n * Settles MaybePromise values.\n * If any value is a Promise, behaves like Promise.allSettled(). Otherwise, returns the values\n * synchronously, each wrapped as a fulfilled result.\n */\nexport function maybeAllSettled<T extends readonly MaybePromise<unknown>[]>(\n  values: T,\n): MaybePromise<MaybeSettledAll<T>> {\n  if (values.some((value) => value instanceof Promise)) {\n    return Promise.allSettled(values) as Promise<MaybeSettledAll<T>>;\n  }\n\n  return values.map((value) => ({ status: 'fulfilled', value })) as MaybeSettledAll<T>;\n}\n","export const noop = (..._: any[]) => {};\n\n// used e.g. because of https://github.com/withastro/astro/issues/14684 — fixed in\n// @astrojs/compiler 3.0.0, but @astrojs/check still bundles the unfixed 2.x line;\n// obsolete once the language server ships with compiler >= 3.0.0\nexport const markAsUsed = (..._: any[]) => {};\n","type DeepNonUndefined<T> =\n  T extends Record<string, unknown>\n    ? {\n        [P in keyof T as undefined extends T[P] ? never : P]: T[P] extends (infer U)[]\n          ? DeepNonUndefined<U>[]\n          : T[P] extends Record<string, unknown>\n            ? DeepNonUndefined<T[P]>\n            : Exclude<T[P], undefined>;\n      }\n    : Exclude<T, undefined>;\n\ntype ShallowNonUndefined<T> = {\n  [P in keyof T as undefined extends T[P] ? never : P]: Exclude<T[P], undefined>;\n};\n\n/**\n * Removes undefined properties from an object.\n * Optionally processes nested objects and arrays recursively.\n *\n * @param obj object to clean\n * @param recursive whether to recursively process nested objects and arrays (default: true)\n */\nexport function omitUndefined<T extends Record<string, unknown>>(obj: T, recursive?: true): DeepNonUndefined<T>;\nexport function omitUndefined<T extends Record<string, unknown>>(obj: T, recursive: false): ShallowNonUndefined<T>;\nexport function omitUndefined<T extends Record<string, unknown>>(\n  obj: T,\n  recursive = true,\n): DeepNonUndefined<T> | ShallowNonUndefined<T> {\n  const result = {} as DeepNonUndefined<T> | ShallowNonUndefined<T>;\n\n  for (const [key, value] of Object.entries(obj)) {\n    if (value !== undefined) {\n      // recursively process nested objects\n      if (recursive && value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {\n        (result as Record<string, unknown>)[key] = omitUndefined(value as Record<string, unknown>, recursive);\n      } else if (recursive && Array.isArray(value)) {\n        // recursively process arrays\n        (result as Record<string, unknown>)[key] = value\n          .filter((item) => item !== undefined)\n          .map((item) => {\n            if (item && typeof item === 'object' && !Array.isArray(item) && !(item instanceof Date)) {\n              return omitUndefined(item as Record<string, unknown>, recursive);\n            }\n            return item;\n          });\n      } else {\n        // handle primitive values\n        (result as Record<string, unknown>)[key] = value;\n      }\n    }\n  }\n\n  return result;\n}\n","export function optionalize<T, U, D = undefined>(\n  fn: (v: T) => U,\n  options?: { defaultValue?: D | undefined; strategy?: 'falsy' | 'nullish' | undefined } | undefined,\n): (v: T | null | undefined) => U | D {\n  const defaultValue = options?.defaultValue;\n  const emptyMode = options?.strategy ?? 'nullish';\n\n  return (v: T | null | undefined): U | D => {\n    if (v === null || v === undefined || (emptyMode === 'falsy' && !v)) {\n      return defaultValue as D;\n    }\n\n    return fn(v);\n  };\n}\n","import { sleep } from './sleep';\n\nexport type RetryOptions = {\n  /** total number of attempts before the last error is rethrown (default 3) */\n  retries?: number | undefined;\n\n  /** fixed delay between attempts (default 1000) */\n  delayMs?: number | undefined;\n\n  /** aborts the delay between attempts */\n  signal?: AbortSignal | undefined;\n\n  /** called after every failed attempt with the error and the 1-based attempt number */\n  onError?: ((error: unknown, attempt: number) => void) | undefined;\n};\n\n/**\n * Runs `fn`, retrying with a fixed delay on failure. Resolves with the first successful result;\n * rethrows the last error once the attempts are exhausted.\n */\nexport async function retry<T>(fn: () => T, options?: RetryOptions | undefined): Promise<T> {\n  const retries = options?.retries ?? 3;\n  const delayMs = options?.delayMs ?? 1000;\n\n  for (let attempt = 1; ; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      options?.onError?.(error, attempt);\n\n      if (attempt >= retries) {\n        throw error;\n      }\n\n      await sleep(delayMs, options?.signal);\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/match.d.ts

@@ -0,0 +1,32 @@
+//#region src/match/index.d.ts
+type StringPattern = ((value: string) => boolean) | {
+  exact: string;
+} | {
+  prefix: string;
+} | {
+  suffix: string;
+} | {
+  includes: string;
+} | {
+  pattern: RegExp;
+};
+/**
+ * Checks if a string matches a single pattern.
+ */
+declare function matches(value: string, pattern: StringPattern): boolean;
+/**
+ * Checks if a string matches any of the patterns.
+ * For repeated matching against the same pattern set, prefer {@link createMatcher}.
+ */
+declare function matchesAny(value: string, patterns: readonly StringPattern[]): boolean;
+/**
+ * Compiles a pattern set into a matcher function.
+ *
+ * Patterns are bucketed by check cost at creation time: all `exact` patterns collapse
+ * into a single Set lookup, then prefixes / suffixes / substrings run as cheap string
+ * checks, and regular expressions and matcher functions run last.
+ */
+declare function createMatcher(patterns: readonly StringPattern[]): (value: string) => boolean;
+//#endregion
+export { StringPattern, createMatcher, matches, matchesAny };
+//# sourceMappingURL=match.d.ts.map

package/dist/match.js

@@ -0,0 +1,48 @@
+//#region src/match/index.ts
+/**
+* Checks if a string matches a single pattern.
+*/
+function matches(value, pattern) {
+	if (typeof pattern === "function") return pattern(value);
+	if ("exact" in pattern) return value === pattern.exact;
+	if ("prefix" in pattern) return value.startsWith(pattern.prefix);
+	if ("suffix" in pattern) return value.endsWith(pattern.suffix);
+	if ("includes" in pattern) return value.includes(pattern.includes);
+	return pattern.pattern.test(value);
+}
+/**
+* Checks if a string matches any of the patterns.
+* For repeated matching against the same pattern set, prefer {@link createMatcher}.
+*/
+function matchesAny(value, patterns) {
+	return patterns.some((pattern) => matches(value, pattern));
+}
+/**
+* Compiles a pattern set into a matcher function.
+*
+* Patterns are bucketed by check cost at creation time: all `exact` patterns collapse
+* into a single Set lookup, then prefixes / suffixes / substrings run as cheap string
+* checks, and regular expressions and matcher functions run last.
+*/
+function createMatcher(patterns) {
+	const exacts = /* @__PURE__ */ new Set();
+	const prefixes = [];
+	const suffixes = [];
+	const substrings = [];
+	const regexps = [];
+	const fns = [];
+	for (const pattern of patterns) if (typeof pattern === "function") fns.push(pattern);
+	else if ("exact" in pattern) exacts.add(pattern.exact);
+	else if ("prefix" in pattern) prefixes.push(pattern.prefix);
+	else if ("suffix" in pattern) suffixes.push(pattern.suffix);
+	else if ("includes" in pattern) substrings.push(pattern.includes);
+	else regexps.push(pattern.pattern);
+	return (value) => {
+		if (exacts.has(value)) return true;
+		return prefixes.some((prefix) => value.startsWith(prefix)) || suffixes.some((suffix) => value.endsWith(suffix)) || substrings.some((substring) => value.includes(substring)) || regexps.some((regexp) => regexp.test(value)) || fns.some((fn) => fn(value));
+	};
+}
+//#endregion
+export { createMatcher, matches, matchesAny };
+
+//# sourceMappingURL=match.js.map

package/dist/match.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match.js","names":[],"sources":["../src/match/index.ts"],"sourcesContent":["export type StringPattern =\n  | ((value: string) => boolean)\n  | { exact: string }\n  | { prefix: string }\n  | { suffix: string }\n  | { includes: string }\n  | { pattern: RegExp };\n\n/**\n * Checks if a string matches a single pattern.\n */\nexport function matches(value: string, pattern: StringPattern): boolean {\n  if (typeof pattern === 'function') {\n    return pattern(value);\n  }\n\n  if ('exact' in pattern) {\n    return value === pattern.exact;\n  }\n\n  if ('prefix' in pattern) {\n    return value.startsWith(pattern.prefix);\n  }\n\n  if ('suffix' in pattern) {\n    return value.endsWith(pattern.suffix);\n  }\n\n  if ('includes' in pattern) {\n    return value.includes(pattern.includes);\n  }\n\n  return pattern.pattern.test(value);\n}\n\n/**\n * Checks if a string matches any of the patterns.\n * For repeated matching against the same pattern set, prefer {@link createMatcher}.\n */\nexport function matchesAny(value: string, patterns: readonly StringPattern[]): boolean {\n  return patterns.some((pattern) => matches(value, pattern));\n}\n\n/**\n * Compiles a pattern set into a matcher function.\n *\n * Patterns are bucketed by check cost at creation time: all `exact` patterns collapse\n * into a single Set lookup, then prefixes / suffixes / substrings run as cheap string\n * checks, and regular expressions and matcher functions run last.\n */\nexport function createMatcher(patterns: readonly StringPattern[]): (value: string) => boolean {\n  const exacts = new Set<string>();\n  const prefixes: string[] = [];\n  const suffixes: string[] = [];\n  const substrings: string[] = [];\n  const regexps: RegExp[] = [];\n  const fns: ((value: string) => boolean)[] = [];\n\n  for (const pattern of patterns) {\n    if (typeof pattern === 'function') {\n      fns.push(pattern);\n    } else if ('exact' in pattern) {\n      exacts.add(pattern.exact);\n    } else if ('prefix' in pattern) {\n      prefixes.push(pattern.prefix);\n    } else if ('suffix' in pattern) {\n      suffixes.push(pattern.suffix);\n    } else if ('includes' in pattern) {\n      substrings.push(pattern.includes);\n    } else {\n      regexps.push(pattern.pattern);\n    }\n  }\n\n  return (value) => {\n    if (exacts.has(value)) {\n      return true;\n    }\n\n    return (\n      prefixes.some((prefix) => value.startsWith(prefix)) ||\n      suffixes.some((suffix) => value.endsWith(suffix)) ||\n      substrings.some((substring) => value.includes(substring)) ||\n      regexps.some((regexp) => regexp.test(value)) ||\n      fns.some((fn) => fn(value))\n    );\n  };\n}\n"],"mappings":";;;;AAWA,SAAgB,QAAQ,OAAe,SAAiC;CACtE,IAAI,OAAO,YAAY,YACrB,OAAO,QAAQ,KAAK;CAGtB,IAAI,WAAW,SACb,OAAO,UAAU,QAAQ;CAG3B,IAAI,YAAY,SACd,OAAO,MAAM,WAAW,QAAQ,MAAM;CAGxC,IAAI,YAAY,SACd,OAAO,MAAM,SAAS,QAAQ,MAAM;CAGtC,IAAI,cAAc,SAChB,OAAO,MAAM,SAAS,QAAQ,QAAQ;CAGxC,OAAO,QAAQ,QAAQ,KAAK,KAAK;AACnC;;;;;AAMA,SAAgB,WAAW,OAAe,UAA6C;CACrF,OAAO,SAAS,MAAM,YAAY,QAAQ,OAAO,OAAO,CAAC;AAC3D;;;;;;;;AASA,SAAgB,cAAc,UAAgE;CAC5F,MAAM,yBAAS,IAAI,IAAY;CAC/B,MAAM,WAAqB,CAAC;CAC5B,MAAM,WAAqB,CAAC;CAC5B,MAAM,aAAuB,CAAC;CAC9B,MAAM,UAAoB,CAAC;CAC3B,MAAM,MAAsC,CAAC;CAE7C,KAAK,MAAM,WAAW,UACpB,IAAI,OAAO,YAAY,YACrB,IAAI,KAAK,OAAO;MACX,IAAI,WAAW,SACpB,OAAO,IAAI,QAAQ,KAAK;MACnB,IAAI,YAAY,SACrB,SAAS,KAAK,QAAQ,MAAM;MACvB,IAAI,YAAY,SACrB,SAAS,KAAK,QAAQ,MAAM;MACvB,IAAI,cAAc,SACvB,WAAW,KAAK,QAAQ,QAAQ;MAEhC,QAAQ,KAAK,QAAQ,OAAO;CAIhC,QAAQ,UAAU;EAChB,IAAI,OAAO,IAAI,KAAK,GAClB,OAAO;EAGT,OACE,SAAS,MAAM,WAAW,MAAM,WAAW,MAAM,CAAC,KAClD,SAAS,MAAM,WAAW,MAAM,SAAS,MAAM,CAAC,KAChD,WAAW,MAAM,cAAc,MAAM,SAAS,SAAS,CAAC,KACxD,QAAQ,MAAM,WAAW,OAAO,KAAK,KAAK,CAAC,KAC3C,IAAI,MAAM,OAAO,GAAG,KAAK,CAAC;CAE9B;AACF"}

package/dist/react.d.ts

@@ -0,0 +1,28 @@
+import { DependencyList, EffectCallback } from "react";
+//#region src/react/use-debounced-value.d.ts
+/**
+ * Returns the value, updated only after it has stayed unchanged for the given delay.
+ */
+declare function useDebouncedValue<T>(value: T, delay: number): T;
+//#endregion
+//#region src/react/use-effect-after-mount.d.ts
+/**
+ * Runs the effect on dependency changes, but skips the initial mount.
+ */
+declare function useEffectAfterMount(effect: EffectCallback, deps?: DependencyList | undefined): void;
+//#endregion
+//#region src/react/use-effect-once.d.ts
+/**
+ * Runs the effect exactly once on mount.
+ */
+declare function useEffectOnce(effect: EffectCallback): void;
+//#endregion
+//#region src/react/use-is-mobile.d.ts
+/**
+ * Tracks whether the viewport is below the mobile breakpoint (768px).
+ * Returns false during SSR.
+ */
+declare function useIsMobile(): boolean;
+//#endregion
+export { useDebouncedValue, useEffectAfterMount, useEffectOnce, useIsMobile };
+//# sourceMappingURL=react.d.ts.map

package/dist/react.js

@@ -0,0 +1,62 @@
+import { useEffect, useRef, useState, useSyncExternalStore } from "react";
+//#region src/react/use-debounced-value.ts
+/**
+* Returns the value, updated only after it has stayed unchanged for the given delay.
+*/
+function useDebouncedValue(value, delay) {
+	const [debouncedValue, setDebouncedValue] = useState(value);
+	useEffect(() => {
+		const timeout = setTimeout(() => {
+			setDebouncedValue(value);
+		}, delay);
+		return () => clearTimeout(timeout);
+	}, [value, delay]);
+	return debouncedValue;
+}
+//#endregion
+//#region src/react/use-effect-after-mount.ts
+/**
+* Runs the effect on dependency changes, but skips the initial mount.
+*/
+function useEffectAfterMount(effect, deps) {
+	const mountedRef = useRef(false);
+	useEffect(() => {
+		if (mountedRef.current) return effect();
+		mountedRef.current = true;
+	}, deps);
+}
+//#endregion
+//#region src/react/use-effect-once.ts
+/**
+* Runs the effect exactly once on mount.
+*/
+function useEffectOnce(effect) {
+	const hasRunRef = useRef(false);
+	useEffect(() => {
+		if (hasRunRef.current) return;
+		hasRunRef.current = true;
+		return effect();
+	}, []);
+}
+//#endregion
+//#region src/react/use-is-mobile.ts
+const MOBILE_BREAKPOINT = 768;
+function subscribe(callback) {
+	const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+	mql.addEventListener("change", callback);
+	return () => mql.removeEventListener("change", callback);
+}
+function getSnapshot() {
+	return window.innerWidth < MOBILE_BREAKPOINT;
+}
+/**
+* Tracks whether the viewport is below the mobile breakpoint (768px).
+* Returns false during SSR.
+*/
+function useIsMobile() {
+	return useSyncExternalStore(subscribe, getSnapshot, () => false);
+}
+//#endregion
+export { useDebouncedValue, useEffectAfterMount, useEffectOnce, useIsMobile };
+
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":[],"sources":["../src/react/use-debounced-value.ts","../src/react/use-effect-after-mount.ts","../src/react/use-effect-once.ts","../src/react/use-is-mobile.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\n/**\n * Returns the value, updated only after it has stayed unchanged for the given delay.\n */\nexport function useDebouncedValue<T>(value: T, delay: number): T {\n  const [debouncedValue, setDebouncedValue] = useState(value);\n\n  useEffect(() => {\n    const timeout = setTimeout(() => {\n      setDebouncedValue(value);\n    }, delay);\n\n    return () => clearTimeout(timeout);\n  }, [value, delay]);\n\n  return debouncedValue;\n}\n","import { type DependencyList, type EffectCallback, useEffect, useRef } from 'react';\n\n/**\n * Runs the effect on dependency changes, but skips the initial mount.\n */\nexport function useEffectAfterMount(effect: EffectCallback, deps?: DependencyList | undefined) {\n  const mountedRef = useRef(false);\n\n  useEffect(() => {\n    if (mountedRef.current) {\n      return effect();\n    }\n    mountedRef.current = true;\n  }, deps); // eslint-disable-line @eslint-react/exhaustive-deps\n}\n","import { type EffectCallback, useEffect, useRef } from 'react';\n\n/**\n * Runs the effect exactly once on mount.\n */\nexport function useEffectOnce(effect: EffectCallback) {\n  const hasRunRef = useRef(false);\n\n  useEffect(() => {\n    if (hasRunRef.current) {\n      return;\n    }\n\n    hasRunRef.current = true;\n\n    return effect();\n  }, []); // eslint-disable-line @eslint-react/exhaustive-deps\n}\n","import { useSyncExternalStore } from 'react';\n\nconst MOBILE_BREAKPOINT = 768;\n\nfunction subscribe(callback: () => void): () => void {\n  const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);\n\n  mql.addEventListener('change', callback);\n\n  return () => mql.removeEventListener('change', callback);\n}\n\nfunction getSnapshot(): boolean {\n  return window.innerWidth < MOBILE_BREAKPOINT;\n}\n\n/**\n * Tracks whether the viewport is below the mobile breakpoint (768px).\n * Returns false during SSR.\n */\nexport function useIsMobile(): boolean {\n  return useSyncExternalStore(subscribe, getSnapshot, () => false);\n}\n"],"mappings":";;;;;AAKA,SAAgB,kBAAqB,OAAU,OAAkB;CAC/D,MAAM,CAAC,gBAAgB,qBAAqB,SAAS,KAAK;CAE1D,gBAAgB;EACd,MAAM,UAAU,iBAAiB;GAC/B,kBAAkB,KAAK;EACzB,GAAG,KAAK;EAER,aAAa,aAAa,OAAO;CACnC,GAAG,CAAC,OAAO,KAAK,CAAC;CAEjB,OAAO;AACT;;;;;;ACZA,SAAgB,oBAAoB,QAAwB,MAAmC;CAC7F,MAAM,aAAa,OAAO,KAAK;CAE/B,gBAAgB;EACd,IAAI,WAAW,SACb,OAAO,OAAO;EAEhB,WAAW,UAAU;CACvB,GAAG,IAAI;AACT;;;;;;ACTA,SAAgB,cAAc,QAAwB;CACpD,MAAM,YAAY,OAAO,KAAK;CAE9B,gBAAgB;EACd,IAAI,UAAU,SACZ;EAGF,UAAU,UAAU;EAEpB,OAAO,OAAO;CAChB,GAAG,CAAC,CAAC;AACP;;;ACfA,MAAM,oBAAoB;AAE1B,SAAS,UAAU,UAAkC;CACnD,MAAM,MAAM,OAAO,WAAW,eAAe,oBAAoB,EAAE,IAAI;CAEvE,IAAI,iBAAiB,UAAU,QAAQ;CAEvC,aAAa,IAAI,oBAAoB,UAAU,QAAQ;AACzD;AAEA,SAAS,cAAuB;CAC9B,OAAO,OAAO,aAAa;AAC7B;;;;;AAMA,SAAgB,cAAuB;CACrC,OAAO,qBAAqB,WAAW,mBAAmB,KAAK;AACjE"}

package/dist/sleep-J71HYu7n.js

@@ -0,0 +1,19 @@
+//#region src/core/sleep.ts
+function sleep(ms, signal) {
+	if (signal?.aborted) return Promise.reject(signal.reason);
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(signal.reason);
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+//#endregion
+export { sleep as t };
+
+//# sourceMappingURL=sleep-J71HYu7n.js.map

package/dist/sleep-J71HYu7n.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep-J71HYu7n.js","names":[],"sources":["../src/core/sleep.ts"],"sourcesContent":["export function sleep(ms: number, signal?: AbortSignal | undefined): Promise<void> {\n  if (signal?.aborted) {\n    return Promise.reject(signal.reason);\n  }\n\n  return new Promise((resolve, reject) => {\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort);\n      resolve();\n    }, ms);\n\n    const onAbort = () => {\n      clearTimeout(timer);\n      reject(signal!.reason);\n    };\n\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n"],"mappings":";AAAA,SAAgB,MAAM,IAAY,QAAiD;CACjF,IAAI,QAAQ,SACV,OAAO,QAAQ,OAAO,OAAO,MAAM;CAGrC,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,QAAQ,iBAAiB;GAC7B,QAAQ,oBAAoB,SAAS,OAAO;GAC5C,QAAQ;EACV,GAAG,EAAE;EAEL,MAAM,gBAAgB;GACpB,aAAa,KAAK;GAClB,OAAO,OAAQ,MAAM;EACvB;EAEA,QAAQ,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;CAC3D,CAAC;AACH"}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@entwico/dash",
+  "version": "1.0.0",
+  "description": "Typical reusable utilities shared across projects. Tree-shakable, ESM-only, zero-dependency core.",
+  "type": "module",
+  "sideEffects": false,
+  "author": "admin@entwico.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/entwico/dash"
+  },
+  "scripts": {
+    "start": "tsdown --watch",
+    "build": "tsdown",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "clear": "rm -rf dist",
+    "lint": "eslint --cache src",
+    "lint:fix": "pnpm lint --fix",
+    "typecheck": "tsc --noEmit",
+    "validate": "pnpm lint && pnpm typecheck && pnpm coverage",
+    "prepublishOnly": "pnpm build",
+    "ci:version": "changeset version && pnpm install --no-frozen-lockfile",
+    "ci:publish": "changeset publish"
+  },
+  "peerDependencies": {
+    "clsx": ">=2",
+    "react": ">=18",
+    "tailwind-merge": ">=2"
+  },
+  "peerDependenciesMeta": {
+    "clsx": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "tailwind-merge": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@changesets/cli": "^2.31.0",
+    "@entwico/eslint-config": "^2.0.7",
+    "@types/node": "^26.1.1",
+    "@types/react": "^19.2.17",
+    "@vitest/coverage-istanbul": "^4.1.10",
+    "clsx": "^2.1.1",
+    "eslint": "^10.6.0",
+    "react": "^19.2.7",
+    "tailwind-merge": "^3.6.0",
+    "tsdown": "^0.22.4",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.10"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./async": {
+      "types": "./dist/async.d.ts",
+      "import": "./dist/async.js"
+    },
+    "./match": {
+      "types": "./dist/match.d.ts",
+      "import": "./dist/match.js"
+    },
+    "./cn": {
+      "types": "./dist/cn.d.ts",
+      "import": "./dist/cn.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "packageManager": "pnpm@11.1.3"
+}