@wow-two-beta/ui-vue 0.0.4 → 0.0.6

package/dist/foundation/media/MediaStreamResult.d.ts

@@ -1,45 +0,0 @@
-/**
- * The outcome of a capture attempt. Six arms because a camera prompt has six meaningfully different endings,
- * each wanting different UI copy and a different next step.
- *
- * - `granted` — the user allowed it; `stream` is live and the caller now OWNS it (see `stopMediaStream`).
- * - `denied` — the user pressed Block, or a prior block is being replayed without a prompt. Not retryable
- *   without a browser-settings change, so re-prompting on a timer only annoys.
- * - `unavailable` — no device matches the request. A laptop with no webcam, or an unplugged USB mic.
- * - `in-use` — the device exists but another application (or another tab) holds it. Retryable once freed.
- * - `unsupported` — no API here at all: SSR, an insecure context, an older browser. See `getMediaSupport` for
- *   which of those it is.
- * - `failed` — anything else, carrying the normalized `Error`.
- */
-export type MediaStreamResult = {
-    readonly status: 'granted';
-    readonly stream: MediaStream;
-} | {
-    readonly status: 'denied';
-} | {
-    readonly status: 'unavailable';
-} | {
-    readonly status: 'in-use';
-} | {
-    readonly status: 'unsupported';
-} | {
-    readonly status: 'failed';
-    readonly error: Error;
-};
-/** The `status` discriminant of a {@link MediaStreamResult} — for a consumer's own switch or status→copy map. */
-export type MediaStreamStatus = MediaStreamResult['status'];
-/** Every {@link MediaStreamResult} arm except the successful one — what a rejected `getUserMedia` can become. */
-export type MediaStreamFailure = Exclude<MediaStreamResult, {
-    status: 'granted';
-}>;
-/**
- * Classifies a rejected `getUserMedia` into its {@link MediaStreamFailure}.
- *
- * Exported for the sibling request modules and their tests; absent from the barrel, where the request functions
- * are the surface a consumer wants. Never throws — an unrecognized name falls through to `failed` with the value
- * normalized by `foundation/errors`' `toError`, so even a thrown `null` arrives as a real `Error`.
- *
- * @param cause The value `getUserMedia` rejected (or threw) with.
- * @returns The matching failure arm.
- */
-export declare function toMediaStreamFailure(cause: unknown): MediaStreamFailure;

package/dist/foundation/net/UseEventStream.d.ts

@@ -1,25 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { ConnectionState } from './ConnectionState';
-import { EventStreamOptions, EventStreamPayloads } from './CreateEventStream';
-/** The live view a scope gets over its stream. */
-export interface EventStreamHandle {
-    /** The current connection state, updating on every transition. */
-    readonly readyState: Readonly<ShallowRef<ConnectionState>>;
-    /** Whether `EventSource` exists in this runtime; `false` under SSR and in a locked-down browser. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /** Closes the stream early. The scope-disposal cleanup calls it anyway. */
-    readonly close: () => void;
-}
-/**
- * Opens a Server-Sent Events stream for the lifetime of the scope.
- *
- * The stream is closed when the scope is disposed and re-opened whenever `url` changes. Pass `null` to hold
- * off connecting (waiting for auth, a route param, a feature flag) — a ref or getter is how that flips.
- *
- * @typeParam TEvents - Maps each server event name to its payload type.
- * @param url - The stream endpoint, or `null` to stay disconnected.
- * @param options - Handlers and configuration, read once when the stream opens; handler callbacks are re-read
- *   per event, so a ref or getter keeps them live.
- * @returns The connection state, support flag, and `close`.
- */
-export declare function useEventStream<TEvents extends EventStreamPayloads = EventStreamPayloads>(url: MaybeRefOrGetter<string | null>, options?: MaybeRefOrGetter<EventStreamOptions<TEvents>>): EventStreamHandle;

package/dist/foundation/net/UsePolling.d.ts

@@ -1,26 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { PollerState, PollFn, PollerOptions } from './CreatePoller';
-/** The live view a scope gets over its poll loop. */
-export interface PollingHandle {
-    /** The current poller state, updating on every transition. `paused` covers manual, hidden, and offline. */
-    readonly state: Readonly<ShallowRef<PollerState>>;
-    /** Suspends polling until `resume()`. */
-    readonly pause: () => void;
-    /** Clears the manual suspension; polling stays suspended if the tab is hidden or the browser offline. */
-    readonly resume: () => void;
-    /** Stops the loop and detaches its listeners. The scope-disposal cleanup calls it anyway. */
-    readonly stop: () => void;
-}
-/**
- * Runs `fn` on an interval for the lifetime of the scope, suspended automatically while the tab is hidden or
- * the browser is offline.
- *
- * The loop stops when the scope is disposed and is rebuilt whenever `intervalMs` changes. `fn` is read fresh
- * on each tick, so a getter whose target changes needs no rebuild.
- *
- * @param fn - The work to repeat; a returned promise is awaited before the next tick is scheduled.
- * @param options - Interval and suspension behaviour, read once when the loop is built; handler callbacks are
- *   re-read per emission, so a ref or getter keeps them live.
- * @returns The poller state and `pause` / `resume` / `stop`.
- */
-export declare function usePolling(fn: MaybeRefOrGetter<PollFn>, options?: MaybeRefOrGetter<PollerOptions>): PollingHandle;

package/dist/foundation/net/UseSocket.d.ts

@@ -1,32 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { ConnectionState } from './ConnectionState';
-import { SocketClientOptions } from './CreateSocketClient';
-/** The live view a scope gets over its socket. */
-export interface SocketHandle<TOut> {
-    /** The current connection state, updating on every transition. */
-    readonly readyState: Readonly<ShallowRef<ConnectionState>>;
-    /** Whether `WebSocket` exists in this runtime; `false` under SSR. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /**
-     * Sends a message, queueing it while the socket is still connecting.
-     *
-     * @returns `true` when the frame went out immediately, `false` when queued, dropped, or disposed.
-     */
-    readonly send: (message: TOut) => boolean;
-    /** Closes the socket early and suppresses reconnection. The scope-disposal cleanup calls it anyway. */
-    readonly close: () => void;
-}
-/**
- * Opens a JSON WebSocket for the lifetime of the scope.
- *
- * The socket is closed when the scope is disposed and re-opened whenever `url` changes. Pass `null` to hold
- * off connecting (waiting for auth, a route param, a feature flag) — a ref or getter is how that flips.
- *
- * @typeParam TIn - The decoded inbound message type.
- * @typeParam TOut - The outbound message type.
- * @param url - The socket endpoint, or `null` to stay disconnected.
- * @param options - Handlers and configuration, read once when the socket opens; handler callbacks are re-read
- *   per message, so a ref or getter keeps them live.
- * @returns The connection state, support flag, and `send` / `close`.
- */
-export declare function useSocket<TIn = unknown, TOut = unknown>(url: MaybeRefOrGetter<string | null>, options?: MaybeRefOrGetter<SocketClientOptions<TIn, TOut>>): SocketHandle<TOut>;

package/dist/foundation/notifications/UseNotificationPermission.d.ts

@@ -1,27 +0,0 @@
-import { ComputedRef, ShallowRef } from 'vue';
-import { NotificationPermissionState } from './NotificationPermission';
-/** What {@link useNotificationPermission} returns. */
-export interface NotificationPermissionControls {
-    /** The current grant. `unsupported` during SSR and until mount, then the real value. */
-    readonly permission: Readonly<ShallowRef<NotificationPermissionState>>;
-    /** Convenience for `permission === 'granted'` — the gate a `notify` call sits behind. */
-    readonly granted: ComputedRef<boolean>;
-    /** Whether the Notification API exists at all: `false` only for `unsupported`. Hide the feature when false. */
-    readonly supported: ComputedRef<boolean>;
-    /** Whether a prompt is worth offering — `permission === 'default'`. False once the user has decided either way. */
-    readonly requestable: ComputedRef<boolean>;
-    /** Whether a {@link NotificationPermissionControls.request} call is in flight — the button's disabled flag. */
-    readonly requesting: Readonly<ShallowRef<boolean>>;
-    /**
-     * Prompts for the grant and resolves to the resulting state, which is also written to
-     * {@link NotificationPermissionControls.permission}. Never throws, never rejects.
-     */
-    readonly request: () => Promise<NotificationPermissionState>;
-}
-/**
- * Exposes the notification grant as reactive state, with a `request()` that prompts for it.
- *
- * Updates when the grant changes — on request, and (where the Permissions API is available) on an external
- * grant or revoke. Inherits the module's never-throws contract: `request` resolves to a state, never rejects.
- */
-export declare function useNotificationPermission(): NotificationPermissionControls;

package/dist/foundation/notifications/UsePermissionState.d.ts

@@ -1,14 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { PermissionQueryName, PermissionQueryState } from './QueryPermission';
-/**
- * Follows a permission's state reactively, updating when the user grants or revokes it — including from
- * the browser's own site settings or another tab.
- *
- * Holds `null` while the first query is in flight (and during SSR), then a {@link PermissionQueryState}.
- * Changing `name` resets to `null` and re-queries. Never throws.
- *
- * @param name The permission to follow — `'notifications'`, `'geolocation'`, `'camera'`, … A ref or getter
- *   re-queries when it changes.
- * @returns The current state, or `null` before the first answer.
- */
-export declare function usePermissionState(name: MaybeRefOrGetter<PermissionQueryName>): Readonly<ShallowRef<PermissionQueryState | null>>;

package/dist/foundation/observers/UseInView.d.ts

@@ -1,41 +0,0 @@
-import { ComputedRef, MaybeRefOrGetter } from 'vue';
-import { IntersectionOptions } from './ObserveIntersection';
-/** Root/margin/threshold plus the lifecycle knobs the composable adds. */
-export interface UseInViewOptions extends IntersectionOptions {
-    /**
-     * Stop observing permanently after the first intersection. The state stays `true` from then on, even if the
-     * element scrolls away or `target` is later pointed at a different node. Use for anything that should happen
-     * once — lazy loads, entrance animations, "seen" analytics.
-     */
-    readonly once?: boolean;
-    /** Suspend observation without tearing down. Flipping it back re-observes the current target. */
-    readonly disabled?: boolean;
-    /**
-     * What `inView` reports when `IntersectionObserver` does not exist in this environment. Defaults to `true`
-     * (fail open — show the content). Set `false` only when hidden is the safer wrong answer.
-     */
-    readonly fallbackInView?: boolean;
-}
-/** What `useInView` returns. */
-export interface InViewState {
-    /** Whether the element currently meets the threshold. */
-    readonly inView: ComputedRef<boolean>;
-    /**
-     * The entry behind the current value — `intersectionRatio`, `boundingClientRect`, `time`. `null` before the
-     * observer's first callback and whenever the API is unavailable.
-     */
-    readonly entry: ComputedRef<IntersectionObserverEntry | null>;
-}
-/**
- * Tracks whether the element behind `target` is intersecting the root.
- *
- * Takes the element as a ref or getter rather than handing one back, so the caller keeps ownership of its
- * `useTemplateRef`. The first callback arrives asynchronously (a frame or so after mount), so `inView` is
- * `false` on the very first read even for an element sitting in the middle of the viewport — assert against it
- * with `waitFor`, never synchronously.
- *
- * @param target Points at the element to watch. Changing it re-observes.
- * @param options Root, margin, threshold, plus `once` / `disabled` / `fallbackInView`.
- * @returns `{ inView, entry }`, updating only when `isIntersecting` or `intersectionRatio` actually changes.
- */
-export declare function useInView<T extends Element>(target: MaybeRefOrGetter<T | null | undefined>, options?: MaybeRefOrGetter<UseInViewOptions | undefined>): InViewState;

package/dist/foundation/observers/UseIntersectionObserver.d.ts

@@ -1,18 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { IntersectionOptions } from './ObserveIntersection';
-/** Root/margin/threshold plus the one lifecycle knob that makes sense for a shared observer. */
-export interface UseIntersectionObserverOptions extends IntersectionOptions {
-    /** Suspend observation of every target without tearing down. Flipping it back re-observes them all. */
-    readonly disabled?: boolean;
-}
-/**
- * Observes many elements through a single `IntersectionObserver`.
- *
- * The callback fires once per entry, and `entry.target` identifies which element it belongs to — the usual
- * consumer keeps a `Map` from element to row id, or compares against its own refs.
- *
- * @param targets The elements to observe, as a ref or getter over the list. Nulls are skipped.
- * @param callback Receives each entry plus the shared observer.
- * @param options Root, margin, threshold, `disabled`.
- */
-export declare function useIntersectionObserver(targets: MaybeRefOrGetter<readonly (Element | null | undefined)[]>, callback: (entry: IntersectionObserverEntry, observer: IntersectionObserver) => void, options?: MaybeRefOrGetter<UseIntersectionObserverOptions | undefined>): void;

package/dist/foundation/observers/UseMutationObserver.d.ts

@@ -1,21 +0,0 @@
-import { MaybeRefOrGetter } from 'vue';
-import { MutationOptions } from './ObserveMutation';
-/** The `MutationObserverInit` flags plus the one lifecycle knob. */
-export interface UseMutationObserverOptions extends MutationOptions {
-    /** Suspend observation without tearing down. Flipping it back re-subscribes to the current node. */
-    readonly disabled?: boolean;
-}
-/**
- * Runs `callback` whenever the node behind `target` mutates.
- *
- * With no options, watches `childList` — additions and removals of direct children. Add `subtree: true` to
- * extend that (and every other flag) to descendants.
- *
- * Takes the node as a ref or getter rather than handing one back. Records describe what ALREADY happened; the
- * DOM is in its post-mutation state by the time the callback runs.
- *
- * @param target Points at the node to watch. Changing it re-subscribes.
- * @param callback Receives the batch of records plus the observer, so a caller can disconnect from inside.
- * @param options Which mutation kinds to report, plus `disabled`.
- */
-export declare function useMutationObserver<T extends Node>(target: MaybeRefOrGetter<T | null | undefined>, callback: (records: readonly MutationRecord[], observer: MutationObserver) => void, options?: MaybeRefOrGetter<UseMutationObserverOptions | undefined>): void;

package/dist/foundation/screen/ScreenResult.d.ts

@@ -1,38 +0,0 @@
-/**
- * The non-success half of {@link ScreenResult}, shared by the value-carrying and void variants.
- *
- * - `unsupported` — the API is absent: SSR, an older browser, or a platform that cannot honour the request at
- *   all. Carries no error because no call was made. Hide the affordance rather than disabling it.
- * - `denied` — the API exists and the platform refused. A permissions policy, an OS-level block, or a
- *   precondition the caller cannot satisfy. Not retryable by repeating the same call.
- * - `requires-gesture` — the call was made outside a user gesture (transient activation). Retryable: move it
- *   into a `click` / `keydown` handler. Its own status precisely because the fix is mechanical.
- * - `failed` — anything else, carrying the normalized `Error`.
- */
-export type ScreenFailure = {
-    readonly status: 'unsupported';
-} | {
-    readonly status: 'denied';
-    readonly error: Error;
-} | {
-    readonly status: 'requires-gesture';
-    readonly error: Error;
-} | {
-    readonly status: 'failed';
-    readonly error: Error;
-};
-/** The outcome of a screen action that yields nothing on success — entering fullscreen, unlocking orientation. */
-export type ScreenResult = {
-    readonly status: 'ok';
-} | ScreenFailure;
-/**
- * The outcome of a screen action that yields a `TValue` on success — the wake-lock handle, today's only case.
- * The failure legs are identical to {@link ScreenResult}'s, so `result.status === 'ok'` narrows to the value and
- * every other branch reads the same as it does elsewhere in the slice.
- */
-export type ScreenValueResult<TValue> = {
-    readonly status: 'ok';
-    readonly value: TValue;
-} | ScreenFailure;
-/** The `status` discriminant of a {@link ScreenResult} — for a consumer's own status→copy map. */
-export type ScreenStatus = ScreenResult['status'];

package/dist/foundation/screen/UseFullscreen.d.ts

@@ -1,28 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { ScreenResult } from './ScreenResult';
-/** What {@link useFullscreen} returns. */
-export interface FullscreenControls {
-    /** Whether anything is currently presented fullscreen — including a transition this composable did not initiate. */
-    readonly isFullscreen: Readonly<ShallowRef<boolean>>;
-    /** Whether the Fullscreen API is present. `false` under SSR; render the control only once this is `true`. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /** Presents the composable's target fullscreen. Call from a user gesture. Resolves to the result; never throws. */
-    readonly enter: () => Promise<ScreenResult>;
-    /** Leaves fullscreen. Resolves to `ok` when nothing was presented. Never throws. */
-    readonly exit: () => Promise<ScreenResult>;
-    /** Exits when presented, enters otherwise. Call from a user gesture. Never throws. */
-    readonly toggle: () => Promise<ScreenResult>;
-}
-/**
- * Tracks fullscreen state and exposes the three actions against an optional target.
- *
- * Pass `target` to present one element (a video, a canvas, a dashboard panel); omit it to present the whole
- * document. Takes the element as a ref or getter rather than handing one back, so a `useTemplateRef` drops
- * straight in — and it is read at call time, so it may still be `null` when the handler is wired up.
- *
- * Inherits the module's never-throws contract.
- *
- * @param target The element to present. Defaults to `document.documentElement` when omitted or still `null`.
- * @returns The current state plus the `enter` / `exit` / `toggle` actions.
- */
-export declare function useFullscreen(target?: MaybeRefOrGetter<Element | null | undefined>): FullscreenControls;

package/dist/foundation/screen/UseOrientation.d.ts

@@ -1,28 +0,0 @@
-import { ShallowRef } from 'vue';
-import { OrientationLockResult, ScreenOrientationLock, ScreenOrientationType } from './ScreenOrientation';
-import { ScreenResult } from './ScreenResult';
-/** What {@link useOrientation} returns. */
-export interface OrientationControls {
-    /** The current device orientation, or `null` under SSR and where `screen.orientation` is absent. */
-    readonly orientation: Readonly<ShallowRef<ScreenOrientationType | null>>;
-    /** The current angle in degrees relative to the device's natural orientation, or `null` when unavailable. */
-    readonly angle: Readonly<ShallowRef<number | null>>;
-    /** Whether locking is present. `false` under SSR, on desktop, and on Safari — hide the control when `false`. */
-    readonly supported: Readonly<ShallowRef<boolean>>;
-    /** Asks the device to hold an orientation. Enter fullscreen first. Resolves to the result; never throws. */
-    readonly lock: (orientation: ScreenOrientationLock) => Promise<OrientationLockResult>;
-    /** Releases the lock. Synchronous, like the platform's own `unlock()`. Never throws. */
-    readonly unlock: () => ScreenResult;
-}
-/**
- * Tracks the device orientation and exposes the lock actions.
- *
- * Use the reported orientation to adapt a layout only where a CSS media query genuinely cannot — the query is
- * cheaper and needs no JavaScript. The real reason to reach for this composable is `lock` / `unlock`, which have
- * no CSS equivalent.
- *
- * Inherits the module's never-throws contract.
- *
- * @returns The current orientation and angle plus the `lock` / `unlock` actions.
- */
-export declare function useOrientation(): OrientationControls;

package/dist/foundation/screen/UseWakeLock.d.ts

@@ -1,18 +0,0 @@
-import { MaybeRefOrGetter, ShallowRef } from 'vue';
-import { WakeLockKind, WakeLockState } from './WakeLock';
-/**
- * Holds a screen wake lock for as long as `active` resolves to `true`, re-acquiring it after every visibility
- * change.
- *
- * Drive it from whatever state means "the user is watching": a running timer, a playing video, an open recipe.
- * Flipping `active` to `false` releases; so does disposing the scope. The lock is re-acquired automatically when
- * the page returns to visible, which is the behaviour a raw `navigator.wakeLock.request` does not give you.
- *
- * Holds a defined `idle` state under SSR and on browsers without the API — check `status === 'unsupported'`
- * before offering a "keep screen awake" control.
- *
- * @param active Whether the lock should be held. A ref or getter is how it flips.
- * @param type The kind of lock. Defaults to `screen`. Changing it re-acquires.
- * @returns The current {@link WakeLockState}.
- */
-export declare function useWakeLock(active: MaybeRefOrGetter<boolean>, type?: MaybeRefOrGetter<WakeLockKind | undefined>): Readonly<ShallowRef<WakeLockState>>;

package/dist/foundation/selection/Filter.d.ts

@@ -1,71 +0,0 @@
-import { FieldAccessors, LocaleOptions } from './Field';
-/** Defines the closed set of comparisons a filter may express. */
-export declare const FilterOperator: {
-    /** Refers to exact equality — case-folded for strings, no cross-type coercion. */
-    readonly Equals: "equals";
-    /** Refers to a substring match on the value's text form. */
-    readonly Contains: "contains";
-    /** Refers to a prefix match on the value's text form. */
-    readonly StartsWith: "startsWith";
-    /** Refers to a strictly-greater-than comparison. */
-    readonly GreaterThan: "gt";
-    /** Refers to a strictly-less-than comparison. */
-    readonly LessThan: "lt";
-    /** Refers to an inclusive range check between two bounds. */
-    readonly Between: "between";
-    /** Refers to membership in a fixed list of values. */
-    readonly In: "in";
-};
-export type FilterOperator = (typeof FilterOperator)[keyof typeof FilterOperator];
-/** The fields every filter carries, whatever its operator. */
-interface FilterBase<TField extends string> {
-    /** The field name, resolved through the accessor registry or read as a plain property. */
-    readonly field: TField;
-    /** The case sensitivity of string comparison. Defaults to `false` — text operators fold case. */
-    readonly isCaseSensitive?: boolean;
-}
-/** Represents a filter whose operator takes a single comparison value. */
-export interface ValueFilter<TField extends string = string> extends FilterBase<TField> {
-    /** The comparison applied to the field. */
-    readonly op: 'equals' | 'contains' | 'startsWith' | 'gt' | 'lt';
-    /** The value compared against the field. */
-    readonly value: unknown;
-}
-/** Represents an inclusive range filter. Bounds may be given in either order. */
-export interface BetweenFilter<TField extends string = string> extends FilterBase<TField> {
-    /** The comparison applied to the field. */
-    readonly op: 'between';
-    /** The inclusive `[low, high]` bounds — normalised when reversed. */
-    readonly value: readonly [unknown, unknown];
-}
-/** Represents a membership filter over a fixed candidate list. */
-export interface InFilter<TField extends string = string> extends FilterBase<TField> {
-    /** The comparison applied to the field. */
-    readonly op: 'in';
-    /** The candidate values; the field matches when it equals any of them. */
-    readonly value: readonly unknown[];
-}
-/**
- * Represents one filter clause. A discriminated union rather than `{ field, op, value: unknown }` so the
- * value shape each operator requires — a 2-tuple for `between`, an array for `in` — is checked at the call
- * site instead of failing at match time.
- */
-export type FilterDescriptor<TField extends string = string> = ValueFilter<TField> | BetweenFilter<TField> | InFilter<TField>;
-/**
- * Reports whether one item satisfies one filter clause. Exported for the surfaces that test a single row —
- * an optimistic insert deciding whether the new row belongs in the current view, for instance.
- */
-export declare function matchesFilter<T, TField extends string = string>(item: T, filter: FilterDescriptor<TField>, accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): boolean;
-/**
- * Builds the AND-ed predicate a filter list describes — exported so a virtualised or streaming surface can
- * test rows as they arrive instead of materialising a filtered array.
- */
-export declare function filterPredicate<T, TField extends string = string>(filters: readonly FilterDescriptor<TField>[], accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): (item: T) => boolean;
-/**
- * Keeps the items matching every filter. Clauses combine with AND — two clauses on the same field narrow
- * each other (the `between` of a `gt` and an `lt`), they do not union.
- *
- * Returns the input array itself when there is nothing to filter, so an unfiltered render costs no copy.
- */
-export declare function applyFilters<T, TField extends string = string>(items: ReadonlyArray<T>, filters: readonly FilterDescriptor<TField>[], accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): ReadonlyArray<T>;
-export {};

package/dist/foundation/selection/Selection.d.ts

@@ -1,116 +0,0 @@
-/** Represents the identity of a selectable item — the value a surface keys its rows/options by. */
-export type SelectionKey = string | number;
-/** Defines how many items a surface allows to be selected at once. */
-export declare const SelectionMode: {
-    /** Refers to a non-selectable surface — every mutating op is inert. */
-    readonly None: "none";
-    /** Refers to at most one selected item — selecting replaces rather than accumulates. */
-    readonly Single: "single";
-    /** Refers to any number of selected items, including ranges. */
-    readonly Multiple: "multiple";
-};
-export type SelectionMode = (typeof SelectionMode)[keyof typeof SelectionMode];
-/** Defines the tri-state a header checkbox renders for a key set. */
-export declare const SelectionStatus: {
-    /** Refers to none of the given keys being selected — an unchecked box. */
-    readonly None: "none";
-    /** Refers to a partial selection — an indeterminate box. */
-    readonly Some: "some";
-    /** Refers to every given key being selected — a checked box. */
-    readonly All: "all";
-};
-export type SelectionStatus = (typeof SelectionStatus)[keyof typeof SelectionStatus];
-/** Represents an immutable selection snapshot. Build with {@link createSelection}; never construct by hand. */
-export interface SelectionState<TKey extends SelectionKey> {
-    /** The mode enforced by every op on this state. */
-    readonly mode: SelectionMode;
-    /** The selected keys, in the order they were added. */
-    readonly keys: ReadonlySet<TKey>;
-    /** The last plainly-interacted key — the fixed end of a subsequent range extension, or `null`. */
-    readonly anchor: TKey | null;
-}
-/** Options accepted by the range ops. */
-export interface SelectRangeOptions {
-    /**
-     * The union behaviour. `true` (default) merges the range into the existing selection — the checkbox-list
-     * shift-click every data grid in this SDK wants. `false` replaces the selection with the range alone,
-     * matching a file-manager style list.
-     */
-    isAdditive?: boolean;
-}
-/**
- * Creates a selection state, normalising the seed to the mode: `none` drops every key, `single` keeps only
- * the first. Also the way to re-mode an existing state — `createSelection('single', state.keys)`.
- *
- * @param mode The selection mode to enforce. Defaults to `'multiple'`.
- * @param keys The initially selected keys, in priority order.
- * @param anchor The initial range anchor. Defaults to `null`.
- */
-export declare function createSelection<TKey extends SelectionKey>(mode?: SelectionMode, keys?: Iterable<TKey>, anchor?: TKey | null): SelectionState<TKey>;
-/** Reports whether a key is currently selected. */
-export declare function isSelected<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): boolean;
-/** The number of selected keys. */
-export declare function selectionCount<TKey extends SelectionKey>(state: SelectionState<TKey>): number;
-/** The selected keys as an array, in insertion order — the shape a controlled `onSelectionChange` emits. */
-export declare function selectedKeys<TKey extends SelectionKey>(state: SelectionState<TKey>): readonly TKey[];
-/**
- * Selects a key and moves the anchor to it. In `single` mode this REPLACES the selection rather than
- * accumulating; in `none` mode it is inert.
- */
-export declare function select<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey>;
-/**
- * Deselects a key and moves the anchor to it. Inert in `none` mode, and inert when the key was not
- * selected — an unselected key carries no interaction to anchor on.
- */
-export declare function deselect<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey>;
-/**
- * Flips one key's membership and moves the anchor to it — the plain click. In `single` mode, toggling the
- * selected key clears the selection and toggling any other key replaces it.
- */
-export declare function toggle<TKey extends SelectionKey>(state: SelectionState<TKey>, key: TKey): SelectionState<TKey>;
-/**
- * Adds every given key to the selection, leaving the anchor and any selection OUTSIDE the given keys
- * untouched — so "select all" on a filtered table keeps rows selected under other filters.
- *
- * Inert in `none` and `single` modes: "all" has no meaning on a surface that holds at most one key.
- */
-export declare function selectAll<TKey extends SelectionKey>(state: SelectionState<TKey>, keys: Iterable<TKey>): SelectionState<TKey>;
-/** Empties the selection and drops the anchor — with nothing selected there is no range to extend from. */
-export declare function clear<TKey extends SelectionKey>(state: SelectionState<TKey>): SelectionState<TKey>;
-/**
- * Flips the membership of every given key. Keys selected OUTSIDE the given set are left alone, so
- * inverting a filtered page inverts exactly that page.
- *
- * Inert in `none` and `single` modes.
- */
-export declare function invert<TKey extends SelectionKey>(state: SelectionState<TKey>, keys: Iterable<TKey>): SelectionState<TKey>;
-/**
- * The header-checkbox click: selects every given key unless all of them are already selected, in which
- * case it deselects them. Selections outside the given keys survive either way.
- *
- * Inert in `none` and `single` modes, and on an empty key list.
- */
-export declare function toggleAll<TKey extends SelectionKey>(state: SelectionState<TKey>, keys: Iterable<TKey>): SelectionState<TKey>;
-/**
- * The tri-state a header checkbox renders for the given keys: `'all'` when every one is selected,
- * `'none'` when none is, `'some'` otherwise. An empty key list is `'none'` — there is nothing to check.
- */
-export declare function selectionStatus<TKey extends SelectionKey>(state: SelectionState<TKey>, keys: Iterable<TKey>): SelectionStatus;
-/**
- * Selects the contiguous run between two keys — the shift-click. `orderedKeys` is the surface's CURRENT
- * visual order (already sorted and filtered), which is what makes the range mean what the user sees.
- *
- * The anchor is left AT `anchor`, not moved to `target`: successive shift-clicks must all measure from the
- * same fixed end, so dragging a range back and forth grows and shrinks it instead of walking it away.
- *
- * Degenerate cases, all documented rather than thrown: `none` mode is inert; `single` mode collapses to
- * {@link select} on `target`; a `target` missing from `orderedKeys` is inert; an `anchor` missing from
- * `orderedKeys` falls back to selecting `target` alone.
- */
-export declare function selectRange<TKey extends SelectionKey>(state: SelectionState<TKey>, anchor: TKey, target: TKey, orderedKeys: readonly TKey[], options?: SelectRangeOptions): SelectionState<TKey>;
-/**
- * The shift-click as a surface actually calls it: extends from the state's own anchor to `target`. With no
- * anchor yet (nothing has been plainly clicked), the target itself becomes the anchor and the range is the
- * single row — which is exactly what a shift-click on a fresh list should do.
- */
-export declare function extendSelection<TKey extends SelectionKey>(state: SelectionState<TKey>, target: TKey, orderedKeys: readonly TKey[], options?: SelectRangeOptions): SelectionState<TKey>;

package/dist/foundation/selection/Sort.d.ts

@@ -1,69 +0,0 @@
-import { FieldAccessors, LocaleOptions } from './Field';
-/** Defines the ordering applied to a sorted field. */
-export declare const SortDirection: {
-    /** Refers to ascending order — smallest/earliest/`false` first. */
-    readonly Asc: "asc";
-    /** Refers to descending order — largest/latest/`true` first. */
-    readonly Desc: "desc";
-};
-export type SortDirection = (typeof SortDirection)[keyof typeof SortDirection];
-/** Represents one field of an ordering. A list of these is the whole sort state; array order is precedence. */
-export interface SortDescriptor<TField extends string = string> {
-    /** The field name, resolved through the accessor registry or read as a plain property. */
-    readonly field: TField;
-    /** The direction applied to this field. */
-    readonly direction: SortDirection;
-}
-/** Options accepted by {@link toggleSort}. */
-export interface ToggleSortOptions {
-    /**
-     * The multi-field behaviour. `false` (default) keeps at most one sorted field — a click on a new field
-     * replaces the ordering. `true` appends the new field after the existing ones, so precedence follows
-     * click order (the shift-click-a-second-header behaviour).
-     */
-    isMulti?: boolean;
-}
-/**
- * Compares two non-nullish values with the SDK's default ordering, direction-agnostic (callers negate).
- * Handles, in order: numbers, bigints, booleans (`false` before `true`), the `Temporal` types, native
- * `Date`, strings, and finally anything else via its text form.
- *
- * Nullish handling is deliberately NOT here — {@link applySort} applies it outside the direction flip so
- * absent values sort last in both directions. Calling this with a nullish value falls through to the text
- * comparison, which is not the documented ordering.
- */
-export declare function compareValues(a: unknown, b: unknown, options?: LocaleOptions): number;
-/** The direction currently applied to a field, or `null` when the field is unsorted. */
-export declare function sortDirectionFor<TField extends string>(descriptors: readonly SortDescriptor<TField>[], field: TField): SortDirection | null;
-/**
- * The 0-based precedence of a field in the ordering, or `-1` when unsorted — the number a multi-sort header
- * renders as its "1 / 2 / 3" badge (add one for display).
- */
-export declare function sortIndexFor<TField extends string>(descriptors: readonly SortDescriptor<TField>[], field: TField): number;
-/**
- * Advances one field through the `asc → desc → none` cycle and returns the next descriptor list.
- *
- * Single-field (default): the result is `[{ field, 'asc' }]`, `[{ field, 'desc' }]`, or `[]`. Clicking a
- * different field restarts that field's cycle at `asc` and drops the previous one.
- *
- * Multi-field (`{ isMulti: true }`): the field keeps its position while cycling `asc → desc`, and the third
- * click removes it, leaving the other fields' precedence intact. A field not yet in the list is appended.
- */
-export declare function toggleSort<TField extends string>(descriptors: readonly SortDescriptor<TField>[], field: TField, options?: ToggleSortOptions): readonly SortDescriptor<TField>[];
-/**
- * Builds the comparator an ordering describes — exported so a virtualised or server-side surface can feed
- * it to its own machinery instead of materialising a sorted array.
- *
- * Fields are consulted in array order and the first non-zero result wins. Within each field: absent values
- * (`null` / `undefined` / `NaN`) sort last regardless of direction, then {@link compareValues} decides and
- * the direction is applied to that result only.
- */
-export declare function sortComparator<T, TField extends string = string>(descriptors: readonly SortDescriptor<TField>[], accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): (a: T, b: T) => number;
-/**
- * Sorts a list by an ordering, without mutating the input. Returns the input array itself when there is
- * nothing to order, so an unsorted render costs no copy.
- *
- * The sort is stable (`Array.prototype.sort` has been stable since ES2019), which is what makes multi-field
- * ordering composable: equal rows keep the order the previous field — or the server — put them in.
- */
-export declare function applySort<T, TField extends string = string>(items: ReadonlyArray<T>, descriptors: readonly SortDescriptor<TField>[], accessors?: FieldAccessors<T, TField>, options?: LocaleOptions): ReadonlyArray<T>;