bitboss-ui 3.0.0-beta.47 → 3.0.0-beta.49

package/dist/components/BbNumberInput/warroom/harness.d.ts

@@ -0,0 +1,217 @@
+import { Affix } from './oracle';
+/**
+ * CDP (IME composition, media emulation) exists on Chromium only; tests that
+ * need it skip on Firefox / WebKit with `it.skipIf(!isChromium)`.
+ */
+export declare const isChromium: boolean;
+type Send = <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>;
+/** vitest's CDPSession type is empty; the session speaks plain CDP. */
+export declare const send: Send;
+export type FieldState = {
+    /** What the visible input shows. */
+    display: string;
+    /** Caret / selection in the visible input. */
+    caret: [number, number];
+    /** The last `update:modelValue` payload (`undefined`: none yet). */
+    model: unknown;
+    /** Every `update:modelValue` payload so far, in order. */
+    emits: unknown[];
+    /** The value a native POST carries (the named input's value), if any. */
+    posted: string | null;
+    /** What the step was, for the trace. */
+    step: string;
+};
+export type Field = {
+    el: HTMLInputElement;
+    host: HTMLElement;
+    emits: unknown[];
+    /** Writes the model from the outside (a parent `v-model` write). */
+    setModel: (value: number | null) => Promise<void>;
+    state: (step?: string) => FieldState;
+    unmount: () => void;
+    /** Every event the input received, for the trace (type + inputType / key). */
+    events: string[];
+    /** What it was mounted with (the shell helpers read the affix from it). */
+    locale: string;
+    props: Record<string, unknown>;
+};
+/**
+ * Mounts a BbNumberInput in `locale` (a built-in locale key), inside a
+ * `<form>` so the posted value and form restore can be read. Extra props go
+ * straight to the component (`disableFormatting`, `minPrecision`, `max`, …).
+ */
+export declare const mountNumber: ({ locale, modelValue, name, props, }?: {
+    locale?: string;
+    modelValue?: number | null;
+    name?: string;
+    props?: Record<string, unknown>;
+}) => Promise<Field>;
+/** Lets the component's own `nextTick` / rAF work settle. */
+export declare const settle: () => Promise<void>;
+/** Puts the caret (or a selection) in the visible input. */
+export declare const select: (f: Field, start: number, end?: number) => Promise<FieldState>;
+/** Real keystrokes, one at a time; the trace has a state after each key. */
+export declare const typeKeys: (f: Field, text: string) => Promise<FieldState[]>;
+/** One named key, real (`Backspace`, `Delete`, `ArrowLeft`, `Enter`, `Home`). */
+export declare const press: (f: Field, key: string) => Promise<FieldState>;
+/** Real Undo / Redo shortcuts (the browser's own stack). */
+export declare const undo: (f: Field) => Promise<FieldState>;
+export declare const redo: (f: Field) => Promise<FieldState>;
+/**
+ * Real clipboard round trip: the text goes onto the SYSTEM clipboard through
+ * a scratch textarea and a real Copy, then a real Paste into the field (at
+ * its current caret / selection). What the component reads is exactly what a
+ * user's paste delivers.
+ */
+export declare const pasteReal: (f: Field, text: string) => Promise<FieldState>;
+/**
+ * Runs a real copy / cut / paste with the clipboard to itself: files and
+ * engines run side by side and share it (src/dev/clipboardLockCommand.ts).
+ */
+export declare const withClipboard: <T>(run: () => Promise<T>) => Promise<T>;
+/**
+ * A synthetic `paste` with the given `text/plain` (and optional
+ * `text/html`), for shapes the system clipboard would normalise (it may turn
+ * U+202F into a space on some platforms). Cancelable, as a real one is. If
+ * nobody cancels it, nothing is inserted (a synthetic paste has no default
+ * action): that alone is a finding for an engine that relies on the default.
+ */
+export declare const pasteEvent: (f: Field, text: string, html?: string) => Promise<FieldState>;
+/** A synthetic text drop onto the field (dragstart/dragover elided). */
+export declare const drop: (f: Field, text: string) => Promise<FieldState>;
+/**
+ * Real IME composition through CDP: each entry of `steps` is the
+ * composition string as the IME shows it (`imeSetComposition`), then
+ * `commit` is inserted (`insertText` ends the composition), the way a
+ * Japanese / Chinese / Korean IME produces full-width digits.
+ */
+export declare const imeCompose: (f: Field, steps: string[], commit: string) => Promise<FieldState[]>;
+/**
+ * Android (Gboard and most soft keyboards): `keydown` arrives as
+ * `key: "Unidentified"`, keyCode 229, and the edit comes through
+ * `beforeinput` / `input`. Ordinary digit taps send a CANCELABLE
+ * `insertText` beforeinput (the default here); suggestions and composing
+ * keyboards send non-cancelable `insertCompositionText`. When nobody
+ * cancels the beforeinput, the text is applied at the caret the way the
+ * browser would, then `input` fires — a faithful stand-in, since headless
+ * Chromium cannot emit a 229 keydown itself.
+ */
+export declare const android229: (f: Field, text: string, { inputType, cancelable, }?: {
+    inputType?: string;
+    cancelable?: boolean;
+}) => Promise<FieldState>;
+/**
+ * A keyboard suggestion replacing the whole word (Android autocorrect):
+ * non-cancelable `insertReplacementText`, `data` null, the value swapped.
+ */
+export declare const androidReplaceAll: (f: Field, next: string) => Promise<FieldState>;
+/**
+ * Form restore (back / forward, bfcache, session restore): the browser
+ * writes the painted text back into the input with NO input event, then
+ * fires `pageshow` (`persisted: true` for bfcache). Chrome and Firefox do
+ * this even with `autocomplete="off"` (WHATWG html#9019). `focus: true`
+ * also focuses the field afterwards, the other reconcile point.
+ */
+export declare const restore: (f: Field, text: string, { persisted, focus }?: {
+    persisted?: boolean | undefined;
+    focus?: boolean | undefined;
+}) => Promise<FieldState>;
+/**
+ * Autofill. Chrome's autofill writes the value and fires `input` (no
+ * `inputType`) and `change`; some password managers write silently.
+ * `mode: 'events'` is Chrome's shape, `'silent'` the managers'.
+ */
+export declare const autofill: (f: Field, text: string, { mode }?: {
+    mode?: "silent" | "events" | undefined;
+}) => Promise<FieldState>;
+/** Real blur: focus moves to a sibling button the harness adds. */
+export declare const blur: (f: Field) => Promise<FieldState>;
+/** Native submit: the FormData the browser would POST for the field. */
+export declare const formData: (f: Field) => FormData;
+/** Emulate `prefers-reduced-motion`, a narrow viewport or a locale's fonts: undo with `resetEmulation`. */
+export declare const emulateMedia: (features: Array<{
+    name: string;
+    value: string;
+}>) => Promise<unknown>;
+export declare const resetEmulation: () => Promise<unknown>;
+/** Select all with the platform's real shortcut (Ctrl+A on macOS moves to the line start instead). */
+export declare const selectAll: (f: Field) => Promise<FieldState>;
+/**
+ * The line-start / line-end keys as the platform has them: `Home` / `End`,
+ * and on macOS also Cmd+Left / Cmd+Right (a mac Home key scrolls, it does
+ * not move the caret). `which: 'both'` presses both, a state after each.
+ */
+export declare const lineEdge: (f: Field, edge: "start" | "end", which?: "home-end" | "platform") => Promise<FieldState>;
+/**
+ * The x of display offset `offset` inside the input, relative to its border
+ * box, measured on a hidden mirror with the input's computed text styles (so
+ * proportional fonts, NBSP / U+202F widths and `text-align` all count) minus
+ * the input's own horizontal scroll. `offset` = a caret boundary; `onChar` =
+ * the middle of the character AT `offset` instead.
+ */
+export declare const offsetX: (f: Field, offset: number, onChar?: boolean) => number;
+/**
+ * A REAL click (pointer down / up, the browser places the caret) at display
+ * offset `offset`: on the caret boundary before that character, or with
+ * `{ onChar: true }` on the middle of the character itself (a click ON `$`,
+ * on the NBSP, on `€`). `shift: true` extends the current selection to that
+ * point, the way a Shift+click (or the end of a drag) does.
+ */
+export declare const clickAt: (f: Field, offset: number, { onChar, shift }?: {
+    onChar?: boolean | undefined;
+    shift?: boolean | undefined;
+}) => Promise<FieldState>;
+/** A double click on the character at `offset` (word selection). */
+export declare const doubleClickAt: (f: Field, offset: number) => Promise<FieldState>;
+/**
+ * The display split into the field's SHELL (prefix / suffix: symbol, unit,
+ * literals, bidi, the painted minus) and the numeric HOLE, against the shell
+ * the spec says this value should wear (oracle `shellOf`, from this engine's
+ * own `Intl`, plural form and sign of `value` included). `value` defaults to
+ * the last model; `fractionDigits` to the digits the hole shows. `ok: false`
+ * means the display does not wear the expected shell. For a field with no
+ * affix the whole display is the hole.
+ */
+export declare const readShell: (f: Field, { value, fractionDigits }?: {
+    value?: number;
+    fractionDigits?: number;
+}) => {
+    shell: import('./oracle').Shell | null;
+    ok: boolean;
+    prefix: string;
+    hole: string;
+    suffix: string;
+};
+/** The affix props the field was mounted with (`currency` wins), or `null`. */
+export declare const affixOf: (f: Field) => Affix | null;
+/**
+ * The accessibility facts a lane checks: `aria-valuetext` (set only at rest),
+ * `aria-valuenow`, the role, focus, and the spoken NAME the at-rest text
+ * should contain for an affixed field (oracle `spokenNameOf`).
+ */
+export declare const aria: (f: Field) => {
+    role: string | null;
+    valuetext: string | null;
+    valuenow: string | null;
+    focused: boolean;
+    spokenName: string | null;
+};
+/**
+ * A synthetic drop at display `offset` (the point is put on that caret
+ * boundary, so the engine reads it from `caretPositionFromPoint`); the end
+ * of the field when `offset` is past it. Returns the event too, to check it
+ * was cancelled.
+ */
+export declare const dropAt: (f: Field, offset: number, text: string) => Promise<{
+    event: DragEvent;
+    state: FieldState;
+}>;
+/**
+ * A REAL mouse drag from display offset `from` to `to` (each on the middle
+ * of that character with `onChar`, else on the caret boundary), through
+ * the `pointerDrag` command (vitest.warroom.config.ts). Playwright only.
+ */
+export declare const dragSelect: (f: Field, from: number, to: number, { onChar }?: {
+    onChar?: boolean | undefined;
+}) => Promise<FieldState>;
+export {};

package/dist/components/BbNumberInput/warroom/oracle.d.ts

@@ -0,0 +1,150 @@
+/**
+ * Built-in locale key → Intl tag (the table `intlLocaleOf` reads: `en` is
+ * en-US, `nl` nl-NL). Anything else is used as a tag as-is, so engine-level
+ * rows can name tags no dictionary ships (`lt`, `ar-EG`, `hi-IN`).
+ */
+export declare const intlTag: (locale: string) => string;
+export type LocaleShape = {
+    group: string;
+    decimal: string;
+    /** Integer group sizes from the right: [primary, secondary]. */
+    primary: number;
+    secondary: number;
+};
+export declare const shapeOf: (locale: string) => LocaleShape;
+/**
+ * Character-level normalisation every path shares (§ 2.13, GROK 4 / 7):
+ * NFKC, script digits to ASCII, minus look-alikes to `-`, bidi marks gone.
+ */
+export declare const normaliseChars: (text: string) => string;
+/**
+ * ASSUME_TRIM: a clipboard copied from a spreadsheet cell carries a trailing
+ * newline / tab, from a PDF surrounding spaces. The legality check runs on the
+ * text trimmed of ASCII whitespace at both ends (otherwise `1.234\n` from a de
+ * spreadsheet would read 1.234 through Q51.2).
+ */
+export declare const ASSUME_TRIM = true;
+/**
+ * Is `text` a number formatted the locale's way? Group marks only at legal
+ * positions (lakh sizes included), one decimal mark, an optional leading `-`.
+ * ASSUME_POSITIONS: legality is about POSITIONS only — `1.234` is legal in
+ * `it` although `useGrouping: "auto"` would print `1234` there.
+ */
+export declare const isLocaleShaped: (text: string, locale: string) => boolean;
+/** Strict locale read: group marks out, the decimal mark becomes `.`. */
+export declare const strictParse: (text: string, locale: string) => number | null;
+/**
+ * Q51.2 on a fragment — today's `replaceCommaWithPeriod` +
+ * `removeUnwantedSymbols` + `defaultPad`, after the shared char normalisation.
+ */
+export declare const q51Parse: (text: string) => number | null;
+export type PastePath = 'strict' | 'q51.2' | 'scientific';
+/**
+ * Owner round 5 (BRIEF.md § Owner answers, round 5), all yes:
+ * CURRENCY_STRIP — one currency sign (`\p{Sc}`) or percent / per-mille sign
+ * at either end goes before the legality check (`$1,000` → 1000);
+ * PARENS_NEGATIVE — `(1,234.56)` is −1234.56; SCIENTIFIC — `1.2E+05` is
+ * 120000. ASSUME_TRIM, ASSUME_POSITIONS and LENGTH_CAP were ruled as encoded.
+ * Letters that name a currency (`Ft`, `kr.`, `CHF`) are not signs: only a
+ * currency field's own shell strips them (`pasteIntoAffixed`).
+ */
+export declare const CURRENCY_STRIP = true;
+export declare const PARENS_NEGATIVE = true;
+export declare const SCIENTIFIC = true;
+/** What a paste into an EMPTY field of `locale` should leave in the model. */
+export declare const pasteInto: (clipboard: string, locale: string) => {
+    value: number | null;
+    path: PastePath;
+};
+/**
+ * The field's affix props. `currency` wins when both are set (GROK-CURRENCY
+ * "Maintainer"); `unit` is an `Intl` unit (`percent` is a unit here, NOT
+ * `style: 'percent'`: the model is the number shown).
+ */
+export type Affix = {
+    currency?: string;
+    unit?: string;
+};
+/** The `Intl` options a field's affix stands for (`null`: no affix). */
+export declare const affixOptions: (affix: Affix, spoken?: boolean) => Intl.NumberFormatOptions | null;
+export type Shell = {
+    prefix: string;
+    suffix: string;
+};
+/**
+ * The shell a field shows around `value` (GROK-CURRENCY § 5 + INGEST): the
+ * parts before and after the hole, the `minusSign` part painted as ASCII `-`,
+ * literals and bidi marks kept as `Intl` gives them. The value decides it, not
+ * only the sign: unit plurals (`el` κιλό / κιλά, `en-GB` hr / hrs) follow the
+ * number as shown, so `fractionDigits` is the count of fraction digits the
+ * display paints. `null` for no affix, or a code `Intl` refuses (`RangeError`:
+ * the field paints a plain number).
+ */
+export declare const shellOf: (locale: string, affix: Affix, value: number, fractionDigits?: number) => Shell | null;
+/** The part types of a shell, for assertions that hold across ICU builds. */
+export declare const shellTypesOf: (locale: string, affix: Affix, value: number) => {
+    prefix: string[];
+    suffix: string[];
+} | null;
+/** A display split into shell and hole; `ok: false` when the shell is not the expected one. */
+export declare const splitDisplay: (display: string, shell: Shell | null) => {
+    ok: boolean;
+    prefix: string;
+    hole: string;
+    suffix: string;
+};
+/**
+ * The currency's own fraction digits (`resolvedOptions()`, never a table):
+ * JPY 0, EUR 2, KWD 3, CLF 4. `null` for a refused code. A unit has none.
+ */
+export declare const currencyDigitsOf: (locale: string, currency: string) => {
+    min: number;
+    max: number;
+} | null;
+/**
+ * The at-rest `aria-valuetext` of an affixed field: the spoken NAME form
+ * (`currencyDisplay: 'name'`, `unitDisplay: 'long'`) of the value with the
+ * fraction digits the display paints. Assert `toContain` the name part, not
+ * equality, unless the test pins one engine.
+ */
+export declare const spokenNameOf: (locale: string, affix: Affix, value: number) => string | null;
+/**
+ * Every shell the field can paint, both signs, every plural form, comparable
+ * text, longest first (so `US$` is tried before `$`).
+ */
+export declare const shellsOf: (locale: string, affix: Affix) => {
+    prefix: string;
+    suffix: string;
+    negative: boolean;
+}[];
+/**
+ * Paste into an EMPTY currency / unit field (GROK-CURRENCY § 2 Paste + § 5
+ * Read-back): strip THIS field's shells first (both signs, every plural form,
+ * space-like literals equal, both yen glyphs), then the round-5 sign strip,
+ * then strict-or-Q51.2. A shell is removed as a whole token (`kr.` never eats
+ * the da group dot). A negative shell's minus survives the strip.
+ */
+export declare const pasteIntoAffixed: (clipboard: string, locale: string, affix: Affix) => {
+    value: number | null;
+    path: PastePath;
+    shell: boolean;
+};
+/**
+ * FOREIGN_UNIT (coordinator 2026-10-07): in a currency / unit field, a
+ * foreign symbol made of letters at either end goes like a foreign currency
+ * sign, with no conversion: `1,234 lb` into kilogram reads 1234, `12,50 CHF`
+ * into EUR 12.5, `US$12` into EUR 12. A plain field keeps the round-5 rule
+ * (only `\p{Sc}` / `%` signs strip). The token starts with a letter or `°`
+ * and may hold letters, marks, `.`, `/`, `²`, `³` (`km/h`, `m²`, `kr.`).
+ */
+export declare const FOREIGN_UNIT = true;
+/**
+ * A field with 0 fraction digits (`maxPrecision` 0, JPY / KRW by default):
+ * lane `currency` DECISION 19:32 — a typed decimal mark stays in raw (`12,`
+ * shows), the digits after it are refused, blur drops the mark: typed `12,5`
+ * is 12, never 125. A paste truncates (`12,5` → 12): `maxPrecision` never
+ * rounds (ZERO_DIGIT_PASTE, coordinator 2026-10-07: truncate, over
+ * GROK-CURRENCY-INGEST item 3's 13).
+ */
+export declare const ZERO_DIGIT_PASTE: "truncate" | "round";
+export declare const capFraction: (value: number | null, maxPrecision: number) => number | null;

package/dist/components/BbPagination/BbPagination.vue_vue_type_script_setup_true_lang.js

@@ -3,9 +3,9 @@ import { usePassthrough as t } from "../../composables/usePassthrough.js";
 import { useBbTableContext as n, useBbTableContextHasHost as r, useBbTableContextPageIsSet as i } from "../../composables/useBbTableContext.js";
 import { removedPropsFor as ee } from "../../deprecation/removedProps.js";
 import { warnRemovedAttrs as a } from "../../utilities/functions/warnRemovedAttrs.js";
-import { useFrameworkDetection as o } from "../../composables/useFrameworkDetection.js";
-import s from "../BbBaseButton/BbBaseButton.vue.js";
-import { useLocale as c } from "../../composables/useLocale.js";
+import { useLocale as o } from "../../composables/useLocale.js";
+import { useFrameworkDetection as s } from "../../composables/useFrameworkDetection.js";
+import c from "../BbBaseButton/BbBaseButton.vue.js";
 import { useRoute as te } from "../../composables/useRoute.js";
 import { parseCount as l, parsePositiveInteger as u } from "../../utilities/functions/parsePaginationNumber.js";
 import { BB_PAGINATION_PT as d } from "./types.js";
@@ -55,7 +55,7 @@ var se = ["aria-label"], ce = { class: "bb-pagination__page-label bb-sr-only" },
 			active: { disabled: () => !!P.disabled }
 		});
 		process.env.NODE_ENV !== "production" && a("BbPagination", ee("BbPagination"));
-		let { t: I } = c(), L = te(), R = re(), { isInertia: z } = o(), B = n(() => P.tableId), V = i(() => P.tableId);
+		let { t: I } = o(), L = te(), R = re(), { isInertia: z } = s(), B = n(() => P.tableId), V = i(() => P.tableId);
 		r(() => P.tableId), e();
 		let H = m(() => {
 			let e = l(P.totalItems);
@@ -229,7 +229,7 @@ var se = ["aria-label"], ce = { class: "bb-pagination__page-label bb-sr-only" },
 			ref: q,
 			class: "bb-pagination__pages"
 		}, [
-			g("li", null, [_(D(s), S(y(pe.value)), {
+			g("li", null, [_(D(c), S(y(pe.value)), {
 				default: j(() => [T(e.$slots, "previous", {}, () => [g("span", ce, E(D(I)("pagination.previous").value), 1), (C(), h("svg", x({
 					class: "bb-pagination__icon",
 					viewBox: "0 0 24 24",
@@ -245,7 +245,7 @@ var se = ["aria-label"], ce = { class: "bb-pagination__page-label bb-sr-only" },
 				"aria-hidden": "true",
 				class: "bb-pagination__ellipsis bb-pagination__page bb-pagination__page--ellipsis",
 				ref_for: !0
-			}, D(F).ellipsis), [T(e.$slots, "ellipsis", {}, () => [g("span", le, E(P.ellipsis), 1)])], 16)) : (C(), ne(D(s), x({
+			}, D(F).ellipsis), [T(e.$slots, "ellipsis", {}, () => [g("span", le, E(P.ellipsis), 1)])], 16)) : (C(), ne(D(c), x({
 				key: 1,
 				ref_for: !0
 			}, me(t)), {
@@ -256,7 +256,7 @@ var se = ["aria-label"], ce = { class: "bb-pagination__page-label bb-sr-only" },
 				}, () => [g("span", M, E(t.page), 1)])]),
 				_: 2
 			}, 1040))]))), 128)),
-			g("li", null, [_(D(s), S(y(he.value)), {
+			g("li", null, [_(D(c), S(y(he.value)), {
 				default: j(() => [T(e.$slots, "next", {}, () => [g("span", N, E(D(I)("pagination.next").value), 1), (C(), h("svg", x({
 					class: "bb-pagination__icon",
 					viewBox: "0 0 24 24",

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

@@ -33,6 +33,7 @@ declare const __VLS_base: import('vue').DefineComponent<__VLS_PublicProps, {}, {
     transitionDuration: number;
     trigger: PopoverTrigger | PopoverTrigger[];
     scrollable: boolean;
+    modal: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;