@momentumcms/plugins-seo 0.4.0

package/index.cjs

@@ -0,0 +1,1665 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/plugins/seo/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  injectSeoFields: () => injectSeoFields,
+  seoPlugin: () => seoPlugin
+});
+module.exports = __toCommonJS(src_exports);
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function textarea(name, options = {}) {
+  return {
+    name,
+    type: "textarea",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function date(name, options = {}) {
+  return {
+    name,
+    type: "date",
+    ...options
+  };
+}
+function checkbox(name, options = {}) {
+  return {
+    name,
+    type: "checkbox",
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  };
+}
+function select(name, options) {
+  return {
+    name,
+    type: "select",
+    ...options
+  };
+}
+function upload(name, options = {}) {
+  return {
+    name,
+    type: "upload",
+    relationTo: options.relationTo ?? "media",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+function tabs(name, options) {
+  return {
+    name,
+    type: "tabs",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  upload: {
+    mimeTypes: ["image/*", "application/pdf", "video/*", "audio/*"]
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/core/src/lib/access/access-helpers.ts
+function hasRole(role) {
+  return ({ req }) => req.user?.role === role;
+}
+
+// libs/plugins/seo/src/lib/seo-fields.ts
+function getSeoFields() {
+  return [
+    text("metaTitle", {
+      label: "Meta Title",
+      maxLength: 70,
+      description: "Title tag for search engines (50-60 chars recommended)"
+    }),
+    textarea("metaDescription", {
+      label: "Meta Description",
+      maxLength: 160,
+      rows: 3,
+      description: "Description for search results (120-155 chars recommended)"
+    }),
+    text("canonicalUrl", {
+      label: "Canonical URL",
+      description: "Override the canonical URL for this page"
+    }),
+    text("focusKeyword", {
+      label: "Focus Keyword",
+      description: "Primary keyword to optimize this content for"
+    }),
+    text("ogTitle", {
+      label: "OG Title",
+      description: "Open Graph title (falls back to Meta Title)"
+    }),
+    textarea("ogDescription", {
+      label: "OG Description",
+      rows: 2,
+      description: "Open Graph description (falls back to Meta Description)"
+    }),
+    upload("ogImage", {
+      label: "OG Image",
+      relationTo: "media",
+      mimeTypes: ["image/*"],
+      description: "Recommended size: 1200x630px"
+    }),
+    select("ogType", {
+      label: "OG Type",
+      options: [
+        { label: "Website", value: "website" },
+        { label: "Article", value: "article" },
+        { label: "Product", value: "product" },
+        { label: "Profile", value: "profile" }
+      ],
+      defaultValue: "website"
+    }),
+    select("twitterCard", {
+      label: "Twitter Card",
+      options: [
+        { label: "Summary", value: "summary" },
+        { label: "Summary Large Image", value: "summary_large_image" },
+        { label: "Player", value: "player" },
+        { label: "App", value: "app" }
+      ],
+      defaultValue: "summary_large_image"
+    }),
+    checkbox("noIndex", {
+      label: "No Index",
+      description: "Tell search engines not to index this page"
+    }),
+    checkbox("noFollow", {
+      label: "No Follow",
+      description: "Tell search engines not to follow links on this page"
+    }),
+    checkbox("excludeFromSitemap", {
+      label: "Exclude from Sitemap",
+      description: "Exclude this page from the XML sitemap without affecting search engine indexing"
+    }),
+    json("structuredData", {
+      label: "Structured Data (JSON-LD)",
+      description: "Custom JSON-LD structured data for this page"
+    })
+  ];
+}
+function createSeoTabConfig() {
+  return {
+    name: "seo",
+    label: "SEO",
+    description: "Search engine optimization settings",
+    fields: getSeoFields()
+  };
+}
+
+// libs/plugins/seo/src/lib/seo-utils.ts
+function hasSeoField(collection) {
+  for (const field of collection.fields) {
+    if (field.name === "seo" && field.type === "group")
+      return true;
+    if (field.type === "tabs") {
+      const tabsField = field;
+      if (tabsField.tabs.some((t) => t.name === "seo"))
+        return true;
+    }
+  }
+  return false;
+}
+function extractSeoFieldData(doc) {
+  const raw = doc["seo"];
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    return raw;
+  }
+  return {};
+}
+function computeGrade(score) {
+  if (score >= 70)
+    return "good";
+  if (score >= 40)
+    return "warning";
+  return "poor";
+}
+
+// libs/plugins/seo/src/lib/seo-field-injector.ts
+function shouldInject(collection, options) {
+  if (collection.managed)
+    return false;
+  if (collection.slug.startsWith("seo-"))
+    return false;
+  if (options.collections === "*") {
+    return !(options.excludeCollections ?? []).includes(collection.slug);
+  }
+  return options.collections.includes(collection.slug);
+}
+function findTopLevelTabs(collection) {
+  return collection.fields.find((f) => f.type === "tabs");
+}
+function injectSeoFields(collections, options) {
+  const seoTab = createSeoTabConfig();
+  for (const collection of collections) {
+    if (!shouldInject(collection, options))
+      continue;
+    if (hasSeoField(collection))
+      continue;
+    const existingTabs = findTopLevelTabs(collection);
+    if (existingTabs) {
+      existingTabs.tabs.push(seoTab);
+    } else {
+      const originalFields = [...collection.fields];
+      const tabsField = tabs("seoTabs", {
+        tabs: [{ label: "Content", fields: originalFields }, seoTab]
+      });
+      collection.fields = [tabsField];
+    }
+  }
+}
+
+// libs/plugins/seo/src/lib/analysis/seo-analysis-collection.ts
+function internalOrAdmin({ req }) {
+  if (!req.user)
+    return true;
+  return req.user.role === "admin";
+}
+var SeoAnalysis = defineCollection({
+  slug: "seo-analysis",
+  managed: true,
+  labels: { singular: "SEO Analysis", plural: "SEO Analyses" },
+  admin: {
+    group: "SEO",
+    hidden: true,
+    useAsTitle: "documentId"
+  },
+  fields: [
+    text("collection", { required: true, label: "Collection" }),
+    text("documentId", { required: true, label: "Document ID" }),
+    number("score", { required: true, label: "Score", min: 0, max: 100 }),
+    text("grade", { required: true, label: "Grade" }),
+    json("rules", { label: "Rule Results" }),
+    text("focusKeyword", { label: "Focus Keyword" }),
+    date("analyzedAt", { required: true, label: "Analyzed At" })
+  ],
+  access: {
+    read: internalOrAdmin,
+    create: internalOrAdmin,
+    update: internalOrAdmin,
+    delete: hasRole("admin")
+  }
+});
+
+// libs/plugins/seo/src/lib/analysis/seo-analyzer.ts
+var HTML_TAG_RE = /<[^>]*>/g;
+var HEADING_RE_SOURCE = "<h([1-6])[^>]*>(.*?)</h[1-6]>";
+var WHITESPACE_RE = /\s+/g;
+function extractTextContent(doc) {
+  const parts = [];
+  for (const value of Object.values(doc)) {
+    if (typeof value === "string") {
+      parts.push(value.replace(HTML_TAG_RE, " "));
+    }
+  }
+  return parts.join(" ").replace(WHITESPACE_RE, " ").trim();
+}
+function extractHeadings(doc) {
+  const headings = [];
+  for (const value of Object.values(doc)) {
+    if (typeof value !== "string")
+      continue;
+    const re = new RegExp(HEADING_RE_SOURCE, "gi");
+    let match;
+    while ((match = re.exec(value)) !== null) {
+      headings.push({
+        level: parseInt(match[1], 10),
+        text: match[2].replace(HTML_TAG_RE, "").trim()
+      });
+    }
+  }
+  return headings;
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function rangeScore(value, optMin, optMax, absMin, absMax) {
+  if (value >= optMin && value <= optMax)
+    return 100;
+  if (value < absMin || value > absMax)
+    return 0;
+  if (value < optMin) {
+    return Math.round((value - absMin) / (optMin - absMin) * 100);
+  }
+  return Math.round((absMax - value) / (absMax - optMax) * 100);
+}
+function createTitleLengthRule(config) {
+  const min = config?.titleLength?.min ?? 50;
+  const max = config?.titleLength?.max ?? 60;
+  return {
+    id: "title-length",
+    name: "Title Length",
+    weight: 15,
+    score: (ctx) => {
+      const title = ctx.seo.metaTitle ?? "";
+      if (!title)
+        return 0;
+      return rangeScore(title.length, min, max, 20, 70);
+    },
+    recommendation: (ctx) => {
+      const title = ctx.seo.metaTitle ?? "";
+      if (!title)
+        return "Add a meta title for search engines";
+      if (title.length < min)
+        return `Title is too short (${title.length} chars). Aim for ${min}-${max} characters.`;
+      if (title.length > max)
+        return `Title is too long (${title.length} chars). Aim for ${min}-${max} characters.`;
+      return null;
+    }
+  };
+}
+function createDescriptionLengthRule(config) {
+  const min = config?.descriptionLength?.min ?? 120;
+  const max = config?.descriptionLength?.max ?? 155;
+  return {
+    id: "description-length",
+    name: "Description Length",
+    weight: 15,
+    score: (ctx) => {
+      const desc = ctx.seo.metaDescription ?? "";
+      if (!desc)
+        return 0;
+      return rangeScore(desc.length, min, max, 50, 160);
+    },
+    recommendation: (ctx) => {
+      const desc = ctx.seo.metaDescription ?? "";
+      if (!desc)
+        return "Add a meta description for search results";
+      if (desc.length < min)
+        return `Description is too short (${desc.length} chars). Aim for ${min}-${max} characters.`;
+      if (desc.length > max)
+        return `Description is too long (${desc.length} chars). Aim for ${min}-${max} characters.`;
+      return null;
+    }
+  };
+}
+function createKeywordInTitleRule() {
+  return {
+    id: "keyword-in-title",
+    name: "Keyword in Title",
+    weight: 15,
+    score: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword)
+        return 100;
+      const title = ctx.seo.metaTitle ?? "";
+      return title.toLowerCase().includes(keyword.toLowerCase()) ? 100 : 0;
+    },
+    recommendation: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword)
+        return null;
+      const title = ctx.seo.metaTitle ?? "";
+      if (!title.toLowerCase().includes(keyword.toLowerCase())) {
+        return `Include your focus keyword "${keyword}" in the meta title`;
+      }
+      return null;
+    }
+  };
+}
+function createKeywordInDescriptionRule() {
+  return {
+    id: "keyword-in-description",
+    name: "Keyword in Description",
+    weight: 10,
+    score: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword)
+        return 100;
+      const desc = ctx.seo.metaDescription ?? "";
+      return desc.toLowerCase().includes(keyword.toLowerCase()) ? 100 : 0;
+    },
+    recommendation: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword)
+        return null;
+      const desc = ctx.seo.metaDescription ?? "";
+      if (!desc.toLowerCase().includes(keyword.toLowerCase())) {
+        return `Include your focus keyword "${keyword}" in the meta description`;
+      }
+      return null;
+    }
+  };
+}
+function createKeywordDensityRule(config) {
+  const minDensity = config?.keywordDensity?.min ?? 1;
+  const maxDensity = config?.keywordDensity?.max ?? 3;
+  return {
+    id: "keyword-density",
+    name: "Keyword Density",
+    weight: 10,
+    score: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword)
+        return 100;
+      if (!ctx.textContent)
+        return 0;
+      const words = ctx.textContent.split(/\s+/).length;
+      if (words === 0)
+        return 0;
+      const keywordLower = keyword.toLowerCase();
+      const textLower = ctx.textContent.toLowerCase();
+      let count = 0;
+      let pos = 0;
+      while ((pos = textLower.indexOf(keywordLower, pos)) !== -1) {
+        count++;
+        pos += keywordLower.length;
+      }
+      const density = count / words * 100;
+      if (density >= minDensity && density <= maxDensity)
+        return 100;
+      if (density === 0)
+        return 0;
+      if (density < minDensity)
+        return clamp(Math.round(density / minDensity * 100), 0, 100);
+      return clamp(Math.round((maxDensity * 2 - density) / maxDensity * 100), 0, 100);
+    },
+    recommendation: (ctx) => {
+      const keyword = ctx.seo.focusKeyword;
+      if (!keyword || !ctx.textContent)
+        return keyword ? "Add content with your focus keyword" : null;
+      return null;
+    }
+  };
+}
+function createHeadingStructureRule() {
+  return {
+    id: "heading-structure",
+    name: "Heading Structure",
+    weight: 10,
+    score: (ctx) => {
+      if (ctx.headings.length === 0)
+        return 0;
+      const hasH1 = ctx.headings.some((h) => h.level === 1);
+      return hasH1 ? 100 : 50;
+    },
+    recommendation: (ctx) => {
+      if (ctx.headings.length === 0)
+        return "Add headings to structure your content";
+      if (!ctx.headings.some((h) => h.level === 1))
+        return "Add an H1 heading to your content";
+      return null;
+    }
+  };
+}
+function createOgDataRule() {
+  return {
+    id: "og-data-complete",
+    name: "Open Graph Data",
+    weight: 10,
+    score: (ctx) => {
+      let score = 0;
+      const ogTitle = ctx.seo.ogTitle ?? ctx.seo.metaTitle;
+      const ogDesc = ctx.seo.ogDescription ?? ctx.seo.metaDescription;
+      const ogImage = ctx.seo.ogImage;
+      if (ogTitle)
+        score += 33;
+      if (ogDesc)
+        score += 33;
+      if (ogImage)
+        score += 34;
+      return score;
+    },
+    recommendation: (ctx) => {
+      const missing = [];
+      if (!ctx.seo.ogTitle && !ctx.seo.metaTitle)
+        missing.push("OG Title");
+      if (!ctx.seo.ogDescription && !ctx.seo.metaDescription)
+        missing.push("OG Description");
+      if (!ctx.seo.ogImage)
+        missing.push("OG Image");
+      return missing.length > 0 ? `Missing Open Graph data: ${missing.join(", ")}` : null;
+    }
+  };
+}
+function createCanonicalUrlRule() {
+  return {
+    id: "canonical-url",
+    name: "Canonical URL",
+    weight: 5,
+    score: (ctx) => ctx.seo.canonicalUrl ? 100 : 0,
+    recommendation: (ctx) => ctx.seo.canonicalUrl ? null : "Set a canonical URL to prevent duplicate content issues"
+  };
+}
+function createContentLengthRule() {
+  return {
+    id: "content-length",
+    name: "Content Length",
+    weight: 5,
+    score: (ctx) => {
+      const words = ctx.textContent.split(/\s+/).filter(Boolean).length;
+      if (words >= 300)
+        return 100;
+      if (words >= 150)
+        return 50;
+      return 0;
+    },
+    recommendation: (ctx) => {
+      const words = ctx.textContent.split(/\s+/).filter(Boolean).length;
+      if (words < 300)
+        return `Content is short (${words} words). Aim for at least 300 words.`;
+      return null;
+    }
+  };
+}
+function createNoIndexWarningRule() {
+  return {
+    id: "no-index-warning",
+    name: "No Index Check",
+    weight: 5,
+    score: (ctx) => ctx.seo.noIndex ? 0 : 100,
+    recommendation: (ctx) => ctx.seo.noIndex ? "This page is set to noindex \u2014 search engines will not index it" : null
+  };
+}
+function buildDefaultRules(config) {
+  return [
+    createTitleLengthRule(config),
+    createDescriptionLengthRule(config),
+    createKeywordInTitleRule(),
+    createKeywordInDescriptionRule(),
+    createKeywordDensityRule(config),
+    createHeadingStructureRule(),
+    createOgDataRule(),
+    createCanonicalUrlRule(),
+    createContentLengthRule(),
+    createNoIndexWarningRule()
+  ];
+}
+function analyzeSeo(context, rules) {
+  const totalWeight = rules.reduce((sum, r) => sum + r.weight, 0);
+  const ruleResults = rules.map((rule) => {
+    const score = clamp(rule.score(context), 0, 100);
+    return {
+      id: rule.id,
+      name: rule.name,
+      score,
+      weight: rule.weight,
+      recommendation: score < 100 ? rule.recommendation(context) : null
+    };
+  });
+  const weightedSum = ruleResults.reduce((sum, r) => sum + r.score * r.weight, 0);
+  const overallScore = totalWeight > 0 ? Math.round(weightedSum / totalWeight) : 0;
+  return {
+    score: overallScore,
+    grade: computeGrade(overallScore),
+    rules: ruleResults
+  };
+}
+
+// libs/plugins/seo/src/lib/analysis/seo-analysis-hooks.ts
+function shouldExclude(collection, config) {
+  return (config.excludeCollections ?? []).includes(collection.slug);
+}
+var HOOK_MARKER = Symbol("seo-analysis-hook");
+function isMarkedHook(h) {
+  return HOOK_MARKER in h;
+}
+function hasAnalysisHook(collection) {
+  return Array.isArray(collection.hooks?.afterChange) && collection.hooks.afterChange.some((h) => isMarkedHook(h) && h[HOOK_MARKER] === true);
+}
+async function analyzeSeoAsync(api, collectionSlug, doc, config) {
+  const seoData = extractSeoFieldData(doc);
+  const docId = String(doc["id"] ?? "");
+  if (!docId)
+    return;
+  const rules = buildDefaultRules(config);
+  if (config.rules) {
+    rules.push(...config.rules);
+  }
+  const textContent = extractTextContent(doc);
+  const headings = extractHeadings(doc);
+  const result = analyzeSeo(
+    {
+      seo: seoData,
+      doc,
+      collection: collectionSlug,
+      textContent,
+      headings
+    },
+    rules
+  );
+  const analysisApi = api.collection("seo-analysis");
+  if (!analysisApi.find || !analysisApi.create)
+    return;
+  const existing = await analysisApi.find({
+    where: {
+      documentId: { equals: docId },
+      collection: { equals: collectionSlug }
+    },
+    limit: 1
+  });
+  const data = {
+    collection: collectionSlug,
+    documentId: docId,
+    score: result.score,
+    grade: result.grade,
+    rules: result.rules,
+    focusKeyword: seoData.focusKeyword ?? null,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (existing.docs.length > 0 && analysisApi.update) {
+    await analysisApi.update(String(existing.docs[0]["id"]), data);
+  } else {
+    await analysisApi.create(data);
+  }
+}
+function injectSeoAnalysisHooks(collections, config, getApi) {
+  for (const collection of collections) {
+    if (!hasSeoField(collection))
+      continue;
+    if (shouldExclude(collection, config))
+      continue;
+    if (hasAnalysisHook(collection))
+      continue;
+    collection.hooks = collection.hooks ?? {};
+    const existingAfterChange = collection.hooks.afterChange ?? [];
+    const afterChangeHook = (args) => {
+      const api = getApi();
+      if (!api)
+        return;
+      const doc = args.doc ?? args.data;
+      if (!doc)
+        return;
+      void analyzeSeoAsync(api, collection.slug, doc, config).catch(() => {
+      });
+    };
+    Object.defineProperty(afterChangeHook, HOOK_MARKER, { value: true });
+    collection.hooks.afterChange = [...existingAfterChange, afterChangeHook];
+  }
+}
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-handler.ts
+var import_express = require("express");
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-generator.ts
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function generateSitemap(entries) {
+  const urls = entries.map((entry) => {
+    const parts = [`    <loc>${escapeXml(entry.loc)}</loc>`];
+    if (entry.lastmod)
+      parts.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);
+    if (entry.changefreq)
+      parts.push(`    <changefreq>${escapeXml(entry.changefreq)}</changefreq>`);
+    if (entry.priority != null)
+      parts.push(`    <priority>${entry.priority.toFixed(1)}</priority>`);
+    return `  <url>
+${parts.join("\n")}
+  </url>`;
+  }).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    urls,
+    "</urlset>"
+  ].join("\n");
+}
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-cache.ts
+var SitemapCache = class {
+  constructor(defaultTtl = 3e5) {
+    this.store = /* @__PURE__ */ new Map();
+    this.defaultTtl = defaultTtl;
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry)
+      return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return entry.value;
+  }
+  set(key, value, ttl) {
+    this.store.set(key, {
+      value,
+      expiresAt: Date.now() + (ttl ?? this.defaultTtl)
+    });
+  }
+  invalidate(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+  }
+};
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-handler.ts
+function resolveChangeFreq(config, slug2) {
+  return config.changeFreqs?.[slug2] ?? config.defaultChangeFreq ?? "weekly";
+}
+async function fetchSitemapSettings(api) {
+  const map = /* @__PURE__ */ new Map();
+  try {
+    const settingsApi = api.collection("seo-sitemap-settings");
+    if (!settingsApi.find)
+      return map;
+    const result = await settingsApi.find({ limit: 0 });
+    for (const doc of result.docs) {
+      if (typeof doc["collection"] === "string") {
+        map.set(doc["collection"], {
+          includeInSitemap: doc["includeInSitemap"] !== false,
+          priority: doc["priority"] != null ? Number(doc["priority"]) : null,
+          changeFreq: typeof doc["changeFreq"] === "string" ? doc["changeFreq"] : null
+        });
+      }
+    }
+  } catch {
+  }
+  return map;
+}
+function createSitemapRouter(options) {
+  const { getApi, siteUrl, config, seoCollections } = options;
+  const cache = new SitemapCache(config.cacheTtl ?? 3e5);
+  const router = (0, import_express.Router)();
+  router.get("/sitemap.xml", async (req, res) => {
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    const host = req.get("host");
+    const effectiveSiteUrl = host ? `${req.protocol}://${host}` : siteUrl || "http://localhost";
+    const cached = cache.get("sitemap");
+    if (cached) {
+      res.set("Content-Type", "application/xml");
+      res.send(cached);
+      return;
+    }
+    try {
+      const entries = [];
+      const collections = config.includeCollections ?? seoCollections;
+      const settingsMap = await fetchSitemapSettings(api);
+      for (const slug2 of collections) {
+        if (config.excludeCollections?.includes(slug2))
+          continue;
+        const collSettings = settingsMap.get(slug2);
+        if (collSettings?.includeInSitemap === false)
+          continue;
+        try {
+          const collectionApi = api.collection(slug2);
+          if (!collectionApi.find)
+            continue;
+          const result = await collectionApi.find({ limit: 0 });
+          for (const doc of result.docs) {
+            const seoData = extractSeoFieldData(doc);
+            if (seoData.noIndex)
+              continue;
+            if (seoData.excludeFromSitemap)
+              continue;
+            const identifier = typeof doc["slug"] === "string" ? doc["slug"] : String(doc["id"]);
+            const loc = config.urlBuilder ? config.urlBuilder(slug2, doc) : `${effectiveSiteUrl}/${slug2}/${identifier}`;
+            if (!loc)
+              continue;
+            const priority = (collSettings?.priority != null ? collSettings.priority : null) ?? config.priorities?.[slug2] ?? config.defaultPriority ?? 0.5;
+            const changefreq = (
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- DB string narrowed to changefreq union
+              collSettings?.changeFreq ?? resolveChangeFreq(config, slug2)
+            );
+            entries.push({
+              loc,
+              lastmod: typeof doc["updatedAt"] === "string" ? doc["updatedAt"] : void 0,
+              changefreq,
+              priority
+            });
+          }
+        } catch {
+        }
+      }
+      const xml = generateSitemap(entries);
+      cache.set("sitemap", xml);
+      res.set("Content-Type", "application/xml");
+      res.send(xml);
+    } catch {
+      res.status(500).json({ error: "Failed to generate sitemap" });
+    }
+  });
+  return { router, clearCache: () => cache.clear() };
+}
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-settings-collection.ts
+function internalOrAdmin2({ req }) {
+  if (!req.user)
+    return true;
+  return req.user.role === "admin";
+}
+var SeoSitemapSettings = defineCollection({
+  slug: "seo-sitemap-settings",
+  managed: true,
+  labels: { singular: "Sitemap Setting", plural: "Sitemap Settings" },
+  admin: {
+    group: "SEO",
+    hidden: true,
+    useAsTitle: "collection"
+  },
+  fields: [
+    text("collection", { required: true, label: "Collection Slug" }),
+    checkbox("includeInSitemap", {
+      label: "Include in Sitemap",
+      defaultValue: true
+    }),
+    number("priority", {
+      label: "Priority",
+      min: 0,
+      max: 1,
+      description: "Sitemap priority (0.0 to 1.0)"
+    }),
+    select("changeFreq", {
+      label: "Change Frequency",
+      options: [
+        { label: "Always", value: "always" },
+        { label: "Hourly", value: "hourly" },
+        { label: "Daily", value: "daily" },
+        { label: "Weekly", value: "weekly" },
+        { label: "Monthly", value: "monthly" },
+        { label: "Yearly", value: "yearly" },
+        { label: "Never", value: "never" }
+      ],
+      defaultValue: "weekly"
+    })
+  ],
+  access: {
+    read: internalOrAdmin2,
+    create: internalOrAdmin2,
+    update: internalOrAdmin2,
+    delete: hasRole("admin")
+  }
+});
+
+// libs/plugins/seo/src/lib/sitemap/sitemap-settings-handler.ts
+var import_express2 = require("express");
+var VALID_CHANGE_FREQS = /* @__PURE__ */ new Set([
+  "always",
+  "hourly",
+  "daily",
+  "weekly",
+  "monthly",
+  "yearly",
+  "never"
+]);
+function isAdminUser(req) {
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "role" in user && user["role"] === "admin";
+}
+function createSitemapSettingsRouter(options) {
+  const { getApi, seoCollections, onSettingsChanged } = options;
+  const router = (0, import_express2.Router)();
+  router.get("/sitemap-settings", async (req, res) => {
+    if (!isAdminUser(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    try {
+      const settingsApi = api.collection("seo-sitemap-settings");
+      if (!settingsApi.find) {
+        res.status(503).json({ error: "Collection not available" });
+        return;
+      }
+      const result = await settingsApi.find({ limit: 0 });
+      const settingsMap = /* @__PURE__ */ new Map();
+      for (const doc of result.docs) {
+        if (typeof doc["collection"] === "string") {
+          settingsMap.set(doc["collection"], doc);
+        }
+      }
+      const settings = seoCollections.map((slug2) => {
+        const saved = settingsMap.get(slug2);
+        return {
+          collection: slug2,
+          includeInSitemap: saved ? saved["includeInSitemap"] !== false : true,
+          priority: saved && saved["priority"] != null ? Number(saved["priority"]) : null,
+          changeFreq: saved ? saved["changeFreq"] ?? null : null,
+          id: saved ? saved["id"] : null
+        };
+      });
+      res.json({ settings });
+    } catch {
+      res.status(500).json({ error: "Failed to fetch sitemap settings" });
+    }
+  });
+  router.put("/sitemap-settings/:collection", async (req, res) => {
+    if (!isAdminUser(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const collectionSlug = req.params["collection"];
+    if (!collectionSlug || !seoCollections.includes(collectionSlug)) {
+      res.status(400).json({ error: "Invalid collection slug" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    try {
+      const settingsApi = api.collection("seo-sitemap-settings");
+      if (!settingsApi.find || !settingsApi.create || !settingsApi.update) {
+        res.status(503).json({ error: "Collection not available" });
+        return;
+      }
+      const body = req.body;
+      const data = {
+        collection: collectionSlug
+      };
+      if ("includeInSitemap" in body) {
+        data["includeInSitemap"] = body["includeInSitemap"] === true;
+      }
+      if ("priority" in body && body["priority"] != null) {
+        data["priority"] = Math.max(0, Math.min(1, Number(body["priority"])));
+      }
+      if ("changeFreq" in body) {
+        const freq = String(body["changeFreq"]);
+        if (!VALID_CHANGE_FREQS.has(freq)) {
+          res.status(400).json({ error: "Invalid changeFreq value" });
+          return;
+        }
+        data["changeFreq"] = freq;
+      }
+      const existing = await settingsApi.find({
+        where: { collection: { equals: collectionSlug } },
+        limit: 1
+      });
+      let result;
+      if (existing.docs.length > 0 && typeof existing.docs[0]["id"] === "string") {
+        result = await settingsApi.update(existing.docs[0]["id"], data);
+      } else {
+        result = await settingsApi.create(data);
+      }
+      if (onSettingsChanged) {
+        onSettingsChanged();
+      }
+      res.json(result);
+    } catch {
+      res.status(500).json({ error: "Failed to update sitemap settings" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/seo/src/lib/robots/robots-handler.ts
+var import_express3 = require("express");
+
+// libs/plugins/seo/src/lib/robots/robots-txt-generator.ts
+function sanitizeLine(str) {
+  return str.replace(/[\r\n]/g, "");
+}
+function generateRobotsTxt(siteUrl, config) {
+  const lines = [];
+  if (config.rules && config.rules.length > 0) {
+    for (const rule of config.rules) {
+      lines.push(`User-agent: ${sanitizeLine(rule.userAgent)}`);
+      if (rule.allow) {
+        for (const path of rule.allow) {
+          lines.push(`Allow: ${sanitizeLine(path)}`);
+        }
+      }
+      if (rule.disallow) {
+        for (const path of rule.disallow) {
+          lines.push(`Disallow: ${sanitizeLine(path)}`);
+        }
+      }
+      if (config.crawlDelay != null) {
+        lines.push(`Crawl-delay: ${config.crawlDelay}`);
+      }
+      lines.push("");
+    }
+  } else {
+    lines.push("User-agent: *");
+    lines.push("Allow: /");
+    if (config.crawlDelay != null) {
+      lines.push(`Crawl-delay: ${config.crawlDelay}`);
+    }
+    lines.push("");
+  }
+  if (siteUrl) {
+    lines.push(`Sitemap: ${siteUrl}/sitemap.xml`);
+  }
+  if (config.additionalSitemaps) {
+    for (const sitemap of config.additionalSitemaps) {
+      lines.push(`Sitemap: ${sanitizeLine(sitemap)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// libs/plugins/seo/src/lib/robots/robots-handler.ts
+var CACHE_KEY = "robots-txt";
+async function readSettingsFromDb(api) {
+  try {
+    const settingsApi = api.collection("seo-settings");
+    if (!settingsApi.find)
+      return null;
+    const result = await settingsApi.find({ limit: 1 });
+    if (result.docs.length === 0)
+      return null;
+    const doc = result.docs[0];
+    return {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- dynamic DB document shape
+      rules: doc["robotsRules"] ?? void 0,
+      crawlDelay: doc["robotsCrawlDelay"] != null ? Number(doc["robotsCrawlDelay"]) : void 0,
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- dynamic DB document shape
+      additionalSitemaps: doc["robotsAdditionalSitemaps"] ?? void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function createRobotsRouter(options) {
+  const { siteUrl, config, getApi } = options;
+  const cache = new SitemapCache(3e5);
+  const router = (0, import_express3.Router)();
+  router.get("/robots.txt", async (req, res) => {
+    const cached = cache.get(CACHE_KEY);
+    if (cached) {
+      res.set("Content-Type", "text/plain");
+      res.send(cached);
+      return;
+    }
+    const host = req.get("host");
+    const effectiveSiteUrl = host ? `${req.protocol}://${host}` : siteUrl || "http://localhost";
+    let effectiveConfig = config;
+    if (getApi) {
+      const api = getApi();
+      if (api) {
+        const dbConfig = await readSettingsFromDb(api);
+        if (dbConfig) {
+          effectiveConfig = dbConfig;
+        }
+      }
+    }
+    const content = generateRobotsTxt(effectiveSiteUrl, effectiveConfig);
+    cache.set(CACHE_KEY, content);
+    res.set("Content-Type", "text/plain");
+    res.send(content);
+  });
+  return {
+    router,
+    clearCache: () => {
+      cache.clear();
+    }
+  };
+}
+
+// libs/plugins/seo/src/lib/meta/meta-handler.ts
+var import_express4 = require("express");
+
+// libs/plugins/seo/src/lib/meta/meta-builder.ts
+function extractOgImageUrl(ogImage) {
+  if (typeof ogImage === "string")
+    return ogImage;
+  if (typeof ogImage === "object" && ogImage !== null && "url" in ogImage) {
+    const url = ogImage["url"];
+    return typeof url === "string" ? url : void 0;
+  }
+  return void 0;
+}
+function buildMetaTags(doc, seo, _siteUrl) {
+  const title = seo.metaTitle ?? (typeof doc["title"] === "string" ? doc["title"] : "");
+  const meta = [];
+  const link = [];
+  const script = [];
+  if (seo.metaDescription) {
+    meta.push({ name: "description", content: seo.metaDescription });
+  }
+  const robotsParts = [];
+  if (seo.noIndex)
+    robotsParts.push("noindex");
+  if (seo.noFollow)
+    robotsParts.push("nofollow");
+  if (robotsParts.length > 0) {
+    meta.push({ name: "robots", content: robotsParts.join(", ") });
+  }
+  const ogTitle = seo.ogTitle ?? seo.metaTitle ?? (typeof doc["title"] === "string" ? doc["title"] : "");
+  if (ogTitle) {
+    meta.push({ property: "og:title", content: ogTitle });
+  }
+  const ogDescription = seo.ogDescription ?? seo.metaDescription;
+  if (ogDescription) {
+    meta.push({ property: "og:description", content: ogDescription });
+  }
+  if (seo.ogImage) {
+    const imageUrl = extractOgImageUrl(seo.ogImage);
+    if (imageUrl) {
+      meta.push({ property: "og:image", content: imageUrl });
+    }
+  }
+  if (seo.ogType) {
+    meta.push({ property: "og:type", content: seo.ogType });
+  }
+  if (seo.twitterCard) {
+    meta.push({ name: "twitter:card", content: seo.twitterCard });
+  }
+  if (seo.canonicalUrl) {
+    link.push({ rel: "canonical", href: seo.canonicalUrl });
+  }
+  if (seo.structuredData) {
+    script.push({
+      type: "application/ld+json",
+      innerHTML: JSON.stringify(seo.structuredData).replace(/</g, "\\u003c")
+    });
+  }
+  return { title, meta, link, script };
+}
+
+// libs/plugins/seo/src/lib/meta/meta-handler.ts
+function isAdminUser2(req) {
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "role" in user && user["role"] === "admin";
+}
+function createMetaRouter(options) {
+  const { getApi, siteUrl, seoCollections } = options;
+  const allowedCollections = new Set(seoCollections);
+  const router = (0, import_express4.Router)();
+  router.get("/meta/:collection/:id", async (req, res) => {
+    if (!isAdminUser2(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    const { collection, id } = req.params;
+    if (!allowedCollections.has(collection)) {
+      res.status(404).json({ error: "Collection not SEO-enabled" });
+      return;
+    }
+    try {
+      const collectionApi = api.collection(collection);
+      if (!collectionApi.findById) {
+        res.status(404).json({ error: "Collection not found" });
+        return;
+      }
+      const doc = await collectionApi.findById(id, { depth: 1 });
+      if (!doc) {
+        res.status(404).json({ error: "Document not found" });
+        return;
+      }
+      const seoData = extractSeoFieldData(doc);
+      const metaTags = buildMetaTags(doc, seoData, siteUrl);
+      res.json(metaTags);
+    } catch {
+      res.status(500).json({ error: "Failed to build meta tags" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/seo/src/lib/dashboard/seo-analysis-handler.ts
+var import_express5 = require("express");
+function isAdminUser3(req) {
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "role" in user && user["role"] === "admin";
+}
+function createDashboardRouter(options) {
+  const { getApi } = options;
+  const router = (0, import_express5.Router)();
+  router.get("/analyses", async (req, res) => {
+    if (!isAdminUser3(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    try {
+      const analysisApi = api.collection("seo-analysis");
+      if (!analysisApi.find) {
+        res.status(503).json({ error: "Collection not available" });
+        return;
+      }
+      const limit = Math.min(Number(req.query["limit"]) || 500, 1e3);
+      const sort = String(req.query["sort"] || "-analyzedAt");
+      const result = await analysisApi.find({ limit, sort });
+      res.json(result);
+    } catch {
+      res.status(500).json({ error: "Failed to fetch analyses" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/seo/src/lib/settings/seo-settings-collection.ts
+function internalOrAdmin3({ req }) {
+  if (!req.user)
+    return true;
+  return req.user.role === "admin";
+}
+var SeoSettings = defineCollection({
+  slug: "seo-settings",
+  managed: true,
+  labels: { singular: "SEO Setting", plural: "SEO Settings" },
+  admin: {
+    group: "SEO",
+    hidden: true
+  },
+  fields: [
+    json("robotsRules", {
+      label: "Robots Rules",
+      description: "Array of { userAgent, allow, disallow } rules"
+    }),
+    number("robotsCrawlDelay", {
+      label: "Crawl Delay",
+      min: 0,
+      description: "Crawl delay in seconds (optional)"
+    }),
+    json("robotsAdditionalSitemaps", {
+      label: "Additional Sitemaps",
+      description: "Array of additional sitemap URLs to include"
+    })
+  ],
+  access: {
+    read: internalOrAdmin3,
+    create: internalOrAdmin3,
+    update: internalOrAdmin3,
+    delete: hasRole("admin")
+  }
+});
+
+// libs/plugins/seo/src/lib/settings/seo-settings-handler.ts
+var import_express6 = require("express");
+var DEFAULT_RULES = [{ userAgent: "*", allow: ["/"], disallow: [] }];
+function isAdminUser4(req) {
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "role" in user && user["role"] === "admin";
+}
+function createSeoSettingsRouter(options) {
+  const { getApi, defaultRobotsConfig, onSettingsChanged } = options;
+  const router = (0, import_express6.Router)();
+  router.get("/seo-settings", async (req, res) => {
+    if (!isAdminUser4(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    try {
+      const settingsApi = api.collection("seo-settings");
+      if (!settingsApi.find) {
+        res.status(503).json({ error: "Collection not available" });
+        return;
+      }
+      const result = await settingsApi.find({ limit: 1 });
+      if (result.docs.length > 0) {
+        res.json(result.docs[0]);
+        return;
+      }
+      const defaultRules = defaultRobotsConfig?.rules ?? DEFAULT_RULES;
+      res.json({
+        robotsRules: defaultRules,
+        robotsCrawlDelay: defaultRobotsConfig?.crawlDelay ?? null,
+        robotsAdditionalSitemaps: defaultRobotsConfig?.additionalSitemaps ?? []
+      });
+    } catch {
+      res.status(500).json({ error: "Failed to fetch SEO settings" });
+    }
+  });
+  router.put("/seo-settings", async (req, res) => {
+    if (!isAdminUser4(req)) {
+      res.status(401).json({ error: "Admin access required" });
+      return;
+    }
+    const api = getApi();
+    if (!api) {
+      res.status(503).json({ error: "API not ready" });
+      return;
+    }
+    try {
+      const settingsApi = api.collection("seo-settings");
+      if (!settingsApi.find || !settingsApi.create || !settingsApi.update) {
+        res.status(503).json({ error: "Collection not available" });
+        return;
+      }
+      const body = req.body;
+      const data = {};
+      if ("robotsRules" in body) {
+        if (!Array.isArray(body["robotsRules"])) {
+          res.status(400).json({ error: "robotsRules must be an array" });
+          return;
+        }
+        data["robotsRules"] = body["robotsRules"].map(
+          (rule) => ({
+            userAgent: String(rule["userAgent"] ?? "*").replace(/[\r\n]/g, ""),
+            allow: Array.isArray(rule["allow"]) ? (
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validated as array above
+              rule["allow"].map((p) => String(p).replace(/[\r\n]/g, ""))
+            ) : [],
+            disallow: Array.isArray(rule["disallow"]) ? (
+              // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validated as array above
+              rule["disallow"].map((p) => String(p).replace(/[\r\n]/g, ""))
+            ) : []
+          })
+        );
+      }
+      if ("robotsCrawlDelay" in body) {
+        const delay = body["robotsCrawlDelay"];
+        data["robotsCrawlDelay"] = delay != null ? Math.max(0, Number(delay)) : null;
+      }
+      if ("robotsAdditionalSitemaps" in body) {
+        if (!Array.isArray(body["robotsAdditionalSitemaps"])) {
+          res.status(400).json({ error: "robotsAdditionalSitemaps must be an array" });
+          return;
+        }
+        data["robotsAdditionalSitemaps"] = body["robotsAdditionalSitemaps"].map(
+          (s) => String(s).replace(/[\r\n]/g, "")
+        );
+      }
+      const existing = await settingsApi.find({ limit: 1 });
+      let result;
+      if (existing.docs.length > 0 && typeof existing.docs[0]["id"] === "string") {
+        result = await settingsApi.update(existing.docs[0]["id"], data);
+      } else {
+        result = await settingsApi.create(data);
+      }
+      if (onSettingsChanged) {
+        onSettingsChanged();
+      }
+      res.json(result);
+    } catch {
+      res.status(500).json({ error: "Failed to update SEO settings" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/seo/src/lib/seo-plugin.ts
+function resolveAdminRoutes(dashboardConfig) {
+  if (dashboardConfig === false)
+    return [];
+  const dashboardModule = "./dashboard/seo-dashboard.page";
+  const defaultLoadComponent = () => import(dashboardModule).then((m) => m["SeoDashboardPage"]);
+  const defaultRoute = {
+    path: "seo",
+    label: "SEO",
+    icon: "heroMagnifyingGlass",
+    loadComponent: defaultLoadComponent,
+    group: "SEO"
+  };
+  const sitemapModule = "./sitemap/sitemap-settings.page";
+  const sitemapRoute = {
+    path: "seo/sitemap",
+    label: "Sitemap",
+    icon: "heroMap",
+    loadComponent: () => import(sitemapModule).then((m) => m["SitemapSettingsPage"]),
+    group: "SEO"
+  };
+  const robotsModule = "./robots/robots-settings.page";
+  const robotsRoute = {
+    path: "seo/robots",
+    label: "Robots",
+    icon: "heroDocumentText",
+    loadComponent: () => import(robotsModule).then((m) => m["RobotsSettingsPage"]),
+    group: "SEO"
+  };
+  if (dashboardConfig === void 0 || dashboardConfig === true) {
+    return [defaultRoute, sitemapRoute, robotsRoute];
+  }
+  return [
+    {
+      ...defaultRoute,
+      loadComponent: dashboardConfig.loadComponent ?? defaultLoadComponent,
+      group: dashboardConfig.group ?? defaultRoute.group
+    },
+    sitemapRoute,
+    robotsRoute
+  ];
+}
+function resolveAnalysisConfig(analysis) {
+  if (analysis === false)
+    return null;
+  if (analysis === void 0 || analysis === true)
+    return {};
+  return analysis;
+}
+function seoPlugin(config) {
+  const adminRoutes = resolveAdminRoutes(config.adminDashboard);
+  const analysisConfig = resolveAnalysisConfig(config.analysis);
+  const siteUrl = config.siteUrl ?? "";
+  let momentumApi = null;
+  const seoCollectionSlugs = /* @__PURE__ */ new Set();
+  return {
+    name: "seo",
+    adminRoutes,
+    browserImports: {
+      adminRoutes: {
+        path: "@momentumcms/plugins-seo/admin-routes",
+        exportName: "seoAdminRoutes"
+      },
+      modifyCollections: {
+        path: "@momentumcms/plugins-seo/fields",
+        exportName: "injectSeoFields"
+      }
+    },
+    modifyCollections(collections) {
+      if (config.enabled === false)
+        return;
+      injectSeoFields(collections, {
+        collections: config.collections,
+        excludeCollections: config.excludeCollections
+      });
+    },
+    async onInit({ collections, logger, registerMiddleware }) {
+      if (config.enabled === false) {
+        logger.info("SEO plugin disabled");
+        return;
+      }
+      injectSeoFields(collections, {
+        collections: config.collections,
+        excludeCollections: config.excludeCollections
+      });
+      logger.info("SEO fields injected");
+      for (const c of collections) {
+        if (hasSeoField(c)) {
+          seoCollectionSlugs.add(c.slug);
+        }
+      }
+      if (analysisConfig && !collections.some((c) => c.slug === "seo-analysis")) {
+        collections.push(SeoAnalysis);
+        injectSeoAnalysisHooks(collections, analysisConfig, () => momentumApi);
+        logger.info("SEO analysis hooks injected");
+      }
+      if (config.sitemap !== false) {
+        if (!collections.some((c) => c.slug === "seo-sitemap-settings")) {
+          collections.push(SeoSitemapSettings);
+        }
+        const sitemapConfig = typeof config.sitemap === "object" ? config.sitemap : {};
+        const { router: sitemapRouter, clearCache } = createSitemapRouter({
+          getApi: () => momentumApi,
+          siteUrl,
+          config: sitemapConfig,
+          seoCollections: [...seoCollectionSlugs]
+        });
+        registerMiddleware({
+          path: "/",
+          handler: sitemapRouter,
+          position: "root"
+        });
+        logger.info("Sitemap endpoint registered at /sitemap.xml");
+        const settingsRouter = createSitemapSettingsRouter({
+          getApi: () => momentumApi,
+          seoCollections: [...seoCollectionSlugs],
+          onSettingsChanged: clearCache
+        });
+        registerMiddleware({
+          path: "/seo",
+          handler: settingsRouter,
+          position: "before-api"
+        });
+        logger.info("Sitemap settings endpoint registered");
+      }
+      if (config.robots !== false) {
+        const robotsConfig = typeof config.robots === "object" ? config.robots : {};
+        if (!collections.some((c) => c.slug === "seo-settings")) {
+          collections.push(SeoSettings);
+        }
+        const { router: robotsRouter, clearCache: clearRobotsCache } = createRobotsRouter({
+          siteUrl,
+          config: robotsConfig,
+          getApi: () => momentumApi
+        });
+        registerMiddleware({
+          path: "/",
+          handler: robotsRouter,
+          position: "root"
+        });
+        logger.info("Robots.txt endpoint registered at /robots.txt");
+        const seoSettingsRouter = createSeoSettingsRouter({
+          getApi: () => momentumApi,
+          defaultRobotsConfig: robotsConfig,
+          onSettingsChanged: clearRobotsCache
+        });
+        registerMiddleware({
+          path: "/seo",
+          handler: seoSettingsRouter,
+          position: "before-api"
+        });
+        logger.info("SEO settings endpoint registered");
+      }
+      if (config.metaApi !== false) {
+        const metaRouter = createMetaRouter({
+          getApi: () => momentumApi,
+          siteUrl,
+          seoCollections: [...seoCollectionSlugs]
+        });
+        registerMiddleware({
+          path: "/seo",
+          handler: metaRouter,
+          position: "before-api"
+        });
+        logger.info("Meta tag API endpoint registered");
+      }
+      const dashboardRouter = createDashboardRouter({ getApi: () => momentumApi });
+      registerMiddleware({
+        path: "/seo",
+        handler: dashboardRouter,
+        position: "before-api"
+      });
+      logger.info("SEO dashboard API endpoint registered");
+      if (adminRoutes.length > 0) {
+        logger.info("SEO admin dashboard route declared");
+      }
+      logger.info("SEO plugin initialized");
+    },
+    async onReady({ logger, api }) {
+      if (config.enabled === false)
+        return;
+      momentumApi = api;
+      logger.info("SEO plugin ready");
+    },
+    async onShutdown({ logger }) {
+      logger.info("SEO plugin shut down");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  injectSeoFields,
+  seoPlugin
+});