bitboss-ui 3.0.0-beta.63 → 3.0.0-beta.65

package/dist/components/BbSelectPopover/knownItems.d.ts

@@ -20,6 +20,11 @@ export type KnownItemsSource = {
      * outside the list (a field chip's ×), so the open list keeps their pins.
      */
     userUnpick?: (values: unknown[]) => void;
+    /**
+     * Set by the popover: whether a row is a known row, for `BbSelect`'s chip
+     * slot `known` (Q77.7).
+     */
+    isKnown?: (row: unknown) => boolean;
 };
 export declare const provideKnownItems: (source: KnownItemsSource | null) => void;
 export declare const useKnownItems: () => KnownItemsSource | null;

package/dist/components/BbSelectPopover/types.d.ts

@@ -10,6 +10,32 @@ export type BbSelectKnownItem = {
     value: unknown;
     label: string;
 };
+/** What `known-items` takes. */
+export type BbSelectKnownItems = Array<BbSelectKnownItem | null | undefined>;
+/**
+ * The row an option or chip slot gets, told apart by `known` (Q77.7). On a
+ * select that binds `known-items`, a known row stands in as `item` until the
+ * list brings the real one: `{ value, label }`, whatever the options' shape.
+ * Without `known-items` the row is always the option. `BbSelectSlotRow<Row>`
+ * alone is the bound case: what a helper taking a slot's `{ item, known }`
+ * is typed with.
+ */
+export type BbSelectSlotRow<Item, Known extends BbSelectKnownItems | undefined = BbSelectKnownItems> = [Known] extends [undefined] ? {
+    /** Always `false` here: this select binds no `known-items`. */
+    known: false;
+    /** The raw item from the `items` prop. */
+    item: Item;
+} : {
+    /** A known row (`known-items`): the list has not brought this value's own row yet. */
+    known: true;
+    /** The known row, `{ value, label }`; read `text` for what it shows. */
+    item: BbSelectKnownItem;
+} | {
+    /** The list's own row. */
+    known: false;
+    /** The raw item from the `items` prop. */
+    item: Item;
+};
 /**
  * A selected option as resolved by the select family and exposed through slot
  * props (`selectedOptions`): the raw source `item` plus its resolved display
@@ -84,16 +110,16 @@ export declare const BB_SELECT_POPOVER_PT: {
     readonly parts: readonly ["root", "panel", "sheet", "input", "clear", "list", "option", "itemText", "itemIcon", "itemDescription", "header", "footer"];
     readonly states: readonly ["selected", "disabled", "open"];
 };
-export type BbSelectPopoverProps<Item> = {
+export type BbSelectPopoverProps<Item, Known extends BbSelectKnownItems | undefined = BbSelectKnownItems> = {
     [K in `pt:${BbSelectPopoverSurfacePtPart}` | `pt:${BbSelectPopoverPtPart}:${BbSelectPopoverPtState}`]?: PtValue;
 } & {
-    [K in `pt:${BbSelectPopoverOptionPtPart}`]?: PtValue | ((ctx: PtItemCtx<PtNoInfer<Item>, BbSelectPopoverPtState>) => PtItemResult);
+    [K in `pt:${BbSelectPopoverOptionPtPart}`]?: PtValue | ((ctx: PtItemCtx<PtNoInfer<Item>, BbSelectPopoverPtState, never, BbSelectSlotRow<PtNoInfer<Item>, PtNoInfer<Known>>>) => PtItemResult);
 } & {
     /**
      * Passthrough, object form: the same keys as the `pt:*` attributes
      * without the prefix. See the `pt:<part>` row.
      */
-    pt?: PtItemMap<BbSelectPopoverPtPart, BbSelectPopoverOptionPtPart, BbSelectPopoverPtState, PtNoInfer<Item>>;
+    pt?: PtItemMap<BbSelectPopoverPtPart, BbSelectPopoverOptionPtPart, BbSelectPopoverPtState, PtNoInfer<Item>, never, BbSelectSlotRow<PtNoInfer<Item>, PtNoInfer<Known>>>;
     /**
      * External activator element or component ref.
      * When provided, the activator slot is not rendered and event listeners
@@ -269,11 +295,11 @@ export type BbSelectPopoverProps<Item> = {
     /**
      * `{ value, label }` rows naming the value the app already holds, whatever
      * the options' shape: the activator's `text` with no request until the
-     * first open (`prefill: true` still loads). Not options; the options'
-     * accessors never run on them; slots get the row as `item` until the list
+     * first open (`prefill: true` still loads). Not options: accessors never
+     * run on them; slots get one as `item`, `known: true`, until the list
      * brings its own.
      */
-    knownItems?: Array<BbSelectKnownItem | null | undefined>;
+    knownItems?: [Known] extends [undefined] ? BbSelectKnownItems : Known;
     /**
      * Display the loading state styles.
      */
@@ -465,15 +491,13 @@ export type BbSelectPopoverActivatorSlotProps = {
     toggle: () => Promise<void>;
 };
 /** Props exposed by the `option` slot. */
-export type BbSelectPopoverOptionSlotProps<Item> = {
+export type BbSelectPopoverOptionSlotProps<Item, Known extends BbSelectKnownItems | undefined = undefined> = BbSelectSlotRow<Item, Known> & {
     /** Whether this option is disabled. */
     disabled: boolean;
     /** Whether this option currently has keyboard focus. */
     focused: boolean;
     /** Zero-based index of this option in the list. */
     index: number;
-    /** The raw item from the `items` prop. */
-    item: Item;
     /** Whether items are still being fetched. */
     loading: boolean;
     /** Whether this option is currently selected. */
@@ -513,8 +537,15 @@ export type BbSelectPopoverPanelSlotProps = {
     query: string;
     /** The resolved options that are currently selected. */
     selectedOptions: BbSelectResolvedOption[];
+    /**
+     * Bind it as the `id` of a heading in `#header`: on the phone sheet the
+     * dialog is labelled by it (`aria-labelledby`); on the desktop panel the
+     * listbox keeps the trigger's name, and the id is there so one markup
+     * serves both.
+     */
+    titleId: string;
 };
-export type BbSelectPopoverSlots<Item> = {
+export type BbSelectPopoverSlots<Item, Known extends BbSelectKnownItems | undefined = undefined> = {
     /**
      * Replaces the default trigger element that opens the select popover.
      */
@@ -552,7 +583,10 @@ export type BbSelectPopoverSlots<Item> = {
         error: unknown;
     }) => any;
     /**
-     * Replaces the default rendering of each option row in the dropdown.
+     * Replaces the default rendering of each option row in the dropdown. With
+     * `known-items` bound, a row the list has not brought yet is the known
+     * `{ value, label }` row, `known: true`: check `known` before reading an
+     * option field off `item`.
      */
-    option?: (props: BbSelectPopoverOptionSlotProps<Item>) => any;
+    option?: (props: BbSelectPopoverOptionSlotProps<Item, Known>) => any;
 };

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

@@ -3,8 +3,8 @@ export type { BbSmoothHeightProps, BbSmoothHeightSlots };
 type __VLS_Slots = BbSmoothHeightSlots;
 declare const __VLS_base: import('vue').DefineComponent<BbSmoothHeightProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BbSmoothHeightProps> & Readonly<{}>, {
     disabled: boolean;
-    transitionDuration: number;
     tag: import('../../types/CommonProps').LayoutTag;
+    transitionDuration: number;
     strategy: "resize" | "mutation";
     mutationOptions: MutationObserverInit;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/components/BbSwitchGroup/BbSwitchGroup.vue_vue_type_script_setup_true_lang.js

@@ -110,7 +110,6 @@ var A = /*@__PURE__*/ b({
 		"pt:icon": {},
 		"pt:label": {},
 		"pt:itemDescription": {},
-		pt: {},
 		autofocus: {},
 		compact: { type: Boolean },
 		dependencies: {},
@@ -163,7 +162,8 @@ var A = /*@__PURE__*/ b({
 		validationLabel: {},
 		rules: {},
 		validationMode: {},
-		formless: { type: Boolean }
+		formless: { type: Boolean },
+		pt: {}
 	},
 	emits: [
 		"blur",

package/dist/components/BbSwitchGroup/types.d.ts

@@ -1,15 +1,25 @@
 import { BbCheckboxIconSlotProps } from '../BbCheckbox/types';
-import { BbCheckboxGroupEvents, BbCheckboxGroupProps } from '../BbCheckboxGroup/types';
+import { BbCheckboxGroupBaseProps, BbCheckboxGroupEvents } from '../BbCheckboxGroup/types';
+import { GroupPtMap, PtNoInfer } from '../../types/passthrough';
 import { CommonFieldAsteriskSlotProps } from '../CommonField/types';
-/** `BbSwitchGroup` shares `BbCheckboxGroup`'s passthrough vocabulary (its props are the same type). */
+/**
+ * `BbSwitchGroup`'s passthrough vocabulary: BbCheckboxGroup's, without the
+ * `variant` indicator (BbTabs' looks are the checkbox group's alone).
+ */
 export declare const BB_SWITCH_GROUP_PT: {
     readonly parts: readonly ["root", "legend", "description", "message", "hint", "list", "item", "icon", "label", "itemDescription"];
     readonly states: readonly ["hasValue", "checked", "readonly", "disabled", "warnings", "errors", "focused", "focusVisible", "loading"];
     readonly rowParts: readonly ["item", "icon", "label", "itemDescription"];
     readonly rowStates: readonly ["checked", "focused", "focusVisible"];
 };
-/** Re-export of BbCheckboxGroupProps for the switch-group variant. */
-export type BbSwitchGroupProps<T = any> = BbCheckboxGroupProps<T>;
+/** BbCheckboxGroup's props without its `variant` (and the `indicator` part). */
+export type BbSwitchGroupProps<T = any> = BbCheckboxGroupBaseProps<T> & {
+    /**
+     * Passthrough, object form: the same keys as the `pt:*` attributes
+     * without the prefix. See the `pt:<part>` row.
+     */
+    pt?: GroupPtMap<PtNoInfer<T>>;
+};
 /** Re-export for consumers importing events type from BbSwitchGroup. */
 export type BbSwitchGroupEvents = BbCheckboxGroupEvents;
 /** Props exposed by the `description` slot. */

package/dist/components/BbSwitchGroup/types.js

@@ -1,5 +1,10 @@
-import { BB_CHECKBOX_GROUP_PT as e } from "../BbCheckboxGroup/types.js";
+import { GROUP_PT_PARTS as e, GROUP_PT_STATES as t, GROUP_ROW_PT_PARTS as n, GROUP_ROW_PT_STATES as r } from "../../types/passthrough.js";
 //#region src/components/BbSwitchGroup/types.ts
-var t = e;
+var i = {
+	parts: e,
+	states: t,
+	rowParts: n,
+	rowStates: r
+};
 //#endregion
-export { t as BB_SWITCH_GROUP_PT };
+export { i as BB_SWITCH_GROUP_PT };