@nubisco/ui 3.1.0 → 3.3.0

package/dist/composables/useToast.composable.d.ts

@@ -0,0 +1,325 @@
+import { type ComputedRef, type InjectionKey, type Ref } from 'vue';
+import type { TToastVariant, IToastCta } from '../components/Toast.vue';
+/**
+ * The toast queue: the clock, the cap and the ordering that `NbToaster`
+ * renders.
+ *
+ * The split matters. `NbToast` knows how one message looks, `NbToaster` knows
+ * where the stack sits and how it moves, and this file knows *when* a message
+ * leaves. Timing lives here rather than in the item because the whole region
+ * pauses together: while the pointer rests on the top toast, the two below it
+ * must stop counting down as well, and an item that owns its own timer cannot
+ * know that. Three applications hand-rolled a host over `NbToast` and all
+ * three got a different part of this wrong, which is why it is now library
+ * code.
+ */
+/**
+ * Why a toast ended. Passed to `IToastOptions.onDismiss`.
+ *
+ * - `user`: the close button, or Escape while the toast held focus.
+ * - `timeout`: the countdown ran out.
+ * - `action`: the reader pressed the toast's own action.
+ * - `replaced`: a newer message took its place, either because a `key` push
+ *   claimed its slot or because the stack was full of toasts that can never
+ *   expire.
+ * - `navigated`: `dismissTransient()`, from a router guard.
+ * - `cleared`: `dismissAll()`, typically sign-out.
+ *
+ * The reason is the only thing that separates "Deleted. [Undo]" committing
+ * from cancelling, so it is never collapsed into a boolean.
+ */
+export type TToastDismissReason = 'user' | 'timeout' | 'action' | 'replaced' | 'navigated' | 'cleared';
+/** Everything a caller can say about a toast. Only `message` is required. */
+export interface IToastOptions {
+    /** The news, in one sentence. Written in the past tense: "Draft saved". */
+    message: string;
+    /** Tone. Also decides the icon, the politeness and the default duration. */
+    variant?: TToastVariant;
+    /** Optional short heading. Skip it when the message already stands alone. */
+    title?: string;
+    /**
+     * Milliseconds on screen. `0` means it stays until dismissed. Omit it and
+     * the variant decides (see `NB_TOAST_DURATIONS`).
+     */
+    duration?: number;
+    /**
+     * One action. A toast that carries one never auto-dismisses unless an
+     * explicit `duration` says it should: an action that removes itself while
+     * it is being reached for is not an action.
+     */
+    cta?: IToastCta;
+    /**
+     * De-duplication key. Pushing again with a key that is already queued takes
+     * over that toast's slot instead of adding a second one, so a double-clicked
+     * Save button produces one "Saved", not two.
+     *
+     * The second push replaces the message wholesale: only the id, the slot and
+     * the position survive, and every field the new call leaves out goes back to
+     * its default rather than lingering from the previous one. A first push with
+     * a `title` and an `error` variant followed by a bare
+     * `push({ key, message })` is a plain info toast, not the old error wearing
+     * a new sentence. The displaced message's `onDismiss` fires with reason
+     * `replaced` before the new one takes the slot.
+     */
+    key?: string;
+    /**
+     * Survive a route change.
+     *
+     * A toast is scoped to the moment, and the moment usually ends with the
+     * route: "Draft saved" outliving the draft's page is news about a screen
+     * the user has left, and its `Undo` acts on a record they can no longer
+     * see. `dismissTransient()`, called from a router guard, clears everything
+     * that does not set this.
+     *
+     * Set it for news that is true wherever the user ends up: "Signed out",
+     * "Export ready", "Connection restored".
+     */
+    retain?: boolean;
+    /**
+     * Called once, when the toast leaves the queue, with the reason it left.
+     *
+     * This is the observation point the CTA pattern needs. "Deleted. [Undo]"
+     * only works if something commits the delete when the toast goes and
+     * cancels it when Undo is pressed, and the difference between those two is
+     * exactly the reason:
+     *
+     * ```ts
+     * let undone = false
+     * toast.push({
+     *   message: 'Comment deleted',
+     *   cta: { label: 'Undo', action: () => { undone = true; restore(row) } },
+     *   onDismiss: (reason) => { if (!undone) commitDelete(row) },
+     * })
+     * ```
+     *
+     * It fires exactly once per pushed message, and the reason is always the
+     * true one. Two rules keep that promise:
+     *
+     * - `update()` is not an end of life, so a progress toast that becomes a
+     *   result calls it once, at the end. `update()` therefore cannot change
+     *   the callback either: it is not in `TToastPatch`.
+     * - A second `push()` sharing a `key` is a *different* message taking over
+     *   the slot, so the message being displaced ends first, with reason
+     *   `replaced`, and the new callback takes over from there. Deleting row 1
+     *   and then row 2 under one key commits row 1 and then row 2, in that
+     *   order, rather than committing row 1 twice.
+     */
+    onDismiss?: (reason: TToastDismissReason) => void;
+}
+/**
+ * A partial change to a live toast, as accepted by `IToastHandle.update()`.
+ *
+ * `onDismiss` is deliberately not in it. The callback is the commit point of
+ * the message that was pushed, and an update only rewrites the words of that
+ * same message: swapping the callback halfway would either drop a commit or
+ * run it twice, which is the one thing this queue promises never to do. When
+ * the *message* really is a new one, push it (with a `key` if it should reuse
+ * the slot) and the queue ends the old one first, with reason `replaced`.
+ *
+ * Passing it anyway is ignored, and warns outside production.
+ */
+export type TToastPatch = Omit<Partial<IToastOptions>, 'onDismiss'>;
+/** A queued toast, as `NbToaster` reads it. */
+export interface IToastRecord extends IToastOptions {
+    /** Queue-unique id. Stable for the life of the toast. */
+    id: string;
+    variant: TToastVariant;
+    /** Resolved duration: never undefined here, `0` means persistent. */
+    duration: number;
+    /** `true` once it holds one of the visible slots. */
+    visible: boolean;
+    /**
+     * Incremented every time the countdown restarts (admission, or an update
+     * that changed the message). `NbToaster` keys the timer bar on it so the
+     * bar restarts with the clock instead of continuing from where it was.
+     */
+    cycle: number;
+}
+/**
+ * What `push()` hands back so the caller can keep talking about a toast it
+ * created: the save-in-progress that becomes a save-succeeded.
+ */
+export interface IToastHandle {
+    /** The record id, for `queue.dismiss(id)` or logging. */
+    readonly id: string;
+    /**
+     * Rewrite the toast in place. It keeps its slot and its position, so the
+     * stack does not jump. The countdown restarts, because the words changed
+     * and the reader has not seen the new ones yet.
+     *
+     * Passing a `variant` without a `duration` adopts that variant's default,
+     * which is what turns a persistent "Saving..." into a self-clearing
+     * "Saved". Fields left out of the patch are left alone.
+     *
+     * `onDismiss` is not patchable: see `TToastPatch`.
+     */
+    update(patch: TToastPatch): void;
+    /**
+     * Remove it now. Safe to call after it has already gone. The reason is
+     * forwarded to `onDismiss`; it defaults to `user` because the usual caller
+     * is a control the reader pressed.
+     */
+    dismiss(reason?: TToastDismissReason): void;
+    /** `false` once it has been dismissed or has expired. */
+    isActive(): boolean;
+}
+/** Options for a standalone queue. */
+export interface IToastQueueOptions {
+    /** How many toasts may be on screen at once. Default `3`. */
+    max?: number;
+    /** Per-variant duration overrides, merged over `NB_TOAST_DURATIONS`. */
+    durations?: Partial<Record<TToastVariant, number>>;
+    /**
+     * The visually hidden severity word each variant is announced with, for
+     * applications that are not in English. Merged over `NB_TOAST_STATUS_LABELS`.
+     * An empty string suppresses the word for that variant.
+     */
+    statusLabels?: Partial<Record<TToastVariant, string>>;
+    /** Accessible name of every close button in this queue. */
+    closeLabel?: string;
+}
+/** The strings `NbToaster` reads out of its queue. */
+export interface IToastLabels {
+    status: Record<TToastVariant, string>;
+    close: string;
+}
+/** The queue object shared by `useToast()` and `NbToaster`. */
+export interface IToastQueue {
+    /** Everything queued: the visible slots first, then whatever is waiting. */
+    readonly items: ComputedRef<IToastRecord[]>;
+    /** The records `NbToaster` renders, oldest first. */
+    readonly visible: ComputedRef<IToastRecord[]>;
+    /** Records admitted but waiting for a free slot. */
+    readonly pending: ComputedRef<IToastRecord[]>;
+    /** `true` while the clock is held (pointer, focus, or a hidden tab). */
+    readonly paused: Ref<boolean>;
+    /** Visible-slot cap. Writable, so a host can widen it for one screen. */
+    readonly max: Ref<number>;
+    /**
+     * Translated strings for this queue. `NbToaster` passes them to every
+     * toast, so a Spanish product states them once instead of per call.
+     */
+    readonly labels: IToastLabels;
+    /** Queue a toast. Returns the handle. */
+    push(options: IToastOptions): IToastHandle;
+    /** `variant: 'info'`, message-first for the common call. */
+    info(message: string, options?: Omit<IToastOptions, 'message' | 'variant'>): IToastHandle;
+    /** `variant: 'success'`. */
+    success(message: string, options?: Omit<IToastOptions, 'message' | 'variant'>): IToastHandle;
+    /** `variant: 'warning'`. */
+    warning(message: string, options?: Omit<IToastOptions, 'message' | 'variant'>): IToastHandle;
+    /** `variant: 'error'`. Persistent by default. */
+    error(message: string, options?: Omit<IToastOptions, 'message' | 'variant'>): IToastHandle;
+    /** Rewrite a live toast by id, field by field. No-op if it has gone. */
+    update(id: string, patch: TToastPatch): void;
+    /** Remove one toast and let the next pending one in. */
+    dismiss(id: string, reason?: TToastDismissReason): void;
+    /**
+     * Clear the whole queue, visible and pending, `retain` included. Sign-out,
+     * tenant switch, anything after which no queued message is still true.
+     */
+    dismissAll(reason?: TToastDismissReason): void;
+    /**
+     * Clear everything that did not ask to survive a route change. Call it from
+     * a router guard:
+     *
+     * ```ts
+     * router.afterEach(() => toast.dismissTransient())
+     * ```
+     *
+     * Nothing in this file knows about a router, and it must not: the library
+     * has no dependency on one and cannot guess whether a product's tab switch
+     * is a navigation. The queue provides the operation, the application says
+     * when.
+     */
+    dismissTransient(reason?: TToastDismissReason): void;
+    /** Hold every countdown. Idempotent. */
+    pause(): void;
+    /** Resume from the exact remaining time, not from the start. */
+    resume(): void;
+    /** Remaining milliseconds for a record, for tests and instrumentation. */
+    remaining(id: string): number;
+}
+/**
+ * Default time on screen, per variant.
+ *
+ * The scale is reading time, not importance: a success is four words the user
+ * expected, a warning is a sentence they did not. An error stays until it is
+ * dismissed, because "it failed" is the start of a task and a message that
+ * removes itself before the user can act on it is worse than no message.
+ */
+export declare const NB_TOAST_DURATIONS: Record<TToastVariant, number>;
+/**
+ * The word a screen reader hears before the message, per variant.
+ *
+ * Severity is otherwise carried by an icon (aria-hidden) and an accent colour,
+ * which is exactly the WCAG 1.4.1 failure: "Could not reach the server" with
+ * no indication that it is an error. Override the map per queue rather than
+ * per toast when the product is not in English.
+ */
+export declare const NB_TOAST_STATUS_LABELS: Record<TToastVariant, string>;
+/**
+ * Build an isolated queue. Applications use `useToast()`, which shares one
+ * queue per page; tests and stories want their own so one spec cannot leave a
+ * toast behind for the next.
+ */
+export declare function createToastQueue(options?: IToastQueueOptions): IToastQueue;
+/**
+ * Injection key for a queue scoped to one application instance.
+ *
+ * ```ts
+ * app.provide(NB_TOAST_QUEUE_KEY, createToastQueue())
+ * ```
+ *
+ * `useToast()` prefers it whenever it is called from a component, and
+ * `NbToaster` renders it without being given a `:queue`. Two reasons to use
+ * it: server rendering, where a module-level singleton is shared by every
+ * request the Node process is handling concurrently, and a host application
+ * that mounts several Vue apps in one page and does not want one app's toasts
+ * announced by another's toaster.
+ *
+ * It cannot be reached from a plain module (a service, a router guard, a
+ * store action) because there is no component instance there, which is why the
+ * shared queue below stays the default rather than being replaced by this.
+ */
+export declare const NB_TOAST_QUEUE_KEY: InjectionKey<IToastQueue>;
+/**
+ * The toast queue for the current context.
+ *
+ * Inside a component, an app-scoped queue provided under
+ * `NB_TOAST_QUEUE_KEY` wins. Everywhere else, and when nothing was provided,
+ * this is one shared queue per page, created on first use, so a service
+ * module, a route guard and a deeply nested component all reach the same
+ * stack without prop drilling or a plugin install. Mount a single
+ * `<NbToaster />` to render it.
+ *
+ * @example
+ * const toast = useToast()
+ * toast.success('Draft saved')
+ *
+ * @example Progress that resolves into its own result
+ * const saving = toast.info('Saving changes...', { duration: 0 })
+ * try {
+ *   await save()
+ *   saving.update({ variant: 'success', message: 'Changes saved' })
+ * } catch {
+ *   saving.update({ variant: 'error', message: 'Could not save changes' })
+ * }
+ */
+export declare function useToast(): IToastQueue;
+/**
+ * Drop the shared queue, clearing whatever was in it.
+ *
+ * For tests, so one spec cannot leave a toast behind for the next, and for a
+ * single-render script (a static build, a prerender pass) that wants the
+ * module back in its initial state.
+ *
+ * It is not request isolation. A module-level singleton is shared by every
+ * request a Node process is serving at once, and resetting it globally
+ * between awaits would empty a queue another request is still filling. Server
+ * rendering with concurrent requests wants a queue per application instance:
+ * `app.provide(NB_TOAST_QUEUE_KEY, createToastQueue())`, which is scoped to
+ * the app that `createSSRApp()` returned and dies with it.
+ */
+export declare function resetToastQueue(): void;
+//# sourceMappingURL=useToast.composable.d.ts.map

package/dist/composables/useToast.composable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useToast.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useToast.composable.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,GAAG,EACT,MAAM,KAAK,CAAA;AACZ,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAEvE;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,GAC3B,MAAM,GACN,SAAS,GACT,QAAQ,GACR,UAAU,GACV,WAAW,GACX,SAAS,CAAA;AAEb,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC5B,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAA;IACf,4EAA4E;IAC5E,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,GAAG,CAAC,EAAE,SAAS,CAAA;IACf;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAA;CAClD;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE,WAAW,CAAC,CAAA;AAEnE,+CAA+C;AAC/C,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,yDAAyD;IACzD,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,aAAa,CAAA;IACtB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAA;IAChB,qDAAqD;IACrD,OAAO,EAAE,OAAO,CAAA;IAChB;;;;OAIG;IACH,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;IAChC;;;;OAIG;IACH,OAAO,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC3C,yDAAyD;IACzD,QAAQ,IAAI,OAAO,CAAA;CACpB;AAED,sCAAsC;AACtC,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,wEAAwE;IACxE,SAAS,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC,CAAA;IACrD,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC,CAAA;IACrC,KAAK,EAAE,MAAM,CAAA;CACd;AAED,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,YAAY,EAAE,CAAC,CAAA;IAC3C,qDAAqD;IACrD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,CAAC,CAAA;IAC7C,oDAAoD;IACpD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC,YAAY,EAAE,CAAC,CAAA;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;IAC7B,yEAAyE;IACzE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAA;IAC7B,yCAAyC;IACzC,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,YAAY,CAAA;IAC1C,4DAA4D;IAC5D,IAAI,CACF,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC,GACnD,YAAY,CAAA;IACf,4BAA4B;IAC5B,OAAO,CACL,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC,GACnD,YAAY,CAAA;IACf,4BAA4B;IAC5B,OAAO,CACL,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC,GACnD,YAAY,CAAA;IACf,iDAAiD;IACjD,KAAK,CACH,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC,GACnD,YAAY,CAAA;IACf,wEAAwE;IACxE,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;IAC5C,wDAAwD;IACxD,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACvD;;;OAGG;IACH,UAAU,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IAC9C;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,MAAM,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAA;IACpD,wCAAwC;IACxC,KAAK,IAAI,IAAI,CAAA;IACb,gEAAgE;IAChE,MAAM,IAAI,IAAI,CAAA;IACd,0EAA0E;IAC1E,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAA;CAC9B;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAK5D,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAKhE,CAAA;AAUD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,kBAAuB,GAC/B,WAAW,CAsSb;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,WAAW,CAC/B,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,IAAI,WAAW,CAStC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,SAG9B"}

package/dist/directives/ToolTip.content.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tooltip content rendering, and nothing else.
+ *
+ * Split out of `ToolTip.directive.ts` because it answers a different question
+ * from the rest of it. Everything in that file is about WHEN a chip exists
+ * and WHERE it sits; everything here is about what is allowed inside one when
+ * the text did not come from the person writing the template. The two change
+ * for unrelated reasons: a new allowed tag is a security review, a new
+ * placement rule is a layout bug.
+ *
+ * Private to the directive. Nothing here is part of the public API.
+ */
+import type { IComponentContent } from '../types/ContentRenderer';
+declare const devWarn: (key: string, message: string) => void;
+/**
+ * Renders tooltip content - supports both string and complex content structure
+ */
+declare const renderTooltipContent: (content: string | Array<IComponentContent> | undefined | null) => string;
+export { renderTooltipContent, devWarn };
+//# sourceMappingURL=ToolTip.content.d.ts.map

package/dist/directives/ToolTip.content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolTip.content.d.ts","sourceRoot":"","sources":["../../src/directives/ToolTip.content.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAwPhE,QAAA,MAAM,OAAO,GAAI,KAAK,MAAM,EAAE,SAAS,MAAM,SAM5C,CAAA;AA2DD;;GAEG;AACH,QAAA,MAAM,oBAAoB,GACxB,SAAS,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,SAAS,GAAG,IAAI,KAC5D,MAYF,CAAA;AAED,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,CAAA"}

package/dist/directives/ToolTip.directive.d.ts

@@ -1,17 +1,96 @@
-import type { App } from 'vue';
+import type { App, ObjectDirective } from 'vue';
 import type { IComponentContent } from '../types/ContentRenderer';
 export interface ITooltipOptions {
-    body?: string | Array<IComponentContent>;
-    header?: string | Array<IComponentContent>;
-    tip?: string | Array<IComponentContent>;
-    flavor?: string;
+    /** The three content slots accept `null` as well as `undefined`, because an
+     *  application binding a value straight from its state (`projectPath`, a
+     *  fetched description, an optional field) usually has `string | null` and
+     *  the runtime has always treated any falsy value as "no tooltip" via
+     *  `hasContent`. Rejecting `null` in the type while accepting it at runtime
+     *  only forced `?? undefined` at every call site. Found by type-checking
+     *  `v-nb-tooltip` in a real consumer for the first time. */
+    body?: string | Array<IComponentContent> | null;
+    header?: string | Array<IComponentContent> | null;
+    tip?: string | Array<IComponentContent> | null;
+    /** The chip's tone, from the same vocabulary the rest of the library uses
+     *  (`NbBanner.status`, `EVariant`). `default` is the inverted chip and is
+     *  what a labelling tooltip should stay on: a coloured chip on a plain icon
+     *  button reads as a state the control does not have. Reach for `danger` or
+     *  `warning` only when the tooltip is explaining a blocked or destructive
+     *  action, which is the case the fleet actually has. */
+    status?: TTooltipStatus;
+    /** @deprecated Use `status`. Kept because it is the name every existing
+     *  binding uses and removing it would break them silently. `status` wins
+     *  when both are given. Typed now, where it used to be `string`: the four
+     *  values that were only ever documented are now the four the compiler
+     *  accepts, plus `success` and `warning`, which the library's own status
+     *  vocabulary has and this directive was missing. */
+    flavor?: TTooltipStatus;
     delay?: number;
+    /** Milliseconds the chip stays up after the pointer or focus leaves.
+     *  Defaults to 150. Raise it when the anchor sits next to a target the
+     *  user must cross to reach, lower it for dense toolbars. */
+    hideDelay?: number;
+    /** How the tooltip is wired to assistive technology.
+     *  - `label`: the tooltip IS the anchor's accessible name (icon-only
+     *    controls). Applied as a permanent `aria-label`, because a name that
+     *    only exists while a chip is on screen is not a name.
+     *  - `description`: the tooltip adds to an anchor that is already named.
+     *    Applied as `aria-describedby` on the visible chip only.
+     *  - `none`: no aria wiring at all. For decorative or duplicated text.
+     *  - `auto` (default): `label` when the anchor has no accessible name,
+     *    `description` when it does. */
+    aria?: TTooltipAria;
+    /** Add `tabindex="0"` to an anchor that cannot otherwise take focus, so
+     *  keyboard users can reach the tooltip. Only for anchors that carry
+     *  information nothing else conveys (a truncated cell, a status dot).
+     *  Never needed on a button or a link. */
+    focusable?: boolean;
+    /** Open on touch (tap) as well as hover and focus. Default true. */
+    touch?: boolean;
     animationTime?: number;
     position?: 'top' | 'bottom' | 'left' | 'right' | 'cursor';
     followCursor?: boolean;
     overflowOnly?: boolean;
+    /** Extra classes for the CHIP (not for the anchor, which keeps its own
+     *  `class` attribute untouched). Use it for a one-off width or a product
+     *  skin; the supported knobs are the three custom properties in the docs. */
+    chipClass?: string;
+    /** @deprecated Use `chipClass`, which says which element it lands on.
+     *  `classExtra` is a name nothing else in this library uses. */
     classExtra?: string;
+    /** Controlled visibility. When this is a boolean, the chip is on screen if
+     *  and only if it is `true`, and hover / focus / tap stop opening and
+     *  closing it themselves: they report what the user did through
+     *  `onOpenChange` and leave the decision to you. This is what an onboarding
+     *  highlight, a "show me" button and a visual-regression snapshot of the
+     *  open state need, and there was previously no way to get any of them
+     *  without synthesising MouseEvents. Leave it `undefined` for the ordinary
+     *  uncontrolled tooltip. */
+    open?: boolean;
+    /** Open once, on mount, and behave normally afterwards. Uncontrolled: the
+     *  first hover-out closes it for good. For a hint that should be seen once
+     *  without taking the tooltip away from the user. */
+    defaultOpen?: boolean;
+    /** Called on every transition, with what caused it. In controlled mode this
+     *  is the only way the user's pointer and keyboard reach you. */
+    onOpenChange?: (open: boolean, reason: TTooltipReason) => void;
 }
+export type TTooltipAria = 'auto' | 'label' | 'description' | 'none';
+/** What opened a chip. `program` is a controlled or `defaultOpen` show, which
+ *  never waits out the hover-intent delay. */
+export type TTooltipTrigger = 'pointer' | 'focus' | 'touch' | 'program';
+/** What caused a transition reported through `onOpenChange`.
+ *  - `dismiss`: the user got rid of it. Escape, a pointerdown outside, the
+ *    window losing focus, a drag starting, the anchor scrolling out of sight.
+ *  - `superseded`: another anchor opened a chip, and only one chip is ever on
+ *    screen. Nothing the user did was a dismissal OF THIS tooltip, which is
+ *    why it is not called one: a host that treats every `false` as "the user
+ *    is done with this hint" would otherwise cancel an onboarding highlight
+ *    the moment the pointer crossed an unrelated icon button. */
+export type TTooltipReason = TTooltipTrigger | 'dismiss' | 'superseded';
+/** The chip's tone. Same words as `NbBanner.status` and `EVariant`, minus the
+ *  ones a 55-character chip has no use for. */
+export type TTooltipStatus = 'default' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
 declare const tooltipDirective: (app: App) => void;
 /** Dismiss every currently-visible tooltip. Useful for view switches
  *  in single-page apps where the trigger element gets unmounted by a
@@ -19,9 +98,16 @@ declare const tooltipDirective: (app: App) => void;
  *  tooltip element about to be appended) leaves orphan chips behind.
  *  Call from the host on route / view change.
  *
- *  Exposed via `useTooltip()` (composable) and `Tooltip.dismissAll`
- *  (named export) so consumers don't need to dig through registered
- *  state directly. */
+ *  Exported by name from the library entry, alongside the directive
+ *  installer, so consumers do not have to reach into registered state. */
 export declare function dismissAllTooltips(): void;
+export type TTooltipDirective = ObjectDirective<HTMLElement, ITooltipOptions>;
+declare module 'vue' {
+    interface GlobalDirectives {
+        /** Attach a tooltip to any element. See `ITooltipOptions` for the
+         *  binding value: at minimum one of `header`, `body` or `tip`. */
+        vNbTooltip: TTooltipDirective;
+    }
+}
 export default tooltipDirective;
 //# sourceMappingURL=ToolTip.directive.d.ts.map

package/dist/directives/ToolTip.directive.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ToolTip.directive.d.ts","sourceRoot":"","sources":["../../src/directives/ToolTip.directive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAoB,MAAM,KAAK,CAAA;AAEhD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAgChE,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAA;IACxC,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAA;IAC1C,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,CAAA;IACvC,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;IACzD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAuKD,QAAA,MAAM,gBAAgB,GAAI,KAAK,GAAG,SAkGjC,CAAA;AAkTD;;;;;;;;sBAQsB;AACtB,wBAAgB,kBAAkB,SASjC;AAED,eAAe,gBAAgB,CAAA"}
+{"version":3,"file":"ToolTip.directive.d.ts","sourceRoot":"","sources":["../../src/directives/ToolTip.directive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAoB,eAAe,EAAE,MAAM,KAAK,CAAA;AAEjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAuGhE,MAAM,WAAW,eAAe;IAC9B;;;;;;gEAM4D;IAC5D,IAAI,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAA;IAC/C,MAAM,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAA;IACjD,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,IAAI,CAAA;IAC9C;;;;;4DAKwD;IACxD,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB;;;;;yDAKqD;IACrD,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;iEAE6D;IAC7D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;;;;;;wCAQoC;IACpC,IAAI,CAAC,EAAE,YAAY,CAAA;IACnB;;;8CAG0C;IAC1C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAA;IACzD,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB;;iFAE6E;IAC7E,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;oEACgE;IAChE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;;;;gCAO4B;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAA;IACd;;yDAEqD;IACrD,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB;qEACiE;IACjE,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,cAAc,KAAK,IAAI,CAAA;CAC/D;AAED,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,GAAG,aAAa,GAAG,MAAM,CAAA;AACpE;8CAC8C;AAC9C,MAAM,MAAM,eAAe,GAAG,SAAS,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAA;AACvE;;;;;;;iEAOiE;AACjE,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,SAAS,GAAG,YAAY,CAAA;AACvE;+CAC+C;AAC/C,MAAM,MAAM,cAAc,GACtB,SAAS,GACT,SAAS,GACT,MAAM,GACN,SAAS,GACT,SAAS,GACT,QAAQ,CAAA;AA83BZ,QAAA,MAAM,gBAAgB,GAAI,KAAK,GAAG,SAyQjC,CAAA;AAsgBD;;;;;;;0EAO0E;AAC1E,wBAAgB,kBAAkB,SAmBjC;AAeD,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,WAAW,EAAE,eAAe,CAAC,CAAA;AAE7E,OAAO,QAAQ,KAAK,CAAC;IAInB,UAAU,gBAAgB;QACxB;0EACkE;QAClE,UAAU,EAAE,iBAAiB,CAAA;KAC9B;CACF;AAED,eAAe,gBAAgB,CAAA"}

package/dist/global.d.ts

@@ -24,6 +24,7 @@ import Checkbox from './components/Checkbox.vue'
 import CheckboxGroup from './components/CheckboxGroup.vue'
 import ColorStrip from './components/ColorStrip.vue'
 import CommandPalette from './components/CommandPalette.vue'
+import Confirm from './components/Confirm.vue'
 import DataTable from './components/DataTable.vue'
 import DatePicker from './components/DatePicker.vue'
 import DefinitionList from './components/DefinitionList.vue'
@@ -38,6 +39,7 @@ import Grid from './components/Grid.vue'
 import Icon from './components/Icon.vue'
 import ImageCropper from './components/ImageCropper.vue'
 import InfoHint from './components/InfoHint.vue'
+import InlineLoading from './components/InlineLoading.vue'
 import InterpolationChart from './components/Charts/InterpolationChart.vue'
 import JsonTree from './components/JsonTree.vue'
 import Label from './components/Label.vue'
@@ -50,6 +52,8 @@ import MenuDivider from './components/MenuDivider.vue'
 import MenuItem from './components/MenuItem.vue'
 import Message from './components/Message.vue'
 import Modal from './components/Modal.vue'
+import NotificationCenter from './components/NotificationCenter.vue'
+import NotificationCenterItem from './components/NotificationCenterItem.vue'
 import NubiscoMark from './components/NubiscoMark.vue'
 import NubiscoPlatformMark from './components/NubiscoPlatformMark.vue'
 import NumberInput from './components/NumberInput.vue'
@@ -68,14 +72,19 @@ import SidebarMenu from './components/SidebarMenu.vue'
 import SidebarMenuGroup from './components/SidebarMenuGroup.vue'
 import SidebarMenuItem from './components/SidebarMenuItem.vue'
 import SidebarVariantScope from './components/SidebarVariantScope.vue'
+import Skeleton from './components/Skeleton.vue'
 import Slider from './components/Slider.vue'
 import Sparkline from './components/Charts/Sparkline.vue'
+import Spinner from './components/Spinner.vue'
+import Stepper from './components/Stepper.vue'
+import StepperStep from './components/StepperStep.vue'
 import Submenu from './components/Submenu.vue'
 import SurfaceLayerScope from './components/SurfaceLayerScope.vue'
 import Switch from './components/Switch.vue'
 import Tabs from './components/Tabs.vue'
 import TextInput from './components/TextInput.vue'
 import Toast from './components/Toast.vue'
+import Toaster from './components/Toaster.vue'
 import Tree from './components/Tree.vue'
 import TreeNode from './components/TreeNode.vue'
 import UserMenu from './components/UserMenu.vue'
@@ -107,6 +116,7 @@ declare module 'vue' {
     NbCheckboxGroup: typeof CheckboxGroup
     NbColorStrip: typeof ColorStrip
     NbCommandPalette: typeof CommandPalette
+    NbConfirm: typeof Confirm
     NbDataTable: typeof DataTable
     NbDatePicker: typeof DatePicker
     NbDefinitionList: typeof DefinitionList
@@ -121,6 +131,7 @@ declare module 'vue' {
     NbIcon: typeof Icon
     NbImageCropper: typeof ImageCropper
     NbInfoHint: typeof InfoHint
+    NbInlineLoading: typeof InlineLoading
     NbInterpolationChart: typeof InterpolationChart
     NbJsonTree: typeof JsonTree
     NbLabel: typeof Label
@@ -133,6 +144,8 @@ declare module 'vue' {
     NbMenuItem: typeof MenuItem
     NbMessage: typeof Message
     NbModal: typeof Modal
+    NbNotificationCenter: typeof NotificationCenter
+    NbNotificationCenterItem: typeof NotificationCenterItem
     NbNubiscoMark: typeof NubiscoMark
     NbNubiscoPlatformMark: typeof NubiscoPlatformMark
     NbNumberInput: typeof NumberInput
@@ -151,14 +164,19 @@ declare module 'vue' {
     NbSidebarMenuGroup: typeof SidebarMenuGroup
     NbSidebarMenuItem: typeof SidebarMenuItem
     NbSidebarVariantScope: typeof SidebarVariantScope
+    NbSkeleton: typeof Skeleton
     NbSlider: typeof Slider
     NbSparkline: typeof Sparkline
+    NbSpinner: typeof Spinner
+    NbStepper: typeof Stepper
+    NbStepperStep: typeof StepperStep
     NbSubmenu: typeof Submenu
     NbSurfaceLayerScope: typeof SurfaceLayerScope
     NbSwitch: typeof Switch
     NbTabs: typeof Tabs
     NbTextInput: typeof TextInput
     NbToast: typeof Toast
+    NbToaster: typeof Toaster
     NbTree: typeof Tree
     NbTreeNode: typeof TreeNode
     NbUserMenu: typeof UserMenu