strapi-sitemap-generator 0.1.1

package/dist/_chunks/en-BptFMppp.mjs

@@ -0,0 +1,7 @@
+const en = {
+  "plugin.name": "Sitemap Generator",
+  "plugin.description": "Generate XML sitemaps from your Strapi content"
+};
+export {
+  en as default
+};

package/dist/_chunks/en-CZAGT--R.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const en = {
+  "plugin.name": "Sitemap Generator",
+  "plugin.description": "Generate XML sitemaps from your Strapi content"
+};
+exports.default = en;

package/dist/admin/index.js

@@ -0,0 +1,67 @@
+"use strict";
+const React = require("react");
+const jsxRuntime = require("react/jsx-runtime");
+const icons = require("@strapi/icons");
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "strapi-sitemap-generator";
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const Initializer = ({ setPlugin }) => {
+  const ref = React.useRef(setPlugin);
+  React.useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const PluginIcon = () => /* @__PURE__ */ jsxRuntime.jsx(icons.PuzzlePiece, {});
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.plugin.name`,
+        defaultMessage: "Sitemap Generator"
+      },
+      Component: async () => {
+        const { App } = await Promise.resolve().then(() => require("../_chunks/App-D449cQR3.js"));
+        return App;
+      }
+    });
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => Promise.resolve().then(() => require("../_chunks/en-CZAGT--R.js")) }), `./translations/${locale}.json`, 3);
+          return { data: getTranslation(data), locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  },
+  bootstrap() {
+  }
+};
+module.exports = index;

package/dist/admin/index.mjs

@@ -0,0 +1,68 @@
+import { useRef, useEffect } from "react";
+import { jsx } from "react/jsx-runtime";
+import { PuzzlePiece } from "@strapi/icons";
+const __variableDynamicImportRuntimeHelper = (glob, path, segs) => {
+  const v = glob[path];
+  if (v) {
+    return typeof v === "function" ? v() : Promise.resolve(v);
+  }
+  return new Promise((_, reject) => {
+    (typeof queueMicrotask === "function" ? queueMicrotask : setTimeout)(
+      reject.bind(
+        null,
+        new Error(
+          "Unknown variable dynamic import: " + path + (path.split("/").length !== segs ? ". Note that variables only represent file names one level deep." : "")
+        )
+      )
+    );
+  });
+};
+const PLUGIN_ID = "strapi-sitemap-generator";
+const getTranslation = (id) => `${PLUGIN_ID}.${id}`;
+const Initializer = ({ setPlugin }) => {
+  const ref = useRef(setPlugin);
+  useEffect(() => {
+    ref.current(PLUGIN_ID);
+  }, []);
+  return null;
+};
+const PluginIcon = () => /* @__PURE__ */ jsx(PuzzlePiece, {});
+const index = {
+  register(app) {
+    app.addMenuLink({
+      to: `plugins/${PLUGIN_ID}`,
+      icon: PluginIcon,
+      intlLabel: {
+        id: `${PLUGIN_ID}.plugin.name`,
+        defaultMessage: "Sitemap Generator"
+      },
+      Component: async () => {
+        const { App } = await import("../_chunks/App-Bvbv7t_S.mjs");
+        return App;
+      }
+    });
+    app.registerPlugin({
+      id: PLUGIN_ID,
+      initializer: Initializer,
+      isReady: false,
+      name: PLUGIN_ID
+    });
+  },
+  async registerTrads({ locales }) {
+    return Promise.all(
+      locales.map(async (locale) => {
+        try {
+          const { default: data } = await __variableDynamicImportRuntimeHelper(/* @__PURE__ */ Object.assign({ "./translations/en.json": () => import("../_chunks/en-BptFMppp.mjs") }), `./translations/${locale}.json`, 3);
+          return { data: getTranslation(data), locale };
+        } catch {
+          return { data: {}, locale };
+        }
+      })
+    );
+  },
+  bootstrap() {
+  }
+};
+export {
+  index as default
+};

package/dist/admin/src/components/Initializer.d.ts

@@ -0,0 +1,5 @@
+type InitializerProps = {
+    setPlugin: (id: string) => void;
+};
+declare const Initializer: ({ setPlugin }: InitializerProps) => null;
+export { Initializer };

package/dist/admin/src/components/PluginIcon.d.ts

@@ -0,0 +1,2 @@
+declare const PluginIcon: () => import("react/jsx-runtime").JSX.Element;
+export { PluginIcon };

package/dist/admin/src/index.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    register(app: any): void;
+    registerTrads({ locales }: {
+        locales: string[];
+    }): Promise<({
+        data: string;
+        locale: string;
+    } | {
+        data: {};
+        locale: string;
+    })[]>;
+    bootstrap(): void;
+};
+export default _default;

package/dist/admin/src/pages/App.d.ts

@@ -0,0 +1,2 @@
+declare const App: () => import("react/jsx-runtime").JSX.Element;
+export { App };

package/dist/admin/src/pages/HomePage.d.ts

@@ -0,0 +1,2 @@
+declare const HomePage: () => import("react/jsx-runtime").JSX.Element;
+export { HomePage };

package/dist/admin/src/pluginId.d.ts

@@ -0,0 +1 @@
+export declare const PLUGIN_ID = "strapi-sitemap-generator";

package/dist/admin/src/utils/getTranslation.d.ts

@@ -0,0 +1,2 @@
+declare const getTranslation: (id: string) => string;
+export { getTranslation };

package/dist/server/index.js

@@ -0,0 +1,338 @@
+"use strict";
+const bootstrap = ({ strapi }) => {
+};
+const destroy = ({ strapi }) => {
+};
+const register = ({ strapi }) => {
+};
+const config = {
+  default: {},
+  validator() {
+  }
+};
+const contentTypes = {};
+const controller = ({ strapi }) => ({
+  /**
+   * Generate sitemap XML
+   * Public endpoint for serving sitemap.xml
+   */
+  async generateXml(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const xml = await service2.generateXML();
+      ctx.type = "application/xml";
+      ctx.body = xml;
+    } catch (error) {
+      ctx.throw(500, `Failed to generate sitemap: ${error.message}`);
+    }
+  },
+  /**
+   * Get sitemap data as JSON
+   * Admin endpoint for preview
+   */
+  async getSitemapData(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const data = await service2.getSitemapData();
+      ctx.body = data;
+    } catch (error) {
+      ctx.throw(500, `Failed to get sitemap data: ${error.message}`);
+    }
+  },
+  /**
+   * (Removed) Download sitemap.xml - not needed, engines fetch XML via public URL
+   */
+  /**
+   * Get all available content types
+   * Admin endpoint for content type discovery
+   */
+  async getContentTypes(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const contentTypes2 = await service2.discoverContentTypes();
+      ctx.body = { data: contentTypes2 };
+    } catch (error) {
+      ctx.throw(500, `Failed to discover content types: ${error.message}`);
+    }
+  },
+  /**
+   * Get current plugin configuration
+   * Admin endpoint for loading settings
+   */
+  async getConfig(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const config2 = await service2.getConfig();
+      ctx.body = config2;
+    } catch (error) {
+      ctx.throw(500, `Failed to get config: ${error.message}`);
+    }
+  },
+  /**
+   * Update plugin configuration
+   * Admin endpoint for saving settings
+   */
+  async updateConfig(ctx) {
+    try {
+      const service2 = strapi.plugin("strapi-sitemap-generator").service("service");
+      const config2 = await service2.updateConfig(ctx.request.body);
+      ctx.body = config2;
+    } catch (error) {
+      ctx.throw(500, `Failed to update config: ${error.message}`);
+    }
+  }
+});
+const controllers = {
+  controller
+};
+const middlewares = {};
+const policies = {};
+const contentAPIRoutes = {
+  type: "content-api",
+  routes: [
+    {
+      method: "GET",
+      path: "/sitemap.xml",
+      handler: "controller.generateXml",
+      config: {
+        auth: false,
+        policies: []
+      }
+    }
+  ]
+};
+const adminAPIRoutes = {
+  type: "admin",
+  routes: [
+    {
+      method: "GET",
+      path: "/data",
+      handler: "controller.getSitemapData",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/content-types",
+      handler: "controller.getContentTypes",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "GET",
+      path: "/config",
+      handler: "controller.getConfig",
+      config: {
+        policies: []
+      }
+    },
+    {
+      method: "PUT",
+      path: "/config",
+      handler: "controller.updateConfig",
+      config: {
+        policies: []
+      }
+    }
+  ]
+};
+const routes = {
+  "content-api": contentAPIRoutes,
+  admin: adminAPIRoutes
+};
+const service = ({ strapi }) => ({
+  /**
+   * Discover ALL content types with slug fields
+   */
+  async discoverContentTypes() {
+    const contentTypes2 = [];
+    const allContentTypes = strapi.contentTypes;
+    for (const [uid, contentType] of Object.entries(allContentTypes)) {
+      if (!uid.startsWith("api::")) continue;
+      const schema = contentType;
+      const attributes = schema.attributes || {};
+      const hasSlug = "slug" in attributes;
+      if (hasSlug) {
+        contentTypes2.push({
+          uid,
+          singularName: schema.info?.singularName || uid.split(".").pop(),
+          pluralName: schema.info?.pluralName || uid.split(".").pop(),
+          displayName: schema.info?.displayName || uid,
+          hasPublishedAt: "publishedAt" in attributes
+        });
+      }
+    }
+    return contentTypes2;
+  },
+  /**
+   * Get content type info
+   */
+  async getContentTypeInfo(uid) {
+    const contentType = strapi.contentTypes[uid];
+    const attributes = contentType.attributes || {};
+    return {
+      singularName: contentType.info?.singularName || uid.split(".").pop(),
+      pluralName: contentType.info?.pluralName || uid.split(".").pop(),
+      displayName: contentType.info?.displayName || uid,
+      hasPublishedAt: "publishedAt" in attributes
+    };
+  },
+  /**
+   * Generate sitemap XML from user-selected content types
+   */
+  async generateXML() {
+    const config2 = await this.getConfig();
+    const {
+      baseUrl = "https://example.com",
+      selectedContentTypes = [],
+      customPaths = {},
+      customPriorities = {},
+      customChangefreq = {}
+    } = config2;
+    strapi.log.info(`[Sitemap] Generating sitemap with ${selectedContentTypes.length} selected content types`);
+    strapi.log.info(`[Sitemap] Selected types:`, selectedContentTypes);
+    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
+    xml += '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">\n';
+    if (selectedContentTypes.length === 0) {
+      strapi.log.warn("[Sitemap] No content types selected for sitemap generation");
+      xml += "</urlset>";
+      return xml;
+    }
+    for (const uid of selectedContentTypes) {
+      try {
+        const contentType = await this.getContentTypeInfo(uid);
+        strapi.log.info(`[Sitemap] Processing content type: ${uid}`);
+        const entries = await strapi.entityService.findMany(uid);
+        strapi.log.info(`[Sitemap] Found ${entries?.length || 0} entries for ${uid}`);
+        if (entries && Array.isArray(entries) && entries.length > 0) {
+          const basePath = customPaths[uid] || `/${contentType.pluralName}`;
+          const priority = customPriorities[uid] || 0.7;
+          const changefreq = customChangefreq[uid] || "monthly";
+          entries.forEach((entry) => {
+            if (entry.slug) {
+              xml += this.generateUrlEntry({
+                loc: `${baseUrl}${basePath}/${entry.slug}`,
+                lastmod: entry.updatedAt ? new Date(entry.updatedAt).toISOString().split("T")[0] : (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+                priority,
+                changefreq
+              });
+            }
+          });
+        }
+      } catch (error) {
+        strapi.log.error(`[Sitemap] Failed to fetch entries for ${uid}:`, error.message);
+        strapi.log.error(`[Sitemap] Error details:`, error);
+      }
+    }
+    xml += "</urlset>";
+    strapi.log.info(`[Sitemap] Sitemap generation complete`);
+    return xml;
+  },
+  generateUrlEntry({ loc, lastmod, priority, changefreq }) {
+    let entry = "  <url>\n";
+    entry += `    <loc>${this.escapeXml(loc)}</loc>
+`;
+    if (lastmod) entry += `    <lastmod>${lastmod}</lastmod>
+`;
+    if (changefreq) entry += `    <changefreq>${changefreq}</changefreq>
+`;
+    if (priority) entry += `    <priority>${priority}</priority>
+`;
+    entry += "  </url>\n";
+    return entry;
+  },
+  escapeXml(unsafe) {
+    return unsafe.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  },
+  /**
+   * Get structured sitemap data for frontend display
+   */
+  async getSitemapData() {
+    const config2 = await this.getConfig();
+    const {
+      baseUrl = "https://example.com",
+      selectedContentTypes = [],
+      customPaths = {}
+    } = config2;
+    strapi.log.info(`[Sitemap] Getting sitemap data for ${selectedContentTypes.length} content types`);
+    const data = {
+      entries: {},
+      meta: {
+        totalUrls: 0,
+        lastGenerated: (/* @__PURE__ */ new Date()).toISOString(),
+        contentTypes: []
+      }
+    };
+    if (selectedContentTypes.length === 0) {
+      strapi.log.warn("[Sitemap] No content types selected - returning empty sitemap data");
+      return data;
+    }
+    for (const uid of selectedContentTypes) {
+      try {
+        const contentType = await this.getContentTypeInfo(uid);
+        strapi.log.info(`[Sitemap] Fetching data for ${uid}`);
+        const entries = await strapi.entityService.findMany(uid);
+        strapi.log.info(`[Sitemap] Found ${entries?.length || 0} entries for ${uid}`);
+        if (entries && Array.isArray(entries) && entries.length > 0) {
+          const basePath = customPaths[uid] || `/${contentType.pluralName}`;
+          data.entries[uid] = entries.filter((entry) => entry.slug).map((entry) => ({
+            url: `${baseUrl}${basePath}/${entry.slug}`,
+            title: entry.title || entry.name || entry.slug,
+            lastmod: entry.updatedAt
+          }));
+          data.meta.contentTypes.push({
+            uid,
+            displayName: contentType.displayName,
+            count: data.entries[uid].length
+          });
+          data.meta.totalUrls += data.entries[uid].length;
+        }
+      } catch (error) {
+        strapi.log.error(`[Sitemap] Failed to fetch ${uid}:`, error.message);
+        strapi.log.error(`[Sitemap] Error details:`, error);
+      }
+    }
+    strapi.log.info(`[Sitemap] Total URLs in sitemap: ${data.meta.totalUrls}`);
+    return data;
+  },
+  /**
+   * Get plugin configuration
+   */
+  async getConfig() {
+    const pluginStore = strapi.store({ type: "plugin", name: "strapi-sitemap-generator" });
+    const config2 = await pluginStore.get({ key: "config" });
+    return config2 || {
+      baseUrl: "https://example.com",
+      selectedContentTypes: [],
+      customPaths: {},
+      customPriorities: {},
+      customChangefreq: {}
+    };
+  },
+  /**
+   * Update plugin configuration
+   */
+  async updateConfig(newConfig) {
+    const pluginStore = strapi.store({ type: "plugin", name: "strapi-sitemap-generator" });
+    await pluginStore.set({ key: "config", value: newConfig });
+    return newConfig;
+  }
+});
+const services = {
+  service
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+module.exports = index;