studiocms 0.1.0-beta.7 → 0.1.0-beta.8

package/dist/index.js

@@ -0,0 +1,1177 @@
+import fs from "node:fs";
+import inlineModPlugin, { defineModule } from "@inox-tools/inline-mod/vite";
+import { runtimeLogger } from "@inox-tools/runtime-logger";
+import ui from "@studiocms/ui";
+import { addVirtualImports, createResolver, defineIntegration } from "astro-integration-kit";
+import { envField } from "astro/config";
+import { z } from "astro/zod";
+import boxen from "boxen";
+import packageJson from "package-json";
+import copy from "rollup-plugin-copy";
+import { compare as semCompare } from "semver";
+import { loadEnv } from "vite";
+import { routesDir } from "./consts.js";
+import { StudioCMSError } from "./errors.js";
+import { dynamicSitemap } from "./lib/dynamic-sitemap/index.js";
+import {
+  apiRoute,
+  removeLeadingTrailingSlashes,
+  sdkRouteResolver,
+  v1RestRoute
+} from "./lib/index.js";
+import { shared } from "./lib/renderer/shared.js";
+import robotsTXT from "./lib/robots/index.js";
+import { checkForWebVitals } from "./lib/webVitals/checkForWebVitalsPlugin.js";
+import { getInjectedTypes } from "./stubs/index.js";
+import { injectDashboardAPIRoutes } from "./utils/addAPIRoutes.js";
+import { addIntegrationArray } from "./utils/addIntegrationArray.js";
+import { checkAstroConfig } from "./utils/astroConfigCheck.js";
+import { addAstroEnvConfig } from "./utils/astroEnvConfig.js";
+import { changelogHelper } from "./utils/changelog.js";
+import { checkEnvKeys } from "./utils/checkENV.js";
+import { watchStudioCMSConfig } from "./utils/configManager.js";
+import { configResolver } from "./utils/configResolver.js";
+import { injectDashboardRoute } from "./utils/injectRouteArray.js";
+import { integrationLogger } from "./utils/integrationLogger.js";
+import { nodeNamespaceBuiltinsAstro } from "./utils/integrations.js";
+import { readJson } from "./utils/readJson.js";
+import { injectAuthAPIRoutes, injectAuthPageRoutes } from "./utils/routeBuilder.js";
+import { convertToSafeString } from "./utils/safeString.js";
+const { resolve } = createResolver(import.meta.url);
+const { name: pkgName, version: pkgVersion } = readJson(
+  resolve("../package.json")
+);
+const env = loadEnv("", process.cwd(), "");
+const RendererComponent = resolve("./components/Renderer.astro");
+const defaultEditorComponent = resolve("./components/DefaultEditor.astro");
+const defaultCustomImageComponent = resolve("./components/image/CustomImage.astro");
+const defaultPlugin = {
+  name: "StudioCMS (Built-in)",
+  identifier: "studiocms",
+  studiocmsMinimumVersion: pkgVersion,
+  dashboardGridItems: [
+    {
+      name: "overview",
+      span: 1,
+      variant: "default",
+      requiresPermission: "editor",
+      header: { title: "Overview", icon: "bolt" },
+      body: {
+        html: "<totals></totals>",
+        components: {
+          totals: resolve("./components/default-grid-items/Totals.astro")
+        }
+      }
+    },
+    {
+      name: "recently-updated-pages",
+      span: 2,
+      variant: "default",
+      requiresPermission: "editor",
+      header: { title: "Recently Updated Pages", icon: "document-arrow-up" },
+      body: {
+        html: "<recentlyupdatedpages></recentlyupdatedpages>",
+        components: {
+          recentlyupdatedpages: resolve(
+            "./components/default-grid-items/Recently-updated-pages.astro"
+          )
+        }
+      }
+    },
+    {
+      name: "recently-signed-up-users",
+      span: 1,
+      variant: "default",
+      requiresPermission: "admin",
+      header: { title: "Recently Signed Up Users", icon: "user-group" },
+      body: {
+        html: "<recentlysignedupusers></recentlysignedupusers>",
+        components: {
+          recentlysignedupusers: resolve(
+            "./components/default-grid-items/Recently-signed-up.astro"
+          )
+        }
+      }
+    },
+    {
+      name: "recently-created-pages",
+      span: 2,
+      variant: "default",
+      requiresPermission: "editor",
+      header: { title: "Recently Created Pages", icon: "document-plus" },
+      body: {
+        html: "<recentlycreatedpages></recentlycreatedpages>",
+        components: {
+          recentlycreatedpages: resolve(
+            "./components/default-grid-items/Recently-created-pages.astro"
+          )
+        }
+      }
+    }
+  ],
+  pageTypes: [
+    {
+      label: "Markdown (Built-in)",
+      identifier: "studiocms/markdown",
+      pageContentComponent: defaultEditorComponent
+    }
+    // { label: 'HTML (StudioCMS)', identifier: 'studiocms/html' },
+  ]
+};
+const studiocms = defineIntegration({
+  name: pkgName,
+  optionsSchema: z.custom(),
+  setup: ({ name, options: opts }) => {
+    let options;
+    const messages = [];
+    let ComponentRegistry;
+    let resolvedCalloutTheme;
+    let imageComponentPath;
+    const availableDashboardGridItems = [];
+    const availableDashboardPages = {
+      user: [],
+      admin: []
+    };
+    return {
+      name,
+      hooks: {
+        // DB Setup: Setup the Database Connection for AstroDB and StudioCMS
+        "astro:db:setup": ({ extendDb }) => {
+          extendDb({ configEntrypoint: resolve("./db/config.js") });
+        },
+        "astro:config:setup": async (params) => {
+          const { logger, config, updateConfig, injectRoute, injectScript } = params;
+          const { resolve: astroConfigResolve } = createResolver(config.root.pathname);
+          logger.info("Checking configuration...");
+          watchStudioCMSConfig(params);
+          options = await configResolver(params, opts);
+          const {
+            verbose,
+            rendererConfig,
+            includedIntegrations,
+            imageService,
+            plugins,
+            componentRegistry,
+            overrides,
+            dbStartPage,
+            dashboardConfig,
+            defaultFrontEndConfig
+          } = options;
+          const {
+            dashboardEnabled,
+            inject404Route,
+            dashboardRouteOverride,
+            AuthConfig: {
+              enabled: authEnabled,
+              providers: {
+                github: githubAPI,
+                discord: discordAPI,
+                google: googleAPI,
+                auth0: auth0API,
+                usernameAndPassword: usernameAndPasswordAPI,
+                usernameAndPasswordConfig: { allowUserRegistration }
+              }
+            }
+          } = dashboardConfig;
+          const frontEndDefaultsTrue = {
+            htmlDefaultLanguage: "en",
+            htmlDefaultHead: [],
+            favicon: "/favicon.svg",
+            injectQuickActionsMenu: true
+          };
+          const frontEndDefaultsFalse = {
+            htmlDefaultLanguage: "en",
+            htmlDefaultHead: [],
+            favicon: "/favicon.svg",
+            injectQuickActionsMenu: true
+          };
+          const frontendConfig = typeof defaultFrontEndConfig === "object" ? defaultFrontEndConfig : defaultFrontEndConfig === false ? frontEndDefaultsFalse : frontEndDefaultsTrue;
+          const shouldInject404Route = inject404Route && dashboardEnabled;
+          const logInfo = { logger, logLevel: "info", verbose };
+          if (componentRegistry) ComponentRegistry = componentRegistry;
+          resolvedCalloutTheme = resolve(
+            `./styles/md-remark-callouts/${rendererConfig.studiocms.callouts.theme}.css`
+          );
+          integrationLogger(logInfo, "Setting up StudioCMS...");
+          runtimeLogger(params, {
+            name: "studiocms-runtime"
+          });
+          checkAstroConfig(params);
+          integrationLogger(logInfo, "Setting up StudioCMS internals...");
+          addAstroEnvConfig(params, {
+            validateSecrets: true,
+            schema: {
+              // Auth Encryption Key
+              CMS_ENCRYPTION_KEY: envField.string({
+                context: "server",
+                access: "secret",
+                optional: false
+              }),
+              // GitHub Auth Provider Environment Variables
+              CMS_GITHUB_CLIENT_ID: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_GITHUB_CLIENT_SECRET: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_GITHUB_REDIRECT_URI: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              // Discord Auth Provider Environment Variables
+              CMS_DISCORD_CLIENT_ID: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_DISCORD_CLIENT_SECRET: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_DISCORD_REDIRECT_URI: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              // Google Auth Provider Environment Variables
+              CMS_GOOGLE_CLIENT_ID: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_GOOGLE_CLIENT_SECRET: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_GOOGLE_REDIRECT_URI: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              // Auth0 Auth Provider Environment Variables
+              CMS_AUTH0_CLIENT_ID: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_AUTH0_CLIENT_SECRET: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_AUTH0_DOMAIN: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              CMS_AUTH0_REDIRECT_URI: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              }),
+              // Cloudinary Environment Variables for Custom Image Component
+              CMS_CLOUDINARY_CLOUDNAME: envField.string({
+                context: "server",
+                access: "secret",
+                optional: true
+              })
+            }
+          });
+          if (imageService.cdnPlugin === "cloudinary-js") {
+            if (!env.CMS_CLOUDINARY_CLOUDNAME) {
+              integrationLogger(
+                { logger, logLevel: "warn", verbose: true },
+                "Using the Cloudinary CDN JS SDK Plugin requires the CMS_CLOUDINARY_CLOUDNAME environment variable to be set. Please add this to your .env file."
+              );
+            }
+          }
+          integrationLogger(logInfo, "Configuring CustomImage Component...");
+          imageComponentPath = overrides.CustomImageOverride ? astroConfigResolve(overrides.CustomImageOverride) : defaultCustomImageComponent;
+          integrationLogger({ logger, logLevel: "info", verbose }, "Setting up StudioCMS Auth...");
+          checkEnvKeys(logger, options);
+          integrationLogger(logInfo, "Injecting SDK Routes...");
+          injectRoute({
+            pattern: sdkRouteResolver("list-pages"),
+            entrypoint: routesDir.sdk("list-pages.js"),
+            prerender: false
+          });
+          injectRoute({
+            pattern: sdkRouteResolver("update-latest-version-cache"),
+            entrypoint: routesDir.sdk("update-latest-version-cache.js"),
+            prerender: false
+          });
+          injectRoute({
+            pattern: sdkRouteResolver("fallback-list-pages.json"),
+            entrypoint: routesDir.sdk("fallback-list-pages.json.js"),
+            prerender: false
+          });
+          injectRoute({
+            pattern: sdkRouteResolver("full-changelog.json"),
+            entrypoint: routesDir.sdk("full-changelog.json.js"),
+            prerender: false
+          });
+          integrationLogger(logInfo, "Setting up StudioCMS Renderer...");
+          injectRoute({
+            pattern: apiRoute("render"),
+            entrypoint: routesDir.api("render.astro"),
+            prerender: false
+          });
+          if (dbStartPage) {
+            integrationLogger(
+              { logger, logLevel: "info", verbose },
+              "Injecting First Time Setup Routes..."
+            );
+            injectRoute({
+              pattern: "start",
+              entrypoint: routesDir.fts("1-start.astro"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: "start/1",
+              entrypoint: routesDir.fts("1-start.astro"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: "start/2",
+              entrypoint: routesDir.fts("2-next.astro"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: "done",
+              entrypoint: routesDir.fts("3-done.astro"),
+              prerender: false
+            });
+          }
+          if (shouldInject404Route) {
+            integrationLogger(logInfo, "Injecting 404 Route...");
+            injectRoute({
+              pattern: "404",
+              entrypoint: routesDir.errors("404.astro"),
+              prerender: false
+            });
+          }
+          injectDashboardAPIRoutes(params, {
+            options,
+            routes: [
+              {
+                enabled: dashboardEnabled && !dbStartPage,
+                pattern: "live-render",
+                entrypoint: routesDir.dashApi("partials/LiveRender.astro")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage,
+                pattern: "editor",
+                entrypoint: routesDir.dashApi("partials/Editor.astro")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage,
+                pattern: "search-list",
+                entrypoint: routesDir.dashApi("search-list.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage,
+                pattern: "user-list-items",
+                entrypoint: routesDir.dashApi("partials/UserListItems.astro")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "config",
+                entrypoint: routesDir.dashApi("config.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "profile",
+                entrypoint: routesDir.dashApi("profile.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "users",
+                entrypoint: routesDir.dashApi("users.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "content/page",
+                entrypoint: routesDir.dashApi("content/page.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "content/folder",
+                entrypoint: routesDir.dashApi("content/folder.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "create-reset-link",
+                entrypoint: routesDir.dashApi("create-reset-link.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "reset-password",
+                entrypoint: routesDir.dashApi("reset-password.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "plugins/[plugin]",
+                entrypoint: routesDir.dashApi("plugins/[plugin].js")
+              },
+              {
+                enabled: dbStartPage,
+                pattern: "step-1",
+                entrypoint: routesDir.fts("api/step-1.js")
+              },
+              {
+                enabled: dbStartPage,
+                pattern: "step-2",
+                entrypoint: routesDir.fts("api/step-2.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "create-user",
+                entrypoint: routesDir.dashApi("create-user.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "create-user-invite",
+                entrypoint: routesDir.dashApi("create-user-invite.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "api-tokens",
+                entrypoint: routesDir.dashApi("api-tokens.js")
+              },
+              {
+                enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                pattern: "verify-session",
+                entrypoint: routesDir.dashApi("verify-session.js")
+              }
+            ]
+          });
+          injectDashboardRoute(
+            params,
+            {
+              options,
+              routes: [
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "/",
+                  entrypoint: routesDir.dashRoute("index.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management",
+                  entrypoint: routesDir.dashRoute("content-management/index.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management/create",
+                  entrypoint: routesDir.dashRoute("content-management/createpage.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management/create-folder",
+                  entrypoint: routesDir.dashRoute("content-management/createfolder.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management/edit",
+                  entrypoint: routesDir.dashRoute("content-management/editpage.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management/edit-folder",
+                  entrypoint: routesDir.dashRoute("content-management/editfolder.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "content-management/diff",
+                  entrypoint: routesDir.dashRoute("content-management/diff.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "profile",
+                  entrypoint: routesDir.dashRoute("profile.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "configuration",
+                  entrypoint: routesDir.dashRoute("configuration.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "user-management",
+                  entrypoint: routesDir.dashRoute("user-management/index.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage,
+                  pattern: "user-management/edit",
+                  entrypoint: routesDir.dashRoute("user-management/edit.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                  pattern: "password-reset",
+                  entrypoint: routesDir.dashRoute("password-reset.astro")
+                },
+                {
+                  enabled: dashboardEnabled && !dbStartPage && authEnabled,
+                  pattern: "plugins/[plugin]",
+                  entrypoint: routesDir.dashRoute("plugins/[plugin].astro")
+                }
+              ]
+            },
+            false
+          );
+          injectAuthAPIRoutes(params, {
+            options,
+            routes: [
+              {
+                pattern: "login",
+                entrypoint: routesDir.authAPI("login.js"),
+                enabled: usernameAndPasswordAPI
+              },
+              {
+                pattern: "logout",
+                entrypoint: routesDir.authAPI("logout.js"),
+                enabled: dashboardEnabled && !options.dbStartPage
+              },
+              {
+                pattern: "register",
+                entrypoint: routesDir.authAPI("register.js"),
+                enabled: usernameAndPasswordAPI && allowUserRegistration
+              },
+              {
+                pattern: "github",
+                entrypoint: routesDir.authAPI("github/index.js"),
+                enabled: githubAPI
+              },
+              {
+                pattern: "github/callback",
+                entrypoint: routesDir.authAPI("github/callback.js"),
+                enabled: githubAPI
+              },
+              {
+                pattern: "discord",
+                entrypoint: routesDir.authAPI("discord/index.js"),
+                enabled: discordAPI
+              },
+              {
+                pattern: "discord/callback",
+                entrypoint: routesDir.authAPI("discord/callback.js"),
+                enabled: discordAPI
+              },
+              {
+                pattern: "google",
+                entrypoint: routesDir.authAPI("google/index.js"),
+                enabled: googleAPI
+              },
+              {
+                pattern: "google/callback",
+                entrypoint: routesDir.authAPI("google/callback.js"),
+                enabled: googleAPI
+              },
+              {
+                pattern: "auth0",
+                entrypoint: routesDir.authAPI("auth0/index.js"),
+                enabled: auth0API
+              },
+              {
+                pattern: "auth0/callback",
+                entrypoint: routesDir.authAPI("auth0/callback.js"),
+                enabled: auth0API
+              }
+            ]
+          });
+          injectAuthPageRoutes(
+            params,
+            {
+              options,
+              routes: [
+                {
+                  pattern: "login/",
+                  entrypoint: routesDir.authPage("login.astro"),
+                  enabled: dashboardEnabled && !options.dbStartPage
+                },
+                {
+                  pattern: "logout/",
+                  entrypoint: routesDir.authPage("logout.astro"),
+                  enabled: dashboardEnabled && !options.dbStartPage
+                },
+                {
+                  pattern: "signup/",
+                  entrypoint: routesDir.authPage("signup.astro"),
+                  enabled: usernameAndPasswordAPI && allowUserRegistration
+                }
+              ]
+            },
+            false
+          );
+          if (!dbStartPage && authEnabled) {
+            integrationLogger(logInfo, "Injecting REST API Routes...");
+            injectRoute({
+              pattern: v1RestRoute("folders"),
+              entrypoint: routesDir.v1Rest("folders/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("folders/[id]"),
+              entrypoint: routesDir.v1Rest("folders/[id].js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("pages"),
+              entrypoint: routesDir.v1Rest("pages/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("pages/[id]"),
+              entrypoint: routesDir.v1Rest("pages/[id]/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("pages/[id]/history"),
+              entrypoint: routesDir.v1Rest("pages/[id]/history/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("pages/[id]/history/[diffid]"),
+              entrypoint: routesDir.v1Rest("pages/[id]/history/[diffid].js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("settings"),
+              entrypoint: routesDir.v1Rest("settings/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("users"),
+              entrypoint: routesDir.v1Rest("users/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("users/[id]"),
+              entrypoint: routesDir.v1Rest("users/[id].js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("public/pages"),
+              entrypoint: routesDir.v1Rest("public/pages/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("public/pages/[id]"),
+              entrypoint: routesDir.v1Rest("public/pages/[id].js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("public/folders"),
+              entrypoint: routesDir.v1Rest("public/folders/index.js"),
+              prerender: false
+            });
+            injectRoute({
+              pattern: v1RestRoute("public/folders/[id]"),
+              entrypoint: routesDir.v1Rest("public/folders/[id].js"),
+              prerender: false
+            });
+          }
+          const integrations = [
+            { integration: nodeNamespaceBuiltinsAstro() },
+            { integration: ui({ noInjectCSS: true }) }
+          ];
+          integrationLogger(logInfo, "Adding optional integrations...");
+          integrationLogger(logInfo, "Setting up StudioCMS plugins...");
+          let sitemapEnabled = false;
+          const sitemaps = [];
+          const wvPlugin = checkForWebVitals(params, { name, verbose, version: pkgVersion });
+          const pluginsToProcess = [defaultPlugin];
+          if (wvPlugin) pluginsToProcess.push(wvPlugin);
+          if (plugins) pluginsToProcess.push(...plugins);
+          const safePluginList = [];
+          for (const {
+            studiocmsMinimumVersion,
+            integration,
+            triggerSitemap,
+            sitemaps: pluginSitemaps,
+            dashboardGridItems,
+            dashboardPages,
+            ...safePlugin
+          } of pluginsToProcess || []) {
+            const comparison = semCompare(studiocmsMinimumVersion, pkgVersion);
+            if (comparison === 1) {
+              throw new StudioCMSError(
+                `Plugin ${name} requires StudioCMS version ${studiocmsMinimumVersion} or higher.`,
+                `Plugin ${name} requires StudioCMS version ${studiocmsMinimumVersion} or higher, please update StudioCMS to the required version, contact the plugin author to update the minimum version requirement or remove the plugin from the StudioCMS config.`
+              );
+            }
+            if (integration && Array.isArray(integration)) {
+              integrations.push(...integration.map((integration2) => ({ integration: integration2 })));
+            } else if (integration) {
+              integrations.push({ integration });
+            }
+            if (triggerSitemap) sitemapEnabled = triggerSitemap;
+            if (pluginSitemaps) {
+              sitemaps.push(...pluginSitemaps);
+            }
+            if (dashboardGridItems) {
+              availableDashboardGridItems.push(
+                ...dashboardGridItems.map((item) => ({
+                  ...item,
+                  name: `${convertToSafeString(safePlugin.identifier)}/${convertToSafeString(item.name)}`
+                }))
+              );
+            }
+            if (dashboardPages) {
+              if (dashboardPages.user) {
+                availableDashboardPages.user?.push(
+                  ...dashboardPages.user.map((page) => ({
+                    ...page,
+                    slug: `${convertToSafeString(safePlugin.identifier)}/${convertToSafeString(page.route)}`
+                  }))
+                );
+              }
+              if (dashboardPages.admin) {
+                availableDashboardPages.admin?.push(
+                  ...dashboardPages.admin.map((page) => ({
+                    ...page,
+                    slug: `${convertToSafeString(safePlugin.identifier)}/${convertToSafeString(page.route)}`
+                  }))
+                );
+              }
+            }
+            safePluginList.push(safePlugin);
+          }
+          if (includedIntegrations.robotsTXT === true) {
+            integrations.push({ integration: robotsTXT({ sitemap: sitemapEnabled }) });
+          } else if (typeof includedIntegrations.robotsTXT === "object") {
+            integrations.push({
+              integration: robotsTXT({
+                ...includedIntegrations.robotsTXT,
+                sitemap: sitemapEnabled
+              })
+            });
+          }
+          if (sitemapEnabled) {
+            integrations.push({
+              integration: dynamicSitemap({
+                sitemaps
+              })
+            });
+          }
+          let defaultDashboardRoute = dashboardRouteOverride ? removeLeadingTrailingSlashes(dashboardRouteOverride) : "dashboard";
+          if (defaultDashboardRoute === "/") {
+            defaultDashboardRoute = "";
+          }
+          const makeDashboardRoute = (path) => {
+            return `${defaultDashboardRoute}/${path}`;
+          };
+          if (availableDashboardPages.user && availableDashboardPages.user.length > 0 || availableDashboardPages.admin && availableDashboardPages.admin.length > 0) {
+            injectRoute({
+              pattern: makeDashboardRoute("[...pluginPage]"),
+              entrypoint: routesDir.dashRoute("[...pluginPage].astro"),
+              prerender: false
+            });
+          }
+          addIntegrationArray(params, integrations);
+          integrationLogger(logInfo, "Adding Virtual Imports...");
+          defineModule("studiocms:plugins", {
+            defaultExport: safePluginList
+          });
+          defineModule("studiocms:config", {
+            defaultExport: options,
+            constExports: {
+              config: options,
+              dashboardConfig: options.dashboardConfig,
+              AuthConfig: options.dashboardConfig.AuthConfig,
+              developerConfig: options.dashboardConfig.developerConfig,
+              defaultFrontEndConfig: options.defaultFrontEndConfig,
+              sdk: options.sdk
+            }
+          });
+          defineModule("studiocms:version", {
+            defaultExport: pkgVersion
+          });
+          const allPageTypes = safePluginList.flatMap(({ pageTypes }) => pageTypes || []);
+          const editorKeys = allPageTypes.map(({ identifier }) => convertToSafeString(identifier));
+          const editorComponents = allPageTypes.map(({ identifier, pageContentComponent }) => {
+            if (!pageContentComponent) {
+              return `export { default as ${convertToSafeString(identifier)} } from '${defaultEditorComponent}';`;
+            }
+            return `export { default as ${convertToSafeString(identifier)} } from '${pageContentComponent}';`;
+          }).join("\n");
+          const componentKeys = ComponentRegistry ? Object.keys(ComponentRegistry).map((key) => key.toLowerCase()) : [];
+          const components = ComponentRegistry ? Object.entries(ComponentRegistry).map(
+            ([key, value]) => `export { default as ${key} } from '${astroConfigResolve(value)}';`
+          ).join("\n") : "";
+          const dashboardGridComponents = availableDashboardGridItems.map((item) => {
+            const components2 = item.body?.components || {};
+            const remappedComps = Object.entries(components2).map(
+              ([key, value]) => `export { default as ${key} } from '${value}';`
+            );
+            return remappedComps.join("\n");
+          }).join("\n");
+          const dashboardPagesComponentsUser = availableDashboardPages.user?.map(({ pageBodyComponent, pageActionsComponent, ...item }) => {
+            const components2 = {
+              pageBodyComponent
+            };
+            if (item.sidebar === "double") {
+              components2.innerSidebarComponent = item.innerSidebarComponent;
+            }
+            if (pageActionsComponent) {
+              components2.pageActionsComponent = pageActionsComponent;
+            }
+            const remappedComps = Object.entries(components2).map(
+              ([key, value]) => `export { default as ${convertToSafeString(item.title + key)} } from '${value}';`
+            );
+            return remappedComps.join("\n");
+          }).join("\n") || "";
+          const dashboardPagesComponentsAdmin = availableDashboardPages.admin?.map(({ pageBodyComponent, pageActionsComponent, ...item }) => {
+            const components2 = {
+              pageBodyComponent
+            };
+            if (item.sidebar === "double") {
+              components2.innerSidebarComponent = item.innerSidebarComponent;
+            }
+            if (pageActionsComponent) {
+              components2.pageActionsComponent = pageActionsComponent;
+            }
+            const remappedComps = Object.entries(components2).map(
+              ([key, value]) => `export { default as ${convertToSafeString(item.title + key)} } from '${value}';`
+            );
+            return remappedComps.join("\n");
+          }).join("\n") || "";
+          addVirtualImports(params, {
+            name,
+            imports: {
+              // Core Virtual Components
+              "studiocms:components": `
+								export { default as FormattedDate } from '${options.overrides.FormattedDateOverride ? astroConfigResolve(options.overrides.FormattedDateOverride) : resolve("./components/FormattedDate.astro")}';
+								export { default as Generator } from '${resolve("./components/Generator.astro")}';
+							`,
+              "virtual:studiocms/components/Editors": `
+								export const editorKeys = ${JSON.stringify([...editorKeys])};
+								${editorComponents}
+							`,
+              // StudioCMS lib
+              "studiocms:lib": `
+								export * from '${resolve("./lib/head.js")}';
+								export * from '${resolve("./lib/headDefaults.js")}';
+								export * from '${resolve("./lib/jsonUtils.js")}';
+								export * from '${resolve("./lib/pathGenerators.js")}';
+								export * from '${resolve("./lib/removeLeadingTrailingSlashes.js")}';
+								export * from '${resolve("./lib/routeMap.js")}';
+								export * from '${resolve("./lib/urlGen.js")}';
+							`,
+              // SDK Virtual Modules
+              "virtual:studiocms/sdk/env": `
+								export const dbUrl = '${env.ASTRO_DB_REMOTE_URL}';
+								export const dbSecret = '${env.ASTRO_DB_APP_TOKEN}';
+								export const cmsEncryptionKey = '${env.CMS_ENCRYPTION_KEY}';
+							`,
+              "studiocms:sdk": `
+								import studioCMS_SDK from '${resolve("./sdk/index.js")}';
+								export default studioCMS_SDK;
+							`,
+              "studiocms:sdk/cache": `
+								export * from '${resolve("./sdk/cache.js")}';
+								import studioCMS_SDK_Cache from '${resolve("./sdk/cache.js")}';
+								export default studioCMS_SDK_Cache;
+							`,
+              "studiocms:sdk/types": `
+								export * from '${resolve("./sdk/types.js")}';
+							`,
+              // i18n Virtual Module
+              "studiocms:i18n": `
+								export * from '${resolve("./lib/i18n/index.js")}';
+								export { default as LanguageSelector } from '${resolve("./lib/i18n/LanguageSelector.astro")}';
+							`,
+              // User Virtual Components
+              "studiocms:component-proxy": `
+								export const componentKeys = ${JSON.stringify(componentKeys || [])};
+								${components}
+							`,
+              "studiocms:logger": `
+								import { logger } from '@it-astro:logger:studiocms-runtime';
+								export default logger.fork('studiocms:runtime');
+							`,
+              // Plugin Helpers
+              "studiocms:plugin-helpers": `
+								export * from "${resolve("./plugins.js")}";
+								export * from "${resolve("./lib/plugins/index.js")}";
+							`,
+              // Dashboard Grid Items
+              "studiocms:components/dashboard-grid-components": `
+								${dashboardGridComponents}
+							`,
+              "studiocms:components/dashboard-grid-items": `
+								import * as components from 'studiocms:components/dashboard-grid-components';
+
+								const currentComponents = ${JSON.stringify(availableDashboardGridItems)};
+
+								const dashboardGridItems = currentComponents.map((item) => {
+									const gridItem = { ...item };
+
+									if (gridItem.body?.components) {
+										gridItem.body.components = Object.entries(gridItem.body.components).reduce(
+											(acc, [key, value]) => ({
+												...acc,
+												[key]: components[key],
+											}),
+											{}
+										);
+									}
+
+									return gridItem;
+								});
+
+								export default dashboardGridItems;
+							`,
+              // Dashboard Pages
+              "studiocms:plugins/dashboard-pages/components/user": `
+								${dashboardPagesComponentsUser}
+							`,
+              "studiocms:plugins/dashboard-pages/user": `
+								import { convertToSafeString } from '${resolve("./utils/safeString.js")}';
+								import * as components from 'studiocms:plugins/dashboard-pages/components/user';
+
+								const currentComponents = ${JSON.stringify(availableDashboardPages.user || [])};
+
+								const dashboardPages = currentComponents.map((item) => {
+									const page = { 
+										...item,
+										components: {
+											PageBodyComponent: components[convertToSafeString(item.title + 'pageBodyComponent')],
+											PageActionsComponent: components[convertToSafeString(item.title + 'pageActionsComponent')] || null,
+											InnerSidebarComponent: item.sidebar === 'double' ? components[convertToSafeString(item.title + 'innerSidebarComponent')] || null : null,
+										},
+									};
+
+									return page;
+								});
+
+								export default dashboardPages;
+							`,
+              "studiocms:plugins/dashboard-pages/components/admin": `
+								${dashboardPagesComponentsAdmin}
+							`,
+              "studiocms:plugins/dashboard-pages/admin": `
+								import { convertToSafeString } from '${resolve("./utils/safeString.js")}';
+								import * as components from 'studiocms:plugins/dashboard-pages/components/admin';
+
+								const currentComponents = ${JSON.stringify(availableDashboardPages.admin || [])};
+
+								const dashboardPages = currentComponents.map((item) => {
+									const page = { 
+										...item,
+										components: {
+											PageBodyComponent: components[convertToSafeString(item.title + 'pageBodyComponent')],
+											PageActionsComponent: components[convertToSafeString(item.title + 'pageActionsComponent')] || null,
+											InnerSidebarComponent: item.sidebar === 'double' ? components[convertToSafeString(item.title + 'innerSidebarComponent')] || null : null,
+										},
+									};
+
+									return page;
+								});
+
+								export default dashboardPages;
+							`,
+              // Renderer Virtual Imports
+              "studiocms:renderer/config": `
+								export default ${JSON.stringify(options.rendererConfig)};
+							`,
+              "studiocms:renderer": `
+								export { default as StudioCMSRenderer } from '${RendererComponent}';
+							`,
+              "studiocms:renderer/current": `
+								export * from '${resolve("./lib/renderer/contentRenderer.js")}';
+								import contentRenderer from '${resolve("./lib/renderer/contentRenderer.js")}';
+								export default contentRenderer;
+							`,
+              "studiocms:renderer/markdown-remark/css": `
+								import '${resolve("./styles/md-remark-headings.css")}';
+								${rendererConfig.studiocms.callouts.enabled ? `import '${resolvedCalloutTheme}';` : ""}
+							`,
+              // Image Handler Virtual Imports
+              "studiocms:imageHandler/components": `
+								export { default as CustomImage } from '${imageComponentPath}';
+							`,
+              // Auth Virtual Imports
+              "studiocms:auth/lib/encryption": `
+								export * from '${resolve("./lib/auth/encryption.js")}'
+							`,
+              "studiocms:auth/lib/password": `
+								export * from '${resolve("./lib/auth/password.js")}'
+							`,
+              "studiocms:auth/lib/rate-limit": `
+								export * from '${resolve("./lib/auth/rate-limit.js")}'
+							`,
+              "studiocms:auth/lib/session": `
+								export * from '${resolve("./lib/auth/session.js")}'
+							`,
+              "studiocms:auth/lib/types": `
+								export * from '${resolve("./lib/auth/types.js")}'
+							`,
+              "studiocms:auth/lib/user": `
+								export * from '${resolve("./lib/auth/user.js")}'
+							`,
+              "studiocms:auth/utils/authEnvCheck": `
+								export * from '${resolve("./utils/authEnvCheck.js")}'
+							`,
+              "studiocms:auth/utils/validImages": `
+								export * from '${resolve("./utils/validImages.js")}'
+							`,
+              "studiocms:auth/utils/getLabelForPermissionLevel": `
+								export * from '${resolve("./utils/getLabelForPermissionLevel.js")}'
+							`,
+              "studiocms:auth/scripts/three": `
+								import '${resolve("./scripts/three.js")}';
+							`
+            }
+          });
+          if (rendererConfig.renderer === "studiocms") {
+            integrationLogger(logInfo, "Injecting StudioCMS Renderer CSS...");
+            injectScript("page-ssr", 'import "studiocms:renderer/markdown-remark/css";');
+          }
+          if (frontendConfig.injectQuickActionsMenu) {
+            injectScript(
+              "head-inline",
+              fs.readFileSync(resolve("./components/user-quick-tools.js"), "utf-8")
+            );
+          }
+          integrationLogger(
+            logInfo,
+            "Updating Astro Config with StudioCMS Resources and settings..."
+          );
+          updateConfig({
+            image: {
+              remotePatterns: [
+                {
+                  protocol: "https"
+                }
+              ]
+            },
+            vite: {
+              optimizeDeps: {
+                exclude: ["three"]
+              },
+              plugins: [
+                inlineModPlugin(),
+                copy({
+                  copyOnce: true,
+                  hook: "buildStart",
+                  targets: [
+                    {
+                      src: resolve("../static/studiocms-resources/*"),
+                      dest: "public/studiocms-resources/"
+                    }
+                  ]
+                })
+              ]
+            }
+          });
+          let pluginListLength = 0;
+          let pluginListMessage = "";
+          pluginListLength = safePluginList.length;
+          pluginListMessage = safePluginList.map((p, i) => `${i + 1}. ${p.name}`).join("\n");
+          const messageBox = boxen(pluginListMessage, {
+            padding: 1,
+            title: `Currently Installed StudioCMS Modules (${pluginListLength})`
+          });
+          messages.push({
+            label: "studiocms:plugins",
+            logLevel: "info",
+            message: ` 
+ 
+${messageBox} 
+ 
+`
+          });
+          changelogHelper(params);
+        },
+        // Config Done: Make DTS file for StudioCMS Plugins Virtual Module
+        "astro:config:done": ({ injectTypes, config }) => {
+          const { resolve: astroConfigResolve } = createResolver(config.root.pathname);
+          const injectedTypes = getInjectedTypes(
+            ComponentRegistry,
+            imageComponentPath,
+            astroConfigResolve
+          );
+          for (const type of injectedTypes) {
+            injectTypes(type);
+          }
+          shared.markdownConfig = config.markdown;
+          shared.studiocms = options.rendererConfig.studiocms;
+          messages.push({
+            label: "studiocms:setup",
+            logLevel: "info",
+            message: "Setup Complete. \u{1F680}"
+          });
+        },
+        // DEV SERVER: Check for updates on server start and log messages
+        "astro:server:start": async ({ logger: l }) => {
+          const logger = l.fork(`${name}:update-check`);
+          try {
+            const { version: latestVersion } = await packageJson(name.toLowerCase());
+            const comparison = semCompare(pkgVersion, latestVersion);
+            if (comparison === -1) {
+              logger.warn(
+                `A new version of '${name}' is available. Please update to ${latestVersion} using your favorite package manager.`
+              );
+            } else if (comparison === 0) {
+              logger.info(`You are using the latest version of '${name}' (${pkgVersion})`);
+            } else {
+              logger.info(
+                `You are using a newer version (${pkgVersion}) of '${name}' than the latest release (${latestVersion})`
+              );
+            }
+          } catch (error) {
+            if (error instanceof Error) {
+              logger.error(`Error fetching latest version from npm registry: ${error.message}`);
+            } else {
+              logger.error(
+                "An unknown error occurred while fetching the latest version from the npm registry."
+              );
+            }
+          }
+          for (const { label, message, logLevel } of messages) {
+            integrationLogger(
+              {
+                logger: l.fork(label),
+                logLevel,
+                verbose: logLevel === "info" ? options.verbose : true
+              },
+              message
+            );
+          }
+          if (options.dbStartPage) {
+            integrationLogger(
+              { logger, logLevel: "warn", verbose: true },
+              "Start Page is Enabled.  This will be the only page available until you initialize your database and disable the config option forcing this page to be displayed. To get started, visit http://localhost:4321/start/ in your browser to initialize your database. And Setup your installation."
+            );
+          }
+        },
+        // BUILD: Log messages at the end of the build
+        "astro:build:done": ({ logger }) => {
+          for (const { label, message, logLevel } of messages) {
+            integrationLogger(
+              {
+                logger: logger.fork(label),
+                logLevel,
+                verbose: logLevel === "info" ? options.verbose : true
+              },
+              message
+            );
+          }
+        }
+      }
+    };
+  }
+});
+var index_default = studiocms;
+export {
+  index_default as default,
+  studiocms
+};