studiocms 0.1.0-beta.10

package/dist/lib/routeMap.js

@@ -0,0 +1,249 @@
+import { dashboardConfig } from "studiocms:config";
+import { makeAPIRoute } from "./makeAPIRoute.js";
+import urlGenFactory from "./urlGen.js";
+const { dashboardRouteOverride } = dashboardConfig;
+function getSluggedRoute(url, slug) {
+  return urlGenFactory(true, url + slug, dashboardRouteOverride);
+}
+function getEditRoute(slug) {
+  return getSluggedRoute("edit/pages/", slug);
+}
+function getDeleteRoute(slug) {
+  return getSluggedRoute("delete/pages/", slug);
+}
+function makeNonDashboardRoute(route) {
+  return urlGenFactory(false, route);
+}
+function makeDashboardRoute(route) {
+  return urlGenFactory(true, route, dashboardRouteOverride);
+}
+const authAPIRoute = makeAPIRoute("auth");
+const dashboardAPIRoute = makeAPIRoute("dashboard");
+const sdkRoute = makeAPIRoute("sdk");
+const rendererRoute = makeAPIRoute("renderer");
+const StudioCMSRoutes = {
+  mainLinks: {
+    /**
+     * Base URL for the non-dashboard site.
+     */
+    baseSiteURL: makeNonDashboardRoute(),
+    /**
+     * URL for the dashboard index.
+     */
+    dashboardIndex: makeDashboardRoute(),
+    /**
+     * URL for the user profile page.
+     */
+    userProfile: makeDashboardRoute("profile"),
+    /**
+     * URL for the content management page.
+     */
+    contentManagement: makeDashboardRoute("content-management"),
+    /**
+     * URL for creating content in the content management page.
+     */
+    contentManagementCreate: makeDashboardRoute("content-management/create"),
+    /**
+     * URL for editing content in the content management page.
+     */
+    contentManagementEdit: makeDashboardRoute("content-management/edit"),
+    /**
+     * URL for creating a folder in the content management page.
+     */
+    contentManagementFolderCreate: makeDashboardRoute("content-management/create-folder"),
+    /**
+     * URL for editing a folder in the content management page.
+     */
+    contentManagementFolderEdit: makeDashboardRoute("content-management/edit-folder"),
+    /**
+     * URL for viewing content differences in the content management page.
+     */
+    contentManagementDiff: makeDashboardRoute("content-management/diff"),
+    /**
+     * URL for creating a new page.
+     */
+    createPage: makeDashboardRoute("create-page"),
+    /**
+     * URL for the site configuration page.
+     */
+    siteConfiguration: makeDashboardRoute("configuration"),
+    /**
+     * URL for the user management page.
+     */
+    userManagement: makeDashboardRoute("user-management"),
+    /**
+     * URL for editing user management details.
+     */
+    userManagementEdit: makeDashboardRoute("user-management/edit"),
+    /**
+     * URL for the plugins page.
+     */
+    plugins: makeDashboardRoute("plugins/")
+  },
+  authLinks: {
+    /**
+     * URL for the login page.
+     */
+    loginURL: makeDashboardRoute("login"),
+    /**
+     * URL for the logout page.
+     */
+    logoutURL: makeDashboardRoute("logout"),
+    /**
+     * URL for the signup page.
+     */
+    signupURL: makeDashboardRoute("signup"),
+    /**
+     * API route for logging in.
+     */
+    loginAPI: authAPIRoute("login"),
+    /**
+     * API route for logging out.
+     */
+    logoutAPI: authAPIRoute("logout"),
+    /**
+     * API route for registering a new user.
+     */
+    registerAPI: authAPIRoute("register"),
+    /**
+     * API route for GitHub authentication index.
+     */
+    githubIndex: authAPIRoute("github"),
+    /**
+     * API route for GitHub authentication callback.
+     */
+    githubCallback: authAPIRoute("github/callback"),
+    /**
+     * API route for Discord authentication index.
+     */
+    discordIndex: authAPIRoute("discord"),
+    /**
+     * API route for Discord authentication callback.
+     */
+    discordCallback: authAPIRoute("discord/callback"),
+    /**
+     * API route for Google authentication index.
+     */
+    googleIndex: authAPIRoute("google"),
+    /**
+     * API route for Google authentication callback.
+     */
+    googleCallback: authAPIRoute("google/callback"),
+    /**
+     * API route for Auth0 authentication index.
+     */
+    auth0Index: authAPIRoute("auth0"),
+    /**
+     * API route for Auth0 authentication callback.
+     */
+    auth0Callback: authAPIRoute("auth0/callback")
+  },
+  endpointLinks: {
+    /**
+     * API route for searching lists.
+     */
+    searchList: dashboardAPIRoute("search-list"),
+    partials: {
+      /**
+       * API route for live preview box rendering.
+       */
+      livePreviewBox: dashboardAPIRoute("live-render"),
+      /**
+       * API route for fetching user list items.
+       */
+      userListItems: dashboardAPIRoute("user-list-items"),
+      /**
+       * API route for rendering content.
+       */
+      render: rendererRoute("render"),
+      /**
+       * API route for the editor.
+       */
+      editor: dashboardAPIRoute("editor")
+    },
+    /**
+     * API route for fetching configuration.
+     */
+    config: dashboardAPIRoute("config"),
+    /**
+     * API route for fetching users.
+     */
+    users: dashboardAPIRoute("users"),
+    /**
+     * API route for fetching user profile.
+     */
+    profile: dashboardAPIRoute("profile"),
+    /**
+     * API route for creating a password reset link.
+     */
+    createResetLink: dashboardAPIRoute("create-reset-link"),
+    /**
+     * API route for resetting password.
+     */
+    resetPassword: dashboardAPIRoute("reset-password"),
+    content: {
+      /**
+       * API route for fetching page content.
+       */
+      page: dashboardAPIRoute("content/page"),
+      /**
+       * API route for fetching folder content.
+       */
+      folder: dashboardAPIRoute("content/folder")
+    },
+    /**
+     * API route for fetching plugins.
+     */
+    plugins: dashboardAPIRoute("plugins/"),
+    newUsers: {
+      /**
+       * API route for creating a new user.
+       */
+      create: dashboardAPIRoute("create-user"),
+      /**
+       * API route for inviting a new user.
+       */
+      invite: dashboardAPIRoute("create-user-invite")
+    },
+    /**
+     * API route for fetching API tokens.
+     */
+    apiTokens: dashboardAPIRoute("api-tokens"),
+    /**
+     * API route for verifying a user session.
+     */
+    verifySession: dashboardAPIRoute("verify-session")
+  },
+  sdk: {
+    /**
+     * SDK route for listing pages.
+     */
+    pages: sdkRoute("list-pages"),
+    /**
+     * SDK route for fetching fallback list of pages.
+     */
+    fallback_pages: sdkRoute("fallback-list-pages.json"),
+    /**
+     * SDK route for updating the latest version cache.
+     */
+    updateLatestVersionCache: sdkRoute("update-latest-version-cache")
+  },
+  fts: {
+    /**
+     * API route for step 1 of the FTS process.
+     */
+    step1: dashboardAPIRoute("step-1"),
+    /**
+     * API route for step 2 of the FTS process.
+     */
+    step2: dashboardAPIRoute("step-2")
+  }
+};
+export {
+  StudioCMSRoutes,
+  getDeleteRoute,
+  getEditRoute,
+  getSluggedRoute,
+  makeDashboardRoute,
+  makeNonDashboardRoute
+};

package/dist/lib/urlGen.d.ts

@@ -0,0 +1,11 @@
+/**
+ * # urlGenFactory Helper Function
+ *
+ * Generate a URL based on the path and route type.
+ *
+ * @param isDashboardRoute
+ * @param path
+ * @param DashboardRouteOverride
+ * @returns
+ */
+export default function urlGenFactory(isDashboardRoute: boolean, path: string | undefined, DashboardRouteOverride?: string): string;

package/dist/lib/urlGen.js

@@ -0,0 +1,26 @@
+import { pathWithBase } from "./pathGenerators.js";
+import { removeLeadingTrailingSlashes } from "./removeLeadingTrailingSlashes.js";
+function urlGenFactory(isDashboardRoute, path, DashboardRouteOverride) {
+  let url;
+  let dashboardRoute = "dashboard";
+  if (DashboardRouteOverride) {
+    dashboardRoute = removeLeadingTrailingSlashes(DashboardRouteOverride);
+  }
+  if (path) {
+    if (isDashboardRoute) {
+      url = pathWithBase(`${dashboardRoute}/${path}`);
+    } else {
+      url = pathWithBase(path);
+    }
+  } else {
+    if (isDashboardRoute) {
+      url = pathWithBase(dashboardRoute);
+    } else {
+      url = "/";
+    }
+  }
+  return url;
+}
+export {
+  urlGenFactory as default
+};

package/dist/lib/webVitals/checkForWebVitalsPlugin.d.ts

@@ -0,0 +1,18 @@
+import type { StudioCMSPlugin } from '../../plugins.js';
+export declare const webVitalsName = "@astrojs/web-vitals";
+/**
+ * Checks for the presence of the Web Vitals integration and sets up the necessary configurations.
+ *
+ * @param params - The parameters provided by the Astro configuration setup.
+ * @param opts - Options for configuring the Web Vitals integration.
+ * @param opts.name - The name of the Web Vitals integration.
+ * @param opts.verbose - A flag indicating whether to log verbose messages.
+ * @param opts.version - The minimum version of StudioCMS required for the Web Vitals integration.
+ *
+ * @returns A StudioCMSPlugin object if the Web Vitals integration is enabled, otherwise null.
+ */
+export declare const checkForWebVitals: import("astro-integration-kit").HookUtility<"astro:config:setup", [opts: {
+    name: string;
+    verbose: boolean;
+    version: string;
+}], StudioCMSPlugin | null>;

package/dist/lib/webVitals/checkForWebVitalsPlugin.js

@@ -0,0 +1,82 @@
+import {
+  addVirtualImports,
+  createResolver,
+  defineUtility,
+  hasIntegration
+} from "astro-integration-kit";
+import { integrationLogger } from "../../utils/integrationLogger.js";
+const webVitalsName = "@astrojs/web-vitals";
+const { resolve } = createResolver(import.meta.url);
+const checkForWebVitals = defineUtility("astro:config:setup")(
+  (params, opts) => {
+    integrationLogger(
+      { logger: params.logger, logLevel: "info", verbose: opts.verbose },
+      `Checking for '${webVitalsName}' integration...`
+    );
+    const enabled = hasIntegration(params, { name: webVitalsName });
+    if (enabled) {
+      integrationLogger(
+        { logger: params.logger, logLevel: "info", verbose: opts.verbose },
+        "Web Vitals Integration Found!"
+      );
+    } else {
+      integrationLogger(
+        { logger: params.logger, logLevel: "info", verbose: opts.verbose },
+        `Web Vitals integration not found. If you wish to use Web Vitals, please install the '${webVitalsName}' package.`
+      );
+    }
+    addVirtualImports(params, {
+      name: opts.name,
+      imports: {
+        "studiocms-dashboard:web-vitals": `
+					export * from "${resolve("./webVital.js")}"
+				`
+      }
+    });
+    const webVitalsPlugin = {
+      name: "Astro Web Vitals",
+      identifier: webVitalsName,
+      studiocmsMinimumVersion: opts.version,
+      dashboardGridItems: [
+        {
+          name: "core-web-vitals",
+          span: 2,
+          variant: "default",
+          header: {
+            title: "Core Web Vitals",
+            icon: "chart-pie"
+          },
+          body: {
+            html: "<corevitals></corevitals>",
+            components: {
+              corevitals: resolve("./dashboard-grid-items/CoreVitals.astro")
+            }
+          }
+        }
+      ],
+      dashboardPages: {
+        admin: [
+          {
+            title: {
+              "en-us": "Analytics and Vitals"
+            },
+            icon: "chart-pie",
+            route: "analytics",
+            description: "View the Core Web Vitals and Analytics of your site.",
+            sidebar: "single",
+            pageBodyComponent: resolve("./pages/analytics/body.astro"),
+            requiredPermissions: "admin"
+          }
+        ]
+      }
+    };
+    if (enabled) {
+      return webVitalsPlugin;
+    }
+    return null;
+  }
+);
+export {
+  checkForWebVitals,
+  webVitalsName
+};

package/dist/lib/webVitals/consts.d.ts

@@ -0,0 +1,240 @@
+import type { WebVitalsMetricType } from './schemas.js';
+import type { GetWebVitalsData } from './types.js';
+export declare const WEB_VITALS_METRIC_TABLE = "AstrojsWebVitals_Metric";
+export declare const CoreWebVitals: WebVitalsMetricType[];
+export declare const WEB_VITALS_METRIC_LABELS: Record<WebVitalsMetricType, string>;
+export declare const tsMetric: import("@astrojs/db/runtime").Table<"AstrojsWebVitals_Metric", {
+    pathname: {
+        type: "text";
+        schema: ({
+            name?: string | undefined;
+            label?: string | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+            default?: string | import("drizzle-orm").SQL<any> | undefined;
+            multiline?: boolean | undefined;
+        } & ({
+            optional?: boolean | undefined;
+            primaryKey?: false | undefined;
+        } | {
+            primaryKey: true;
+            optional?: false | undefined;
+        })) & {
+            references?: () => {
+                type: "text";
+                schema: ({
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    unique?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("drizzle-orm").SQL<any> | undefined;
+                    multiline?: boolean | undefined;
+                } & ({
+                    optional?: boolean | undefined;
+                    primaryKey?: false | undefined;
+                } | {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                })) & {
+                    references?: () => /*elided*/ any;
+                };
+            };
+        };
+    };
+    route: {
+        type: "text";
+        schema: ({
+            name?: string | undefined;
+            label?: string | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+            default?: string | import("drizzle-orm").SQL<any> | undefined;
+            multiline?: boolean | undefined;
+        } & ({
+            optional?: boolean | undefined;
+            primaryKey?: false | undefined;
+        } | {
+            primaryKey: true;
+            optional?: false | undefined;
+        })) & {
+            references?: () => {
+                type: "text";
+                schema: ({
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    unique?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("drizzle-orm").SQL<any> | undefined;
+                    multiline?: boolean | undefined;
+                } & ({
+                    optional?: boolean | undefined;
+                    primaryKey?: false | undefined;
+                } | {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                })) & {
+                    references?: () => /*elided*/ any;
+                };
+            };
+        };
+    };
+    name: {
+        type: "text";
+        schema: ({
+            name?: string | undefined;
+            label?: string | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+            default?: string | import("drizzle-orm").SQL<any> | undefined;
+            multiline?: boolean | undefined;
+        } & ({
+            optional?: boolean | undefined;
+            primaryKey?: false | undefined;
+        } | {
+            primaryKey: true;
+            optional?: false | undefined;
+        })) & {
+            references?: () => {
+                type: "text";
+                schema: ({
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    unique?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("drizzle-orm").SQL<any> | undefined;
+                    multiline?: boolean | undefined;
+                } & ({
+                    optional?: boolean | undefined;
+                    primaryKey?: false | undefined;
+                } | {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                })) & {
+                    references?: () => /*elided*/ any;
+                };
+            };
+        };
+    };
+    id: {
+        type: "text";
+        schema: {
+            primaryKey: true;
+        };
+    };
+    value: {
+        type: "number";
+        schema: ({
+            name?: string | undefined;
+            label?: string | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+        } & ({
+            optional?: boolean | undefined;
+            default?: number | import("drizzle-orm").SQL<any> | undefined;
+            primaryKey?: false | undefined;
+        } | {
+            primaryKey: true;
+            optional?: false | undefined;
+            default?: undefined;
+        })) & {
+            references?: () => {
+                type: "number";
+                schema: ({
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    unique?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    collection?: string | undefined;
+                } & ({
+                    optional?: boolean | undefined;
+                    default?: number | import("drizzle-orm").SQL<any> | undefined;
+                    primaryKey?: false | undefined;
+                } | {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                    default?: undefined;
+                })) & {
+                    references?: () => /*elided*/ any;
+                };
+            };
+        };
+    };
+    rating: {
+        type: "text";
+        schema: ({
+            name?: string | undefined;
+            label?: string | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+            default?: string | import("drizzle-orm").SQL<any> | undefined;
+            multiline?: boolean | undefined;
+        } & ({
+            optional?: boolean | undefined;
+            primaryKey?: false | undefined;
+        } | {
+            primaryKey: true;
+            optional?: false | undefined;
+        })) & {
+            references?: () => {
+                type: "text";
+                schema: ({
+                    name?: string | undefined;
+                    label?: string | undefined;
+                    unique?: boolean | undefined;
+                    deprecated?: boolean | undefined;
+                    collection?: string | undefined;
+                    default?: string | import("drizzle-orm").SQL<any> | undefined;
+                    multiline?: boolean | undefined;
+                } & ({
+                    optional?: boolean | undefined;
+                    primaryKey?: false | undefined;
+                } | {
+                    primaryKey: true;
+                    optional?: false | undefined;
+                })) & {
+                    references?: () => /*elided*/ any;
+                };
+            };
+        };
+    };
+    timestamp: {
+        type: "date";
+        schema: {
+            name?: string | undefined;
+            label?: string | undefined;
+            optional?: boolean | undefined;
+            unique?: boolean | undefined;
+            deprecated?: boolean | undefined;
+            collection?: string | undefined;
+            default?: Date | import("drizzle-orm").SQL<any> | undefined;
+        };
+    };
+}>;
+/**
+ * An object representing the default empty return value for web vitals data.
+ *
+ * @constant
+ * @type {GetWebVitalsData}
+ *
+ * @property {Array} raw - An empty array representing raw web vitals data.
+ * @property {Array} routeSummary - An empty array representing route summary data.
+ * @property {Object} summary - An empty object representing the summary of web vitals data.
+ * @property {Object} twentyFourHours - An object representing web vitals data for the last 24 hours.
+ * @property {Object} twentyFourHours.summary - An empty object representing the summary of web vitals data for the last 24 hours.
+ * @property {Array} twentyFourHours.routeSummary - An empty array representing route summary data for the last 24 hours.
+ * @property {Object} sevenDays - An object representing web vitals data for the last 7 days.
+ * @property {Object} sevenDays.summary - An empty object representing the summary of web vitals data for the last 7 days.
+ * @property {Array} sevenDays.routeSummary - An empty array representing route summary data for the last 7 days.
+ * @property {Object} thirtyDays - An object representing web vitals data for the last 30 days.
+ * @property {Object} thirtyDays.summary - An empty object representing the summary of web vitals data for the last 30 days.
+ * @property {Array} thirtyDays.routeSummary - An empty array representing route summary data for the last 30 days.
+ */
+export declare const EmptyReturn: GetWebVitalsData;

package/dist/lib/webVitals/consts.js

@@ -0,0 +1,40 @@
+import { column, defineTable } from "astro:db";
+import { asDrizzleTable } from "@astrojs/db/utils";
+const WEB_VITALS_METRIC_TABLE = "AstrojsWebVitals_Metric";
+const CoreWebVitals = ["LCP", "CLS", "INP"];
+const WEB_VITALS_METRIC_LABELS = {
+  LCP: "Largest Contentful Paint",
+  INP: "Interaction to Next Paint",
+  CLS: "Cumulative Layout Shift",
+  FCP: "First Contentful Paint",
+  FID: "First Input Delay",
+  TTFB: "Time to First Byte"
+};
+const Metric = defineTable({
+  columns: {
+    pathname: column.text(),
+    route: column.text(),
+    name: column.text(),
+    id: column.text({ primaryKey: true }),
+    value: column.number(),
+    rating: column.text(),
+    timestamp: column.date()
+  },
+  deprecated: Boolean(process.env.DEPRECATE_WEB_VITALS) ?? false
+});
+const tsMetric = asDrizzleTable(WEB_VITALS_METRIC_TABLE, Metric);
+const EmptyReturn = {
+  raw: [],
+  routeSummary: [],
+  summary: {},
+  twentyFourHours: { summary: {}, routeSummary: [] },
+  sevenDays: { summary: {}, routeSummary: [] },
+  thirtyDays: { summary: {}, routeSummary: [] }
+};
+export {
+  CoreWebVitals,
+  EmptyReturn,
+  WEB_VITALS_METRIC_LABELS,
+  WEB_VITALS_METRIC_TABLE,
+  tsMetric
+};