@hyalo/angular 0.1.0 → 0.3.1

package/types/hyalo-angular-hover-card.d.ts

@@ -0,0 +1,47 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import { HyPlacement } from "@hyalo/angular/overlay";
+export declare class HyHoverCard {
+  readonly content: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  readonly hoverCardLabel: import("@angular/core").InputSignal<string>;
+  readonly placement: import("@angular/core").InputSignal<HyPlacement>;
+  readonly open: import("@angular/core").WritableSignal<boolean>;
+  protected readonly id: string;
+  private readonly injector;
+  private readonly host;
+  private readonly container;
+  private readonly fidelity;
+  private readonly document;
+  private readonly intent;
+  private ref;
+  private timer;
+  private disposed;
+  private suppressFocus;
+  protected focusTrigger(): void;
+  constructor();
+  protected enter(event: PointerEvent): void;
+  protected leave(event?: PointerEvent): void;
+  protected focusOut(event: FocusEvent): void;
+  protected escape(event: Event): void;
+  protected focusCard(event: Event): void;
+  show(): void;
+  hide(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyHoverCard, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyHoverCard, "[hyHoverCard]", ["hyHoverCard"], {
+    "content": {
+      "alias": "hyHoverCard";
+      "required": true;
+      "isSignal": true;
+    };
+    "hoverCardLabel": {
+      "alias": "hoverCardLabel";
+      "required": true;
+      "isSignal": true;
+    };
+    "placement": {
+      "alias": "placement";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/hyalo-angular-image-compare.d.ts

@@ -0,0 +1,55 @@
+import * as i0 from "@angular/core";
+/** Native range input provides pointer, touch, keyboard and screen reader controls. */
+export declare class HyImageCompare {
+  readonly before: import("@angular/core").InputSignal<string>;
+  readonly after: import("@angular/core").InputSignal<string>;
+  readonly beforeAlt: import("@angular/core").InputSignal<string>;
+  readonly afterAlt: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly value: import("@angular/core").ModelSignal<number>;
+  readonly ratio: import("@angular/core").InputSignal<string>;
+  protected readonly id: string;
+  protected readonly position: import("@angular/core").Signal<number>;
+  protected readonly clip: import("@angular/core").Signal<string>;
+  protected change(event: Event): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyImageCompare, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyImageCompare, "hy-image-compare", never, {
+    "before": {
+      "alias": "before";
+      "required": true;
+      "isSignal": true;
+    };
+    "after": {
+      "alias": "after";
+      "required": true;
+      "isSignal": true;
+    };
+    "beforeAlt": {
+      "alias": "beforeAlt";
+      "required": true;
+      "isSignal": true;
+    };
+    "afterAlt": {
+      "alias": "afterAlt";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "ratio": {
+      "alias": "ratio";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}

package/types/hyalo-angular-kbd.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class HyKbd {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyKbd, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyKbd, "kbd[hyKbd]", never, {}, {}, never, ["*"], true, never>;
+}

package/types/hyalo-angular-lightbox.d.ts

@@ -0,0 +1,67 @@
+import { HyDialogRef } from "@hyalo/angular/dialog";
+import * as i0 from "@angular/core";
+export interface HyGalleryImage {
+  readonly src: string;
+  readonly alt: string;
+  readonly thumbnail?: string;
+  readonly caption?: string;
+}
+export interface HyLightboxOptions {
+  readonly index?: number;
+  readonly label?: string;
+  readonly closeLabel?: string;
+  readonly previousLabel?: string;
+  readonly nextLabel?: string;
+}
+interface GalleryData extends HyLightboxOptions {
+  readonly images: readonly HyGalleryImage[];
+}
+export declare class HyLightboxView {
+  protected readonly data: GalleryData;
+  protected readonly ref: HyDialogRef<any>;
+  protected readonly index: import("@angular/core").WritableSignal<number>;
+  protected readonly image: import("@angular/core").Signal<HyGalleryImage | undefined>;
+  protected move(delta: number): void;
+  protected onKey(event: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLightboxView, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyLightboxView, "hy-lightbox-view", never, {}, {}, never, never, true, never>;
+}
+/** Opens a gallery using the kit dialog's focus trap, Escape handling and focus restore. */
+export declare class HyLightbox {
+  private readonly dialog;
+  open(images: readonly HyGalleryImage[], options?: HyLightboxOptions): HyDialogRef | null;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLightbox, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class HyGallery {
+  private readonly lightbox;
+  readonly images: import("@angular/core").InputSignal<readonly HyGalleryImage[]>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly openLabel: import("@angular/core").InputSignal<string>;
+  readonly options: import("@angular/core").InputSignal<HyLightboxOptions>;
+  open(index: number): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyGallery, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyGallery, "hy-gallery", never, {
+    "images": {
+      "alias": "images";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "openLabel": {
+      "alias": "openLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export {};

package/types/hyalo-angular-link.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class HyLink {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyLink, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyLink, "a[hyLink]", never, {}, {}, never, ["*"], true, never>;
+}

package/types/hyalo-angular-list.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+export declare class HyList {
+  readonly label: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyList, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyList, "hy-list", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare class HyListItem {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly description: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyListItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyListItem, "li[hyListItem]", never, {
+    "heading": {
+      "alias": "heading";
+      "required": true;
+      "isSignal": true;
+    };
+    "description": {
+      "alias": "description";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+export declare const HY_LIST: readonly [typeof HyList, typeof HyListItem];

package/types/hyalo-angular-marquee.d.ts

@@ -0,0 +1,48 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+export declare class HyMarqueeItem {
+  readonly template: TemplateRef<unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMarqueeItem, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyMarqueeItem, "ng-template[hyMarqueeItem]", never, {}, {}, never, never, true, never>;
+}
+export declare class HyMarquee {
+  private readonly motion;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly duration: import("@angular/core").InputSignal<string>;
+  readonly reverse: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pauseLabel: import("@angular/core").InputSignal<string>;
+  readonly playLabel: import("@angular/core").InputSignal<string>;
+  protected readonly paused: import("@angular/core").WritableSignal<boolean>;
+  protected readonly motionEnabled: import("@angular/core").Signal<boolean>;
+  protected readonly running: import("@angular/core").Signal<boolean>;
+  protected readonly items: import("@angular/core").Signal<readonly HyMarqueeItem[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMarquee, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMarquee, "hy-marquee", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "duration": {
+      "alias": "duration";
+      "required": false;
+      "isSignal": true;
+    };
+    "reverse": {
+      "alias": "reverse";
+      "required": false;
+      "isSignal": true;
+    };
+    "pauseLabel": {
+      "alias": "pauseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "playLabel": {
+      "alias": "playLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["items"], ["*"], true, never>;
+}
+export declare const HY_MARQUEE: readonly [typeof HyMarquee, typeof HyMarqueeItem];

package/types/hyalo-angular-menu.d.ts

@@ -0,0 +1,105 @@
+import * as i0 from "@angular/core";
+import { TemplateRef } from "@angular/core";
+import * as i1 from "@angular/cdk/menu";
+import * as i2 from "@hyalo/angular/core";
+export declare class HyMenu {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMenu, "hy-menu", never, {}, {}, never, ["*"], true, [{
+    directive: typeof i1.CdkMenu;
+    inputs: {};
+    outputs: {};
+  }, {
+    directive: typeof i2.HyMaterialDirective;
+    inputs: {
+      "hyMaterial": "material";
+    };
+    outputs: {};
+  }]>;
+}
+export declare class HyMenuTrigger {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMenuTrigger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyMenuTrigger, "[hyMenuTriggerFor]", never, {}, {}, never, never, true, [{
+    directive: typeof i1.CdkMenuTrigger;
+    inputs: {
+      "cdkMenuTriggerFor": "hyMenuTriggerFor";
+      "cdkMenuPosition": "menuPosition";
+      "cdkMenuTriggerData": "menuData";
+    };
+    outputs: {
+      "cdkMenuOpened": "menuOpened";
+      "cdkMenuClosed": "menuClosed";
+    };
+  }]>;
+}
+export declare class HyMenuItem {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMenuItem, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMenuItem, "button[hyMenuItem],a[hyMenuItem]", never, {}, {}, never, ["*"], true, [{
+    directive: typeof i1.CdkMenuItem;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+      "cdkMenuitemTypeaheadLabel": "typeaheadLabel";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+export declare class HyMenuCheckbox {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMenuCheckbox, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMenuCheckbox, "button[hyMenuCheckbox]", never, {}, {}, never, ["*"], true, [{
+    directive: typeof i1.CdkMenuItemCheckbox;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+      "cdkMenuItemChecked": "checked";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+export declare class HyMenuRadio {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMenuRadio, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMenuRadio, "button[hyMenuRadio]", never, {}, {}, never, ["*"], true, [{
+    directive: typeof i1.CdkMenuItemRadio;
+    inputs: {
+      "cdkMenuItemDisabled": "disabled";
+      "cdkMenuItemChecked": "checked";
+    };
+    outputs: {
+      "cdkMenuItemTriggered": "triggered";
+    };
+  }]>;
+}
+export declare class HySplitButton {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly menu: import("@angular/core").InputSignal<TemplateRef<unknown>>;
+  readonly menuLabel: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  readonly activated: import("@angular/core").OutputEmitterRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySplitButton, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HySplitButton, "hy-split-button", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "menu": {
+      "alias": "menu";
+      "required": true;
+      "isSignal": true;
+    };
+    "menuLabel": {
+      "alias": "menuLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "activated": "activated";
+  }, never, never, true, never>;
+}
+export declare const HY_MENU: readonly [typeof HyMenu, typeof HyMenuItem, typeof HyMenuTrigger, typeof HyMenuCheckbox, typeof HyMenuRadio, typeof HySplitButton];

package/types/hyalo-angular-mesh.d.ts

@@ -0,0 +1,36 @@
+import * as i0 from "@angular/core";
+/** Ambient backdrop. Content stays in a separate, stationary layer. */
+export declare class HyMesh {
+  private readonly motion;
+  private readonly visible;
+  readonly animated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly pauseLabel: import("@angular/core").InputSignal<string>;
+  readonly playLabel: import("@angular/core").InputSignal<string>;
+  readonly disabledLabel: import("@angular/core").InputSignal<string>;
+  protected readonly paused: import("@angular/core").WritableSignal<boolean>;
+  protected readonly allowed: import("@angular/core").Signal<boolean>;
+  protected readonly moving: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMesh, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyMesh, "hy-mesh", never, {
+    "animated": {
+      "alias": "animated";
+      "required": false;
+      "isSignal": true;
+    };
+    "pauseLabel": {
+      "alias": "pauseLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "playLabel": {
+      "alias": "playLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabledLabel": {
+      "alias": "disabledLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}

package/types/hyalo-angular-motion.d.ts

@@ -0,0 +1,218 @@
+import { HyGsap } from "@hyalo/angular/core";
+import * as i0 from "@angular/core";
+import { Signal } from "@angular/core";
+/** One named motion: duration in seconds plus matching GSAP and CSS easings. */
+export interface HyMotionPreset {
+  readonly duration: number;
+  readonly ease: string;
+  readonly css: string;
+}
+/**
+ * The shared motion vocabulary. CSS has the same values as `--hy-dur-*` and
+ * `--hy-ease-*` tokens.
+ *
+ * - `settle`: the default for anything that moves into place.
+ * - `pop`: a small overshoot. Only for motion the user caused, such as a
+ *   toggle they just pressed. Never for things that appear on their own.
+ * - `quick`: acknowledgements, like a press or a hover.
+ * - `scene`: large, slow movements such as section reveals.
+ */
+export declare const MOTION: {
+  readonly settle: {
+    readonly duration: 0.44;
+    readonly ease: "power3.out";
+    readonly css: "cubic-bezier(0.215, 0.61, 0.355, 1)";
+  };
+  readonly pop: {
+    readonly duration: 0.5;
+    readonly ease: "back.out(1.5)";
+    readonly css: "cubic-bezier(0.34, 1.56, 0.64, 1)";
+  };
+  readonly quick: {
+    readonly duration: 0.22;
+    readonly ease: "power2.out";
+    readonly css: "cubic-bezier(0.25, 0.46, 0.45, 0.94)";
+  };
+  readonly scene: {
+    readonly duration: 0.9;
+    readonly ease: "expo.out";
+    readonly css: "cubic-bezier(0.16, 1, 0.3, 1)";
+  };
+};
+/**
+ * Motion state for the whole app: whether the user prefers reduced motion,
+ * whether effects may run at all, and lazy access to GSAP.
+ */
+export declare class HyMotion {
+  private readonly config;
+  private readonly fidelity;
+  private readonly document;
+  private readonly isBrowser;
+  private readonly _reduced;
+  private gsapPromise;
+  /** True when the OS asks for reduced motion, or the app forced it. */
+  readonly reduced: import("@angular/core").Signal<boolean>;
+  /** True when decorative motion (tilt, magnetic, reveal) may run. */
+  readonly enabled: import("@angular/core").Signal<boolean>;
+  constructor();
+  /**
+   * Requests reduced or normal motion without overriding the OS preference, and mirrors
+   * the choice to `data-hy-motion` so CSS tokens follow. Pass `null` to go
+   * back to the OS setting.
+   */
+  setReduced(reduced: boolean | null): void;
+  /**
+   * Loads GSAP once, if the app provided a loader. Resolves to `null` on the
+   * server, without a loader, or if loading fails, so callers can fall back
+   * to CSS.
+   */
+  gsap(): Promise<HyGsap | null>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyMotion, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/**
+ * A spring in the two numbers Apple designs with.
+ *
+ * - `damping`: 1 settles without overshoot, lower values bounce.
+ * - `response`: roughly how many seconds it takes to get there. Not a
+ *   duration; the settle time falls out of the physics.
+ */
+export interface HySpringConfig {
+  /** Finite and greater than zero, so the spring can settle. */
+  readonly damping: number;
+  /** Finite and at least 1/60 second. Use set() for an immediate change. */
+  readonly response: number;
+}
+/**
+ * The shared springs.
+ *
+ * - `settle`: the default. No bounce.
+ * - `momentum`: after a flick or a drag, when the gesture carried speed.
+ */
+export declare const SPRINGS: {
+  readonly settle: {
+    readonly damping: 1;
+    readonly response: 0.4;
+  };
+  readonly momentum: {
+    readonly damping: 0.8;
+    readonly response: 0.3;
+  };
+};
+/** Options for {@link HySpring.to}. */
+export interface HySpringTarget extends Partial<HySpringConfig> {
+  /** Starting velocity in units per second. Defaults to the current one. */
+  readonly velocity?: number;
+  /** Runs once the value comes to rest on the target. */
+  readonly onRest?: () => void;
+}
+/**
+ * Animates one number on `requestAnimationFrame`. Every `to()` starts from
+ * the live value and keeps its velocity, so the motion can be grabbed and
+ * redirected at any moment without a jump or a sudden stop.
+ */
+export declare class HySpring {
+  private readonly onUpdate;
+  /** The value on screen right now. */
+  value: number;
+  /** Units per second. */
+  velocity: number;
+  private target;
+  private config;
+  private onRest;
+  private frame;
+  private last;
+  constructor(initial: number, onUpdate: (value: number) => void);
+  /** True while the spring is moving. */
+  get running(): boolean;
+  /** Springs toward `target`, from wherever it is now. */
+  to(target: number, options?: HySpringTarget): void;
+  /** Jumps to a value and stops, as when a finger holds it. */
+  set(value: number): void;
+  /** Stops where it is. A pending `onRest` is dropped. */
+  stop(): void;
+  private readonly tick;
+}
+/**
+ * How far a flick travels before it stops, from the velocity in px per
+ * second. This is the deceleration curve of scrolling, so a target picked
+ * from `position + project(velocity)` lands where the gesture was going.
+ */
+export declare function project(velocity: number, decelerationRate?: number): number;
+/**
+ * Resistance past a boundary. The further the overshoot, the less the
+ * element follows, so an edge feels soft instead of frozen.
+ */
+export declare function rubberband(overshoot: number, dimension: number, constant?: number): number;
+/** Velocity of a pointer from its last 100ms of movement. */
+export declare class HyVelocityTracker {
+  private samples;
+  add(value: number, time?: number): void;
+  reset(): void;
+  /** Units per second. Zero if the pointer has been still for 100ms. */
+  velocity(now?: number): number;
+}
+/** A static SSR state keeps browser measurements out of the hydration structure. */
+export declare function injectHyVisibility(): Signal<boolean>;
+export interface HyPointerHandlers {
+  enter?(event: PointerEvent, rect: DOMRect): void;
+  move(event: PointerEvent, rect: DOMRect): void;
+  leave?(): void;
+  destroy?(): void;
+}
+/** One sampler per document; style writes stay on opted-in surfaces. */
+export declare class HySceneLight {
+  private readonly document;
+  private readonly motion;
+  private readonly entries;
+  private readonly observers;
+  private resize?;
+  private abort?;
+  private event?;
+  private frame;
+  private dirty;
+  constructor();
+  register(host: HTMLElement, handlers: HyPointerHandlers, scene?: boolean, root?: Element | null): () => void;
+  private start;
+  private schedule;
+  private draw;
+  private leave;
+  private reset;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySceneLight, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export declare class HySceneLightDirective {
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HySceneLightDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HySceneLightDirective, "[hySceneLight]", never, {}, {}, never, never, true, never>;
+}
+/** The caller owns the state change and focus; this directive only animates its own host bounds. */
+export declare class HyFlip {
+  private readonly host;
+  private readonly motion;
+  private readonly injector;
+  private readonly destroy;
+  private animation?;
+  private generation;
+  constructor();
+  run(change: () => void): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyFlip, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyFlip, "[hyFlip]", ["hyFlip"], {}, {}, never, never, true, never>;
+}
+export declare class HyStagger {
+  readonly hyStagger: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  private readonly host;
+  private readonly visible;
+  private readonly motion;
+  private readonly seen;
+  private readonly animations;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyStagger, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyStagger, "[hyStagger]", never, {
+    "hyStagger": {
+      "alias": "hyStagger";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

package/types/hyalo-angular-navigation-menu.d.ts

@@ -0,0 +1,47 @@
+import { ConnectedPosition } from "@angular/cdk/overlay";
+import * as i0 from "@angular/core";
+export interface HyNavigationLink {
+  readonly label: string;
+  readonly href: string;
+  readonly description?: string;
+}
+export interface HyNavigationSection {
+  readonly label: string;
+  readonly links: readonly HyNavigationLink[];
+}
+export interface HyNavigationItem {
+  readonly id: string;
+  readonly label: string;
+  readonly href?: string;
+  readonly sections?: readonly HyNavigationSection[];
+}
+export declare class HyNavigationMenu {
+  readonly items: import("@angular/core").InputSignal<readonly HyNavigationItem[]>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly open: import("@angular/core").WritableSignal<string | null>;
+  protected readonly id: string;
+  private readonly host;
+  private readonly document;
+  private trigger;
+  protected readonly positions: ConnectedPosition[];
+  protected outside(event: MouseEvent): void;
+  private panel;
+  protected enterPanel(event: KeyboardEvent): void;
+  protected panelKeydown(event: KeyboardEvent): void;
+  toggle(id: string, event: Event): void;
+  escape(event: Event): void;
+  focusOut(event: FocusEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavigationMenu, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyNavigationMenu, "hy-navigation-menu", never, {
+    "items": {
+      "alias": "items";
+      "required": true;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}