forty-cdk 0.2.0 → 0.3.0

package/types/forty-cdk-file-upload.d.ts

@@ -0,0 +1,124 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import * as forty_cdk_file_upload from 'forty-cdk/file-upload';
+
+/**
+ * Shared state contract between the pieces of a FileUpload primitive.
+ * Provided by `ForFileUpload`, consumed by `ForFileUploadInput` and
+ * `ForFileUploadTrigger`.
+ */
+interface ForFileUploadContext {
+    readonly accept: Signal<string | null>;
+    readonly multiple: Signal<boolean>;
+    readonly directory: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    /** Registers the native `<input type="file">` so the root can open the dialog and sync dropped files. */
+    registerInput(el: HTMLInputElement): void;
+    /** Opens the native file chooser dialog by programmatically clicking the registered input. */
+    openFileDialog(): void;
+    /** Emits `filesChange` with the given `FileList` if it is non-empty. */
+    emitFiles(files: FileList): void;
+}
+declare const FOR_FILE_UPLOAD_CONTEXT: InjectionToken<ForFileUploadContext>;
+
+/**
+ * Root drop zone for the FileUpload primitive. Composes with
+ * `[forFileUploadInput]` (the accessible native file input) and
+ * `[forFileUploadTrigger]` (the button that opens the dialog).
+ *
+ * `filesChange` is a plain `output<FileList>()` — this primitive is not a
+ * Signal Forms control; the native `<input type="file">` is the form participant.
+ *
+ * Reflects `data-dragging` while files are dragged over the zone and
+ * `data-disabled` when the input is disabled.
+ */
+declare class ForFileUpload implements ForFileUploadContext {
+    #private;
+    /** MIME types or file extensions accepted by the file chooser (e.g. `"image/*,.pdf"`). */
+    readonly accept: _angular_core.InputSignal<string | null>;
+    /** Whether multiple files can be selected at once. */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When `true`, the native picker selects a whole folder; the emitted
+     * `FileList` then contains every file inside it (each carrying a
+     * `webkitRelativePath` so the consumer can reconstruct the tree).
+     */
+    readonly directory: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Whether the file upload zone and all its pieces are disabled. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Emitted when files are chosen via the dialog or dropped onto the zone. */
+    readonly filesChange: _angular_core.OutputEmitterRef<FileList>;
+    protected readonly dragging: _angular_core.Signal<boolean>;
+    /** Registers the native input so the root can open the dialog and sync dropped files. */
+    registerInput(el: HTMLInputElement): void;
+    /** Opens the native file chooser dialog if not disabled. */
+    openFileDialog(): void;
+    /** Emits `filesChange` with the provided `FileList` if it contains at least one file. */
+    emitFiles(files: FileList): void;
+    protected onDragEnter(event: DragEvent): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDragLeave(): void;
+    protected onDrop(event: DragEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUpload, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUpload, "[forFileUpload]", ["forFileUpload"], { "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "directory": { "alias": "directory"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "filesChange": "filesChange"; }, never, never, true, never>;
+}
+
+/**
+ * The native `<input type="file">` piece of the FileUpload primitive.
+ * Apply on a real `<input>` element inside `[forFileUpload]`.
+ *
+ * The directive forces `type="file"` and mirrors `accept`, `multiple`,
+ * `directory` (as `webkitdirectory`), and `disabled` from the root context.
+ * When the user selects files via the native dialog the `change` event emits
+ * `filesChange` on the root.
+ *
+ * Consumers are expected to visually hide this input with their own CSS
+ * (e.g. an `sr-only` / `visually-hidden` utility) while keeping it focusable
+ * so keyboard users and assistive technology can activate it directly. The
+ * directive never sets `hidden`, `display:none`, or `visibility:hidden` — it
+ * remains strictly headless.
+ */
+declare class ForFileUploadInput {
+    #private;
+    protected readonly ctx: forty_cdk_file_upload.ForFileUploadContext;
+    constructor();
+    protected onChange(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUploadInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUploadInput, "input[forFileUploadInput]", ["forFileUploadInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Trigger button that opens the native file chooser dialog.
+ * Apply on a native `<button>` inside `[forFileUpload]`.
+ *
+ * `type="button"` is forced to prevent accidental form submission.
+ * The native `disabled` attribute is reflected imperatively so the button
+ * is visually and functionally disabled when the root zone is disabled.
+ */
+declare class ForFileUploadTrigger {
+    protected readonly ctx: forty_cdk_file_upload.ForFileUploadContext;
+    constructor();
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForFileUploadTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForFileUploadTrigger, "[forFileUploadTrigger]", ["forFileUploadTrigger"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant file-upload zones in the surrounding
+ * injector scope. Configure with `provideForFileUploadDefaults`. The shape
+ * is a stub today — present so future per-scope tuning can land without
+ * churning the public surface.
+ */
+interface ForFileUploadDefaults {
+}
+/** Token holding the resolved file-upload defaults for the current scope. */
+declare const FOR_FILE_UPLOAD_DEFAULTS: _angular_core.InjectionToken<ForFileUploadDefaults>;
+/**
+ * Configures forty-cdk file-upload defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForFileUploadDefaults(defaults?: Partial<ForFileUploadDefaults>): Provider[];
+
+export { FOR_FILE_UPLOAD_CONTEXT, FOR_FILE_UPLOAD_DEFAULTS, ForFileUpload, ForFileUploadInput, ForFileUploadTrigger, provideForFileUploadDefaults };
+export type { ForFileUploadContext, ForFileUploadDefaults };

package/types/forty-cdk-hover-card.d.ts

@@ -0,0 +1,320 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { AnchoredPositioningContext, FloatingSide, FloatingAlign, VetoableNativeEvent } from 'forty-cdk/core';
+import * as forty_cdk_hover_card from 'forty-cdk/hover-card';
+
+/** Why an open / close was scheduled. */
+type HoverCardScheduleReason = 'hover-trigger' | 'hover-content' | 'focus' | 'escape';
+interface ForHoverCardContext extends AnchoredPositioningContext {
+    readonly open: Signal<boolean>;
+    readonly disabled: Signal<boolean>;
+    readonly trigger: Signal<HTMLElement | null>;
+    readonly content: Signal<HTMLElement | null>;
+    registerTrigger(el: HTMLElement): void;
+    unregisterTrigger(el: HTMLElement): void;
+    registerArrow(el: HTMLElement): void;
+    unregisterArrow(el: HTMLElement): void;
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
+    /** Schedule the card to open after `openDelay` ms (instant when delay is 0). */
+    scheduleOpen(reason: HoverCardScheduleReason): void;
+    /** Schedule the card to close after `closeDelay` ms (instant on `escape`). */
+    scheduleClose(reason: HoverCardScheduleReason): void;
+    /** Cancel any pending open / close timer without changing state. */
+    cancelPending(): void;
+    /**
+     * Emit the public `(escapeKeyDown)` output and, unless prevented, close.
+     * Driven by the content's document-level dismissable layer, so the card
+     * responds to Escape regardless of where focus lives — including a card
+     * opened by hover while focus sits on an unrelated element.
+     */
+    emitEscapeKeyDown(event: KeyboardEvent): void;
+}
+declare const FOR_HOVER_CARD_CONTEXT: InjectionToken<ForHoverCardContext>;
+
+/**
+ * Headless hover-preview card. Use it to surface rich, interactive previews
+ * (profile snapshots, link previews, definition cards) on hover or focus
+ * of an already-meaningful trigger (a link, a name).
+ *
+ * **Not a tooltip.** Hover-cards may contain interactive content
+ * (clickable links, copy buttons, …); the trigger must convey full meaning
+ * on its own so keyboard-only users miss nothing.
+ *
+ * Open / close delays default to 700 / 300 ms; the per-injector-scope
+ * `provideForHoverCardDefaults` configures the cadence and the skip-delay
+ * window for adjacent cards.
+ *
+ * @example
+ * ```html
+ * <span forHoverCard #card="forHoverCard">
+ *   <a forHoverCardTrigger href="/users/ada">Ada Lovelace</a>
+ *   @if (card.open()) {
+ *     <div forHoverCardContent animate.enter="fade-in" animate.leave="fade-out">
+ *       <img src="/api/avatar/ada" alt="" />
+ *       <h3>Ada Lovelace</h3>
+ *       <p>Mathematician.</p>
+ *     </div>
+ *   }
+ * </span>
+ * ```
+ */
+declare class ForHoverCard implements ForHoverCardContext {
+    #private;
+    /**
+     * Two-way bindable. Whether the card is currently shown. The `model()`
+     * change emitter (`(openChange)`) fires only on internal transitions
+     * (delay-driven, escape, blur, and the force-close that runs when `disabled`
+     * flips to true), never on consumer writes through `[(open)]`.
+     */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * Per-card override for the side the card is anchored to. Pair with
+     * `align` for the full positioning API. When `undefined` (default), falls
+     * back to `ForHoverCardDefaults.side` from the surrounding
+     * `provideForHoverCardDefaults` scope (`'top'` unless configured).
+     *
+     * The input is aliased to `side`; consumers bind `[side]="..."` and read
+     * the effective value via the public `side` computed below.
+     */
+    readonly _sideInput: _angular_core.InputSignal<FloatingSide | undefined>;
+    /** Effective anchor side: the `side` input when set, else the scope default. */
+    readonly side: _angular_core.Signal<FloatingSide>;
+    /**
+     * Per-card override for the alignment along the chosen `side`. When
+     * `undefined` (default), falls back to `ForHoverCardDefaults.align` from the
+     * surrounding `provideForHoverCardDefaults` scope (`'center'` unless
+     * configured).
+     *
+     * The input is aliased to `align`; consumers bind `[align]="..."` and read
+     * the effective value via the public `align` computed below.
+     */
+    readonly _alignInput: _angular_core.InputSignal<FloatingAlign | undefined>;
+    /** Effective alignment: the `align` input when set, else the scope default. */
+    readonly align: _angular_core.Signal<FloatingAlign>;
+    /**
+     * Per-card override for the gap (px) between trigger and card along the
+     * main axis. When `undefined` (default),
+     * falls back to `ForHoverCardDefaults.sideOffset` from the surrounding
+     * `provideForHoverCardDefaults` scope (`8` unless configured).
+     *
+     * The input is aliased to `sideOffset`; consumers bind `[sideOffset]="..."`
+     * and read the effective value via the public `sideOffset` computed below.
+     */
+    readonly _sideOffsetInput: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Effective main-axis gap (px): the `sideOffset` input when set, else the scope default. */
+    readonly sideOffset: _angular_core.Signal<number>;
+    /** Gap (px) along the cross axis. Default `0`. */
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** When `true` (default), `flip` and `shift` keep the card inside the viewport. */
+    readonly avoidCollisions: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Per-card override for the padding (px) applied uniformly to the `flip`,
+     * `shift`, and `size` middlewares. When `undefined` (default), falls back
+     * to `ForHoverCardDefaults.collisionPadding` from the surrounding
+     * `provideForHoverCardDefaults` scope (`8` unless configured).
+     *
+     * The input is aliased to `collisionPadding`; consumers bind
+     * `[collisionPadding]="..."` and read the effective value via the public
+     * `collisionPadding` computed below.
+     */
+    readonly _collisionPaddingInput: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** Effective collision padding (px): the `collisionPadding` input when set, else the scope default. */
+    readonly collisionPadding: _angular_core.Signal<number>;
+    /** Padding (px) for the `arrow` middleware. Default `0`. */
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Stickiness behaviour for `shift`. Default `'partial'`. */
+    readonly sticky: _angular_core.InputSignal<false | "partial" | "always">;
+    /** When `true`, sets `data-detached=""` while the trigger is scrolled off-screen. */
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * When `true` (default), the content is clipped until floating-ui resolves
+     * its first position, preventing a flash at the viewport corner. Set to
+     * `false` so a dramatic `animate.enter` plays from its first frame (the
+     * surface may flash briefly at the unresolved position while positioning
+     * computes).
+     */
+    readonly clipUntilPositioned: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Per-card override for open delay (ms). Falls back to coordinator (700ms). */
+    readonly openDelay: _angular_core.InputSignal<number | undefined>;
+    /** Per-card override for close delay (ms). Falls back to coordinator (300ms). */
+    readonly closeDelay: _angular_core.InputSignal<number | undefined>;
+    /** When true, all hover / focus interaction is ignored and any open card is forced closed. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Fires when the user presses Escape while the card is open, regardless of
+     * where focus currently lives — on the trigger, inside the portaled
+     * content, or on an unrelated element (the common case for a card opened by
+     * hover). Routed through the content's document-level dismissable layer.
+     * Call `preventDefault()` on the emitted veto to suppress the automatic
+     * close. The native `KeyboardEvent` is on `.event`.
+     */
+    readonly escapeKeyDown: _angular_core.OutputEmitterRef<VetoableNativeEvent<KeyboardEvent>>;
+    readonly trigger: _angular_core.Signal<HTMLElement | null>;
+    readonly arrow: _angular_core.Signal<HTMLElement | null>;
+    readonly content: _angular_core.Signal<HTMLElement | null>;
+    constructor();
+    registerTrigger(el: HTMLElement): void;
+    unregisterTrigger(el: HTMLElement): void;
+    registerArrow(el: HTMLElement): void;
+    unregisterArrow(el: HTMLElement): void;
+    registerContent(el: HTMLElement): void;
+    unregisterContent(el: HTMLElement): void;
+    scheduleOpen(_reason: HoverCardScheduleReason): void;
+    scheduleClose(reason: HoverCardScheduleReason): void;
+    cancelPending(): void;
+    /**
+     * Emit `(escapeKeyDown)` and, unless the consumer calls `preventDefault()`
+     * on the veto, close immediately. Driven by the content's document-level
+     * dismissable layer so Escape works no matter where focus currently lives
+     * — including a hover-opened card with focus on an unrelated element.
+     */
+    emitEscapeKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForHoverCard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForHoverCard, "[forHoverCard]", ["forHoverCard"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "_sideInput": { "alias": "side"; "required": false; "isSignal": true; }; "_alignInput": { "alias": "align"; "required": false; "isSignal": true; }; "_sideOffsetInput": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "avoidCollisions": { "alias": "avoidCollisions"; "required": false; "isSignal": true; }; "_collisionPaddingInput": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "clipUntilPositioned": { "alias": "clipUntilPositioned"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "escapeKeyDown": "escapeKeyDown"; }, never, never, true, never>;
+}
+
+/**
+ * Element that activates the hover-card on hover or focus. Apply on a link,
+ * a button, or any focusable element that already conveys the underlying
+ * action (the card adds preview, not meaning).
+ *
+ * Reflects `data-state` so consumers can style the trigger when its card is
+ * open (e.g. an underline that turns solid).
+ *
+ * **Intentional ARIA exception.** The trigger exposes no `aria-controls`,
+ * `aria-expanded`, or `aria-describedby`, and `[forHoverCardContent]` carries
+ * no role. This is deliberate: the trigger must already be
+ * self-meaningful (a link or button that conveys the underlying action on its
+ * own — the card adds preview, not meaning), and the card is non-essential
+ * supplementary content that is hover/focus-revealed and not part of the
+ * accessibility relationship. Popover / Tooltip, whose content is meant to be
+ * discovered via the trigger, do wire trigger ARIA — HoverCard intentionally
+ * does not.
+ *
+ * Escape dismissal is owned by the content's document-level dismissable
+ * layer (see `ForHoverCardContent`), so it works from the trigger and from
+ * unrelated focus alike — the trigger carries no Escape listener of its own.
+ *
+ * The root is normally resolved via DI from the enclosing `[forHoverCard]`.
+ * When the trigger is declared inside an `ng-template` stamped into the root
+ * (e.g. via `ngTemplateOutlet`), DI resolves at the template's declaration
+ * site and misses the root — pass it explicitly through the selector input,
+ * `routerLink`-style: `[forHoverCardTrigger]="root"` with `#root="forHoverCard"`.
+ */
+declare class ForHoverCardTrigger {
+    #private;
+    /**
+     * Optional explicit reference to the `[forHoverCard]` root, named after the
+     * selector `routerLink`-style. The bare valueless attribute keeps resolving
+     * the enclosing root via DI; pass the root explicitly
+     * (`[forHoverCardTrigger]="root"`, with `#root="forHoverCard"`) when the
+     * trigger is declared in an `ng-template` stamped inside the root — DI
+     * resolves at the template's declaration site, so the enclosing root is
+     * invisible there. The empty string (what the valueless attribute yields)
+     * is treated as unset.
+     */
+    readonly forHoverCardTrigger: _angular_core.InputSignal<"" | ForHoverCardContext>;
+    protected readonly ctx: _angular_core.Signal<ForHoverCardContext>;
+    constructor();
+    protected onPointerEnter(): void;
+    protected onPointerLeave(event: PointerEvent): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForHoverCardTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForHoverCardTrigger, "[forHoverCardTrigger]", ["forHoverCardTrigger"], { "forHoverCardTrigger": { "alias": "forHoverCardTrigger"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The hover-card surface. Portaled to `document.body` and positioned by
+ * floating-ui (via the shared `injectOverlayShell` helper). Pointer-enter
+ * on the content cancels the pending close, so the user can move the
+ * cursor from the trigger into the card to interact with its content
+ * (links, buttons, copy targets).
+ *
+ * Mount / unmount via `@if (card.open())` on the consumer side so
+ * `animate.enter` / `animate.leave` work natively.
+ *
+ * Escape is routed through the shared document-level `DismissableLayer`
+ * (Escape-only — outside dismissal stays implicit via pointer-leave
+ * timing), so it dismisses the card no matter where focus lives when the
+ * card was hover-opened. Initial-focus and return-focus bundles are
+ * omitted because the surface is informational and never steals focus.
+ *
+ * **Intentional ARIA exception.** The content carries no role (only
+ * `data-state` for styling) and the trigger exposes no ARIA linkage — the
+ * card is non-essential supplementary content. See
+ * `ForHoverCardTrigger` for the full rationale.
+ */
+declare class ForHoverCardContent {
+    protected readonly ctx: forty_cdk_hover_card.ForHoverCardContext;
+    constructor();
+    protected onPointerEnter(): void;
+    protected onPointerLeave(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForHoverCardContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForHoverCardContent, "[forHoverCardContent]", ["forHoverCardContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Arrow pointing from the card back to its trigger. Floating-ui places it
+ * along the right edge so the consumer only has to give it a size and a
+ * background — no positioning math required.
+ */
+declare class ForHoverCardArrow {
+    #private;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ForHoverCardArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ForHoverCardArrow, "[forHoverCardArrow]", ["forHoverCardArrow"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant hover-cards in the surrounding injector
+ * scope. Configure with `provideForHoverCardDefaults` at the app root or in
+ * any component's `providers`.
+ */
+interface ForHoverCardDefaults {
+    /** Open delay (ms) for cards that don't override `openDelay` locally. */
+    openDelay: number;
+    /** Close delay (ms) for cards that don't override `closeDelay` locally. */
+    closeDelay: number;
+    /**
+     * Window (ms) after a peer card in this scope closes during which the
+     * next open is instant — useful for adjacent profile cards in a list,
+     * so cursor movement doesn't feel sluggish.
+     */
+    skipDelayDuration: number;
+    /**
+     * Side the card is anchored to for cards that don't override `side`
+     * locally. Library fallback `'top'`.
+     */
+    side: FloatingSide;
+    /**
+     * Alignment along the chosen `side` for cards that don't override `align`
+     * locally. Library fallback `'center'`.
+     */
+    align: FloatingAlign;
+    /**
+     * Gap (px) between trigger and card along the main axis for cards that
+     * don't override `sideOffset` locally.
+     * Library fallback `8`.
+     */
+    sideOffset: number;
+    /**
+     * Padding (px) applied uniformly to the `flip`, `shift`, and `size`
+     * middlewares for cards that don't override `collisionPadding` locally.
+     * Library fallback `8`.
+     */
+    collisionPadding: number;
+}
+/** Token holding the resolved hover-card defaults for the current scope. */
+declare const FOR_HOVER_CARD_DEFAULTS: _angular_core.InjectionToken<ForHoverCardDefaults>;
+/**
+ * Configures forty-cdk hover-card defaults for this injector scope.
+ * Partial overrides inherit unspecified keys from the parent scope (or
+ * library defaults at the root). Each call establishes a new coordinator
+ * scope.
+ */
+declare function provideForHoverCardDefaults(defaults?: Partial<ForHoverCardDefaults>): Provider[];
+
+export { FOR_HOVER_CARD_CONTEXT, FOR_HOVER_CARD_DEFAULTS, ForHoverCard, ForHoverCardArrow, ForHoverCardContent, ForHoverCardTrigger, provideForHoverCardDefaults };
+export type { ForHoverCardContext, ForHoverCardDefaults, HoverCardScheduleReason };

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

@@ -0,0 +1,169 @@
+import { FormValueControl } from '@angular/forms/signals';
+import { TextValueControlBase } from 'forty-cdk/core';
+import * as i0 from '@angular/core';
+import { Provider } from '@angular/core';
+
+/**
+ * Headless 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.
+ *
+ * Apply on a native `<input>`. The element keeps its own `type`
+ * (`text` / `email` / `password` / …), caret, IME composition, and native form
+ * submission — the directive only bridges the value to a signal and reflects
+ * validation state. For a multi-line control use `[forTextarea]`.
+ *
+ * The host gets `data-empty` (while the value is `''`), `data-disabled`, and
+ * `data-readonly` for CSS hooks.
+ *
+ * @example
+ * ```html
+ * <input forInput [(value)]="email" type="email" />
+ *
+ * <!-- With Signal Forms + Field (auto-wired): -->
+ * <div forField>
+ *   <label forLabel>Full name</label>
+ *   <input forInput [formField]="profile.name" />
+ * </div>
+ * ```
+ */
+declare class ForInput extends TextValueControlBase implements FormValueControl<string> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ForInput, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ForInput, "[forInput]", ["forInput"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * Headless multi-line text `<textarea>` 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.
+ *
+ * Apply on a native `<textarea>`. The element keeps its own caret, wrapping,
+ * IME composition, and native form submission — the directive only bridges the
+ * value to a signal and reflects validation state. The string-valued sibling
+ * of `[forInput]`.
+ *
+ * The host gets `data-empty` (while the value is `''`), `data-disabled`, and
+ * `data-readonly` for CSS hooks.
+ *
+ * With `[autosize]` the host grows and shrinks its height to fit the content on
+ * every edit, programmatic value change, and width reflow, and reflects
+ * `data-autosize` for styling (pair it with `resize: none; overflow: hidden;`).
+ * Autosize is a DOM side effect gated to the browser, so it is inert under SSR.
+ *
+ * @example
+ * ```html
+ * <textarea forTextarea [(value)]="bio" placeholder="About you"></textarea>
+ *
+ * <!-- Grow to content: -->
+ * <textarea forTextarea autosize [(value)]="bio"></textarea>
+ *
+ * <!-- With Signal Forms + Field (auto-wired): -->
+ * <div forField>
+ *   <label forLabel>Bio</label>
+ *   <textarea forTextarea [formField]="profile.bio"></textarea>
+ * </div>
+ * ```
+ */
+declare class ForTextarea extends TextValueControlBase implements FormValueControl<string> {
+    #private;
+    /**
+     * Opt into height auto-sizing. When `true` the textarea's height tracks its
+     * content: it grows as the value gets taller and shrinks back as it gets
+     * shorter, recomputed on every edit, on programmatic `value` writes, and on
+     * width reflow. Defaults to `false`, leaving the element's height to CSS.
+     */
+    readonly autosize: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ForTextarea, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ForTextarea, "[forTextarea]", ["forTextarea"], { "autosize": { "alias": "autosize"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Defaults inherited by descendant `[forInput]` / `[forTextarea]` controls in
+ * the surrounding injector scope. Configure with `provideForInputDefaults`.
+ * The shape is a stub today — present so future per-scope tuning can land
+ * without churning the public surface.
+ */
+interface ForInputDefaults {
+}
+/** Token holding the resolved text-input defaults for the current scope. */
+declare const FOR_INPUT_DEFAULTS: i0.InjectionToken<ForInputDefaults>;
+/**
+ * Configures forty-cdk text-input defaults for this injector scope. Partial
+ * overrides inherit unspecified keys from the parent scope (or library
+ * defaults at the root).
+ */
+declare function provideForInputDefaults(defaults?: Partial<ForInputDefaults>): Provider[];
+
+/**
+ * Exact public names of every `ForInput` 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[myInput]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForInput,
+ *       inputs: [...FOR_INPUT_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_INPUT_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MyInput {}
+ * ```
+ */
+declare const FOR_INPUT_HOST_DIRECTIVE_INPUTS: readonly ["value", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForInput` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_INPUT_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_INPUT_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
+/**
+ * Exact public names of every `ForTextarea` 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: 'textarea[myTextarea]',
+ *   template: '',
+ *   hostDirectives: [
+ *     {
+ *       directive: ForTextarea,
+ *       inputs: [...FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS],
+ *       outputs: [...FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS],
+ *     },
+ *   ],
+ * })
+ * export class MyTextarea {}
+ * ```
+ */
+declare const FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS: readonly ["value", "autosize", "dirty", "disabled", "errors", "invalid", "name", "pending", "readonly", "required", "touched"];
+/**
+ * Exact public names of every `ForTextarea` output, the Signal Forms `touch` output
+ * included. Spread it into the `outputs` array of the same `hostDirectives` entry as
+ * {@link FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS}.
+ */
+declare const FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS: readonly ["valueChange", "touchedChange", "touch"];
+
+export { FOR_INPUT_DEFAULTS, FOR_INPUT_HOST_DIRECTIVE_INPUTS, FOR_INPUT_HOST_DIRECTIVE_OUTPUTS, FOR_TEXTAREA_HOST_DIRECTIVE_INPUTS, FOR_TEXTAREA_HOST_DIRECTIVE_OUTPUTS, ForInput, ForTextarea, provideForInputDefaults };
+export type { ForInputDefaults };

package/types/forty-cdk-internationalized-date.d.ts

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 import { Provider } from '@angular/core';
 import { CalendarDate, CalendarDateTime } from '@internationalized/date';
-import { DateAdapter } from 'forty-cdk';
+import { DateAdapter } from 'forty-cdk/core';
 
 /**
  * {@link DateAdapter} over `@internationalized/date`'s immutable `CalendarDate`.