studiocms 0.1.0-beta.10

package/dist/lib/webVitals/utils/webVitalsUtils.js

@@ -0,0 +1,234 @@
+function msToSeconds(ms) {
+  return ms / 1e3;
+}
+function calculateClsAverage(clsValues) {
+  const sum = clsValues.reduce((acc, curr) => acc + curr, 0);
+  const average = sum / clsValues.length;
+  return Math.round(average * 100) / 100;
+}
+const clsDataAverage = (webVitalData) => {
+  const clsData = [];
+  if (webVitalData) {
+    for (const item of webVitalData) {
+      if (item.name === "CLS") {
+        clsData.push(item.value);
+      }
+    }
+  }
+  return calculateClsAverage(clsData);
+};
+function calculateClsScoreText(cls) {
+  if (cls <= 0.1) {
+    return "Excellent";
+  }
+  if (cls <= 0.25) {
+    return "Good";
+  }
+  if (cls <= 0.5) {
+    return "Fair";
+  }
+  return "Poor";
+}
+function calculateClsScorePercent(cls) {
+  if (cls <= 0.1) {
+    return 100;
+  }
+  if (cls <= 0.25) {
+    return Math.round(100 - (cls - 0.1) / (0.25 - 0.1) * 25);
+  }
+  if (cls <= 0.5) {
+    return Math.round(75 - (cls - 0.25) / (0.5 - 0.25) * 25);
+  }
+  return Math.round(50 - (cls - 0.5) / (1 - 0.5) * 50);
+}
+const progressBarClsColor = (clsData) => {
+  if (clsData <= 0.25) {
+    return "green";
+  }
+  if (clsData > 0.25 && clsData <= 0.5) {
+    return "yellow";
+  }
+  return "red";
+};
+const progressBarClsTrackColor = (clsData) => {
+  if (clsData <= 0.25) {
+    return "yellow";
+  }
+  if (clsData > 0.25) {
+    return "red";
+  }
+  return "red";
+};
+const clsTextColor = (clsData) => {
+  if (clsData <= 0.25) {
+    return "green";
+  }
+  if (clsData > 0.25 && clsData <= 0.5) {
+    return "yellow";
+  }
+  return "red";
+};
+function calculateLcpAverage(lcpValues) {
+  const sum = lcpValues.reduce((acc, curr) => acc + curr, 0);
+  const average = sum / lcpValues.length;
+  return Math.floor(Math.round(average * 100) / 100);
+}
+const lcpDataAverage = (webVitalData) => {
+  const lcpData = [];
+  if (webVitalData) {
+    for (const item of webVitalData) {
+      if (item.name === "LCP") {
+        lcpData.push(item.value);
+      }
+    }
+  }
+  return calculateLcpAverage(lcpData);
+};
+function calculateLcpScoreText(lcp) {
+  if (msToSeconds(lcp) <= 2) {
+    return "Excellent";
+  }
+  if (msToSeconds(lcp) <= 4) {
+    return "Good";
+  }
+  if (msToSeconds(lcp) <= 6) {
+    return "Fair";
+  }
+  return "Poor";
+}
+function calculateLcpScorePercent(lcp) {
+  if (msToSeconds(lcp) <= 2) {
+    return 100;
+  }
+  if (msToSeconds(lcp) <= 4) {
+    return Math.round(100 - (lcp - 2) / (4 - 2) * 50);
+  }
+  if (msToSeconds(lcp) <= 6) {
+    return Math.round(50 - (lcp - 4) / (6 - 4) * 50);
+  }
+  return Math.round(0 - (lcp - 6) / (10 - 6) * 50);
+}
+const progressBarLcpColor = (lcpData) => {
+  if (msToSeconds(lcpData) <= 2.5) {
+    return "green";
+  }
+  if (msToSeconds(lcpData) > 2.5 && lcpData <= 4) {
+    return "yellow";
+  }
+  return "red";
+};
+const progressBarLcpTrackColor = (lcpData) => {
+  if (msToSeconds(lcpData) <= 2.5) {
+    return "yellow";
+  }
+  if (msToSeconds(lcpData) > 2.5) {
+    return "red";
+  }
+  return "red";
+};
+const lcpTextColor = (lcpData) => {
+  if (msToSeconds(lcpData) <= 2.5) {
+    return "green";
+  }
+  if (msToSeconds(lcpData) > 2.5 && lcpData <= 4) {
+    return "yellow";
+  }
+  return "red";
+};
+function calculateInpAverage(inpValues) {
+  const sum = inpValues.reduce((acc, curr) => acc + curr, 0);
+  const average = sum / inpValues.length;
+  return Math.round(average * 100) / 100;
+}
+function inpDataAverage(webVitalData) {
+  const inpData = [];
+  if (webVitalData) {
+    for (const item of webVitalData) {
+      if (item.name === "INP") {
+        inpData.push(item.value);
+      }
+    }
+  }
+  return Math.floor(calculateInpAverage(inpData));
+}
+function calculateInpScoreText(inp) {
+  if (inp <= 50) {
+    return "Excellent";
+  }
+  if (inp <= 100) {
+    return "Good";
+  }
+  if (inp <= 200) {
+    return "Fair";
+  }
+  return "Poor";
+}
+function calculateInpScorePercent(inp) {
+  if (inp <= 50) {
+    return 100;
+  }
+  if (inp <= 100) {
+    return Math.round(100 - (inp - 50) / (100 - 50) * 50);
+  }
+  if (inp <= 200) {
+    return Math.round(50 - (inp - 100) / (200 - 100) * 50);
+  }
+  return Math.round(0 - (inp - 200) / (300 - 200) * 50);
+}
+const progressBarInpColor = (inpData) => {
+  if (inpData <= 100) {
+    return "green";
+  }
+  if (inpData > 100 && inpData <= 200) {
+    return "yellow";
+  }
+  return "red";
+};
+const progressBarInpTrackColor = (inpData) => {
+  if (inpData <= 100) {
+    return "yellow";
+  }
+  if (inpData > 100) {
+    return "red";
+  }
+  return "red";
+};
+const inpTextColor = (inpData) => {
+  if (inpData <= 100) {
+    return "green";
+  }
+  if (inpData > 100 && inpData <= 200) {
+    return "yellow";
+  }
+  return "red";
+};
+function generateLighthouseFetchUrl(url, strategy = "mobile") {
+  const baseUrl = "https://www.googleapis.com/pagespeedonline/v5/runPagespeed";
+  const fetchUrl = `${baseUrl}?url=${encodeURIComponent(url)}&fields=lighthouseResult%2Fcategories%2F*%2Fscore&prettyPrint=false&strategy=${strategy}&category=performance&category=pwa&category=best-practices&category=accessibility&category=seo`;
+  return fetchUrl;
+}
+export {
+  calculateClsAverage,
+  calculateClsScorePercent,
+  calculateClsScoreText,
+  calculateInpAverage,
+  calculateInpScorePercent,
+  calculateInpScoreText,
+  calculateLcpAverage,
+  calculateLcpScorePercent,
+  calculateLcpScoreText,
+  clsDataAverage,
+  clsTextColor,
+  generateLighthouseFetchUrl,
+  inpDataAverage,
+  inpTextColor,
+  lcpDataAverage,
+  lcpTextColor,
+  msToSeconds,
+  progressBarClsColor,
+  progressBarClsTrackColor,
+  progressBarInpColor,
+  progressBarInpTrackColor,
+  progressBarLcpColor,
+  progressBarLcpTrackColor
+};

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

@@ -0,0 +1,20 @@
+import type { GetWebVitalsData, IntermediateWebVitalsRouteSummary, MetricStats, WebVitalsMetricSummary, WebVitalsResponseItem, WebVitalsRouteSummary, WebVitalsSummary } from './types.js';
+export type { WebVitalsResponseItem, IntermediateWebVitalsRouteSummary, MetricStats, WebVitalsMetricSummary, WebVitalsRouteSummary, WebVitalsSummary, GetWebVitalsData, };
+/**
+ * Fetches web vitals data from the Astro database.
+ *
+ * @returns {Promise<GetWebVitalsData>} A promise that resolves to an object containing web vitals data.
+ *
+ * The returned object contains the following properties:
+ * - `raw`: The raw web vitals data.
+ * - `routeSummary`: A summary of web vitals data by route.
+ * - `summary`: A general summary of web vitals data.
+ * - `twentyFourHours`: An object containing web vitals data for the last 24 hours, with `summary` and `routeSummary` properties.
+ * - `sevenDays`: An object containing web vitals data for the last 7 days, with `summary` and `routeSummary` properties.
+ * - `thirtyDays`: An object containing web vitals data for the last 30 days, with `summary` and `routeSummary` properties.
+ *
+ * If the web vitals metric table is not found in the Astro database, or if an error occurs, an empty return object is returned.
+ *
+ * @throws {Error} If there is an issue with fetching or processing the web vitals data.
+ */
+export declare function getWebVitals(): Promise<GetWebVitalsData>;

package/dist/lib/webVitals/webVital.js

@@ -0,0 +1,40 @@
+import studioCMS_SDK from "studiocms:sdk";
+import { EmptyReturn, WEB_VITALS_METRIC_TABLE, tsMetric } from "./consts.js";
+import { checkDate } from "./utils/checkDate.js";
+import { processWebVitalsRouteSummary } from "./webVitalsRouteSummary.js";
+import { processWebVitalsSummary } from "./webVitalsSummary.js";
+async function getWebVitals() {
+  try {
+    const AstroDB = await import("astro:db");
+    if (WEB_VITALS_METRIC_TABLE in AstroDB) {
+      if (AstroDB.AstrojsWebVitals_Metric) {
+        const raw = await studioCMS_SDK.db.select().from(tsMetric);
+        const last24HoursData = raw.filter((item) => checkDate(item.timestamp).isInLast24Hours());
+        const last7DaysData = raw.filter((item) => checkDate(item.timestamp).isInLast7Days());
+        const last30DaysData = raw.filter((item) => checkDate(item.timestamp).isInLast30Days());
+        const routeSummary = processWebVitalsRouteSummary(raw);
+        const summary = processWebVitalsSummary(raw);
+        const twentyFourHours = {
+          summary: processWebVitalsSummary(last24HoursData),
+          routeSummary: processWebVitalsRouteSummary(last24HoursData)
+        };
+        const sevenDays = {
+          summary: processWebVitalsSummary(last7DaysData),
+          routeSummary: processWebVitalsRouteSummary(last7DaysData)
+        };
+        const thirtyDays = {
+          summary: processWebVitalsSummary(last30DaysData),
+          routeSummary: processWebVitalsRouteSummary(last30DaysData)
+        };
+        return { raw, routeSummary, summary, twentyFourHours, sevenDays, thirtyDays };
+      }
+      return EmptyReturn;
+    }
+    return EmptyReturn;
+  } catch (error) {
+    return EmptyReturn;
+  }
+}
+export {
+  getWebVitals
+};

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

@@ -0,0 +1,19 @@
+import type { WebVitalsResponseItem, WebVitalsRouteSummary } from './types.js';
+/**
+ * Processes an array of Web Vitals response items and returns a summary of web vitals for each route.
+ *
+ * @param data - An array of WebVitalsResponseItem objects representing the web vitals data.
+ * @returns An array of WebVitalsRouteSummary objects summarizing the web vitals for each route.
+ *
+ * The function performs the following steps:
+ * 1. Groups the data by route and name.
+ * 2. Processes each group separately, ensuring the sample size is at least 4.
+ * 3. Sorts the metrics within each group by rating and value.
+ * 4. Assigns quartiles to the metrics using NTILE(4) logic.
+ * 5. Identifies the end of each quartile.
+ * 6. Selects only the metrics in quartile 3 where quartile_end is true.
+ * 7. Converts the selected metrics into WebVitalsRouteSummary structures.
+ *
+ * The resulting summaries include the route, whether the route passes core web vitals, the metrics for LCP, CLS, and INP, and a score.
+ */
+export declare function processWebVitalsRouteSummary(data: WebVitalsResponseItem[]): WebVitalsRouteSummary[];

package/dist/lib/webVitals/webVitalsRouteSummary.js

@@ -0,0 +1,59 @@
+function processWebVitalsRouteSummary(data) {
+  const grouped = data.reduce(
+    (acc, item) => {
+      const key = `${item.route}-${item.name}`;
+      if (!acc[key]) acc[key] = [];
+      acc[key].push(item);
+      return acc;
+    },
+    {}
+  );
+  const results = [];
+  for (const metrics of Object.values(grouped)) {
+    if (metrics.length < 4) continue;
+    metrics.sort((a, b) => a.rating.localeCompare(b.rating) || a.value - b.value);
+    const quartileSize = Math.ceil(metrics.length / 4);
+    metrics.forEach((metric, index) => {
+      metric.quartile = Math.floor(index / quartileSize) + 1;
+    });
+    metrics.forEach((metric, index, arr) => {
+      const nextItem = arr[index + 1];
+      metric.quartile_end = !nextItem || nextItem.quartile !== metric.quartile;
+    });
+    results.push(...metrics.filter((metric) => metric.quartile === 3 && metric.quartile_end));
+  }
+  const summaries = {};
+  for (const item of results) {
+    const { route, name, rating, value } = item;
+    const routeSummary = summaries[route] ||= {
+      route,
+      passingCoreWebVitals: true,
+      metrics: {},
+      score: 0
+    };
+    routeSummary.metrics[name] = {
+      rating,
+      value,
+      sampleSize: results.length
+    };
+    if (["LCP", "CLS", "INP"].includes(name) && rating !== "good") {
+      routeSummary.passingCoreWebVitals = false;
+    }
+  }
+  return Object.values(summaries).filter(
+    (route) => Boolean(route.metrics.CLS && route.metrics.LCP && route.metrics.INP)
+  ).map((route) => ({
+    ...route,
+    score: simpleScore(
+      route.metrics.LCP.rating,
+      route.metrics.CLS.rating,
+      route.metrics.INP.rating
+    )
+  })).sort((a, b) => a.score - b.score);
+}
+const weighting = { LCP: 0.4, CLS: 0.3, INP: 0.3 };
+const scoring = { good: 1, "needs-improvement": 0.5, poor: 0 };
+const simpleScore = (lcpRating, clsRating, inpRating) => scoring[lcpRating] * weighting.LCP + scoring[clsRating] * weighting.CLS + scoring[inpRating] * weighting.INP;
+export {
+  processWebVitalsRouteSummary
+};

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

@@ -0,0 +1,19 @@
+import type { WebVitalsResponseItem, WebVitalsSummary } from './types.js';
+/**
+ * Processes an array of web vitals response items and generates a summary.
+ *
+ * @param data - An array of `WebVitalsResponseItem` objects to be processed.
+ * @returns A `WebVitalsSummary` object containing the processed summary.
+ *
+ * The function performs the following steps:
+ * 1. Groups the input data by the `name` property.
+ * 2. Processes each metric group separately.
+ * 3. Sorts the metrics within each group by `rating` and `value`.
+ * 4. Assigns quartiles to each metric.
+ * 5. Identifies the end of each rating group.
+ * 6. Computes the sample size for each metric group.
+ * 7. Computes histogram densities for each rating.
+ * 8. Computes the 75th percentile (P75) for each metric group.
+ * 9. Filters the final results based on specific conditions.
+ */
+export declare function processWebVitalsSummary(data: WebVitalsResponseItem[]): WebVitalsSummary;

package/dist/lib/webVitals/webVitalsSummary.js

@@ -0,0 +1,49 @@
+function processWebVitalsSummary(data) {
+  const grouped = data.reduce(
+    (acc, item) => {
+      if (!acc[item.name]) acc[item.name] = [];
+      acc[item.name].push(item);
+      return acc;
+    },
+    {}
+  );
+  const summary = {};
+  for (const [metricName, metrics] of Object.entries(grouped)) {
+    if (metrics.length < 4) continue;
+    metrics.sort((a, b) => a.rating.localeCompare(b.rating) || a.value - b.value);
+    const quartileSize = Math.ceil(metrics.length / 4);
+    for (let i = 0; i < metrics.length; i++) {
+      metrics[i].quartile = Math.floor(i / quartileSize) + 1;
+    }
+    for (let i = 0; i < metrics.length; i++) {
+      const nextItem = metrics[i + 1];
+      metrics[i].rating_end = !nextItem || nextItem.rating !== metrics[i].rating;
+    }
+    const sampleSize = metrics.length;
+    const histogram = {
+      good: 0,
+      "needs-improvement": 0,
+      poor: 0
+    };
+    for (let i = 0; i < metrics.length; i++) {
+      if (metrics[i].rating_end) {
+        const ratingCount = metrics.filter((m) => m.rating === metrics[i].rating).length;
+        histogram[metrics[i].rating] = ratingCount / sampleSize;
+      }
+    }
+    const p75Index = Math.floor(metrics.length * 0.75);
+    const p75Metric = metrics[p75Index] || null;
+    const percentiles = p75Metric ? { p75: { value: p75Metric.value, rating: p75Metric.rating } } : {};
+    const finalMetrics = metrics.filter(
+      // biome-ignore lint/style/noNonNullAssertion: <explanation>
+      (metric) => metric.rating_end || metric.quartile * 25 === 75
+    );
+    if (finalMetrics.length > 0) {
+      summary[metricName] = { histogram, percentiles, sampleSize };
+    }
+  }
+  return summary;
+}
+export {
+  processWebVitalsSummary
+};

package/dist/plugins.d.ts

@@ -0,0 +1,2 @@
+import { type AvailableDashboardPages, type DashboardPage, type FinalDashboardPage, type SafePluginListType, type SettingsField, type StudioCMSPlugin, type StudioCMSPluginOptions, definePlugin } from './schemas/index.js';
+export { type SettingsField, type SafePluginListType, type StudioCMSPlugin, type StudioCMSPluginOptions, type AvailableDashboardPages, type FinalDashboardPage, type DashboardPage, definePlugin, };

package/dist/plugins.js

@@ -0,0 +1,6 @@
+import {
+  definePlugin
+} from "./schemas/index.js";
+export {
+  definePlugin
+};

package/dist/renderer.d.ts

@@ -0,0 +1,23 @@
+declare module 'studiocms:renderer/config' {
+	const config: import('./schemas/config/rendererConfig.ts').StudioCMSRendererConfig;
+	export default config;
+}
+
+declare module 'studiocms:renderer/astroMarkdownConfig' {
+	const config: import('astro').AstroConfig['markdown'];
+	export default config;
+}
+
+declare module 'studiocms:renderer' {
+	export const StudioCMSRenderer: typeof import('./components/Renderer.astro').default;
+}
+
+declare module 'studiocms:renderer/current' {
+	const deModule: typeof import('./lib/renderer/contentRenderer.js').default;
+	export default deModule;
+	export const contentRenderer: typeof import('./lib/renderer/contentRenderer.js').contentRenderer;
+}
+
+declare module 'studiocms:component-proxy' {
+	export const componentKeys: string[];
+}

package/dist/routes/api/render.astro

@@ -0,0 +1,25 @@
+---
+export const partial = true;
+import { StudioCMSRenderer } from 'studiocms:renderer';
+
+type Content = string;
+
+const queryParam = Astro.url.searchParams.get('content');
+
+async function setContent() {
+	const jsonData: { content: string | undefined } | undefined = await Astro.request.json();
+
+	if (jsonData?.content) {
+		return jsonData.content;
+	}
+
+	if (queryParam && queryParam !== 'null') {
+		return queryParam;
+	}
+
+	return 'No content to display';
+}
+
+const content: Content = await setContent();
+---
+<StudioCMSRenderer {content} />

package/dist/routes/auth/api/auth0/callback.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/auth0/callback.js

@@ -0,0 +1,117 @@
+import { createUserSession } from "studiocms:auth/lib/session";
+import { LinkNewOAuthCookieName, createOAuthUser, getUserData } from "studiocms:auth/lib/user";
+import { config } from "studiocms:config";
+import { StudioCMSRoutes } from "studiocms:lib";
+import studioCMS_SDK from "studiocms:sdk";
+import { OAuth2RequestError } from "arctic";
+import {
+  ProviderCookieName,
+  ProviderID,
+  auth0,
+  getClientDomain
+} from "./shared.js";
+const GET = async (context) => {
+  const { url, cookies, redirect } = context;
+  const code = url.searchParams.get("code");
+  const state = url.searchParams.get("state");
+  const storedState = cookies.get(ProviderCookieName)?.value ?? null;
+  const CLIENT_DOMAIN = getClientDomain();
+  if (!code || !state || !storedState || state !== storedState) {
+    return redirect(StudioCMSRoutes.authLinks.loginURL);
+  }
+  let tokens;
+  try {
+    tokens = await auth0.validateAuthorizationCode(code);
+    const auth0Response = await fetch(`${CLIENT_DOMAIN}/userinfo`, {
+      headers: {
+        Authorization: `Bearer ${tokens.accessToken}`
+      }
+    });
+    const auth0User = await auth0Response.json();
+    const auth0UserId = auth0User.sub;
+    const auth0Username = auth0User.nickname;
+    const existingOAuthAccount = await studioCMS_SDK.AUTH.oAuth.searchProvidersForId(
+      ProviderID,
+      auth0UserId
+    );
+    if (existingOAuthAccount) {
+      const user = await studioCMS_SDK.GET.databaseEntry.users.byId(existingOAuthAccount.userId);
+      if (!user) {
+        return new Response("User not found", {
+          status: 404
+        });
+      }
+      await createUserSession(user.id, context);
+      return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+    }
+    const loggedInUser = await getUserData(context);
+    const linkNewOAuth = !!cookies.get(LinkNewOAuthCookieName)?.value;
+    if (loggedInUser.user && linkNewOAuth) {
+      const existingUser = await studioCMS_SDK.GET.databaseEntry.users.byId(loggedInUser.user.id);
+      if (existingUser) {
+        await studioCMS_SDK.AUTH.oAuth.create({
+          userId: existingUser.id,
+          provider: ProviderID,
+          providerUserId: auth0UserId
+        });
+        await createUserSession(existingUser.id, context);
+        return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+      }
+    }
+    const newUser = await createOAuthUser(
+      {
+        id: crypto.randomUUID(),
+        username: auth0Username,
+        name: auth0User.name,
+        email: auth0User.email,
+        avatar: auth0User.picture,
+        createdAt: /* @__PURE__ */ new Date()
+      },
+      { provider: ProviderID, providerUserId: auth0UserId }
+    );
+    if ("error" in newUser) {
+      return new Response("Error creating user", { status: 500 });
+    }
+    if (config.dbStartPage) {
+      return redirect("/done");
+    }
+    await createUserSession(newUser.id, context);
+    return redirect(StudioCMSRoutes.mainLinks.dashboardIndex);
+  } catch (e) {
+    if (e instanceof OAuth2RequestError) {
+      const code2 = e.code;
+      return new Response(code2, {
+        status: 400
+      });
+    }
+    return new Response(null, {
+      status: 500
+    });
+  }
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/auth0/index.d.ts

@@ -0,0 +1,4 @@
+import type { APIRoute } from 'astro';
+export declare const GET: APIRoute;
+export declare const OPTIONS: APIRoute;
+export declare const ALL: APIRoute;

package/dist/routes/auth/api/auth0/index.js

@@ -0,0 +1,36 @@
+import { setOAuthSessionTokenCookie } from "studiocms:auth/lib/session";
+import { generateState } from "arctic";
+import { ProviderCookieName, auth0 } from "./shared.js";
+const GET = async (context) => {
+  const state = generateState();
+  const scopes = ["profile", "email"];
+  const url = auth0.createAuthorizationURL(state, scopes);
+  setOAuthSessionTokenCookie(context, ProviderCookieName, state);
+  return context.redirect(url.toString());
+};
+const OPTIONS = async () => {
+  return new Response(null, {
+    status: 204,
+    statusText: "No Content",
+    headers: {
+      Allow: "OPTIONS, GET",
+      "ALLOW-ACCESS-CONTROL-ORIGIN": "*",
+      "Cache-Control": "public, max-age=604800, immutable",
+      Date: (/* @__PURE__ */ new Date()).toUTCString()
+    }
+  });
+};
+const ALL = async () => {
+  return new Response(null, {
+    status: 405,
+    statusText: "Method Not Allowed",
+    headers: {
+      "ACCESS-CONTROL-ALLOW-ORIGIN": "*"
+    }
+  });
+};
+export {
+  ALL,
+  GET,
+  OPTIONS
+};

package/dist/routes/auth/api/auth0/shared.d.ts

@@ -0,0 +1,13 @@
+import { Auth0 } from 'arctic';
+export declare const CLIENT_ID: string, CLIENT_SECRET: string, DOMAIN: string | undefined, REDIRECT_URI: string;
+export declare const getClientDomain: () => string;
+export declare const ProviderID = "auth0";
+export declare const ProviderCookieName = "auth0_oauth_state";
+export declare const auth0: Auth0;
+export interface Auth0User {
+    sub: string;
+    name: string;
+    email: string;
+    picture: string;
+    nickname: string;
+}