@ojiepermana/angular 22.1.14 → 22.2.0

package/types/ojiepermana-angular-component-tooltip.d.ts

@@ -1,143 +1,233 @@
-import * as _angular_core from '@angular/core';
-import { InjectionToken, Signal, TemplateRef } from '@angular/core';
-import * as i1 from '@ojiepermana/angular/component/utils/scale';
-import { ComponentScaleDirective } from '@ojiepermana/angular/component/utils/scale';
-
-type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
-type TooltipAlign = 'start' | 'center' | 'end';
-interface TooltipDefaults {
-    readonly side: Signal<TooltipSide>;
-    readonly align: Signal<TooltipAlign>;
-    readonly sideOffset: Signal<number>;
-    readonly openDelay: Signal<number>;
-    readonly closeDelay: Signal<number>;
+import * as i0 from "@angular/core";
+import { InjectionToken, Signal, TemplateRef } from "@angular/core";
+import * as i1 from "@ojiepermana/angular/component/utils/scale";
+import { ComponentScaleDirective } from "@ojiepermana/angular/component/utils/scale";
+export type TooltipSide = 'top' | 'right' | 'bottom' | 'left';
+export type TooltipAlign = 'start' | 'center' | 'end';
+export interface TooltipDefaults {
+  readonly side: Signal<TooltipSide>;
+  readonly align: Signal<TooltipAlign>;
+  readonly sideOffset: Signal<number>;
+  readonly openDelay: Signal<number>;
+  readonly closeDelay: Signal<number>;
 }
-declare const TOOLTIP_DEFAULTS: InjectionToken<TooltipDefaults>;
-declare class TooltipComponent implements TooltipDefaults {
-    readonly side: _angular_core.InputSignal<TooltipSide>;
-    readonly align: _angular_core.InputSignal<TooltipAlign>;
-    readonly sideOffset: _angular_core.InputSignal<number>;
-    readonly openDelay: _angular_core.InputSignal<number>;
-    /**
-     * Delay before the tooltip hides after the pointer leaves.
-     *
-     * It matches `openDelay` rather than being zero so the pointer has time to
-     * cross the `sideOffset` gap and land on the panel. That is what makes the
-     * panel reachable, which WCAG 1.4.13 (hoverable) asks for. Set it to `0` for
-     * an instant hide, accepting that the panel then cannot be hovered.
-     */
-    readonly closeDelay: _angular_core.InputSignal<number>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "Tooltip", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+export declare const TOOLTIP_DEFAULTS: InjectionToken<TooltipDefaults>;
+export declare class TooltipComponent implements TooltipDefaults {
+  readonly side: import("@angular/core").InputSignal<TooltipSide>;
+  readonly align: import("@angular/core").InputSignal<TooltipAlign>;
+  readonly sideOffset: import("@angular/core").InputSignal<number>;
+  readonly openDelay: import("@angular/core").InputSignal<number>;
+  /**
+   * Delay before the tooltip hides after the pointer leaves.
+   *
+   * It matches `openDelay` rather than being zero so the pointer has time to
+   * cross the `sideOffset` gap and land on the panel. That is what makes the
+   * panel reachable, which WCAG 1.4.13 (hoverable) asks for. Set it to `0` for
+   * an instant hide, accepting that the panel then cannot be hovered.
+   */
+  readonly closeDelay: import("@angular/core").InputSignal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TooltipComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<TooltipComponent, "Tooltip", never, {
+    "side": {
+      "alias": "side";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "sideOffset": {
+      "alias": "sideOffset";
+      "required": false;
+      "isSignal": true;
+    };
+    "openDelay": {
+      "alias": "openDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeDelay": {
+      "alias": "closeDelay";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
 }
-
-declare class TooltipContentDirective {
-    protected readonly componentScale: ComponentScaleDirective;
-    readonly radius: _angular_core.InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
-    readonly density: _angular_core.InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
-    readonly template: TemplateRef<unknown>;
-    /**
-     * Resolved `--radius-base` / `--spacing-base` knob values (or `null` to
-     * inherit the global axis). Public so {@link TooltipTriggerDirective} can mirror
-     * them onto the CDK overlay panel — the element that actually paints the rounded
-     * background + padding — since this directive sits on an `<ng-template>` whose
-     * host bindings never reach the imperatively-created overlay subtree.
-     */
-    readonly radiusBase: _angular_core.Signal<string | null>;
-    readonly densityBase: _angular_core.Signal<string | null>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipContentDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipContentDirective, "ng-template[TooltipContent]", ["TooltipContent"], {}, {}, never, never, true, [{ directive: typeof i1.ComponentScaleDirective; inputs: { "radius": "radius"; "density": "density"; }; outputs: {}; }]>;
+export declare class TooltipContentDirective {
+  protected readonly componentScale: ComponentScaleDirective;
+  readonly radius: import("@angular/core").InputSignal<"inherit" | "none" | "xs" | "sm" | "md" | "xl" | "full">;
+  readonly density: import("@angular/core").InputSignal<"inherit" | "compact" | "normal" | "relaxed" | "spacious">;
+  readonly template: TemplateRef<unknown>;
+  /**
+   * Resolved `--radius-base` / `--spacing-base` knob values (or `null` to
+   * inherit the global axis). Public so {@link TooltipTriggerDirective} can mirror
+   * them onto the CDK overlay panel — the element that actually paints the rounded
+   * background + padding — since this directive sits on an `<ng-template>` whose
+   * host bindings never reach the imperatively-created overlay subtree.
+   */
+  readonly radiusBase: import("@angular/core").Signal<string | null>;
+  readonly densityBase: import("@angular/core").Signal<string | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TooltipContentDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipContentDirective, "ng-template[TooltipContent]", ["TooltipContent"], {}, {}, never, never, true, [{
+    directive: typeof i1.ComponentScaleDirective;
+    inputs: {
+      "radius": "radius";
+      "density": "density";
+    };
+    outputs: {};
+  }]>;
 }
-
-declare class TooltipTriggerDirective {
-    private readonly overlay;
-    private readonly vcr;
-    private readonly el;
-    private readonly destroyRef;
-    private readonly defaults;
-    private readonly idGenerator;
-    readonly TooltipTrigger: _angular_core.InputSignal<TooltipContentDirective>;
-    readonly side: _angular_core.InputSignal<TooltipSide | undefined>;
-    readonly align: _angular_core.InputSignal<TooltipAlign | undefined>;
-    readonly sideOffset: _angular_core.InputSignal<number | undefined>;
-    readonly openDelay: _angular_core.InputSignal<number | undefined>;
-    readonly closeDelay: _angular_core.InputSignal<number | undefined>;
-    readonly disabled: _angular_core.InputSignal<boolean>;
-    readonly openedChange: _angular_core.OutputEmitterRef<boolean>;
-    readonly isOpen: _angular_core.WritableSignal<boolean>;
-    protected readonly contentId: _angular_core.WritableSignal<string | null>;
-    private overlayRef;
-    private openTimeoutId;
-    private closeTimeoutId;
-    private isPointerInsideTrigger;
-    private isPointerInsidePanel;
-    private isTriggerFocused;
-    private isDestroying;
-    /**
-     * Holds the tooltip open while the pointer rests on the panel, so a user can
-     * move onto it to read or copy the content (WCAG 1.4.13, hoverable).
-     */
-    private readonly onPanelPointerEnter;
-    private readonly onPanelPointerLeave;
-    constructor();
-    handlePointerEnter(): void;
-    handlePointerLeave(event: PointerEvent): void;
-    handleFocusIn(): void;
-    handleFocusOut(event: FocusEvent): void;
-    open(): void;
-    close(): void;
-    private applySurfaceVars;
-    private bindOverlayLifecycle;
-    private scheduleOpen;
-    private scheduleClose;
-    private releasePanel;
-    private clearOpenTimeout;
-    private clearCloseTimeout;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipTriggerDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipTriggerDirective, "[TooltipTrigger]", ["TooltipTrigger"], { "TooltipTrigger": { "alias": "TooltipTrigger"; "required": true; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "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; }; }, { "openedChange": "openedChange"; }, never, never, true, never>;
+export declare class TooltipTriggerDirective {
+  private readonly overlay;
+  private readonly vcr;
+  private readonly el;
+  private readonly destroyRef;
+  private readonly defaults;
+  private readonly idGenerator;
+  readonly TooltipTrigger: import("@angular/core").InputSignal<TooltipContentDirective>;
+  readonly side: import("@angular/core").InputSignal<TooltipSide | undefined>;
+  readonly align: import("@angular/core").InputSignal<TooltipAlign | undefined>;
+  readonly sideOffset: import("@angular/core").InputSignal<number | undefined>;
+  readonly openDelay: import("@angular/core").InputSignal<number | undefined>;
+  readonly closeDelay: import("@angular/core").InputSignal<number | undefined>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly openedChange: import("@angular/core").OutputEmitterRef<boolean>;
+  readonly isOpen: import("@angular/core").WritableSignal<boolean>;
+  protected readonly contentId: import("@angular/core").WritableSignal<string | null>;
+  private overlayRef;
+  private openTimeoutId;
+  private closeTimeoutId;
+  private isPointerInsideTrigger;
+  private isPointerInsidePanel;
+  private isTriggerFocused;
+  private isDestroying;
+  /**
+   * Holds the tooltip open while the pointer rests on the panel, so a user can
+   * move onto it to read or copy the content (WCAG 1.4.13, hoverable).
+   */
+  private readonly onPanelPointerEnter;
+  private readonly onPanelPointerLeave;
+  constructor();
+  handlePointerEnter(): void;
+  handlePointerLeave(event: PointerEvent): void;
+  handleFocusIn(): void;
+  handleFocusOut(event: FocusEvent): void;
+  open(): void;
+  close(): void;
+  private applySurfaceVars;
+  private bindOverlayLifecycle;
+  private scheduleOpen;
+  private scheduleClose;
+  private releasePanel;
+  private clearOpenTimeout;
+  private clearCloseTimeout;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TooltipTriggerDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipTriggerDirective, "[TooltipTrigger]", ["TooltipTrigger"], {
+    "TooltipTrigger": {
+      "alias": "TooltipTrigger";
+      "required": true;
+      "isSignal": true;
+    };
+    "side": {
+      "alias": "side";
+      "required": false;
+      "isSignal": true;
+    };
+    "align": {
+      "alias": "align";
+      "required": false;
+      "isSignal": true;
+    };
+    "sideOffset": {
+      "alias": "sideOffset";
+      "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;
+    };
+  }, {
+    "openedChange": "openedChange";
+  }, never, never, true, never>;
 }
-
 /** Posisi tooltip; kompatibel dengan nilai `matTooltipPosition` lama. */
-type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
+export type TooltipPosition = 'left' | 'right' | 'above' | 'below' | 'before' | 'after';
 /**
  * Shadcn-styled text tooltip — CDK overlay, tanpa dependensi Material.
  *
  * @example
  * <button Button [Tooltip]="'Save changes'" TooltipPosition="above">Save</button>
  */
-declare class TooltipDirective {
-    private readonly overlay;
-    private readonly el;
-    private readonly destroyRef;
-    private readonly idGenerator;
-    readonly Tooltip: _angular_core.InputSignal<string>;
-    readonly TooltipPosition: _angular_core.InputSignal<TooltipPosition>;
-    readonly TooltipDisabled: _angular_core.InputSignal<boolean>;
-    readonly TooltipShowDelay: _angular_core.InputSignal<number>;
-    /**
-     * Delay before hiding. It matches the show delay rather than being zero so the
-     * pointer can cross the offset gap and land on the panel, which is what makes
-     * the panel reachable (WCAG 1.4.13, hoverable). Set `0` for an instant hide,
-     * accepting that the panel then cannot be hovered.
-     */
-    readonly TooltipHideDelay: _angular_core.InputSignal<number>;
-    private overlayRef;
-    private contentRef;
-    private showTimeoutId;
-    private hideTimeoutId;
-    private isPointerInsidePanel;
-    private readonly onPanelPointerEnter;
-    private readonly onPanelPointerLeave;
-    private readonly side;
-    constructor();
-    show(): void;
-    hide(): void;
-    protected scheduleShow(): void;
-    protected scheduleHide(): void;
-    private clearTimers;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[Tooltip]", ["Tooltip"], { "Tooltip": { "alias": "Tooltip"; "required": false; "isSignal": true; }; "TooltipPosition": { "alias": "TooltipPosition"; "required": false; "isSignal": true; }; "TooltipDisabled": { "alias": "TooltipDisabled"; "required": false; "isSignal": true; }; "TooltipShowDelay": { "alias": "TooltipShowDelay"; "required": false; "isSignal": true; }; "TooltipHideDelay": { "alias": "TooltipHideDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { TOOLTIP_DEFAULTS, TooltipComponent, TooltipContentDirective, TooltipDirective, TooltipTriggerDirective };
-export type { TooltipAlign, TooltipDefaults, TooltipPosition, TooltipSide };
+export declare class TooltipDirective {
+  private readonly overlay;
+  private readonly el;
+  private readonly destroyRef;
+  private readonly idGenerator;
+  readonly Tooltip: import("@angular/core").InputSignal<string>;
+  readonly TooltipPosition: import("@angular/core").InputSignal<TooltipPosition>;
+  readonly TooltipDisabled: import("@angular/core").InputSignal<boolean>;
+  readonly TooltipShowDelay: import("@angular/core").InputSignal<number>;
+  /**
+   * Delay before hiding. It matches the show delay rather than being zero so the
+   * pointer can cross the offset gap and land on the panel, which is what makes
+   * the panel reachable (WCAG 1.4.13, hoverable). Set `0` for an instant hide,
+   * accepting that the panel then cannot be hovered.
+   */
+  readonly TooltipHideDelay: import("@angular/core").InputSignal<number>;
+  private overlayRef;
+  private contentRef;
+  private showTimeoutId;
+  private hideTimeoutId;
+  private isPointerInsidePanel;
+  private readonly onPanelPointerEnter;
+  private readonly onPanelPointerLeave;
+  private readonly side;
+  constructor();
+  show(): void;
+  hide(): void;
+  protected scheduleShow(): void;
+  protected scheduleHide(): void;
+  private clearTimers;
+  static ɵfac: i0.ɵɵFactoryDeclaration<TooltipDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<TooltipDirective, "[Tooltip]", ["Tooltip"], {
+    "Tooltip": {
+      "alias": "Tooltip";
+      "required": false;
+      "isSignal": true;
+    };
+    "TooltipPosition": {
+      "alias": "TooltipPosition";
+      "required": false;
+      "isSignal": true;
+    };
+    "TooltipDisabled": {
+      "alias": "TooltipDisabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "TooltipShowDelay": {
+      "alias": "TooltipShowDelay";
+      "required": false;
+      "isSignal": true;
+    };
+    "TooltipHideDelay": {
+      "alias": "TooltipHideDelay";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/ojiepermana-angular-component-utils-core.d.ts

@@ -1,24 +1,21 @@
-import { ClassValue } from 'clsx';
-import { InjectionToken } from '@angular/core';
-
-declare function cn(...inputs: ClassValue[]): string;
-
+import { ClassValue } from "clsx";
+import { InjectionToken } from "@angular/core";
+export declare function cn(...inputs: ClassValue[]): string;
 /** Request/application-scoped DOM id generator with deterministic sequencing. */
-declare class UiIdGenerator {
-    private counter;
-    private readonly appInfix;
-    constructor(appId?: string);
-    next(prefix: string): string;
+export declare class UiIdGenerator {
+  private counter;
+  private readonly appInfix;
+  constructor(appId?: string);
+  next(prefix: string): string;
 }
 /**
  * One generator per Angular application injector. Separate SSR requests and a
  * hydrating browser application therefore start from the same deterministic
  * sequence instead of sharing process-global state.
  */
-declare const UI_ID_GENERATOR: InjectionToken<UiIdGenerator>;
+export declare const UI_ID_GENERATOR: InjectionToken<UiIdGenerator>;
 /** Generates an id during component/directive construction. */
-declare function injectUniqueId(prefix: string): string;
-
+export declare function injectUniqueId(prefix: string): string;
 /**
  * One item of a horizontal roving row: a trigger that discloses an overlay, or
  * a plain link sitting beside one. The row only ever asks an item whether it is
@@ -26,33 +23,33 @@ declare function injectUniqueId(prefix: string): string;
  * never touches roles or ARIA, so a real `menubar` and a disclosure navigation
  * can share it without either inheriting the other's semantics.
  */
-interface RovingRowItem {
-    disabled(): boolean;
-    focus(): void;
-    containsTarget(target: EventTarget | null): boolean;
+export interface RovingRowItem {
+  disabled(): boolean;
+  focus(): void;
+  containsTarget(target: EventTarget | null): boolean;
 }
 /** The subset of a disclosure trigger the row needs to hand one panel over. */
-interface RovingRowTrigger extends RovingRowItem {
-    close(options: {
-        restoreFocus: boolean;
-    }): void;
+export interface RovingRowTrigger extends RovingRowItem {
+  close(options: {
+    restoreFocus: boolean;
+  }): void;
 }
-type RovingRowDirection = 'previous' | 'next' | 'start' | 'end';
+export type RovingRowDirection = 'previous' | 'next' | 'start' | 'end';
 /** Which items answer for a keyboard event: every one, or only the enabled ones. */
-type RovingRowScope = 'all' | 'enabled';
-interface RovingRowConfig<TItem extends RovingRowItem> {
-    /** Every row item in DOM order, disabled ones included. */
-    items: () => readonly TItem[];
-    /** The row element; its resolved writing direction decides which way an arrow steps. */
-    host: () => HTMLElement;
-    /** Whether arrows wrap around at the ends instead of clamping. */
-    loop: () => boolean;
-    /**
-     * Commits a resolved move. The row has already picked the neighbour and
-     * ruled out the no-op cases; what focusing it means for an open panel is the
-     * owning component's decision, so it lands here.
-     */
-    enter: (item: TItem) => void;
+export type RovingRowScope = 'all' | 'enabled';
+export interface RovingRowConfig<TItem extends RovingRowItem> {
+  /** Every row item in DOM order, disabled ones included. */
+  items: () => readonly TItem[];
+  /** The row element; its resolved writing direction decides which way an arrow steps. */
+  host: () => HTMLElement;
+  /** Whether arrows wrap around at the ends instead of clamping. */
+  loop: () => boolean;
+  /**
+   * Commits a resolved move. The row has already picked the neighbour and
+   * ruled out the no-op cases; what focusing it means for an open panel is the
+   * owning component's decision, so it lands here.
+   */
+  enter: (item: TItem) => void;
 }
 /**
  * Roving focus across one horizontal row of items, with at most one open
@@ -63,43 +60,42 @@ interface RovingRowConfig<TItem extends RovingRowItem> {
  * panel open. Everything that differs between the two -- roles, ARIA, and what
  * happens to an open panel when focus moves on -- stays in the components.
  */
-declare class RovingRow<TItem extends RovingRowItem, TTrigger extends TItem & RovingRowTrigger> {
-    private readonly config;
-    private readonly activeItem;
-    private readonly open;
-    constructor(config: RovingRowConfig<TItem>);
-    items(): readonly TItem[];
-    enabledItems(): TItem[];
-    setActive(item: TItem): void;
-    /**
-     * The roving `tabindex` for one row item.
-     *
-     * A composite widget carries exactly one tab stop: normally the active item
-     * owns it, falling back to the first enabled one. When EVERY item is disabled
-     * there is no enabled candidate, and leaving them all at `-1` drops the whole
-     * widget out of the tab order -- it becomes unreachable and a keyboard user
-     * cannot even discover that it is there. The first item keeps the tab stop
-     * instead and announces its state through `aria-disabled`, which is the APG
-     * focusable-disabled-item approach.
-     */
-    tabIndexFor(item: TItem): number;
-    openTrigger(): TTrigger | null;
-    hasOpenTrigger(except?: TTrigger): boolean;
-    notifyOpen(trigger: TTrigger): void;
-    notifyClosed(trigger: TTrigger): void;
-    /** The row item an event came from, or `null` when it came from outside the row. */
-    itemFrom(target: EventTarget | null, scope: RovingRowScope): TItem | null;
-    /**
-     * Handles the keys that walk the row itself -- Home, End and the horizontal
-     * arrows -- and reports whether it claimed the event, so a component can add
-     * its own keys around this without restating the row model.
-     */
-    handleNavigationKey(item: TItem, event: KeyboardEvent): boolean;
-    move(currentItem: TItem, direction: RovingRowDirection): void;
-    private nextIndex;
-    private horizontalStep;
+export declare class RovingRow<TItem extends RovingRowItem, TTrigger extends TItem & RovingRowTrigger> {
+  private readonly config;
+  private readonly activeItem;
+  private readonly open;
+  constructor(config: RovingRowConfig<TItem>);
+  items(): readonly TItem[];
+  enabledItems(): TItem[];
+  setActive(item: TItem): void;
+  /**
+   * The roving `tabindex` for one row item.
+   *
+   * A composite widget carries exactly one tab stop: normally the active item
+   * owns it, falling back to the first enabled one. When EVERY item is disabled
+   * there is no enabled candidate, and leaving them all at `-1` drops the whole
+   * widget out of the tab order -- it becomes unreachable and a keyboard user
+   * cannot even discover that it is there. The first item keeps the tab stop
+   * instead and announces its state through `aria-disabled`, which is the APG
+   * focusable-disabled-item approach.
+   */
+  tabIndexFor(item: TItem): number;
+  openTrigger(): TTrigger | null;
+  hasOpenTrigger(except?: TTrigger): boolean;
+  notifyOpen(trigger: TTrigger): void;
+  notifyClosed(trigger: TTrigger): void;
+  /** The row item an event came from, or `null` when it came from outside the row. */
+  itemFrom(target: EventTarget | null, scope: RovingRowScope): TItem | null;
+  /**
+   * Handles the keys that walk the row itself -- Home, End and the horizontal
+   * arrows -- and reports whether it claimed the event, so a component can add
+   * its own keys around this without restating the row model.
+   */
+  handleNavigationKey(item: TItem, event: KeyboardEvent): boolean;
+  move(currentItem: TItem, direction: RovingRowDirection): void;
+  private nextIndex;
+  private horizontalStep;
 }
-
 /**
  * Per-component corner-radius / spacing-density override helpers.
  *
@@ -116,22 +112,21 @@ declare class RovingRow<TItem extends RovingRowItem, TTrigger extends TItem & Ro
  * `'inherit'` preset binds nothing, so the component keeps following the axis.
  */
 /** Corner-radius presets for a per-component `radius` input. */
-declare const COMPONENT_RADII: readonly ["inherit", "none", "xs", "sm", "md", "xl", "full"];
-type ComponentRadius = (typeof COMPONENT_RADII)[number];
+export declare const COMPONENT_RADII: readonly ["inherit", "none", "xs", "sm", "md", "xl", "full"];
+export type ComponentRadius = (typeof COMPONENT_RADII)[number];
 /** Spacing-density presets for a per-component `density` input. */
-declare const COMPONENT_DENSITIES: readonly ["inherit", "compact", "normal", "relaxed", "spacious"];
-type ComponentDensity = (typeof COMPONENT_DENSITIES)[number];
+export declare const COMPONENT_DENSITIES: readonly ["inherit", "compact", "normal", "relaxed", "spacious"];
+export type ComponentDensity = (typeof COMPONENT_DENSITIES)[number];
 /**
  * Resolves a `radius` input to a `--radius-base` value, or `null` to inherit the
  * global axis. Bind the result to the surface host: `[style.--radius-base]`.
  */
-declare function radiusBaseValue(radius: ComponentRadius): string | null;
+export declare function radiusBaseValue(radius: ComponentRadius): string | null;
 /**
  * Resolves a `density` input to a `--spacing-base` value, or `null` to inherit
  * the global axis. Bind the result to the surface host: `[style.--spacing-base]`.
  */
-declare function densityBaseValue(density: ComponentDensity): string | null;
-
+export declare function densityBaseValue(density: ComponentDensity): string | null;
 /**
  * Returns a document-unique id with the given prefix, e.g. `uniqueId('Checkbox')`
  * → `"checkbox-1"`. Single shared counter for every component in the library.
@@ -139,8 +134,7 @@ declare function densityBaseValue(density: ComponentDensity): string | null;
  * @deprecated Use `injectUniqueId` or inject `UI_ID_GENERATOR`. This legacy
  * function cannot isolate concurrent server-rendering requests.
  */
-declare function uniqueId(prefix: string): string;
-
+export declare function uniqueId(prefix: string): string;
 /**
  * One safe way to touch `localStorage`, for every library that persists a
  * preference.
@@ -160,10 +154,10 @@ declare function uniqueId(prefix: string): string;
  * entry point.
  */
 /** A storage that never throws. Missing storage reads as `null` and writes are dropped. */
-interface WebStorageRef {
-    read(key: string): string | null;
-    write(key: string, value: string): void;
-    remove(key: string): void;
+export interface WebStorageRef {
+  read(key: string): string | null;
+  write(key: string, value: string): void;
+  remove(key: string): void;
 }
 /**
  * `localStorage` reached through a document's own window.
@@ -172,13 +166,10 @@ interface WebStorageRef {
  * part that can throw, and a storage that is blocked now may be available later
  * (or the other way round).
  */
-declare function documentLocalStorage(documentRef: Document | null | undefined): WebStorageRef;
+export declare function documentLocalStorage(documentRef: Document | null | undefined): WebStorageRef;
 /**
  * `localStorage` from the global scope, for callers that only know whether they
  * are in a browser (the `isPlatformBrowser` flavour) rather than holding a
  * `Document`.
  */
-declare function globalLocalStorage(isBrowser: boolean): WebStorageRef;
-
-export { COMPONENT_DENSITIES, COMPONENT_RADII, RovingRow, UI_ID_GENERATOR, UiIdGenerator, cn, densityBaseValue, documentLocalStorage, globalLocalStorage, injectUniqueId, radiusBaseValue, uniqueId };
-export type { ComponentDensity, ComponentRadius, RovingRowConfig, RovingRowDirection, RovingRowItem, RovingRowScope, RovingRowTrigger, WebStorageRef };
+export declare function globalLocalStorage(isBrowser: boolean): WebStorageRef;

package/types/ojiepermana-angular-component-utils-overlay.d.ts

@@ -1,21 +1,17 @@
-import { ConnectedPosition, OverlayRef } from '@angular/cdk/overlay';
-import { Observable } from 'rxjs';
-
-type OverlaySide = 'top' | 'right' | 'bottom' | 'left';
-type OverlayAlign = 'start' | 'center' | 'end';
+import { ConnectedPosition, OverlayRef } from "@angular/cdk/overlay";
+import { Observable } from "rxjs";
+export type OverlaySide = 'top' | 'right' | 'bottom' | 'left';
+export type OverlayAlign = 'start' | 'center' | 'end';
 /**
  * Builds the CDK `ConnectedPosition` for a shadcn-style `side`/`align`/`sideOffset`
  * triple. Shared by every anchored overlay in the library (popover, tooltip,
  * hover-card, menus, combobox).
  */
-declare function connectedPositionFor(side: OverlaySide, align: OverlayAlign, sideOffset: number): ConnectedPosition;
-declare function oppositeSide(side: OverlaySide): OverlaySide;
+export declare function connectedPositionFor(side: OverlaySide, align: OverlayAlign, sideOffset: number): ConnectedPosition;
+export declare function oppositeSide(side: OverlaySide): OverlaySide;
 /**
  * Emits whenever the user dismisses the overlay: pointer down outside (ignoring
  * the origin element so trigger clicks keep toggling), Escape, or detachment.
  * Subscribers decide how to close.
  */
-declare function overlayDismissals(overlayRef: OverlayRef, origin?: HTMLElement): Observable<unknown>;
-
-export { connectedPositionFor, oppositeSide, overlayDismissals };
-export type { OverlayAlign, OverlaySide };
+export declare function overlayDismissals(overlayRef: OverlayRef, origin?: HTMLElement): Observable<unknown>;