@nubisco/ui 3.2.0 → 3.4.0

package/dist/components/Stepper.d.ts

@@ -0,0 +1,101 @@
+import { IDefaultProps } from '../types/Props.d'
+
+/** Reading direction of the step list. */
+enum EStepperOrientation {
+  Horizontal = 'horizontal',
+  Vertical = 'vertical',
+}
+
+/** Marker and type scale. */
+enum EStepperSize {
+  Small = 'sm',
+  Medium = 'md',
+}
+
+/**
+ * The state one step is in. Derived from position unless a step overrides it
+ * with `complete`, `invalid` or `disabled`.
+ */
+enum EStepStatus {
+  /** Behind the current step, or explicitly marked done. */
+  Complete = 'complete',
+  /** Where the user is now. */
+  Current = 'current',
+  /** Ahead of the current step. */
+  Incomplete = 'incomplete',
+  /** Cannot be reached at all, whatever the user has visited. */
+  Disabled = 'disabled',
+  /** Visited and left in a state the flow will not accept. */
+  Invalid = 'invalid',
+}
+
+/**
+ * The words read out after a step's label, and the accessible name of the
+ * list. The only English in the component, so this is the localisation hook.
+ */
+interface IStepperLabels {
+  /** Accessible name of the list when `ariaLabel` is not given. */
+  progress?: string
+  /**
+   * Template announced politely when the current step changes.
+   * `{step}`, `{total}` and `{label}` are substituted.
+   */
+  announcement?: string
+  complete?: string
+  current?: string
+  incomplete?: string
+  disabled?: string
+  invalid?: string
+}
+
+interface IStepperProps extends IDefaultProps {
+  /** Zero-based index of the current step. Omit to let the stepper own it. */
+  modelValue?: number
+  /** Layout direction. Vertical reads better when labels are long. */
+  orientation?: `${EStepperOrientation}`
+  /** Marker and type scale. */
+  size?: `${EStepperSize}`
+  /** Allow clicking back to a step the user has already reached. */
+  navigable?: boolean
+  /**
+   * Furthest index the user has reached, which is what `navigable` opens up.
+   * Omit and the stepper keeps its own high-water mark, so going back never
+   * closes the steps ahead. Pass it when the flow is resumed from storage.
+   */
+  furthest?: number
+  /** Accessible name of the list. Falls back to `labels.progress`. */
+  ariaLabel?: string
+  /** Status words announced per step. Override to translate. */
+  labels?: IStepperLabels
+  /**
+   * Announce the new step in a polite live region when the flow advances.
+   * Turn it off when the flow already moves focus to the new step's heading,
+   * which would otherwise announce the move twice.
+   */
+  announce?: boolean
+}
+
+interface IStepperStepProps extends IDefaultProps {
+  /** One or two words naming what the step accomplishes. */
+  label?: string
+  /** Optional second line: what the step needs, or why it is optional. */
+  description?: string
+  /**
+   * Force the complete state on a step that is not behind the current one,
+   * for a flow that lets an optional step be finished out of order.
+   */
+  complete?: boolean
+  /** Visited and rejected. Stays reachable so the user can go back and fix it. */
+  invalid?: boolean
+  /** Not part of this run of the flow. Never reachable, never focusable. */
+  disabled?: boolean
+}
+
+export {
+  EStepperOrientation,
+  EStepperSize,
+  EStepStatus,
+  IStepperLabels,
+  IStepperProps,
+  IStepperStepProps,
+}

package/dist/components/Stepper.vue.d.ts

@@ -0,0 +1,31 @@
+import { EStepperOrientation, EStepperSize, IStepperProps } from './Stepper.d';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<IStepperProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (index: number) => any;
+    change: (index: number) => any;
+}, string, import("vue").PublicProps, Readonly<IStepperProps> & Readonly<{
+    "onUpdate:modelValue"?: ((index: number) => any) | undefined;
+    onChange?: ((index: number) => any) | undefined;
+}>, {
+    modelValue: number;
+    size: `${EStepperSize}`;
+    id: string;
+    orientation: `${EStepperOrientation}`;
+    ariaLabel: string;
+    labels: import("./Stepper.d").IStepperLabels;
+    navigable: boolean;
+    furthest: number;
+    announce: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Stepper.vue.d.ts.map

package/dist/components/Stepper.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Stepper.vue.d.ts","sourceRoot":"","sources":["../../src/components/Stepper.vue"],"names":[],"mappings":"AA0eA,OAAO,EAAE,mBAAmB,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AA2a9E,QAAA,IAAI,OAAO,IAAW,CAAE;AACxB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,CAAC;AAO/C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;6EAId,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/StepperStep.vue.d.ts

@@ -0,0 +1,24 @@
+import { IStepperStepProps } from './Stepper.d';
+declare var __VLS_14: {}, __VLS_16: {};
+type __VLS_Slots = {} & {
+    label?: (props: typeof __VLS_14) => any;
+} & {
+    description?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<IStepperStepProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IStepperStepProps> & Readonly<{}>, {
+    disabled: boolean;
+    label: string;
+    id: string;
+    invalid: boolean;
+    description: string;
+    complete: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=StepperStep.vue.d.ts.map

package/dist/components/StepperStep.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StepperStep.vue.d.ts","sourceRoot":"","sources":["../../src/components/StepperStep.vue"],"names":[],"mappings":"AAoaA,OAAO,EAAe,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAoS5D,QAAA,IAAI,QAAQ,IAAW,EAAE,QAAQ,IAAY,CAAE;AAC/C,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC3C;IAAE,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAOpD,QAAA,MAAM,UAAU;;;;;;;6EAGd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/TextInput.vue.d.ts

@@ -63,11 +63,11 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     max: string | number;
     helper: string;
     placeholder: string;
-    readonly: boolean;
     step: string | number;
-    highlight: (text: string) => string;
     maxlength: number;
     multiline: boolean;
+    highlight: (text: string) => string;
+    readonly: boolean;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/components/TextInput.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextInput.vue.d.ts","sourceRoot":"","sources":["../../src/components/TextInput.vue"],"names":[],"mappings":"AA8iBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AAO9D,MAAM,WAAW,eAAgB,SAAQ,uBAAuB;IAC9D,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;CACrC;AAED,KAAK,WAAW,GAAG,eAAe,CAAC;AAyFnC,KAAK,gBAAgB,GAAG;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AA2BF,KAAK,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAkYxD,QAAA,IAAI,OAAO,IAAU,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAY,CAAE;AACjI,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,GAC1C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC9C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC9C;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAQ9C,QAAA,MAAM,UAAU;;;;;;;;;;;;UA3hBP,MAAM;;;;;;;UAQN,MAAM;SAPP,MAAM,GAAG,MAAM;SACf,MAAM,GAAG,MAAM;;;;UACd,MAAM,GAAG,MAAM;eAcV,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;eAbxB,MAAM;eAEN,OAAO;6EA0hBnB,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}
+{"version":3,"file":"TextInput.vue.d.ts","sourceRoot":"","sources":["../../src/components/TextInput.vue"],"names":[],"mappings":"AA8iBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAA;AAO9D,MAAM,WAAW,eAAgB,SAAQ,uBAAuB;IAC9D,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACtB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAA;CACrC;AAED,KAAK,WAAW,GAAG,eAAe,CAAC;AAyFnC,KAAK,gBAAgB,GAAG;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AA2BF,KAAK,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAkYxD,QAAA,IAAI,OAAO,IAAU,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAY,CAAE;AACjI,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,GAC1C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC9C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC9C;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAQ9C,QAAA,MAAM,UAAU;;;;;;;;;;;;UA3hBP,MAAM;;;;;;;UAQN,MAAM;SAPP,MAAM,GAAG,MAAM;SACf,MAAM,GAAG,MAAM;;;UACd,MAAM,GAAG,MAAM;eACV,MAAM;eAEN,OAAO;eAWP,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM;;6EA+gBpC,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/Toast.vue.d.ts

@@ -7,18 +7,61 @@ type __VLS_Props = {
     variant?: TToastVariant;
     title?: string;
     message: string;
+    /**
+     * Milliseconds the countdown bar represents. `0` draws no bar.
+     *
+     * When `managed` is false (a bare `NbToast`), this is also the toast's own
+     * auto-dismiss timer. When `managed` is true, `NbToaster` owns the clock
+     * and this value only sizes the bar.
+     */
     duration?: number;
     cta?: IToastCta;
+    /**
+     * ARIA role. `NbToaster` sets `status` for success and info and `alert`
+     * for warning and error. Declared as a real prop rather than left to
+     * fallthrough attributes, so adding `inheritAttrs: false` or a wrapper
+     * element here can never silently revert every success toast to `alert`.
+     */
+    role?: 'alert' | 'status' | 'none';
+    /** Politeness. Defaults to `assertive` for errors, `polite` otherwise. */
+    ariaLive?: 'assertive' | 'polite' | 'off';
+    /**
+     * Visually hidden severity word, read before the title. Defaults to the
+     * English name of the variant; pass your own for another language, or an
+     * empty string to suppress it.
+     */
+    statusLabel?: string;
+    /** Accessible name of the close button. Translate it per application. */
+    closeLabel?: string;
+    /**
+     * `true` when a host owns the clock. The toast then runs no timer of its
+     * own and takes its pause state from `paused`, so a whole stack can stop
+     * together instead of each item counting down on its own.
+     */
+    managed?: boolean;
+    /** Countdown held, when managed. Ignored otherwise. */
+    paused?: boolean;
+    /** Bump to restart the countdown bar after the message changed. */
+    cycle?: number;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    action: () => any;
     close: () => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAction?: (() => any) | undefined;
     onClose?: (() => any) | undefined;
 }>, {
     title: string;
+    role: "alert" | "status" | "none";
     variant: TToastVariant;
+    closeLabel: string;
     duration: number;
+    statusLabel: string;
     cta: IToastCta;
+    ariaLive: "assertive" | "polite" | "off";
+    managed: boolean;
+    paused: boolean;
+    cycle: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/Toast.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Toast.vue.d.ts","sourceRoot":"","sources":["../../src/components/Toast.vue"],"names":[],"mappings":"AAgQA,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;AAEpE,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB;AAED,KAAK,WAAW,GAAG;IACf,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,SAAS,CAAA;CAChB,CAAC;AA8LJ,QAAA,MAAM,YAAY;;;;;WAlMN,MAAM;aADJ,aAAa;cAGZ,MAAM;SACX,SAAS;6EAmMjB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"Toast.vue.d.ts","sourceRoot":"","sources":["../../src/components/Toast.vue"],"names":[],"mappings":"AAsdA,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,GAAG,MAAM,CAAA;AAEpE,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB;AAED,KAAK,WAAW,GAAG;IACf,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;IACf;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,GAAG,CAAC,EAAE,SAAS,CAAA;IACf;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAA;IAClC,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,WAAW,GAAG,QAAQ,GAAG,KAAK,CAAA;IACzC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,uDAAuD;IACvD,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,mEAAmE;IACnE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAC;AA8PJ,QAAA,MAAM,YAAY;;;;;;;WApSN,MAAM;UAiBP,OAAO,GAAG,QAAQ,GAAG,MAAM;aAlBxB,aAAa;gBA4BV,MAAM;cAlBR,MAAM;iBAgBH,MAAM;SAfd,SAAS;cASJ,WAAW,GAAG,QAAQ,GAAG,KAAK;aAc/B,OAAO;YAER,OAAO;WAER,MAAM;6EAmQhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/Toaster.d.ts

@@ -0,0 +1,93 @@
+import type { IToastQueue } from '../composables/useToast.composable'
+
+/**
+ * Where the stack sits.
+ *
+ * The suffix is the inline edge, so it follows the document direction rather
+ * than the screen: `-end` is the right in a left-to-right document and the
+ * left in Arabic or Hebrew. The audit found five different breakpoint scales
+ * and no shared idea of "the corner"; naming the edge logically is what stops
+ * a right-to-left build from putting the stack on top of the shell rail.
+ */
+type TToasterPlacement =
+  | 'top-start'
+  | 'top'
+  | 'top-end'
+  | 'bottom-start'
+  | 'bottom'
+  | 'bottom-end'
+
+interface IToasterProps {
+  /**
+   * Queue to render. Defaults to the shared `useToast()` queue.
+   *
+   * Pass one from `createToastQueue()` for anything that is not the
+   * application's own stack: a docs demo, a test, a second host inside a
+   * dialog. Two hosts rendering the same queue show and announce every
+   * message twice, and both write to `queue.max`; the host warns about it in
+   * development.
+   *
+   * It is read reactively, so binding a queue that is created after mount is
+   * safe.
+   */
+  queue?: IToastQueue
+  /**
+   * Corner or edge the stack grows from. `bottom-end` keeps it clear of the
+   * shell top bar, where the actions that raise most toasts live.
+   */
+  placement?: TToasterPlacement
+  /**
+   * Visible-slot cap. Extras wait in the queue and slide in as slots free up.
+   *
+   * The cap belongs to the queue, since admission happens in `push()` before
+   * any host renders, so this prop writes through to `queue.max` and restores
+   * the previous value when the host unmounts.
+   *
+   * There is deliberately **no default**. Leaving it off means the queue keeps
+   * whatever cap it was built with, so `createToastQueue({ max: 2 })` rendered
+   * by a bare `<NbToaster :queue="toast" />` shows two. A default here would
+   * silently overrule every queue configured through `createToastQueue`, which
+   * is the one place a consumer expects to set this. Set it on the prop only
+   * when the host is the thing that knows better than the queue: a demo, a
+   * dialog, a narrow viewport.
+   *
+   * The queue's own default, from `createToastQueue()`, is `3`.
+   */
+  max?: number
+  /** Accessible name of the region landmark. */
+  label?: string
+  /**
+   * Teleport target. Body keeps the stack out of every transformed ancestor.
+   *
+   * `false` turns the teleport off and renders the stack where the component
+   * sits. That is the server-rendering answer: `<Teleport>` does not render
+   * into its target on the server, it buffers into `ctx.teleports`, and an app
+   * that does not write that buffer into the target hydrates a stack the
+   * server never sent. Either splice `ctx.teleports.body` into your HTML
+   * template, or pass `:to="false"` and mount the host at the app root.
+   */
+  to?: string | false
+  /**
+   * Keyboard shortcut that moves focus into the stack and back out again.
+   * `'alt+t'` by default; pass `null` to remove it.
+   *
+   * Written as modifiers plus one key (`'alt+t'`, `'ctrl+shift+n'`). The
+   * terminal key is matched on its physical position (`event.code`), not on
+   * the character it produces, because Option on macOS is a character
+   * modifier: Option+T types a dagger, never a `t`.
+   *
+   * Without a hotkey, the only route to a toast's action is to tab past the
+   * rest of the document, which is a long way from wherever the user was, and
+   * the countdown is running while they travel.
+   */
+  hotkey?: string | null
+  /**
+   * Spoken form of the hotkey, appended once to the announcement of a toast
+   * that carries an action. Translate it with the rest of the interface, and
+   * change it if you change `hotkey`: it is a promise made to somebody who
+   * cannot see the stack, so it has to name a key that works.
+   */
+  hotkeyHint?: string
+}
+
+export type { IToasterProps, TToasterPlacement }

package/dist/components/Toaster.vue.d.ts

@@ -0,0 +1,30 @@
+import type { IToasterProps } from './Toaster.d';
+import { type IToastRecord, type TToastDismissReason } from '../composables/useToast.composable';
+import type { IToastQueue } from '../composables/useToast.composable';
+export type { TToasterPlacement } from './Toaster.d';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: __VLS_WithSlots<import("vue").DefineComponent<IToasterProps, {
+    queue: import("vue").ComputedRef<IToastQueue>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IToasterProps> & Readonly<{}>, {
+    label: string;
+    max: number;
+    to: string | false;
+    placement: import("./Toaster.d").TToasterPlacement;
+    queue: IToastQueue;
+    hotkey: string | null;
+    hotkeyHint: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    toast?: (props: {
+        toast: IToastRecord;
+        paused: boolean;
+        dismiss: (reason?: TToastDismissReason) => void;
+        action: () => Set<string>;
+    }) => any;
+}>;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+//# sourceMappingURL=Toaster.vue.d.ts.map

package/dist/components/Toaster.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Toaster.vue.d.ts","sourceRoot":"","sources":["../../src/components/Toaster.vue"],"names":[],"mappings":"AA+9BA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAChD,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EACzB,MAAM,oCAAoC,CAAA;AAG3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AAErE,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;wBAwB/B,OAAO,YAAY;AAAxC,wBAAyC;AACzC,QAAA,MAAM,YAAY;;;;;;;;;;;YA41BN,CAAC,KAAK;;;2BAtEM,mBAAmB;;KAsER,KAAK,GAAG;EAWvC,CAAC;AAWL,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/UserMenu.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserMenu.vue.d.ts","sourceRoot":"","sources":["../../src/components/UserMenu.vue"],"names":[],"mappings":"AAqfA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAiHpE,iBAAS,MAAM,SASd;AAED,iBAAS,KAAK,SAIb;AA0YD,QAAA,IAAI,OAAO;;;CAAU,EAAE,QAAQ;;CAAW,EAAE,QAAQ,IAAY,CAAE;AAClE,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,GAC5C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAQ9C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAKd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}
+{"version":3,"file":"UserMenu.vue.d.ts","sourceRoot":"","sources":["../../src/components/UserMenu.vue"],"names":[],"mappings":"AA6fA,OAAO,KAAK,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAyHpE,iBAAS,MAAM,SASd;AAED,iBAAS,KAAK,SAIb;AAkZD,QAAA,IAAI,OAAO;;;CAAU,EAAE,QAAQ;;CAAW,EAAE,QAAQ,IAAY,CAAE;AAClE,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,OAAO,KAAK,GAAG,CAAA;CAAE,GAC5C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAQ9C,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6EAKd,CAAC;AACH,QAAA,MAAM,YAAY,EAAS,eAAe,CAAC,OAAO,UAAU,EAAE,WAAW,CAAC,CAAC;wBACtD,OAAO,YAAY;AAAxC,wBAAyC;AAWzC,KAAK,eAAe,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG;IAChC,QAAO;QACN,MAAM,EAAE,CAAC,CAAC;KACV,CAAA;CACD,CAAC"}

package/dist/components/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;;iBA8Jf,GAAG;;AADlB,wBAMC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/components/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;;iBAkLf,GAAG;;AADlB,wBAMC"}

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

@@ -0,0 +1,45 @@
+import type { IConfirmOptions } from '../components/Confirm.d';
+/**
+ * Awaitable confirmation.
+ *
+ * ```ts
+ * const confirm = useConfirm()
+ * if (await confirm({ title: 'Delete environment', subject: env.name })) {
+ *   await api.deleteEnvironment(env.id)
+ * }
+ * ```
+ *
+ * Resolves `true` only if the user confirmed (and, when `onConfirm` is
+ * supplied, only after that work succeeded). Escape, the overlay, the close
+ * button and the cancel button all resolve `false`. It never rejects: a
+ * failing `onConfirm` keeps the dialog open instead, so a rejected promise
+ * would have no honest meaning here.
+ */
+export type TConfirmFn = (options: IConfirmOptions) => Promise<boolean>;
+/**
+ * Cancels the dialog on screen and everything waiting behind it, resolving
+ * every outstanding `confirm()` to `false`, then tears the host down.
+ *
+ * Call it when the ground moves under a pending question: a route change, a
+ * signed-out session, a Tauri window closing. Without it a confirm asked
+ * about a record that no longer exists sits there waiting for an answer.
+ *
+ * Work already in flight is not cancelled, because nothing here can cancel a
+ * request it did not make. It is disowned: every entry is marked done, so
+ * when that request finally lands it resolves nothing, closes nothing and
+ * shows its failure to nobody. Pass an AbortSignal inside `onConfirm` if the
+ * call itself has to stop too.
+ */
+export declare function dismissConfirms(): void;
+/**
+ * Returns the `confirm()` function. It is a plain function over module state,
+ * not an injection, so it works in a component, in a Pinia store, in a router
+ * guard and in a plain module.
+ *
+ * Nothing to install and nothing to mount: the first call creates the host.
+ * That matters beyond convenience, because `window.confirm` is a documented
+ * no-op inside a Tauri webview and cannot be driven by a gamepad, so the
+ * alternative every app reached for is not available to two of ours.
+ */
+export declare function useConfirm(): TConfirmFn;
+//# sourceMappingURL=useConfirm.composable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useConfirm.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useConfirm.composable.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,wBAAwB,CAAA;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAiTvE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,IAAI,IAAI,CA8BtC;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,IAAI,UAAU,CAEvC"}

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

@@ -0,0 +1,43 @@
+import { type Ref } from 'vue';
+type TInlineLoadingStatus = 'inactive' | 'active' | 'finished' | 'error';
+interface IUseInlineLoadingOptions {
+    /** Called when the wrapped action rejects, before the status flips to `error`. */
+    onError?: (error: unknown) => void;
+}
+interface IUseInlineLoading {
+    /** Bind to `NbInlineLoading`'s `status` prop. */
+    status: Readonly<Ref<TInlineLoadingStatus>>;
+    /** Whatever the last failed run rejected with, for logging or a message. */
+    error: Readonly<Ref<unknown>>;
+    /** Runs an async action and drives the status through the four states. */
+    run: <T>(action: () => Promise<T>) => Promise<T | undefined>;
+    /** Back to `inactive`. Bind to the component's `success` event. */
+    reset: () => void;
+}
+/**
+ * Drives the NbInlineLoading state machine for a single action.
+ *
+ * The audit found four apps that confirmed a successful save with nothing at
+ * all, and none of them were being careless: they were all writing the same
+ * try/catch/finally by hand and the finally reset the flag before anything
+ * could be shown. Handing the sequence over removes the chance to get it
+ * wrong.
+ *
+ * Two behaviours are worth knowing about:
+ *
+ * - Overlapping runs. If a second `run` starts while the first is in flight,
+ *   only the newest one is allowed to write the status. A slow first save can
+ *   no longer land on top of a fast second one and report the wrong outcome.
+ * - Rejections are absorbed, not rethrown. `run` is meant to be called from a
+ *   click handler, where a rethrown rejection becomes an unhandled promise.
+ *   The reason is kept in `error` and passed to `onError`, and the failure is
+ *   visible in the UI, which is what the caller actually wanted.
+ *
+ * @example
+ * const save = useInlineLoading()
+ * // <NbButton @click="save.run(() => api.save(form))">Save</NbButton>
+ * // <NbInlineLoading :status="save.status.value" @success="save.reset" />
+ */
+export declare function useInlineLoading(options?: IUseInlineLoadingOptions): IUseInlineLoading;
+export type { TInlineLoadingStatus, IUseInlineLoading, IUseInlineLoadingOptions, };
+//# sourceMappingURL=useInlineLoading.composable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useInlineLoading.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useInlineLoading.composable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAA;AAG7C,KAAK,oBAAoB,GAAG,UAAU,GAAG,QAAQ,GAAG,UAAU,GAAG,OAAO,CAAA;AAExE,UAAU,wBAAwB;IAChC,kFAAkF;IAClF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;CACnC;AAED,UAAU,iBAAiB;IACzB,iDAAiD;IACjD,MAAM,EAAE,QAAQ,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAA;IAC3C,4EAA4E;IAC5E,KAAK,EAAE,QAAQ,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAA;IAC7B,0EAA0E;IAC1E,GAAG,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAAA;IAC5D,mEAAmE;IACnE,KAAK,EAAE,MAAM,IAAI,CAAA;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,wBAAgB,gBAAgB,CAC9B,OAAO,GAAE,wBAA6B,GACrC,iBAAiB,CA0CnB;AAGD,YAAY,EACV,oBAAoB,EACpB,iBAAiB,EACjB,wBAAwB,GACzB,CAAA"}

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

@@ -0,0 +1,63 @@
+/**
+ * Announces that a load has finished, from a component that is about to stop
+ * existing.
+ *
+ * A spinner or a skeleton says "this is loading" and then, when the work is
+ * done, it is unmounted. Sighted users see the content appear. A screen reader
+ * user gets silence: the live region that was doing the talking has been
+ * removed from the document, so nothing can be spoken through it, and the
+ * newly inserted content is not itself an update anyone is watching. Every
+ * loading indicator in the library shares this problem, and it is why the
+ * completion half of a load is the part that goes missing.
+ *
+ * The fix cannot live inside the component: to be heard, the message has to be
+ * written into a live region that is already in the document and stays there
+ * afterwards. So there is one shared region, owned by this module, appended to
+ * `<body>` the first time anything announces and reused from then on.
+ *
+ * Two details that matter more than they look:
+ *
+ * - The message is written on a later task, not synchronously. A live region
+ *   that is inserted and filled in the same frame is frequently missed, and
+ *   the announcement typically races the unmount that triggered it.
+ * - The same text twice in a row is not spoken twice by most screen readers,
+ *   because the node's contents did not change. Clearing first makes the
+ *   second "Invoices loaded" a real change.
+ *
+ * The delay is also what makes `suppressLoadingAnnouncement` possible, and that
+ * matters more than it sounds: an indicator is unmounted by the same state
+ * change that decides whether the load succeeded or failed, and it cannot read
+ * that decision. Vue does not update a component's props on the render that
+ * removes it, so a `:failed` prop set in the same tick is never seen by the
+ * teardown handler. The failure path speaks up instead. See the composable's
+ * docs and the "when the fetch fails" section of the skeleton page.
+ */
+/**
+ * Speaks `message` politely. Called from a component's teardown, after the
+ * work it was covering has finished.
+ */
+export declare function announceLoadingComplete(message: string | undefined): void;
+/**
+ * Cancels the completion announcement for the load that is ending right now.
+ *
+ * Call it where the failure is known, before the state change that removes the
+ * indicator:
+ *
+ * ```ts
+ * catch (reason) {
+ *   suppressLoadingAnnouncement()
+ *   error.value = reason
+ * }
+ * ```
+ *
+ * The suppression covers anything queued for the rest of the current task, so
+ * it holds across the render that unmounts the spinner or skeleton and the
+ * teardown handler that would have announced. It then lifts by itself: the
+ * next load is a new load, and it is allowed to report its own ending.
+ */
+export declare function suppressLoadingAnnouncement(): void;
+/** The shared region, for tests. Null until something has announced. */
+export declare function loadingAnnouncerRegion(): HTMLElement | null;
+/** Test helper: removes the region and cancels anything queued. */
+export declare function resetLoadingAnnouncer(): void;
+//# sourceMappingURL=useLoadingAnnouncer.composable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadingAnnouncer.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useLoadingAnnouncer.composable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAmCH;;;GAGG;AAEH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAezE;AAGD;;;;;;;;;;;;;;;;;GAiBG;AAEH,wBAAgB,2BAA2B,IAAI,IAAI,CAYlD;AAGD,wEAAwE;AACxE,wBAAgB,sBAAsB,IAAI,WAAW,GAAG,IAAI,CAE3D;AAED,mEAAmE;AACnE,wBAAgB,qBAAqB,IAAI,IAAI,CAQ5C"}

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

@@ -0,0 +1,47 @@
+/**
+ * The page scroll lock, counted, in one place.
+ *
+ * `document.body.style.overflow` is a single slot on a single element, so every
+ * component that wants to stop the page scrolling is writing to the same
+ * variable. Three of ours did, independently: NbModal (counted), NbCommandPalette
+ * (a raw assignment) and NbSpinner's page overlay (a save/restore pair of its
+ * own). Any two of them overlapping produced the same class of bug, and the
+ * worst ordering left the page permanently unscrollable with nothing on screen:
+ *
+ *   1. the spinner saves `''` and sets `hidden`
+ *   2. a modal opens, saves `hidden` as the value to put back
+ *   3. the spinner releases and restores `''`, so the page scrolls behind the
+ *      open dialog
+ *   4. the modal closes and restores its saved `hidden`, forever
+ *
+ * A counter fixes it because the thing being tracked is not "am I locked" but
+ * "how many owners still need the lock". The original value is read once, when
+ * the count goes from zero to one, and put back once, when it returns to zero.
+ * Restoring the literal previous value (usually the empty string, meaning "not
+ * set by us") matters: an application that legitimately sets `overflow: hidden`
+ * on the body for its own layout keeps it.
+ *
+ * Owners hold a share rather than calling the module functions directly, so a
+ * component that unmounts mid-lock releases exactly one count and a component
+ * that locks twice still only holds one.
+ */
+/** Adds one owner to the lock, taking the scrollbar away on the first. */
+export declare function acquireScrollLock(): void;
+/** Drops one owner. The page scrolls again only when the last one has gone. */
+export declare function releaseScrollLock(): void;
+/** How many owners hold the lock. Exposed for tests and for debugging. */
+export declare function scrollLockDepth(): number;
+/**
+ * One owner's share of the lock, tied to the calling scope.
+ *
+ * `lock()` and `unlock()` are idempotent for this owner, and the share is
+ * released automatically when the component goes away, which is the case that
+ * used to leak: a route change that unmounts a dialog without closing it.
+ */
+export declare function useScrollLock(): {
+    lock: () => void;
+    unlock: () => void;
+};
+/** Test helper: forgets every owner and puts the body back as it was found. */
+export declare function resetScrollLock(): void;
+//# sourceMappingURL=useScrollLock.composable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useScrollLock.composable.d.ts","sourceRoot":"","sources":["../../src/composables/useScrollLock.composable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAOH,0EAA0E;AAC1E,wBAAgB,iBAAiB,IAAI,IAAI,CAOxC;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,IAAI,IAAI,CAKxC;AAED,0EAA0E;AAC1E,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,IAAI;IAAE,IAAI,EAAE,MAAM,IAAI,CAAC;IAAC,MAAM,EAAE,MAAM,IAAI,CAAA;CAAE,CAkBxE;AAED,+EAA+E;AAC/E,wBAAgB,eAAe,IAAI,IAAI,CAMtC"}