@edvak99/voice-receptionist-widget 1.1.13 → 1.1.15

package/lib/pages/tasks-page/tasks-page.component.d.ts

@@ -10,6 +10,7 @@ export declare class TasksPageComponent implements OnInit {
     protected readonly total: import("@angular/core").WritableSignal<number>;
     protected readonly page: import("@angular/core").WritableSignal<number>;
     protected readonly loading: import("@angular/core").WritableSignal<boolean>;
+    protected readonly skeletonRows: readonly number[];
     protected readonly selectedTask: import("@angular/core").WritableSignal<TaskItem | null>;
     /** Default to Open so staff see actionable work; Done tab for completed. */
     protected readonly statusFilter: import("@angular/core").WritableSignal<"" | TaskStatus>;

package/lib/pages/wizard-page/wizard-page.component.d.ts

@@ -7,6 +7,8 @@ export declare class WizardPageComponent implements OnInit {
     protected readonly activeStep: import("@angular/core").WritableSignal<number>;
     protected readonly loading: import("@angular/core").WritableSignal<boolean>;
     protected readonly activated: import("@angular/core").WritableSignal<boolean>;
+    protected readonly stepSkeletonRows: readonly [0, 1, 2, 3, 4];
+    protected readonly transcriptSkeletonRows: readonly [0, 1, 2];
     protected readonly completedCount: import("@angular/core").Signal<number>;
     ngOnInit(): void;
     protected selectStep(step: SetupStep): void;

package/lib/services/agent-settings-drawer.service.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+/** Single shared open state for the Agent Settings ed-drawer. */
+export declare class AgentSettingsDrawerService {
+    readonly open: import("@angular/core").WritableSignal<boolean>;
+    show(): void;
+    hide(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AgentSettingsDrawerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AgentSettingsDrawerService>;
+}

package/lib/shared/modal.component.d.ts

@@ -1,20 +1,29 @@
-import { EventEmitter } from '@angular/core';
+import { AfterViewInit, EventEmitter, OnDestroy } from '@angular/core';
 import * as i0 from "@angular/core";
 /**
  * Lightweight, reusable modal shell.
  *
  * Renders a centered card on top of a dimmed backdrop. Closes on backdrop
- * click, ESC key, or via the close button. Slot the modal body using
- * <ng-content>.
+ * click, ESC key, or via the close button.
+ *
+ * Slots:
+ * - default: scrollable body
+ * - [modalStickyTop]: optional sticky content below the title header
+ * - [modalFooter]: optional sticky footer (actions / preview)
  */
-export declare class ModalComponent {
+export declare class ModalComponent implements AfterViewInit, OnDestroy {
     title: string;
     subtitle?: string;
     maxWidth: string;
     readonly closed: EventEmitter<void>;
+    private readonly backdrop?;
+    private readonly renderer;
+    private movedToBody;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
     onEscape(): void;
     onBackdropClick(event: MouseEvent): void;
     close(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<ModalComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "app-modal", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ModalComponent, "app-modal", never, { "title": { "alias": "title"; "required": true; }; "subtitle": { "alias": "subtitle"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; }, { "closed": "closed"; }, never, ["[modalStickyTop]", "*", "[modalFooter]"], true, never>;
 }

package/lib/shared/smart-tooltip.directive.d.ts

@@ -0,0 +1,439 @@
+/**
+ * SmartTooltipDirective - Enterprise-grade tooltip system for Angular 19
+ *
+ * A fully-featured, accessible tooltip directive with support for:
+ * - Multiple content types (text, HTML, Angular templates)
+ * - Intelligent positioning with auto-placement and collision detection
+ * - Hover intent to prevent accidental triggers
+ * - Full keyboard and screen reader support (WCAG 2.1 AA compliant)
+ * - Touch device support with long-press activation
+ * - Performance optimized with RAF throttling and zone.runOutsideAngular
+ * - Memory leak prevention with proper cleanup
+ * - XSS protection via DomSanitizer
+ *
+ * @example
+ * // Basic text tooltip
+ * <button smartTooltip="Save your changes">Save</button>
+ *
+ * @example
+ * // HTML content (sanitized)
+ * <button
+ *   smartTooltip="<strong>Warning:</strong> This action cannot be undone"
+ *   [tooltipAllowHtml]="true">
+ *   Delete
+ * </button>
+ *
+ * @example
+ * // Angular template
+ * <button [smartTooltip]="null" [tooltipTemplate]="myTemplate">Info</button>
+ * <ng-template #myTemplate let-data>
+ *   <div>Custom content with {{data.value}}</div>
+ * </ng-template>
+ */
+import { OnDestroy, OnInit, OnChanges, AfterViewInit, SimpleChanges, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+type PlacementBase = 'top' | 'bottom' | 'left' | 'right';
+type Placement = PlacementBase | 'auto';
+type Trigger = 'hover' | 'focus' | 'click' | 'manual';
+export declare class SmartTooltipDirective implements OnInit, OnDestroy, OnChanges, AfterViewInit {
+    private host;
+    private r;
+    private zone;
+    private appRef;
+    private sanitizer;
+    /**
+     * Tooltip text content. If null/empty, tooltip won't show.
+     * @example <button smartTooltip="Save">Save</button>
+     */
+    text: string | null;
+    /**
+     * Treat text input as HTML and render it (sanitized) inside the tooltip.
+     * Content is sanitized using Angular's DomSanitizer to prevent XSS attacks.
+     * @default false
+     */
+    tooltipAllowHtml: boolean;
+    /**
+     * Render tooltip body from an Angular template instead of text.
+     * When provided, this takes precedence over the text input.
+     * @example
+     * <button [tooltipTemplate]="myTemplate">Info</button>
+     * <ng-template #myTemplate>Custom content</ng-template>
+     */
+    tooltipTemplate?: TemplateRef<unknown> | null;
+    /**
+     * Context passed into tooltipTemplate when rendering it.
+     * @example
+     * <button [tooltipTemplate]="tpl" [tooltipTemplateContext]="{user: currentUser}">
+     * <ng-template #tpl let-user="user">Hello {{user.name}}</ng-template>
+     */
+    tooltipTemplateContext: Record<string, unknown> | null;
+    /**
+     * Placement: fixed sides or 'auto' to choose best fit based on available space.
+     * Auto mode intelligently selects the placement with the most available space.
+     * @default 'top'
+     */
+    tooltipPlacement: Placement;
+    /**
+     * What triggers show/hide. Can be a single trigger or array of triggers.
+     * - 'hover': Show on mouseenter, hide on mouseleave (with hover intent)
+     * - 'focus': Show on focus, hide on blur
+     * - 'click': Toggle on click, close on outside click
+     * - 'manual': Programmatic control only (use show()/hide() methods)
+     * @default ['hover', 'focus']
+     */
+    tooltipTrigger: Trigger | Trigger[];
+    /**
+     * Delay before showing tooltip (milliseconds).
+     * Prevents tooltips from appearing too quickly during fast mouse movements.
+     * @default 80
+     */
+    tooltipDelayShow: number;
+    /**
+     * Delay before hiding tooltip (milliseconds).
+     * @default 80
+     */
+    tooltipDelayHide: number;
+    /**
+     * Gap between host element and tooltip (pixels).
+     * @default 8
+     */
+    tooltipOffset: number;
+    /**
+     * Maximum tooltip width (pixels).
+     * Content will wrap to fit within this constraint.
+     * @default 280
+     */
+    tooltipMaxWidth: number;
+    /**
+     * Stacking order for the body-appended tooltip.
+     * Use a higher value (e.g. 100200) inside ui-dialog overlays (z-index 100100).
+     * @default 99999
+     */
+    tooltipZIndex: number | string;
+    /**
+     * Extra CSS classes to apply to the tooltip container.
+     * Useful for custom styling or theming.
+     * @example tooltipClass="dark-theme large-text"
+     */
+    tooltipClass: string;
+    /**
+     * Master disable switch. When true, tooltip will never show.
+     * @default false
+     */
+    tooltipDisabled: boolean;
+    /**
+     * Render arrow pointing to host element.
+     * @default false
+     */
+    tooltipArrow: boolean;
+    /**
+     * Hover-intent timing (milliseconds).
+     * User must keep mouse relatively still for this duration before tooltip shows.
+     * Prevents tooltips from appearing during fast mouse sweeps across the UI.
+     * @default 220
+     */
+    tooltipHoverIntentMs: number;
+    /**
+     * Hover-intent radius (pixels).
+     * Mouse movement within this radius resets the hover intent timer.
+     * @default 6
+     */
+    tooltipHoverIntentRadius: number;
+    /**
+     * Optional custom id for the tooltip element.
+     * If not provided, a unique ID is generated automatically.
+     */
+    tooltipId?: string;
+    /**
+     * ARIA role for screen readers.
+     * @default 'tooltip'
+     */
+    tooltipRole: string;
+    /**
+     * Animation enter duration (milliseconds).
+     * Time for fade-in and scale-up animation when tooltip appears.
+     * @default 220
+     */
+    tooltipAnimEnterMs: number;
+    /**
+     * Animation exit duration (milliseconds).
+     * Time for fade-out animation when tooltip disappears.
+     * @default 160
+     */
+    tooltipAnimExitMs: number;
+    /**
+     * Animation timing function (CSS easing).
+     * Controls the acceleration curve of the animation.
+     * @default 'cubic-bezier(.22,.95,.5,1)'
+     */
+    tooltipAnimEasing: string;
+    /**
+     * Allow the mouse to hover over the tooltip (keeps it open).
+     * When enabled, users can move their mouse from the host to the tooltip
+     * without it disappearing. Text selection is still prevented.
+     * @default true
+     */
+    tooltipHoverable: boolean;
+    /**
+     * Extra grace time to cross the gap from host → tooltip (milliseconds).
+     * When mouse leaves the host, tooltip stays open for this duration to allow
+     * the user to move their cursor onto the tooltip surface.
+     * @default 180
+     */
+    tooltipHandoffMs: number;
+    /**
+     * When true, the tooltip is shown immediately and stays visible until this becomes false
+     * (e.g. validation state cleared). Use with `tooltipTrigger="manual"` so hover does not fight it.
+     * While true, programmatic hide from hover/focus is suppressed.
+     */
+    tooltipOpen: boolean;
+    /**
+     * When true, only show the tooltip if the host (or a child with `.truncate`) is visually
+     * truncated (scrollWidth/Height exceeds clientWidth/Height). Default false keeps existing call sites unchanged.
+     */
+    tooltipOnlyWhenTruncated: boolean;
+    /** Tooltip container element (created once, reused until destroyed). */
+    private tipEl;
+    /** Optional arrow element (only created when tooltipArrow is true). */
+    private arrowEl;
+    /** Cached reference to content element (avoids repeated querySelector calls). */
+    private contentEl;
+    /** Unique id bound to aria-describedby (generated or provided via input). */
+    private tipId;
+    /** Element that actually receives focus (inner <button>, <a>, etc.). */
+    private descTargetEl?;
+    /** Timer references for delayed show/hide/hover-intent operations. */
+    private showTimer;
+    private hideTimer;
+    private hoverTimer;
+    /** Touch long-press timer; cleared on destroy to prevent show-after-destroy. */
+    private touchTimer;
+    /** Unsubscribe function for per-hover mousemove listener (prevents accumulation). */
+    private hoverMoveUnsub?;
+    /** Active embedded view when using tooltipTemplate (needs proper lifecycle management). */
+    private templateView?;
+    /**
+     * Collected listener unsubscribers - host-scoped (persist for directive lifetime).
+     * These listeners are attached to the host element and window, cleaned up in ngOnDestroy.
+     */
+    private cleanupFns;
+    /**
+     * Collected listener unsubscribers - tooltip-scoped (cleaned when tooltip destroyed).
+     * These listeners are attached to the tooltip element and scroll ancestors,
+     * must be cleaned up when tooltip is removed from DOM to prevent memory leaks.
+     */
+    private tipCleanupFns;
+    /** ResizeObserver to reposition tooltip when host or tooltip size changes. */
+    private ro?;
+    /** IntersectionObserver to hide tooltip when host scrolls out of view. */
+    private io?;
+    /**
+     * Scrollable ancestors of the host element.
+     * We listen to scroll events on these to reposition the tooltip.
+     * Cleared when tooltip is destroyed to prevent memory leaks.
+     */
+    private scrollingAncestors;
+    /** Current visibility state of the tooltip. */
+    private isVisible;
+    /** Last recorded pointer position for hover-intent tracking. */
+    private lastPointerX;
+    private lastPointerY;
+    /**
+     * Timestamp until which hover triggers are blocked (after wheel scroll).
+     * Prevents tooltips from appearing immediately after user scrolls.
+     */
+    private wheelBlockUntil;
+    /** Whether the pointer is currently over the tooltip surface. */
+    private overTip;
+    /** Document-level ESC key listener unsubscribe function. */
+    private docKeydownUnsub?;
+    /**
+     * Internal: pending hide timeout used for the handoff window.
+     * Allows time for mouse to move from host element to tooltip.
+     */
+    private handoffHideTimer;
+    /**
+     * Active placement while visible (to reduce jitter/flip-flop).
+     * Once a placement is chosen and tooltip is visible, we try to keep
+     * this placement unless it would cause clipping.
+     */
+    private activePlacement?;
+    /**
+     * Cached RAF-throttled position updater (reused across all event listeners).
+     * Creating this once and reusing prevents memory leaks from duplicate closures.
+     */
+    private rafUpdatePosition;
+    /**
+     * Setup: inject global CSS, compute ids, bind triggers, install observers.
+     * All high-frequency event listeners run outside Angular zone for performance.
+     */
+    ngOnInit(): void;
+    /**
+     * React to @Input() changes.
+     * Content changes trigger re-render and repositioning.
+     * Disabling or removing content while visible triggers immediate hide.
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    /**
+     * Tear down: timers, DOM, listeners, observers, ARIA links.
+     * Critical for preventing memory leaks in long-lived applications.
+     */
+    ngOnDestroy(): void;
+    /**
+     * Normalize triggers to array form for consistent handling.
+     * Allows single trigger or array of triggers as input.
+     */
+    private normalizeTriggers;
+    /**
+     * Bind hover/focus/click/touch triggers with cleanup.
+     * Each trigger type has specific behavior optimized for that interaction pattern.
+     */
+    private bindTriggers;
+    /**
+     * Show tooltip after optional delay (creates DOM if first time).
+     * Delays are important for preventing tooltip spam during rapid interactions.
+     */
+    private show;
+    /**
+     * True when the host or a `.truncate` descendant is visually ellipsized / clipped.
+     * Uses a 1px slack for subpixel rounding.
+     */
+    private isTruncationTargetOverflowing;
+    private elementOverflows;
+    /**
+     * Hide tooltip after optional delay.
+     * Animation duration is respected before setting display:none.
+     */
+    private hide;
+    /**
+     * Clear all timers safely.
+     * Critical to prevent stale callbacks from executing.
+     */
+    private clearTimers;
+    /**
+     * Create tooltip container + content (and arrow if enabled), attach to <body>.
+     * Tooltip is positioned fixed and appended to body to avoid z-index/overflow issues.
+     */
+    private createTooltip;
+    /**
+     * Remove tooltip DOM from the document and clean up all associated resources.
+     * Critical for preventing memory leaks - must clean up listeners BEFORE removing DOM.
+     */
+    private destroyTooltip;
+    /**
+     * Inject a single global <style> for animations/appearance (idempotent, async).
+     * Uses RAF to prevent blocking the initial render.
+     * Only one style tag is created even if multiple tooltips exist.
+     */
+    private ensureGlobalCssOnce;
+    /**
+     * Recompute placement, clamp to viewport, and (optionally) position arrow.
+     * Uses cached measurements to avoid layout thrashing.
+     */
+    private updatePosition;
+    /**
+     * Determine optimal placement considering current state and clipping.
+     * Tries to maintain current placement for stability, falls back to best available.
+     */
+    private determinePlacement;
+    /**
+     * Choose best placement based on available space.
+     * Prefers placements with more available room.
+     */
+    private chooseAutoPlacement;
+    /**
+     * Try desired placement; if it clips viewport/ancestors, flip to opposite/orthogonals.
+     * Prevents tooltip from being cut off by viewport edges or scrollable containers.
+     */
+    private resolveWithFlips;
+    /**
+     * True if the given placement would clip now.
+     * Used to check if we should keep current placement.
+     */
+    private placementWouldClip;
+    /**
+     * Hypothetical rect for a placement (no DOM mutation).
+     * Allows us to test placements without actually moving the tooltip.
+     */
+    private previewPos;
+    /**
+     * Is the rect outside the viewport?
+     * Checks if any edge extends beyond window boundaries.
+     */
+    private clipsViewport;
+    /**
+     * Is the rect fully outside any scrollable ancestor's content box?
+     * Prevents tooltips from appearing when host is scrolled out of view in container.
+     */
+    private clipsAncestors;
+    /**
+     * Pixels of space on each side around the host.
+     * Used to determine which placement has the most available room.
+     */
+    private availableSpace;
+    /**
+     * Position arrow toward host center along active edge.
+     * Arrow stays within tooltip bounds and points toward center of host element.
+     */
+    private positionArrow;
+    /**
+     * Collect scrollable ancestors to reposition on their scroll.
+     * Walks up the DOM tree finding elements with overflow: scroll/auto.
+     */
+    private getScrollableAncestors;
+    /**
+     * The element that actually receives focus (inner control if present).
+     * Searches for focusable elements inside the host, falls back to host itself.
+     * Critical for proper ARIA relationships.
+     */
+    private getFocusTarget;
+    /**
+     * Bind document-level ESC to dismiss tooltip.
+     * Allows users to dismiss tooltip with Escape key from anywhere.
+     */
+    private bindDocEsc;
+    /**
+     * Remove document-level ESC handler.
+     * Cleaned up when tooltip is hidden to prevent unnecessary event processing.
+     */
+    private unbindDocEsc;
+    /**
+     * RAF-throttled wrapper to coalesce frequent events.
+     * Ensures position updates happen at most once per frame, preventing layout thrashing.
+     */
+    private rafThrottled;
+    /**
+     * Whether there is content (text or template) to show.
+     * Prevents creating empty tooltips.
+     */
+    private hasTooltipContent;
+    /**
+     * Inject the right type of content into the tooltip container.
+     * Supports three content types: template, HTML (sanitized), and plain text.
+     */
+    private populateContent;
+    /**
+     * Re-render the tooltip content when inputs change.
+     * Uses RAF to batch DOM reads/writes and prevent layout thrashing.
+     */
+    private refreshTooltipContent;
+    /**
+     * Safely sanitize arbitrary HTML before injecting.
+     * Prevents XSS attacks while providing helpful feedback for blocked content.
+     */
+    private sanitizeHtml;
+    /**
+     * Check if running in production mode.
+     * Used to conditionally log warnings only in development.
+     */
+    private isProduction;
+    /**
+     * Tear down a previously created template view.
+     * Proper cleanup prevents memory leaks from embedded views.
+     */
+    private destroyTemplateView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmartTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SmartTooltipDirective, "[smartTooltip]", never, { "text": { "alias": "smartTooltip"; "required": false; }; "tooltipAllowHtml": { "alias": "tooltipAllowHtml"; "required": false; }; "tooltipTemplate": { "alias": "tooltipTemplate"; "required": false; }; "tooltipTemplateContext": { "alias": "tooltipTemplateContext"; "required": false; }; "tooltipPlacement": { "alias": "tooltipPlacement"; "required": false; }; "tooltipTrigger": { "alias": "tooltipTrigger"; "required": false; }; "tooltipDelayShow": { "alias": "tooltipDelayShow"; "required": false; }; "tooltipDelayHide": { "alias": "tooltipDelayHide"; "required": false; }; "tooltipOffset": { "alias": "tooltipOffset"; "required": false; }; "tooltipMaxWidth": { "alias": "tooltipMaxWidth"; "required": false; }; "tooltipZIndex": { "alias": "tooltipZIndex"; "required": false; }; "tooltipClass": { "alias": "tooltipClass"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipArrow": { "alias": "tooltipArrow"; "required": false; }; "tooltipHoverIntentMs": { "alias": "tooltipHoverIntentMs"; "required": false; }; "tooltipHoverIntentRadius": { "alias": "tooltipHoverIntentRadius"; "required": false; }; "tooltipId": { "alias": "tooltipId"; "required": false; }; "tooltipRole": { "alias": "tooltipRole"; "required": false; }; "tooltipAnimEnterMs": { "alias": "tooltipAnimEnterMs"; "required": false; }; "tooltipAnimExitMs": { "alias": "tooltipAnimExitMs"; "required": false; }; "tooltipAnimEasing": { "alias": "tooltipAnimEasing"; "required": false; }; "tooltipHoverable": { "alias": "tooltipHoverable"; "required": false; }; "tooltipHandoffMs": { "alias": "tooltipHandoffMs"; "required": false; }; "tooltipOpen": { "alias": "tooltipOpen"; "required": false; }; "tooltipOnlyWhenTruncated": { "alias": "tooltipOnlyWhenTruncated"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/shared/table-skeleton.constants.d.ts

@@ -0,0 +1,2 @@
+/** Default row count for table body skeleton placeholders. */
+export declare const TABLE_SKELETON_ROWS: readonly number[];

package/lib/shared/viewport-portal.directive.d.ts

@@ -0,0 +1,16 @@
+import { AfterViewInit, OnDestroy } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Moves the host element to `document.body` so `position: fixed` overlays
+ * cover the full browser viewport (escapes `#content-area` / `.eds-content`
+ * overflow and stacking contexts), matching `app-modal` behavior.
+ */
+export declare class ViewportPortalDirective implements AfterViewInit, OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private movedToBody;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportPortalDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ViewportPortalDirective, "[edsViewportPortal]", never, {}, {}, never, never, true, never>;
+}

package/lib/ui/ed-avatar.component.d.ts

@@ -0,0 +1,18 @@
+import * as i0 from "@angular/core";
+export type EdAvatarTone = 'gray' | 'brand' | 'warm' | 'green' | 'amber' | 'violet' | 'rose';
+export type EdAvatarShape = 'circle' | 'box';
+export type EdAvatarSize = 'xs' | 'sm' | 'base' | 'md' | 'lg';
+export declare class EdAvatarComponent {
+    initials: string;
+    tone: EdAvatarTone | string;
+    shape: EdAvatarShape;
+    size: EdAvatarSize;
+    gradient: boolean;
+    get shapeAttr(): EdAvatarShape;
+    get sizeAttr(): EdAvatarSize;
+    get toneAttr(): string;
+    get gradientClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdAvatarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EdAvatarComponent, "ed-avatar", never, { "initials": { "alias": "initials"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "size": { "alias": "size"; "required": false; }; "gradient": { "alias": "gradient"; "required": false; }; }, {}, never, never, true, never>;
+    static ngAcceptInputType_gradient: unknown;
+}

package/lib/ui/ed-button.component.d.ts

@@ -0,0 +1,44 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+type Size = 'xs' | 'sm' | 'base' | 'md' | 'lg';
+type Variant = 'default' | 'primary' | 'secondary' | 'accent' | 'success' | 'danger' | 'warning' | 'info';
+type Shape = 'square' | 'pill' | 'rounded';
+export declare class EdButtonComponent {
+    variant: import("@angular/core").InputSignal<Variant>;
+    size: import("@angular/core").InputSignal<Size>;
+    disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    ghost: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    outline: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    subtle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    fill: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    loading: import("@angular/core").InputSignalWithTransform<string | boolean, unknown>;
+    block: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    elevated: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    shape: import("@angular/core").InputSignal<Shape>;
+    type: import("@angular/core").InputSignal<"button" | "submit" | "reset">;
+    href: import("@angular/core").InputSignal<string | null>;
+    routerLink: import("@angular/core").InputSignal<string | any[] | null>;
+    rel: import("@angular/core").InputSignal<string | null>;
+    target: import("@angular/core").InputSignal<string | null>;
+    download: import("@angular/core").InputSignal<string | boolean | null>;
+    ariaLabel: import("@angular/core").InputSignal<string | null>;
+    clicked: EventEmitter<MouseEvent>;
+    styleKind: import("@angular/core").Signal<"fill" | "ghost" | "outline" | "subtle">;
+    constructor();
+    linkMode: import("@angular/core").Signal<"router" | "href" | null>;
+    asAnchor: import("@angular/core").Signal<boolean>;
+    effectiveHref: import("@angular/core").Signal<string | null>;
+    effectiveRouterLink: import("@angular/core").Signal<string | any[] | null>;
+    safeRel: import("@angular/core").Signal<string | null>;
+    private static readonly HEIGHTS;
+    private static readonly ICONS;
+    btnHeightPx: import("@angular/core").Signal<number>;
+    iconPx: import("@angular/core").Signal<number>;
+    loadingOn: import("@angular/core").Signal<boolean>;
+    loadingLabel: import("@angular/core").Signal<string>;
+    downloadAttr(): string | null;
+    onClick(evt: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EdButtonComponent, "ed-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ghost": { "alias": "ghost"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "subtle": { "alias": "subtle"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": false; "isSignal": true; }; "routerLink": { "alias": "routerLink"; "required": false; "isSignal": true; }; "rel": { "alias": "rel"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "download": { "alias": "download"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "clicked": "click$"; }, never, ["[slot=\"prefix\"]", "*", "[slot=\"suffix\"]"], true, never>;
+}
+export {};

package/lib/ui/ed-icon-button.component.d.ts

@@ -0,0 +1,67 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+type Size = 'xs' | 'sm' | 'base' | 'md' | 'lg';
+type Variant = 'default' | 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'accent' | 'info';
+type Shape = 'circle' | 'square';
+type BtnType = 'button' | 'submit' | 'reset';
+type IconPixelSize = 14 | 16 | 18 | 20 | 24 | 28 | 32;
+export declare class EdIconButtonComponent {
+    label: string;
+    name: string;
+    size: Size;
+    variant: Variant;
+    allowBubble: boolean;
+    ghost: boolean;
+    outline: boolean;
+    solid: boolean;
+    subtle: boolean;
+    shape: Shape;
+    private readonly btnTypes;
+    private typeValue;
+    set type(v: BtnType);
+    get type(): BtnType;
+    disabled: boolean;
+    loading: boolean;
+    toggle: boolean;
+    pressed: boolean;
+    id?: string;
+    title?: string;
+    nameAttr?: string;
+    value?: string;
+    autofocus: boolean;
+    tabIndex?: number;
+    readonly click: EventEmitter<MouseEvent>;
+    readonly focus: EventEmitter<FocusEvent>;
+    readonly blur: EventEmitter<FocusEvent>;
+    readonly click$: EventEmitter<MouseEvent>;
+    readonly focus$: EventEmitter<FocusEvent>;
+    readonly blur$: EventEmitter<FocusEvent>;
+    get isDisabled(): boolean;
+    get ariaBusy(): 'true' | null;
+    get iconSize(): IconPixelSize;
+    get btnSizeVar(): string;
+    get spinnerSizeVar(): string;
+    get btnRadiusVar(): string;
+    get effectiveStyle(): 'ghost' | 'outline' | 'subtle' | 'solid';
+    onClick(ev: MouseEvent): void;
+    onFocus(ev: FocusEvent): void;
+    onBlur(ev: FocusEvent): void;
+    stopClickBubble(e: Event): void;
+    stopPointerDownBubble(e: Event): void;
+    stopPointerUpBubble(e: Event): void;
+    stopMouseDownBubble(e: Event): void;
+    stopMouseUpBubble(e: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EdIconButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EdIconButtonComponent, "ed-icon-button", never, { "label": { "alias": "label"; "required": true; }; "name": { "alias": "name"; "required": true; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "allowBubble": { "alias": "allowBubble"; "required": false; }; "ghost": { "alias": "ghost"; "required": false; }; "outline": { "alias": "outline"; "required": false; }; "solid": { "alias": "solid"; "required": false; }; "subtle": { "alias": "subtle"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; "pressed": { "alias": "pressed"; "required": false; }; "id": { "alias": "id"; "required": false; }; "title": { "alias": "title"; "required": false; }; "nameAttr": { "alias": "nameAttr"; "required": false; }; "value": { "alias": "value"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; }, { "click": "click"; "focus": "focus"; "blur": "blur"; "click$": "click$"; "focus$": "focus$"; "blur$": "blur$"; }, never, never, true, never>;
+    static ngAcceptInputType_allowBubble: unknown;
+    static ngAcceptInputType_ghost: unknown;
+    static ngAcceptInputType_outline: unknown;
+    static ngAcceptInputType_solid: unknown;
+    static ngAcceptInputType_subtle: unknown;
+    static ngAcceptInputType_disabled: unknown;
+    static ngAcceptInputType_loading: unknown;
+    static ngAcceptInputType_toggle: unknown;
+    static ngAcceptInputType_pressed: unknown;
+    static ngAcceptInputType_autofocus: unknown;
+}
+export {};