@charlescms/astro 0.1.0

package/src/data-analyzer.js

@@ -0,0 +1,304 @@
+import { getFrontmatter } from "./astro-frontmatter.js";
+import { createEntryId } from "./ids.js";
+import { parseFrontmatterModule, parseValueExpression, unwrapValue } from "./js-ast.js";
+
+// Extracts editable display strings from JavaScript/TypeScript/JSON data
+// structures using the Babel AST (full grammar, exact offsets). It is not a
+// JavaScript evaluator: only string literals inside object/array structures
+// become editable, and only when they are display copy. Link targets, asset
+// paths and structural fields stay locked, and any value Babel cannot parse is
+// simply not offered — a parse problem degrades to a safe skip, never a write.
+const navLabelKeys = ["label", "text", "title", "name"];
+const navHrefKeys = ["href", "url", "to", "link", "path"];
+const structuralFieldKeys = new Set([
+  "href", "url", "uri", "src", "image", "img", "icon", "to", "link", "path",
+  "slug", "id", "key", "type", "kind", "variant", "category", "tag", "tags",
+  "status", "state", "color", "colour", "lang", "locale", "date", "datetime",
+  "time", "target", "rel", "file", "value", "class", "classname", "style"
+]);
+
+export function extractNavCollections(source, file) {
+  const entries = {};
+  for (const root of dataRoots(source, file)) {
+    forEachArray(root.node, root.name, (arrayNode, name) => {
+      const operations = navOperations(arrayNode, source, root.base);
+      if (!operations) return;
+      const id = createEntryId(file, operations);
+      entries[id] = { id, file, tag: "nav", kind: "nav", label: name || "navigation", operations };
+    });
+  }
+  return entries;
+}
+
+export function extractDataCollections(source, file) {
+  const entries = {};
+  const roots = dataRoots(source, file);
+
+  // Object arrays (cards, people, FAQs, menu dishes) and positional tuples
+  // (`[["Name","Desc","8"], …]`). Link lists are left to the nav extractor.
+  for (const root of roots) {
+    forEachArray(root.node, root.name, (arrayNode, name) => {
+      const elements = arrayNode.elements.filter(Boolean);
+      if (elements.length === 0) return;
+      if (elements.every((element) => unwrapValue(element).type === "ObjectExpression")) {
+        if (isLinkList(arrayNode)) return;
+        const { operations, media } = collectItems(elements, source, root.base);
+        if (operations.length || media.length) addDataEntry(entries, file, name || "content", operations, media);
+      } else if (elements.every((element) => unwrapValue(element).type === "ArrayExpression")) {
+        const operations = collectTuples(elements, source, root.base);
+        if (operations.length) addDataEntry(entries, file, name || "content", operations, []);
+      }
+    });
+  }
+
+  // Quoted object fields that are NOT inside an array represent site/config
+  // details (`site.phone`, address, hours). Nested objects are followed.
+  const operations = [];
+  const media = [];
+  const counter = { value: 0 };
+  for (const root of roots) collectConfigFields(root.node, "", source, root.base, operations, media, counter);
+  if (operations.length || media.length) {
+    const id = createEntryId(file, operations.length ? operations : media);
+    entries[id] = { id, file, tag: "data", kind: "data", label: "details", operations };
+    if (media.length) entries[id].media = media;
+  }
+  return entries;
+}
+
+// Shared with the Astro component analyzer so quoted component props and data
+// fields follow the same conservative definition of editable display copy.
+export function isDisplayTextField(key, value) {
+  if (structuralFieldKeys.has(key.toLowerCase())) return false;
+  if (/href|url|uri|src|slug|icon|image|img|path|id$|^id|class/i.test(key)) return false;
+  const text = String(value || "").trim();
+  if (!text || text.includes("\\")) return false;
+  if (/^(?:\/|#|https?:|mailto:|tel:|\.\.?\/|data:)/i.test(text)) return false;
+  return !/\.(?:png|jpe?g|svg|webp|gif|avif|pdf|mp4|webm|woff2?|ttf|css|js)$/i.test(text);
+}
+
+function isMediaPathField(key, value) {
+  if (!/(^|_)(image|img|photo|picture|cover|thumb|thumbnail|poster|banner|avatar|logo|icon)s?$/i.test(key)) return false;
+  return /^\/[^\s?#]+\.(?:png|jpe?g|svg|webp|gif|avif)$/i.test(String(value || "").trim());
+}
+
+function isLinkHref(value) {
+  return /^(?:\/|#|https?:|mailto:|tel:|\.\.?\/)/i.test(String(value || "").trim());
+}
+
+// An array is a navigation/link list when every item is an object carrying both
+// a label-like field and a static link destination.
+function isLinkList(arrayNode) {
+  const elements = arrayNode.elements.filter(Boolean);
+  return elements.length > 0 && elements.every((element) => {
+    const object = unwrapValue(element);
+    if (object.type !== "ObjectExpression") return false;
+    const props = objectProps(object);
+    const labelKey = navLabelKeys.find((key) => isStringProp(props, key));
+    const hrefKey = navHrefKeys.find((key) => props.has(key));
+    const href = hrefKey && props.get(hrefKey);
+    return Boolean(labelKey && href && href.type === "StringLiteral" && isLinkHref(href.value));
+  });
+}
+
+function navOperations(arrayNode, source, base) {
+  if (!isLinkList(arrayNode)) return null;
+  const elements = arrayNode.elements.filter(Boolean);
+  const operations = [];
+  elements.forEach((element, index) => {
+    const props = objectProps(unwrapValue(element));
+    const labelKey = navLabelKeys.find((key) => isStringProp(props, key));
+    const hrefKey = navHrefKeys.find((key) => props.has(key));
+    const span = literalSpan(props.get(labelKey), source, base);
+    if (!span) return;
+    operations.push({
+      kind: "data-string",
+      name: `item_${index}`,
+      quote: span.quote,
+      start: span.start,
+      end: span.end,
+      oldValue: span.value,
+      href: props.get(hrefKey).value
+    });
+  });
+  return operations.length === elements.length ? operations : null;
+}
+
+function collectItems(elements, source, base) {
+  const operations = [];
+  const media = [];
+  elements.forEach((element, index) => {
+    collectFields(unwrapValue(element), `item${index}`, source, base, operations, media);
+  });
+  return { operations, media };
+}
+
+// Walks one object's fields (any depth) into editable text operations and media
+// replacements. The field name encodes the path so a value round-trips to the
+// right control and the right source span.
+function collectFields(objectNode, prefix, source, base, operations, media) {
+  for (const property of objectNode.properties || []) {
+    if (property.type !== "ObjectProperty" || property.computed) continue;
+    const key = keyName(property.key);
+    if (key == null) continue;
+    collectValue(unwrapValue(property.value), `${prefix}_${key}`, key, source, base, operations, media);
+  }
+}
+
+function collectValue(node, name, key, source, base, operations, media) {
+  if (node.type === "ObjectExpression") {
+    collectFields(node, name, source, base, operations, media);
+    return;
+  }
+  if (node.type === "ArrayExpression") {
+    node.elements.forEach((element, index) => {
+      if (element) collectValue(unwrapValue(element), `${name}_${index}`, key, source, base, operations, media);
+    });
+    return;
+  }
+  if (node.type !== "StringLiteral") return;
+  const span = literalSpan(node, source, base);
+  if (!span) return;
+  if (isMediaPathField(key, span.value)) {
+    media.push({ name, label: key, path: span.value });
+  } else if (isDisplayTextField(key, span.value)) {
+    operations.push({ kind: "data-string", name, quote: span.quote, start: span.start, end: span.end, oldValue: span.value });
+  }
+}
+
+function collectTuples(rows, source, base) {
+  const operations = [];
+  rows.forEach((rowNode, row) => {
+    const cells = unwrapValue(rowNode).elements.filter(Boolean);
+    if (cells.length === 0 || !cells.every((cell) => unwrapValue(cell).type === "StringLiteral")) return;
+    cells.forEach((cell, column) => {
+      const span = literalSpan(unwrapValue(cell), source, base);
+      if (!span || !isDisplayTextField("", span.value)) return;
+      operations.push({
+        kind: "data-string",
+        name: `row${row}_col${column}`,
+        quote: span.quote,
+        start: span.start,
+        end: span.end,
+        oldValue: span.value
+      });
+    });
+  });
+  return operations;
+}
+
+// Object string fields that are not inside any array. Nested objects are
+// followed; arrays are skipped here because their contents are handled as data
+// collections (object arrays / tuples) above.
+function collectConfigFields(node, path, source, base, operations, media, counter) {
+  if (!node || node.type !== "ObjectExpression") return;
+  for (const property of node.properties || []) {
+    if (property.type !== "ObjectProperty" || property.computed) continue;
+    const key = keyName(property.key);
+    if (key == null) continue;
+    const value = unwrapValue(property.value);
+    const fieldPath = path ? `${path}_${key}` : key;
+    if (value.type === "ObjectExpression") {
+      collectConfigFields(value, fieldPath, source, base, operations, media, counter);
+    } else if (value.type === "StringLiteral") {
+      const span = literalSpan(value, source, base);
+      if (!span) continue;
+      const name = `field${counter.value++}_${fieldPath}`;
+      if (isMediaPathField(key, span.value)) {
+        media.push({ name, label: key, path: span.value });
+      } else if (isDisplayTextField(key, span.value)) {
+        operations.push({ kind: "data-string", name, quote: span.quote, start: span.start, end: span.end, oldValue: span.value });
+      }
+    }
+  }
+}
+
+function addDataEntry(entries, file, label, operations, media) {
+  const id = createEntryId(file, operations.length ? operations : media);
+  entries[id] = { id, file, tag: "data", kind: "data", label, operations };
+  if (media.length > 0) entries[id].media = media;
+}
+
+// --- AST helpers -------------------------------------------------------------
+
+// Parses a source file into the top-level value roots worth walking, carrying
+// the declaration name (used to label a collection) and the base offset that
+// maps AST positions back to the original source.
+function dataRoots(source, file) {
+  if (/\.json$/i.test(file)) {
+    const node = parseValueExpression(source);
+    return node ? [{ name: "", node, base: 0 }] : [];
+  }
+  let code = source;
+  let base = 0;
+  if (file.endsWith(".astro")) {
+    const frontmatter = getFrontmatter(source);
+    if (!frontmatter) return [];
+    code = frontmatter.value;
+    base = frontmatter.offset;
+  }
+  const ast = parseFrontmatterModule(code);
+  if (!ast) return [];
+  const roots = [];
+  for (const statement of ast.program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations) {
+        if (declarator.id.type === "Identifier" && declarator.init) {
+          roots.push({ name: declarator.id.name, node: unwrapValue(declarator.init), base });
+        }
+      }
+    } else if (statement.type === "ExportDefaultDeclaration") {
+      roots.push({ name: "", node: unwrapValue(statement.declaration), base });
+    }
+  }
+  return roots;
+}
+
+// Visits every array literal reachable through objects, carrying the nearest
+// declaration/property name so a collection can be labelled.
+function forEachArray(node, name, visit) {
+  if (!node || typeof node.type !== "string") return;
+  if (node.type === "ArrayExpression") {
+    visit(node, name);
+    for (const element of node.elements) forEachArray(unwrapValue(element), name, visit);
+  } else if (node.type === "ObjectExpression") {
+    for (const property of node.properties) {
+      if (property.type === "ObjectProperty") {
+        forEachArray(unwrapValue(property.value), keyName(property.key) || name, visit);
+      }
+    }
+  }
+}
+
+function objectProps(objectNode) {
+  const props = new Map();
+  for (const property of objectNode.properties || []) {
+    if (property.type !== "ObjectProperty" || property.computed) continue;
+    const key = keyName(property.key);
+    if (key != null) props.set(key, unwrapValue(property.value));
+  }
+  return props;
+}
+
+function isStringProp(props, key) {
+  return props.get(key)?.type === "StringLiteral";
+}
+
+function keyName(key) {
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "StringLiteral") return key.value;
+  if (key.type === "NumericLiteral") return String(key.value);
+  return null;
+}
+
+// The exact source span of a string literal's value (inside the quotes). Escaped
+// strings are skipped: their raw bytes carry backslashes the write path would
+// have to re-encode, so they stay locked instead of binding to a partial value.
+function literalSpan(node, source, base) {
+  if (!node || node.type !== "StringLiteral") return null;
+  const start = base + node.start + 1;
+  const end = base + node.end - 1;
+  const value = source.slice(start, end);
+  if (value.includes("\\")) return null;
+  return { value, quote: source[base + node.start], start, end };
+}