@open-press/core 0.3.0

package/engine/source-text-tools.mjs

@@ -0,0 +1,280 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { resolveActiveSourceWorkspace } from "./source-workspace.mjs";
+
+const MARKDOWN_EXTENSIONS = new Set([".md"]);
+const ALL_SOURCE_EXTENSIONS = new Set([".css", ".html", ".js", ".json", ".md", ".mdx", ".mjs", ".ts", ".tsx"]);
+const REACT_IMPLEMENTATION_EXTENSIONS = new Set([".css", ".html", ".js", ".json", ".mjs", ".ts", ".tsx"]);
+
+export async function searchSourceText({ config, query, scope = "content", caseSensitive = false }) {
+  const files = await collectSourceTextFiles(config, { scope });
+  const rawMatches = [];
+  for (const file of files) {
+    rawMatches.push(...findLiteralMatches(file.text, query, { caseSensitive }).map((match) => ({
+      ...match,
+      scope: file.scope,
+      file: file.name,
+      path: file.relativePath,
+    })));
+  }
+  const matches = rawMatches.map((match, index) => ({
+    ...match,
+    id: `match-${String(index + 1).padStart(4, "0")}`,
+  }));
+
+  return {
+    kind: "search",
+    query,
+    scope,
+    caseSensitive,
+    matchCount: matches.length,
+    files: summarizeFiles(matches),
+    matches,
+  };
+}
+
+export async function replaceSourceText({
+  config,
+  from,
+  to,
+  scope = "content",
+  caseSensitive = false,
+  includeCode = false,
+  apply = false,
+}) {
+  const files = await collectSourceTextFiles(config, { scope });
+  const changes = [];
+  let matchCount = 0;
+
+  for (const file of files) {
+    const result = replaceLiteralMatches(file.text, from, to, { caseSensitive, includeCode });
+    if (result.replacements.length === 0) continue;
+    matchCount += result.replacements.length;
+    changes.push({
+      scope: file.scope,
+      file: file.name,
+      path: file.relativePath,
+      absolutePath: file.absolutePath,
+      replacements: result.replacements.map((replacement, index) => ({
+        ...replacement,
+        id: `replace-${String(matchCount - result.replacements.length + index + 1).padStart(4, "0")}`,
+      })),
+    });
+    if (apply) {
+      await fs.writeFile(file.absolutePath, result.text, "utf8");
+    }
+  }
+
+  return {
+    kind: "replace",
+    from,
+    to,
+    scope,
+    caseSensitive,
+    includeCode,
+    applied: apply,
+    matchCount,
+    fileCount: changes.length,
+    changes,
+  };
+}
+
+export async function collectSourceTextFiles(config, { scope = "content" } = {}) {
+  const roots = await sourceRoots(config, scope);
+  const files = [];
+  for (const rootInfo of roots) {
+    const visit = async (absolutePath) => {
+      const extension = path.extname(absolutePath);
+      if (!rootInfo.extensions.has(extension)) return;
+      const relativePath = path.relative(config.root, absolutePath).replaceAll("\\", "/");
+      files.push({
+        scope: rootInfo.scope,
+        name: path.basename(absolutePath),
+        absolutePath,
+        relativePath,
+        text: await fs.readFile(absolutePath, "utf8"),
+      });
+    };
+    if (rootInfo.kind === "file") {
+      try {
+        await fs.access(rootInfo.absolutePath);
+        await visit(rootInfo.absolutePath);
+      } catch (error) {
+        if (error?.code !== "ENOENT") throw error;
+      }
+    } else {
+      await walkFiles(rootInfo.absolutePath, visit);
+    }
+  }
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return files;
+}
+
+export function findLiteralMatches(text, query, { caseSensitive = false } = {}) {
+  if (!query) return [];
+  const matches = [];
+  forEachLine(text, ({ line, lineNumber, lineOffset }) => {
+    for (const range of findLineMatches(line, query, { caseSensitive })) {
+      matches.push({
+        line: lineNumber,
+        column: range.start + 1,
+        index: lineOffset + range.start,
+        text: line.slice(range.start, range.end),
+        preview: previewLine(line, range.start, range.end),
+      });
+    }
+  });
+  return matches;
+}
+
+export function replaceLiteralMatches(text, from, to, { caseSensitive = false, includeCode = false } = {}) {
+  if (!from) return { text, replacements: [] };
+  let output = "";
+  const replacements = [];
+  let inFence = false;
+
+  forEachLine(text, ({ line, ending, lineNumber, lineOffset }) => {
+    const fenceLine = isFenceLine(line);
+    const replaceLine = includeCode || (!inFence && !fenceLine);
+    if (!replaceLine) {
+      output += line + ending;
+      if (fenceLine) inFence = !inFence;
+      return;
+    }
+
+    const ranges = findLineMatches(line, from, { caseSensitive });
+    if (ranges.length === 0) {
+      output += line + ending;
+      if (fenceLine) inFence = !inFence;
+      return;
+    }
+
+    let nextLine = "";
+    let cursor = 0;
+    for (const range of ranges) {
+      nextLine += line.slice(cursor, range.start) + to;
+      replacements.push({
+        line: lineNumber,
+        column: range.start + 1,
+        index: lineOffset + range.start,
+        before: line,
+        after: replaceRangesInLine(line, ranges, to),
+        text: line.slice(range.start, range.end),
+        replacement: to,
+        previewBefore: previewLine(line, range.start, range.end),
+        previewAfter: previewLine(replaceRangesInLine(line, ranges, to), range.start, range.start + to.length),
+      });
+      cursor = range.end;
+    }
+    nextLine += line.slice(cursor);
+    output += nextLine + ending;
+    if (fenceLine) inFence = !inFence;
+  });
+
+  return { text: output, replacements };
+}
+
+async function sourceRoots(config, scope) {
+  const sourceWorkspace = await resolveActiveSourceWorkspace(config);
+  const sourceConfig = sourceWorkspace.config;
+  const contentRoot = {
+    scope: "content",
+    kind: "dir",
+    absolutePath: sourceWorkspace.sourceDir,
+    extensions: sourceWorkspace.contentExtensions,
+  };
+
+  if (scope === "all") {
+    const roots = [
+      contentRoot,
+      { scope: "design-doc", kind: "file", absolutePath: sourceConfig.paths.designDoc, extensions: MARKDOWN_EXTENSIONS },
+      { scope: "components", kind: "dir", absolutePath: sourceConfig.paths.componentsDir, extensions: ALL_SOURCE_EXTENSIONS },
+      { scope: "document-entry", kind: "file", absolutePath: sourceWorkspace.entryPath, extensions: REACT_IMPLEMENTATION_EXTENSIONS },
+      { scope: "chapters", kind: "dir", absolutePath: sourceWorkspace.sourceDir, extensions: REACT_IMPLEMENTATION_EXTENSIONS },
+    ];
+    return roots;
+  }
+  return [contentRoot];
+}
+
+async function walkFiles(directory, visit) {
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const absolutePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) await walkFiles(absolutePath, visit);
+    else if (entry.isFile()) await visit(absolutePath);
+  }
+}
+
+function forEachLine(text, visit) {
+  const lineRe = /([^\r\n]*)(\r\n|\n|\r|$)/g;
+  let lineNumber = 1;
+  let offset = 0;
+  let match;
+  while ((match = lineRe.exec(text))) {
+    const [full, line, ending] = match;
+    if (full === "") break;
+    visit({ line, ending, lineNumber, lineOffset: offset });
+    offset += full.length;
+    lineNumber += 1;
+  }
+}
+
+function findLineMatches(line, query, { caseSensitive }) {
+  const haystack = caseSensitive ? line : line.toLowerCase();
+  const needle = caseSensitive ? query : query.toLowerCase();
+  const ranges = [];
+  let cursor = 0;
+  while (needle && cursor <= haystack.length) {
+    const start = haystack.indexOf(needle, cursor);
+    if (start < 0) break;
+    const end = start + needle.length;
+    ranges.push({ start, end });
+    cursor = end;
+  }
+  return ranges;
+}
+
+function replaceRangesInLine(line, ranges, replacement) {
+  let output = "";
+  let cursor = 0;
+  for (const range of ranges) {
+    output += line.slice(cursor, range.start) + replacement;
+    cursor = range.end;
+  }
+  return output + line.slice(cursor);
+}
+
+function previewLine(line, start, end) {
+  const previewStart = Math.max(0, start - 40);
+  const previewEnd = Math.min(line.length, end + 40);
+  const prefix = previewStart > 0 ? "..." : "";
+  const suffix = previewEnd < line.length ? "..." : "";
+  return `${prefix}${line.slice(previewStart, previewEnd)}${suffix}`;
+}
+
+function summarizeFiles(matches) {
+  const summaries = new Map();
+  for (const match of matches) {
+    const current = summaries.get(match.path) ?? {
+      scope: match.scope,
+      file: match.file,
+      path: match.path,
+      matchCount: 0,
+    };
+    current.matchCount += 1;
+    summaries.set(match.path, current);
+  }
+  return Array.from(summaries.values());
+}
+
+function isFenceLine(line) {
+  return /^\s*(```|~~~)/.test(line);
+}

package/engine/source-workspace.mjs

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { loadReactDocumentEntry } from "./react/document-entry.mjs";
+
+export const REACT_MDX_CONTENT_EXTENSIONS = new Set([".mdx"]);
+
+export async function resolveActiveSourceWorkspace(config) {
+  const reactEntry = await loadReactDocumentEntry(config.root);
+  if (!reactEntry) {
+    throw new Error(
+      "React/MDX document entry not found. Expected document/index.tsx; run `node engine/cli.mjs migrate-to-react .` before using workspace source tools.",
+    );
+  }
+
+  return {
+    kind: "react-mdx",
+    checkedName: "react-source",
+    config: reactEntry.config,
+    entryPath: reactEntry.entryPath,
+    sourceDir: reactEntry.config.paths.sourceDir,
+    contentExtensions: REACT_MDX_CONTENT_EXTENSIONS,
+    contentLabel: "React MDX chapter source",
+    missingCode: "react-source.missing",
+    emptyCode: "react-source.empty",
+    missingMessage: `React chapter source directory does not exist yet; create ${reactEntry.config.sourceDir}/ before running export.`,
+    emptyMessage: "React chapter source directory has no `*.mdx` files; the document will export with zero chapter pages.",
+  };
+}
+
+export async function collectActiveContentFiles(sourceWorkspace, { skipUnderscoreFiles = false } = {}) {
+  const files = [];
+  await walkFiles(sourceWorkspace.sourceDir, async (absolutePath) => {
+    if (!sourceWorkspace.contentExtensions.has(path.extname(absolutePath))) return;
+    const name = path.basename(absolutePath);
+    if (skipUnderscoreFiles && name.startsWith("_")) return;
+    files.push({
+      absolutePath,
+      name,
+      relativePath: rootRelativePath(sourceWorkspace.config, absolutePath),
+      sourceRelativePath: path.relative(sourceWorkspace.sourceDir, absolutePath).replaceAll("\\", "/"),
+      text: await fs.readFile(absolutePath, "utf8"),
+    });
+  });
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+  return files;
+}
+
+export async function sourceDirectoryExists(sourceWorkspace) {
+  try {
+    const stat = await fs.stat(sourceWorkspace.sourceDir);
+    return stat.isDirectory();
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+
+export function rootRelativePath(config, absolutePath) {
+  return path.relative(config.root, absolutePath).replaceAll("\\", "/");
+}
+
+async function walkFiles(directory, visit) {
+  let entries;
+  try {
+    entries = await fs.readdir(directory, { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return;
+    throw error;
+  }
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const absolutePath = path.join(directory, entry.name);
+    if (entry.isDirectory()) await walkFiles(absolutePath, visit);
+    else if (entry.isFile()) await visit(absolutePath);
+  }
+}