@fullstackdatasolutions/articles 0.1.0

package/dist/server.cjs

@@ -0,0 +1,732 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+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.ts
+var server_exports = {};
+__export(server_exports, {
+  categoryToSlug: () => categoryToSlug,
+  generateArticleMetadata: () => generateArticleMetadata,
+  generateArticleStaticParams: () => generateArticleStaticParams,
+  generateCategoryMetadata: () => generateCategoryMetadata,
+  generateCategoryStaticParams: () => generateCategoryStaticParams,
+  getAdjacentArticles: () => getAdjacentArticles,
+  getAllArticles: () => getAllArticles,
+  getAllCategories: () => getAllCategories,
+  getArticleMetadata: () => getArticleMetadata,
+  getArticleSitemapEntries: () => getArticleSitemapEntries,
+  getArticlesByCategory: () => getArticlesByCategory,
+  getAvailableArticleSlugs: () => getAvailableArticleSlugs,
+  markdownToHtml: () => markdownToHtml,
+  sanitizeImagePath: () => sanitizeImagePath2,
+  searchArticles: () => searchArticles
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/server-articles.ts
+var import_react = require("react");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_reading_time = __toESM(require("reading-time"), 1);
+
+// src/markdown.ts
+var import_rehype_prism_plus = __toESM(require("rehype-prism-plus"), 1);
+var import_rehype_sanitize = __toESM(require("rehype-sanitize"), 1);
+var import_rehype_stringify = __toESM(require("rehype-stringify"), 1);
+var import_remark = require("remark");
+var import_remark_gfm = __toESM(require("remark-gfm"), 1);
+var import_remark_parse = __toESM(require("remark-parse"), 1);
+var import_remark_rehype = __toESM(require("remark-rehype"), 1);
+var import_unist_util_visit = require("unist-util-visit");
+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("/")) {
+    console.warn(`Potentially unsafe image path detected: ${cleanPath}`);
+    return null;
+  }
+  if (!/^[a-zA-Z0-9._/-]+$/.test(cleanPath)) {
+    console.warn(`Invalid characters in image path: ${cleanPath}`);
+    return null;
+  }
+  if (cleanPath.includes("/")) {
+    const normalizedPath = cleanPath.replaceAll("\\", "/");
+    if (normalizedPath.startsWith("..") || normalizedPath.includes("../")) {
+      console.warn(`Path traversal attempt detected: ${cleanPath}`);
+      return null;
+    }
+    return `/articles/${articleSlug}/${normalizedPath}`;
+  } else {
+    return `/articles/${articleSlug}/${cleanPath}`;
+  }
+}
+var customRenderer = () => {
+  return (tree) => {
+    (0, import_unist_util_visit.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";
+            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;
+      }
+    });
+    (0, import_unist_util_visit.visit)(tree, "element", (node) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h;
+      if (node.tagName === "sup" && ((_b = (_a = node.children) == null ? void 0 : _a[0]) == null ? void 0 : _b.type) === "element" && node.children[0].tagName === "a") {
+        const link = node.children[0];
+        if (((_c = link.properties) == null ? void 0 : _c.href) && typeof link.properties.href === "string" && link.properties.href.startsWith("#user-content-fn-")) {
+          if (link.properties) {
+            delete link.properties.target;
+            delete link.properties.rel;
+            link.properties.className = "text-primary hover:underline";
+          }
+          link.properties.href = link.properties.href.replaceAll("#user-content-fn-", "#footnote-");
+          if (((_d = node.properties) == null ? void 0 : _d.id) && typeof node.properties.id === "string") {
+            const newId = node.properties.id.replaceAll("user-content-fnref-", "ref-");
+            link.properties.id = newId;
+            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}]`;
+          }
+        }
+      }
+      if (node.tagName === "section" && (Array.isArray((_g = node.properties) == null ? void 0 : _g.className) ? node.properties.className.includes("footnotes") : ((_h = node.properties) == null ? void 0 : _h.className) === "footnotes")) {
+        const olCandidate = node.children.find(
+          (child) => child.type === "element" && child.tagName === "ol"
+        );
+        if ((olCandidate == null ? void 0 : olCandidate.type) === "element") {
+          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") {
+              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);
+              }
+              const styleLinks = (nodes) => {
+                nodes.forEach((n) => {
+                  var _a2, _b2;
+                  if (n.type !== "element")
+                    return;
+                  const el = n;
+                  if (el.tagName === "a") {
+                    const isBackRef = ((_a2 = el.properties) == null ? void 0 : _a2["dataFootnoteBackref"]) !== void 0 || ((_b2 = el.children[0]) == null ? void 0 : _b2.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)
+                    styleLinks(el.children);
+                });
+              };
+              styleLinks(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 rehypeProcessImages = (options = {}) => {
+  return (tree) => {
+    (0, import_unist_util_visit.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 {
+            console.warn(`Using placeholder for unsafe image path: ${src}`);
+            node.properties.src = "/placeholder-logo.png";
+          }
+        }
+      }
+    });
+  };
+};
+function markdownToHtml(markdown, articleSlug) {
+  return __async(this, null, function* () {
+    try {
+      let processor = (0, import_remark.remark)().use(import_remark_parse.default).use(import_remark_gfm.default).use(import_remark_rehype.default).use(customRenderer).use(import_rehype_prism_plus.default).use(import_rehype_sanitize.default, {
+        attributes: {
+          "*": ["className", "class", "id"],
+          a: ["href", "target", "rel", "id"],
+          img: ["src", "alt"]
+        }
+      });
+      if (articleSlug) {
+        processor = processor.use(rehypeProcessImages, { articleSlug });
+      }
+      const result = yield processor.use(import_rehype_stringify.default).process(markdown);
+      return result.toString();
+    } catch (error) {
+      console.error("Markdown conversion error:", error);
+      return markdown;
+    }
+  });
+}
+
+// src/server-articles.ts
+var articlesDirectory = import_node_path.default.join(process.cwd(), "public/articles");
+function getReadingTime(content) {
+  return (0, import_reading_time.default)(content).text;
+}
+function findArticleImage(slug) {
+  try {
+    const articleDir = import_node_path.default.join(articlesDirectory, slug);
+    const entries = import_node_fs.default.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("/")) {
+    console.warn(`Potentially unsafe image path detected: ${cleanPath}`);
+    return null;
+  }
+  if (!/^[a-zA-Z0-9._/-]+$/.test(cleanPath)) {
+    console.warn(`Invalid characters in image path: ${cleanPath}`);
+    return null;
+  }
+  if (cleanPath.includes("/")) {
+    const normalizedPath = import_node_path.default.normalize(cleanPath);
+    if (normalizedPath.startsWith("..") || normalizedPath.includes("../")) {
+      console.warn(`Path traversal attempt detected: ${cleanPath}`);
+      return null;
+    }
+    return `/articles/${articleSlug}/${cleanPath}`;
+  }
+  return `/articles/${articleSlug}/${cleanPath}`;
+}
+function getAvailableArticleSlugs() {
+  try {
+    if (!import_node_fs.default.existsSync(articlesDirectory))
+      return [];
+    const items = import_node_fs.default.readdirSync(articlesDirectory, { withFileTypes: true });
+    return items.filter((item) => item.isDirectory()).filter((dir) => {
+      const articleDir = import_node_path.default.join(articlesDirectory, dir.name);
+      try {
+        const entries = import_node_fs.default.readdirSync(articleDir, {
+          withFileTypes: true
+        });
+        return entries.some((entry) => {
+          const name = typeof entry === "string" ? entry : entry == null ? void 0 : entry.name;
+          if (name !== "article.md")
+            return false;
+          if (typeof entry === "string")
+            return true;
+          if (typeof (entry == null ? void 0 : entry.isFile) === "function")
+            return entry.isFile();
+          return true;
+        });
+      } catch (e) {
+        return false;
+      }
+    }).map((dir) => dir.name);
+  } catch (error) {
+    console.error("Error reading articles directory:", error);
+    return [];
+  }
+}
+function getArticleSummary(slug) {
+  return __async(this, null, function* () {
+    try {
+      const articlePath = import_node_path.default.join(articlesDirectory, slug, "article.md");
+      if (!import_node_fs.default.existsSync(articlePath))
+        return null;
+      const fileContent = import_node_fs.default.readFileSync(articlePath, "utf8");
+      const { data, content: markdownContent } = (0, import_gray_matter.default)(fileContent);
+      const readTime = getReadingTime(markdownContent);
+      let featuredImage = data.featuredImage || "";
+      if (featuredImage && !featuredImage.startsWith("http")) {
+        const sanitizedPath = sanitizeImagePath2(featuredImage, slug);
+        featuredImage = sanitizedPath || "/placeholder-logo.png";
+      } else if (!featuredImage) {
+        featuredImage = findArticleImage(slug) || "/placeholder-logo.png";
+      }
+      let articleDate;
+      if (data.date) {
+        try {
+          const parsedDate = new Date(data.date);
+          if (!Number.isNaN(parsedDate.getTime())) {
+            articleDate = parsedDate.toISOString().split("T")[0];
+          }
+        } catch (e) {
+          console.warn(`Invalid date for article ${slug}: ${data.date}`);
+        }
+      }
+      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: articleDate,
+        author: data.author || "Andrew Blase",
+        category: categories[0],
+        categories,
+        readTime,
+        featuredImage,
+        tags: data.tags || []
+      };
+    } catch (error) {
+      console.error(`Error loading article ${slug}:`, error);
+      return null;
+    }
+  });
+}
+var getArticleMetadata = (0, import_react.cache)((slug) => __async(void 0, null, function* () {
+  try {
+    const articlePath = import_node_path.default.join(articlesDirectory, slug, "article.md");
+    if (!import_node_fs.default.existsSync(articlePath))
+      return null;
+    const fileContent = import_node_fs.default.readFileSync(articlePath, "utf8");
+    const { data, content: markdownContent } = (0, import_gray_matter.default)(fileContent);
+    const htmlContent = yield markdownToHtml(markdownContent, slug);
+    const readTime = getReadingTime(markdownContent);
+    let featuredImage = data.featuredImage || "";
+    if (featuredImage && !featuredImage.startsWith("http")) {
+      const sanitizedPath = sanitizeImagePath2(featuredImage, slug);
+      featuredImage = sanitizedPath || "/placeholder-logo.png";
+    } else if (!featuredImage) {
+      featuredImage = findArticleImage(slug) || "/placeholder-logo.png";
+    }
+    let articleDate;
+    if (data.date) {
+      try {
+        const parsedDate = new Date(data.date);
+        if (!Number.isNaN(parsedDate.getTime())) {
+          articleDate = parsedDate.toISOString().split("T")[0];
+        }
+      } catch (e) {
+        console.warn(`Invalid date for article ${slug}: ${data.date}`);
+      }
+    }
+    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: articleDate,
+      author: data.author || "Andrew Blase",
+      category: categories[0],
+      categories,
+      readTime,
+      featuredImage,
+      tags: data.tags || [],
+      content: markdownContent,
+      htmlContent
+    };
+  } catch (error) {
+    console.error(`Error loading article ${slug}:`, error);
+    return null;
+  }
+}));
+var getAllArticles = (0, import_react.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).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 getAdjacentArticles(currentSlug) {
+  return __async(this, null, function* () {
+    const allArticles = yield getAllArticles();
+    const currentIndex = allArticles.findIndex((article) => article.slug === currentSlug);
+    if (currentIndex === -1)
+      return { previous: null, next: null };
+    const previous = currentIndex < allArticles.length - 1 ? allArticles[currentIndex + 1] : null;
+    const next = currentIndex > 0 ? allArticles[currentIndex - 1] : null;
+    return { previous, next };
+  });
+}
+function searchArticles(query) {
+  return __async(this, null, function* () {
+    if (!(query == null ? void 0 : query.trim()))
+      return getAllArticles();
+    const articles = yield getAllArticles();
+    const searchTerm = query.toLowerCase().trim();
+    return articles.filter((article) => {
+      var _a;
+      const matchesTitle = article.title.toLowerCase().includes(searchTerm);
+      const matchesExcerpt = article.excerpt.toLowerCase().includes(searchTerm);
+      const matchesAuthor = article.author.toLowerCase().includes(searchTerm);
+      const matchesCategory = article.categories.some((cat) => cat.toLowerCase().includes(searchTerm));
+      const matchesTags = (_a = article.tags) == null ? void 0 : _a.some((tag) => tag.toLowerCase().includes(searchTerm));
+      return matchesTitle || matchesExcerpt || matchesAuthor || matchesCategory || Boolean(matchesTags);
+    });
+  });
+}
+function categoryToSlug(category) {
+  return category.toLowerCase().replaceAll(/\s+/g, "-").replaceAll(/[^a-z0-9-]/g, "");
+}
+function getAllCategories() {
+  return __async(this, null, function* () {
+    const articles = yield getAllArticles();
+    const categoryMap = /* @__PURE__ */ new Map();
+    for (const article of articles) {
+      for (const cat of article.categories) {
+        if (!categoryMap.has(cat)) {
+          categoryMap.set(cat, { count: 0, featuredImage: article.featuredImage });
+        }
+        categoryMap.get(cat).count++;
+      }
+    }
+    return Array.from(categoryMap.entries()).map(([name, { count, featuredImage }]) => ({
+      name,
+      slug: categoryToSlug(name),
+      count,
+      featuredImage
+    })).sort((a, b) => b.count - a.count);
+  });
+}
+function getArticlesByCategory(categorySlug) {
+  return __async(this, null, function* () {
+    const articles = yield getAllArticles();
+    return articles.filter(
+      (article) => article.categories.some((cat) => categoryToSlug(cat) === categorySlug)
+    );
+  });
+}
+
+// src/seoUtils.ts
+function generateArticleStaticParams() {
+  return getAvailableArticleSlugs().map((slug) => ({ slug }));
+}
+function generateCategoryStaticParams() {
+  return __async(this, null, function* () {
+    const categories = yield getAllCategories();
+    return categories.map((cat) => ({ category: cat.slug }));
+  });
+}
+function resolveImageUrl(featuredImage, siteUrl) {
+  const base = siteUrl.replace(/\/$/, "");
+  if (featuredImage.startsWith("http://") || featuredImage.startsWith("https://")) {
+    return featuredImage;
+  }
+  return `${base}/${featuredImage.replace(/^\/+/, "")}`;
+}
+function generateArticleMetadata(slug, config) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    const article = yield getArticleMetadata(slug);
+    if (!article) {
+      return {
+        title: "Article Not Found",
+        description: "The requested article could not be found."
+      };
+    }
+    const siteUrl = config.siteUrl.replace(/\/$/, "");
+    const articleUrl = `${siteUrl}/articles/${slug}`;
+    const imageUrl = article.featuredImage ? resolveImageUrl(article.featuredImage, siteUrl) : `${siteUrl}/placeholder-logo.png`;
+    const description = (_a = article.excerpt) != null ? _a : `Read ${article.title} on ${config.siteName}.`;
+    return {
+      title: `${article.title} | ${config.siteName}`,
+      description,
+      keywords: [
+        "volunteer management software",
+        "political campaign software",
+        "campaign operations",
+        "civic tech",
+        ...((_b = article.tags) != null ? _b : []).map((tag) => tag.toLowerCase())
+      ].join(", "),
+      openGraph: __spreadProps(__spreadValues({
+        title: article.title,
+        description,
+        url: articleUrl,
+        siteName: config.siteName,
+        images: [{ url: imageUrl, width: 1200, height: 630, alt: article.title }],
+        locale: "en_US",
+        type: "article"
+      }, article.date && { publishedTime: article.date }), {
+        authors: [article.author],
+        tags: (_c = article.tags) != null ? _c : []
+      }),
+      twitter: {
+        card: "summary_large_image",
+        title: article.title,
+        description,
+        images: [imageUrl]
+      },
+      alternates: {
+        canonical: articleUrl
+      },
+      robots: {
+        index: true,
+        follow: true,
+        googleBot: {
+          index: true,
+          follow: true,
+          "max-video-preview": -1,
+          "max-image-preview": "large",
+          "max-snippet": -1
+        }
+      },
+      other: __spreadProps(__spreadValues({
+        "article:author": article.author
+      }, article.date && {
+        "article:published_time": new Date(article.date).toISOString()
+      }), {
+        "article:section": article.category,
+        "article:tag": (_e = (_d = article.tags) == null ? void 0 : _d.join(",")) != null ? _e : "",
+        "linkedin:owner": (_f = process.env.NEXT_PUBLIC_LINKEDIN_COMPANY_ID) != null ? _f : ""
+      })
+    };
+  });
+}
+function generateCategoryMetadata(categorySlug, config) {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const articles = yield getArticlesByCategory(categorySlug);
+    if (articles.length === 0)
+      return { title: "Category Not Found" };
+    const categoryName = articles[0].category;
+    const siteUrl = config.siteUrl.replace(/\/$/, "");
+    const categoryUrl = `${siteUrl}/articles/category/${categorySlug}`;
+    const raw = (_a = config.categoryDescriptions) == null ? void 0 : _a[categorySlug];
+    const fallback = `Browse ${articles.length} article${articles.length === 1 ? "" : "s"} in the ${categoryName} category.`;
+    const description = typeof raw === "string" ? raw : (_b = raw == null ? void 0 : raw.short) != null ? _b : fallback;
+    return {
+      title: `${categoryName} Articles | ${config.siteName}`,
+      description,
+      openGraph: {
+        title: `${categoryName} Articles`,
+        description,
+        url: categoryUrl,
+        siteName: config.siteName,
+        images: [{ url: articles[0].featuredImage }]
+      },
+      alternates: {
+        canonical: categoryUrl
+      }
+    };
+  });
+}
+function getArticleSitemapEntries(baseUrl) {
+  return __async(this, null, function* () {
+    try {
+      const [articles, categories] = yield Promise.all([getAllArticles(), getAllCategories()]);
+      const articleEntries = articles.map((article) => ({
+        url: `${baseUrl}/articles/${article.slug}`,
+        lastModified: article.date ? new Date(article.date) : void 0,
+        changeFrequency: "weekly",
+        priority: 0.8
+      }));
+      const categoryEntries = categories.map((cat) => ({
+        url: `${baseUrl}/articles/category/${cat.slug}`,
+        lastModified: /* @__PURE__ */ new Date(),
+        changeFrequency: "weekly",
+        priority: 0.7
+      }));
+      return [...articleEntries, ...categoryEntries];
+    } catch (e) {
+      return [];
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  categoryToSlug,
+  generateArticleMetadata,
+  generateArticleStaticParams,
+  generateCategoryMetadata,
+  generateCategoryStaticParams,
+  getAdjacentArticles,
+  getAllArticles,
+  getAllCategories,
+  getArticleMetadata,
+  getArticleSitemapEntries,
+  getArticlesByCategory,
+  getAvailableArticleSlugs,
+  markdownToHtml,
+  sanitizeImagePath,
+  searchArticles
+});
+//# sourceMappingURL=server.cjs.map