forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-radio-group.d.ts

@@ -0,0 +1,222 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { FormValueControl } from '@angular/forms/signals';
+import { WritingDirection, ListNavigationAction, FormUiControlBase } from 'forty-cdk/core';
+import * as forty_cdk_radio_group from 'forty-cdk/radio-group';
+
+/**
+ * Lightweight handle each `ForRadio` registers with the group on init so the
+ * group can react to changes in any radio's `disabled` (the `firstEnabledHost`
+ * computation depends on every registered handle's disabled signal).
+ */
+interface ForRadioHandle {
+    readonly host: HTMLElement;
+    readonly value: Signal<string>;
+    readonly disabled: Signal<boolean>;
+}
+/**
+ * Coordination contract owned by `ForRadioGroup`. Each `ForRadio` reads its
+ * checked / disabled / tabindex state from this and routes click + keyboard
+ * activation through `select` / `navigate`.
+ */
+interface ForRadioGroupContext {
+    readonly value: Signal<string>;
+    /**
+     * The group's effective disabled — its own `disabled` input OR'd with a
+     * surrounding disabled `[forFieldset]`. Each `ForRadio` ORs this into its own
+     * `effectiveDisabled`, so a disabled group (or fieldset) disables every radio.
+     */
+    readonly effectiveDisabled: Signal<boolean>;
+    readonly readonly: Signal<boolean>;
+    readonly orientation: Signal<'horizontal' | 'vertical'>;
+    readonly dir: Signal<WritingDirection>;
+    /** True when some registered radio's value matches the group's current value. */
+    readonly hasSelectedRadio: Signal<boolean>;
+    isSelected(value: string): boolean;
+    /** Selects `value` if the group is interactive. */
+    select(value: string): void;
+    /** Moves focus + selection from `currentRadio` according to `action`. */
+    navigate(currentRadio: HTMLElement, action: ListNavigationAction): void;
+    /** True when `el` is the first enabled radio in registration order. */
+    isFirstEnabledRadio(el: HTMLElement): boolean;
+    registerRadio(handle: ForRadioHandle): void;
+    unregisterRadio(handle: ForRadioHandle): void;
+}
+declare const FOR_RADIO_GROUP_CONTEXT: InjectionToken<ForRadioGroupContext>;
+
+/**
+ * Root of the Radio Group primitive. Owns the selected value, orientation,
+ * and disabled / readonly / form-state inputs. Provides the shared context
+ * to descendant `ForRadio` directives.
+ *
+ * Implements the [WAI-ARIA Radio Group pattern](https://www.w3.org/WAI/ARIA/apg/patterns/radio/)
+ * and `FormValueControl<string>` from `@angular/forms/signals`, so it
+ * auto-wires with `[formField]`.
+ *
+ * Selection-on-focus: arrow keys move focus AND change the value (APG
+ * standard behavior). Wrap-around at the ends. Disabled radios are skipped.
+ *
+ * Empty string is the canonical "nothing selected" value (matches HTML form
+ * semantics). Choose non-empty `value`s on each `ForRadio`.
+ */
+declare class ForRadioGroup extends FormUiControlBase implements FormValueControl<string>, ForRadioGroupContext {
+    #private;
+    /** Two-way bindable. Selected radio's value. Empty string = none selected. */
+    readonly value: _angular_core.ModelSignal<string>;
+    /** Layout direction for keyboard navigation. */
+    readonly orientation: _angular_core.InputSignal<"horizontal" | "vertical">;
+    /**
+     * Reading direction for horizontal orientation. When unset (default
+     * `null`), the inherited ambient direction is resolved from the nearest
+     * ancestor carrying a `dir` attribute (or `<html dir>`), defaulting to
+     * `'ltr'`. An explicit `[dir]` always wins. The resolved value is reflected
+     * to the host `dir` attribute and swaps ArrowLeft / ArrowRight in RTL.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    /**
+     * Whether arrow navigation wraps around past the first / last enabled
+     * radio. Default `true` — matches the WAI-ARIA Radio Group APG. Set to
+     * `false` for a non-wrapping group. The default is read from
+     * `provideForRadioGroupDefaults` for the surrounding scope.
+     */
+    readonly loop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** True when some registered radio's value matches the group's current value. */
+    readonly hasSelectedRadio: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Move focus to a radio, implementing `FormUiControl.focus` from
+     * `@angular/forms/signals`. Without this override Signal Forms would focus
+     * the host `role="radiogroup"` wrapper — which is not focusable and carries
+     * no keyboard map — so focus-on-error would silently go nowhere. Targets the
+     * selected radio's host when one matches, else the first enabled radio host;
+     * no-op when the group is disabled or has no enabled radio.
+     */
+    focus(options?: FocusOptions): void;
+    isSelected(v: string): boolean;
+    select(v: string): void;
+    navigate(currentRadio: HTMLElement, action: ListNavigationAction): void;
+    isFirstEnabledRadio(el: HTMLElement): boolean;
+    registerRadio(handle: ForRadioHandle): void;
+    unregisterRadio(handle: ForRadioHandle): void;
+    protected onFocusOut(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForRadioGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForRadioGroup, "[forRadioGroup]", ["forRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+/**
+ * Injection key the `[forRadioIndicator]` uses to resolve its parent radio,
+ * decoupled from the concrete `ForRadio` class. `ForRadio` provides itself
+ * under this token, so a design system wrapping the radio by subclassing
+ * re-points it at the subclass with a single provider
+ * (`{ provide: FOR_RADIO, useExisting: MtxRadio }`) and the indicator keeps
+ * resolving — see `docs/wrapping-form-primitives.md`.
+ */
+declare const FOR_RADIO: InjectionToken<ForRadio>;
+/**
+ * One radio inside a `ForRadioGroup`. Apply on a `<button type="button">`.
+ *
+ * The directive reflects ARIA + roving tabindex for the WAI-ARIA Radio
+ * pattern: only the selected radio (or the first enabled one when nothing
+ * is selected) gets `tabindex=0`.
+ */
+declare class ForRadio {
+    #private;
+    /** Parent group's context — public so siblings like `ForRadioIndicator` can read it. */
+    readonly group: forty_cdk_radio_group.ForRadioGroupContext;
+    /** Unique identifier for this radio's value. Required. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** When true, this radio is disabled (independent of the group's disabled). */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly id: _angular_core.Signal<string>;
+    readonly checked: _angular_core.Signal<boolean>;
+    readonly effectiveDisabled: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Tabindex per APG: 0 if this radio is selected; if no registered radio
+     * matches the group's value (none selected, or a stale value matching no
+     * radio), 0 if this is the first enabled radio in DOM order; -1 otherwise.
+     *
+     * Disabled radios are always -1.
+     */
+    readonly tabindex: _angular_core.Signal<0 | -1>;
+    protected onClick(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForRadio, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForRadio, "[forRadio]", ["forRadio"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Optional indicator slot inside a `ForRadio`. Apply on the element the
+ * consumer wants to show only while this radio is selected (typically a
+ * filled dot inside the radio circle). The directive mirrors `data-state`
+ * from the parent radio; hide the unchecked state via
+ * `[data-state="unchecked"] { display: none }` or `@if`.
+ *
+ * Purely a styling convenience.
+ */
+declare class ForRadioIndicator {
+    protected readonly parent: ForRadio;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForRadioIndicator, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForRadioIndicator, "[forRadioIndicator]", ["forRadioIndicator"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant radio groups in the surrounding injector
+ * scope. Configure with `provideForRadioGroupDefaults` either at the
+ * application root or in any component's `providers` array; partial
+ * overrides merge with the parent scope.
+ */
+interface ForRadioGroupDefaults {
+    /**
+     * Whether arrow navigation wraps around past the first / last enabled
+     * radio. Matches the WAI-ARIA Radio Group APG default.
+     */
+    loop: boolean;
+}
+/** Token holding the resolved radio-group defaults for the current scope. */
+declare const FOR_RADIO_GROUP_DEFAULTS: _angular_core.InjectionToken<ForRadioGroupDefaults>;
+/**
+ * Configures forty-cdk radio-group defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForRadioGroupDefaults(defaults?: Partial<ForRadioGroupDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForRadioGroup` input, its models included. Spread it into the
+ * `inputs` array of a `hostDirectives` entry so a wrapper component re-exposes the
+ * primitive's full surface — the Signal Forms members `[formField]` binds among them —
+ * without hand-maintaining the list. Always spread into an inline object literal as shown
+ * below: the literal is what keeps the entry statically analyzable for consumers compiling
+ * against the published package. An anti-drift spec fails when this list no longer matches
+ * the directive's actual API. See `docs/wrapping-form-primitives.md` for both supported
+ * wrapping patterns.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'div[myRadioGroup]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForRadioGroup,
+ *       inputs: [...FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_RADIO_GROUP_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MyRadioGroup {}
+ * ```
+ */
+declare const FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS: readonly ["value", "dir", "dirty", "disabled", "errors", "invalid", "loop", "name", "orientation", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForRadioGroup` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_RADIO_GROUP_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
+export { FOR_RADIO, FOR_RADIO_GROUP_CONTEXT, FOR_RADIO_GROUP_DEFAULTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_INPUTS, FOR_RADIO_GROUP_HOST_DIRECTIVE_OUTPUTS, ForRadio, ForRadioGroup, ForRadioIndicator, provideForRadioGroupDefaults };
+export type { ForRadioGroupContext, ForRadioGroupDefaults };

package/types/forty-cdk-scroll-area.d.ts

@@ -0,0 +1,258 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import * as forty_cdk_core from 'forty-cdk/core';
+import { WritingDirection } from 'forty-cdk/core';
+import * as forty_cdk_scroll_area from 'forty-cdk/scroll-area';
+
+type ForScrollAreaType = 'auto' | 'always' | 'scroll' | 'hover';
+type ForScrollbarOrientation = 'horizontal' | 'vertical';
+interface ForScrollAreaContext {
+    readonly type: Signal<ForScrollAreaType>;
+    readonly scrollHideDelay: Signal<number>;
+    readonly dir: Signal<WritingDirection>;
+    /** The scrolling element (registered by `ForScrollAreaViewport`). */
+    readonly viewport: Signal<HTMLElement | null>;
+    /** The content element (registered by `ForScrollAreaContent`, observed by the viewport). */
+    readonly content: Signal<HTMLElement | null>;
+    /** Live scroll offset of the viewport. */
+    readonly scrollLeft: Signal<number>;
+    readonly scrollTop: Signal<number>;
+    /** Live size measurements of the viewport. */
+    readonly clientWidth: Signal<number>;
+    readonly clientHeight: Signal<number>;
+    readonly scrollWidth: Signal<number>;
+    readonly scrollHeight: Signal<number>;
+    /** True while the user is hovering anywhere on the root (for `type="hover"`). */
+    readonly hovering: Signal<boolean>;
+    /** True for a short window after the most recent scroll (for `type="scroll"`). */
+    readonly scrolling: Signal<boolean>;
+    registerViewport(el: HTMLElement | null): void;
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
+    reportScroll(left: number, top: number): void;
+    reportSize(clientW: number, clientH: number, scrollW: number, scrollH: number): void;
+    noteUserScroll(): void;
+}
+declare const FOR_SCROLL_AREA_CONTEXT: InjectionToken<ForScrollAreaContext>;
+
+/**
+ * Root of the custom-scrollbar primitive. Owns the viewport reference,
+ * scroll geometry signals, and visibility state for the synthetic
+ * scrollbars.
+ *
+ * Native scrollbars on the inner viewport are hidden via styles injected
+ * by `[forScrollAreaViewport]` (the only place in forty-cdk that
+ * imperatively touches CSS); the consumer styles `[forScrollAreaThumb]`
+ * however they like.
+ *
+ * @example
+ * ```html
+ * <div forScrollArea>
+ *   <div forScrollAreaViewport>
+ *     <div forScrollAreaContent>… long content …</div>
+ *   </div>
+ *   <div forScrollAreaScrollbar orientation="vertical">
+ *     <div forScrollAreaThumb></div>
+ *   </div>
+ *   <div forScrollAreaScrollbar orientation="horizontal">
+ *     <div forScrollAreaThumb></div>
+ *   </div>
+ *   <div forScrollAreaCorner></div>
+ * </div>
+ * ```
+ */
+declare class ForScrollArea implements ForScrollAreaContext {
+    #private;
+    /**
+     * When the synthetic scrollbars are visible:
+     * - `auto`: shown whenever the axis overflows, regardless of interaction;
+     *   self-hides when the content fits.
+     * - `always`: the scrollbar (and corner) stay mounted and
+     *   `data-state="visible"` regardless of overflow — a stable, always-painted
+     *   track. When the axis does not overflow the thumb fills
+     *   the full track and dragging is a no-op. The library is headless and does
+     *   not own layout, so to actually *reserve* the gutter (no content shift
+     *   when crossing the overflow boundary) the consumer lays the scrollbar out
+     *   in flow — see the ScrollArea README's grid example.
+     * - `scroll`: shown during scroll, faded after `scrollHideDelay` ms.
+     * - `hover`: shown while the cursor is over the area (and during scroll).
+     */
+    readonly type: _angular_core.InputSignal<ForScrollAreaType>;
+    /**
+     * ms after the most recent scroll before scrollbars fade (only
+     * `type="scroll"` and `"hover"`). The default is read from
+     * `provideForScrollAreaDefaults` for the surrounding scope.
+     */
+    readonly scrollHideDelay: _angular_core.InputSignalWithTransform<number, unknown>;
+    /**
+     * Writing direction. When unset (default `null`), the inherited ambient
+     * direction is resolved from the nearest ancestor carrying a `dir` attribute
+     * (or `<html dir>`), defaulting to `'ltr'`. An explicit `[dir]` always wins.
+     * The resolved value is reflected to the host `dir` attribute and positions
+     * the vertical scrollbar on the left in RTL.
+     */
+    readonly _dirInput: _angular_core.InputSignal<WritingDirection | null>;
+    readonly dir: _angular_core.Signal<WritingDirection>;
+    readonly viewport: _angular_core.Signal<HTMLElement | null>;
+    readonly content: _angular_core.Signal<HTMLElement | null>;
+    readonly scrollLeft: _angular_core.Signal<number>;
+    readonly scrollTop: _angular_core.Signal<number>;
+    readonly clientWidth: _angular_core.Signal<number>;
+    readonly clientHeight: _angular_core.Signal<number>;
+    readonly scrollWidth: _angular_core.Signal<number>;
+    readonly scrollHeight: _angular_core.Signal<number>;
+    readonly hovering: _angular_core.Signal<boolean>;
+    readonly scrolling: _angular_core.Signal<boolean>;
+    registerViewport(el: HTMLElement | null): void;
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
+    reportScroll(left: number, top: number): void;
+    reportSize(clientW: number, clientH: number, scrollW: number, scrollH: number): void;
+    noteUserScroll(): void;
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollArea, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollArea, "[forScrollArea]", ["forScrollArea"], { "type": { "alias": "type"; "required": false; "isSignal": true; }; "scrollHideDelay": { "alias": "scrollHideDelay"; "required": false; "isSignal": true; }; "_dirInput": { "alias": "dir"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The actually-scrolling element. Hides native scrollbars (the only place
+ * in forty-cdk that ships CSS — see README), tracks scroll position, and
+ * reports geometry to the root so the synthetic scrollbar can render.
+ */
+declare class ForScrollAreaViewport {
+    #private;
+    constructor();
+    protected onScroll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollAreaViewport, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollAreaViewport, "[forScrollAreaViewport]", ["forScrollAreaViewport"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Marks the content element inside `[forScrollAreaViewport]`. The viewport
+ * observes this element with a `ResizeObserver` so `scrollWidth` /
+ * `scrollHeight` updates when content reflows.
+ *
+ * Required for the synthetic scrollbar to react to content resizes — without
+ * it, the viewport falls back to no observation and scrollbars stay sized to
+ * whatever the layout reported on first render.
+ */
+declare class ForScrollAreaContent {
+    #private;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollAreaContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollAreaContent, "[forScrollAreaContent]", ["forScrollAreaContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Synthetic scrollbar track. Reflects `data-orientation`, `data-state`
+ * (`visible` / `hidden`), and exposes its host element via the orientation
+ * input so the thumb can compute geometry.
+ *
+ * The element is fully removed (`hidden`) when the corresponding axis has
+ * no overflow *and* `type` is not `'always'` — there is no scrollbar to
+ * render. Under `type="always"` the track stays painted regardless of
+ * overflow, so the consumer's reserved gutter is never empty.
+ * Visibility is enforced with an inline `display: none` (which beats any
+ * author `display` rule a consumer applies via a class) in addition to the
+ * `hidden` attribute that removes it from the a11y tree.
+ */
+declare class ForScrollAreaScrollbar {
+    #private;
+    readonly orientation: _angular_core.InputSignal<ForScrollbarOrientation>;
+    readonly ctx: forty_cdk_scroll_area.ForScrollAreaContext;
+    readonly host: HTMLElement;
+    readonly size: _angular_core.Signal<forty_cdk_core.ElementBox | null>;
+    /** True while the thumb is being dragged. Pins the track visible / painted. */
+    readonly dragging: _angular_core.Signal<boolean>;
+    /**
+     * Marks the track as actively dragged so an in-flight drag is never aborted
+     * by the scrollbar self-hiding (`type="hover"` / `"scroll"` fading the track,
+     * or a consumer `display:none` on `data-state="hidden"`). Called by the thumb
+     * on pointer-down / drag-end.
+     */
+    setDragging(dragging: boolean): void;
+    readonly hasOverflow: _angular_core.Signal<boolean>;
+    /**
+     * Whether the track is rendered at all. `'always'` keeps it painted
+     * unconditionally (a stable, always-present track); every
+     * other `type` paints only the axis that actually overflows. An in-flight
+     * thumb drag also pins it painted so the gesture is never aborted by the
+     * track self-removing. Gates both the `hidden` attribute and the inline
+     * `display: none` self-removal.
+     */
+    readonly painted: _angular_core.Signal<boolean>;
+    /**
+     * `'visible' | 'hidden'`. An in-flight thumb drag forces `'visible'` so a
+     * consumer fade on `data-state="hidden"` can't hide the track mid-gesture.
+     * Otherwise: `'always'` resolves to `'visible'` regardless of overflow — the
+     * track is permanently present. `'auto'` shows whenever the axis overflows;
+     * `'hover'` / `'scroll'` additionally gate on the interaction signals. A
+     * non-overflowing axis is `'hidden'` for every mode except `'always'`.
+     */
+    readonly state: _angular_core.Signal<"visible" | "hidden">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollAreaScrollbar, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollAreaScrollbar, "[forScrollAreaScrollbar]", ["forScrollAreaScrollbar"], { "orientation": { "alias": "orientation"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The draggable thumb inside a `[forScrollAreaScrollbar]`. Sizes itself
+ * proportionally to viewport / content and translates along the track
+ * based on `scrollLeft` / `scrollTop`. Pointer-drag scrolls the viewport
+ * proportionally.
+ */
+declare class ForScrollAreaThumb {
+    #private;
+    readonly scrollbar: ForScrollAreaScrollbar;
+    constructor();
+    protected widthPx(): number | null;
+    protected heightPx(): number | null;
+    protected leftPx(): number | null;
+    protected topPx(): number | null;
+    protected transformValue(): string;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onLostPointerCapture(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollAreaThumb, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollAreaThumb, "[forScrollAreaThumb]", ["forScrollAreaThumb"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Filler in the corner where horizontal and vertical scrollbars meet.
+ * Shown when both axes overflow, or unconditionally under `type="always"`
+ * (both tracks are permanently present then). Visibility is enforced with an
+ * inline `display: none` (which beats any author `display` rule a consumer
+ * applies via a class) in addition to the `hidden` attribute that removes it
+ * from the a11y tree.
+ */
+declare class ForScrollAreaCorner {
+    protected readonly ctx: forty_cdk_scroll_area.ForScrollAreaContext;
+    protected readonly visible: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForScrollAreaCorner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForScrollAreaCorner, "[forScrollAreaCorner]", ["forScrollAreaCorner"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant scroll areas in the surrounding injector
+ * scope. Configure with `provideForScrollAreaDefaults` either at the
+ * application root or in any component's `providers` array; partial
+ * overrides merge with the parent scope.
+ */
+interface ForScrollAreaDefaults {
+    /**
+     * Milliseconds after the most recent scroll before the synthetic
+     * scrollbars fade. Applies when `type` is `'scroll'` or `'hover'`.
+     */
+    scrollHideDelay: number;
+}
+/** Token holding the resolved scroll-area defaults for the current scope. */
+declare const FOR_SCROLL_AREA_DEFAULTS: _angular_core.InjectionToken<ForScrollAreaDefaults>;
+/**
+ * Configures forty-cdk scroll-area defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForScrollAreaDefaults(defaults?: Partial<ForScrollAreaDefaults>): Provider[];
+
+export { FOR_SCROLL_AREA_CONTEXT, FOR_SCROLL_AREA_DEFAULTS, ForScrollArea, ForScrollAreaContent, ForScrollAreaCorner, ForScrollAreaScrollbar, ForScrollAreaThumb, ForScrollAreaViewport, provideForScrollAreaDefaults };
+export type { ForScrollAreaContext, ForScrollAreaDefaults, ForScrollAreaType, ForScrollbarOrientation };

package/types/forty-cdk-search.d.ts

@@ -0,0 +1,142 @@
+import { FormValueControl } from '@angular/forms/signals';
+import { TextValueControlBase } from 'forty-cdk/core';
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+
+/**
+ * Headless `role="searchbox"` text input implementing Angular's
+ * `FormValueControl<string>` from `@angular/forms/signals`, so it auto-wires
+ * with `[formField]` and auto-associates inside a `[forField]` (label /
+ * description / error) with no extra markup. Reuses the exact form-value
+ * wiring of `[forInput]` — same IME handling, same value mirror, same
+ * validation reflection.
+ *
+ * Apply on a native `<input>`. The element keeps its own `type`, caret, IME
+ * composition, and native form submission — the directive only bridges the
+ * value to a signal, reflects validation state, and emits `role="searchbox"`.
+ *
+ * Pair with `[forSearchClear]` (passing the exported instance) for an inline
+ * clear-button affordance that hides itself while the value is empty.
+ *
+ * @example
+ * ```html
+ * <input forSearch #s="forSearch" [(value)]="q" />
+ * <button [forSearchClear]="s">×</button>
+ *
+ * <!-- With Signal Forms + Field (auto-wired): -->
+ * <div forField>
+ *   <label forLabel>Search</label>
+ *   <input forSearch [formField]="search.query" />
+ * </div>
+ * ```
+ */
+declare class ForSearch extends TextValueControlBase implements FormValueControl<string> {
+    #private;
+    /**
+     * Resets the value to `''`. Typically called by `[forSearchClear]` when the
+     * user activates the clear button, but can also be called programmatically.
+     */
+    clear(): void;
+    /**
+     * Moves focus to the native input element. Called by `[forSearchClear]`
+     * after clearing so the user can continue typing without chasing the caret.
+     */
+    focusInput(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ForSearch, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ForSearch, "input[forSearch]", ["forSearch"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Optional clear button for `[forSearch]`. Apply on a `<button>` element and
+ * pass the exported search instance through the selector input:
+ * `[forSearchClear]="s"` where `#s="forSearch"` is on the `<input>`.
+ *
+ * The button self-hides while the value is `''`, so consumers can leave it
+ * inline in the template without an extra `@if`. Visibility is enforced with
+ * an inline `display: none` (which beats any author `display` rule applied via
+ * a class) in addition to the `hidden` attribute that removes the element from
+ * the accessibility tree. This mirrors `[forComboboxClear]`'s approach.
+ *
+ * On activation (click) the button clears the value to `''` and refocuses the
+ * input so the user can continue typing without chasing the caret.
+ *
+ * The `aria-label="Clear"` default is set as a static host attribute. Consumers
+ * who want a different label can override it with their own `aria-label` on the
+ * same element — the consumer's attribute wins per Angular's host-binding
+ * precedence rules.
+ *
+ * The button stays in the natural tab order (no `tabindex="-1"`) unlike
+ * `[forComboboxClear]`, which lives inside an `aria-activedescendant` flow.
+ */
+declare class ForSearchClear {
+    /**
+     * The `[forSearch]` instance to operate on. Pass the exported reference:
+     * `<input forSearch #s="forSearch" /> <button [forSearchClear]="s">`.
+     */
+    readonly search: i0.InputSignal<ForSearch>;
+    /** `true` while there is text to clear; drives the self-hide logic. */
+    protected readonly hasContent: i0.Signal<boolean>;
+    /**
+     * Disabled when the search field is disabled or read-only — the clear action
+     * is unavailable in those states.
+     */
+    protected readonly isDisabled: i0.Signal<boolean>;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ForSearchClear, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ForSearchClear, "[forSearchClear]", ["forSearchClear"], { "search": { "alias": "forSearchClear"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant `[forSearch]` controls in the surrounding
+ * injector scope. Configure with `provideForSearchDefaults`. The shape is a
+ * stub today — present so future per-scope tuning can land without churning
+ * the public surface.
+ */
+interface ForSearchDefaults {
+}
+/** Token holding the resolved search-field defaults for the current scope. */
+declare const FOR_SEARCH_DEFAULTS: i0.InjectionToken<ForSearchDefaults>;
+/**
+ * Configures forty-cdk search-field defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForSearchDefaults(defaults?: Partial<ForSearchDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForSearch` input, its models included. Spread it into the
+ * `inputs` array of a `hostDirectives` entry so a wrapper component re-exposes the
+ * primitive's full surface — the Signal Forms members `[formField]` binds among them —
+ * without hand-maintaining the list. Always spread into an inline object literal as shown
+ * below: the literal is what keeps the entry statically analyzable for consumers compiling
+ * against the published package. An anti-drift spec fails when this list no longer matches
+ * the directive's actual API. See `docs/wrapping-form-primitives.md` for both supported
+ * wrapping patterns.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'input[mySearch]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForSearch,
+ *       inputs: [...FOR_SEARCH_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MySearch {}
+ * ```
+ */
+declare const FOR_SEARCH_HOST_DIRECTIVE_INPUTS: readonly ["value", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForSearch` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_SEARCH_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
+export { FOR_SEARCH_DEFAULTS, FOR_SEARCH_HOST_DIRECTIVE_INPUTS, FOR_SEARCH_HOST_DIRECTIVE_OUTPUTS, ForSearch, ForSearchClear, provideForSearchDefaults };
+export type { ForSearchDefaults };