@sightmap/sightmap 0.2.1 → 0.3.0

package/dist/index.js

@@ -74,6 +74,9 @@ var DUPLICATE_ROUTE = "duplicate-route";
 var ROUTE_SHADOWING = "route-shadowing";
 var UNKNOWN_SOURCE = "unknown-source";
 var SELECTOR_SYNTAX = "selector-syntax";
+var FMT_NOT_CANONICAL = "fmt.not-canonical";
+var FMT_PARSE_ERROR = "fmt.parse-error";
+var FMT_SCHEMA_INVALID = "fmt.schema-invalid";
 
 // src/validate.ts
 import { existsSync, readFileSync } from "fs";
@@ -649,17 +652,58 @@ async function lint(sightmap, opts = {}) {
 
 // src/format/index.ts
 import { stringify } from "yaml";
-var CANONICAL_KEY_ORDER = [
+
+// src/format/canonical-rules.ts
+var TOP_LEVEL_KEY_ORDER = [
   "version",
   "memory",
   "views",
   "components",
   "requests"
 ];
+var VIEW_KEY_ORDER = [
+  "name",
+  "route",
+  "description",
+  "components",
+  "memory",
+  "requests"
+];
+var COMPONENT_KEY_ORDER = [
+  "name",
+  "selector",
+  "description",
+  "children",
+  "memory"
+];
+var REQUEST_KEY_ORDER = [
+  "name",
+  "route",
+  "method",
+  "description",
+  "source",
+  "request",
+  "response",
+  "headers",
+  "memory"
+];
+function compareByName(a, b) {
+  return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;
+}
+function compareRequests(a, b) {
+  if (a.route !== b.route) return a.route < b.route ? -1 : 1;
+  const am = a.method ?? "";
+  const bm = b.method ?? "";
+  return am < bm ? -1 : am > bm ? 1 : 0;
+}
+
+// src/format/index.ts
 function format(input) {
   const ordered = {};
-  for (const key of CANONICAL_KEY_ORDER) {
-    if (input[key] !== void 0) ordered[key] = input[key];
+  for (const key of TOP_LEVEL_KEY_ORDER) {
+    if (input[key] !== void 0) {
+      ordered[key] = input[key];
+    }
   }
   for (const key of Object.keys(input)) {
     if (key.startsWith("__")) continue;
@@ -672,9 +716,264 @@ function format(input) {
   });
   return yaml3.endsWith("\n") ? yaml3 : yaml3 + "\n";
 }
+
+// src/format/canonicalize.ts
+import { parseDocument, isMap, isSeq, isScalar } from "yaml";
+function canonicalize(input, opts) {
+  const doc = parseDocument(input, { keepSourceTokens: false });
+  const first = doc.errors[0];
+  if (first !== void 0) {
+    const loc = first.linePos?.[0] ? { line: first.linePos[0].line, column: first.linePos[0].col } : void 0;
+    return {
+      kind: "parse-error",
+      diagnostics: [
+        {
+          severity: "error",
+          code: FMT_PARSE_ERROR,
+          message: first.message,
+          file: opts.file,
+          ...loc !== void 0 ? { loc } : {}
+        }
+      ]
+    };
+  }
+  const v = validate(input, { sourceFile: opts.file });
+  if (!v.ok) {
+    const diagnostics = v.diagnostics.map((d) => ({
+      ...d,
+      severity: "error",
+      code: FMT_SCHEMA_INVALID,
+      file: opts.file
+    }));
+    return { kind: "schema-invalid", diagnostics };
+  }
+  if (isMap(doc.contents)) {
+    reorderTopLevelKeys(doc.contents);
+    reorderEntriesUnder(doc.contents, "views", VIEW_KEY_ORDER);
+    reorderEntriesUnder(doc.contents, "components", COMPONENT_KEY_ORDER);
+    reorderEntriesUnder(doc.contents, "requests", REQUEST_KEY_ORDER);
+    forEachViewEntry(doc.contents, (view) => {
+      reorderEntriesUnder(view, "components", COMPONENT_KEY_ORDER);
+      reorderEntriesUnder(view, "requests", REQUEST_KEY_ORDER);
+      forEachComponentEntry(view, "components", (cmp) => {
+        reorderChildrenRecursive(cmp);
+      });
+    });
+    forEachComponentEntry(doc.contents, "components", (cmp) => {
+      reorderChildrenRecursive(cmp);
+    });
+    sortTopLevelSeq(doc.contents, "views", (a, b) => {
+      const an = scalarPropFromMapItem(a, "name");
+      const bn = scalarPropFromMapItem(b, "name");
+      return compareByName({ name: an ?? "" }, { name: bn ?? "" });
+    });
+    sortTopLevelSeq(doc.contents, "components", (a, b) => {
+      const an = scalarPropFromMapItem(a, "name");
+      const bn = scalarPropFromMapItem(b, "name");
+      return compareByName({ name: an ?? "" }, { name: bn ?? "" });
+    });
+    sortTopLevelSeq(doc.contents, "requests", (a, b) => {
+      return compareRequests(
+        { route: scalarPropFromMapItem(a, "route") ?? "", method: scalarPropFromMapItem(a, "method") },
+        { route: scalarPropFromMapItem(b, "route") ?? "", method: scalarPropFromMapItem(b, "method") }
+      );
+    });
+    visitAllScalars(doc, (scalar) => {
+      if (typeof scalar.value !== "string") return;
+      scalar.type = chooseQuoteType(scalar.value);
+    });
+    normalizeBlankLines(doc);
+  }
+  const output = serialize(doc);
+  return { kind: "canonical", text: output, changed: output !== input };
+}
+function reorderTopLevelKeys(map) {
+  reorderMapKeys(map, TOP_LEVEL_KEY_ORDER);
+}
+function reorderMapKeys(map, keyOrder) {
+  const items = map.items;
+  const byKey = /* @__PURE__ */ new Map();
+  const unknownInOrder = [];
+  for (const item of items) {
+    const key = scalarKey(item);
+    if (key === null) {
+      unknownInOrder.push(item);
+      continue;
+    }
+    if (keyOrder.includes(key)) {
+      byKey.set(key, item);
+    } else {
+      unknownInOrder.push(item);
+    }
+  }
+  const reordered = [];
+  for (const k of keyOrder) {
+    const p = byKey.get(k);
+    if (p !== void 0) reordered.push(p);
+  }
+  reordered.push(...unknownInOrder);
+  map.items = reordered;
+}
+function reorderEntriesUnder(map, key, keyOrder) {
+  const seq = lookupSeq(map, key);
+  if (seq === null) return;
+  for (const item of seq.items) {
+    if (isMap(item)) reorderMapKeys(item, keyOrder);
+  }
+}
+function forEachViewEntry(root, fn) {
+  const seq = lookupSeq(root, "views");
+  if (seq === null) return;
+  for (const item of seq.items) {
+    if (isMap(item)) fn(item);
+  }
+}
+function forEachComponentEntry(root, key, fn) {
+  const seq = lookupSeq(root, key);
+  if (seq === null) return;
+  for (const item of seq.items) {
+    if (isMap(item)) fn(item);
+  }
+}
+function reorderChildrenRecursive(cmp) {
+  const children = lookupSeq(cmp, "children");
+  if (children === null) return;
+  for (const child of children.items) {
+    if (!isMap(child)) continue;
+    reorderMapKeys(child, COMPONENT_KEY_ORDER);
+    reorderChildrenRecursive(child);
+  }
+}
+function lookupSeq(map, key) {
+  for (const item of map.items) {
+    if (scalarKey(item) === key && isSeq(item.value)) return item.value;
+  }
+  return null;
+}
+function scalarKey(pair) {
+  const k = pair.key ?? null;
+  if (k === null) return null;
+  const v = typeof k === "object" && k !== null && "value" in k ? k.value : k;
+  return typeof v === "string" ? v : null;
+}
+function sortTopLevelSeq(root, key, cmp) {
+  const seq = lookupSeq(root, key);
+  if (seq === null) return;
+  seq.items = seq.items.slice().sort(cmp);
+}
+function scalarPropFromMapItem(item, key) {
+  if (!isMap(item)) return void 0;
+  for (const pair of item.items) {
+    if (scalarKey(pair) !== key) continue;
+    const v = pair.value;
+    if (v !== null && typeof v === "object" && "value" in v) {
+      const inner = v.value;
+      return typeof inner === "string" ? inner : void 0;
+    }
+    return typeof v === "string" ? v : void 0;
+  }
+  return void 0;
+}
+function visitAllScalars(doc, fn) {
+  walk(doc.contents, fn);
+}
+function walk(node, fn) {
+  if (node === null || node === void 0) return;
+  if (isScalar(node)) {
+    fn(node);
+    return;
+  }
+  if (isMap(node)) {
+    for (const pair of node.items) {
+      walk(pair.key, fn);
+      walk(pair.value, fn);
+    }
+    return;
+  }
+  if (isSeq(node)) {
+    for (const item of node.items) walk(item, fn);
+  }
+}
+function normalizeBlankLines(doc) {
+  const root = doc.contents;
+  if (!isMap(root)) return;
+  const firstPair = root.items[0];
+  if (firstPair !== void 0) {
+    const keyNode = firstPair.key;
+    const docMutable = doc;
+    const keyComment = keyNode?.commentBefore;
+    const docComment = docMutable.commentBefore;
+    if (typeof keyComment === "string" && keyComment.length > 0) {
+      docMutable.commentBefore = keyComment;
+      keyNode.commentBefore = null;
+    }
+    const hasHeader = typeof docMutable.commentBefore === "string" && docMutable.commentBefore.length > 0 || typeof docComment === "string" && docComment.length > 0;
+    firstPair.spaceBefore = hasHeader;
+  }
+  for (const key of ["views", "components", "requests"]) {
+    const seq = lookupSeq(root, key);
+    if (seq === null) continue;
+    seq.items.forEach((item, idx) => {
+      if (typeof item === "object" && item !== null) {
+        item.spaceBefore = idx > 0;
+      }
+    });
+    for (const item of seq.items) {
+      if (isMap(item)) clearInnerBlankLines(item);
+    }
+  }
+}
+function clearInnerBlankLines(map) {
+  for (const pair of map.items) {
+    pair.spaceBefore = false;
+    if (isSeq(pair.value)) {
+      for (const item of pair.value.items) {
+        if (typeof item === "object" && item !== null) {
+          item.spaceBefore = false;
+        }
+        if (isMap(item)) clearInnerBlankLines(item);
+      }
+    } else if (isMap(pair.value)) {
+      clearInnerBlankLines(pair.value);
+    }
+  }
+}
+function chooseQuoteType(value) {
+  if (requiresDoubleQuotes(value)) return "QUOTE_DOUBLE";
+  if (value.includes('"')) return "QUOTE_SINGLE";
+  if (isPlainSafe(value)) return "PLAIN";
+  return "QUOTE_SINGLE";
+}
+function requiresDoubleQuotes(s) {
+  return /[\x00-\x1f]/.test(s);
+}
+function isPlainSafe(s) {
+  if (s.length === 0) return false;
+  const first = s[0];
+  if ("-?:,[]{}#&*!|>'\"%@`".includes(first)) return false;
+  if (first === " " || first === "	") return false;
+  if (s.includes(": ")) return false;
+  if (s.includes(" #")) return false;
+  if (/^(true|false|null|~|y|n|yes|no|on|off|True|False|Null|Yes|No|On|Off|TRUE|FALSE|NULL|YES|NO|ON|OFF)$/.test(s)) return false;
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) return false;
+  if (/^0[xob]/.test(s)) return false;
+  return true;
+}
+function serialize(doc) {
+  const out = doc.toString({
+    indent: 2,
+    lineWidth: 0,
+    minContentWidth: 0,
+    blockQuote: "literal"
+  });
+  return out.endsWith("\n") ? out : out + "\n";
+}
 export {
   DUPLICATE_ROUTE,
   DUPLICATE_VIEW_NAME,
+  FMT_NOT_CANONICAL,
+  FMT_PARSE_ERROR,
+  FMT_SCHEMA_INVALID,
   MERGE_COLLISION_COMPONENT,
   MERGE_COLLISION_VIEW,
   PARSE_ERROR,
@@ -683,6 +982,7 @@ export {
   SELECTOR_SYNTAX,
   UNKNOWN_SOURCE,
   UNKNOWN_VERSION,
+  canonicalize,
   explain,
   format,
   lint,