@objectstack/sdui-parser 17.2.0 → 17.3.0

package/dist/index.js

@@ -20,9 +20,16 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  CONSUMED_WIDGET_OPTION_KEYS: () => CONSUMED_WIDGET_OPTION_KEYS,
+  DASHBOARD_WIDGET_HOST_TYPES: () => DASHBOARD_WIDGET_HOST_TYPES,
+  MANIFEST_INPUT_TYPES: () => MANIFEST_INPUT_TYPES,
+  UNCONSUMED_WIDGET_OPTION: () => UNCONSUMED_WIDGET_OPTION,
+  canonicalizeInputType: () => canonicalizeInputType,
+  checkDashboardWidgetOptions: () => checkDashboardWidgetOptions,
   compile: () => compile,
   generateBlockList: () => generateBlockList,
   generateDts: () => generateDts,
+  inputTypeArms: () => inputTypeArms,
   interpretBrace: () => interpretBrace,
   manifestFromConfigs: () => manifestFromConfigs,
   parseJsx: () => parseJsx,
@@ -34,6 +41,7 @@ module.exports = __toCommonJS(index_exports);
 // src/parse.ts
 var EVENT_ATTR = /^on[A-Z]/;
 var FORBIDDEN_ATTRS = /* @__PURE__ */ new Set(["dangerouslySetInnerHTML", "ref", "key"]);
+var DISCRIMINATOR_ATTR = "type";
 function parseJsx(source, options = {}) {
   return new Parser(source, options).parseDocument();
 }
@@ -80,7 +88,7 @@ var Parser = class {
       if (c === "" || c === ">" || c === "/") break;
       const attr = this.parseAttr(start, tag);
       if (!attr) break;
-      props[attr.name] = attr.value;
+      if (!attr.drop) props[attr.name] = attr.value;
     }
     this.skipWs();
     let children;
@@ -91,7 +99,7 @@ var Parser = class {
     } else {
       this.error("unterminated-open-tag", `Unterminated <${tag}> open tag`, start, tag);
     }
-    const node = { type: tag, ...props };
+    const node = { ...props, type: tag };
     if (children && children.length) node.children = children;
     return node;
   }
@@ -108,6 +116,15 @@ var Parser = class {
       this.skipWs();
       value = this.parseAttrValue(tag);
     }
+    if (name === DISCRIMINATOR_ATTR) {
+      this.error(
+        "forbidden-attr",
+        `Attribute "${DISCRIMINATOR_ATTR}" is not allowed on <${tag}> \u2014 on this tier the tag name IS the component, so <${tag}> already means type "${tag}". Delete the attribute, or write the tag of the component you meant.`,
+        elStart,
+        tag
+      );
+      return { name, value: void 0, drop: true };
+    }
     if (EVENT_ATTR.test(name) || FORBIDDEN_ATTRS.has(name)) {
       this.error("forbidden-attr", `Attribute "${name}" is not allowed on <${tag}>`, elStart, tag);
       return { name: `__forbidden_${name}`, value: void 0 };
@@ -165,8 +182,17 @@ var Parser = class {
         continue;
       }
       const text = this.readTextRun();
-      const trimmed = text.replace(/\s+/g, " ").trim();
-      if (trimmed) children.push(trimmed);
+      const collapsed = text.replace(/\s+/g, " ");
+      const core = collapsed.trim();
+      const afterSibling = children.length > 0;
+      const beforeElement = this.peek() === "<" && !this.src.startsWith("</", this.pos);
+      if (core) {
+        const lead = afterSibling && collapsed.startsWith(" ") ? " " : "";
+        const trail = beforeElement && collapsed.endsWith(" ") ? " " : "";
+        children.push(`${lead}${core}${trail}`);
+      } else if (collapsed && afterSibling && beforeElement) {
+        children.push(" ");
+      }
     }
     return children;
   }
@@ -250,9 +276,268 @@ function interpretBrace(raw) {
   try {
     return JSON.parse(trimmed);
   } catch {
-    return { $expr: trimmed };
+    const literal = readLiteral(trimmed);
+    return literal === NOT_LITERAL ? { $expr: trimmed } : literal;
   }
 }
+var NOT_LITERAL = /* @__PURE__ */ Symbol("not-a-literal");
+var LITERAL_WS = /[ \t\n\r]/;
+var IDENT_START = /[A-Za-z_$]/;
+var IDENT_CHAR = /[A-Za-z0-9_$]/;
+var NUMBER = /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?/;
+var SIMPLE_ESCAPE = {
+  '"': '"',
+  "\\": "\\",
+  "/": "/",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	"
+};
+function readLiteral(src) {
+  const reader = new LiteralReader(src);
+  const value = reader.value();
+  if (value === NOT_LITERAL) return NOT_LITERAL;
+  reader.ws();
+  return reader.done() ? value : NOT_LITERAL;
+}
+var LiteralReader = class {
+  constructor(src) {
+    this.src = src;
+    this.pos = 0;
+  }
+  done() {
+    return this.pos >= this.src.length;
+  }
+  ws() {
+    while (this.pos < this.src.length && LITERAL_WS.test(this.src[this.pos])) this.pos++;
+  }
+  value() {
+    this.ws();
+    const c = this.src[this.pos];
+    if (c === void 0) return NOT_LITERAL;
+    if (c === '"' || c === "'") return this.string(c);
+    if (c === "[") return this.array();
+    if (c === "{") return this.object();
+    if (this.keyword("true")) return true;
+    if (this.keyword("false")) return false;
+    if (this.keyword("null")) return null;
+    return this.number();
+  }
+  /** A keyword only when it is not the prefix of a longer identifier. */
+  keyword(word) {
+    if (!this.src.startsWith(word, this.pos)) return false;
+    const after = this.src[this.pos + word.length];
+    if (after !== void 0 && IDENT_CHAR.test(after)) return false;
+    this.pos += word.length;
+    return true;
+  }
+  number() {
+    const m = NUMBER.exec(this.src.slice(this.pos));
+    if (!m) return NOT_LITERAL;
+    this.pos += m[0].length;
+    return Number(m[0]);
+  }
+  string(quote) {
+    this.pos++;
+    let out = "";
+    for (; ; ) {
+      const c = this.src[this.pos];
+      if (c === void 0) return NOT_LITERAL;
+      if (c === quote) {
+        this.pos++;
+        return out;
+      }
+      if (c === "\\") {
+        const esc = this.src[this.pos + 1];
+        if (esc === void 0) return NOT_LITERAL;
+        if (esc === "u") {
+          const hex = this.src.slice(this.pos + 2, this.pos + 6);
+          if (!/^[0-9a-fA-F]{4}$/.test(hex)) return NOT_LITERAL;
+          out += String.fromCharCode(parseInt(hex, 16));
+          this.pos += 6;
+          continue;
+        }
+        if (esc === "'" && quote === "'") {
+          out += "'";
+          this.pos += 2;
+          continue;
+        }
+        const simple = SIMPLE_ESCAPE[esc];
+        if (simple === void 0) return NOT_LITERAL;
+        out += simple;
+        this.pos += 2;
+        continue;
+      }
+      if (c < " ") return NOT_LITERAL;
+      out += c;
+      this.pos++;
+    }
+  }
+  array() {
+    this.pos++;
+    const out = [];
+    this.ws();
+    if (this.src[this.pos] === "]") {
+      this.pos++;
+      return out;
+    }
+    for (; ; ) {
+      const item = this.value();
+      if (item === NOT_LITERAL) return NOT_LITERAL;
+      out.push(item);
+      this.ws();
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+        continue;
+      }
+      if (c === "]") {
+        this.pos++;
+        return out;
+      }
+      return NOT_LITERAL;
+    }
+  }
+  object() {
+    this.pos++;
+    const out = {};
+    this.ws();
+    if (this.src[this.pos] === "}") {
+      this.pos++;
+      return out;
+    }
+    for (; ; ) {
+      this.ws();
+      const key = this.key();
+      if (key === NOT_LITERAL) return NOT_LITERAL;
+      this.ws();
+      if (this.src[this.pos] !== ":") return NOT_LITERAL;
+      this.pos++;
+      const item = this.value();
+      if (item === NOT_LITERAL) return NOT_LITERAL;
+      Object.defineProperty(out, key, {
+        value: item,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+      this.ws();
+      const c = this.src[this.pos];
+      if (c === ",") {
+        this.pos++;
+        continue;
+      }
+      if (c === "}") {
+        this.pos++;
+        return out;
+      }
+      return NOT_LITERAL;
+    }
+  }
+  /** A quoted string, or a bare identifier — the second ruled widening. */
+  key() {
+    const c = this.src[this.pos];
+    if (c === '"' || c === "'") return this.string(c);
+    if (c !== void 0 && IDENT_START.test(c)) {
+      const start = this.pos;
+      this.pos++;
+      while (this.pos < this.src.length && IDENT_CHAR.test(this.src[this.pos])) this.pos++;
+      return this.src.slice(start, this.pos);
+    }
+    return NOT_LITERAL;
+  }
+};
+
+// src/input-type.ts
+var MANIFEST_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "string",
+  "number",
+  "boolean",
+  "enum",
+  "array",
+  "object",
+  "color",
+  "date",
+  "code",
+  "file",
+  "slot"
+]);
+function inputTypeArms(type) {
+  if (type === void 0) return [];
+  return Array.isArray(type) ? type : [type];
+}
+function canonicalizeInputType(type) {
+  const arms = (Array.isArray(type) ? type : [type]).filter(
+    (arm) => typeof arm === "string" && MANIFEST_INPUT_TYPES.has(arm)
+  );
+  const distinct = [...new Set(arms)];
+  if (distinct.length === 0) return "string";
+  if (distinct.length === 1) return distinct[0];
+  return distinct;
+}
+
+// src/dashboard-widget-options.ts
+var UNCONSUMED_WIDGET_OPTION = "unconsumed-widget-option";
+var DASHBOARD_WIDGET_HOST_TYPES = /* @__PURE__ */ new Set([
+  "dashboard",
+  "dashboard-grid"
+]);
+var CONSUMED_WIDGET_OPTION_KEYS = [
+  "dateGranularity",
+  "description",
+  "limit",
+  "sortBy",
+  "sortOrder",
+  "stageOrder"
+];
+var CONSUMED = new Set(CONSUMED_WIDGET_OPTION_KEYS);
+var isPlainObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isExpr = (v) => isPlainObject(v) && "$expr" in v;
+function checkDashboardWidgetOptions(node) {
+  if (!DASHBOARD_WIDGET_HOST_TYPES.has(node.type)) return [];
+  const widgets = node.widgets;
+  if (!Array.isArray(widgets)) return [];
+  const diagnostics = [];
+  widgets.forEach((widget, index) => {
+    if (!isPlainObject(widget) || isExpr(widget)) return;
+    if (widget.component !== void 0) return;
+    if (widget.dataset === void 0 || widget.dataset === null || widget.dataset === "") return;
+    const options = widget.options;
+    if (!isPlainObject(options) || isExpr(options)) return;
+    if (Array.isArray(widget.suppressWarnings) && widget.suppressWarnings.includes(UNCONSUMED_WIDGET_OPTION)) {
+      return;
+    }
+    const label = typeof widget.id === "string" && widget.id !== "" ? widget.id : `#${index}`;
+    const widgetType = typeof widget.type === "string" && widget.type !== "" ? widget.type : "widget";
+    for (const key of Object.keys(options)) {
+      if (CONSUMED.has(key)) continue;
+      diagnostics.push({
+        severity: "warning",
+        // DIVERGENCE FROM OBJECTUI, and the only one below this file's header:
+        // objectui writes `code: UNCONSUMED_WIDGET_OPTION` here. This repo runs
+        // `check:dispatcher-error-vocabulary`, whose `objlitconst` shape reads
+        // the SCREAMING_SNAKE constant NAME at a `code:` position and then must
+        // reduce it to a literal — and its literal grammar is
+        // `[A-Za-z][A-Za-z0-9_]*`, which a KEBAB-case value cannot satisfy. So
+        // the constant form is reported as an unresolvable code constant, and
+        // that finding cannot be declared away. `unconsumed-widget-option` is a
+        // parser DIAGNOSTIC code, not an ADR-0112 wire code, and an inline
+        // quoted literal is the form both vocabulary gates already accept for
+        // the six sibling diagnostic codes in `validate.ts`
+        // (`unknown-component`, `unknown-prop`, `not-a-container`,
+        // `inert-expression`, `type-mismatch`, `invalid-enum`). The emitted
+        // VALUE is unchanged, and the test next door pins it equal to
+        // `UNCONSUMED_WIDGET_OPTION` so the two spellings cannot drift apart.
+        code: "unconsumed-widget-option",
+        message: `<${node.type}> widget "${label}" (${widgetType}): options.${key} reaches no renderer \u2014 dashboard widget renderers read only: ${CONSUMED_WIDGET_OPTION_KEYS.join(", ")}`,
+        tag: node.type
+      });
+    }
+  });
+  return diagnostics;
+}
 
 // src/validate.ts
 var BASE_PROPS = /* @__PURE__ */ new Set([
@@ -266,7 +551,7 @@ var BASE_PROPS = /* @__PURE__ */ new Set([
   "disabledOn",
   "children"
 ]);
-var isExpr = (v) => typeof v === "object" && v !== null && "$expr" in v;
+var isExpr2 = (v) => typeof v === "object" && v !== null && "$expr" in v;
 function validateTree(tree, manifest) {
   const diagnostics = [];
   const requires = /* @__PURE__ */ new Set();
@@ -309,7 +594,14 @@ function validateTree(tree, manifest) {
         if (input.binding) {
           bindings.push({ tag: node.type, input: key, kind: input.binding, value });
         }
-        if (!isExpr(value)) {
+        if (isExpr2(value)) {
+          diagnostics.push({
+            severity: "warning",
+            code: "inert-expression",
+            message: `<${node.type}> prop "${key}" is a braced expression this tier never evaluates \u2014 the value will be silently ignored at render. This tier materializes LITERALS only (strings, numbers, booleans, null, arrays, objects; quotes may be single or double, object keys may be unquoted), e.g. columns={['name','amount']} works \u2014 columns={rows.map((r) => r.name)} cannot`,
+            tag: node.type
+          });
+        } else {
           const typeDiag = checkType(node.type, input, value);
           if (typeDiag) diagnostics.push(typeDiag);
         }
@@ -322,46 +614,70 @@ function validateTree(tree, manifest) {
           tag: node.type
         });
       }
+      diagnostics.push(...checkDashboardWidgetOptions(node));
     }
     if (node.children) node.children.forEach(visit);
   };
   if (tree) visit(tree);
   return { diagnostics, requires: [...requires], bindings };
 }
-function checkType(tag, input, value) {
-  const mismatch = (expected) => ({
-    severity: "warning",
-    code: "type-mismatch",
-    message: `<${tag}> prop "${input.name}" expected ${expected}`,
-    tag
-  });
-  switch (input.type) {
+var enumValues = (input) => (input.enum ?? []).map((e) => typeof e === "object" ? e.value : e);
+function armAccepts(arm, input, value) {
+  switch (arm) {
     case "number":
-      return typeof value === "number" ? null : mismatch("a number");
+      return typeof value === "number";
     case "boolean":
-      return typeof value === "boolean" ? null : mismatch("a boolean");
+      return typeof value === "boolean";
     case "string":
     case "color":
     case "date":
     case "code":
     case "file":
-      return typeof value === "string" ? null : mismatch("a string");
+      return typeof value === "string";
     case "array":
-      return Array.isArray(value) ? null : mismatch("an array");
+      return Array.isArray(value);
     case "object":
-      return typeof value === "object" && value !== null && !Array.isArray(value) ? null : mismatch("an object");
-    case "enum": {
-      const allowed = (input.enum ?? []).map((e) => typeof e === "object" ? e.value : e);
-      return allowed.includes(value) ? null : {
-        severity: "error",
-        code: "invalid-enum",
-        message: `<${tag}> prop "${input.name}"=${JSON.stringify(value)} is not one of ${JSON.stringify(allowed)}`,
-        tag
-      };
-    }
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    case "enum":
+      return enumValues(input).includes(value);
     default:
-      return null;
+      return true;
+  }
+}
+function armExpectation(arm, input) {
+  switch (arm) {
+    case "number":
+      return "a number";
+    case "boolean":
+      return "a boolean";
+    case "array":
+      return "an array";
+    case "object":
+      return "an object";
+    case "enum":
+      return `one of ${JSON.stringify(enumValues(input))}`;
+    default:
+      return "a string";
+  }
+}
+function checkType(tag, input, value) {
+  const arms = inputTypeArms(input.type);
+  if (arms.length === 0) return null;
+  if (arms.some((arm) => armAccepts(arm, input, value))) return null;
+  if (arms.length === 1 && arms[0] === "enum") {
+    return {
+      severity: "error",
+      code: "invalid-enum",
+      message: `<${tag}> prop "${input.name}"=${JSON.stringify(value)} is not one of ${JSON.stringify(enumValues(input))}`,
+      tag
+    };
   }
+  return {
+    severity: arms.includes("enum") ? "error" : "warning",
+    code: "type-mismatch",
+    message: `<${tag}> prop "${input.name}" expected ${arms.map((arm) => armExpectation(arm, input)).join(" or ")}`,
+    tag
+  };
 }
 
 // src/codegen.ts
@@ -378,7 +694,6 @@ function generateDts(manifest, options = {}) {
     interface ElementChildrenAttribute { children: object; }` : "";
   return `// AUTO-GENERATED by @object-ui/sdui-parser \u2014 DO NOT EDIT.
 // Source of truth: ComponentRegistry inputs (ADR-0080 \xA73). Regenerate via codegen.
-/* eslint-disable */
 
 export interface SduiBaseProps {
   id?: string;
@@ -405,17 +720,18 @@ export {};
 `;
 }
 function emitInterface(comp) {
-  const lines = comp.inputs.filter((i) => i.type !== "slot").map((i) => `  ${propLine(i)}`).join("\n");
+  const lines = comp.inputs.filter((i) => valueArms(i).length > 0).map((i) => `  ${propLine(i)}`).join("\n");
   return `export interface ${propsName(comp.type)} extends SduiBaseProps {
 ${lines}
 }`;
 }
+var valueArms = (input) => inputTypeArms(input.type).filter((arm) => arm !== "slot");
 function propLine(input) {
   const opt = input.required ? "" : "?";
   return `${quoteKeyIfNeeded(input.name)}${opt}: ${tsType(input)};`;
 }
-function tsType(input) {
-  switch (input.type) {
+function armTsType(arm, input) {
+  switch (arm) {
     case "number":
       return "number";
     case "boolean":
@@ -428,15 +744,16 @@ function tsType(input) {
       const vals = (input.enum ?? []).map((e) => typeof e === "object" ? e.value : e);
       return vals.length ? vals.map((v) => JSON.stringify(v)).join(" | ") : "string";
     }
-    case "string":
-    case "color":
-    case "date":
-    case "code":
-    case "file":
     default:
       return "string";
   }
 }
+function tsType(input) {
+  const arms = valueArms(input);
+  if (arms.length === 0) return "string";
+  const emitted = [...new Set(arms.map((arm) => armTsType(arm, input)))];
+  return emitted.join(" | ");
+}
 var IDENT = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 var quoteKeyIfNeeded = (name) => IDENT.test(name) ? name : JSON.stringify(name);
 function propsName(type) {
@@ -475,19 +792,6 @@ function compile(source, manifest) {
     ok: !diagnostics.some((d) => d.severity === "error")
   };
 }
-var INPUT_TYPES = /* @__PURE__ */ new Set([
-  "string",
-  "number",
-  "boolean",
-  "enum",
-  "array",
-  "object",
-  "color",
-  "date",
-  "code",
-  "file",
-  "slot"
-]);
 function manifestFromConfigs(configs, opts = {}) {
   const components = {};
   for (const c of configs) {
@@ -499,7 +803,7 @@ function manifestFromConfigs(configs, opts = {}) {
       isContainer: c.isContainer,
       inputs: (c.inputs ?? []).map((i) => ({
         name: i.name,
-        type: INPUT_TYPES.has(i.type) ? i.type : "string",
+        type: canonicalizeInputType(i.type),
         required: i.required,
         enum: i.enum,
         binding: i.binding,
@@ -511,9 +815,16 @@ function manifestFromConfigs(configs, opts = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  CONSUMED_WIDGET_OPTION_KEYS,
+  DASHBOARD_WIDGET_HOST_TYPES,
+  MANIFEST_INPUT_TYPES,
+  UNCONSUMED_WIDGET_OPTION,
+  canonicalizeInputType,
+  checkDashboardWidgetOptions,
   compile,
   generateBlockList,
   generateDts,
+  inputTypeArms,
   interpretBrace,
   manifestFromConfigs,
   parseJsx,