@bfra.me/doc-sync 0.1.0 → 0.1.1

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-DRBRT57F.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-DRBRT57F.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