@devfellowship/components 3.2.3 → 3.3.0

package/dist/cli.js

@@ -464,11 +464,121 @@ var SCHEMA_V1 = {
   }
 };
 
+// node_modules/@devfellowship/ux-paths-spec/dist/index.js
+function stepScreenId(step) {
+  return typeof step === "string" ? step : step.screen;
+}
+function flowScreenIds(flow) {
+  return [flow.start, ...flow.steps.map(stepScreenId)];
+}
+function danglingScreenIds(doc) {
+  const declared = new Set((doc.screens ?? []).map((screen) => screen.id));
+  const dangling = /* @__PURE__ */ new Set();
+  for (const flow of doc.flows ?? []) {
+    for (const id of flowScreenIds(flow)) {
+      if (!declared.has(id))
+        dangling.add(id);
+    }
+  }
+  return [...dangling];
+}
+
 // src/cli/ux-paths/lib/load-schema.ts
 async function loadSchemaV1() {
   return SCHEMA_V1;
 }
 
+// src/cli/ux-paths/lib/structural-checks.ts
+function screensOf(doc) {
+  const screens = doc?.screens;
+  return Array.isArray(screens) ? screens : [];
+}
+function flowsOf(doc) {
+  const flows = doc?.flows;
+  return Array.isArray(flows) ? flows : [];
+}
+function checkUniqueIds(doc) {
+  const seen = /* @__PURE__ */ new Set();
+  const duplicates = /* @__PURE__ */ new Set();
+  for (const screen of screensOf(doc)) {
+    const id = screen?.id;
+    if (typeof id !== "string") continue;
+    if (seen.has(id)) duplicates.add(id);
+    else seen.add(id);
+  }
+  if (duplicates.size === 0) return null;
+  return {
+    rule: "unique-ids",
+    message: `${duplicates.size} duplicate screen id${duplicates.size === 1 ? "" : "s"}`,
+    detail: [...duplicates].sort().map((id) => `  - "${id}" is declared more than once`)
+  };
+}
+function checkWholeFlows(doc) {
+  const normalised = {
+    screens: screensOf(doc),
+    flows: flowsOf(doc).map((flow) => ({
+      ...flow,
+      steps: Array.isArray(flow?.steps) ? flow.steps : []
+    }))
+  };
+  const dangling = danglingScreenIds(normalised);
+  if (dangling.length === 0) return null;
+  const flows = flowsOf(doc);
+  const where = /* @__PURE__ */ new Map();
+  flows.forEach((flow, i) => {
+    const f = flow;
+    const label = typeof f?.name === "string" ? f.name : `flows[${i}]`;
+    const referenced = [
+      f?.start,
+      ...(Array.isArray(f?.steps) ? f.steps : []).map(
+        (step) => typeof step === "string" ? step : step?.screen
+      )
+    ];
+    for (const id of referenced) {
+      if (typeof id !== "string" || !dangling.includes(id)) continue;
+      if (!where.has(id)) where.set(id, /* @__PURE__ */ new Set());
+      where.get(id)?.add(label);
+    }
+  });
+  return {
+    rule: "whole-flows",
+    message: `${dangling.length} screen id${dangling.length === 1 ? "" : "s"} referenced by a flow that no screen declares`,
+    detail: dangling.slice().sort().map((id) => {
+      const labels = [...where.get(id) ?? []].sort().join(", ");
+      return `  - "${id}"${labels ? `   (referenced by: ${labels})` : ""}`;
+    })
+  };
+}
+function checkActionTargets(doc) {
+  const screens = screensOf(doc);
+  const declared = new Set(
+    screens.map((s) => s?.id).filter((id) => typeof id === "string")
+  );
+  const dangling = /* @__PURE__ */ new Map();
+  for (const screen of screens) {
+    const actions = Array.isArray(screen?.actions) ? screen.actions : [];
+    for (const action of actions) {
+      const target = action?.next_screen;
+      if (typeof target !== "string" || target.trim() === "") continue;
+      if (declared.has(target)) continue;
+      const site = `${typeof screen?.id === "string" ? screen.id : "<screen with no id>"}.${typeof action?.id === "string" ? action.id : "<action with no id>"}`;
+      if (!dangling.has(target)) dangling.set(target, /* @__PURE__ */ new Set());
+      dangling.get(target)?.add(site);
+    }
+  }
+  if (dangling.size === 0) return null;
+  return {
+    rule: "action-targets",
+    message: `${dangling.size} action target${dangling.size === 1 ? "" : "s"} that no screen declares`,
+    detail: [...dangling.keys()].sort().map((id) => `  - "${id}"   (targeted by: ${[...dangling.get(id) ?? []].sort().join(", ")})`)
+  };
+}
+function checkStructure(doc) {
+  return [checkUniqueIds(doc), checkWholeFlows(doc), checkActionTargets(doc)].filter(
+    (p) => p !== null
+  );
+}
+
 // src/cli/ux-paths/commands/validate.ts
 function registerValidate(program2) {
   program2.command("validate [path]").description("Validate a flows.json against the DFL UX Paths v1 schema.").action(async (maybePath) => {
@@ -495,20 +605,32 @@ function registerValidate(program2) {
     }
     const validate = ajv.compile(schema);
     const ok = validate(doc);
-    if (ok) {
-      console.log(chalk2.green("OK"), path, "conforms to schema v1.");
-      process.exit(0);
+    if (!ok) {
+      console.error(chalk2.red("FAIL"), path);
+      for (const err of validate.errors ?? []) {
+        console.error(
+          chalk2.yellow("  -"),
+          err.instancePath || "<root>",
+          err.message,
+          err.params ? JSON.stringify(err.params) : ""
+        );
+      }
+      process.exit(1);
     }
-    console.error(chalk2.red("FAIL"), path);
-    for (const err of validate.errors ?? []) {
+    const problems = checkStructure(doc);
+    if (problems.length > 0) {
+      console.error(chalk2.red("FAIL"), path);
       console.error(
-        chalk2.yellow("  -"),
-        err.instancePath || "<root>",
-        err.message,
-        err.params ? JSON.stringify(err.params) : ""
+        chalk2.yellow("  the document satisfies schema v1 but is not internally consistent:")
       );
+      for (const problem of problems) {
+        console.error(chalk2.yellow(`  [${problem.rule}]`), problem.message);
+        for (const line of problem.detail) console.error(chalk2.dim(`  ${line}`));
+      }
+      process.exit(1);
     }
-    process.exit(1);
+    console.log(chalk2.green("OK"), path, "conforms to schema v1.");
+    process.exit(0);
   });
 }