@charlescms/astro 0.1.0

package/src/frontmatter.js

@@ -0,0 +1,153 @@
+import { load } from "js-yaml";
+import { getFrontmatter } from "./analyzer.js";
+import { createEntryId } from "./ids.js";
+
+/**
+ * Collect editable YAML frontmatter scalars with their exact source positions.
+ *
+ * Includes nested keys (`author.name`, `category.title`) common in content
+ * collections. The edit model stays bulletproof: only single-line scalars are
+ * located, and only the value's exact bytes are replaced — never restructuring
+ * YAML. Indentation gives the key path; an unresolvable path is skipped, so a
+ * tracking mistake can only drop a field, never corrupt the file.
+ *
+ * @param {string} source Full file contents (frontmatter is extracted internally).
+ * @param {string} file File path, used to build stable entry ids.
+ * @returns {{entries: Object}} Map of entry id → frontmatter field descriptor.
+ */
+export function collectFrontmatterFields(source, file) {
+  const frontmatter = getFrontmatter(source);
+  if (!frontmatter) return { entries: {} };
+
+  let parsed;
+  try {
+    parsed = load(frontmatter.value);
+  } catch {
+    return { entries: {} };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { entries: {} };
+  }
+
+  const entries = {};
+  let lineOffset = 0;
+  // Stack of open mapping keys (a key with no inline value), so an indented line
+  // knows its parents. Each entry is { indent, key }.
+  const stack = [];
+  for (const lineWithEnding of frontmatter.value.match(/[^\r\n]*(?:\r\n|\n|\r|$)/g) || []) {
+    if (!lineWithEnding) continue;
+    const line = lineWithEnding.replace(/\r\n$|\n$|\r$/, "");
+    const match = line.match(/^([ \t]*)([A-Za-z_][\w.-]*):[ \t]*(.*)$/);
+    if (!match) {
+      lineOffset += lineWithEnding.length;
+      continue;
+    }
+
+    const indent = match[1].length;
+    const key = match[2];
+    const rawValue = match[3];
+    // Close any sibling/deeper mappings before placing this key in the path.
+    while (stack.length && stack[stack.length - 1].indent >= indent) stack.pop();
+    const path = [...stack.map((level) => level.key), key];
+
+    // A key with no inline value opens a nested mapping (or a list); remember it
+    // so its children resolve, and move on.
+    if (rawValue.trim() === "") {
+      stack.push({ indent, key });
+      lineOffset += lineWithEnding.length;
+      continue;
+    }
+
+    const parsedValue = resolvePath(parsed, path);
+    const scalar = locateScalar(rawValue);
+    const valueType = classifyValue(parsedValue);
+    if (!scalar || !valueType) {
+      lineOffset += lineWithEnding.length;
+      continue;
+    }
+
+    const rawValueStart = line.length - rawValue.length;
+    const start = frontmatter.offset + lineOffset + rawValueStart + scalar.start;
+    const operation = {
+      kind: "frontmatter",
+      name: path.join("."),
+      start,
+      end: start + scalar.value.length,
+      oldValue: scalar.value,
+      quote: scalar.quote,
+      valueType
+    };
+    const id = createEntryId(file, [operation]);
+    entries[id] = { id, file, tag: "frontmatter", operations: [operation] };
+    lineOffset += lineWithEnding.length;
+  }
+
+  return { entries };
+}
+
+// Walk a key path (["author","name"]) through plain nested objects only. Anything
+// that isn't an own key of an object along the way yields undefined, so the line
+// is treated as non-editable rather than guessed.
+function resolvePath(root, path) {
+  let value = root;
+  for (const segment of path) {
+    if (!value || typeof value !== "object" || Array.isArray(value) || !Object.hasOwn(value, segment)) {
+      return undefined;
+    }
+    value = value[segment];
+  }
+  return value;
+}
+
+function locateScalar(valueSource) {
+  const leading = valueSource.match(/^[ \t]*/)?.[0].length || 0;
+  const value = valueSource.slice(leading);
+  if (!value || /^[|>]/.test(value) || /^[&*]/.test(value)) return null;
+
+  if (value[0] === '"' || value[0] === "'") {
+    const quote = value[0];
+    const end = findClosingQuote(value, quote);
+    if (end === -1 || !isOnlyComment(value.slice(end + 1))) return null;
+    return {
+      quote,
+      start: leading + 1,
+      value: value.slice(1, end)
+    };
+  }
+
+  const comment = value.search(/[ \t]+#/);
+  const raw = (comment === -1 ? value : value.slice(0, comment)).trimEnd();
+  if (!raw || /^(?:\[|\{)/.test(raw) || /:\s*$/.test(raw)) return null;
+  return { quote: "", start: leading, value: raw };
+}
+
+function findClosingQuote(value, quote) {
+  for (let index = 1; index < value.length; index++) {
+    if (value[index] !== quote) continue;
+    if (quote === "'" && value[index + 1] === "'") {
+      index++;
+      continue;
+    }
+    if (quote === '"' && isEscaped(value, index)) continue;
+    return index;
+  }
+  return -1;
+}
+
+function isEscaped(value, index) {
+  let slashes = 0;
+  for (let cursor = index - 1; cursor >= 0 && value[cursor] === "\\"; cursor--) slashes++;
+  return slashes % 2 === 1;
+}
+
+function isOnlyComment(value) {
+  return /^(?:[ \t]*(?:#.*)?)?$/.test(value);
+}
+
+function classifyValue(value) {
+  if (typeof value === "string") return "string";
+  if (typeof value === "number" && Number.isFinite(value)) return "number";
+  if (typeof value === "boolean") return "boolean";
+  if (value instanceof Date && !Number.isNaN(value.getTime())) return "date";
+  return null;
+}

package/src/ids.js

@@ -0,0 +1,20 @@
+// Produces stable source-map IDs from file paths and edit operations. The same
+// source yields the same ID in development and production without shared state.
+export function createEntryId(file, operations) {
+  const value = [
+    file,
+    ...operations.map((operation) => `${operation.kind}:${operation.name}:${operation.start}:${operation.end}:${operation.oldValue}`)
+  ].join("\n");
+  return `cms_${stableHash(value)}`;
+}
+
+function stableHash(value) {
+  let hash = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const bytes = new TextEncoder().encode(value);
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * prime);
+  }
+  return hash.toString(16).padStart(16, "0");
+}