@nanahoshi/mona-ui 0.24.0 → 0.24.2

package/types/nanahoshi-mona-ui-button.d.ts

@@ -1,9 +1,15 @@
 import * as _angular_core from '@angular/core';
+import { Signal } from '@angular/core';
 import * as class_variance_authority_types from 'class-variance-authority/types';
 import { VariantInputs } from '@nanahoshi/mona-ui/internal';
 import { VariantProps } from 'class-variance-authority';
 import { Subject } from 'rxjs';
 
+/**
+ * Values accepted by the `aria-haspopup` input of `ButtonDirective`. `"false"` (the default) omits the attribute.
+ */
+type ButtonAriaHasPopup = "dialog" | "false" | "grid" | "listbox" | "menu" | "tree" | "true";
+
 declare const buttonThemeVariants: (props?: ({
     disabled?: boolean | null | undefined;
     iconOnly?: boolean | null | undefined;
@@ -18,41 +24,44 @@ type ButtonVariantsInput = VariantInputs<ButtonVariantProps>;
 
 declare class ButtonDirective implements ButtonVariantsInput {
     #private;
-    protected readonly displaysPressedState: _angular_core.Signal<boolean>;
+    protected readonly baseClass: _angular_core.Signal<string>;
     protected readonly effectiveDisabled: _angular_core.Signal<boolean>;
     protected readonly effectiveLook: _angular_core.Signal<"default" | "primary" | "success" | "error" | "warning" | "info" | "outline" | "secondary" | "ghost" | "link" | "clear" | null | undefined>;
     protected readonly effectiveRounded: _angular_core.Signal<"full" | "large" | "medium" | "none" | "small" | null | undefined>;
     protected readonly effectiveSize: _angular_core.Signal<"large" | "medium" | "small" | null | undefined>;
     protected readonly effectiveToggleable: _angular_core.Signal<boolean>;
-    protected readonly isInButtonGroup: _angular_core.Signal<boolean>;
-    protected readonly baseClass: _angular_core.Signal<string>;
     protected readonly loadingSize: _angular_core.Signal<12 | 16 | 14>;
     /**
      * @description Value forwarded to the `aria-haspopup` attribute. Set when this button triggers a popup, menu,
      * listbox, tree, grid, or dialog. Omit or leave as `"false"` for plain action buttons.
      * @default "false"
      */
-    readonly ariaHasPopup: _angular_core.InputSignal<string>;
+    readonly ariaHasPopup: _angular_core.InputSignal<ButtonAriaHasPopup>;
     /**
      * @description Renders the component with reduced visual emphasis and removes pointer interaction.
-     * When inside a `ButtonGroup`, the group's disabled state takes precedence.
+     * Accepts the bare attribute form (`<button monaButton disabled>`).
+     * When inside a `ButtonGroup`, the button is disabled when either it or the group is disabled.
      * @default false
      */
-    readonly disabled: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * @description Removes horizontal padding and fixes a square aspect ratio sized to match `size`.
-     * Provide `aria-label` on the host when using icon-only buttons.
+     * Provide `aria-label` on the host when using icon-only buttons; in dev mode, an icon-only button without an
+     * accessible name logs a warning.
      * @default false
      */
-    readonly iconOnly: _angular_core.InputSignal<boolean>;
+    readonly iconOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * @description Displays a loading indicator and prevents interaction while an operation is in progress.
-     * Sets `aria-busy="true"` on the host.
+     * Sets `aria-busy="true"` and `aria-disabled="true"` on the host. The button stays focusable, so keyboard focus
+     * isn't lost when loading starts, and clicks (including form submission) are blocked until it ends.
      * @default false
      */
-    readonly loading: _angular_core.ModelSignal<boolean>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /**
      * @description Visual style variant of the button. When inside a `ButtonGroup`, the group's look takes precedence.
+     * `"outline"` looks the same as `"default"`. `"clear"` shows no selected state, so use another look for
+     * toggle buttons.
      * @default "default"
      */
     readonly look: _angular_core.ModelSignal<"default" | "primary" | "success" | "error" | "warning" | "info" | "outline" | "secondary" | "ghost" | "link" | "clear" | null | undefined>;
@@ -75,23 +84,23 @@ declare class ButtonDirective implements ButtonVariantsInput {
      */
     readonly size: _angular_core.InputSignal<"large" | "medium" | "small" | null | undefined>;
     /**
-     * @description Tab index of the host element. Automatically overridden to `-1` when the button is disabled or loading.
-     * Accepts a numeric string and converts it to a number.
+     * @description Tab index of the host element. Automatically overridden to `-1` when the button is disabled.
+     * Accepts a numeric string and converts it to a number; a value that is not a number falls back to `0`.
      * @default 0
      */
     readonly tabindex: _angular_core.InputSignalWithTransform<number, string | number>;
+    /**
+     * @description Enables toggle behavior — each click flips the `selected` state and `aria-pressed` is managed.
+     * Accepts the bare attribute form. Buttons in a `ButtonGroup` are toggleable unless this is set to `false`.
+     * @default undefined
+     */
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
     /**
      * @description Native `type` attribute of the button. Defaults to `"button"` to prevent accidental
      * form submission; set to `"submit"` or `"reset"` explicitly when that behavior is intended.
      * @default "button"
      */
     readonly type: _angular_core.InputSignal<"button" | "reset" | "submit">;
-    /**
-     * @description Enables toggle behavior — each click flips the `selected` state and `aria-pressed` is managed.
-     * Must use `[toggleable]="true"` binding syntax, not bare attribute form.
-     * @default undefined
-     */
-    readonly toggleable: _angular_core.InputSignal<boolean | undefined>;
     /**
      * @description Additional CSS classes merged onto the host element via `tailwind-merge`.
      * @default ""
@@ -99,19 +108,34 @@ declare class ButtonDirective implements ButtonVariantsInput {
     readonly userClass: _angular_core.InputSignal<string>;
     constructor();
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "button[monaButton]", never, { "ariaHasPopup": { "alias": "aria-haspopup"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "disabled": "disabledChange"; "loading": "loadingChange"; "look": "lookChange"; "selected": "selectedChange"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ButtonDirective, "button[monaButton]", never, { "ariaHasPopup": { "alias": "aria-haspopup"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "look": { "alias": "look"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tabindex": { "alias": "tabindex"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, { "look": "lookChange"; "selected": "selectedChange"; }, never, never, true, never>;
 }
 
+/**
+ * Coordinates a `mona-button-group` with its buttons: the group publishes its look, size, rounding, disabled state
+ * and members here, and buttons report clicks and receive selection changes through it. It is public so the
+ * button-group entry point can provide it; applications don't need to use it directly.
+ */
 declare class ButtonService {
+    #private;
     readonly buttonClick$: Subject<[ButtonDirective, boolean]>;
     readonly buttonSelect$: Subject<[ButtonDirective, boolean]>;
     readonly groupDisabled: _angular_core.WritableSignal<boolean>;
     readonly groupLook: _angular_core.WritableSignal<"default" | "primary" | "success" | "error" | "warning" | "info" | "outline" | "secondary" | "ghost" | "link" | "clear" | null | undefined>;
     readonly groupRounded: _angular_core.WritableSignal<"full" | "large" | "medium" | "none" | "small" | null | undefined>;
     readonly groupSize: _angular_core.WritableSignal<"large" | "medium" | "small" | null | undefined>;
+    /**
+     * The buttons that belong to the group. Only these follow the group's look, size, rounding, disabled state and
+     * selection; other buttons that can inject this service ignore it.
+     */
+    readonly members: Signal<readonly ButtonDirective[]>;
+    /**
+     * Sets the source of the group's members, such as the group's `contentChildren(ButtonDirective)` query.
+     */
+    setMembers(members: Signal<readonly ButtonDirective[]>): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonService, never>;
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<ButtonService>;
 }
 
 export { ButtonDirective, ButtonService };
-export type { ButtonVariantProps, ButtonVariantsInput };
+export type { ButtonAriaHasPopup, ButtonVariantProps, ButtonVariantsInput };

package/types/nanahoshi-mona-ui-common.d.ts

@@ -60,7 +60,12 @@ declare class ContainsPipe implements PipeTransform {
 }
 
 declare class SlicePipe implements PipeTransform {
-    transform<T>(value: Iterable<T>, start: number, end: number): T[];
+    /**
+     * Returns the elements from `start` up to, but not including, `end`, with the semantics of `Array.prototype.slice`:
+     * negative indices count from the end, and an omitted `end` slices to the end. Returns an empty array for
+     * `null` or `undefined`, such as the first value of the `async` pipe.
+     */
+    transform<T>(value: Iterable<T> | null | undefined, start: number, end?: number): T[];
     static ɵfac: i0.ɵɵFactoryDeclaration<SlicePipe, never>;
     static ɵpipe: i0.ɵɵPipeDeclaration<SlicePipe, "monaSlice", true>;
 }
@@ -76,10 +81,12 @@ type BuiltIn = Primitive | Date | RegExp | Function | Map<unknown, unknown> | Se
 type DeepPartial<T> = T extends BuiltIn ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : {
     [P in keyof T]?: DeepPartial<T[P]>;
 };
-type Path<T> = T extends object ? {
-    [K in keyof T]-?: [
-        K
-    ] | (Path<T[K]> extends infer P ? (P extends ReadonlyArray<PropertyKey> ? [K, ...P] : never) : never);
+/**
+ * Every key path into `T`. Paths stop at built-in values (dates, maps, sets, functions), and index arrays by
+ * number, so `['tags', 0]` is a path and `['tags', 'map']` is not.
+ */
+type Path<T> = T extends BuiltIn ? never : T extends ReadonlyArray<infer U> ? [number] | (Path<U> extends infer P ? (P extends ReadonlyArray<PropertyKey> ? [number, ...P] : never) : never) : T extends object ? {
+    [K in keyof T]-?: [K] | (Path<T[K]> extends infer P ? (P extends ReadonlyArray<PropertyKey> ? [K, ...P] : never) : never);
 }[keyof T] : never;
 type PathValue<T, P> = P extends readonly [infer K, ...infer R] ? K extends keyof T ? R["length"] extends 0 ? T[K] : PathValue<T[K], Extract<R, ReadonlyArray<PropertyKey>>> : never : never;
 type ArrayStrategy = {
@@ -92,18 +99,40 @@ type ArrayStrategy = {
 };
 interface DeepMergeOptions {
     arrayStrategy?: ArrayStrategy | ((key: PropertyKey, path: ReadonlyArray<PropertyKey>) => ArrayStrategy);
+    /**
+     * What an own `undefined` value in the patch does. `"skip"` (the default) keeps the base value;
+     * `"assign"` sets the field to `undefined`.
+     */
+    undefinedValues?: "assign" | "skip";
 }
 declare const isEmptyObject: (obj: Record<PropertyKey, unknown>) => boolean;
 declare const isPlainObject: (v: unknown) => v is Record<PropertyKey, unknown>;
+/**
+ * Merges `patch` into a copy of `base`. Only plain objects (object literals, `JSON.parse` output) are merged
+ * key by key. Any other value in the patch, including a class instance, a `Date`, a `Map` or a `Set`, replaces
+ * the base value as a whole, so a partial patch for a class-instance field must carry the whole value.
+ * `__proto__` keys in the patch are ignored.
+ */
 declare function deepMerge<T>(base: T, patch: DeepPartial<T>, options?: DeepMergeOptions, path?: ReadonlyArray<PropertyKey>): T;
 declare function deepMerge<T>(base: DeepPartial<T>, patch: DeepPartial<T>, options?: DeepMergeOptions, path?: ReadonlyArray<PropertyKey>): DeepPartial<T>;
 declare function mergeInto<T>(base: T, patch: DeepPartial<T>, options?: DeepMergeOptions): T;
 declare function mergePatchInto<T>(base: DeepPartial<T>, patch: DeepPartial<T>, options?: DeepMergeOptions): DeepPartial<T>;
-declare function buildNested(keys: ReadonlyArray<PropertyKey>, leaf: unknown): Record<PropertyKey, unknown>;
-declare function patchAt<T, P extends Path<T>>(path: P, value: PathValue<T, P>): DeepPartial<T>;
+/**
+ * Builds a patch that sets `leaf` at `keys`. When `current` (the value the patch will be merged into) holds an
+ * array along the path, the patch carries a copy of that array with the one element replaced, since arrays are
+ * replaced rather than merged. Without `current`, every level is an object.
+ */
+declare function buildNested(keys: ReadonlyArray<PropertyKey>, leaf: unknown, current?: unknown): Record<PropertyKey, unknown>;
+declare function patchAt<T, P extends Path<T>>(path: P, value: PathValue<T, P>, current?: T): DeepPartial<T>;
 declare function setAt<T, P extends Path<T>>(obj: T, path: P, value: PathValue<T, P>, options?: DeepMergeOptions): T;
 declare function prunePatch<T>(base: T, patch: DeepPartial<T>): DeepPartial<T> | undefined;
 declare function prunePatch<T>(base: DeepPartial<T>, patch: DeepPartial<T>): DeepPartial<T> | undefined;
+/**
+ * Structural equality for plain objects, arrays, `Date`, `RegExp`, `Map` and `Set`. Primitives are equal when
+ * `===` says so, and `NaN` equals `NaN`. Dates are equal when they hold the same time (two invalid dates are
+ * equal). Map keys and set members are matched by `SameValueZero`, like `Map.prototype.has`. Cyclic values are
+ * supported.
+ */
 declare function deepEquals<T>(o1: T, o2: T): boolean;
 
 /**
@@ -142,18 +171,6 @@ interface IObjectPatchStore<T> {
      * pending changes (i.e. the draft is an empty object).
      */
     readonly changes: Signal<DeepPartial<T> | undefined>;
-    /**
-     * `true` when the current draft is structurally equal to the last
-     * committed snapshot, i.e. no unsaved changes exist relative to the
-     * last commit point.
-     */
-    readonly pristine: Signal<boolean>;
-    /**
-     * The live merged view of base + draft. Prefer `select()` over reading
-     * this directly in computed signals when you only care about a specific
-     * slice of the object, to avoid unnecessary downstream invalidations.
-     */
-    readonly view: Signal<T>;
     /**
      * Discard the current draft without affecting the committed snapshot.
      * The view reverts to the base value.
@@ -174,7 +191,8 @@ interface IObjectPatchStore<T> {
      * Deep-merge `patch` into the current draft. Only the fields present in
      * `patch` are affected; all other fields retain their current draft or
      * base values. Automatically prunes fields that match the base value so
-     * the draft stays minimal.
+     * the draft stays minimal. A field set to `undefined` is cleared, unless
+     * `options.undefinedValues` is `"skip"`.
      */
     patch(patch: DeepPartial<T>, options?: DeepMergeOptions): void;
     /**
@@ -185,26 +203,17 @@ interface IObjectPatchStore<T> {
      * store.patchPath(['address', 'city'], 'London');
      */
     patchPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    /**
+     * `true` when the current draft is structurally equal to the last
+     * committed snapshot, i.e. no unsaved changes exist relative to the
+     * last commit point.
+     */
+    readonly pristine: Signal<boolean>;
     /**
      * Discard both the draft and the committed snapshot, fully resetting
      * the store to a pristine, empty state.
      */
     reset(): void;
-    /**
-     * Directly replace the draft with the given patch object, bypassing the
-     * merge logic. Use with care — this does not prune against the base.
-     * Prefer `patch()` for most use cases.
-     */
-    setDraft(patch: DeepPartial<T>): void;
-    /**
-     * Convenience wrapper over `patch` that sets a single path to a value.
-     * Unlike the old implementation, this merges rather than replaces the
-     * draft, so unrelated draft fields are preserved.
-     *
-     * @example
-     * store.setPath(['address', 'city'], 'London');
-     */
-    setPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
     /**
      * Returns a `Signal` that emits only the slice of `view` selected by
      * `projector`. Uses `deepEquals` as the equality function, so downstream
@@ -222,6 +231,28 @@ interface IObjectPatchStore<T> {
      * readonly city = store.select(v => v.address.city);
      */
     select<R>(projector: (view: T) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+    /**
+     * Directly replace the draft with the given patch object, bypassing the
+     * merge logic. Use with care — this does not prune against the base, so
+     * a field equal to its base value still counts in `changes` and
+     * `hasDraft()`, while `pristine` ignores it. Prefer `patch()` for most use
+     * cases.
+     */
+    setDraft(patch: DeepPartial<T>): void;
+    /**
+     * Same as `patchPath`: sets a single path to a value, merging into the
+     * draft, so unrelated draft fields are preserved.
+     *
+     * @example
+     * store.setPath(['address', 'city'], 'London');
+     */
+    setPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
+    /**
+     * The live merged view of base + draft. Prefer `select()` over reading
+     * this directly in computed signals when you only care about a specific
+     * slice of the object, to avoid unnecessary downstream invalidations.
+     */
+    readonly view: Signal<T>;
 }
 declare class ObjectPatchStore<T> implements IObjectPatchStore<T> {
     #private;
@@ -236,11 +267,16 @@ declare class ObjectPatchStore<T> implements IObjectPatchStore<T> {
     patch(patch: DeepPartial<T>, options?: DeepMergeOptions): void;
     patchPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
     reset(): void;
+    select<R>(projector: (view: T) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
     setDraft(patch: DeepPartial<T>): void;
     setPath<P extends Path<T>>(path: P, value: PathValue<T, P>, options?: DeepMergeOptions): void;
-    select<R>(projector: (view: T) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
 }
 interface IterablePatchStoreOptions<TItem, TId> {
+    /**
+     * Controls what happens to uncommitted drafts when the base signal emits
+     * a new value. Defaults to `'wipe'`.
+     */
+    baseChangeStrategy?: BaseChangeStrategy;
     /** Extracts the stable identity key from an item. */
     idOf: (item: TItem) => TId;
     /**
@@ -248,13 +284,10 @@ interface IterablePatchStoreOptions<TItem, TId> {
      * per-row edits). Accepts either a `Map` or an `ImmutableDictionary`.
      */
     initial?: () => Map<TId, DeepPartial<TItem>> | ImmutableDictionary<TId, DeepPartial<TItem>>;
+    /** Default merge options applied to all patch operations unless overridden per-call. */
+    mergeOptions?: DeepMergeOptions;
     /** Factory that returns the authoritative base signal for this store. */
     source: () => Signal<Iterable<TItem>>;
-    /**
-     * Controls what happens to uncommitted drafts when the base signal emits
-     * a new value. Defaults to `'wipe'`.
-     */
-    baseChangeStrategy?: BaseChangeStrategy;
 }
 interface IIterablePatchStore<TItem, TId> {
     /**
@@ -262,18 +295,6 @@ interface IIterablePatchStore<TItem, TId> {
      * with its current draft. Items without a draft are excluded.
      */
     readonly changes: Signal<TItem[]>;
-    /**
-     * `true` when every item's current draft is structurally equal to its
-     * last committed snapshot.
-     */
-    readonly pristine: Signal<boolean>;
-    /**
-     * The live merged view of all base items with their drafts applied.
-     * Items without a draft are returned as-is (same reference).
-     * Prefer `select()` over reading this directly in computed signals when
-     * you only care about a specific slice.
-     */
-    readonly view: Signal<TItem[]>;
     /**
      * Discard the draft for the item identified by `id`.
      * Has no effect if the item has no draft.
@@ -298,6 +319,8 @@ interface IIterablePatchStore<TItem, TId> {
      * Deep-merge `patch` into the draft for the item identified by `id`.
      * Automatically prunes fields that now match the base item so the draft
      * stays minimal. Removes the draft entry entirely if it becomes empty.
+     * A field set to `undefined` is cleared, unless `options.undefinedValues`
+     * is `"skip"`.
      */
     patch(id: TId, patch: DeepPartial<TItem>, options?: DeepMergeOptions): void;
     /**
@@ -314,26 +337,16 @@ interface IIterablePatchStore<TItem, TId> {
      * store.patchPath(itemId, ['address', 'city'], 'London');
      */
     patchPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    /**
+     * `true` when every item's current draft is structurally equal to its
+     * last committed snapshot.
+     */
+    readonly pristine: Signal<boolean>;
     /**
      * Discard all drafts and committed snapshots, fully resetting the store
      * to a pristine, empty state.
      */
     reset(): void;
-    /**
-     * Directly replace the draft for `id` with the given patch object,
-     * bypassing the merge logic. Use with care — this does not prune against
-     * the base item. Prefer `patch()` for most use cases.
-     */
-    setDraft(id: TId, patch: DeepPartial<TItem>): void;
-    /**
-     * Convenience wrapper over `patch` that sets a single path to a value
-     * for a specific item. Merges into the existing draft rather than
-     * replacing it, so unrelated draft fields are preserved.
-     *
-     * @example
-     * store.setPath(itemId, ['address', 'city'], 'London');
-     */
-    setPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
     /**
      * Returns a `Signal` that emits only the slice of `view` selected by
      * `projector`. Uses `deepEquals` as the equality function by default,
@@ -347,6 +360,30 @@ interface IIterablePatchStore<TItem, TId> {
      * readonly cities = store.select(items => items.map(i => i.address.city));
      */
     select<R>(projector: (view: TItem[]) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
+    /**
+     * Directly replace the draft for `id` with the given patch object,
+     * bypassing the merge logic. An empty patch removes the draft. Use with
+     * care — this does not prune against the base item, so a field equal to
+     * its base value still counts in `changes`, `hasDraft()` and
+     * `dirtyCount()`, while `pristine` ignores it. Prefer `patch()` for most
+     * use cases.
+     */
+    setDraft(id: TId, patch: DeepPartial<TItem>): void;
+    /**
+     * Same as `patchPath`: sets a single path to a value for a specific item,
+     * merging into the existing draft, so unrelated draft fields are preserved.
+     *
+     * @example
+     * store.setPath(itemId, ['address', 'city'], 'London');
+     */
+    setPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
+    /**
+     * The live merged view of all base items with their drafts applied.
+     * Items without a draft are returned as-is (same reference).
+     * Prefer `select()` over reading this directly in computed signals when
+     * you only care about a specific slice.
+     */
+    readonly view: Signal<TItem[]>;
 }
 declare class IterablePatchStore<TItem, TId> implements IIterablePatchStore<TItem, TId> {
     #private;
@@ -360,13 +397,13 @@ declare class IterablePatchStore<TItem, TId> implements IIterablePatchStore<TIte
     dirtyCount(): number;
     getCommitted(): ImmutableDictionary<TId, DeepPartial<TItem>>;
     hasDraft(id: TId): boolean;
-    patch(id: TId, patch: DeepPartial<TItem>, options?: DeepMergeOptions): void;
-    patchMany(patchTuple: Iterable<[TId, DeepPartial<TItem>]>, options?: DeepMergeOptions): void;
+    patch(id: TId, patch: DeepPartial<TItem>, options?: DeepMergeOptions | undefined): void;
+    patchMany(patchTuple: Iterable<[TId, DeepPartial<TItem>]>, options?: DeepMergeOptions | undefined): void;
     patchPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
     reset(): void;
+    select<R>(projector: (view: TItem[]) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
     setDraft(id: TId, patch: DeepPartial<TItem>): void;
     setPath<P extends Path<TItem>>(id: TId, path: P, value: PathValue<TItem, P>, options?: DeepMergeOptions): void;
-    select<R>(projector: (view: TItem[]) => R, equal?: (a: R, b: R) => boolean): Signal<R>;
 }
 declare const createIterablePatchStore: <TItem, TId>(options: IterablePatchStoreOptions<TItem, TId>) => IIterablePatchStore<TItem, TId>;
 declare const createObjectPatchStore: <T>(options: ObjectPatchStoreOptions<T>) => IObjectPatchStore<T>;
@@ -378,12 +415,18 @@ declare const classInputToClass: (input: ClassInputType) => string;
  * @param value The current value.
  * @param min The minimum value.
  * @param max The maximum value.
- * @param precision The number of decimal places to round the percentage to.
+ * @param precision The number of decimal places to round the percentage to, clamped to 0–100.
  * @default 2
- * @returns The percentage of the value within the range, rounded to the specified precision.
+ * @returns The percentage of the value within the range, rounded to the specified precision, or 0 when the range
+ * or the value is not finite.
  */
 declare const getPercentage: (value: number, min: number, max: number, precision?: number) => number;
 
+/**
+ * Moves the items at `indices` by `offset` positions, keeping their relative order. Returns a copy of the array
+ * unchanged when the offset is 0 or not an integer, or when any index is not an integer, is out of bounds, or would
+ * move out of bounds. Duplicate indices count once.
+ */
 declare function moveIndices<T>(array: T[], indices: number[], offset: number): T[];
 
 export { AnyPipe, ContainsPipe, FilterChangeEvent, IterablePatchStore, ObjectPatchStore, PreventableEvent, SlicePipe, TakeFirstPipe, buildNested, classInputToClass, createIterablePatchStore, createObjectPatchStore, deepEquals, deepMerge, getPercentage, isEmptyObject, isPlainObject, mergeInto, mergePatchInto, moveIndices, patchAt, prunePatch, setAt };