stimeo-ui 0.13.0 → 0.15.0

package/dist/inspector/cli_bin.js

@@ -71,6 +71,30 @@ function announcerSeatingDiagnostic(sources) {
   };
 }
 
+// src/utils/declared_value.ts
+function parseDeclared(raw, parse, fallback) {
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function compileRegExp(source, anchor = "none") {
+  return parseDeclared(
+    source,
+    (text) => {
+      const bare = new RegExp(text);
+      return anchor === "exact" ? new RegExp(`^(?:${text})$`) : bare;
+    },
+    null
+  );
+}
+function parseJsonObject(raw) {
+  const parsed = parseDeclared(raw, (text) => JSON.parse(text), null);
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  return parsed;
+}
+
 // src/inspector/html_parser.ts
 var ERB_ELEMENT_TAG = "#erb";
 var VOID_ELEMENTS = /* @__PURE__ */ new Set([
@@ -989,7 +1013,21 @@ function parseValueAttr(attrName, knownIdentifiers) {
   const valueGuess = dash === -1 ? "" : rest.slice(dash + 1);
   return { identifier: null, valueToken: valueGuess || identifierGuess };
 }
-function actionDescriptors(dataActionValue) {
+var DEFAULT_EVENT_NAMES = {
+  a: "click",
+  button: "click",
+  details: "toggle",
+  form: "submit",
+  input: "input",
+  select: "change",
+  textarea: "input"
+};
+function defaultEventFor(host) {
+  if (!host) return "";
+  if (host.tag === "input" && host.inputType === "submit") return "click";
+  return DEFAULT_EVENT_NAMES[host.tag] ?? "";
+}
+function actionDescriptors(dataActionValue, host) {
   const descriptors = [];
   for (const descriptor of dataActionValue.split(/\s+/)) {
     const hash = descriptor.indexOf("#");
@@ -1002,6 +1040,8 @@ function actionDescriptors(dataActionValue) {
       lhs = lhs.slice(arrow + 2);
       const at = eventType.indexOf("@");
       if (at !== -1) eventType = eventType.slice(0, at);
+    } else {
+      eventType = defaultEventFor(host);
     }
     if (!lhs.startsWith(NAMESPACE_PREFIX)) continue;
     const method = /^[a-zA-Z_$][\w$]*/.exec(descriptor.slice(hash + 1))?.[0] ?? "";
@@ -1026,6 +1066,7 @@ var DIAGNOSTIC_CODES = [
   "missing-conditional-target",
   "missing-required-action",
   "missing-action-completion",
+  "missing-action-event",
   "missing-aria",
   "invalid-aria-value",
   "keyboard-inaccessible",
@@ -1370,9 +1411,7 @@ function checkSource(source, manifest) {
                 didYouMean(parsed.valueToken, (controller?.values ?? []).map(dasherize))
               );
             } else if (!isDynamicValue(attr)) {
-              const constraint = controller?.valueConstraints.find(
-                (candidate) => dasherize(candidate.value) === parsed.valueToken
-              );
+              const constraint = declaredConstraint(controller, parsed.valueToken);
               if (constraint && !valueSatisfiesConstraint(attr.value, constraint)) {
                 const literal = constraint.type === "string" ? attr.value : attr.value.trim();
                 report(
@@ -1390,12 +1429,26 @@ function checkSource(source, manifest) {
         }
       }
       if (attr.name === "data-action") {
-        for (const { identifier, method, eventType } of actionDescriptors(attr.value)) {
+        const host = {
+          tag: node.tag,
+          inputType: node.attrs.find((a) => a.name === "type")?.value
+        };
+        for (const { identifier, method, eventType } of actionDescriptors(attr.value, host)) {
           const controller = known[identifier];
           if (controller && method.length > 0) {
             const owner = findOwner(node, identifier);
             if (owner) recordAction(owner, identifier, node, method, eventType);
           }
+          if (controller && method.length > 0 && eventType === "" && node.origin === "markup" && !isDynamicValue(attr)) {
+            report(
+              node,
+              "missing-action-event",
+              "error",
+              `"${identifier}#${method}" omits the event and <${node.tag}> has no default one, so Stimulus never binds it.`,
+              attr,
+              `Name the event: data-action="<event>->${identifier}#${method}".`
+            );
+          }
           if (!controller) {
             const best = nearestName(identifier, knownIdentifiers);
             report(
@@ -1861,8 +1914,13 @@ function checkSource(source, manifest) {
   diagnostics.sort((a, b) => a.line - b.line || a.column - b.column);
   return diagnostics;
 }
+function declaredConstraint(controller, valueToken) {
+  const matches = (candidate) => dasherize(candidate.value) === valueToken;
+  const syntax = controller?.valueSyntaxConstraints;
+  return controller?.valueConstraints.find(matches) ?? (Array.isArray(syntax) ? syntax.find(matches) : void 0);
+}
 function valueSatisfiesConstraint(raw, constraint) {
-  if (constraint.type === "string") return constraint.allowedValues.includes(raw);
+  if (constraint.type === "string") return stringValueSatisfies(raw, constraint);
   const value = decodeNumericValue(raw);
   if (Number.isNaN(value)) return false;
   if (constraint.finite && !Number.isFinite(value)) return false;
@@ -1873,8 +1931,18 @@ function valueSatisfiesConstraint(raw, constraint) {
 function decodeNumericValue(raw) {
   return Number(raw.replace(/_/g, ""));
 }
+function stringValueSatisfies(raw, constraint) {
+  if (!("syntax" in constraint)) return constraint.allowedValues.includes(raw);
+  if (constraint.syntax === "regexp") return compileRegExp(raw, "exact") !== null;
+  if (raw === "") return true;
+  const parsed = parseJsonObject(raw);
+  if (parsed === null) return false;
+  return Object.values(parsed).every(
+    (source) => typeof source === "string" && (constraint.entries !== "regexp" || compileRegExp(source, "exact") !== null)
+  );
+}
 function describeValueConstraint(constraint) {
-  if (constraint.type === "string") return `one of ${list(constraint.allowedValues)}`;
+  if (constraint.type === "string") return describeStringConstraint(constraint);
   const parts = [constraint.finite ? "a finite number" : "a number"];
   if (constraint.greaterThan !== void 0) {
     parts.push(`greater than ${constraint.greaterThan}`);
@@ -1882,6 +1950,11 @@ function describeValueConstraint(constraint) {
   if (constraint.integer) parts.push("with no fractional part");
   return parts.join(" ");
 }
+function describeStringConstraint(constraint) {
+  if (!("syntax" in constraint)) return `one of ${list(constraint.allowedValues)}`;
+  if (constraint.syntax === "regexp") return "a valid regular expression";
+  return constraint.entries === "regexp" ? "a JSON object whose values are valid regular expressions" : "a JSON object of strings";
+}
 var UNRESOLVED_TARGET_HINT = "Part of this scope is rendered by a helper or a non-literal data: hash, so the target may exist at runtime.";
 var UNRESOLVED_HOST_HINT = "An enclosing helper's data: option is not a literal hash, so the host controller may be declared at runtime.";
 function hasReadableMarkup(el) {
@@ -2644,6 +2717,29 @@ var CONTROLLER_CONTRACT_SCHEMA = {
         required: ["value", "type", "suggestion"]
       }
     },
+    valueSyntaxConstraints: {
+      type: "array",
+      description: "Grammar contracts on String Values whose accepted set cannot be enumerated. Its own field so an engine that predates it skips these instead of reading them through allowedValues.",
+      items: {
+        type: "object",
+        properties: {
+          value: { type: "string", description: "Camel-case declared Value name." },
+          type: { type: "string", enum: ["string"] },
+          syntax: {
+            type: "string",
+            enum: ["regexp", "json-object"],
+            description: "Grammar the whole literal must satisfy."
+          },
+          entries: {
+            type: "string",
+            enum: ["regexp"],
+            description: "For a json-object syntax, the grammar every property value must satisfy."
+          },
+          suggestion: { type: "string" }
+        },
+        required: ["value", "type", "syntax", "suggestion"]
+      }
+    },
     valueRelations: {
       type: "array",
       description: "Statically checkable relationships between authored Stimulus Values.",