@fullstackdatasolutions/articles 0.8.0 → 0.8.2

package/dist/nextjs.js

@@ -0,0 +1,618 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/server-articles.ts
+import { cache } from "react";
+import matter from "gray-matter";
+import fs from "node:fs";
+import path from "node:path";
+import readingTime from "reading-time";
+
+// src/markdown.ts
+import rehypePrism from "rehype-prism-plus";
+import rehypeSanitize from "rehype-sanitize";
+import rehypeSlug from "rehype-slug";
+import rehypeStringify from "rehype-stringify";
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+import remarkGithubBlockquoteAlert from "remark-github-blockquote-alert";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import { visit } from "unist-util-visit";
+
+// src/errorReporting.ts
+function defaultArticlesErrorHandler(report) {
+  if (process.env.NODE_ENV === "production") return;
+  const context = report.context ? ` ${JSON.stringify(report.context)}` : "";
+  const detail = report.error instanceof Error ? `: ${report.error.message}` : "";
+  console.warn(`[articles:${report.code}] ${report.message}${context}${detail}`);
+}
+var articlesErrorHandler = defaultArticlesErrorHandler;
+function reportArticlesError(report) {
+  articlesErrorHandler(report);
+}
+
+// src/markdown.ts
+function sanitizeImagePath(rawPath, articleSlug) {
+  if (!rawPath || typeof rawPath !== "string") {
+    return null;
+  }
+  const cleanPath = rawPath.replaceAll(/[\x00-\x1f\x7f-\x9f]/g, "");
+  if (cleanPath.startsWith("http://") || cleanPath.startsWith("https://")) {
+    return cleanPath;
+  }
+  if (cleanPath.includes("..") || cleanPath.includes("\\") || cleanPath.startsWith("/")) {
+    reportArticlesError({
+      code: "unsafe-image-path",
+      message: "Rejected unsafe markdown image path.",
+      context: { articleSlug, path: cleanPath }
+    });
+    return null;
+  }
+  if (!/^[a-zA-Z0-9._/-]+$/.test(cleanPath)) {
+    reportArticlesError({
+      code: "unsafe-image-path",
+      message: "Rejected markdown image path with invalid characters.",
+      context: { articleSlug, path: cleanPath }
+    });
+    return null;
+  }
+  if (cleanPath.includes("/")) {
+    const normalizedPath = cleanPath.replaceAll("\\", "/");
+    if (normalizedPath.startsWith("..") || normalizedPath.includes("../")) {
+      reportArticlesError({
+        code: "unsafe-image-path",
+        message: "Rejected markdown image path traversal attempt.",
+        context: { articleSlug, path: cleanPath }
+      });
+      return null;
+    }
+    return `/articles/${articleSlug}/${normalizedPath}`;
+  } else {
+    return `/articles/${articleSlug}/${cleanPath}`;
+  }
+}
+function styleFootnoteLinks(nodes) {
+  nodes.forEach((n) => {
+    var _a, _b;
+    if (n.type !== "element") return;
+    const el = n;
+    if (el.tagName === "a") {
+      const isBackRef = ((_a = el.properties) == null ? void 0 : _a["dataFootnoteBackref"]) !== void 0 || ((_b = el.children[0]) == null ? void 0 : _b.type) === "text" && el.children[0].value === "\u21A9";
+      if (isBackRef) {
+        el.properties.className = "text-primary hover:underline ml-1";
+        if (typeof el.properties.href === "string") {
+          el.properties.href = el.properties.href.replaceAll("#user-content-fnref-", "#ref-");
+        }
+      } else {
+        el.properties.className = "text-primary hover:underline break-all";
+      }
+    }
+    if (el.children) styleFootnoteLinks(el.children);
+  });
+}
+function processFootnoteRef(node) {
+  var _a, _b, _c, _d, _e, _f;
+  if (node.tagName !== "sup" || ((_b = (_a = node.children) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) !== "element" || node.children[0].tagName !== "a")
+    return;
+  const link = node.children[0];
+  const href = (_c = link.properties) == null ? void 0 : _c.href;
+  if (typeof href !== "string" || !href.startsWith("#user-content-fn-")) return;
+  delete link.properties.target;
+  delete link.properties.rel;
+  link.properties.className = "text-primary hover:underline";
+  link.properties.href = href.replaceAll("#user-content-fn-", "#footnote-");
+  if (typeof ((_d = node.properties) == null ? void 0 : _d.id) === "string") {
+    link.properties.id = node.properties.id.replaceAll("user-content-fnref-", "ref-");
+    delete node.properties.id;
+  }
+  if (((_f = (_e = link.children) == null ? void 0 : _e[0]) == null ? void 0 : _f.type) === "text") {
+    link.children[0].value = `[${link.children[0].value}]`;
+  }
+}
+function processFootnotesSection(node) {
+  var _a;
+  const cls = (_a = node.properties) == null ? void 0 : _a.className;
+  const isFootnotes = node.tagName === "section" && (Array.isArray(cls) ? cls.includes("footnotes") : cls === "footnotes");
+  if (!isFootnotes) return;
+  const olCandidate = node.children.find(
+    (child) => child.type === "element" && child.tagName === "ol"
+  );
+  if ((olCandidate == null ? void 0 : olCandidate.type) !== "element") return;
+  const ol = olCandidate;
+  ol.properties.className = "list-decimal ml-6 space-y-2 text-sm text-muted-foreground";
+  ol.children.forEach((li) => {
+    if (li.type !== "element" || li.tagName !== "li") return;
+    const liEl = li;
+    if (liEl.properties) {
+      liEl.properties.className = "pl-2";
+      if (typeof liEl.properties.id === "string") {
+        liEl.properties.id = liEl.properties.id.replaceAll("user-content-fn-", "footnote-");
+      }
+    }
+    const pIndex = liEl.children.findIndex(
+      (child) => child.type === "element" && child.tagName === "p"
+    );
+    if (pIndex !== -1) {
+      const p = liEl.children[pIndex];
+      liEl.children.splice(pIndex, 1, ...p.children);
+    }
+    styleFootnoteLinks(liEl.children);
+  });
+  const hr = {
+    type: "element",
+    tagName: "hr",
+    properties: { className: "my-8 border-border" },
+    children: []
+  };
+  const h3 = {
+    type: "element",
+    tagName: "h3",
+    properties: { className: "text-lg font-semibold mb-4" },
+    children: [{ type: "text", value: "References" }]
+  };
+  node.children = [hr, h3, ol];
+  if (node.properties) node.properties.className = void 0;
+}
+var customRenderer = () => {
+  return (tree) => {
+    visit(tree, "element", (node) => {
+      if (node.tagName) {
+        const props = node.properties || {};
+        switch (node.tagName) {
+          case "h1":
+            props.className = "text-3xl font-bold text-foreground mt-8 mb-4 scroll-mt-20";
+            break;
+          case "h2":
+            props.className = "text-2xl font-semibold text-foreground mt-6 mb-3 scroll-mt-20";
+            break;
+          case "h3":
+            props.className = "text-xl font-semibold text-foreground mt-4 mb-2 scroll-mt-20";
+            break;
+          case "h4":
+            props.className = "text-lg font-semibold text-foreground mt-3 mb-2 scroll-mt-20";
+            break;
+          case "p":
+            props.className = "text-muted-foreground leading-relaxed mb-4";
+            break;
+          case "a": {
+            props.className = "text-primary hover:underline transition-colors duration-200";
+            const href = typeof props.href === "string" ? props.href : "";
+            if (!href.startsWith("#")) {
+              props.target = "_blank";
+              props.rel = "noopener noreferrer";
+            }
+            break;
+          }
+          case "ul":
+            props.className = "list-disc list-inside mb-4 space-y-2 ml-4";
+            break;
+          case "ol":
+            props.className = "list-decimal list-inside mb-4 space-y-2 ml-4";
+            break;
+          case "li":
+            props.className = "mb-1";
+            break;
+          case "blockquote":
+            props.className = "border-l-4 border-primary pl-4 italic my-4 text-muted-foreground";
+            break;
+          case "code":
+            props.className = (props.className ? props.className + " " : "") + "bg-muted px-1 py-0.5 rounded text-sm font-mono";
+            break;
+          case "pre":
+            props.className = "bg-muted rounded-lg p-4 overflow-x-auto my-4";
+            break;
+          case "img":
+            props.className = "rounded-lg my-6 w-full max-w-2xl mx-auto";
+            break;
+          case "table":
+            props.className = "border-collapse border border-border my-4 w-full";
+            break;
+          case "th":
+            props.className = "border border-border px-2 py-1 bg-muted font-semibold";
+            break;
+          case "td":
+            props.className = "border border-border px-2 py-1";
+            break;
+          case "hr":
+            props.className = "my-8 border-border";
+            break;
+          default:
+            break;
+        }
+        node.properties = props;
+      }
+    });
+    visit(tree, "element", (node) => {
+      processFootnoteRef(node);
+      processFootnotesSection(node);
+    });
+  };
+};
+var rehypeProcessImages = (options = {}) => {
+  return (tree) => {
+    visit(tree, "element", (node) => {
+      if (node.tagName === "img" && node.properties) {
+        const src = node.properties.src;
+        if (src && typeof src === "string" && options.articleSlug) {
+          const sanitizedSrc = sanitizeImagePath(src, options.articleSlug);
+          if (sanitizedSrc) {
+            node.properties.src = sanitizedSrc;
+          } else {
+            reportArticlesError({
+              code: "unsafe-image-path",
+              message: "Using placeholder for unsafe markdown image path.",
+              context: { articleSlug: options.articleSlug, path: src }
+            });
+            node.properties.src = "/placeholder-logo.png";
+          }
+        }
+      }
+    });
+  };
+};
+function markdownToHtml(markdown, articleSlug) {
+  return __async(this, null, function* () {
+    try {
+      let processor = remark().use(remarkParse).use(remarkGfm).use(remarkGithubBlockquoteAlert).use(remarkRehype).use(customRenderer).use(rehypeSlug).use(rehypePrism).use(rehypeSanitize, {
+        attributes: {
+          "*": ["className", "class", "id"],
+          a: ["href", "target", "rel", "id"],
+          img: ["src", "alt"]
+        }
+      });
+      if (articleSlug) {
+        processor = processor.use(rehypeProcessImages, { articleSlug });
+      }
+      const result = yield processor.use(rehypeStringify).process(markdown);
+      return result.toString();
+    } catch (error) {
+      reportArticlesError({
+        code: "markdown-conversion-failed",
+        message: "Unable to convert markdown to HTML.",
+        error,
+        context: { articleSlug }
+      });
+      return markdown;
+    }
+  });
+}
+function nodeTextValue(c) {
+  return c.type === "text" ? c.value : "";
+}
+function extractHeadingItem(node) {
+  var _a;
+  const match = /^h([1-6])$/.exec(node.tagName);
+  if (!match) return null;
+  const id = typeof ((_a = node.properties) == null ? void 0 : _a.id) === "string" ? node.properties.id : "";
+  const text = node.children.map(nodeTextValue).join("");
+  if (!id || !text) return null;
+  return { id, depth: Number.parseInt(match[1], 10), text };
+}
+function extractToc(markdown) {
+  return __async(this, null, function* () {
+    const headings = [];
+    const collectHeadings = () => (tree) => {
+      visit(tree, "element", (node) => {
+        const item = extractHeadingItem(node);
+        if (item) headings.push(item);
+      });
+    };
+    yield remark().use(remarkParse).use(remarkGfm).use(remarkRehype).use(rehypeSlug).use(collectHeadings).use(rehypeStringify).process(markdown);
+    return headings;
+  });
+}
+
+// src/server-articles.ts
+var articlesDirectory = path.join(
+  /* turbopackIgnore: true */
+  process.cwd(),
+  "public/articles"
+);
+function getReadingTime(content) {
+  return readingTime(content).text;
+}
+function findArticleImage(slug) {
+  try {
+    const articleDir = path.join(articlesDirectory, slug);
+    const entries = fs.readdirSync(articleDir, { withFileTypes: true });
+    const names = entries.map((entry) => {
+      if (typeof entry === "string") return entry;
+      if (entry && typeof entry.name === "string") return entry.name;
+      return null;
+    }).filter((name) => Boolean(name));
+    const imageExtensions = [".png", ".jpg", ".jpeg", ".gif", ".webp"];
+    const imageFileName = names.find(
+      (name) => imageExtensions.some((ext) => name.toLowerCase().endsWith(ext))
+    );
+    return imageFileName ? sanitizeImagePath2(imageFileName, slug) : null;
+  } catch (e) {
+    return null;
+  }
+}
+function sanitizeImagePath2(rawPath, articleSlug) {
+  if (!rawPath || typeof rawPath !== "string") return null;
+  const cleanPath = rawPath.replaceAll(/[\x00-\x1f\x7f-\x9f]/g, "");
+  if (cleanPath.startsWith("http://") || cleanPath.startsWith("https://")) return cleanPath;
+  if (cleanPath.includes("..") || cleanPath.includes("\\") || cleanPath.startsWith("/")) {
+    reportArticlesError({
+      code: "unsafe-image-path",
+      message: "Rejected unsafe article image path.",
+      context: { articleSlug, path: cleanPath }
+    });
+    return null;
+  }
+  if (!/^[a-zA-Z0-9._/-]+$/.test(cleanPath)) {
+    reportArticlesError({
+      code: "unsafe-image-path",
+      message: "Rejected article image path with invalid characters.",
+      context: { articleSlug, path: cleanPath }
+    });
+    return null;
+  }
+  if (cleanPath.includes("/")) {
+    const normalizedPath = path.normalize(cleanPath);
+    if (normalizedPath.startsWith("..") || normalizedPath.includes("../")) {
+      reportArticlesError({
+        code: "unsafe-image-path",
+        message: "Rejected article image path traversal attempt.",
+        context: { articleSlug, path: cleanPath }
+      });
+      return null;
+    }
+    return `/articles/${articleSlug}/${cleanPath}`;
+  }
+  return `/articles/${articleSlug}/${cleanPath}`;
+}
+function findArticleFile(slug) {
+  const mdPath = path.join(articlesDirectory, slug, "article.md");
+  const mdxPath = path.join(articlesDirectory, slug, "article.mdx");
+  if (fs.existsSync(mdPath)) return { filePath: mdPath, contentType: "md" };
+  if (fs.existsSync(mdxPath)) return { filePath: mdxPath, contentType: "mdx" };
+  return null;
+}
+function getAvailableArticleSlugs() {
+  try {
+    if (!fs.existsSync(articlesDirectory)) return [];
+    return walkArticleDir(articlesDirectory, "");
+  } catch (error) {
+    reportArticlesError({
+      code: "article-directory-read-failed",
+      message: "Unable to read articles directory.",
+      error,
+      context: { directory: articlesDirectory }
+    });
+    return [];
+  }
+}
+function walkArticleDir(dir, baseSlug) {
+  const slugs = [];
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      if (!item.isDirectory()) continue;
+      const slug = baseSlug ? `${baseSlug}/${item.name}` : item.name;
+      if (findArticleFile(slug) !== null) {
+        slugs.push(slug);
+      }
+      slugs.push(...walkArticleDir(path.join(dir, item.name), slug));
+    }
+  } catch (e) {
+  }
+  return slugs;
+}
+function parseDateField(rawDate) {
+  if (!rawDate) return void 0;
+  try {
+    const parsed = new Date(rawDate);
+    if (!Number.isNaN(parsed.getTime())) return parsed.toISOString().split("T")[0];
+  } catch (e) {
+  }
+  return void 0;
+}
+function resolveFeaturedImage(rawImage, slug) {
+  const img = typeof rawImage === "string" ? rawImage : "";
+  if (img && !img.startsWith("http")) return sanitizeImagePath2(img, slug) || "/placeholder-logo.png";
+  if (!img) return findArticleImage(slug) || "/placeholder-logo.png";
+  return img;
+}
+function parseFaqItems(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const items = raw.filter(
+    (item) => typeof item === "object" && item !== null && typeof item.question === "string" && typeof item.answer === "string"
+  );
+  return items.length ? items : void 0;
+}
+function parseHowToSteps(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const steps = raw.filter(
+    (item) => typeof item === "object" && item !== null && typeof item.name === "string" && typeof item.text === "string"
+  );
+  return steps.length ? steps : void 0;
+}
+function getArticleSummary(slug) {
+  return __async(this, null, function* () {
+    try {
+      const found = findArticleFile(slug);
+      if (!found) return null;
+      const fileContent = fs.readFileSync(found.filePath, "utf8");
+      const { data, content: markdownContent } = matter(fileContent);
+      const readTime = getReadingTime(markdownContent);
+      const allTags = Array.isArray(data.tags) ? data.tags.filter((t) => typeof t === "string" && String(t).trim()) : [];
+      const categories = allTags.length > 0 ? allTags.map((t) => t.replaceAll("-", " ").trim()) : ["Campaigns"];
+      return {
+        slug,
+        title: data.title || slug.replaceAll("-", " "),
+        excerpt: data.excerpt || "",
+        date: parseDateField(data.date),
+        lastmod: parseDateField(data.lastmod),
+        author: data.author || "Andrew Blase",
+        category: categories[0],
+        categories,
+        readTime,
+        featuredImage: resolveFeaturedImage(data.featuredImage, slug),
+        tags: data.tags || [],
+        contentType: found.contentType,
+        draft: data.draft === true,
+        faq: parseFaqItems(data.faq),
+        howTo: parseHowToSteps(data.howTo),
+        canonicalUrl: typeof data.canonicalUrl === "string" ? data.canonicalUrl : void 0,
+        articleType: typeof data.articleType === "string" ? data.articleType : void 0,
+        series: typeof data.series === "string" ? data.series : void 0,
+        aiCrawl: data.aiCrawl === true
+      };
+    } catch (error) {
+      reportArticlesError({
+        code: "article-load-failed",
+        message: "Unable to load article summary.",
+        error,
+        context: { slug }
+      });
+      return null;
+    }
+  });
+}
+var getArticleMetadata = cache((slug) => __async(void 0, null, function* () {
+  try {
+    const summary = yield getArticleSummary(slug);
+    if (!summary) return null;
+    const found = findArticleFile(slug);
+    if (!found) return null;
+    const fileContent = fs.readFileSync(found.filePath, "utf8");
+    const { content: markdownContent } = matter(fileContent);
+    const toc = yield extractToc(markdownContent);
+    let htmlContent;
+    let mdxSource;
+    if (found.contentType === "mdx") {
+      mdxSource = markdownContent;
+    } else {
+      htmlContent = yield markdownToHtml(markdownContent, slug);
+    }
+    return __spreadProps(__spreadValues({}, summary), { content: markdownContent, htmlContent, mdxSource, toc });
+  } catch (error) {
+    reportArticlesError({
+      code: "article-load-failed",
+      message: "Unable to load article metadata.",
+      error,
+      context: { slug }
+    });
+    return null;
+  }
+}));
+var getAllArticles = cache(() => __async(void 0, null, function* () {
+  const slugs = getAvailableArticleSlugs();
+  const articles = yield Promise.all(slugs.map((slug) => getArticleSummary(slug)));
+  const currentDate = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  return articles.filter((article) => article !== null).filter((article) => !article.date || article.date <= currentDate).filter((article) => !(article.draft && process.env.NODE_ENV === "production")).sort((a, b) => {
+    if (!a.date && !b.date) return 0;
+    if (!a.date) return 1;
+    if (!b.date) return -1;
+    return new Date(b.date).getTime() - new Date(a.date).getTime();
+  });
+}));
+function getArticleMarkdown(slug) {
+  return __async(this, null, function* () {
+    try {
+      const summary = yield getArticleSummary(slug);
+      if (!(summary == null ? void 0 : summary.aiCrawl)) return null;
+      const found = findArticleFile(slug);
+      if (!found) return null;
+      const fileContent = fs.readFileSync(found.filePath, "utf8");
+      const { content: markdownContent } = matter(fileContent);
+      return markdownContent;
+    } catch (error) {
+      reportArticlesError({
+        code: "article-markdown-load-failed",
+        message: "Unable to load article markdown.",
+        error,
+        context: { slug }
+      });
+      return null;
+    }
+  });
+}
+function getArticleMarkdownResponse(slug, config) {
+  return __async(this, null, function* () {
+    const markdown = yield getArticleMarkdown(slug);
+    if (markdown === null) return new Response("Not Found", { status: 404 });
+    const article = yield getArticleMetadata(slug);
+    return new Response(markdown, {
+      headers: __spreadValues({
+        "Content-Type": "text/markdown; charset=utf-8",
+        "Cache-Control": "public, max-age=3600, s-maxage=3600"
+      }, article ? getArticleAiHeaders(article, config) : {})
+    });
+  });
+}
+function getArticleMarkdownUrl(article, config) {
+  if (article.aiCrawl !== true) return void 0;
+  const pathname = `/articles/${article.slug}.md`;
+  if (!config) return pathname;
+  return `${config.siteUrl.replace(/\/$/, "")}${pathname}`;
+}
+function getArticleAiHeaders(article, config) {
+  const markdownUrl = getArticleMarkdownUrl(article, config);
+  if (markdownUrl) {
+    return {
+      Link: `<${markdownUrl}>; rel="alternate"; type="text/markdown"`
+    };
+  }
+  return {
+    "X-Robots-Tag": "noai, noimageai"
+  };
+}
+
+// src/nextjs.ts
+function createArticleMarkdownHandler(config) {
+  function GET(_request, context) {
+    return __async(this, null, function* () {
+      const params = yield context.params;
+      const slugParts = params["slug"];
+      const slug = Array.isArray(slugParts) ? slugParts.join("/") : slugParts != null ? slugParts : "";
+      const cleanSlug = slug.endsWith(".md") ? slug.slice(0, -3) : slug;
+      return getArticleMarkdownResponse(cleanSlug, config);
+    });
+  }
+  return { GET };
+}
+export {
+  createArticleMarkdownHandler
+};
+//# sourceMappingURL=nextjs.js.map