feat(sdui-parser): emit SduiBaseProps from the base-prop list and Omit declared base attributes, as objectui does

Claude-Session: https://claude.ai/code/session_01VDtqoecgES7ScQYGbFVDRv

Author: claude

.changeset/20578-sdui-parser-base-props-one-list.md

@@ -1,7 +1,10 @@
 ---
-'@objectstack/sdui-parser': patch
+'@objectstack/sdui-parser': minor
 ---
 
-The save gate's base-prop list now matches objectui's `SDUI_BASE_PROPS` at the console pin `db11afd4967c` (objectui#11008, #11044). Five keys join the `every-node` set: `bind`, `hidden`, `visibleWhen`, `hiddenOn`, `testId`. Six `BaseSchema` keys become `where-undeclared`: `name`, `label`, `description`, `placeholder`, `data`, `ariaLabel` are accepted without `unknown-prop` on a type whose registration declares no input of that name, and a type that declares one keeps its declared type check.
+`@objectstack/sdui-parser` now reads one base-prop list, ported from objectui's `SDUI_BASE_PROPS` at the console pin `db11afd4967c` (objectui#11008, #11044). Both `validateTree` and the generated JSX types (`generateDts`'s `SduiBaseProps`) are driven by it.
 
-Effect: `os validate` no longer warns `unknown-prop` on those keys where the protocol declares them. Only warnings disappear. No component in the served manifest declares any of the five `every-node` keys, and a declared `where-undeclared` key is still checked exactly as before, so no error-severity diagnostic is removed and no previously-rejected page is newly accepted as an error. The list is module-local here (no export); `codegen.ts` is unchanged.
+- On every node, whatever the component declares: `bind`, `hidden`, `visibleWhen`, `hiddenOn`, `testId` are newly accepted. They no longer draw `unknown-prop`, and the generated types accept them as attributes.
+- Only on a type whose registration declares no input of that name: `name`, `label`, `description`, `placeholder`, `data`, `ariaLabel` are newly accepted. A type that declares one keeps its declared type check and its declared attribute type; its generated interface `Omit`s that key from `SduiBaseProps`.
+
+Effect for consumers: `os validate` stops warning `unknown-prop` on those keys, and a `.tsx` page that authors them now type-checks against `generateDts` output where it was a TypeScript error before. Measured on the tracked `sdui.manifest.json` (107 components), no component declares any of the five every-node keys, and every declared where-undeclared key is checked as before, so no diagnostic of error severity is removed for that manifest. The wider type surface is why this is a minor, not a patch.

packages/sdui-parser/src/__tests__/base-props-one-list.test.ts

@@ -13,7 +13,8 @@
  * the five newly-`every-node` keys, so no declared type check moves.
  */
 import { describe, expect, it } from 'vitest';
-import { manifestFromConfigs, validateTree } from '../index.js';
+import { generateDts, manifestFromConfigs, validateTree } from '../index.js';
+import { SDUI_BASE_PROPS } from '../validate.js';
 import type { Manifest, SchemaElement } from '../types.js';
 
 const manifest: Manifest = manifestFromConfigs([
@@ -26,9 +27,12 @@ const codes = (node: SchemaElement): string[] =>
   validateTree(node, manifest).diagnostics.map((d) => d.code);
 
 const EVERY_NODE = [
-  'type', 'id', 'className', 'style', 'visible', 'visibleWhen', 'visibleOn', 'hidden',
+  'id', 'className', 'style', 'visible', 'visibleWhen', 'visibleOn', 'hidden',
   'hiddenOn', 'disabled', 'disabledOn', 'bind', 'testId', 'children',
 ];
+// `type` is the one `every-node` entry with no attribute form: on a node it
+// IS the tag, so a node cannot carry it without being the component under test.
+// It is pinned through the list below, not through `validateTree`.
 const WHERE_UNDECLARED = ['name', 'label', 'description', 'placeholder', 'data', 'ariaLabel'];
 
 describe('base props — one list, two scopes (objectui#11008, #11044)', () => {
@@ -47,7 +51,34 @@ describe('base props — one list, two scopes (objectui#11008, #11044)', () => {
     expect(validateTree({ type: 'labelled', label: 'ok' } as SchemaElement, manifest).diagnostics).toEqual([]);
   });
 
+  it('the list is the 20 entries, `type` alone having no attribute type', () => {
+    expect(SDUI_BASE_PROPS.map((p) => p.name)).toEqual(['type', ...EVERY_NODE, ...WHERE_UNDECLARED]);
+    expect(SDUI_BASE_PROPS.filter((p) => p.tsType === null).map((p) => p.name)).toEqual(['type']);
+    expect(SDUI_BASE_PROPS.filter((p) => p.scope === 'every-node').map((p) => p.name)).toEqual(['type', ...EVERY_NODE]);
+  });
+
   it('a non-base key is still unknown', () => {
     expect(codes({ type: 'leaf', nonsense: 1 } as SchemaElement)).toEqual(['unknown-prop']);
   });
 });
+
+describe('generateDts — `SduiBaseProps` is emitted from the same list', () => {
+  const dts = generateDts(manifest);
+  const emitted = /export interface SduiBaseProps \{\n([\s\S]*?)\n\}/.exec(dts)?.[1].split('\n') ?? [];
+
+  it('carries every list entry that has an attribute type, in list order, and nothing else', () => {
+    expect(emitted).toEqual(
+      SDUI_BASE_PROPS.filter((p) => p.tsType !== null).map((p) => `  ${p.name}?: ${p.tsType};`),
+    );
+    expect(emitted).toContain('  bind?: string;');
+    expect(emitted).toContain('  hidden?: boolean;');
+  });
+
+  it('a component extends the whole base when it declares no base attribute', () => {
+    expect(dts).toContain('export interface LeafProps extends SduiBaseProps {');
+  });
+
+  it('a component that declares a base attribute Omits exactly that one from the base', () => {
+    expect(dts).toContain('export interface LabelledProps extends Omit<SduiBaseProps, "label"> {\n  label?: string;\n}');
+  });
+});

packages/sdui-parser/src/__tests__/html-tier-manifest.test.ts

@@ -124,7 +124,7 @@ describe('generateDts publishes the html tier into JSX.IntrinsicElements', () =>
     const dts = generateDts(published);
     expect(dts).toContain('"p": PProps;');
     expect(dts).toContain('"a": AProps;');
-    expect(dts).toContain('export interface AProps extends SduiBaseProps {\n  className?: string;\n  href?: string;\n}');
+    expect(dts).toContain('export interface AProps extends Omit<SduiBaseProps, "className"> {\n  className?: string;\n  href?: string;\n}');
     expect(dts).toContain('"flex": FlexProps;');
   });
 });

packages/sdui-parser/src/codegen.ts

@@ -10,6 +10,26 @@
 
 import type { Manifest, ManifestComponent, ManifestInput, ManifestInputType } from './types.js';
 import { inputTypeArms } from './input-type.js';
+import { SDUI_BASE_PROPS } from './validate.js';
+
+/**
+ * `SduiBaseProps`, emitted from {@link SDUI_BASE_PROPS} — the list
+ * `validateTree` reads — so the generated types and the validator cannot
+ * disagree about a base prop (objectui#11044). ⛔ Never a second hand-kept
+ * copy of the list here: that is how this interface came to refuse `bind` and
+ * `hidden` after the validator accepted them.
+ */
+const emitBaseProps = (): string =>
+  `export interface SduiBaseProps {\n${SDUI_BASE_PROPS.filter((prop) => prop.tsType !== null)
+    .map((prop) => `  ${prop.name}?: ${prop.tsType};`)
+    .join('\n')}\n}`;
+
+/**
+ * The attributes `SduiBaseProps` carries — every entry of the list but `type`,
+ * whatever its scope. A declared input of the same name outranks each of them
+ * in the generated types (objectui#11044, objectui#11075).
+ */
+const BASE_ATTRIBUTES = new Set(SDUI_BASE_PROPS.filter((prop) => prop.tsType !== null).map((prop) => prop.name));
 
 export interface CodegenOptions {
   /** include a self-contained minimal JSX namespace so the d.ts type-checks
@@ -38,16 +58,7 @@ export function generateDts(manifest: Manifest, options: CodegenOptions = {}): s
   return `// AUTO-GENERATED by @object-ui/sdui-parser — DO NOT EDIT.
 // Source of truth: ComponentRegistry inputs (ADR-0080 §3). Regenerate via codegen.
 
-export interface SduiBaseProps {
-  id?: string;
-  className?: string;
-  style?: Record<string, unknown>;
-  visible?: boolean;
-  visibleOn?: string;
-  disabled?: boolean;
-  disabledOn?: string;
-  children?: unknown;
-}
+${emitBaseProps()}
 
 ${interfaces}
 
@@ -70,13 +81,31 @@ export {};
  * those arms only (objectui#3832): the old test was `i.type !== 'slot'`, which a
  * union like `['slot', 'string']` would have passed while `tsType` fell through
  * to the default and typed it `string` anyway.
+ *
+ * A base attribute the component declares is `Omit`ted from the base it
+ * extends, whatever its scope: the declared input wins with its type. So a
+ * declared type the base one does not admit is no TS2430 conflict — neither
+ * `label?: string | Record<string, unknown>` on a `'where-undeclared'` member
+ * (objectui#11044) nor `record:alert`'s
+ * `visible?: boolean | string | Record<string, unknown>` on an `'every-node'`
+ * one (objectui#11075) — and one the base admits (`className?: string`) types
+ * the same either way.
+ *
+ * The scope is the VALIDATOR's distinction — `validateTree` skips an
+ * `'every-node'` key before the declared-input lookup — and does not reach this
+ * surface. ⛔ Every declared base attribute is `Omit`ted, not only the ones
+ * whose types conflict: assignability is TypeScript's judgement, and a
+ * conflicts-only rule here would re-derive it from type strings.
+ *
+ * A slot-only input emits no attribute, so a declared `children: 'slot'` is
+ * not `Omit`ted and the base `children` stays.
  */
 function emitInterface(comp: ManifestComponent): string {
-  const lines = comp.inputs
-    .filter((i) => valueArms(i).length > 0)
-    .map((i) => `  ${propLine(i)}`)
-    .join('\n');
-  return `export interface ${propsName(comp.type)} extends SduiBaseProps {\n${lines}\n}`;
+  const emitted = comp.inputs.filter((i) => valueArms(i).length > 0);
+  const lines = emitted.map((i) => `  ${propLine(i)}`).join('\n');
+  const yielded = emitted.filter((i) => BASE_ATTRIBUTES.has(i.name)).map((i) => JSON.stringify(i.name));
+  const base = yielded.length > 0 ? `Omit<SduiBaseProps, ${yielded.join(' | ')}>` : 'SduiBaseProps';
+  return `export interface ${propsName(comp.type)} extends ${base} {\n${lines}\n}`;
 }
 
 /** The arms that describe a VALUE (every arm except `'slot'`). */

packages/sdui-parser/src/validate.ts

@@ -69,10 +69,10 @@ export function acceptsChildren(comp: Pick<ManifestComponent, 'inputs'>): boolea
  *    that name. Where one does, the declared input wins, its `type-mismatch`
  *    check included, and the generated JSX types take the declared type too.
  */
-type SduiBasePropScope = 'every-node' | 'where-undeclared';
+export type SduiBasePropScope = 'every-node' | 'where-undeclared';
 
 /** One entry of {@link SDUI_BASE_PROPS}. */
-interface SduiBaseProp {
+export interface SduiBaseProp {
   /** The `BaseSchema` member (`@object-ui/types`). */
   readonly name: string;
   readonly scope: SduiBasePropScope;
@@ -132,16 +132,16 @@ interface SduiBaseProp {
  *
  * LOCKSTEP: the list, its scopes and the two Sets below are the port of
  * objectui's `SDUI_BASE_PROPS` (objectui#11008, #11044, pin `db11afd4967c`).
- * Unlike objectui's, this copy is module-local and has ONE consumer,
- * {@link validateTree}: objectstack's `codegen.ts` emits no base-props
- * interface, so the "BOTH of its consumers" sentence above describes objectui.
+ * Both consumers are ported too: {@link validateTree} and `codegen.ts`'s
+ * `SduiBaseProps`. The list is exported for `codegen.ts` only; `index.ts` does
+ * not re-export it.
  *
  * `children` IS here: the key is legal on every node, so it never draws
  * `unknown-prop` and its declared `slot` input is never type-checked. Whether
  * a given component RENDERS it is the containment question below, answered by
  * {@link acceptsChildren} from the declared input.
  */
-const SDUI_BASE_PROPS: readonly SduiBaseProp[] = Object.freeze([
+export const SDUI_BASE_PROPS: readonly SduiBaseProp[] = Object.freeze([
   { name: 'type', scope: 'every-node', tsType: null },
   { name: 'id', scope: 'every-node', tsType: 'string' },
   { name: 'className', scope: 'every-node', tsType: 'string' },