@tileflow/dev 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/chunk-LNCTVFUD.js

@@ -0,0 +1,236 @@
+import {
+  sanitizeDiagnosticSecrets
+} from "./chunk-KDFTE4Q5.js";
+
+// src/validation.ts
+import { realpathSync } from "fs";
+import { isAbsolute, relative, resolve, sep, win32 } from "path";
+import { compareCodeUnits } from "@tileflow/core";
+var tileflowCommandDocumentSchemaVersion = 1;
+function createTileflowCommandSummary(input) {
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(input.command, "command"),
+    ok: input.ok,
+    phase: normalizePhase(input.phase, "command"),
+    code: normalizeCode(input.code, input.ok ? "COMMAND_OK" : "COMMAND_FAILED"),
+    path: boundText(input.path ?? "", 300),
+    severity: input.severity,
+    message: boundText(input.message.replace(/[\r\n]+/gu, " ").trim(), 300),
+    suggestion: boundText(input.suggestion.replace(/[\r\n]+/gu, " ").trim(), 300)
+  };
+}
+function createTileflowStructuredDiagnostics(error, cwd, defaults) {
+  const inheritedCode = optionalField(error, "code");
+  const inheritedDomain = optionalField(error, "domain") ?? optionalField(error, "owner") ?? optionalNestedField(error, "domain") ?? optionalNestedField(error, "owner");
+  const inheritedLevel = optionalField(error, "level") ?? optionalNestedField(error, "level");
+  const inheritedMessage = optionalField(error, "message") ?? optionalNestedField(error, "message");
+  const inheritedPath = optionalField(error, "path") ?? optionalNestedField(error, "path");
+  const inheritedPhase = optionalField(error, "phase") ?? optionalNestedField(error, "phase");
+  const inheritedSeverity = optionalField(error, "severity") ?? optionalNestedField(error, "severity");
+  const inheritedSuggestion = optionalField(error, "suggestion") ?? optionalNestedField(error, "suggestion");
+  const inheritedTarget = optionalField(error, "target") ?? optionalNestedField(error, "target");
+  const issues = getIssues(error);
+  const candidates = issues.length ? issues : [
+    {
+      message: inheritedMessage ?? (error instanceof Error ? error.message : "The Tileflow command failed."),
+      path: inheritedPath ?? ""
+    }
+  ];
+  const diagnostics = candidates.map((issue) => {
+    const phase = normalizePhase(issue.phase ?? inheritedPhase, defaults.phase);
+    const code = normalizeCode(issue.code ?? inheritedCode, defaults.code);
+    const severity = normalizeSeverity(
+      issue.severity ?? issue.level ?? inheritedSeverity ?? inheritedLevel,
+      defaults.severity ?? "error"
+    );
+    const domain = sanitizeDiagnosticContext(issue.domain ?? issue.owner ?? inheritedDomain, cwd);
+    const target = sanitizeDiagnosticContext(issue.target ?? inheritedTarget, cwd);
+    const suggestion = issue.suggestion ?? inheritedSuggestion;
+    return {
+      phase,
+      code,
+      ...domain ? { domain } : {},
+      path: boundText(sanitizePath(issue.path ?? inheritedPath ?? "", cwd), 300),
+      ...target ? { target } : {},
+      severity,
+      message: boundText(sanitizeMessage(issue.message, cwd), 300),
+      suggestion: suggestion ? boundText(sanitizeMessage(suggestion, cwd), 300) : suggestionForDiagnostic(code, phase)
+    };
+  });
+  diagnostics.sort(compareDiagnostics);
+  return diagnostics.filter(
+    (diagnostic, index) => index === 0 || JSON.stringify(diagnostic) !== JSON.stringify(diagnostics[index - 1])
+  ).slice(0, 32);
+}
+function createTileflowCommandFailureDocument(command, error, cwd, defaults) {
+  const diagnostics = createTileflowStructuredDiagnostics(error, cwd, defaults);
+  const primary = diagnostics[0] ?? {
+    phase: normalizePhase(defaults.phase, "command"),
+    code: normalizeCode(defaults.code, "COMMAND_FAILED"),
+    path: "",
+    severity: defaults.severity ?? "error",
+    message: "The Tileflow command failed.",
+    suggestion: "Review the command input and run it again."
+  };
+  return {
+    schemaVersion: tileflowCommandDocumentSchemaVersion,
+    command: normalizeCommandField(command, "command"),
+    ok: false,
+    phase: primary.phase,
+    code: primary.code,
+    ...primary.domain ? { domain: primary.domain } : {},
+    path: primary.path,
+    ...primary.target ? { target: primary.target } : {},
+    severity: primary.severity,
+    message: primary.message,
+    suggestion: primary.suggestion,
+    diagnostics
+  };
+}
+function serializeTileflowCommandDocument(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function getIssues(error) {
+  if (!error || typeof error !== "object") return [];
+  const containers = [];
+  for (const key of ["diagnostics", "messages", "issues"]) {
+    const value = error[key];
+    if (Array.isArray(value)) containers.push(value);
+  }
+  const details = error.details;
+  if (details && typeof details === "object") {
+    const diagnostics = details.diagnostics;
+    if (Array.isArray(diagnostics)) containers.push(diagnostics);
+  }
+  return containers.flatMap(
+    (container) => container.flatMap((entry) => {
+      if (!entry || typeof entry !== "object") return [];
+      const candidate = entry;
+      if (typeof candidate.message !== "string") return [];
+      return [
+        {
+          ...typeof candidate.code === "string" ? { code: candidate.code } : {},
+          ...typeof candidate.domain === "string" ? { domain: candidate.domain } : {},
+          ...typeof candidate.level === "string" ? { level: candidate.level } : {},
+          message: candidate.message,
+          ...typeof candidate.owner === "string" ? { owner: candidate.owner } : {},
+          ...typeof candidate.path === "string" ? { path: candidate.path } : {},
+          ...typeof candidate.phase === "string" ? { phase: candidate.phase } : {},
+          ...typeof candidate.severity === "string" ? { severity: candidate.severity } : {},
+          ...typeof candidate.suggestion === "string" ? { suggestion: candidate.suggestion } : {},
+          ...typeof candidate.target === "string" ? { target: candidate.target } : {}
+        }
+      ];
+    })
+  );
+}
+function sanitizeMessage(value, cwd) {
+  let sanitized = value;
+  for (const root of localPathAliases(cwd)) sanitized = sanitized.replaceAll(root, ".");
+  sanitized = sanitized.replace(/[\r\n]+/gu, " ").trim();
+  sanitized = sanitized.replace(/https?:\/\/[^\s'")<>]+/giu, (url) => {
+    try {
+      return new URL(url.replace(/[),.;]+$/u, "")).origin;
+    } catch {
+      return "(resource URL)";
+    }
+  });
+  sanitized = sanitized.replace(/(^|[\s'"(])[A-Za-z]:[\\/][^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])(?:\\\\|\/\/)[^\s'")]+/gu, "$1(external path)");
+  sanitized = sanitized.replace(/(^|[\s'"(])\/[^\s'")]+/gu, "$1(external path)");
+  return sanitizeDiagnosticSecrets(sanitized);
+}
+function sanitizePath(value, cwd) {
+  if (!value) return "";
+  if (win32.isAbsolute(value) && !isAbsolute(value)) return "(external)";
+  if (!isAbsolute(value)) return sanitizeDiagnosticSecrets(value.replaceAll("\\", "/"));
+  const local = relative(canonicalPath(cwd), canonicalPath(value)).replaceAll(sep, "/");
+  return local.startsWith("../") || local === ".." ? "(external)" : local || ".";
+}
+function sanitizeDiagnosticContext(value, cwd) {
+  if (!value) return void 0;
+  const sanitized = boundText(sanitizeMessage(value, cwd), 300);
+  return sanitized || void 0;
+}
+function localPathAliases(path) {
+  return [.../* @__PURE__ */ new Set([resolve(path), canonicalPath(path)])].sort(
+    (left, right) => right.length - left.length
+  );
+}
+function canonicalPath(path) {
+  try {
+    return realpathSync.native(resolve(path));
+  } catch {
+    return resolve(path);
+  }
+}
+function suggestionForDiagnostic(code, phase) {
+  if (code === "INVALID_TARGET" || phase === "command-validation") {
+    return "Use a documented command option and run the command again.";
+  }
+  if (phase === "config-load") {
+    return "Check the config path and its installed imports, then run the command again.";
+  }
+  if (phase === "config-validation" || code === "CONFIG_INVALID") {
+    return "Edit the reported config path to match the Tileflow config reference, then validate again.";
+  }
+  if (phase.includes("icon") || code.includes("ICON")) {
+    return "Fix the reported icon input and run validation again.";
+  }
+  if (phase.includes("font") || code.includes("FONT") || code.includes("GLYPH")) {
+    return "Fix the reported font or glyph input and run validation again.";
+  }
+  if (phase === "style-validation" || code === "STYLE_INVALID") {
+    return "Adjust the reported semantic map value and run validation again.";
+  }
+  if (phase === "hosted-validation" || code === "HOSTED_INCOMPATIBLE") {
+    return "Use a supported Hosted input or validate with the local target.";
+  }
+  if (phase === "config-inspection") {
+    return "Resolve the reported config diagnostic before inspecting the map again.";
+  }
+  return "Review the reported path and run the command again.";
+}
+function compareDiagnostics(left, right) {
+  return diagnosticSeverityRank(left.severity) - diagnosticSeverityRank(right.severity) || compareCodeUnits(left.path, right.path) || compareCodeUnits(left.domain ?? "", right.domain ?? "") || compareCodeUnits(left.target ?? "", right.target ?? "") || compareCodeUnits(left.phase, right.phase) || compareCodeUnits(left.code, right.code) || compareCodeUnits(left.message, right.message) || compareCodeUnits(left.suggestion, right.suggestion);
+}
+function diagnosticSeverityRank(severity) {
+  return severity === "error" ? 0 : severity === "warning" ? 1 : 2;
+}
+function normalizeSeverity(value, fallback) {
+  return value === "error" || value === "info" || value === "warning" ? value : fallback;
+}
+function normalizeCode(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toUpperCase().replace(/[^A-Z0-9_]/gu, "_").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizePhase(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value ?? fallback).toLowerCase().replace(/[^a-z0-9-]/gu, "-").slice(0, 64);
+  return normalized || fallback;
+}
+function normalizeCommandField(value, fallback) {
+  const normalized = sanitizeDiagnosticSecrets(value).toLowerCase().replace(/[^a-z0-9 ._-]/gu, "").trim().slice(0, 64);
+  return normalized || fallback;
+}
+function optionalField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  const field = value[key];
+  return typeof field === "string" && field.trim() ? field : void 0;
+}
+function optionalNestedField(value, key) {
+  if (!value || typeof value !== "object") return void 0;
+  return optionalField(value.details, key);
+}
+function boundText(value, limit) {
+  return value.length <= limit ? value : `${value.slice(0, limit - 1)}\u2026`;
+}
+
+export {
+  tileflowCommandDocumentSchemaVersion,
+  createTileflowCommandSummary,
+  createTileflowStructuredDiagnostics,
+  createTileflowCommandFailureDocument,
+  serializeTileflowCommandDocument
+};