@raqm/ui 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,230 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnDestroy, OnInit, Signal, TemplateRef } from "@angular/core";
+/** Stable reference to one registered top-level item: a trigger or a direct link. */
+interface RaqmNavigationMenuTopLevelRef {
+  /** The native element the root anchors the overlay to and focuses. */
+  readonly element: HTMLElement;
+  readonly triggerValue: string | null;
+  readonly content: Signal<TemplateRef<unknown> | null>;
+  readonly disabled: boolean;
+  focus(): void;
+}
+/** The typed contract a navigation menu root publishes to its descendants. */
+interface RaqmNavigationMenuContext {
+  readonly open: Signal<boolean>;
+  readonly activeValue: Signal<string | null>;
+  readonly panelId: Signal<string | null>;
+  isActive(value: string): boolean;
+  registerTopLevel(ref: RaqmNavigationMenuTopLevelRef): void;
+  unregisterTopLevel(ref: RaqmNavigationMenuTopLevelRef): void;
+  /** Records a panel link element for the open panel's logical Tab boundaries. */
+  registerPanelLink(element: HTMLElement): void;
+  unregisterPanelLink(element: HTMLElement): void;
+  /** Opens the disclosure for a trigger as a user action (may emit). */
+  openFromTrigger(ref: RaqmNavigationMenuTopLevelRef, focusContent: 'first' | 'last' | 'none'): void;
+  /** Toggles the disclosure for a trigger as a user action (may emit). */
+  toggleFromTrigger(ref: RaqmNavigationMenuTopLevelRef): void;
+  /** Closes the open disclosure as a user action (Escape/link/outside). */
+  closeFromUser(): void;
+  /** Delays a pointer-open for a hovered trigger (the single shared open timer). */
+  scheduleHoverOpen(ref: RaqmNavigationMenuTopLevelRef): void;
+  cancelHoverOpen(): void;
+  scheduleHoverClose(): void;
+  /** Whether a pointer destination belongs to a detached owned overlay. */
+  isInsideDetachedOverlay(node: Node | null): boolean;
+  cancelHoverClose(): void;
+  moveFocusAcrossTopLevel(event: KeyboardEvent, ref: RaqmNavigationMenuTopLevelRef): void;
+  handleTopLevelTab(event: KeyboardEvent, ref: RaqmNavigationMenuTopLevelRef): void;
+  handlePanelTab(event: KeyboardEvent, element: HTMLElement): void;
+  focusContent(focus: 'first' | 'last'): void;
+}
+/** Injection token for the parent navigation menu root; injected optionally. */
+declare const RAQM_NAVIGATION_MENU: InjectionToken<RaqmNavigationMenuContext>;
+/** A nav host coordinating one active disclosure trigger and its shared popup panel. */
+export declare class RaqmNavigationMenuComponent implements RaqmNavigationMenuContext, OnInit, OnDestroy {
+  private readonly host;
+  private readonly overlay;
+  private readonly viewContainerRef;
+  private readonly injector;
+  private readonly directionality;
+  private readonly panelTemplate;
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  /** Panel alignment against the trigger's logical edge. */
+  readonly align: import("@angular/core").InputSignal<"start" | "end">;
+  /** Explicit direction for the panel; falls back to the nearest one. */
+  readonly dir: import("@angular/core").InputSignal<"ltr" | "rtl" | undefined>;
+  private readonly state;
+  private readonly items;
+  /** Whether any disclosure is open. */
+  readonly open: import("@angular/core").Signal<boolean>;
+  /** The active trigger value, or `null`. */
+  readonly activeValue: import("@angular/core").Signal<string | null>;
+  /** The id of the live panel element (the `aria-controls` target). */
+  readonly panelId: import("@angular/core").WritableSignal<string | null>;
+  readonly overlayDir: import("@angular/core").WritableSignal<"ltr" | "rtl">;
+  readonly currentTemplate: import("@angular/core").WritableSignal<TemplateRef<unknown> | null>;
+  readonly previousTemplate: import("@angular/core").WritableSignal<TemplateRef<unknown> | null>;
+  readonly activationDirection: import("@angular/core").WritableSignal<"left" | "right" | null>;
+  readonly side: import("@angular/core").WritableSignal<"bottom" | "top">;
+  readonly closing: import("@angular/core").WritableSignal<boolean>;
+  private readonly position;
+  private readonly pane;
+  private readonly dismissal;
+  private readonly keyboard;
+  private readonly layer;
+  readonly resolvedDir: import("@angular/core").Signal<"ltr" | "rtl">;
+  constructor();
+  ngOnInit(): void;
+  /** Destroys the key manager and releases every overlay/timer/observer. */
+  ngOnDestroy(): void;
+  /** Whether the given trigger value is the root's active disclosure. */
+  isActive(value: string): boolean;
+  /** Registers a top-level item, reporting duplicate/empty values in development. */
+  registerTopLevel(ref: RaqmNavigationMenuTopLevelRef): void;
+  /** Unregisters a top-level item; never changes the value. */
+  unregisterTopLevel(ref: RaqmNavigationMenuTopLevelRef): void;
+  /** Registers a panel link for the open panel's logical Tab boundaries. */
+  registerPanelLink(element: HTMLElement): void;
+  /** Removes a panel link registered for Tab-boundary handling. */
+  unregisterPanelLink(element: HTMLElement): void;
+  openFromTrigger(ref: RaqmNavigationMenuTopLevelRef, focusContent: 'first' | 'last' | 'none'): void;
+  /** Toggles a trigger's disclosure as a user action. */
+  toggleFromTrigger(ref: RaqmNavigationMenuTopLevelRef): void;
+  /** Closes the open disclosure as a user action (Escape/link/outside). */
+  closeFromUser(): void;
+  /** Delays a pointer-open for a hovered trigger (the single shared open timer). */
+  scheduleHoverOpen(ref: RaqmNavigationMenuTopLevelRef): void;
+  cancelHoverOpen(): void;
+  scheduleHoverClose(): void;
+  cancelHoverClose(): void;
+  moveFocusAcrossTopLevel(event: KeyboardEvent, ref: RaqmNavigationMenuTopLevelRef): void;
+  handleTopLevelTab(event: KeyboardEvent, ref: RaqmNavigationMenuTopLevelRef): void;
+  handlePanelTab(event: KeyboardEvent, element: HTMLElement): void;
+  /** Focuses the first or last link inside the open panel. */
+  focusContent(focus: 'first' | 'last'): void;
+  /** Records the focused top-level item as the key manager's active item. */
+  protected onFocusIn(event: FocusEvent): void;
+  /** Closes the panel only when focus leaves both the root and its overlay. */
+  protected onFocusOut(event: FocusEvent): void;
+  /** Panel-level focus-out; same rule as the host. */
+  protected onPanelFocusOut(event: FocusEvent): void;
+  /** Cancels a pending pointer-close when the pointer enters the panel. */
+  protected onPanelPointerEnter(): void;
+  /** Schedules a pointer-close when the pointer leaves the panel. */
+  protected onPanelPointerLeave(event: PointerEvent): void;
+  /** Detached destinations must not arm the trigger's hover-close timer. */
+  isInsideDetachedOverlay(node: Node | null): boolean;
+  private setUserValue;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmNavigationMenuComponent, "nav[raqm-navigation-menu]", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "dir": {
+      "alias": "dir";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, ["*"], true, never>;
+}
+/** The ul holding the navigation menu items, keeping native list semantics. */
+export declare class RaqmNavigationMenuListDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuListDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmNavigationMenuListDirective, "ul[raqm-navigation-menu-list]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Navigation menu trigger: a native `<button>` opening one disclosure panel.
+ *
+ * @remarks
+ * Panel content comes from the nested `ng-template[raqm-navigation-menu-content]`
+ * (read by a content query), not a `TemplateRef` input. Sets the real
+ * `aria-expanded`/`aria-controls` disclosure state; no `menubar`/`menu` role and no
+ * `aria-haspopup`. Arrow Down/Enter/Space open at the first link, Arrow Up at the
+ * last, Left/Right move across items, Escape restores focus. Registration happens in
+ * `ngOnInit`, after the required `value` is bound.
+ */
+export declare class RaqmNavigationMenuTriggerDirective implements OnInit {
+  private readonly host;
+  private readonly menu;
+  private readonly destroyRef;
+  readonly value: import("@angular/core").InputSignal<string>;
+  private readonly contentDirective;
+  private readonly contentTemplate;
+  /** A disabled trigger never opens and is skipped by focus. */
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly active: import("@angular/core").Signal<boolean>;
+  readonly panelId: import("@angular/core").Signal<string | null>;
+  private readonly ref;
+  constructor();
+  ngOnInit(): void;
+  protected onClick(): void;
+  /** Routes every trigger keyboard interaction to the root's policy. */
+  protected onKeydown(event: KeyboardEvent): void;
+  /** Schedules a delayed pointer-open; touch pointers never hover-open. */
+  protected onPointerEnter(event: PointerEvent): void;
+  /** Schedules a delayed pointer-close; the panel's own enter cancels it. */
+  protected onPointerLeave(event: PointerEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmNavigationMenuTriggerDirective, "button[raqm-navigation-menu-trigger]", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["contentDirective"], never, true, never>;
+}
+/** The ng-template holding one trigger panel content; supplies content identity only. */
+export declare class RaqmNavigationMenuContentDirective {
+  readonly content: TemplateRef<unknown>;
+  private readonly menu;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmNavigationMenuContentDirective, "ng-template[raqm-navigation-menu-content]", ["raqmNavigationMenuContent"], {}, {}, never, never, true, never>;
+}
+/** A native link; only an ordinary unmodified primary activation closes the menu. */
+export declare class RaqmNavigationMenuLinkDirective implements OnInit {
+  private readonly host;
+  private readonly menu;
+  private readonly destroyRef;
+  readonly active: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  ngOnInit(): void;
+  protected onClick(event: MouseEvent): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuLinkDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmNavigationMenuLinkDirective, "a[raqm-navigation-menu-link]", never, {
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** A native top-level link styled like a trigger, with no popup. */
+export declare class RaqmNavigationMenuTopLinkDirective implements OnInit {
+  private readonly host;
+  private readonly menu;
+  private readonly destroyRef;
+  private readonly ref;
+  constructor();
+  ngOnInit(): void;
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmNavigationMenuTopLinkDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmNavigationMenuTopLinkDirective, "a[raqm-navigation-menu-top-link]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmNavigationMenu: readonly [typeof RaqmNavigationMenuComponent, typeof RaqmNavigationMenuListDirective, typeof RaqmNavigationMenuTriggerDirective, typeof RaqmNavigationMenuContentDirective, typeof RaqmNavigationMenuLinkDirective, typeof RaqmNavigationMenuTopLinkDirective];
+export {};

package/types/raqm-ui-overlay-internal.d.ts

@@ -0,0 +1,5 @@
+import { OverlayRef } from "@angular/cdk/overlay";
+/** @internal Register an attached pane until its overlay detaches. */
+export declare function registerOverlayOwnership(origin: HTMLElement, ref: OverlayRef, includeBackdrop?: boolean): () => void;
+/** @internal Includes transitively owned panes whose origins remain connected. */
+export declare function containsOwnedOverlay(root: HTMLElement, target: Node | null): boolean;

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

@@ -0,0 +1,84 @@
+import * as i0 from "@angular/core";
+/**
+ * `<nav>` landmark wrapping one page trail; the application supplies the name and current-page state.
+ */
+export declare class RaqmPaginationComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationComponent, "nav[raqm-pagination]", never, {}, {}, never, ["*"], true, never>;
+}
+/** `<ul>` trail; the library owns the list chrome so consumers need not reset it. */
+export declare class RaqmPaginationContentComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationContentComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationContentComponent, "ul[raqm-pagination-content]", never, {}, {}, never, ["*"], true, never>;
+}
+/** `<li>` trail step; the projected link, previous, next or ellipsis is application-owned. */
+export declare class RaqmPaginationItemComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationItemComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationItemComponent, "li[raqm-pagination-item]", never, {}, {}, never, ["*"], true, never>;
+}
+/**
+ * Real anchor reusing the Button classes; `active` selects the outline appearance and `aria-current="page"`.
+ * `labelled` selects the wider size; the default is the icon size.
+ */
+export declare class RaqmPaginationLinkComponent {
+  readonly active: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly labelled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationLinkComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationLinkComponent, "a[raqm-pagination-link]", never, {
+    "active": {
+      "alias": "active";
+      "required": false;
+      "isSignal": true;
+    };
+    "labelled": {
+      "alias": "labelled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * Anchor that steps back; the chevron carries `start` and the reduced padding wins by stylesheet order.
+ * `label` overrides `aria-label` so the control stays named while the text is hidden; the chevron mirrors in RTL.
+ */
+export declare class RaqmPaginationPreviousComponent {
+  readonly label: import("@angular/core").InputSignal<string | null>;
+  readonly text: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationPreviousComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationPreviousComponent, "a[raqm-pagination-previous]", never, {
+    "label": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "text": {
+      "alias": "text";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Mirrors Previous with an `end` chevron. */
+export declare class RaqmPaginationNextComponent {
+  readonly label: import("@angular/core").InputSignal<string | null>;
+  readonly text: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationNextComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationNextComponent, "a[raqm-pagination-next]", never, {
+    "label": {
+      "alias": "aria-label";
+      "required": false;
+      "isSignal": true;
+    };
+    "text": {
+      "alias": "text";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Decorative `aria-hidden` indicator with no tab stop or state. */
+export declare class RaqmPaginationEllipsisComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPaginationEllipsisComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPaginationEllipsisComponent, "span[raqm-pagination-ellipsis]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmPagination: readonly [typeof RaqmPaginationComponent, typeof RaqmPaginationContentComponent, typeof RaqmPaginationItemComponent, typeof RaqmPaginationLinkComponent, typeof RaqmPaginationPreviousComponent, typeof RaqmPaginationNextComponent, typeof RaqmPaginationEllipsisComponent];

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

@@ -0,0 +1,235 @@
+import { Directionality } from "@angular/cdk/bidi";
+import * as i0 from "@angular/core";
+import { InjectionToken, OnDestroy, OnInit, Signal, TemplateRef } from "@angular/core";
+/** Side values, plus the two direction-resolved logical sides. */
+type RaqmPopoverSide = 'top' | 'bottom' | 'left' | 'right' | 'inline-start' | 'inline-end';
+type RaqmPopoverAlign = 'start' | 'center' | 'end';
+type RaqmPopoverPhysicalSide = 'top' | 'bottom' | 'left' | 'right';
+declare const DEFAULT_SIDE: RaqmPopoverSide;
+declare const DEFAULT_ALIGN: RaqmPopoverAlign;
+declare const DEFAULT_SIDE_OFFSET = 4;
+declare const DEFAULT_ALIGN_OFFSET = 0;
+declare const DEFAULT_WIDTH = "18rem";
+declare const VIEWPORT_MARGIN = 5;
+declare const EXIT_ANIMATION_MS = 100;
+declare const PANE_CLASS = "raqm-popover-overlay-pane";
+declare const FOCUSABLE_SELECTOR = "a[href], button, input, select, textarea, [tabindex], [contenteditable=\"true\"]";
+interface PopoverBoxSize {
+  width: number;
+  height: number;
+}
+declare function sameBoxSize(a: PopoverBoxSize | undefined, b: PopoverBoxSize | undefined): boolean;
+declare function prefersReducedMotion(): boolean;
+declare function toSide(value: unknown): RaqmPopoverSide;
+declare function toAlign(value: unknown): RaqmPopoverAlign;
+declare function toDir(value: unknown): 'ltr' | 'rtl' | undefined;
+declare function toOffset(fallback: number): (value: unknown) => number;
+declare function resolvePopoverDirection(dir: 'ltr' | 'rtl' | undefined, element: HTMLElement, directionality: Directionality | null): 'ltr' | 'rtl';
+interface RaqmPopoverTriggerRef {
+  /** The native `<button>` the root anchors the overlay to and restores focus to. */
+  readonly element: HTMLButtonElement;
+  /** Live native disabled state, read by the root's open policy at event time. */
+  readonly disabled: boolean;
+  /** Focuses the trigger; used to restore focus on Escape. */
+  focus(): void;
+}
+interface RaqmPopoverContext {
+  /** Whether the popup is currently open (an enabled `open` model). */
+  readonly open: Signal<boolean>;
+  /** The id of the live popup element (the `aria-controls` target), or `null`. */
+  readonly panelId: Signal<string | null>;
+  /** Registers the single trigger; called once per root. */
+  registerTrigger(ref: RaqmPopoverTriggerRef): void;
+  /** Unregisters the trigger on destroy; never changes open state. */
+  unregisterTrigger(ref: RaqmPopoverTriggerRef): void;
+  /** Registers the single content template; called once per root. */
+  registerContent(template: TemplateRef<unknown>): void;
+  /** Unregisters the content template on destroy. */
+  unregisterContent(template: TemplateRef<unknown>): void;
+  /** Registers a popped title element so the root can point `aria-labelledby` at it. */
+  registerTitle(element: HTMLElement): void;
+  /** Removes a popped title element on destroy. */
+  unregisterTitle(element: HTMLElement): void;
+  /** Registers a popped description element so the root can point `aria-describedby` at it. */
+  registerDescription(element: HTMLElement): void;
+  /** Removes a popped description element on destroy. */
+  unregisterDescription(element: HTMLElement): void;
+  /** Toggles the popup from a trigger activation (never opens a disabled root). */
+  toggleFromTrigger(ref: RaqmPopoverTriggerRef): void;
+  /** Closes the popup as a user action (outside press / Escape / trigger toggle). */
+  closeFromUser(): void;
+  /** Moves focus to the first focusable control inside the open popup, else the popup itself. */
+  focusFirstInPanel(): void;
+  /** Routes Tab on the trigger into the open popup's first control. */
+  onTriggerTab(event: KeyboardEvent): void;
+}
+declare const RAQM_POPOVER: InjectionToken<RaqmPopoverContext>;
+export declare class RaqmPopoverComponent implements RaqmPopoverContext, OnDestroy {
+  private readonly host;
+  private readonly overlay;
+  private readonly viewContainerRef;
+  private readonly injector;
+  private readonly directionality;
+  private readonly viewportRuler;
+  private readonly scrollDispatcher;
+  private readonly checker;
+  private readonly panelTemplate;
+  readonly openValue: import("@angular/core").ModelSignal<boolean>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The preferred side of the trigger; logical sides resolve against `dir`. */
+  readonly side: import("@angular/core").InputSignalWithTransform<RaqmPopoverSide, unknown>;
+  readonly align: import("@angular/core").InputSignalWithTransform<RaqmPopoverAlign, unknown>;
+  readonly sideOffset: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly alignOffset: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly dir: import("@angular/core").InputSignalWithTransform<"ltr" | "rtl" | undefined, unknown>;
+  readonly width: import("@angular/core").InputSignal<string>;
+  readonly panelClass: import("@angular/core").InputSignal<string | undefined>;
+  /** An explicit accessible name used when no title slot is registered. */
+  readonly label: import("@angular/core").InputSignal<string | undefined>;
+  private readonly state;
+  private readonly registration;
+  private readonly canOpen;
+  /** Open AND enabled AND actually attached; the trigger's `aria-expanded` source. */
+  readonly open: import("@angular/core").Signal<boolean>;
+  readonly panelId: import("@angular/core").WritableSignal<string | null>;
+  readonly resolvedSide: import("@angular/core").WritableSignal<RaqmPopoverPhysicalSide>;
+  readonly transformOrigin: import("@angular/core").WritableSignal<string>;
+  readonly closing: import("@angular/core").WritableSignal<boolean>;
+  protected readonly panelDir: import("@angular/core").WritableSignal<"ltr" | "rtl">;
+  protected readonly contentTemplate: import("@angular/core").WritableSignal<TemplateRef<unknown> | null>;
+  private readonly sizing;
+  private readonly position;
+  private readonly layer;
+  private readonly keyboard;
+  private readonly dismissal;
+  constructor();
+  ngOnDestroy(): void;
+  registerTrigger(ref: RaqmPopoverTriggerRef): void;
+  unregisterTrigger(ref: RaqmPopoverTriggerRef): void;
+  registerContent(template: TemplateRef<unknown>): void;
+  unregisterContent(template: TemplateRef<unknown>): void;
+  registerTitle(element: HTMLElement): void;
+  unregisterTitle(element: HTMLElement): void;
+  registerDescription(element: HTMLElement): void;
+  unregisterDescription(element: HTMLElement): void;
+  toggleFromTrigger(ref: RaqmPopoverTriggerRef): void;
+  closeFromUser(): void;
+  /** Dismisses on application navigation; clears `open` even when disabled. */
+  close(): void;
+  focusFirstInPanel(): void;
+  onTriggerTab(event: KeyboardEvent): void;
+  protected onFocusOut(event: FocusEvent): void;
+  protected onPanelFocusOut(event: FocusEvent): void;
+  protected onPanelKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmPopoverComponent, "raqm-popover", ["raqmPopover"], {
+    "openValue": {
+      "alias": "open";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "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;
+    };
+    "dir": {
+      "alias": "dir";
+      "required": false;
+      "isSignal": true;
+    };
+    "width": {
+      "alias": "width";
+      "required": false;
+      "isSignal": true;
+    };
+    "panelClass": {
+      "alias": "panelClass";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "openValue": "openChange";
+  }, never, ["*"], true, never>;
+}
+/**
+ * Popover trigger: the one native `<button>` that opens the popup.
+ *
+ * @remarks
+ * No `aria-haspopup`, because the nonmodal surface has no dialog role. Escape closes and
+ * leaves focus on the trigger; Tab enters the popup's first control.
+ */
+export declare class RaqmPopoverTriggerDirective implements OnInit {
+  private readonly host;
+  private readonly popover;
+  private readonly destroyRef;
+  readonly open: import("@angular/core").Signal<boolean>;
+  readonly panelId: import("@angular/core").Signal<string | null>;
+  private readonly ref;
+  constructor();
+  ngOnInit(): void;
+  /** Toggles on a native click (pointer, Enter or Space); disabled is a no-op. */
+  protected onClick(): void;
+  /** Routes Escape to close and Tab into the open popup's logical order. */
+  protected onKeydown(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmPopoverTriggerDirective, "button[raqm-popover-trigger]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmPopoverContentDirective implements OnInit {
+  private readonly template;
+  private readonly popover;
+  private readonly destroyRef;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmPopoverContentDirective, "ng-template[raqm-popover-content]", ["raqmPopoverContent"], {}, {}, never, never, true, never>;
+}
+export declare class RaqmPopoverHeaderDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverHeaderDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmPopoverHeaderDirective, "[raqm-popover-header]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmPopoverTitleDirective implements OnInit {
+  private readonly host;
+  private readonly popover;
+  private readonly destroyRef;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmPopoverTitleDirective, "[raqm-popover-title]", never, {}, {}, never, never, true, never>;
+}
+export declare class RaqmPopoverDescriptionDirective implements OnInit {
+  private readonly host;
+  private readonly popover;
+  private readonly destroyRef;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmPopoverDescriptionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<RaqmPopoverDescriptionDirective, "[raqm-popover-description]", never, {}, {}, never, never, true, never>;
+}
+export declare const RaqmPopover: readonly [typeof RaqmPopoverComponent, typeof RaqmPopoverTriggerDirective, typeof RaqmPopoverContentDirective, typeof RaqmPopoverHeaderDirective, typeof RaqmPopoverTitleDirective, typeof RaqmPopoverDescriptionDirective];
+export {};

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

@@ -0,0 +1,79 @@
+import * as i0 from "@angular/core";
+import { InjectionToken, OnInit, Signal } from "@angular/core";
+interface RaqmProgressContext {
+  /** `null` means the bar is indeterminate. */
+  readonly value: Signal<number | null>;
+  readonly min: Signal<number>;
+  readonly max: Signal<number>;
+  /** Clamped fill percentage in `0..100`, or `null` while indeterminate. */
+  readonly percentage: Signal<number | null>;
+  /** The id the root points `aria-labelledby` at, or `null`. */
+  readonly labelId: Signal<string | null>;
+  registerLabel(id: string): void;
+  unregisterLabel(id: string): void;
+}
+/** Parts inject this optionally, so a misplaced part reports a dev error instead of crashing. */
+declare const RAQM_PROGRESS: InjectionToken<RaqmProgressContext>;
+/** No ARIA role here: only the root is the progressbar. */
+export declare class RaqmProgressTrackComponent {
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmProgressTrackComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmProgressTrackComponent, "raqm-progress-track", never, {}, {}, never, ["*"], true, never>;
+}
+/** The fill is this host's own box; indeterminate writes no inline style, collapsing its size. */
+export declare class RaqmProgressIndicatorComponent {
+  private readonly progress;
+  protected readonly indicatorStyle: Signal<Record<string, string> | null>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmProgressIndicatorComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmProgressIndicatorComponent, "raqm-progress-indicator", never, {}, {}, never, never, true, never>;
+}
+/** Its owned id is registered with the root, which points `aria-labelledby` at it. */
+export declare class RaqmProgressLabelComponent implements OnInit {
+  private readonly progress;
+  private readonly destroyRef;
+  readonly id: string;
+  constructor();
+  ngOnInit(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmProgressLabelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmProgressLabelComponent, "raqm-progress-label", never, {}, {}, never, ["*"], true, never>;
+}
+/** `aria-hidden`: the root reports the value, and the readout is empty while indeterminate. */
+export declare class RaqmProgressValueComponent {
+  private readonly progress;
+  protected readonly text: Signal<string>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmProgressValueComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmProgressValueComponent, "raqm-progress-value", never, {}, {}, never, never, true, never>;
+}
+/** Owns the task state and its ARIA attributes; `aria-valuenow` is published only for a finite value. */
+export declare class RaqmProgressComponent implements RaqmProgressContext {
+  readonly value: import("@angular/core").InputSignal<number | null>;
+  readonly min: import("@angular/core").InputSignal<number>;
+  readonly max: import("@angular/core").InputSignal<number>;
+  private readonly registeredLabelId;
+  readonly labelId: Signal<string | null>;
+  readonly percentage: Signal<number | null>;
+  protected readonly ariaValueNow: Signal<number | null>;
+  registerLabel(id: string): void;
+  unregisterLabel(id: string): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<RaqmProgressComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<RaqmProgressComponent, "raqm-progress", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare const RaqmProgress: readonly [typeof RaqmProgressComponent, typeof RaqmProgressTrackComponent, typeof RaqmProgressIndicatorComponent, typeof RaqmProgressLabelComponent, typeof RaqmProgressValueComponent];
+export {};