@nubisco/ui 3.1.0 → 3.3.0

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

@@ -1 +1 @@
-{"version":3,"file":"BlueprintCard.vue.d.ts","sourceRoot":"","sources":["../../src/components/BlueprintCard.vue"],"names":[],"mappings":"AAonDA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EAEd,oBAAoB,EACpB,iBAAiB,EAIlB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAqgChE,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;AAK/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"}
+{"version":3,"file":"BlueprintCard.vue.d.ts","sourceRoot":"","sources":["../../src/components/BlueprintCard.vue"],"names":[],"mappings":"AAsqDA,OAAO,KAAK,EACV,mBAAmB,EACnB,cAAc,EAEd,oBAAoB,EACpB,iBAAiB,EAIlB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mBAAmB,CAAA;AAsiChE,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;AAK/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/Button.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Button.vue.d.ts","sourceRoot":"","sources":["../../src/components/Button.vue"],"names":[],"mappings":"AAmdA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAuMtD,QAAA,IAAI,QAAQ,IAAW,CAAE;AACzB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAKhD,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"}
+{"version":3,"file":"Button.vue.d.ts","sourceRoot":"","sources":["../../src/components/Button.vue"],"names":[],"mappings":"AAgfA,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAwMtD,QAAA,IAAI,QAAQ,IAAW,CAAE;AACzB,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAKhD,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/Charts/GanttChart.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GanttChart.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Charts/GanttChart.vue"],"names":[],"mappings":"AAi9BA,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,gBAAgB,CAAA;AA+7BvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;6EAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"GanttChart.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Charts/GanttChart.vue"],"names":[],"mappings":"AA29BA,OAAO,KAAK,EACV,gBAAgB,EAChB,UAAU,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,gBAAgB,CAAA;AAy8BvB,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;6EAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/Charts/InterpolationChart.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationChart.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Charts/InterpolationChart.vue"],"names":[],"mappings":"AAkiBA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,wBAAwB,CAAA;AAwkB/B,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;6EAIhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"InterpolationChart.vue.d.ts","sourceRoot":"","sources":["../../../src/components/Charts/InterpolationChart.vue"],"names":[],"mappings":"AAyiBA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,wBAAwB,CAAA;AA6kB/B,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;6EAIhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/Charts/shared/palette.d.ts

@@ -1,4 +1,79 @@
+/** Number of categorical roles before `colorAt` wraps. */
+declare const CHART_ROLE_COUNT = 8;
+/**
+ * Categorical roles, in assignment order.
+ *
+ * The order is the contract, not an accident of listing: the earlier roles are
+ * the better separated ones, so a two-series chart gets the strongest pair
+ * available and an eight-series chart degrades predictably. Reordering this
+ * array recolours every chart in every consuming app.
+ */
 declare const DEFAULT_PALETTE: string[];
+/**
+ * The colour for series `index`, wrapping at the end of the palette.
+ *
+ * Wrapping is deliberate: a chart handed twelve series still renders. It also
+ * means series 1 and series 9 are indistinguishable, which is a legibility
+ * failure, not a feature. Above five series, encode with something other than
+ * colour (direct labels, small multiples, facets), or pass `seriesColors()`.
+ *
+ * An empty `palette` falls back to the roles rather than returning `undefined`,
+ * because the chart components default their `colors` prop to `[]` and an
+ * `undefined` fill paints black.
+ */
 declare const colorAt: (index: number, palette?: string[]) => string;
-export { DEFAULT_PALETTE, colorAt };
+/** The `var()` reference for one categorical role, 1-based as the token is. */
+declare const chartRole: (role: number) => string;
+/** Which channel a mark uses, which decides how much contrast the role needs. */
+type TChartMark = 'fill' | 'line';
+/**
+ * `count` categorical colours, best-separated set first.
+ *
+ * Use this when the chart knows how many series it has. `colorAt()` and the
+ * default `colors` prop assign roles in role order, which is the compatible
+ * choice and not the legible one; this picks the subset that survives colour
+ * vision deficiency best at that exact count.
+ *
+ * Pass `{ mark: 'line' }` for strokes, points and sparkline-thin marks, which
+ * need 3:1 contrast against the surface as well as separation from each other.
+ * The default, `'fill'`, is for bars, slices, areas and legend chips.
+ *
+ * Above eight it wraps, same as `colorAt()`, and is just as much a legibility
+ * failure there. A non-positive or non-finite `count` returns an empty array,
+ * which is what the `colors` prop wants for "use the default".
+ */
+declare const seriesColors: (count: number, options?: {
+    mark?: TChartMark;
+}) => string[];
+/**
+ * A point on the sequential ramp, `t` from 0 (lowest value) to 1 (highest).
+ *
+ * One hue, lightness carrying magnitude. Use it when the quantity is ordered
+ * and one-directional: heat cells, choropleths, a bar chart shaded by size.
+ * Never use it for unordered categories, it invents a ranking.
+ *
+ * The low end sits close to the page ground by design, so a lone low cell has
+ * little contrast against the surface. Give sequential marks a `stroke` of
+ * `var(--nb-c-border)` and a value label, or a legend with numeric bounds.
+ */
+declare const sequentialAt: (t: number) => string;
+/**
+ * A point on the diverging ramp, `t` from 0 (low pole) through 0.5 (the
+ * neutral midpoint) to 1 (high pole).
+ *
+ * Use it only when the midpoint means something: zero, a target, a baseline
+ * being beaten or missed. Map the domain symmetrically around that midpoint,
+ * otherwise the neutral band lands somewhere arbitrary and the chart lies.
+ */
+declare const divergingAt: (t: number) => string;
+/**
+ * `steps` evenly spaced stops of a ramp, for a legend or a binned scale.
+ *
+ * Bin before you shade. Five to seven steps is the most a reader can match
+ * back to a legend swatch; a continuous ramp is for dense fields (thousands of
+ * cells) where individual lookup is not the point.
+ */
+declare const rampSteps: (steps: number, at?: (t: number) => string) => string[];
+export type { TChartMark };
+export { CHART_ROLE_COUNT, DEFAULT_PALETTE, colorAt, chartRole, seriesColors, sequentialAt, divergingAt, rampSteps, };
 //# sourceMappingURL=palette.d.ts.map

package/dist/components/Charts/shared/palette.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../../../src/components/Charts/shared/palette.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,eAAe,EAAE,MAAM,EAS5B,CAAA;AAED,QAAA,MAAM,OAAO,GAAI,OAAO,MAAM,EAAE,UAAS,MAAM,EAAoB,KAAG,MACrC,CAAA;AAEjC,OAAO,EAAE,eAAe,EAAE,OAAO,EAAE,CAAA"}
+{"version":3,"file":"palette.d.ts","sourceRoot":"","sources":["../../../../src/components/Charts/shared/palette.ts"],"names":[],"mappings":"AA2BA,0DAA0D;AAC1D,QAAA,MAAM,gBAAgB,IAAI,CAAA;AAE1B;;;;;;;GAOG;AACH,QAAA,MAAM,eAAe,EAAE,MAAM,EAS5B,CAAA;AAED;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,OAAO,GACX,OAAO,MAAM,EACb,UAAS,MAAM,EAAoB,KAClC,MAIF,CAAA;AAED,+EAA+E;AAC/E,QAAA,MAAM,SAAS,GAAI,MAAM,MAAM,KAAG,MACyD,CAAA;AAE3F,iFAAiF;AACjF,KAAK,UAAU,GAAG,MAAM,GAAG,MAAM,CAAA;AA2BjC;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,YAAY,GAChB,OAAO,MAAM,EACb,UAAS;IAAE,IAAI,CAAC,EAAE,UAAU,CAAA;CAAO,KAClC,MAAM,EAKR,CAAA;AAaD;;;;;;;;;;GAUG;AACH,QAAA,MAAM,YAAY,GAAI,GAAG,MAAM,KAAG,MAC8C,CAAA;AAEhF;;;;;;;GAOG;AACH,QAAA,MAAM,WAAW,GAAI,GAAG,MAAM,KAAG,MAahC,CAAA;AAED;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,GACb,OAAO,MAAM,EACb,KAAI,CAAC,CAAC,EAAE,MAAM,KAAK,MAAqB,KACvC,MAAM,EAKR,CAAA;AAED,YAAY,EAAE,UAAU,EAAE,CAAA;AAC1B,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,OAAO,EACP,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,SAAS,GACV,CAAA"}

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

@@ -1 +1 @@
-{"version":3,"file":"CommandPalette.vue.d.ts","sourceRoot":"","sources":["../../src/components/CommandPalette.vue"],"names":[],"mappings":"AAghBA,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,oBAAoB,CAAA;AA4c3B,QAAA,MAAM,YAAY;;;;6EAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}
+{"version":3,"file":"CommandPalette.vue.d.ts","sourceRoot":"","sources":["../../src/components/CommandPalette.vue"],"names":[],"mappings":"AAshBA,OAAO,KAAK,EACV,oBAAoB,EAGrB,MAAM,oBAAoB,CAAA;AAkd3B,QAAA,MAAM,YAAY;;;;6EAGhB,CAAC;wBACkB,OAAO,YAAY;AAAxC,wBAAyC"}

package/dist/components/Confirm.d.ts

@@ -0,0 +1,199 @@
+import type { VNodeChild } from 'vue'
+import type { TModalSize } from './Modal.d'
+
+/**
+ * How hard the dialog leans on the user.
+ *
+ * `danger` is the default because the audited fleet's confirmations are
+ * overwhelmingly destructive: deleting an environment and its content,
+ * regenerating a client secret, clearing local storage, deleting someone
+ * else's comment. Making the safe tone the default would mean every
+ * destructive call site has to remember to opt in, which is exactly the
+ * decision this component exists to remove.
+ *
+ * `neutral` is for a consequential but non-destructive commit (publishing,
+ * inviting, transferring ownership): same button order, same focus rules, a
+ * primary confirm instead of a red one.
+ *
+ * It also decides the ARIA role: `danger` renders `role="alertdialog"`
+ * (an interruption, whose description is announced on entry), `neutral`
+ * renders `role="dialog"`.
+ */
+type TConfirmTone = 'danger' | 'neutral'
+
+interface IConfirmProps {
+  /** Whether the dialog is on screen. `useConfirm()` drives this for you. */
+  open?: boolean
+  /**
+   * The question, phrased as the action. "Delete environment", not
+   * "Are you sure?". The title is the only line a hurried user reads.
+   */
+  title: string
+  /**
+   * What happens when they confirm, in one sentence. State the consequence
+   * and its reach ("Every entry, release and API key in it is deleted"),
+   * not the mechanics.
+   */
+  message?: string
+  /**
+   * The name of the exact record being acted on, rendered verbatim in its own
+   * strip. This is the difference between "delete this environment?" and
+   * "delete `production`?", and it is the single cheapest defence against a
+   * confirmed mistake.
+   */
+  subject?: string
+  /** What kind of thing `subject` is: "Environment", "Client", "Comment". */
+  subjectLabel?: string
+  /**
+   * The confirm verb. Name the action ("Delete environment", "Regenerate
+   * secret"), never "OK" or "Yes": the fleet uses Save, Done, Apply and
+   * Create interchangeably, and a naked "Yes" makes the user re-read the
+   * title to find out what they are agreeing to.
+   */
+  confirmLabel?: string
+  /** The exit label. "Cancel" unless you are localising it. */
+  cancelLabel?: string
+  /** Destructive (`danger`, the default) or consequential (`neutral`). */
+  tone?: TConfirmTone
+  /**
+   * Arms a type-to-confirm gate: the confirm button stays disabled until the
+   * user types this string exactly (leading and trailing whitespace ignored,
+   * case sensitive). Reserve it for actions whose blast radius is bigger than
+   * the thing being clicked: an environment and all its content, a production
+   * secret, a tenant. Usually the same value as `subject`.
+   */
+  typeToConfirm?: string
+  /**
+   * Overrides the gate's field label. Defaults to
+   * `Type <typeToConfirm> to confirm`. Supply your own for i18n.
+   */
+  typeToConfirmLabel?: string
+  /** Helper text under the gate field. */
+  typeToConfirmHelper?: string
+  /**
+   * Pending state: the confirm button spins, both buttons and the gate field
+   * lock, and Escape, the overlay and the close button stop dismissing. An
+   * action that has already been fired cannot be un-fired by closing the
+   * dialog, so the dialog refuses to lie about it.
+   */
+  busy?: boolean
+  /**
+   * The text of the pending line. It sits in a `role="status"` region that is
+   * deliberately OUTSIDE the element `aria-describedby` points at: an
+   * alertdialog announces its description on entry, and text inserted into
+   * that same subtree a moment later is at the mercy of how the screen reader
+   * merges the two. Kept separate, the pending line is an ordinary polite
+   * update to a region that was empty, which is a case assistive technology
+   * handles the same way everywhere.
+   */
+  busyLabel?: string
+  /**
+   * The finished beat: the work succeeded and the dialog is about to close.
+   * Both buttons and the gate stay locked, and nothing dismisses, because the
+   * question has already been answered. `useConfirm()` sets this for you, and
+   * only when `successLabel` is supplied.
+   */
+  succeeded?: boolean
+  /**
+   * The line shown while `succeeded`. Leave it unset and there is no finished
+   * beat at all: the dialog closes the moment the work returns. Set it
+   * ("Environment deleted") when the action is slow enough that a dialog
+   * vanishing on its own reads as a glitch rather than a result.
+   */
+  successLabel?: string
+  /**
+   * Failure text from the last attempt. Shown in the body; the dialog stays
+   * open so the user can retry or cancel with the error still visible.
+   */
+  error?: string
+  /** Dialog size, forwarded to NbModal. `sm` unless the body is unusually long. */
+  size?: TModalSize
+  /**
+   * Extra selectors for popups that teleport out of the dialog and must not
+   * be treated as "outside" it by the focus trap or by Escape. Our own
+   * overlays are known already; this is for a third-party combobox whose
+   * markup you cannot annotate with `[data-nb-confirm-floating]`.
+   *
+   * Use `registerConfirmFloatingSelector()` instead when the exemption
+   * applies to every dialog in the application rather than this one.
+   */
+  floatingSelectors?: string[]
+  /**
+   * A class on the dialog's content region (the message, the subject strip,
+   * the gate and the status line). The component's root is NbModal, which
+   * teleports to `<body>`, so attribute fallthrough reaches nothing a
+   * consumer can style: this is the hook that does.
+   *
+   * It is also the practical way to scope the `--nb-confirm-*` custom
+   * properties, which are otherwise set on `:root` because a teleported node
+   * inherits from `<body>` and not from the component that asked for it.
+   */
+  contentClass?: string
+}
+
+/**
+ * What `confirm()` accepts. Same shape as the component, minus the three
+ * props the composable owns (`open`, `busy`, `error`), plus the work itself.
+ */
+interface IConfirmOptions extends Omit<
+  IConfirmProps,
+  'open' | 'busy' | 'error' | 'succeeded'
+> {
+  /**
+   * The action to run when the user confirms. While the returned promise is
+   * pending the dialog is locked, so the user cannot fire it twice; the
+   * promise returned by `confirm()` resolves `true` only after it settles.
+   *
+   * If it rejects, the dialog stays open with the failure shown and nothing
+   * resolves yet: the user retries or cancels (which resolves `false`).
+   * Omit it and `confirm()` resolves as soon as the button is pressed.
+   */
+  onConfirm?: () => unknown | Promise<unknown>
+  /**
+   * Body content as a render function, for the cases `message` cannot carry:
+   * a list of the things about to be deleted, a link to what will break, a
+   * count that needs emphasis. It fills the component's default slot.
+   *
+   * ```ts
+   * confirm({
+   *   title: 'Delete environment',
+   *   body: () => h('ul', items.map((i) => h('li', i.name))),
+   * })
+   * ```
+   *
+   * It renders inside the dialog's own Vue app, which is not your
+   * application's: it has no router, no i18n and no provides. Resolve
+   * anything you need from those before calling `confirm()` and close over
+   * the result. Plain text belongs in `message`.
+   */
+  body?: () => VNodeChild
+  /**
+   * Turns a rejection from `onConfirm` into the text shown in the dialog.
+   * Defaults to the error's `message`, falling back to `String(error)`.
+   */
+  formatError?: (error: unknown) => string
+  /**
+   * How long, in milliseconds, `onConfirm` is given to settle before the
+   * dialog treats it as failed and shows `timeoutMessage`.
+   *
+   * A promise that never settles is the one state this dialog cannot recover
+   * from on its own: cancel, confirm, the gate and the close control are all
+   * locked while the work is in flight, precisely so nobody can fire a second
+   * DELETE, which means a hung request leaves a dialog that cannot be
+   * dismissed by any means. A timeout turns that into an error the user can
+   * read, retry or cancel out of.
+   *
+   * It does not abort the work: nothing here can cancel a request it did not
+   * make. The dialog stops waiting; the request may still land. Pass your own
+   * AbortSignal inside `onConfirm` if the call has to be stopped too.
+   *
+   * Unset by default, because a long-running action that is genuinely
+   * expected to take minutes should not be declared failed by a library
+   * guess. Set it wherever the call has a service-level expectation.
+   */
+  timeout?: number
+  /** The failure text used when `timeout` elapses. */
+  timeoutMessage?: string
+}
+
+export type { IConfirmProps, IConfirmOptions, TConfirmTone }

package/dist/components/Confirm.env.d.ts

@@ -0,0 +1,52 @@
+/**
+ * The two facts about NbConfirm's surroundings that are not the component:
+ * how long its exit takes, and which teleported popups count as being inside
+ * it. Both are shared between NbConfirm and `useConfirm()`, and both used to
+ * be duplicated in the two files with nothing keeping them in step.
+ */
+/**
+ * How long the dialog takes to leave, in milliseconds.
+ *
+ * This is not a reading of NbModal's stylesheet. NbModal declares its own
+ * `0.2s` transition, and an earlier version of this file copied that number
+ * by hand into the queue's delay, which meant editing the SCSS silently
+ * desynchronised the queue: the next question appeared before the last one
+ * had faded, or the dialog sat blank waiting for a transition that had
+ * already finished.
+ *
+ * So NbConfirm stopped reading the number and started writing it.
+ * `applyConfirmMotion` puts this duration on the overlay and the dialog box
+ * as an inline `transition-duration`, which wins over the stylesheet, so the
+ * animation the user sees and the delay the queue waits are the same value by
+ * construction. Change it here and both move together.
+ */
+export declare const CONFIRM_LEAVE_MS = 200;
+/**
+ * Teaches every NbConfirm about a popup that teleports out of the dialog and
+ * cannot carry `[data-nb-confirm-floating]` itself, which is the usual case
+ * for a third-party combobox or date picker whose markup you do not own.
+ *
+ * ```ts
+ * registerConfirmFloatingSelector('.tomselect-dropdown')
+ * ```
+ *
+ * Call it once at application start. It is additive and idempotent; use the
+ * `floatingSelectors` prop instead when only one dialog needs the exemption.
+ * Returns a function that removes the selector again, for a plugin that has
+ * to clean up after itself.
+ */
+export declare function registerConfirmFloatingSelector(selector: string): () => void;
+/** Every selector currently treated as "still inside the dialog". */
+export declare function floatingSelector(extra?: readonly string[]): string;
+/**
+ * Writes the exit duration onto the nodes NbModal animates.
+ *
+ * Under `prefers-reduced-motion` the duration is zero rather than
+ * `transition: none`, for two reasons. It is a value, so flipping the
+ * preference back mid-session restores the animation instead of leaving a
+ * dead `none` on a recycled node. And it is the same property the queue
+ * reads, so a user with reduced motion gets the shorter queue delay too
+ * rather than waiting out an animation that never ran.
+ */
+export declare function applyConfirmMotion(dialog: HTMLElement | null, reduced: boolean): void;
+//# sourceMappingURL=Confirm.env.d.ts.map

package/dist/components/Confirm.env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Confirm.env.d.ts","sourceRoot":"","sources":["../../src/components/Confirm.env.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAA;AAoBnC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,+BAA+B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,IAAI,CAO5E;AAED,qEAAqE;AACrE,wBAAgB,gBAAgB,CAAC,KAAK,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,CAKtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,WAAW,GAAG,IAAI,EAC1B,OAAO,EAAE,OAAO,GACf,IAAI,CAON"}

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

@@ -0,0 +1,61 @@
+import type { IConfirmProps } from './Confirm.d';
+/**
+ * Whether this dialog is the last aria-modal surface in the document, which
+ * for teleported overlays is the one painted on top.
+ *
+ * Without this test, two NbConfirms open at once (two components rendered
+ * from route or store state, which is a supported way to use this) both
+ * answer one Escape, and the older instance answers first: the user cancels
+ * a question they cannot see while the one in front of them stays put.
+ */
+declare function isTopmost(): boolean;
+/**
+ * Hands focus back to whatever opened the dialog. Called on close and again
+ * on unmount, because `dismissConfirms()` destroys the host outright and a
+ * close that is never rendered has no transition to hang a restore on. Losing
+ * this drops a keyboard user at the top of the document.
+ */
+declare function restoreFocus(): void;
+declare var __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<IConfirmProps, {
+    focusCancel: () => void | undefined;
+    restoreFocus: typeof restoreFocus;
+    isTopmost: typeof isTopmost;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    cancel: () => any;
+    confirm: () => any;
+}, string, import("vue").PublicProps, Readonly<IConfirmProps> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    onConfirm?: (() => any) | undefined;
+}>, {
+    size: import("./Modal").TModalSize;
+    error: string;
+    message: string;
+    open: boolean;
+    busy: boolean;
+    subject: string;
+    subjectLabel: string;
+    confirmLabel: string;
+    cancelLabel: string;
+    tone: import("./Confirm.d").TConfirmTone;
+    typeToConfirm: string;
+    typeToConfirmLabel: string;
+    typeToConfirmHelper: string;
+    busyLabel: string;
+    succeeded: boolean;
+    successLabel: string;
+    floatingSelectors: string[];
+    contentClass: string;
+}, {}, {}, {}, 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=Confirm.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Confirm.vue.d.ts","sourceRoot":"","sources":["../../src/components/Confirm.vue"],"names":[],"mappings":"AAmuBA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAkHhD;;;;;;;;GAQG;AACH,iBAAS,SAAS,IAAI,OAAO,CAK5B;AAsFD;;;;;GAKG;AACH,iBAAS,YAAY,SAIpB;AA8iBD,QAAA,IAAI,QAAQ,IAAiC,CAAE;AAC/C,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAShD,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/DatePicker.vue.d.ts

@@ -37,13 +37,13 @@ declare const __VLS_base: import("vue").DefineComponent<IDatePickerProps, {
     locale: string;
     helper: string;
     placeholder: string;
+    readonly: boolean;
     endValue: string | null;
     endPlaceholder: string;
     endLabel: string;
     endError: string;
     endWarning: string;
     disabledDates: string[] | ((date: string) => boolean);
-    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/InlineLoading.d.ts

@@ -0,0 +1,37 @@
+import { IDefaultProps } from '../types/Props.d'
+
+/**
+ * The four states a single action moves through. `inactive` is not "hidden":
+ * the component still renders its (empty) live region so that assistive tech
+ * is watching the node before the first update lands in it.
+ */
+enum EInlineLoadingStatus {
+  Inactive = 'inactive',
+  Active = 'active',
+  Finished = 'finished',
+  Error = 'error',
+}
+
+interface IInlineLoadingProps extends IDefaultProps {
+  /** Current state of the action. */
+  status?: `${EInlineLoadingStatus}`
+  /** Text shown while `status` is `active`. Present tense: "Saving". */
+  label?: string
+  /** Text shown while `status` is `finished`. Past tense: "Saved". */
+  finishedLabel?: string
+  /** Text shown while `status` is `error`. Say what failed, not "Error". */
+  errorLabel?: string
+  /**
+   * Milliseconds the finished state stays on screen before `success` is
+   * emitted. Below roughly 1000 the confirmation is gone before it is read.
+   */
+  dwell?: number
+  /**
+   * Reserves horizontal space for the longest of the three labels so the
+   * controls beside it do not jump when the text changes. Turn off when the
+   * component is the last thing in its row and nothing can be pushed.
+   */
+  reserveSpace?: boolean
+}
+
+export { EInlineLoadingStatus, IInlineLoadingProps }

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

@@ -0,0 +1,30 @@
+import { EInlineLoadingStatus, IInlineLoadingProps } from './InlineLoading.d';
+declare var __VLS_11: {
+    status: "error" | "active" | "inactive" | "finished";
+    text: string;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_11) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<IInlineLoadingProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    success: () => any;
+}, string, import("vue").PublicProps, Readonly<IInlineLoadingProps> & Readonly<{
+    onSuccess?: (() => any) | undefined;
+}>, {
+    label: string;
+    id: string;
+    status: `${EInlineLoadingStatus}`;
+    finishedLabel: string;
+    errorLabel: string;
+    dwell: number;
+    reserveSpace: 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=InlineLoading.vue.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"InlineLoading.vue.d.ts","sourceRoot":"","sources":["../../src/components/InlineLoading.vue"],"names":[],"mappings":"AA+KA,OAAO,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AA4L7E,QAAA,IAAI,QAAQ;;;CAAY,CAAE;AAC1B,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAKhD,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/MenuItem.vue.d.ts

@@ -16,8 +16,8 @@ declare const __VLS_base: import("vue").DefineComponent<IMenuItemProps, {
     icon: string;
     selected: boolean;
     shortcut: string;
-    selectable: boolean;
     danger: boolean;
+    selectable: boolean;
     radioGroup: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/components/Modal.d.ts

@@ -15,11 +15,45 @@ import { ESizeShort } from '../types/Size.d'
  */
 type TModalSize = `${ESizeShort}` | 'xl' | 'immersive'
 
+/** `dialog` for a place the user chose to go, `alertdialog` for an interruption. */
+type TModalRole = 'dialog' | 'alertdialog'
+
 interface IModalProps {
   open?: boolean
   title?: string
   size?: TModalSize
   closeOnOverlay?: boolean
+  /**
+   * ARIA role for the dialog box. `alertdialog` is for a surface that
+   * interrupts to report a condition or ask for a decision that cannot wait
+   * (NbConfirm's destructive tone uses it); screen readers announce its
+   * description on entry rather than waiting to be asked.
+   */
+  role?: TModalRole
+  /**
+   * Id of the element that names the dialog. Defaults to the built-in title
+   * when `title` or the header slot is used, so the common case needs nothing.
+   * Pass your own when the accessible name lives inside the header slot.
+   */
+  labelledBy?: string
+  /** Id of the element that describes the dialog, usually its body. */
+  describedBy?: string
+  /**
+   * Marks the dialog `aria-busy` while work it started is in flight.
+   */
+  busy?: boolean
+  /**
+   * Disables the header close control. A dialog that has fired something
+   * irreversible must not offer a control that pretends to undo it, and a
+   * live button that does nothing is worse than a visibly unavailable one.
+   */
+  closeDisabled?: boolean
+  /**
+   * Whether Escape emits `close`. Escape is answered only by the topmost
+   * open dialog either way, so a modal underneath keeps its state; set this
+   * to `false` when a wrapper (NbConfirm) answers the key itself.
+   */
+  closeOnEscape?: boolean
 }
 
-export { IModalProps, TModalSize }
+export { IModalProps, TModalSize, TModalRole }

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

@@ -7,15 +7,24 @@ type __VLS_Slots = {} & {
 } & {
     footer?: (props: typeof __VLS_28) => any;
 };
-declare const __VLS_base: import("vue").DefineComponent<IModalProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+declare const __VLS_base: import("vue").DefineComponent<IModalProps, {
+    dialogEl: () => HTMLElement | null;
+    bodyEl: () => HTMLElement | null;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     close: () => any;
 }, string, import("vue").PublicProps, Readonly<IModalProps> & Readonly<{
     onClose?: (() => any) | undefined;
 }>, {
     size: import("./Modal.d").TModalSize;
     title: string;
+    role: import("./Modal.d").TModalRole;
     open: boolean;
     closeOnOverlay: boolean;
+    labelledBy: string;
+    describedBy: string;
+    busy: boolean;
+    closeDisabled: boolean;
+    closeOnEscape: 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/Modal.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Modal.vue.d.ts","sourceRoot":"","sources":["../../src/components/Modal.vue"],"names":[],"mappings":"AA0PA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAuM5C,QAAA,IAAI,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAY,CAAE;AACpE,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC5C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAK/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"}
+{"version":3,"file":"Modal.vue.d.ts","sourceRoot":"","sources":["../../src/components/Modal.vue"],"names":[],"mappings":"AAsZA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAkV5C,QAAA,IAAI,QAAQ,IAAW,EAAE,QAAQ,IAAW,EAAE,QAAQ,IAAY,CAAE;AACpE,KAAK,WAAW,GAAG,EAAE,GACnB;IAAE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC5C;IAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,GAC7C;IAAE,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,QAAQ,KAAK,GAAG,CAAA;CAAE,CAAC;AAQ/C,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"}