@nubisco/ui 3.2.0 → 3.4.0

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

@@ -0,0 +1,193 @@
+import { defineComponent, type ComputedRef, type InjectionKey, type ShallowRef } from 'vue';
+/**
+ * Shell regions a view is allowed to contribute controls to.
+ *
+ * These are exactly the regions `NbShell` renders as a single addressable
+ * element. `sidebar-*` is deliberately absent: navigation is the application's
+ * to declare once, not a per-view contribution, and a view that could inject
+ * rail items could also make the rail change shape on every route.
+ * `menubar` is absent because it is the legacy in-body bar, kept for the two
+ * apps that still pass it and not worth a new contract.
+ */
+export type TShellSlotName = 'outer-menu' | 'inner-menu' | 'notification' | 'topbar-left' | 'topbar-right' | 'fixedbar' | 'bottom' | 'inspector';
+/**
+ * What happens when two views hold the same region at the same time, which is
+ * the normal state of affairs for the frame or two a route transition takes.
+ *
+ * - `'last'` (default): the most recently registered contributor renders and
+ *   the others stand down. The leaving view's controls disappear the moment
+ *   the arriving view registers, so the topbar never shows two page titles or
+ *   two Save buttons. When the newer contributor unmounts, the previous one
+ *   becomes active again, which is what makes a contribution inside a dialog
+ *   or a nested route behave.
+ * - `'all'`: every contributor renders, ordered by `order` then registration.
+ *   For genuinely additive regions (a status chip from a background sync
+ *   alongside the page's own actions).
+ */
+export type TShellSlotClaim = 'last' | 'all';
+export interface IShellSlotOptions {
+    /**
+     * Sort key within a region when `claim: 'all'`. Lower renders first (further
+     * left in a horizontal region, higher in a stacked one). Ties keep
+     * registration order. Ignored when `claim` is `'last'`, where there is only
+     * ever one contribution to place.
+     *
+     * Teleports append in mount order, which for concurrent views is whatever
+     * order the router happened to create them in. So under `claim: 'all'` the
+     * outlet wraps its content in a flex box carrying a CSS `order`, and that is
+     * what actually sorts the region. The wrapper inherits the region's own gap
+     * and cross-axis alignment (both with an explicit `inherit`), so
+     * contributions line up with static slot content rather than reading as a
+     * nested group.
+     *
+     * CSS `order` only sorts flex and grid children, and three of the eight
+     * regions (`outer-menu`, `inner-menu`, `notification`) are block containers
+     * whose internal layout belongs to the product, not to us. `NbShell`
+     * therefore switches exactly those three to a column flex container while a
+     * shared contribution is registered, and back when the last one leaves: see
+     * `sharedCount` below and `.nb-shell__region--ordered` in `Shell.vue`. The
+     * switch is scoped to the new API on purpose, so a product that never calls
+     * `useShellSlot` keeps byte-identical layout in the regions it already fills
+     * by hand.
+     * @default 0
+     */
+    order?: number;
+    /**
+     * How this contributor shares the region with others.
+     * @default 'last'
+     */
+    claim?: TShellSlotClaim;
+}
+/** One registered contributor, as the shell sees it. */
+interface IShellSlotEntry {
+    id: number;
+    name: TShellSlotName;
+    order: number;
+    claim: TShellSlotClaim;
+    seq: number;
+    /**
+     * True while the contributor is alive but off screen, which in practice
+     * means a `<KeepAlive>`-cached route component that has been deactivated.
+     * Such an entry is skipped by `activeIds` and by `count`, so a cached page's
+     * controls neither render nor keep a region open.
+     */
+    deactivated: boolean;
+}
+/**
+ * The contract `NbShell` provides and `useShellSlot` consumes. Not public API:
+ * consumers go through the composable, which is the whole point of the piece.
+ */
+export interface IShellSlotRegistry {
+    register(entry: IShellSlotEntry): void;
+    unregister(id: number): void;
+    /** The live host element for a region, or null before the shell has mounted it. */
+    elementFor(name: TShellSlotName): ShallowRef<HTMLElement | null>;
+    /** Ids that should render right now for a region, in render order. */
+    activeIds(name: TShellSlotName): ComputedRef<number[]>;
+    /**
+     * Suspend or resume a registration without losing it. Called from the
+     * composable's `onDeactivated` / `onActivated`, which is the only lifecycle
+     * pair `<KeepAlive>` gives us: a deactivated component is not unmounted, its
+     * effect scope is not disposed, and its teleported nodes stay exactly where
+     * they were.
+     */
+    setActive(id: number, active: boolean): void;
+}
+export declare const NB_SHELL_SLOT_KEY: InjectionKey<IShellSlotRegistry>;
+export interface IShellSlot {
+    /** This contributor's id. Useful in tests and debugging; not needed to render. */
+    readonly id: number;
+    /** The region this contributor targets. */
+    readonly name: TShellSlotName;
+    /**
+     * The host element inside the shell. `null` until the shell has mounted the
+     * region, which is normal on the first tick: a view's `onMounted` runs
+     * BEFORE its ancestors'. Reactive, so anything bound to it corrects itself
+     * without a `nextTick` dance.
+     */
+    readonly target: Readonly<ShallowRef<HTMLElement | null>>;
+    /** True once `target` exists. */
+    readonly ready: ComputedRef<boolean>;
+    /**
+     * True when this contributor both has a target and has won the region under
+     * the current `claim`. `Outlet` already checks this; read it when you need
+     * to skip expensive work rather than just skip rendering.
+     */
+    readonly active: ComputedRef<boolean>;
+    /**
+     * Renders its default slot into the region. Use it as a component:
+     * `<component :is="topbar.Outlet"><NbButton ... /></component>`.
+     *
+     * Content stays owned by the view: it is teleported, not re-created, so its
+     * reactive state, event handlers and component instances are the view's.
+     */
+    readonly Outlet: ReturnType<typeof defineComponent>;
+}
+/**
+ * Contribute controls from a view into a region of the surrounding `NbShell`.
+ *
+ * Eight of our twelve applications solved this with a hand-rolled DOM id
+ * (`#cms-topbar`, `#ob-topbar-left`, `#page-actions`, five more), and every one
+ * of them re-derived the same two problems: the target element does not exist
+ * when the view mounts, and during a route transition two views hold the region
+ * at once. This composable is the supported answer to both.
+ *
+ * ```vue
+ * <script setup lang="ts">
+ * import { useShellSlot } from '@nubisco/ui'
+ * const topbar = useShellSlot('topbar-right')
+ * </script>
+ *
+ * <template>
+ *   <topbar.Outlet>
+ *     <NbButton size="sm" @click="save">Save</NbButton>
+ *   </topbar.Outlet>
+ *   <article>...</article>
+ * </template>
+ * ```
+ *
+ * Contributing also makes the region exist: `NbShell` counts registrations the
+ * same way it counts slot content, so a topbar with no static slots and no
+ * contributions is not rendered at all, and appears the moment a view claims
+ * it. Nothing to hide from the outside with a `:deep()` override.
+ *
+ * Under `<KeepAlive>` the contribution follows the page rather than the
+ * component instance. A cached route component that is deactivated releases the
+ * region on the way out and takes it back (as the newest claimant) on the way
+ * in, so `<router-view v-slot="{ Component }"><KeepAlive><component
+ * :is="Component" /></KeepAlive></router-view>` behaves the same as an
+ * uncached one.
+ *
+ * Outside an `NbShell` the composable is inert: `ready` stays false, `Outlet`
+ * renders nothing, no warning, no throw. That keeps a view usable in isolation
+ * (a storybook page, a unit test, a print route) without branching on it.
+ *
+ * The same is true inside a shell that is not rendering the region: a
+ * contribution to `topbar-left` under `<NbShell topbar="never">` has no host
+ * element to teleport into, so `ready` stays false and nothing renders. The
+ * shell warns about that case in development, because it is a configuration
+ * mistake rather than a legitimate isolated mount.
+ */
+export declare function useShellSlot(name: TShellSlotName, options?: IShellSlotOptions): IShellSlot;
+/**
+ * Builds the registry side of the contract. Called by `NbShell`; exported so
+ * the shell and the composable cannot drift apart, not as consumer API.
+ */
+export declare function createShellSlotRegistry(): {
+    registry: IShellSlotRegistry;
+    /**
+     * Reactive count of *live* contributors per region, for the shell's own
+     * `v-if`. Deactivated (`<KeepAlive>`-cached) entries do not count, so a
+     * topbar opened by a page that has since been cached closes again.
+     */
+    count: (name: TShellSlotName) => number;
+    /**
+     * Reactive count of live `claim: 'all'` contributors per region. The shell
+     * uses it to decide whether a block region needs to become a flex container
+     * for the duration, which is the only way a CSS `order` can sort it.
+     */
+    sharedCount: (name: TShellSlotName) => number;
+    setElement: (name: TShellSlotName, el: HTMLElement | null) => void;
+};
+export {};
+//# sourceMappingURL=useShellSlot.composable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useShellSlot.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useShellSlot.composable.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,eAAe,EAWf,KAAK,WAAW,EAChB,KAAK,YAAY,EAEjB,KAAK,UAAU,EAEhB,MAAM,KAAK,CAAA;AAEZ;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GACtB,YAAY,GACZ,YAAY,GACZ,cAAc,GACd,aAAa,GACb,cAAc,GACd,UAAU,GACV,QAAQ,GACR,WAAW,CAAA;AAEf;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,KAAK,CAAA;AAE5C,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,KAAK,CAAC,EAAE,eAAe,CAAA;CACxB;AAED,wDAAwD;AACxD,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,IAAI,EAAE,cAAc,CAAA;IACpB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,eAAe,CAAA;IACtB,GAAG,EAAE,MAAM,CAAA;IACX;;;;;OAKG;IACH,WAAW,EAAE,OAAO,CAAA;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,CAAA;IACtC,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,mFAAmF;IACnF,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;IAChE,sEAAsE;IACtE,SAAS,CAAC,IAAI,EAAE,cAAc,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,CAAA;IACtD;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAAA;CAC7C;AAED,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,kBAAkB,CACrC,CAAA;AAO1B,MAAM,WAAW,UAAU;IACzB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAA;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC,CAAA;IACzD,iCAAiC;IACjC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IACpC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,CAAA;IACrC;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC,OAAO,eAAe,CAAC,CAAA;CACpD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,cAAc,EACpB,OAAO,GAAE,iBAAsB,GAC9B,UAAU,CAqGZ;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI;IACzC,QAAQ,EAAE,kBAAkB,CAAA;IAC5B;;;;OAIG;IACH,KAAK,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,MAAM,CAAA;IACvC;;;;OAIG;IACH,WAAW,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,MAAM,CAAA;IAC7C,UAAU,EAAE,CAAC,IAAI,EAAE,cAAc,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAA;CACnE,CAwEA"}

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"}