@cdevhub/ngx-tw 0.2.0

package/types/cdevhub-ngx-tw-toast.d.ts

@@ -0,0 +1,388 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, InjectionToken, TemplateRef, Type, OnDestroy, EnvironmentProviders } from '@angular/core';
+import { Observable } from 'rxjs';
+import { Portal } from '@angular/cdk/portal';
+
+/** Patch accepted by {@link ToastRef.update}. Mirrors the subset of `ToastConfig` that is safe to mutate live. */
+interface ToastUpdatePatch {
+    /** New severity — updates color, default icon, and (for `'error'`) live-region politeness. */
+    severity?: ToastSeverity;
+    /** New auto-dismiss duration in ms. Restarts the timer if the toast is visible. `0` disables auto-dismiss. */
+    duration?: number;
+    /** Replace or clear the action button. Pass `null` to remove. */
+    action?: ToastAction | null;
+    /** Override the icon slot. */
+    icon?: string | false | undefined;
+    /** Replace the `TW_TOAST_DATA` payload. */
+    data?: unknown;
+    /** Replace the aria-label applied to the toast wrapper. */
+    ariaLabel?: string;
+    /** Replace the toast's content (string, template, or component). */
+    content?: ToastContent;
+    /** Whether the close button is shown. */
+    dismissible?: boolean;
+}
+/**
+ * Reference to a toast opened via {@link ToastService}. Use to dismiss the
+ * toast, pause / resume its auto-dismiss timer, or observe its lifecycle.
+ *
+ * The service returns a ref synchronously from every open method; the toast
+ * itself is attached asynchronously inside the CDK overlay.
+ */
+declare class ToastRef<C = unknown, R = unknown> {
+    private readonly dismissCallback;
+    /** Unique id. Generated if `config.id` was not provided. */
+    readonly id: string;
+    /** Instance of the component rendered inside the toast (only for component-class content). */
+    componentInstance: C | null;
+    /** Resolved static config for this toast (defaults merged, severity shorthand applied). */
+    readonly config: Readonly<ToastConfig<unknown, R>>;
+    /** Reactive lifecycle state. */
+    readonly state: Signal<ToastState>;
+    /** Reactive severity — may change after `update()` (used by the `promise()` helper). */
+    readonly severity: Signal<ToastSeverity>;
+    /** Reactive dismissibility. */
+    readonly dismissible: Signal<boolean>;
+    /** Reactive icon override. */
+    readonly icon: Signal<string | false | undefined>;
+    /** Reactive content (the source of truth for what gets rendered). */
+    readonly content: Signal<ToastContent>;
+    /** Reactive action button configuration. */
+    readonly action: Signal<ToastAction | undefined>;
+    /** Reactive accessible label. */
+    readonly ariaLabel: Signal<string | undefined>;
+    /** Reactive data payload — re-read by the container to update `TW_TOAST_DATA`. */
+    readonly data: Signal<unknown>;
+    /** @internal Reactive "transient" class applied by swipe gestures (e.g. `translate3d(...)`). */
+    readonly swipeTransform: WritableSignal<string | null>;
+    /** @internal Reactive opacity applied during swipe gestures. */
+    readonly swipeOpacity: WritableSignal<number | null>;
+    /** @internal Leave-animation class override. When non-null, container uses this instead of the position default. */
+    readonly leaveAnimationOverride: WritableSignal<string | null>;
+    /** @internal Portal for component-class content. Set by the service; null for string / template content. */
+    _portal: Portal<unknown> | null;
+    /** @internal True while the pointer hovers this toast. */
+    _hovered: boolean;
+    /** @internal True while focus is within this toast. */
+    _focused: boolean;
+    /** @internal Set by the service so the ref can reach the CDK-owned OverlayRef if it needs to. */
+    _overlayPanelElement: HTMLElement | null;
+    private readonly stateSignal;
+    private readonly severitySignal;
+    private readonly dismissibleSignal;
+    private readonly iconSignal;
+    private readonly contentSignal;
+    private readonly actionSignal;
+    private readonly ariaLabelSignal;
+    private readonly dataSignal;
+    private readonly afterOpenedSubject;
+    private readonly beforeDismissedSubject;
+    private readonly afterDismissedSubject;
+    private readonly updatedSubject;
+    private dismissReason;
+    private dismissResult;
+    private autoDismissTimer;
+    private autoDismissStartedAt;
+    private autoDismissRemaining;
+    private paused;
+    private enterTimer;
+    private leaveTimer;
+    constructor(id: string, content: ToastContent, config: ToastConfig<unknown, R>, dismissCallback: (ref: ToastRef) => void);
+    /**
+     * Dismiss the toast programmatically. The leave animation plays before the
+     * element is removed and subscribers are notified. Safe to call multiple times.
+     */
+    dismiss(result?: R): void;
+    /** Pause the auto-dismiss timer (if any). Called automatically on hover / focus when `pauseOnInteraction` is true. */
+    pause(): void;
+    /** Resume the auto-dismiss timer with the remaining time. */
+    resume(): void;
+    /**
+     * @internal Update the hover state. When `pauseOnInteraction` is set and
+     * either hover or focus is active, the auto-dismiss timer is paused.
+     */
+    _setHovered(hovered: boolean): void;
+    /** @internal Update the focus-within state. See `_setHovered`. */
+    _setFocused(focused: boolean): void;
+    private _syncInteractionPause;
+    /** Invoke the configured action handler (or dismiss with reason `'action'` if none is set). */
+    triggerAction(): void;
+    /** Mutate the live toast in place. Used by the `promise()` helper to swap loading → success / error. */
+    update(patch: ToastUpdatePatch): void;
+    /** Observable that emits once after the enter animation completes. */
+    afterOpened(): Observable<void>;
+    /** Observable that emits once when the dismiss sequence starts. */
+    beforeDismissed(): Observable<R | undefined>;
+    /** Observable that emits once after the leave animation completes and the ref is cleaned up. */
+    afterDismissed(): Observable<ToastDismissal<R>>;
+    /** @internal Observable of `update()` calls. The container subscribes to re-announce to `LiveAnnouncer`. */
+    _updates(): Observable<ToastUpdatePatch>;
+    /** @internal Called by the service when the max-visible cap is exceeded. */
+    _dismissAsMaxExceeded(): void;
+    /** @internal Start the dismiss sequence with the given reason. */
+    _dismissWith(reason: ToastDismissReason, result?: R): void;
+    /** @internal Finalise dismissal — clears timers, emits `afterDismissed`, and hands control back to the service. */
+    _finishDismiss(): void;
+    private _markVisible;
+    private _startAutoDismissTimer;
+}
+
+/** Severity variant — drives color palette, default icon, and live-region politeness. */
+type ToastSeverity = 'info' | 'success' | 'warning' | 'error' | 'neutral';
+/** Screen anchor for a stack of toasts. One CDK overlay is created per position on first use. */
+type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+/** Lifecycle state of a single toast. */
+type ToastState = 'entering' | 'visible' | 'paused' | 'dismissing' | 'dismissed';
+/** Reason a toast was dismissed. */
+type ToastDismissReason = 'action' | 'timeout' | 'swipe' | 'manual' | 'programmatic' | 'max-exceeded';
+/** Payload forwarded to `afterDismissed()` subscribers. */
+interface ToastDismissal<R = unknown> {
+    /** Why the toast closed. */
+    reason: ToastDismissReason;
+    /** Optional value forwarded from `ref.dismiss(result)`. */
+    result?: R;
+}
+/** Context object handed to `TemplateRef` content (`let-data let-ref="ref"`). */
+interface ToastTemplateContext<T = unknown> {
+    /** Data value from `config.data`, unwrapped as the template's `$implicit`. */
+    $implicit: T;
+    /** Reference to the toast itself, bound as `let-ref="ref"`. */
+    ref: ToastRef<unknown, unknown>;
+}
+/** Action button configuration. When `handler` is omitted the button dismisses the toast with reason `'action'`. */
+interface ToastAction {
+    /** Visible label of the action button. */
+    label: string;
+    /** Optional callback invoked when the action is clicked or `ref.triggerAction()` is called. */
+    handler?: (ref: ToastRef) => void;
+}
+/**
+ * Per-call configuration for {@link ToastService} methods. Also used as the
+ * payload of {@link TW_TOAST_DEFAULT_OPTIONS} for app-wide defaults.
+ */
+declare class ToastConfig<D = unknown, R = unknown> {
+    /** Severity of the toast. Defaults to `'info'`. */
+    severity?: ToastSeverity;
+    /** Screen position of the toast stack. Defaults to `'bottom-right'`. */
+    position?: ToastPosition;
+    /** Auto-dismiss duration in ms. `0` disables auto-dismiss. Defaults to `5000`. */
+    duration?: number;
+    /** When true, renders a close (×) button. Defaults to `true`. */
+    dismissible?: boolean;
+    /**
+     * Live-region politeness. When omitted, resolves to `'assertive'` for
+     * `severity: 'error'` and `'polite'` otherwise. Pass `'off'` to skip
+     * `LiveAnnouncer` entirely.
+     */
+    politeness?: 'polite' | 'assertive' | 'off';
+    /** Action button configuration. Omit to hide the action button. */
+    action?: ToastAction;
+    /** Arbitrary data provided to component / template content via `TW_TOAST_DATA`. */
+    data?: D | null;
+    /** Extra CSS classes merged onto the toast panel root via `twMerge`. */
+    panelClass?: string | string[];
+    /**
+     * Icon override. Pass a string (treated as text glyph / icon name) or
+     * `false` to hide the icon. When omitted the severity-default icon is used.
+     *
+     * Note: To render arbitrary icon markup, pass a `TemplateRef` to `show()`
+     * itself (the whole toast is a custom template) — the icon slot accepts only
+     * primitives for the string-content path.
+     */
+    icon?: string | false;
+    /** When true, pause the auto-dismiss timer while the toast is hovered or holds focus. Defaults to `true`. */
+    pauseOnInteraction?: boolean;
+    /** Enable horizontal swipe-to-dismiss via pointer gestures. Defaults to `true`. */
+    swipeToDismiss?: boolean;
+    /**
+     * Maximum visible toasts *per position*. When exceeded, the oldest toast in
+     * that position dismisses with reason `'max-exceeded'`. Defaults to `5`.
+     */
+    maxVisible?: number;
+    /** Explicit id. When omitted a unique id is generated. */
+    id?: string;
+    /** Accessible label applied to the toast element. When omitted, text content is used. */
+    ariaLabel?: string;
+    /** Accessible label applied to the per-position `role="region"` container. Defaults to `'Notifications'`. */
+    regionAriaLabel?: string;
+}
+/** Injection token providing `config.data` to projected component / template content. */
+declare const TW_TOAST_DATA: InjectionToken<unknown>;
+/** Injection token providing the owning {@link ToastRef} to projected component content. */
+declare const TW_TOAST_REF: InjectionToken<ToastRef<unknown, unknown>>;
+/** Injection token carrying application-wide toast defaults. Set via `provideToast(defaults)`. */
+declare const TW_TOAST_DEFAULT_OPTIONS: InjectionToken<Partial<ToastConfig<unknown, unknown>>>;
+/** Accepted content forms for `ToastService.show()`. */
+type ToastContent = string | TemplateRef<ToastTemplateContext> | Type<unknown>;
+
+interface PromiseMessages<T> {
+    loading: string;
+    success: string | ((value: T) => string);
+    error: string | ((err: unknown) => string);
+}
+/**
+ * Opens Tailwind-styled toasts / snackbars inside CDK overlays. One overlay is
+ * created per `ToastPosition` on first use and reused for the lifetime of the
+ * service; toasts stack vertically inside their position container.
+ *
+ * Not `providedIn: 'root'` — register via {@link provideToast}.
+ */
+declare class ToastService implements OnDestroy {
+    private readonly overlay;
+    private readonly injector;
+    private readonly defaultOptions;
+    private readonly parent;
+    private readonly positionOverlays;
+    private readonly activeRefsAtThisLevel;
+    private readonly afterOpenedSubject;
+    private readonly afterAllDismissedSubject;
+    /** Reactive list of every toast that has not yet fully dismissed. */
+    readonly activeToasts: Signal<readonly ToastRef[]>;
+    /** Emits every time a new toast is opened. */
+    readonly afterOpened: Observable<ToastRef>;
+    /** Emits when the active-toasts list transitions back to empty. Emits immediately on subscribe if none are open. */
+    readonly afterAllDismissed: Observable<void>;
+    /**
+     * Open a toast. Content may be a string (rendered inside the default
+     * `ToastComponent`), a `TemplateRef` (rendered via `TemplatePortal`), or a
+     * component class (rendered via `ComponentPortal` with `TW_TOAST_REF` +
+     * `TW_TOAST_DATA` injected).
+     */
+    show<R = void, D = unknown>(content: ToastContent, config?: ToastConfig<D, R>): ToastRef<unknown, R>;
+    /** Shorthand for `show(message, { severity: 'success', ... })`. */
+    success<R = void>(message: string, config?: ToastConfig<unknown, R>): ToastRef<unknown, R>;
+    /** Shorthand for `show(message, { severity: 'error', politeness: 'assertive', ... })`. */
+    error<R = void>(message: string, config?: ToastConfig<unknown, R>): ToastRef<unknown, R>;
+    /** Shorthand for `show(message, { severity: 'warning', ... })`. */
+    warning<R = void>(message: string, config?: ToastConfig<unknown, R>): ToastRef<unknown, R>;
+    /** Shorthand for `show(message, { severity: 'info', ... })`. */
+    info<R = void>(message: string, config?: ToastConfig<unknown, R>): ToastRef<unknown, R>;
+    /**
+     * Show a loading toast, then swap it to success / error when the promise
+     * settles. The same ref is returned and re-used across all three states.
+     * The loading toast is pinned (duration forced to 0, dismissible forced to
+     * false) until the promise resolves.
+     */
+    promise<T, R = void>(promise: Promise<T>, messages: PromiseMessages<T>, config?: ToastConfig<unknown, R>): ToastRef<unknown, R>;
+    /** Dismiss a toast by id. No-op if no matching toast is active. */
+    dismiss(id: string): void;
+    /** Dismiss every active toast across every position. */
+    dismissAll(): void;
+    /** Look up an active toast by id. */
+    getToastById<R = unknown>(id: string): ToastRef<unknown, R> | undefined;
+    ngOnDestroy(): void;
+    private openWithSeverity;
+    private openInternal;
+    private enforceMaxVisible;
+    private registerOpen;
+    private handleDismissed;
+    private attachToContainer;
+    private announceOpen;
+    private announceUpdate;
+    private getContainerForPosition;
+    private buildPositionStrategy;
+    private resolveConfig;
+    private getAfterAllDismissedSource;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ToastService>;
+}
+/**
+ * Registers {@link ToastService} for dependency injection and installs optional
+ * application-wide defaults.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideToast({ position: 'top-right', duration: 4000 })]
+ * });
+ * ```
+ */
+declare function provideToast(defaultOptions?: Partial<ToastConfig>): EnvironmentProviders;
+
+/** Slot directive for the icon. When projected, overrides the severity-default icon. */
+declare class ToastIconDirective {
+    private readonly toast;
+    /** @internal */
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastIconDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToastIconDirective, "[twToastIcon]", never, {}, {}, never, never, true, never>;
+}
+/** Slot directive for the bold title line inside a toast. */
+declare class ToastTitleDirective {
+    private readonly toast;
+    /** @internal */
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastTitleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToastTitleDirective, "[twToastTitle]", never, {}, {}, never, never, true, never>;
+}
+/** Slot directive for a secondary description line inside a toast. */
+declare class ToastDescriptionDirective {
+    private readonly toast;
+    /** @internal */
+    readonly classes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastDescriptionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToastDescriptionDirective, "[twToastDescription]", never, {}, {}, never, never, true, never>;
+}
+/** Slot directive for the action button. Apply to a native `<button>` to inherit the severity-aware styling. */
+declare class ToastActionDirective {
+    private readonly toast;
+    /** @internal */
+    readonly classes: _angular_core.Signal<string>;
+    /** @internal */
+    protected onClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastActionDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ToastActionDirective, "[twToastAction]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Visual toast / snackbar panel. Rendered internally by {@link ToastService} for
+ * string content, and exported for consumers who want to compose the same
+ * visual inside a custom `TemplateRef` or component class passed to `show()`.
+ */
+declare class ToastComponent {
+    /** Severity variant. Drives color palette, default icon, and ARIA role / live politeness. Defaults to `'info'`. */
+    readonly severity: _angular_core.InputSignal<ToastSeverity>;
+    /** Whether to render the close button. Defaults to `true`. */
+    readonly dismissible: _angular_core.InputSignal<boolean>;
+    /**
+     * Icon override. Pass a string to render as text inside the icon slot, or
+     * `false` to hide the built-in severity icon. Ignored when a `[twToastIcon]`
+     * child is projected. When omitted, the severity-default icon renders.
+     *
+     * For arbitrary icon markup, project a `[twToastIcon]` child instead.
+     */
+    readonly icon: _angular_core.InputSignal<string | false | undefined>;
+    /** Explicit aria-label for the toast wrapper. When omitted, text content is used by assistive tech. */
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Fires when the close button is clicked. */
+    readonly dismissed: _angular_core.OutputEmitterRef<void>;
+    /** Fires when a `[twToastAction]` button is clicked. */
+    readonly actionClicked: _angular_core.OutputEmitterRef<void>;
+    /** @internal */
+    readonly projectedIcon: _angular_core.Signal<ToastIconDirective | undefined>;
+    /** @internal */
+    readonly hasProjectedIcon: _angular_core.Signal<boolean>;
+    private readonly variantResult;
+    /** @internal */
+    readonly rootClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly iconClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly titleClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly descriptionClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly contentClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly actionClasses: _angular_core.Signal<string>;
+    /** @internal */
+    readonly dismissClasses: _angular_core.Signal<string>;
+    /** @internal */
+    protected readonly roleAttr: _angular_core.Signal<"alert" | "status">;
+    /** @internal */
+    protected readonly ariaLiveAttr: _angular_core.Signal<"polite" | "assertive">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "tw-toast", never, { "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "dismissed": "dismissed"; "actionClicked": "actionClicked"; }, ["projectedIcon"], ["[twToastIcon]", "[twToastTitle]", "[twToastDescription]", "*", "[twToastAction]"], true, never>;
+}
+
+export { TW_TOAST_DATA, TW_TOAST_DEFAULT_OPTIONS, TW_TOAST_REF, ToastActionDirective, ToastComponent, ToastConfig, ToastDescriptionDirective, ToastIconDirective, ToastRef, ToastService, ToastTitleDirective, provideToast };
+export type { ToastAction, ToastContent, ToastDismissReason, ToastDismissal, ToastPosition, ToastSeverity, ToastState, ToastTemplateContext, ToastUpdatePatch };

package/types/cdevhub-ngx-tw-tooltip.d.ts

@@ -0,0 +1,95 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { TwColor, TwSize } from '@cdevhub/ngx-tw/core';
+
+/** Placement position of the tooltip relative to its trigger element. */
+type TooltipPosition = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+declare class TooltipDirective {
+    /** The tooltip content. Strings render as text; TemplateRef renders via ngTemplateOutlet. */
+    readonly twTooltip: _angular_core.InputSignal<string | TemplateRef<void>>;
+    /** Preferred placement relative to the trigger. CDK handles fallback. Defaults to `'top'`. */
+    readonly twTooltipPosition: _angular_core.InputSignal<TooltipPosition>;
+    /** Semantic color palette for the tooltip. Defaults to `'neutral'`. */
+    readonly twTooltipColor: _angular_core.InputSignal<TwColor>;
+    /** Controls padding, font size, and maximum width. Defaults to `'md'`. */
+    readonly twTooltipSize: _angular_core.InputSignal<TwSize>;
+    /**
+     * Milliseconds to wait before showing after trigger. Defaults to `200` — an
+     * intent threshold: the trigger must be held long enough that the user reads
+     * as "wants the tooltip" rather than a passing graze with the pointer.
+     */
+    readonly twTooltipShowDelay: _angular_core.InputSignal<number>;
+    /**
+     * Milliseconds to wait before hiding after trigger ends. Defaults to `0`
+     * (immediate dismiss). The asymmetry with `twTooltipShowDelay` is
+     * intentional — show is gated to filter noise, hide is instant so the
+     * tooltip never lingers over content the user has moved on from.
+     */
+    readonly twTooltipHideDelay: _angular_core.InputSignal<number>;
+    /** When true, tooltip never shows. Defaults to `false`. */
+    readonly twTooltipDisabled: _angular_core.InputSignal<boolean>;
+    /** When true, renders an arrow pointing to the trigger. Defaults to `true`. */
+    readonly twTooltipArrow: _angular_core.InputSignal<boolean>;
+    /** Optional class string (space-separated) merged into the panel slot for consumer customization. */
+    readonly twTooltipPanelClass: _angular_core.InputSignal<string>;
+    /** Fires when the tooltip becomes visible. */
+    readonly twTooltipShown: _angular_core.OutputEmitterRef<void>;
+    /** Fires when the tooltip is fully hidden. */
+    readonly twTooltipHidden: _angular_core.OutputEmitterRef<void>;
+    private readonly overlay;
+    private readonly elementRef;
+    private readonly destroyRef;
+    private readonly ariaDescriber;
+    private overlayRef;
+    private tooltipInstance;
+    private showTimer;
+    private hideTimer;
+    /** Last description string handed to `AriaDescriber.describe` — required so the symmetrical `removeDescription` call passes the same key. */
+    private _describedBy;
+    /** True when the trigger's `aria-describedby` was set directly to the overlay id (TemplateRef fallback path); used by `removeAriaDescription` to choose the symmetrical teardown. */
+    private _templateDescribedBy;
+    constructor();
+    /** Programmatically show the tooltip. */
+    show(): void;
+    /** Programmatically hide the tooltip. */
+    hide(): void;
+    /** Toggle tooltip visibility. */
+    toggle(): void;
+    protected onMouseEnter(): void;
+    protected onMouseLeave(): void;
+    protected onFocusIn(): void;
+    protected onFocusOut(): void;
+    protected onEscape(): void;
+    protected onTouchStart(): void;
+    protected onTouchEnd(): void;
+    private createAndShow;
+    private createOverlay;
+    private updateTooltip;
+    private detach;
+    /**
+     * Push the current tooltip content as an `aria-describedby` link on the
+     * trigger element. Dual-mode wiring:
+     *
+     * - **String content**: routed through CDK `AriaDescriber.describe`, which
+     *   maintains a single hidden message-container on the document and dedupes
+     *   identical strings across all describers.
+     * - **TemplateRef content**: AriaDescriber's dedup table is keyed by string,
+     *   so we fall back to a direct `setAttribute('aria-describedby', overlayId)`
+     *   pointing at the `role="tooltip"` overlay. Without this fallback,
+     *   assistive tech would have no description link for templated tooltip
+     *   content.
+     *
+     * `_describedBy` tracks the string handed to `AriaDescriber`;
+     * `_templateDescribedBy` is `true` when the fallback path is active so
+     * `removeAriaDescription` can take the symmetrical teardown branch.
+     */
+    private applyAriaDescription;
+    private removeAriaDescription;
+    private disposeOverlay;
+    private clearTimers;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[twTooltip]", ["twTooltip"], { "twTooltip": { "alias": "twTooltip"; "required": true; "isSignal": true; }; "twTooltipPosition": { "alias": "twTooltipPosition"; "required": false; "isSignal": true; }; "twTooltipColor": { "alias": "twTooltipColor"; "required": false; "isSignal": true; }; "twTooltipSize": { "alias": "twTooltipSize"; "required": false; "isSignal": true; }; "twTooltipShowDelay": { "alias": "twTooltipShowDelay"; "required": false; "isSignal": true; }; "twTooltipHideDelay": { "alias": "twTooltipHideDelay"; "required": false; "isSignal": true; }; "twTooltipDisabled": { "alias": "twTooltipDisabled"; "required": false; "isSignal": true; }; "twTooltipArrow": { "alias": "twTooltipArrow"; "required": false; "isSignal": true; }; "twTooltipPanelClass": { "alias": "twTooltipPanelClass"; "required": false; "isSignal": true; }; }, { "twTooltipShown": "twTooltipShown"; "twTooltipHidden": "twTooltipHidden"; }, never, never, true, never>;
+}
+
+export { TooltipDirective };
+export type { TooltipPosition };

package/types/cdevhub-ngx-tw.d.ts

@@ -0,0 +1,49 @@
+export * from '@cdevhub/ngx-tw/core';
+export * from '@cdevhub/ngx-tw/badge';
+export * from '@cdevhub/ngx-tw/button';
+export * from '@cdevhub/ngx-tw/card';
+export * from '@cdevhub/ngx-tw/flip-card';
+export * from '@cdevhub/ngx-tw/alert';
+export * from '@cdevhub/ngx-tw/tabs';
+export * from '@cdevhub/ngx-tw/tab-nav';
+export * from '@cdevhub/ngx-tw/separator';
+export * from '@cdevhub/ngx-tw/tooltip';
+export * from '@cdevhub/ngx-tw/code-block';
+export * from '@cdevhub/ngx-tw/segmented-control';
+export * from '@cdevhub/ngx-tw/avatar';
+export * from '@cdevhub/ngx-tw/menu';
+export * from '@cdevhub/ngx-tw/icon';
+export * from '@cdevhub/ngx-tw/collapsible';
+export * from '@cdevhub/ngx-tw/accordion';
+export * from '@cdevhub/ngx-tw/popover';
+export * from '@cdevhub/ngx-tw/dialog';
+export * from '@cdevhub/ngx-tw/command-palette';
+export * from '@cdevhub/ngx-tw/toast';
+export * from '@cdevhub/ngx-tw/form-field';
+export * from '@cdevhub/ngx-tw/switch';
+export * from '@cdevhub/ngx-tw/checkbox';
+export * from '@cdevhub/ngx-tw/radio';
+export * from '@cdevhub/ngx-tw/select';
+export * from '@cdevhub/ngx-tw/input';
+export * from '@cdevhub/ngx-tw/textarea';
+export * from '@cdevhub/ngx-tw/spinner';
+export * from '@cdevhub/ngx-tw/progress-bar';
+export * from '@cdevhub/ngx-tw/skeleton';
+export * from '@cdevhub/ngx-tw/calendar';
+export * from '@cdevhub/ngx-tw/date-picker';
+export * from '@cdevhub/ngx-tw/date-range-picker';
+export * from '@cdevhub/ngx-tw/time-picker';
+export * from '@cdevhub/ngx-tw/slider';
+export * from '@cdevhub/ngx-tw/stepper';
+export * from '@cdevhub/ngx-tw/paginator';
+export * from '@cdevhub/ngx-tw/sort';
+export * from '@cdevhub/ngx-tw/split';
+export * from '@cdevhub/ngx-tw/table';
+export * from '@cdevhub/ngx-tw/item';
+export * from '@cdevhub/ngx-tw/breadcrumbs';
+export * from '@cdevhub/ngx-tw/timeline';
+export * from '@cdevhub/ngx-tw/carousel';
+export * from '@cdevhub/ngx-tw/stat';
+export * from '@cdevhub/ngx-tw/combobox';
+export * from '@cdevhub/ngx-tw/empty-state';
+export * from '@cdevhub/ngx-tw/sheet';