@seoengine.ai/next-llm-ready 1.0.0

package/dist/hooks/index.cjs

@@ -0,0 +1,619 @@
+'use strict';
+
+var react = require('react');
+
+// src/hooks/use-llm-copy.ts
+
+// src/utils/clipboard.ts
+async function copyToClipboard(text) {
+  if (navigator.clipboard && typeof navigator.clipboard.writeText === "function") {
+    try {
+      await navigator.clipboard.writeText(text);
+      return true;
+    } catch (err) {
+      console.warn("Clipboard API failed, using fallback:", err);
+    }
+  }
+  return fallbackCopyToClipboard(text);
+}
+function fallbackCopyToClipboard(text) {
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.style.position = "fixed";
+  textarea.style.top = "-9999px";
+  textarea.style.left = "-9999px";
+  textarea.style.opacity = "0";
+  textarea.style.pointerEvents = "none";
+  textarea.style.fontSize = "16px";
+  document.body.appendChild(textarea);
+  textarea.focus();
+  textarea.select();
+  try {
+    const successful = document.execCommand("copy");
+    document.body.removeChild(textarea);
+    return successful;
+  } catch (err) {
+    console.error("Fallback copy failed:", err);
+    document.body.removeChild(textarea);
+    return false;
+  }
+}
+
+// src/utils/download.ts
+var defaultOptions = {
+  filename: "content",
+  extension: "md",
+  includeMetadata: false
+};
+function downloadAsFile(content, options = {}) {
+  const opts = { ...defaultOptions, ...options };
+  const filename = sanitizeFilename(opts.filename || "content");
+  const fullFilename = `${filename}.${opts.extension}`;
+  const mimeType = opts.extension === "md" ? "text/markdown" : "text/plain";
+  const blob = new Blob([content], { type: `${mimeType};charset=utf-8` });
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = fullFilename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+function sanitizeFilename(name) {
+  return name.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").substring(0, 100);
+}
+function generateFilename(title) {
+  const base = sanitizeFilename(title);
+  const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return `${base}-${date}`;
+}
+
+// src/utils/html-to-markdown.ts
+var defaultOptions2 = {
+  preserveLineBreaks: true,
+  convertImages: true,
+  convertLinks: true,
+  stripScripts: true,
+  customHandlers: {}
+};
+function htmlToMarkdown(html, options = {}) {
+  const opts = { ...defaultOptions2, ...options };
+  if (typeof window === "undefined") {
+    return serverSideConvert(html, opts);
+  }
+  const doc = new DOMParser().parseFromString(html, "text/html");
+  return convertNode(doc.body, opts);
+}
+function serverSideConvert(html, opts) {
+  let markdown = html;
+  if (opts.stripScripts) {
+    markdown = markdown.replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "");
+    markdown = markdown.replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "");
+  }
+  markdown = markdown.replace(/<h1[^>]*>(.*?)<\/h1>/gi, "\n# $1\n");
+  markdown = markdown.replace(/<h2[^>]*>(.*?)<\/h2>/gi, "\n## $1\n");
+  markdown = markdown.replace(/<h3[^>]*>(.*?)<\/h3>/gi, "\n### $1\n");
+  markdown = markdown.replace(/<h4[^>]*>(.*?)<\/h4>/gi, "\n#### $1\n");
+  markdown = markdown.replace(/<h5[^>]*>(.*?)<\/h5>/gi, "\n##### $1\n");
+  markdown = markdown.replace(/<h6[^>]*>(.*?)<\/h6>/gi, "\n###### $1\n");
+  markdown = markdown.replace(/<(strong|b)[^>]*>(.*?)<\/\1>/gi, "**$2**");
+  markdown = markdown.replace(/<(em|i)[^>]*>(.*?)<\/\1>/gi, "*$2*");
+  if (opts.convertLinks) {
+    markdown = markdown.replace(/<a[^>]*href=["']([^"']*)["'][^>]*>(.*?)<\/a>/gi, "[$2]($1)");
+  }
+  if (opts.convertImages) {
+    markdown = markdown.replace(
+      /<img[^>]*src=["']([^"']*)["'][^>]*alt=["']([^"']*)["'][^>]*\/?>/gi,
+      "![$2]($1)"
+    );
+    markdown = markdown.replace(
+      /<img[^>]*alt=["']([^"']*)["'][^>]*src=["']([^"']*)["'][^>]*\/?>/gi,
+      "![$1]($2)"
+    );
+    markdown = markdown.replace(/<img[^>]*src=["']([^"']*)["'][^>]*\/?>/gi, "![]($1)");
+  }
+  markdown = markdown.replace(/<ul[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ul>/gi, "\n");
+  markdown = markdown.replace(/<ol[^>]*>/gi, "\n");
+  markdown = markdown.replace(/<\/ol>/gi, "\n");
+  markdown = markdown.replace(/<li[^>]*>(.*?)<\/li>/gi, "- $1\n");
+  markdown = markdown.replace(/<blockquote[^>]*>(.*?)<\/blockquote>/gis, (_, content) => {
+    return "\n> " + content.trim().replace(/\n/g, "\n> ") + "\n";
+  });
+  markdown = markdown.replace(/<pre[^>]*><code[^>]*>(.*?)<\/code><\/pre>/gis, "\n```\n$1\n```\n");
+  markdown = markdown.replace(/<code[^>]*>(.*?)<\/code>/gi, "`$1`");
+  markdown = markdown.replace(/<p[^>]*>(.*?)<\/p>/gis, "\n$1\n");
+  markdown = markdown.replace(/<br\s*\/?>/gi, "\n");
+  markdown = markdown.replace(/<hr[^>]*\/?>/gi, "\n---\n");
+  markdown = markdown.replace(/<[^>]+>/g, "");
+  markdown = decodeHTMLEntities(markdown);
+  markdown = markdown.replace(/\n{3,}/g, "\n\n");
+  markdown = markdown.trim();
+  return markdown;
+}
+function convertNode(node, opts) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    return node.textContent || "";
+  }
+  if (node.nodeType !== Node.ELEMENT_NODE) {
+    return "";
+  }
+  const element = node;
+  const tagName = element.tagName.toLowerCase();
+  if (opts.customHandlers?.[tagName]) {
+    return opts.customHandlers[tagName](element);
+  }
+  if (opts.stripScripts && (tagName === "script" || tagName === "style")) {
+    return "";
+  }
+  const childContent = Array.from(element.childNodes).map((child) => convertNode(child, opts)).join("");
+  switch (tagName) {
+    case "h1":
+      return `
+# ${childContent.trim()}
+`;
+    case "h2":
+      return `
+## ${childContent.trim()}
+`;
+    case "h3":
+      return `
+### ${childContent.trim()}
+`;
+    case "h4":
+      return `
+#### ${childContent.trim()}
+`;
+    case "h5":
+      return `
+##### ${childContent.trim()}
+`;
+    case "h6":
+      return `
+###### ${childContent.trim()}
+`;
+    case "p":
+      return `
+${childContent.trim()}
+`;
+    case "br":
+      return opts.preserveLineBreaks ? "\n" : " ";
+    case "strong":
+    case "b":
+      return `**${childContent}**`;
+    case "em":
+    case "i":
+      return `*${childContent}*`;
+    case "u":
+      return `_${childContent}_`;
+    case "s":
+    case "strike":
+    case "del":
+      return `~~${childContent}~~`;
+    case "a":
+      if (opts.convertLinks) {
+        const href = element.getAttribute("href") || "";
+        return `[${childContent}](${href})`;
+      }
+      return childContent;
+    case "img":
+      if (opts.convertImages) {
+        const src = element.getAttribute("src") || "";
+        const alt = element.getAttribute("alt") || "";
+        return `![${alt}](${src})`;
+      }
+      return "";
+    case "ul":
+      return `
+${childContent}
+`;
+    case "ol":
+      return `
+${childContent}
+`;
+    case "li":
+      return `- ${childContent.trim()}
+`;
+    case "blockquote":
+      return `
+> ${childContent.trim().replace(/\n/g, "\n> ")}
+`;
+    case "pre":
+      const codeElement = element.querySelector("code");
+      const lang = codeElement?.className.match(/language-(\w+)/)?.[1] || "";
+      const code = codeElement?.textContent || childContent;
+      return `
+\`\`\`${lang}
+${code.trim()}
+\`\`\`
+`;
+    case "code":
+      if (element.parentElement?.tagName.toLowerCase() === "pre") {
+        return childContent;
+      }
+      return `\`${childContent}\``;
+    case "hr":
+      return "\n---\n";
+    case "table":
+      return convertTable(element);
+    case "div":
+    case "section":
+    case "article":
+    case "main":
+    case "aside":
+    case "header":
+    case "footer":
+    case "nav":
+      return childContent;
+    default:
+      return childContent;
+  }
+}
+function convertTable(table) {
+  const rows = table.querySelectorAll("tr");
+  if (rows.length === 0) return "";
+  let markdown = "\n";
+  let headerProcessed = false;
+  rows.forEach((row, index) => {
+    const cells = row.querySelectorAll("th, td");
+    const rowContent = Array.from(cells).map((cell) => cell.textContent?.trim() || "").join(" | ");
+    markdown += `| ${rowContent} |
+`;
+    if (!headerProcessed && (row.querySelector("th") || index === 0)) {
+      const separator = Array.from(cells).map(() => "---").join(" | ");
+      markdown += `| ${separator} |
+`;
+      headerProcessed = true;
+    }
+  });
+  return markdown + "\n";
+}
+function decodeHTMLEntities(text) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&#39;": "'",
+    "&apos;": "'",
+    "&nbsp;": " ",
+    "&mdash;": "\u2014",
+    "&ndash;": "\u2013",
+    "&hellip;": "\u2026",
+    "&copy;": "\xA9",
+    "&reg;": "\xAE",
+    "&trade;": "\u2122"
+  };
+  let result = text;
+  for (const [entity, char] of Object.entries(entities)) {
+    result = result.replace(new RegExp(entity, "g"), char);
+  }
+  result = result.replace(/&#(\d+);/g, (_, num) => String.fromCharCode(parseInt(num, 10)));
+  result = result.replace(
+    /&#x([0-9a-f]+);/gi,
+    (_, hex) => String.fromCharCode(parseInt(hex, 16))
+  );
+  return result;
+}
+function countWords(text) {
+  return text.replace(/[^\w\s]/g, "").split(/\s+/).filter((word) => word.length > 0).length;
+}
+function calculateReadingTime(text, wordsPerMinute = 200) {
+  const words = countWords(text);
+  return Math.ceil(words / wordsPerMinute);
+}
+
+// src/hooks/use-llm-copy.ts
+function generateMarkdownFromContent(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  const parts = [];
+  if (content.promptPrefix?.trim()) {
+    parts.push(content.promptPrefix.trim());
+    parts.push("");
+  }
+  parts.push(`# ${content.title}`);
+  parts.push("");
+  if (content.excerpt) {
+    parts.push(`> ${content.excerpt}`);
+    parts.push("");
+  }
+  parts.push("---");
+  parts.push(`- **Source**: ${content.url}`);
+  if (content.date) {
+    parts.push(`- **Date**: ${content.date}`);
+  }
+  if (content.author) {
+    parts.push(`- **Author**: ${content.author}`);
+  }
+  if (content.categories?.length) {
+    parts.push(`- **Categories**: ${content.categories.join(", ")}`);
+  }
+  if (content.tags?.length) {
+    parts.push(`- **Tags**: ${content.tags.join(", ")}`);
+  }
+  parts.push("---");
+  parts.push("");
+  if (content.content) {
+    const contentMarkdown = content.content.includes("<") && content.content.includes(">") ? htmlToMarkdown(content.content) : content.content;
+    parts.push(contentMarkdown);
+  }
+  return parts.join("\n").trim();
+}
+function useLLMCopy(options) {
+  const [isCopying, setIsCopying] = react.useState(false);
+  const [isSuccess, setIsSuccess] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const markdown = react.useMemo(() => {
+    return generateMarkdownFromContent(options.content);
+  }, [options.content]);
+  const trackEvent = react.useCallback(
+    (action) => {
+      if (options.onAnalytics) {
+        const contentId = typeof options.content === "string" ? void 0 : options.content.url;
+        options.onAnalytics({
+          action,
+          contentId,
+          url: typeof window !== "undefined" ? window.location.href : void 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    },
+    [options]
+  );
+  const copy = react.useCallback(async () => {
+    setIsCopying(true);
+    setError(null);
+    try {
+      const success = await copyToClipboard(markdown);
+      if (success) {
+        setIsSuccess(true);
+        trackEvent("copy");
+        options.onSuccess?.("copy");
+        setTimeout(() => setIsSuccess(false), 2e3);
+        return true;
+      } else {
+        throw new Error("Failed to copy to clipboard");
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Copy failed");
+      setError(error2);
+      options.onError?.(error2);
+      return false;
+    } finally {
+      setIsCopying(false);
+    }
+  }, [markdown, options, trackEvent]);
+  const view = react.useCallback(() => {
+    trackEvent("view");
+    options.onSuccess?.("view");
+    return markdown;
+  }, [markdown, options, trackEvent]);
+  const download = react.useCallback(
+    (filename) => {
+      const title = typeof options.content === "string" ? "content" : options.content.title;
+      downloadAsFile(markdown, {
+        filename: filename || generateFilename(title),
+        extension: "md"
+      });
+      trackEvent("download");
+      options.onSuccess?.("download");
+    },
+    [markdown, options, trackEvent]
+  );
+  return {
+    copy,
+    view,
+    download,
+    markdown,
+    isCopying,
+    isSuccess,
+    error
+  };
+}
+function useContentStats(content) {
+  return react.useMemo(() => {
+    const markdown = generateMarkdownFromContent(content);
+    const wordCount = countWords(markdown);
+    const readingTime = calculateReadingTime(markdown);
+    return { wordCount, readingTime };
+  }, [content]);
+}
+function useTOC(options) {
+  const {
+    contentRef,
+    levels = ["h2", "h3", "h4"],
+    rootMargin = "-100px 0px -80% 0px",
+    threshold = 0
+  } = options;
+  const [headings, setHeadings] = react.useState([]);
+  const [activeId, setActiveId] = react.useState(null);
+  react.useEffect(() => {
+    if (!contentRef?.current) return;
+    const container = contentRef.current;
+    const selector = levels.join(", ");
+    const elements = container.querySelectorAll(selector);
+    const extracted = [];
+    let index = 0;
+    elements.forEach((el) => {
+      const tagName = el.tagName.toLowerCase();
+      const level = parseInt(tagName.charAt(1), 10);
+      const text = el.textContent?.trim() || "";
+      let id = el.id;
+      if (!id) {
+        id = generateHeadingId(text, index);
+        el.id = id;
+      }
+      extracted.push({ id, text, level });
+      index++;
+    });
+    setHeadings(extracted);
+  }, [contentRef, levels]);
+  react.useEffect(() => {
+    if (!contentRef?.current || headings.length === 0) return;
+    const container = contentRef.current;
+    const observerOptions = {
+      root: null,
+      rootMargin,
+      threshold
+    };
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (entry.isIntersecting) {
+          setActiveId(entry.target.id);
+        }
+      });
+    }, observerOptions);
+    headings.forEach((heading) => {
+      const element = container.querySelector(`#${CSS.escape(heading.id)}`);
+      if (element) {
+        observer.observe(element);
+      }
+    });
+    return () => observer.disconnect();
+  }, [contentRef, headings, rootMargin, threshold]);
+  const scrollTo = react.useCallback((id) => {
+    const element = document.getElementById(id);
+    if (element) {
+      element.scrollIntoView({ behavior: "smooth", block: "start" });
+      setActiveId(id);
+      if (typeof window !== "undefined") {
+        window.history.pushState(null, "", `#${id}`);
+      }
+    }
+  }, []);
+  return { headings, activeId, scrollTo };
+}
+function generateHeadingId(text, index) {
+  const slug = text.toLowerCase().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").substring(0, 50);
+  return slug || `heading-${index}`;
+}
+function buildNestedTOC(headings) {
+  if (headings.length === 0) return [];
+  const result = [];
+  const stack = [];
+  for (const heading of headings) {
+    const item = { ...heading, children: [] };
+    while (stack.length > 0 && stack[stack.length - 1].level >= heading.level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      result.push(item);
+    } else {
+      const parent = stack[stack.length - 1].heading;
+      if (!parent.children) parent.children = [];
+      parent.children.push(item);
+    }
+    stack.push({ heading: item, level: heading.level });
+  }
+  return result;
+}
+function useTOCKeyboard(headings, activeId, scrollTo) {
+  react.useEffect(() => {
+    const handleKeyDown = (e) => {
+      if (headings.length === 0) return;
+      const currentIndex = headings.findIndex((h) => h.id === activeId);
+      if (e.key === "ArrowDown" && e.altKey) {
+        e.preventDefault();
+        const nextIndex = Math.min(currentIndex + 1, headings.length - 1);
+        scrollTo(headings[nextIndex].id);
+      } else if (e.key === "ArrowUp" && e.altKey) {
+        e.preventDefault();
+        const prevIndex = Math.max(currentIndex - 1, 0);
+        scrollTo(headings[prevIndex].id);
+      }
+    };
+    document.addEventListener("keydown", handleKeyDown);
+    return () => document.removeEventListener("keydown", handleKeyDown);
+  }, [headings, activeId, scrollTo]);
+}
+function useAnalytics(options = {}) {
+  const {
+    endpoint = "/api/llm-analytics",
+    includeUrl = true,
+    includeTimestamp = true,
+    metadata = {}
+  } = options;
+  const pendingRef = react.useRef(/* @__PURE__ */ new Set());
+  const track = react.useCallback(
+    async (event) => {
+      const key = `${event.action}-${event.contentId || ""}-${Date.now()}`;
+      if (pendingRef.current.has(key)) {
+        return;
+      }
+      pendingRef.current.add(key);
+      try {
+        const payload = {
+          ...event,
+          ...includeUrl && { url: event.url || window.location.href },
+          ...includeTimestamp && { timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString() },
+          metadata: { ...metadata, ...event.metadata }
+        };
+        if (navigator.sendBeacon) {
+          const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+          navigator.sendBeacon(endpoint, blob);
+        } else {
+          await fetch(endpoint, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            keepalive: true
+          });
+        }
+      } catch (error) {
+        console.error("Analytics tracking failed:", error);
+      } finally {
+        pendingRef.current.delete(key);
+      }
+    },
+    [endpoint, includeUrl, includeTimestamp, metadata]
+  );
+  const trackCopy = react.useCallback(() => {
+    return track({ action: "copy" });
+  }, [track]);
+  const trackView = react.useCallback(() => {
+    return track({ action: "view" });
+  }, [track]);
+  const trackDownload = react.useCallback(() => {
+    return track({ action: "download" });
+  }, [track]);
+  return { track, trackCopy, trackView, trackDownload };
+}
+function createAnalyticsTracker(endpoint) {
+  return async function trackEvent(action, contentId, metadata) {
+    const payload = {
+      action,
+      contentId,
+      url: typeof window !== "undefined" ? window.location.href : void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      metadata
+    };
+    try {
+      if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+        const blob = new Blob([JSON.stringify(payload)], { type: "application/json" });
+        navigator.sendBeacon(endpoint, blob);
+      } else if (typeof fetch !== "undefined") {
+        await fetch(endpoint, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload),
+          keepalive: true
+        });
+      }
+    } catch (error) {
+      console.error("Analytics tracking failed:", error);
+    }
+  };
+}
+
+exports.buildNestedTOC = buildNestedTOC;
+exports.createAnalyticsTracker = createAnalyticsTracker;
+exports.useAnalytics = useAnalytics;
+exports.useContentStats = useContentStats;
+exports.useLLMCopy = useLLMCopy;
+exports.useTOC = useTOC;
+exports.useTOCKeyboard = useTOCKeyboard;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map