@hyalo/angular 0.0.0-stage → 0.3.1

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-navbar.d.ts

@@ -0,0 +1,110 @@
+import * as i0 from "@angular/core";
+/** The logo or product name, at the start of the bar. */
+export declare class HyNavbarBrand {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbarBrand, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyNavbarBrand, "[hyNavbarBrand]", never, {}, {}, never, never, true, never>;
+}
+/** Buttons at the end of the bar, such as sign in or a cart. Always visible. */
+export declare class HyNavbarActions {
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbarActions, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<HyNavbarActions, "[hyNavbarActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * - `floating`: a detached glass pill with space around it.
+ * - `full`: a full-width bar. Once content scrolls under it, a soft fade
+ *   at its lower edge separates the two instead of a hard line.
+ */
+export type HyNavbarAppearance = 'floating' | 'full';
+/**
+ * A glass app bar. Links go in the default slot and are wrapped in a
+ * `<nav>`. On narrow screens they collapse behind a menu button and open as
+ * a panel under the bar. Bind `menuOpen` if you would rather open your own
+ * drawer.
+ *
+ * ```html
+ * <hy-navbar label="Main">
+ *   <a hyNavbarBrand routerLink="/">Atelier</a>
+ *   <a routerLink="/watches" routerLinkActive="active" ariaCurrentWhenActive="page">Watches</a>
+ *   <a routerLink="/journal">Journal</a>
+ *   <div hyNavbarActions><button hyButton size="sm">Book a visit</button></div>
+ * </hy-navbar>
+ * ```
+ *
+ * The bar compacts once the page scrolls, and with `hideOnScroll` it slides
+ * away while scrolling down and returns on the way up. It never hides while
+ * the menu is open or focus is inside it. The collapse point is a container
+ * query on the navbar's own width (48rem by default).
+ */
+export declare class HyNavbar {
+  private readonly toggle;
+  protected readonly linksId: string;
+  /** Accessible name of the `<nav>` landmark. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Accessible name of the menu button on narrow screens. */
+  readonly menuLabel: import("@angular/core").InputSignal<string>;
+  /** Visual style of the bar. */
+  readonly appearance: import("@angular/core").InputSignal<HyNavbarAppearance>;
+  /** CSS positioning of the navbar. */
+  readonly position: import("@angular/core").InputSignal<"sticky" | "fixed" | "static">;
+  /** Material of the bar. */
+  readonly material: import("@angular/core").InputSignal<"" | "clear" | "frosted" | "tinted" | "solid">;
+  /** Slide away while scrolling down. */
+  readonly hideOnScroll: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Scroll distance in pixels after which the bar compacts. */
+  readonly scrollThreshold: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Whether the collapsed menu is open. Two-way bindable. */
+  readonly menuOpen: import("@angular/core").ModelSignal<boolean>;
+  protected readonly scrolled: import("@angular/core").WritableSignal<boolean>;
+  protected readonly hidden: import("@angular/core").WritableSignal<boolean>;
+  constructor();
+  /** Closes the collapsed menu. */
+  closeMenu(restoreFocus?: boolean): void;
+  protected onClick(event: MouseEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNavbar, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyNavbar, "hy-navbar", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuLabel": {
+      "alias": "menuLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "appearance": {
+      "alias": "appearance";
+      "required": false;
+      "isSignal": true;
+    };
+    "position": {
+      "alias": "position";
+      "required": false;
+      "isSignal": true;
+    };
+    "material": {
+      "alias": "material";
+      "required": false;
+      "isSignal": true;
+    };
+    "hideOnScroll": {
+      "alias": "hideOnScroll";
+      "required": false;
+      "isSignal": true;
+    };
+    "scrollThreshold": {
+      "alias": "scrollThreshold";
+      "required": false;
+      "isSignal": true;
+    };
+    "menuOpen": {
+      "alias": "menuOpen";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "menuOpen": "menuOpenChange";
+  }, never, ["[hyNavbarBrand]", "*", "[hyNavbarActions]"], true, never>;
+}
+/** Everything needed to build a navbar. */
+export declare const HY_NAVBAR: readonly [typeof HyNavbar, typeof HyNavbarBrand, typeof HyNavbarActions];

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>;
+}

package/types/hyalo-angular-number-ticker.d.ts

@@ -0,0 +1,52 @@
+import * as i0 from "@angular/core";
+export declare class HyNumberTicker {
+  readonly value: import("@angular/core").InputSignal<number>;
+  readonly locale: import("@angular/core").InputSignal<string | undefined>;
+  private readonly globalLocale;
+  private readonly effectiveLocale;
+  readonly format: import("@angular/core").InputSignal<Intl.NumberFormatOptions>;
+  readonly animate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly prefix: import("@angular/core").InputSignal<string>;
+  readonly suffix: import("@angular/core").InputSignal<string>;
+  private readonly target;
+  private readonly live;
+  private readonly formatter;
+  readonly formatted: import("@angular/core").Signal<string>;
+  readonly accessible: import("@angular/core").Signal<string>;
+  private readonly motion;
+  private readonly visible;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<HyNumberTicker, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<HyNumberTicker, "hy-number-ticker", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "locale": {
+      "alias": "locale";
+      "required": false;
+      "isSignal": true;
+    };
+    "format": {
+      "alias": "format";
+      "required": false;
+      "isSignal": true;
+    };
+    "animate": {
+      "alias": "animate";
+      "required": false;
+      "isSignal": true;
+    };
+    "prefix": {
+      "alias": "prefix";
+      "required": false;
+      "isSignal": true;
+    };
+    "suffix": {
+      "alias": "suffix";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}

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

@@ -0,0 +1,40 @@
+import { ConnectedPosition } from "@angular/cdk/overlay";
+/**
+ * Where a floating element sits relative to its trigger. `start` and `end`
+ * follow the text direction, so `end` is on the right in LTR and on the left
+ * in RTL.
+ */
+export type HyPlacement = 'top' | 'bottom' | 'start' | 'end';
+/**
+ * CDK positions for a placement, with the opposite side as the first
+ * fallback when there is no room.
+ */
+export declare function hyConnectedPositions(placement: HyPlacement, offset?: number): ConnectedPosition[];
+/** Positions for a dropdown that lines up with the trigger's start edge. */
+export declare function hyDropdownPositions(offset?: number): ConnectedPosition[];
+/**
+ * @internal Enter and exit for small overlays (tooltips, popovers, select
+ * panels), driven by `data-state` and CSS transitions.
+ *
+ * Transitions start from the current value, so reopening a panel while it
+ * is still fading out simply turns it around, with no jump.
+ */
+declare class HyPresence {
+  private cancel;
+  /** True while an exit is playing. */
+  get leaving(): boolean;
+  /** Shows a panel that was just attached, or turns a leaving one around. */
+  enter(el: HTMLElement): void;
+  /** Plays the exit, then calls `done`, unless `enter` turns it around first. */
+  leave(el: HTMLElement, done: () => void): void;
+}
+/** Bounded pointer grace; keyboard dismissal never waits for the corridor. */
+export declare class HyHoverIntent {
+  private readonly document;
+  private timer?;
+  private abort?;
+  constructor(document: Document);
+  cancel(): void;
+  leave(event: PointerEvent | undefined, target: HTMLElement | undefined, close: () => void): void;
+}
+export { HyPresence as ɵHyPresence };