@bfra.me/doc-sync 0.1.0 → 0.1.2

package/lib/{chunk-DR6UG237.js → chunk-DTXB5PMR.js}

@@ -1,17 +1,25 @@
 import {
-  createHeadingPattern,
-  extractCodeBlocks,
-  findEmptyMarkdownLinks,
   generateMDXDocument,
-  hasComponent,
   mergeContent,
   validateMDXSyntax
-} from "./chunk-G5KKGJYO.js";
+} from "./chunk-CUBMCGAY.js";
 import {
   analyzePublicAPI,
   parsePackageComplete,
   parseReadmeFile
-} from "./chunk-6NKAJT2M.js";
+} from "./chunk-VHUUC45J.js";
+import {
+  createHeadingPattern,
+  extractCodeBlocks,
+  findEmptyMarkdownLinks,
+  hasComponent
+} from "./chunk-GZ2MP3VN.js";
+import {
+  createDocDebouncer,
+  createDocWatcher,
+  determineRegenerationScope,
+  groupChangesByPackage
+} from "./chunk-45NROJIG.js";
 
 // src/orchestrator/package-scanner.ts
 import fs from "fs/promises";
@@ -197,318 +205,6 @@ function getPackageScope(packageName) {
   return void 0;
 }
 
-// src/watcher/file-watcher.ts
-import path2 from "path";
-import process from "process";
-import { createFileWatcher as createBaseWatcher } from "@bfra.me/es/watcher";
-var DEFAULT_WATCH_PATTERNS = [
-  "packages/*/README.md",
-  "packages/*/readme.md",
-  "packages/*/package.json",
-  "packages/*/src/**/*.ts",
-  "packages/*/src/**/*.tsx"
-];
-var DEFAULT_IGNORE_PATTERNS = [
-  "**/node_modules/**",
-  "**/lib/**",
-  "**/dist/**",
-  "**/.git/**",
-  "**/coverage/**",
-  "**/*.test.ts",
-  "**/*.spec.ts",
-  "**/__tests__/**",
-  "**/__mocks__/**"
-];
-function extractPackageName(filePath, root) {
-  const relativePath = path2.relative(root, filePath);
-  const parts = relativePath.split(path2.sep);
-  if (parts[0] === "packages" && parts.length > 1) {
-    return parts[1];
-  }
-  return void 0;
-}
-function createDocWatcher(options = {}) {
-  const {
-    rootDir = process.cwd(),
-    debounceMs = 300,
-    additionalIgnore = [],
-    usePolling = false
-  } = options;
-  const watchPaths = DEFAULT_WATCH_PATTERNS.map((pattern) => path2.join(rootDir, pattern));
-  const ignoredPatterns = [...DEFAULT_IGNORE_PATTERNS, ...additionalIgnore];
-  const watcherOptions = {
-    debounceMs,
-    ignored: ignoredPatterns,
-    usePolling
-  };
-  const baseWatcher = createBaseWatcher(watchPaths, watcherOptions);
-  const handlers = /* @__PURE__ */ new Set();
-  function transformToDocEvents(changes) {
-    return changes.map((change) => ({
-      type: change.type,
-      path: change.path,
-      packageName: extractPackageName(change.path, rootDir),
-      timestamp: new Date(change.timestamp)
-    }));
-  }
-  return {
-    async start() {
-      baseWatcher.on("change", (event) => {
-        const docEvents = transformToDocEvents(event.changes);
-        for (const handler of handlers) {
-          Promise.resolve(handler(docEvents)).catch((error) => {
-            console.error("[doc-sync] Error in change handler:", error);
-          });
-        }
-      });
-      await baseWatcher.start();
-    },
-    async close() {
-      await baseWatcher.close();
-      handlers.clear();
-    },
-    onChanges(handler) {
-      handlers.add(handler);
-      return () => {
-        handlers.delete(handler);
-      };
-    },
-    getWatchedPaths() {
-      return watchPaths;
-    }
-  };
-}
-function categorizeFile(filePath) {
-  const basename = path2.basename(filePath).toLowerCase();
-  if (basename === "readme.md" || basename === "readme") {
-    return "readme";
-  }
-  if (basename === "package.json") {
-    return "package-json";
-  }
-  const ext = path2.extname(filePath).toLowerCase();
-  if (ext === ".ts" || ext === ".tsx") {
-    return "source";
-  }
-  return "unknown";
-}
-function groupChangesByPackage(events) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const pkg = event.packageName ?? "__unknown__";
-    const existing = grouped.get(pkg);
-    if (existing === void 0) {
-      grouped.set(pkg, [event]);
-    } else {
-      existing.push(event);
-    }
-  }
-  return grouped;
-}
-function filterDocumentationChanges(events) {
-  return events.filter((event) => {
-    const category = categorizeFile(event.path);
-    return category !== "unknown";
-  });
-}
-
-// src/watcher/change-detector.ts
-import { createChangeDetector as createBaseDetector } from "@bfra.me/es/watcher";
-function createDocChangeDetector(options = {}) {
-  const baseDetector = createBaseDetector({ algorithm: options.algorithm });
-  const packageFiles = /* @__PURE__ */ new Map();
-  return {
-    async hasChanged(filePath) {
-      return baseDetector.hasChanged(filePath);
-    },
-    async record(filePath) {
-      await baseDetector.record(filePath);
-    },
-    async recordPackage(pkg, files) {
-      const fileSet = new Set(files);
-      packageFiles.set(pkg.name, fileSet);
-      await Promise.all(files.map(async (file) => baseDetector.record(file)));
-    },
-    clear(filePath) {
-      baseDetector.clear(filePath);
-      for (const fileSet of packageFiles.values()) {
-        fileSet.delete(filePath);
-      }
-    },
-    clearAll() {
-      baseDetector.clearAll();
-      packageFiles.clear();
-    },
-    async analyzeChanges(events) {
-      const packageChanges = /* @__PURE__ */ new Map();
-      for (const event of events) {
-        const packageName = event.packageName ?? "__unknown__";
-        const category = categorizeFile(event.path);
-        let analysis = packageChanges.get(packageName);
-        if (analysis === void 0) {
-          analysis = { categories: /* @__PURE__ */ new Set(), files: [] };
-          packageChanges.set(packageName, analysis);
-        }
-        if (category !== "unknown") {
-          analysis.categories.add(category);
-        }
-        analysis.files.push(event.path);
-      }
-      const results = [];
-      for (const [packageName, analysis] of packageChanges) {
-        const changedCategories = [...analysis.categories];
-        const needsRegeneration = changedCategories.includes("readme") || changedCategories.includes("package-json") || changedCategories.includes("source");
-        results.push({
-          packageName,
-          needsRegeneration,
-          changedCategories,
-          changedFiles: analysis.files
-        });
-      }
-      return results;
-    }
-  };
-}
-function determineRegenerationScope(changedCategories) {
-  const hasReadme = changedCategories.includes("readme");
-  const hasSource = changedCategories.includes("source");
-  const hasPackageJson = changedCategories.includes("package-json");
-  if (hasReadme && hasSource) {
-    return "full";
-  }
-  if (hasSource) {
-    return "api-only";
-  }
-  if (hasReadme) {
-    return "readme-only";
-  }
-  if (hasPackageJson) {
-    return "metadata-only";
-  }
-  return "none";
-}
-async function hasAnyFileChanged(detector, files) {
-  const results = await Promise.all(files.map(async (file) => detector.hasChanged(file)));
-  return results.some((changed) => changed);
-}
-
-// src/watcher/debouncer.ts
-import { createDebouncer as createBaseDebouncer } from "@bfra.me/es/watcher";
-function createDocDebouncer(handler, options = {}) {
-  const { debounceMs = 300, maxWaitMs = 5e3 } = options;
-  let pendingEvents = [];
-  let maxWaitTimeout;
-  function processEvents(events) {
-    if (maxWaitTimeout !== void 0) {
-      clearTimeout(maxWaitTimeout);
-      maxWaitTimeout = void 0;
-    }
-    const deduplicated = deduplicateEvents(events);
-    if (deduplicated.length > 0) {
-      Promise.resolve(handler(deduplicated)).catch((error) => {
-        console.error("[doc-sync] Error in batch handler:", error);
-      });
-    }
-  }
-  const baseDebouncer = createBaseDebouncer((events) => {
-    processEvents(events);
-    pendingEvents = [];
-  }, debounceMs);
-  function startMaxWaitTimer() {
-    if (maxWaitTimeout === void 0) {
-      maxWaitTimeout = setTimeout(() => {
-        baseDebouncer.flush();
-      }, maxWaitMs);
-    }
-  }
-  return {
-    add(event) {
-      pendingEvents.push(event);
-      startMaxWaitTimer();
-      baseDebouncer.add(event);
-    },
-    addAll(events) {
-      for (const event of events) {
-        pendingEvents.push(event);
-        baseDebouncer.add(event);
-      }
-      if (events.length > 0) {
-        startMaxWaitTimer();
-      }
-    },
-    flush() {
-      if (maxWaitTimeout !== void 0) {
-        clearTimeout(maxWaitTimeout);
-        maxWaitTimeout = void 0;
-      }
-      baseDebouncer.flush();
-    },
-    cancel() {
-      if (maxWaitTimeout !== void 0) {
-        clearTimeout(maxWaitTimeout);
-        maxWaitTimeout = void 0;
-      }
-      pendingEvents = [];
-      baseDebouncer.cancel();
-    },
-    getPendingCount() {
-      return pendingEvents.length;
-    }
-  };
-}
-function deduplicateEvents(events) {
-  const latestByPath = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const existing = latestByPath.get(event.path);
-    if (existing === void 0 || event.timestamp > existing.timestamp) {
-      latestByPath.set(event.path, event);
-    }
-  }
-  return [...latestByPath.values()];
-}
-function consolidateEvents(events) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const event of events) {
-    const existing = byPath.get(event.path);
-    if (existing === void 0) {
-      byPath.set(event.path, [event]);
-    } else {
-      existing.push(event);
-    }
-  }
-  const consolidated = [];
-  for (const [, pathEvents] of byPath) {
-    const firstEvent = pathEvents[0];
-    if (firstEvent === void 0) {
-      continue;
-    }
-    if (pathEvents.length === 1) {
-      consolidated.push(firstEvent);
-      continue;
-    }
-    pathEvents.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
-    const first = pathEvents[0];
-    const last = pathEvents.at(-1);
-    if (first === void 0 || last === void 0) {
-      continue;
-    }
-    if (first.type === "add" && last.type === "unlink") {
-      continue;
-    }
-    if (first.type === "unlink" && last.type === "add") {
-      consolidated.push({
-        type: "change",
-        path: last.path,
-        packageName: last.packageName,
-        timestamp: last.timestamp
-      });
-      continue;
-    }
-    consolidated.push(last);
-  }
-  return consolidated;
-}
-
 // src/orchestrator/validation-pipeline.ts
 import { err as err2, ok as ok2 } from "@bfra.me/es/result";
 var DEFAULT_OPTIONS2 = {
@@ -722,7 +418,7 @@ function validateContentString(content, options) {
 
 // src/orchestrator/sync-orchestrator.ts
 import fs2 from "fs/promises";
-import path3 from "path";
+import path2 from "path";
 import { err as err3, ok as ok3 } from "@bfra.me/es/result";
 function createSyncOrchestrator(options) {
   const { config, dryRun = false, verbose = false, onProgress, onError } = options;
@@ -943,7 +639,7 @@ function createSyncOrchestrator(options) {
 }
 function getOutputPath(packageName, outputDir) {
   const slug = createSlug(getUnscopedName2(packageName));
-  return path3.join(outputDir, `${slug}.mdx`);
+  return path2.join(outputDir, `${slug}.mdx`);
 }
 function createSlug(name) {
   return name.toLowerCase().replaceAll(/[^a-z0-9-]/g, "-");
@@ -958,7 +654,7 @@ function getUnscopedName2(packageName) {
   return packageName;
 }
 async function writeFile(filePath, content) {
-  const dir = path3.dirname(filePath);
+  const dir = path2.dirname(filePath);
   await fs2.mkdir(dir, { recursive: true });
   await fs2.writeFile(filePath, content, "utf-8");
 }
@@ -992,15 +688,15 @@ function isNodeError(error) {
   return error instanceof Error && "code" in error;
 }
 function categorizeFileChange(filePath) {
-  const basename = path3.basename(filePath).toLowerCase();
+  const basename = path2.basename(filePath).toLowerCase();
   if (basename === "readme.md" || basename === "readme") return "readme";
   if (basename === "package.json") return "package-json";
   if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) return "source";
   return "unknown";
 }
 function isValidFilePath(filePath, rootDir) {
-  const resolvedPath = path3.resolve(filePath);
-  const resolvedRoot = path3.resolve(rootDir);
+  const resolvedPath = path2.resolve(filePath);
+  const resolvedRoot = path2.resolve(rootDir);
   return resolvedPath.startsWith(resolvedRoot);
 }
 
@@ -1008,20 +704,10 @@ export {
   createPackageScanner,
   filterPackagesByPattern,
   groupPackagesByScope,
-  createDocWatcher,
-  categorizeFile,
-  groupChangesByPackage,
-  filterDocumentationChanges,
-  createDocChangeDetector,
-  determineRegenerationScope,
-  hasAnyFileChanged,
-  createDocDebouncer,
-  deduplicateEvents,
-  consolidateEvents,
   createValidationPipeline,
   validateDocument,
   validateContentString,
   createSyncOrchestrator,
   isValidFilePath
 };
-//# sourceMappingURL=chunk-DR6UG237.js.map
+//# sourceMappingURL=chunk-DTXB5PMR.js.map

package/lib/chunk-GZ2MP3VN.js

@@ -0,0 +1,261 @@
+// src/utils/sanitization.ts
+import { sanitizeInput } from "@bfra.me/es/validation";
+import escapeHtml from "escape-html";
+function sanitizeForMDX(content) {
+  const escaped = sanitizeInput(content, { trim: false });
+  return escaped.replaceAll("{", "{").replaceAll("}", "}");
+}
+function sanitizeAttribute(value) {
+  return escapeHtml(value);
+}
+function parseJSXAttributes(tag) {
+  const attrs = [];
+  const spaceIndex = tag.indexOf(" ");
+  if (spaceIndex === -1) return attrs;
+  const closeIndex = tag.lastIndexOf(">");
+  if (closeIndex === -1) return attrs;
+  const attrRegion = tag.slice(spaceIndex + 1, closeIndex).trim();
+  let i = 0;
+  while (i < attrRegion.length) {
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length) break;
+    let name = "";
+    while (i < attrRegion.length && /[\w-]/.test(attrRegion.charAt(i))) {
+      name += attrRegion[i];
+      i++;
+    }
+    if (!name) break;
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length || attrRegion[i] !== "=") {
+      attrs.push({ name, value: null });
+      continue;
+    }
+    i++;
+    while (i < attrRegion.length && /\s/.test(attrRegion.charAt(i))) i++;
+    if (i >= attrRegion.length) {
+      attrs.push({ name, value: "" });
+      break;
+    }
+    let value = "";
+    const quote = attrRegion[i];
+    if (quote === '"' || quote === "'") {
+      i++;
+      while (i < attrRegion.length && attrRegion[i] !== quote) {
+        value += attrRegion[i];
+        i++;
+      }
+      if (i < attrRegion.length) i++;
+    } else {
+      while (i < attrRegion.length && !/[\s/>]/.test(attrRegion.charAt(i))) {
+        value += attrRegion[i];
+        i++;
+      }
+    }
+    attrs.push({ name, value });
+  }
+  return attrs;
+}
+function sanitizeJSXTag(tag) {
+  const tagMatch = tag.match(/^<([A-Z][a-zA-Z0-9]*)/);
+  if (!tagMatch || typeof tagMatch[1] !== "string" || tagMatch[1].length === 0) {
+    return escapeHtml(tag);
+  }
+  const tagName = tagMatch[1];
+  const selfClosing = tag.endsWith("/>");
+  const attributes = parseJSXAttributes(tag);
+  const sanitizedAttrs = attributes.map(({ name, value }) => {
+    if (value === null) return name;
+    const escaped = escapeHtml(value);
+    return `${name}="${escaped}"`;
+  });
+  const attrString = sanitizedAttrs.length > 0 ? ` ${sanitizedAttrs.join(" ")}` : "";
+  return `<${tagName}${attrString}${selfClosing ? " />" : ">"}`;
+}
+
+// src/utils/safe-patterns.ts
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+function createHeadingPattern(level) {
+  if (level < 1 || level > 6) {
+    throw new Error("Heading level must be between 1 and 6");
+  }
+  const hashes = "#".repeat(level);
+  return new RegExp(`^${hashes} ([^\r
+]+)$`, "gm");
+}
+function hasComponent(content, componentName) {
+  const escaped = componentName.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+  const pattern = new RegExp(String.raw`<${escaped}(?:\s[^>]*)?(?:>|\/>)`);
+  return pattern.test(content);
+}
+function extractCodeBlocks(content) {
+  const processor = unified().use(remarkParse);
+  let tree;
+  try {
+    tree = processor.parse(content);
+  } catch {
+    return [];
+  }
+  const blocks = [];
+  function visit(node) {
+    if (node.type === "code") {
+      const lang = node.lang ?? "";
+      const value = node.value ?? "";
+      blocks.push(`\`\`\`${lang}
+${value}
+\`\`\``);
+    }
+    if (node.type === "inlineCode") {
+      const value = node.value ?? "";
+      blocks.push(`\`${value}\``);
+    }
+    if (Array.isArray(node.children)) {
+      for (const child of node.children) {
+        visit(child);
+      }
+    }
+  }
+  visit(tree);
+  return blocks;
+}
+function parseJSXTags(content) {
+  const results = [];
+  let i = 0;
+  while (i < content.length) {
+    if (content[i] !== "<") {
+      i++;
+      continue;
+    }
+    const startIndex = i;
+    i++;
+    if (i >= content.length) break;
+    const isClosing = content[i] === "/";
+    if (isClosing) {
+      i++;
+      if (i >= content.length) break;
+    }
+    if (!/^[A-Z]/.test(content[i] ?? "")) {
+      continue;
+    }
+    let tagName = "";
+    while (i < content.length && /^[a-z0-9]/i.test(content[i] ?? "")) {
+      tagName += content[i];
+      i++;
+    }
+    if (tagName.length === 0) {
+      continue;
+    }
+    if (isClosing) {
+      if (i < content.length && content[i] === ">") {
+        results.push({
+          tag: `</${tagName}>`,
+          index: startIndex,
+          isClosing: true,
+          isSelfClosing: false
+        });
+        i++;
+      }
+      continue;
+    }
+    let depth = 0;
+    let foundEnd = false;
+    let isSelfClosing = false;
+    while (i < content.length && !foundEnd) {
+      const char = content[i];
+      if ((char === '"' || char === "'") && depth === 0) {
+        const quote = char;
+        i++;
+        while (i < content.length && content[i] !== quote) {
+          if (content[i] === "\\" && i + 1 < content.length) {
+            i += 2;
+          } else {
+            i++;
+          }
+        }
+        if (i < content.length) i++;
+        continue;
+      }
+      if (char === "{") {
+        depth++;
+        i++;
+        continue;
+      }
+      if (char === "}") {
+        depth = Math.max(0, depth - 1);
+        i++;
+        continue;
+      }
+      if (depth === 0) {
+        if (char === "/" && i + 1 < content.length && content[i + 1] === ">") {
+          isSelfClosing = true;
+          foundEnd = true;
+          i += 2;
+          continue;
+        }
+        if (char === ">") {
+          foundEnd = true;
+          i++;
+          continue;
+        }
+      }
+      i++;
+    }
+    if (foundEnd) {
+      const fullTag = content.slice(startIndex, i);
+      results.push({ tag: fullTag, index: startIndex, isClosing: false, isSelfClosing });
+    }
+  }
+  return results;
+}
+function findEmptyMarkdownLinks(content) {
+  const positions = [];
+  let pos = 0;
+  while (pos < content.length) {
+    const openBracket = content.indexOf("[", pos);
+    if (openBracket === -1) break;
+    let bracketDepth = 1;
+    let closeBracket = openBracket + 1;
+    while (closeBracket < content.length && bracketDepth > 0) {
+      if (content[closeBracket] === "[") {
+        bracketDepth++;
+      } else if (content[closeBracket] === "]") {
+        bracketDepth--;
+      }
+      closeBracket++;
+    }
+    if (bracketDepth !== 0) {
+      pos = openBracket + 1;
+      continue;
+    }
+    closeBracket--;
+    if (closeBracket + 1 < content.length && content[closeBracket + 1] === "(") {
+      let parenPos = closeBracket + 2;
+      let isEmptyOrWhitespace = true;
+      while (parenPos < content.length && content[parenPos] !== ")") {
+        if (!/^\s/.test(content[parenPos] ?? "")) {
+          isEmptyOrWhitespace = false;
+          break;
+        }
+        parenPos++;
+      }
+      if (isEmptyOrWhitespace && parenPos < content.length && content[parenPos] === ")") {
+        positions.push(openBracket);
+      }
+    }
+    pos = closeBracket + 1;
+  }
+  return positions;
+}
+
+export {
+  sanitizeForMDX,
+  sanitizeAttribute,
+  parseJSXAttributes,
+  sanitizeJSXTag,
+  createHeadingPattern,
+  hasComponent,
+  extractCodeBlocks,
+  parseJSXTags,
+  findEmptyMarkdownLinks
+};
+//# sourceMappingURL=chunk-GZ2MP3VN.js.map

package/lib/chunk-SQSYXPIF.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-SQSYXPIF.js.map