@bfra.me/doc-sync 0.1.0 → 0.1.2

package/lib/chunk-45NROJIG.js

@@ -0,0 +1,327 @@
+// src/watcher/change-detector.ts
+import { createChangeDetector as createBaseDetector } from "@bfra.me/es/watcher";
+
+// src/watcher/file-watcher.ts
+import path 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 = path.relative(root, filePath);
+  const parts = relativePath.split(path.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) => path.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 = path.basename(filePath).toLowerCase();
+  if (basename === "readme.md" || basename === "readme") {
+    return "readme";
+  }
+  if (basename === "package.json") {
+    return "package-json";
+  }
+  const ext = path.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
+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;
+}
+
+export {
+  createDocWatcher,
+  categorizeFile,
+  groupChangesByPackage,
+  filterDocumentationChanges,
+  createDocChangeDetector,
+  determineRegenerationScope,
+  hasAnyFileChanged,
+  createDocDebouncer,
+  deduplicateEvents,
+  consolidateEvents
+};
+//# sourceMappingURL=chunk-45NROJIG.js.map

package/lib/{chunk-G5KKGJYO.js → chunk-CUBMCGAY.js}

@@ -1,6 +1,13 @@
 import {
   SENTINEL_MARKERS
 } from "./chunk-ROLA7SBB.js";
+import {
+  extractCodeBlocks,
+  parseJSXTags,
+  sanitizeAttribute,
+  sanitizeForMDX,
+  sanitizeJSXTag
+} from "./chunk-GZ2MP3VN.js";
 
 // src/generators/api-reference-generator.ts
 function generateAPIReference(api) {
@@ -435,80 +442,6 @@ function formatGroupedExamples(api, options = {}) {
   return sections.join("\n").trim();
 }
 
-// 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/generators/component-mapper.ts
 var DEFAULT_CONFIG = {
   featureSections: ["features", "highlights", "key features"],
@@ -564,6 +497,9 @@ function isFeatureSection(heading, featureSections) {
 function isInstallationSection(heading, tabSections) {
   return tabSections.some((tab) => heading.includes(tab.toLowerCase()));
 }
+function escapeAngleBrackets(text) {
+  return text.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
 function mapFeatureSection(section) {
   const lines = [];
   lines.push(`## ${section.heading}`);
@@ -574,7 +510,7 @@ function mapFeatureSection(section) {
     for (const feature of features) {
       const icon = inferFeatureIcon(feature.title, feature.emoji);
       lines.push(`  <Card title="${sanitizeAttribute(feature.title)}" icon="${icon}">`);
-      lines.push(`    ${feature.description}`);
+      lines.push(`    ${escapeAngleBrackets(feature.description)}`);
       lines.push("  </Card>");
     }
     lines.push("</CardGrid>");
@@ -1167,179 +1103,6 @@ function stripQuotes(value) {
 
 // src/generators/mdx-generator.ts
 import { err as err2, ok as ok2 } from "@bfra.me/es/result";
-
-// 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 (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;
-}
-
-// src/generators/mdx-generator.ts
 var DEFAULT_OPTIONS2 = {
   includeAPI: true,
   includeExamples: true,
@@ -1442,11 +1205,7 @@ function sanitizeTextContent(content) {
     if (index > lastIndex) {
       parts.push(sanitizeContent(content.slice(lastIndex, index)));
     }
-    if (isClosing) {
-      parts.push(tag);
-    } else {
-      parts.push(sanitizeJSXTag(tag));
-    }
+    parts.push(isClosing ? tag : sanitizeJSXTag(tag));
     lastIndex = index + tag.length;
   }
   if (lastIndex < content.length) {
@@ -1471,17 +1230,23 @@ function validateMDXSyntax(mdx) {
   }
   return ok2(true);
 }
+function isTypeScriptGeneric(tag) {
+  const tagNameMatch = tag.match(/<\/?([A-Z][a-zA-Z0-9]*)/);
+  const tagName = tagNameMatch?.[1];
+  return tagName !== void 0 && tagName.length === 1;
+}
 function checkForUnclosedTags(mdx) {
   const unclosed = [];
   const tagStack = [];
   const codeBlocks = extractCodeBlocks(mdx);
-  let contentWithoutCodeBlocks = mdx;
+  let contentWithoutCode = mdx;
   for (const block of codeBlocks) {
     const lineCount = block.split("\n").length;
     const placeholder = "\n".repeat(lineCount);
-    contentWithoutCodeBlocks = contentWithoutCodeBlocks.replace(block, placeholder);
+    contentWithoutCode = contentWithoutCode.replace(block, placeholder);
   }
-  const jsxTags = parseJSXTags(contentWithoutCodeBlocks);
+  const allJSXTags = parseJSXTags(contentWithoutCode);
+  const jsxTags = allJSXTags.filter(({ tag }) => !isTypeScriptGeneric(tag));
   for (const { tag, isClosing, isSelfClosing } of jsxTags) {
     const tagNameMatch = isClosing ? tag.match(/^<\/([A-Z][a-zA-Z0-9]*)>$/) : tag.match(/^<([A-Z][a-zA-Z0-9]*)/);
     const tagName = tagNameMatch?.[1];
@@ -1548,13 +1313,9 @@ export {
   generateFrontmatter,
   stringifyFrontmatter,
   parseFrontmatter,
-  createHeadingPattern,
-  hasComponent,
-  extractCodeBlocks,
-  findEmptyMarkdownLinks,
   generateMDXDocument,
   sanitizeContent,
   sanitizeTextContent,
   validateMDXSyntax
 };
-//# sourceMappingURL=chunk-G5KKGJYO.js.map
+//# sourceMappingURL=chunk-CUBMCGAY.js.map

package/lib/chunk-DRBRT57F.js

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