@raqm/ui 0.0.0-stage → 0.1.1

package/types/raqm-ui-dropdown-menu.d.ts

@@ -0,0 +1,319 @@
+import * as i0 from "@angular/core";
+import { DestroyRef, InjectionToken, OnChanges, OnDestroy, OnInit, SimpleChanges } from "@angular/core";
+import { Direction, Directionality } from "@angular/cdk/bidi";
+import * as i2 from "@angular/cdk/menu";
+import { CdkContextMenuTrigger, CdkMenuItemCheckbox, CdkMenuItemRadio, CdkMenuTrigger, CdkMenuTriggerBase } from "@angular/cdk/menu";
+import { ConnectedPosition, OverlayRef } from "@angular/cdk/overlay";
+import { Subject } from "rxjs";
+/** @internal Computed CSS direction, including plain ancestors without CDK Dir. */
+export declare class RaqmMenuDirection extends Directionality {
+  private readonly element;
+  private observer;
+  private disposed;
+  get value(): Direction;
+  constructor();
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuDirection, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuDirection, never, never, {}, {}, never, never, true, never>;
+}
+/** @internal Bridge only the documented protected overlay extension point. */
+export declare class RaqmMenuTriggerBase extends CdkMenuTrigger {
+  get menuOverlay(): OverlayRef | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuTriggerBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuTriggerBase, never, never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmContextMenuTriggerBase extends CdkContextMenuTrigger {
+  readonly geometryChanged: Subject<void>;
+  get menuOverlay(): OverlayRef | null;
+  menuAnchorPoint: RaqmMenuAnchorPoint | null;
+  open(coordinates: {
+    x: number;
+    y: number;
+  }): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmContextMenuTriggerBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmContextMenuTriggerBase, never, never, {}, {}, never, never, true, never>;
+}
+/** @internal Pointer anchor coordinates used only by the shipped overlay bridge. */
+interface RaqmMenuAnchorPoint {
+  readonly x: number;
+  readonly y: number;
+}
+/** @internal Bridge options for shipped menu wrappers, not consumer configuration. */
+interface RaqmMenuOverlaySyncOptions {
+  readonly matchAnchorWidth: boolean;
+  readonly anchorPoint?: () => RaqmMenuAnchorPoint | null;
+  /** Recompute family defaults only; preserve explicit consumer positions. */
+  readonly positions?: () => ConnectedPosition[];
+}
+/** @internal Synchronizes the exact trigger overlay through public OverlayRef APIs. */
+export declare class RaqmMenuOverlaySync {
+  private readonly trigger;
+  private readonly anchor;
+  private readonly directionality;
+  private readonly options;
+  private generation;
+  private disposed;
+  private frame;
+  private overlay;
+  private releaseOwnership;
+  private resizeObserver;
+  private connection;
+  private readonly subscriptions;
+  private readonly schedule;
+  constructor(trigger: CdkMenuTriggerBase & {
+    readonly menuOverlay: OverlayRef | null;
+  }, anchor: HTMLElement, destroyRef: DestroyRef, directionality: Directionality, options: RaqmMenuOverlaySyncOptions);
+  refresh(): void;
+  private measure;
+  private observe;
+  private detach;
+}
+export declare class RaqmMenuDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuDirective, "[raqm-menu]", never, {}, {}, never, never, true, [{
+    directive: typeof RaqmMenuDirection;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i2.CdkMenu;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare class RaqmMenuGroupDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuGroupDirective, "[raqm-menu-group]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmMenuLabelDirective {
+  readonly inset: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuLabelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuLabelDirective, "[raqm-menu-label]", never, {
+    "inset": {
+      "alias": "inset";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Attribute directive marking a non-focusable decorative 1px rule between menu regions.
+ *
+ * @remarks
+ * Carries `role="separator"`/`aria-orientation` and is never a roving-tabindex item.
+ */
+export declare class RaqmMenuSeparatorDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuSeparatorDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuSeparatorDirective, "[raqm-menu-separator]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Attribute directive styling a passive keyboard-hint span inside a menu row.
+ *
+ * @remarks
+ * Display-only: no accelerator registration, global key listener or command service.
+ */
+export declare class RaqmMenuShortcutDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuShortcutDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuShortcutDirective, "[raqm-menu-shortcut]", never, {}, {}, never, never, true, never>;
+}
+export declare const RAQM_MENU_SUBMENU_POSITIONS: InjectionToken<ConnectedPosition[]>;
+export declare class RaqmMenuTriggerDirective implements OnInit {
+  private readonly trigger;
+  private readonly parentMenu;
+  readonly submenu: boolean;
+  private readonly element;
+  private readonly directionality;
+  private readonly submenuPositionsDefault;
+  private readonly overlaySync;
+  /**
+   * Installs the default placement when the application did not supply `positions`.
+   *
+   * @remarks
+   * Runs in `ngOnInit` so host-directive inputs are already applied; a non-null
+   * `menuPosition` is left untouched, so an application's list always wins.
+   */
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuTriggerDirective, "button[raqm-menu-trigger-for], a[raqm-menu-trigger-for]", never, {}, {}, never, never, true, [{
+    directive: typeof RaqmMenuDirection;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof RaqmMenuTriggerBase;
+    inputs: {
+      "cdkMenuTriggerFor": "raqm-menu-trigger-for";
+      "cdkMenuPosition": "positions";
+    };
+    outputs: {
+      "cdkMenuOpened": "opened";
+      "cdkMenuClosed": "closed";
+    };
+  }]>;
+}
+export declare class RaqmMenuItemDirective {
+  private readonly elementRef;
+  private readonly destroyRef;
+  private readonly item;
+  readonly appearance: import("@angular/core").InputSignal<"" | "default" | "destructive">;
+  protected readonly activeAppearance: import("@angular/core").Signal<"default" | "destructive">;
+  readonly inset: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly guardDisabledAnchor;
+  private readonly activateAnchorWithSpace;
+  constructor();
+  protected onPointerEnter(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuItemDirective, "button[raqm-menu-item], a[raqm-menu-item]", never, {
+    "appearance": {
+      "alias": "raqm-menu-item";
+      "required": false;
+      "isSignal": true;
+    };
+    "inset": {
+      "alias": "inset";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, [{
+    directive: typeof i2.CdkMenuItem;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+export declare class RaqmMenuCheckboxItemBase extends CdkMenuItemCheckbox {
+  trigger(options?: {
+    keepOpen: boolean;
+  }): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuCheckboxItemBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuCheckboxItemBase, never, never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmMenuCheckboxItemDirective implements OnDestroy {
+  private readonly checkbox;
+  private readonly element;
+  /** Indents the row to line up with indicator-bearing rows. */
+  readonly inset: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /**
+   * The public two-way checked model.
+   *
+   * @remarks
+   * Bound-only: the CDK's `checked` attribute transform is not exposed. The model is the
+   * single state channel.
+   */
+  readonly checked: import("@angular/core").ModelSignal<boolean>;
+  private readonly triggerSubscription;
+  constructor();
+  ngOnDestroy(): void;
+  protected onPointerEnter(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuCheckboxItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuCheckboxItemDirective, "button[raqm-menu-checkbox-item]", never, {
+    "inset": {
+      "alias": "inset";
+      "required": false;
+      "isSignal": true;
+    };
+    "checked": {
+      "alias": "checked";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "checked": "checkedChange";
+  }, never, never, true, [{
+    directive: typeof RaqmMenuCheckboxItemBase;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+    };
+    outputs: {};
+  }]>;
+}
+interface RaqmMenuRadioGroupContext {
+  isSelected(value: string): boolean;
+  /** Commits one user selection using the group's two-way model. */
+  select(value: string): void;
+  /** Registers an item value and rejects duplicate claims in development. */
+  register(value: string): void;
+  /** Releases a previously registered item value. */
+  unregister(value: string): void;
+}
+declare const RAQM_MENU_RADIO_GROUP: InjectionToken<RaqmMenuRadioGroupContext>;
+export declare class RaqmMenuRadioItemBase extends CdkMenuItemRadio {
+  /** Keeps the menu open while retaining the CDK's standard activation path. */
+  trigger(options?: {
+    keepOpen: boolean;
+  }): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuRadioItemBase, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuRadioItemBase, never, never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmMenuRadioGroupDirective implements RaqmMenuRadioGroupContext {
+  /** Selected item value, or null when the group has no current selection. */
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  /** Tracks live item claims so duplicate values are rejected within this group. */
+  private readonly registrations;
+  /** Checks the model without normalizing unknown externally supplied values. */
+  isSelected(value: string): boolean;
+  /** Commits a user selection; model signals suppress unchanged-value emissions. */
+  select(value: string): void;
+  /** Adds a value claim and reports duplicate/nonempty violations clearly in development. */
+  register(value: string): void;
+  /** Removes a value claim and permits later reuse when the last item is destroyed. */
+  unregister(value: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuRadioGroupDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuRadioGroupDirective, "[raqm-menu-radio-group]", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, [{
+    directive: typeof i2.CdkMenuGroup;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+/**
+ * Menu radio item deriving its checked state from the enclosing group's value.
+ * CDK owns ARIA, keyboard navigation, dispatch and disabled activation behavior.
+ */
+export declare class RaqmMenuRadioItemDirective implements OnInit, OnChanges, OnDestroy {
+  private readonly radio;
+  private readonly group;
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly inset: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** CDK triggered subscription, used to make exactly one model commit per activation. */
+  private readonly triggerSubscription;
+  /** Registered value retained so input changes and teardown release the correct claim. */
+  private registeredValue;
+  constructor();
+  ngOnInit(): void;
+  ngOnChanges(changes: SimpleChanges): void;
+  /** Swaps the registered claim only after the proposed value passes group validation. */
+  private updateRegistration;
+  ngOnDestroy(): void;
+  protected onPointerEnter(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmMenuRadioItemDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmMenuRadioItemDirective, "button[raqm-menu-radio-item]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "inset": {
+      "alias": "inset";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, [{
+    directive: typeof RaqmMenuRadioItemBase;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+    };
+    outputs: {};
+  }]>;
+}
+export declare const RaqmDropdownMenu: readonly [typeof RaqmMenuDirective, typeof RaqmMenuTriggerDirective, typeof RaqmMenuItemDirective, typeof RaqmMenuCheckboxItemDirective, typeof RaqmMenuRadioGroupDirective, typeof RaqmMenuRadioItemDirective, typeof RaqmMenuGroupDirective, typeof RaqmMenuLabelDirective, typeof RaqmMenuSeparatorDirective, typeof RaqmMenuShortcutDirective];
+export type { RaqmMenuAnchorPoint, RaqmMenuOverlaySyncOptions };

package/types/raqm-ui-empty.d.ts

@@ -0,0 +1,35 @@
+import * as i0 from "@angular/core";
+/** Layout only; the dashed border stays application-authored (no border-width reset ships). */
+export declare class RaqmEmptyComponent {
+  readonly icon: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyComponent, "raqm-empty", never, {
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class RaqmEmptyHeaderComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyHeaderComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyHeaderComponent, "raqm-empty-header", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmEmptyMediaComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyMediaComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyMediaComponent, "raqm-empty-media", never, {}, {}, never, ["*"], true, never>;
+}
+/** Heading selectors keep native heading semantics without a wrapper. */
+export declare class RaqmEmptyTitleComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyTitleComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyTitleComponent, "raqm-empty-title, h1[raqm-empty-title], h2[raqm-empty-title], h3[raqm-empty-title], h4[raqm-empty-title], h5[raqm-empty-title], h6[raqm-empty-title]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmEmptyDescriptionComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyDescriptionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyDescriptionComponent, "raqm-empty-description, p[raqm-empty-description]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare class RaqmEmptyContentComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmEmptyContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmEmptyContentComponent, "raqm-empty-content", never, {}, {}, never, ["*"], true, never>;
+}
+export declare const RaqmEmpty: readonly [typeof RaqmEmptyComponent, typeof RaqmEmptyHeaderComponent, typeof RaqmEmptyMediaComponent, typeof RaqmEmptyTitleComponent, typeof RaqmEmptyDescriptionComponent, typeof RaqmEmptyContentComponent];

package/types/raqm-ui-field.d.ts

@@ -0,0 +1,88 @@
+import * as i0 from "@angular/core";
+import { AfterContentChecked } from "@angular/core";
+/** Field container; `for`, `id`, `aria-describedby` and `aria-invalid` are app-owned. */
+export declare class RaqmFieldComponent {
+  readonly orientation: import("@angular/core").InputSignal<"vertical" | "horizontal" | "responsive">;
+  private readonly hostIsCustomElement;
+  protected readonly role: 'group' | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldComponent, "raqm-field, span[raqm-field]", never, {
+    "orientation": {
+      "alias": "orientation";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class RaqmFieldContentComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldContentComponent, "raqm-field-content, span[raqm-field-content]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Supporting text; the control's `id` and `aria-describedby` are app-owned. */
+export declare class RaqmFieldDescriptionComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldDescriptionComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldDescriptionComponent, "raqm-field-description, span[raqm-field-description]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Validation message; projected content wins over `errors` and no ids or ARIA attributes are generated. */
+export declare class RaqmFieldErrorComponent {
+  readonly errors: import("@angular/core").InputSignal<readonly ({
+    message?: string;
+  } | undefined)[]>;
+  protected readonly messages: import("@angular/core").Signal<readonly string[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldErrorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldErrorComponent, "raqm-field-error", ["raqmFieldError"], {
+    "errors": {
+      "alias": "errors";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Spacing container; a neutral host, not a `<fieldset>`, and the named container for a responsive Field. */
+export declare class RaqmFieldGroupComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldGroupComponent, "raqm-field-group", never, {}, {}, never, ["*"], true, never>;
+}
+/** Viewless marker on an app-authored `<label>`; native `for` and activation are preserved. */
+export declare class RaqmFieldLabelDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldLabelDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmFieldLabelDirective, "label[raqm-field-label]", never, {}, {}, never, never, true, never>;
+}
+/** Legend treatments; `label` selects the smaller step and setting both attributes throws. */
+export declare class RaqmFieldLegendComponent {
+  readonly legend: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly activeTreatment: import("@angular/core").Signal<"legend" | "label">;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldLegendComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldLegendComponent, "legend[raqm-field-legend]", never, {
+    "legend": {
+      "alias": "legend";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Captioned rule; the nested separator is semantic and adds no tab stop. */
+export declare class RaqmFieldSeparatorComponent implements AfterContentChecked {
+  private readonly host;
+  protected readonly hasCaption: import("@angular/core").WritableSignal<boolean>;
+  ngAfterContentChecked(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldSeparatorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldSeparatorComponent, "raqm-field-separator", never, {}, {}, never, ["*"], true, never>;
+}
+/** Viewless title styling; phrasing content, valid inside a `<label>`. */
+export declare class RaqmFieldTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmFieldTitleDirective, "span[raqm-field-title]", never, {}, {}, never, never, true, never>;
+}
+/** Native `<fieldset>` host; a disabled fieldset does not mirror `FormControl` state. */
+export declare class RaqmFieldsetComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmFieldsetComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmFieldsetComponent, "fieldset[raqm-fieldset]", never, {}, {}, never, ["*"], true, never>;
+}
+export declare const RaqmField: readonly [typeof RaqmFieldComponent, typeof RaqmFieldContentComponent, typeof RaqmFieldDescriptionComponent, typeof RaqmFieldErrorComponent, typeof RaqmFieldGroupComponent, typeof RaqmFieldLabelDirective, typeof RaqmFieldLegendComponent, typeof RaqmFieldSeparatorComponent, typeof RaqmFieldTitleDirective, typeof RaqmFieldsetComponent];

package/types/raqm-ui-hover-card.d.ts

@@ -0,0 +1,139 @@
+import * as i0 from "@angular/core";
+import { OnDestroy, TemplateRef } from "@angular/core";
+/** A physical side; logical inputs resolve to one of these before positioning. */
+type RaqmHoverCardSide = 'top' | 'bottom' | 'left' | 'right';
+/** A side as authored on the input; the two logical sides resolve against the live direction. */
+type RaqmHoverCardRequestedSide = RaqmHoverCardSide | 'inline-start' | 'inline-end';
+/** The popup alignment along the trigger's cross axis. */
+type RaqmHoverCardAlign = 'start' | 'center' | 'end';
+interface RaqmHoverCardPoint {
+  x: number;
+  y: number;
+}
+declare const DEFAULT_SIDE: RaqmHoverCardRequestedSide;
+declare const DEFAULT_ALIGN: RaqmHoverCardAlign;
+declare const DEFAULT_SIDE_OFFSET: number;
+declare const DEFAULT_ALIGN_OFFSET: number;
+/** Fallback when the trigger supplies no close delay. */
+declare const DEFAULT_CLOSE_DELAY = 300;
+/** Content exit duration: equals `--raqm-duration-fast` (100ms) used by the exit transition. */
+declare const EXIT_ANIMATION_MS = 100;
+/** Candidates for the focus scans; the CDK `InteractivityChecker` decides actual tabbability. */
+declare const TABBABLE_SELECTOR = "a[href], button, input, select, textarea, [tabindex], [contenteditable=\"true\"]";
+/** A native link or button; hover/focus intent never replaces native activation. */
+export declare class RaqmHoverCardTriggerDirective {
+  readonly element: HTMLElement;
+  protected readonly card: RaqmHoverCardComponent;
+  readonly delay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly closeDelay: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  constructor();
+  protected enter(event: Event): void;
+  protected leave(event: Event): void;
+  protected blur(event: Event): void;
+  protected keydown(event: Event): void;
+  protected focus(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmHoverCardTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmHoverCardTriggerDirective, "a[raqm-hover-card-trigger], button[raqm-hover-card-trigger]", never, {
+    "delay": {
+      "alias": "delay";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeDelay": {
+      "alias": "closeDelay";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** The portalled content template; the root owns placement. */
+export declare class RaqmHoverCardContentDirective {
+  readonly template: TemplateRef<unknown>;
+  private readonly card;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmHoverCardContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmHoverCardContentDirective, "ng-template[raqm-hover-card-content]", never, {}, {}, never, never, true, never>;
+}
+/** Nonmodal preview root: delayed intent, native activation and no focus theft. */
+export declare class RaqmHoverCardComponent implements OnDestroy {
+  private readonly overlay;
+  private readonly document;
+  private readonly host;
+  private readonly container;
+  private readonly injector;
+  private readonly checker;
+  private readonly panel;
+  readonly openValue: import("@angular/core").ModelSignal<boolean | undefined>;
+  readonly defaultOpen: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The preferred popup side; logical sides resolve against the live direction. */
+  readonly side: import("@angular/core").InputSignal<RaqmHoverCardRequestedSide>;
+  /** The popup alignment along the trigger's cross axis. */
+  readonly align: import("@angular/core").InputSignal<RaqmHoverCardAlign>;
+  /** The distance in pixels between the trigger and the card. */
+  readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** The distance in pixels along the alignment axis. */
+  readonly alignOffset: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly open: import("@angular/core").Signal<boolean>;
+  private readonly trigger;
+  protected readonly content: import("@angular/core").WritableSignal<RaqmHoverCardContentDirective | null>;
+  private readonly state;
+  protected readonly direction: import("@angular/core").WritableSignal<"ltr" | "rtl">;
+  protected readonly resolvedSide: import("@angular/core").WritableSignal<RaqmHoverCardSide>;
+  private readonly positionController;
+  private readonly layer;
+  private readonly keyboard;
+  private readonly intent;
+  constructor();
+  registerTrigger(trigger: RaqmHoverCardTriggerDirective): void;
+  unregisterTrigger(trigger: RaqmHoverCardTriggerDirective): void;
+  registerContent(content: RaqmHoverCardContentDirective): void;
+  unregisterContent(content: RaqmHoverCardContentDirective): void;
+  requestOpen(fromFocus?: boolean): void;
+  /** Closes without restoring, stealing or trapping focus. */
+  close(): void;
+  focusOut(event: FocusEvent): void;
+  triggerKeydown(event: KeyboardEvent): void;
+  protected panelKeydown(event: KeyboardEvent): void;
+  protected pointerEnter(event: PointerEvent): void;
+  protected contentFocus(): void;
+  /** A geometric corridor protects slow/diagonal transit, not just a short timeout. */
+  pointerLeave(event: PointerEvent): void;
+  ngOnDestroy(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmHoverCardComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmHoverCardComponent, "raqm-hover-card", never, {
+    "openValue": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "defaultOpen": {
+      "alias": "defaultOpen";
+      "required": false;
+      "isSignal": true;
+    };
+    "side": {
+      "alias": "side";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "sideOffset": {
+      "alias": "sideOffset";
+      "required": false;
+      "isSignal": true;
+    };
+    "alignOffset": {
+      "alias": "alignOffset";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "openValue": "openChange";
+  }, never, ["*"], true, never>;
+}
+export declare const RaqmHoverCard: readonly [typeof RaqmHoverCardComponent, typeof RaqmHoverCardTriggerDirective, typeof RaqmHoverCardContentDirective];
+export {};

package/types/raqm-ui-input-group.d.ts

@@ -0,0 +1,45 @@
+import * as i0 from "@angular/core";
+import * as i1 from "@raqm/ui/textarea";
+/** Group container; `role="group"` is set, the accessible name is app-owned, and the API is empty. */
+export declare class RaqmInputGroupComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmInputGroupComponent, "raqm-input-group", never, {}, {}, never, ["*"], true, never>;
+}
+/** Passive addon without a `role`; a click on passive space focuses the group control. */
+export declare class RaqmInputGroupAddonComponent {
+  readonly align: import("@angular/core").InputSignal<"inline-start" | "inline-end" | "block-start" | "block-end">;
+  private readonly host;
+  protected onHostClick(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupAddonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmInputGroupAddonComponent, "raqm-input-group-addon", never, {
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Non-interactive prefix/suffix text on a native `<span>` host. */
+export declare class RaqmInputGroupTextComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupTextComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmInputGroupTextComponent, "span[raqm-input-group-text]", never, {}, {}, never, ["*"], true, never>;
+}
+/** Styles a host that separately opts into RaqmButton. */
+export declare class RaqmInputGroupButtonDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupButtonDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmInputGroupButtonDirective, "button[raqm-button][raqm-input-group-button]", never, {}, {}, never, never, true, never>;
+}
+/** Marks an app-authored control; it must be a direct child and carry `aria-invalid="true"` when invalid. */
+export declare class RaqmInputGroupControlDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupControlDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmInputGroupControlDirective, "[raqm-input-group-control]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmInputGroupTextareaDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmInputGroupTextareaDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmInputGroupTextareaDirective, "textarea[raqm-input-group-textarea]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.RaqmTextarea;
+    inputs: {};
+    outputs: {};
+  }]>;
+}
+export declare const RaqmInputGroup: readonly [typeof RaqmInputGroupComponent, typeof RaqmInputGroupAddonComponent, typeof RaqmInputGroupTextComponent, typeof RaqmInputGroupButtonDirective, typeof RaqmInputGroupControlDirective, typeof RaqmInputGroupTextareaDirective];