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

package/scripts/lib/validate-bb-markup.mjs

@@ -21,6 +21,8 @@ import {
 } from './items-provider-context.mjs';
 import { reactiveVModelFindings } from './reactive-v-model.mjs';
 import { textNullValueFindings } from './text-null-value.mjs';
+import { redundantItemAccessorFindings } from './redundant-item-accessor.mjs';
+import { renamedItemFieldFindings } from './renamed-item-field.mjs';
 import { unimportedFindings } from './unimported-components.mjs';
 import {
 	classRenamesFrom,
@@ -472,7 +474,7 @@ const INTENT_ALIASES = {
  * may well be doing something today — a native listener reaching the root
  * element — but is outside the component's contract. It is the flag a caller
  * uses to report at a lower severity; see `checkEvent`.
- * @typedef {{ component: string, attr: string, line?: number, kind: 'unknown-prop' | 'unknown-component' | 'unknown-model' | 'removed-prop' | 'unknown-slot' | 'unknown-event' | 'object-items-without-text' | string, message: string, hint?: string, fallthrough?: boolean }} Finding
+ * @typedef {{ component: string, attr: string, line?: number, kind: 'unknown-prop' | 'unknown-component' | 'unknown-model' | 'removed-prop' | 'unknown-slot' | 'unknown-event' | 'object-items-without-text' | 'redundant-item-accessor' | string, message: string, hint?: string, fallthrough?: boolean }} Finding
  */
 
 /**
@@ -872,6 +874,15 @@ export function validateVueSnippet(code, manifest, options = {}) {
 			findings.splice(i, 1);
 	}
 	findings.push(...formModel);
+	// Q60.24: an accessor that names the default field (`item-text="label"`).
+	findings.push(
+		...redundantItemAccessorFindings(code, { templateAst: ast, arrays })
+	);
+	// Q64.2–Q64.5: an item field spelled the old way (`{ key, text }` rows,
+	// a group's `key`, a tab's or crumb's `key`).
+	findings.push(
+		...renamedItemFieldFindings(code, { templateAst: ast, arrays })
+	);
 	// Q43.9: positional `items` providers and single-cause `reason` checks.
 	findings.push(...itemsProviderFindings(code, options.providerBindings));
 	findings.push(...wrapperDropsPropFindings(code, manifest, aliases));
@@ -1498,7 +1509,9 @@ export function createComponentChecker(surface, options = {}) {
 		r.surface !== 'slot' &&
 		r.surface !== 'event' &&
 		r.surface !== 'method' &&
-		r.surface !== 'option';
+		r.surface !== 'option' &&
+		// An item field (Q64.2) is `renamed-item-field`'s, never an attribute.
+		r.surface !== 'item';
 	// A removed or renamed EVENT (Q56.28): `checkEvent` reads these.
 	const removedEvents = new Map(
 		(surface.removed ?? [])
@@ -2379,25 +2392,37 @@ const resolveArray = (node, arrays) => {
 	return null;
 };
 
-const hasObjectElement = (array) =>
-	array.elements.some(
-		(el) => unwrapTsExpression(el)?.type === 'ObjectExpression'
-	);
+/**
+ * Q60.24: an object item the option default chain cannot label — no `label`
+ * and no `text` key. A spread may bring either, so it is never judged.
+ */
+const hasUnlabelledObjectElement = (array) =>
+	array.elements.some((el) => {
+		const item = unwrapTsExpression(el);
+		return (
+			item?.type === 'ObjectExpression' &&
+			!item.properties.some((p) => p.type === 'SpreadElement') &&
+			!objectKeyNode(item, 'label') &&
+			!objectKeyNode(item, 'text')
+		);
+	});
 
 const GROUP_ITEMS_HINT =
-	"add `itemText` to the group (e.g. `itemText: 'label'`), and `itemValue` (e.g. `itemValue: 'value'`) — without `itemValue` the whole object is the value";
+	'hand-written rows are labelled by `label`: give each row one, or make it a mapped group (an `items` getter, or `itemText` / `itemValue` naming the fields your data holds), which reads `label` / `text` and `value` by default';
 
 const OBJECT_ITEMS_HINT =
-	'set `item-text` to the field holding the label (e.g. `item-text="label"`), and `item-value` to the field holding the value (e.g. `item-value="value"`) — without `item-value` the whole object is the value';
+	'`{ label, value }` and `{ text, value }` items work as they are (text: `label`, else `text`; value: `value`, else the whole object). Any other shape needs `item-text` (the field holding the label) and `item-value` (the field holding the value)';
 
 /**
- * Q53.3 (owner ruling 2026-09-24): OBJECT items with no `item-text` render
- * `JSON.stringify(item)` as each label, and with no `item-value` the whole
- * object is the value — so `{ label, value }` items read as blank or JSON.
- * Flags every item-driven control (any component whose API has `itemText`),
+ * Q53.3 (owner ruling 2026-09-24), narrowed by Q60.24 (2026-10-07): with no
+ * `item-text` an option reads its own `label`, else its own `text`, else
+ * `JSON.stringify(item)`; with no `item-value`, its own `value`, else the
+ * whole object. So only OBJECT items with neither `label` nor `text` render as
+ * JSON. Flags every item-driven control (any component whose API has `itemText`),
  * and each BbDropdown group (`group: true`) with no `itemText` whose object
- * rows have no `text` (hand-written rows are labelled by `text`, so those
- * render blank). `item-text` set without `item-value` is a
+ * rows have neither `label` nor `text` (hand-written rows are labelled by
+ * `label`, so those render blank; a `text` row is `renamed-item-field`'s).
+ * `item-text` set without `item-value` is a
  * deliberate whole-object value and is not flagged; string items are fine.
  *
  * Reach: only arrays visible in the same file — an inline `:items="[…]"`, or
@@ -2436,12 +2461,14 @@ export function checkObjectItemsWithoutText(name, surface, node, arrays) {
 					: null;
 				if (!childArray) continue;
 				// A literal group with no mapper renders hand-written rows by their
-				// `text`; a `{ label, value }` row there has no label at all.
+				// `label`; a row with neither `label` nor `text` (the old spelling,
+				// reported as `renamed-item-field`) has no label at all.
 				const unlabelledRow = childArray.elements.some((raw) => {
 					const row = unwrapTsExpression(raw);
 					return (
 						row?.type === 'ObjectExpression' &&
 						!row.properties.some((p) => p.type === 'SpreadElement') &&
+						!objectKeyNode(row, 'label') &&
 						!objectKeyNode(row, 'text')
 					);
 				});
@@ -2450,15 +2477,13 @@ export function checkObjectItemsWithoutText(name, surface, node, arrays) {
 					!objectKeyNode(entry, 'itemText') &&
 					unlabelledRow
 				) {
-					const key = objectKeyNode(entry, 'key')?.value;
+					const id = objectKeyNode(entry, 'id')?.value;
 					const label =
-						key?.type === 'StringLiteral'
-							? `group \`${key.value}\``
-							: 'a group';
+						id?.type === 'StringLiteral' ? `group \`${id.value}\`` : 'a group';
 					findings.push({
 						kind: 'object-items-without-text',
 						attr: 'items',
-						message: `${label} on BbDropdown has object \`items\` with no \`text\` and the group has no \`itemText\` — those rows render without a label.`,
+						message: `${label} on BbDropdown has object \`items\` with no \`label\` and the group has no \`itemText\` — those rows render without a label.`,
 						hint: GROUP_ITEMS_HINT,
 					});
 				}
@@ -2472,12 +2497,12 @@ export function checkObjectItemsWithoutText(name, surface, node, arrays) {
 	if (!(surface.props ?? []).some((p) => toCamel(p.name) === 'itemText'))
 		return [];
 	if (compilerHasProp(node, 'itemText')) return [];
-	if (!hasObjectElement(items)) return [];
+	if (!hasUnlabelledObjectElement(items)) return [];
 	return [
 		{
 			kind: 'object-items-without-text',
 			attr: 'items',
-			message: `${name}'s \`items\` are objects but \`item-text\` is not set — each option's label is \`JSON.stringify(item)\`.`,
+			message: `${name}'s \`items\` include objects with neither \`label\` nor \`text\` and \`item-text\` is not set — those options' label is \`JSON.stringify(item)\`.`,
 			hint: OBJECT_ITEMS_HINT,
 		},
 	];
@@ -2787,12 +2812,45 @@ export function checkComputedSlotRenames(name, surface, node) {
  * same-file literal (`scriptSetupArrayConsts`, Q53.14).
  */
 export const RESERVED_KEY_SOURCES = {
-	BbTable: { prop: 'columns', noun: 'column key' },
-	BbTabs: { prop: 'items', noun: 'tab key' },
-	BbTabsList: { prop: 'items', noun: 'tab key' },
-	BbBreadcrumbs: { prop: 'items', noun: 'item key' },
-	BbDropdown: { prop: 'items', noun: 'item key', nested: true },
-	BbDropdownButton: { prop: 'items', noun: 'item key', nested: true },
+	BbTable: { prop: 'columns', field: 'key', noun: 'column key' },
+	BbTabs: { prop: 'items', field: 'value', noun: 'tab value' },
+	BbTabsList: { prop: 'items', field: 'value', noun: 'tab value' },
+	BbBreadcrumbs: { prop: 'items', field: 'value', noun: 'crumb value' },
+	// Rows are named by `value`, groups by `id` (`#<groupId>:item`).
+	BbDropdown: {
+		prop: 'items',
+		field: 'value',
+		noun: 'row value',
+		nested: true,
+	},
+	BbDropdownButton: {
+		prop: 'items',
+		field: 'value',
+		noun: 'row value',
+		nested: true,
+	},
+};
+
+/** The field the identity was spelled in before 3.0.0-beta.49 (Q64.2–Q64.5). */
+const OLD_IDENTITY_FIELD = 'key';
+
+/**
+ * The identity a slot is named after, as written: a dropdown group's `id`,
+ * any other entry's `field` (a stale `key` still counts, so a slot check
+ * agrees with the rename `renamed-item-field` asks for).
+ */
+const identityOf = (source, element) => {
+	const entry = unwrapTsExpression(element);
+	const isGroup =
+		source.nested &&
+		entry?.type === 'ObjectExpression' &&
+		(objectKeyNode(entry, 'group') ||
+			objectKeyNode(entry, 'selectable') ||
+			objectKeyNode(entry, 'multiple'));
+	const field = isGroup ? 'id' : source.field;
+	const now = literalKeyOf(element, field);
+	if (now !== null || field === OLD_IDENTITY_FIELD) return now;
+	return literalKeyOf(element, OLD_IDENTITY_FIELD);
 };
 
 /**
@@ -2861,18 +2919,19 @@ export function checkReservedKeys(name, surface, node, arrays) {
 	const findings = [];
 	const walk = (array) => {
 		for (const element of array.elements) {
-			const key = literalKeyOf(element, 'key');
+			const key = identityOf(source, element);
 			if (key !== null) {
 				const slot = reserved.get(runtimeSlotKey(key));
+				const word = source.field;
 				if (slot)
 					findings.push({
 						kind: 'reserved-key',
 						attr: source.prop,
-						message: `${source.noun} \`${key}\` collides with ${name}'s \`#${slot}\` slot; rename the key`,
+						message: `${source.noun} \`${key}\` collides with ${name}'s \`#${slot}\` slot; rename the ${word}`,
 						hint:
 							slot === 'actions' && name === 'BbTable'
 								? 'the #actions slot already creates the actions column — drop this column, or rename its key (e.g. `rowActions`)'
-								: `a key whose slot name is \`${runtimeSlotKey(key)}\` can never have its own slot: pick another key`,
+								: `a ${word} whose slot name is \`${runtimeSlotKey(key)}\` can never have its own slot: pick another ${word}`,
 					});
 			}
 			const entry = unwrapTsExpression(element);
@@ -2937,7 +2996,7 @@ export function keyedSlotLookup(name, surface, propSource, arrays) {
 	);
 	const walk = (array) => {
 		for (const element of array.elements) {
-			const key = literalKeyOf(element, 'key');
+			const key = identityOf(source, element);
 			if (key === null) complete = false;
 			else keys.push(key);
 			const entry = unwrapTsExpression(element);
@@ -2964,7 +3023,7 @@ export function keyedSlotLookup(name, surface, propSource, arrays) {
 	);
 	const expected = new Map();
 	const legacy = new Map();
-	const noun = source.noun.replace(/ key$/, '');
+	const noun = source.noun.replace(/ (key|value)$/, '');
 	for (const key of keys)
 		for (const { head, tail } of patterns) {
 			const now = `${head}${slotKey(key)}${tail}`;
@@ -3049,7 +3108,7 @@ export function keyedSlotLookup(name, surface, propSource, arrays) {
 				return {
 					attr: `#${slot}`,
 					kind: 'unknown-slot',
-					message: `slot \`#${slot}\` matches no ${noun} key and no slot of this ${name}, so it renders nothing${nearest ? ` — the nearest is \`#${nearest.candidate}\`${expected.has(nearest.candidate) ? ` (${noun} \`${expected.get(nearest.candidate)}\`)` : ''}` : ''}.`,
+					message: `slot \`#${slot}\` matches no ${source.noun} and no slot of this ${name}, so it renders nothing${nearest ? ` — the nearest is \`#${nearest.candidate}\`${expected.has(nearest.candidate) ? ` (${noun} \`${expected.get(nearest.candidate)}\`)` : ''}` : ''}.`,
 				};
 			}
 		}
@@ -3105,11 +3164,13 @@ export function squashedSlotWarning(name, surface, slot) {
  * Q53.17 (owner ruling 2026-09-24; doctrine: identifiers something outside the
  * component reads are written, never derived). On BbDropdown items `check` can
  * see (an inline array or a same-file literal, Q53.14):
- * - a row in a `selectable` group needs a `key` (the v-model holds it);
- * - a `selectable` group needs a `key` (its picks are stored under it);
- * - two keyless rows with the same text in ONE group are an error (their
- *   derived identity would collide; across groups it is legal).
- * A keyless action row, a layout-only group and a keyless crumb are fine.
+ * - a row in a `selectable` group needs a `value` (the v-model holds it);
+ * - a `selectable` group needs an `id` (its picks are stored under it);
+ * - two rows with no `value` and the same `label` in ONE group are an error
+ *   (their derived identity would collide; across groups it is legal).
+ * An action row without a `value`, a layout-only group and a crumb without a
+ * `value` are fine. (Before 3.0.0-beta.49 the kinds were `missing-key` and
+ * `duplicate-row-text`; the old fields themselves are `renamed-item-field`.)
  * @param {string} name
  * @param {{ props?: Array<Record<string, any>> }} node compiler-sfc element
  * @param {Map<string, any>} arrays
@@ -3171,7 +3232,8 @@ export function checkDropdownKeys(name, node, arrays) {
 		if (value.type === 'BooleanLiteral') return value.value;
 		return null; // bound to something `check` can't read
 	};
-	const hasKey = (object) => objectKeyNode(object, 'key') != null;
+	const hasValue = (object) => objectKeyNode(object, 'value') != null;
+	const hasId = (object) => objectKeyNode(object, 'id') != null;
 	const isSelectable = (object) => {
 		const node = objectKeyNode(object, 'selectable');
 		return (
@@ -3194,37 +3256,42 @@ export function checkDropdownKeys(name, node, arrays) {
 			const children = objectKeyNode(entry, 'items');
 			const childArray = children ? resolveArray(children.value, arrays) : null;
 			if (isGroup) {
-				const groupKey = literal(entry, 'key');
-				if (isSelectable(entry) && !hasKey(entry))
+				const groupId = literal(entry, 'id');
+				// A group still spelling `key` is `renamed-item-field`'s.
+				if (
+					isSelectable(entry) &&
+					!hasId(entry) &&
+					!objectKeyNode(entry, 'key')
+				)
 					findings.push({
-						kind: 'missing-key',
+						kind: 'missing-id',
 						attr: 'items',
-						message: `a selectable group on ${name} has no \`key\` — its picks are stored under it, so it is required (a keyless group renders as a plain group)`,
+						message: `a selectable group on ${name} has no \`id\` — its picks are stored under it, so it is required (a group without an \`id\` renders as a plain group)`,
 					});
 				if (childArray)
 					scope(
 						childArray,
-						isSelectable(entry) && hasKey(entry),
-						groupKey ? `group \`${groupKey}\`` : 'a group'
+						isSelectable(entry) && hasId(entry),
+						groupId ? `group \`${groupId}\`` : 'a group'
 					);
 				continue;
 			}
-			if (!hasKey(entry)) {
+			if (!hasValue(entry) && !objectKeyNode(entry, 'key')) {
 				if (selectable)
 					findings.push({
-						kind: 'missing-key',
+						kind: 'missing-value',
 						attr: 'items',
-						message: `a row in ${groupName} (selectable) on ${name} has no \`key\` — the v-model holds it, so it is required (a keyless row renders but can't be selected)`,
+						message: `a row in ${groupName} (selectable) on ${name} has no \`value\` — the v-model holds it, so it is required (a row without a \`value\` renders disabled)`,
 					});
-				const text = literal(entry, 'text');
-				if (typeof text === 'string') {
-					if (seen.has(text))
+				const label = literal(entry, 'label');
+				if (typeof label === 'string') {
+					if (seen.has(label))
 						findings.push({
-							kind: 'duplicate-row-text',
+							kind: 'duplicate-row-label',
 							attr: 'items',
-							message: `two keyless rows in ${groupName} on ${name} read \`${text}\` — give them a \`key\` each (identical text is legal across groups, not within one)`,
+							message: `two rows with no \`value\` in ${groupName} on ${name} read \`${label}\` — give each a \`value\` (an identical label is legal across groups, not within one)`,
 						});
-					else seen.set(text, true);
+					else seen.set(label, true);
 				}
 			}
 			// A submenu is its own level.
@@ -3232,7 +3299,7 @@ export function checkDropdownKeys(name, node, arrays) {
 				scope(
 					childArray,
 					false,
-					`the submenu of \`${literal(entry, 'text') ?? 'a row'}\``
+					`the submenu of \`${literal(entry, 'label') ?? 'a row'}\``
 				);
 		}
 	};

package/dist/i18n/index.js

@@ -1,27 +0,0 @@
-//#region src/i18n/index.ts
-var e = [
-	"cs",
-	"da",
-	"de",
-	"el",
-	"en",
-	"es",
-	"fi",
-	"fr",
-	"hu",
-	"it",
-	"ja",
-	"ko",
-	"nb",
-	"nl",
-	"pl",
-	"pt",
-	"ro",
-	"ru",
-	"sv",
-	"tr",
-	"uk",
-	"zh-cn"
-];
-//#endregion
-export { e as BUILTIN_LOCALE_KEYS };