@nubisco/ui 3.2.0 → 3.3.0

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;;iBAgLf,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"}

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