@revealui/core 0.0.1-pre.0

package/dist/core/targets/http/fetchPage.ts

@@ -0,0 +1,78 @@
+// import { cache } from "react";
+
+type Page = {
+  _id: string;
+  title: string;
+  content: string;
+  slug: string;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string;
+  publishedBy: string;
+  createdBy: string;
+  updatedBy: string;
+  isDeleted: boolean;
+  deletedAt: string;
+  deletedBy: string;
+  depth: number;
+  parent: string;
+  children: string[];
+  order: number;
+  status: string;
+  meta: {
+    title: string;
+    description: string;
+    keywords: string;
+    image: string;
+  };
+  _type: string;
+};
+
+// const cachedFetchPage = cache(async (slug: string) => {
+const cachedFetchPage = async (slug: string) => {
+  const response = await fetch(
+    `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/pages?where[slug][equals]=${slug}&depth=2`,
+    {
+      method: "GET",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    },
+  );
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch page data for slug: ${slug} - Status: ${response.status}`,
+    );
+  }
+  const pageData = await response.json();
+  return pageData.docs?.[0] ?? null;
+};
+const fetchPage = async (slug: string): Promise<Page | undefined | null> => {
+  try {
+    const page = await cachedFetchPage(slug);
+    return page;
+  } catch (error) {
+    console.error("Error fetching page data:", error);
+    return null;
+  }
+};
+
+export default fetchPage;
+
+// // import type { Page } from "../../payload/payload";
+
+// export const fetchPage = async (
+//   slug: string,
+// ): Promise<Page | undefined | null> => {
+//   const pageRes: {
+//     docs: Page[];
+//   } = await fetch(
+//     `${process.env.PUBLIC_ENV__PAYLOAD_PUBLIC_SERVER_URL}/api/pages?where[slug][equals]=${slug}&depth=2`,
+//     {
+//       method: "GET",
+//     },
+//   ).then((res) => res.json());
+
+//   return pageRes?.docs?.[0] ?? null;
+// };

package/dist/core/targets/http/fetchPages.ts

@@ -0,0 +1,70 @@
+// import { cache } from "react";
+
+type Page = {
+  _id: string;
+  title: string;
+  content: string;
+  slug: string;
+  createdAt: string;
+  updatedAt: string;
+  publishedAt: string;
+  publishedBy: string;
+  createdBy: string;
+  updatedBy: string;
+  isDeleted: boolean;
+  deletedAt: string;
+  deletedBy: string;
+  depth: number;
+  parent: string;
+  children: string[];
+  order: number;
+  status: string;
+  meta: {
+    title: string;
+    description: string;
+    keywords: string;
+    image: string;
+  };
+  _type: string;
+};
+
+// const fetchPagesCached = cache(async () => {
+const fetchPagesCached = async () => {
+  const response = await fetch(
+    // eslint-disable-next-line prettier/prettier
+    `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/pages?depth=0&limit=100`,
+    {
+      method: "GET",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+      },
+    },
+  );
+  if (!response.ok) {
+    throw new Error(`HTTP error! status: ${response.status}`);
+  }
+  const pageData = await response.json();
+  return pageData.docs ?? [];
+};
+const fetchPages = async (): Promise<Page[]> => {
+  try {
+    const pages = await fetchPagesCached();
+    return pages;
+  } catch (error) {
+    console.error("Failed to fetch pages:", error);
+    return [];
+  }
+};
+
+export default fetchPages;
+
+// export const fetchPages = async (): Promise<Page[]> => {
+//   const pageRes: {
+//     docs: Page[];
+//   } = await fetch(
+//     `${import.meta.env.PUBLIC_ENV__PAYLOAD_PUBLIC_SERVER_URL}/api/pages?depth=0&limit=100`,
+//   ).then((res) => res.json());
+
+//   return pageRes?.docs ?? [];
+// };

package/dist/core/targets/http/fetchVideos.ts

@@ -0,0 +1,26 @@
+const fetchVideos = async () => {
+  try {
+    const response = await fetch(
+      `${process.env.PAYLOAD_PUBLIC_SERVER_URL}/api/videos`,
+      {
+        method: "GET",
+        credentials: "include",
+        headers: {
+          "Content-Type": "application/json",
+        },
+      },
+    );
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! Status: ${response.status}`);
+    }
+    const data = await response.json();
+
+    return data;
+  } catch (error) {
+    console.error("Failed to fetch videos:", error);
+    return [];
+  }
+};
+
+export default fetchVideos;

package/dist/core/targets/http/fetchYouTube.ts

@@ -0,0 +1,90 @@
+// import { cache } from "react";
+
+// const fetchYouTubeData = cache(
+const fetchYouTubeData = async ({
+  endpoint,
+  params,
+}: {
+  endpoint: string;
+  params: Record<string, string>;
+}) => {
+  const defaultParams = {
+    part: "snippet",
+    type: "video",
+    maxResults: "5",
+    key: `${process.env.YOUTUBE_API_KEY}`,
+  };
+
+  const combinedParams = { ...defaultParams, ...params };
+  const queryString = new URLSearchParams(combinedParams).toString();
+  const url = `${process.env.YOUTUBE_BASE_URL}/${endpoint}?${queryString}`;
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`HTTP error: ${response.status}`);
+  }
+  return response.json();
+};
+
+const fetchYouTube = async ({
+  endpoint,
+  params,
+}: {
+  endpoint: string;
+  params: Record<string, string>;
+}) => {
+  try {
+    return await fetchYouTubeData({ endpoint, params });
+  } catch (error) {
+    console.error(`Fetch error for YouTube API: ${error}`);
+    throw error; // Rethrow or handle as needed
+  }
+};
+
+export default fetchYouTube;
+
+// const VITE_YOUTUBE_API_KEY = import.meta.env.VITE_YOUTUBE_API_KEY_KEY; // Make sure to define your API key in your environment variables
+// const VITE_YOUTUBE_BASE_URL = "https://www.googleapis.com/youtube/v3";
+
+// const youtubeFetch = async ({
+//   endpoint,
+//   params,
+// }: {
+//   endpoint: string;
+//   params: Record<string, string>;
+// }) => {
+//   // Default params that will be used with every request
+//   const defaultParams = {
+//     part: "snippet",
+//     type: "video",
+//     maxResults: 5,
+//     key: VITE_YOUTUBE_API_KEY,
+//   };
+
+//   // Combine the default parameters with the ones passed to the function
+//   const combinedParams = {
+//     ...defaultParams,
+//     ...params,
+//   };
+
+//   // Construct query string from parameters object
+//   const queryString = new URLSearchParams(String(combinedParams));
+
+//   // Construct the full URL
+//   const url = `${VITE_YOUTUBE_BASE_URL}/${endpoint}?${queryString}`;
+
+//   // Make the fetch request
+//   try {
+//     const response = await fetch(url);
+//     if (!response.ok) {
+//       throw new Error(`HTTP error: ${response.status}`);
+//     }
+//     const data = await response.json();
+//     return data;
+//   } catch (error) {
+//     // You can add more sophisticated error handling here
+//     throw new Error(`Fetch error: ${error}`);
+//   }
+// };
+
+// export default youtubeFetch;

package/dist/core/targets/server/entry.ts

@@ -0,0 +1,43 @@
+assertServerRouting();
+
+import { assertServerRouting } from "../../gaurds/assertions/assertRoutingType/index.js";
+import { onClientEntryServerRouting } from "../../gaurds/assertions/assertSingleInstance/index.js";
+import { assertHook } from "../../processing/getters/getHook.js";
+import { getPageContext } from "../../processing/getters/getPageContext.js";
+import {
+  From,
+  Source,
+  Sources,
+} from "../../processing/getters/getPageFiles/getExports.js";
+import { executeOnRenderClientHook } from "../client/executeOnRenderClientHook.js";
+import { removeFoucBuster } from "../client/removeFoucBuster.js";
+import "./pageFiles.js";
+// import { assertSingleInstance_onClientEntryServerRouting } from "./utils.js";
+// @ts-ignore Since dist/cjs/client/ is never used, we can ignore this error.
+const isProd: boolean = import.meta.env.PROD;
+onClientEntryServerRouting(isProd);
+
+if (import.meta.env.DEV) removeFoucBuster();
+
+hydrate();
+
+async function hydrate() {
+  const pageContext = {
+    ...(await getPageContext()),
+    config: {
+      pageId: "defaultPageId", // Add appropriate pageId here
+      configValues: {}, // Add appropriate config values here
+      loadConfigValuesAll: async () => ({
+        configValuesSerialized: {}, // Add appropriate serialized config values here
+      }), // Implement this function as needed
+      Page: {},
+    },
+    _pageConfigs: [], // Add appropriate page configs here
+    source: {} as Source, // Add appropriate source value here
+    sources: {} as Sources, // Add appropriate sources value here
+    from: {} as From, // Add appropriate from value here
+  };
+  await executeOnRenderClientHook(pageContext, false);
+  assertHook(pageContext, "onHydrationEnd");
+  await pageContext.exports.onHydrationEnd?.(pageContext);
+}

package/dist/core/targets/server/middleware/addSsrMiddleware.ts

@@ -0,0 +1,52 @@
+export { addSsrMiddleware };
+
+import type { ResolvedConfig, ViteDevServer } from "vite";
+
+import { renderPage } from "../../../renderer/page/index.js";
+
+type ConnectServer = ViteDevServer["middlewares"];
+
+function addSsrMiddleware(
+  middlewares: ConnectServer,
+  config: ResolvedConfig,
+  isPreview: boolean,
+) {
+  middlewares.use(async (req, res, next) => {
+    if (res.headersSent) return next();
+    const url = req.originalUrl || req.url;
+    if (!url) return next();
+    const { headers } = req;
+    const pageContextInit = {
+      urlOriginal: url,
+      headersOriginal: headers,
+    };
+    let pageContext: Awaited<ReturnType<typeof renderPage>>;
+    try {
+      pageContext = await renderPage(pageContextInit);
+    } catch (err) {
+      // Throwing an error in a connect middleware shut downs the server
+      console.error(err);
+      // - next(err) automatically uses buildErrorMessage() (pretty formatting of Rollup errors)
+      //   - But it only works for users using Vite's standalone dev server (it doesn't work for users using Vite's dev middleware)
+      // - We purposely don't use next(err) to align behavior: we use our own/copied implementation of buildErrorMessage() regardless of whether the user uses Vite's dev middleware or Vite's standalone dev server
+      return next();
+    }
+
+    const configHeaders =
+      (isPreview && config?.preview?.headers) || config?.server?.headers;
+    if (configHeaders) {
+      for (const [name, value] of Object.entries(configHeaders) as [
+        string,
+        string,
+      ][])
+        if (value) res.setHeader(name, value);
+    }
+
+    const { httpResponse } = pageContext;
+    httpResponse.headers.forEach(([name, value]: [string, string]) =>
+      res.setHeader(name, value),
+    );
+    res.statusCode = httpResponse.statusCode;
+    httpResponse.pipe(res);
+  });
+}

package/dist/core/targets/server/onLoad.ts

@@ -0,0 +1,7 @@
+import { assertIsBrowser } from "../../gaurds/assertions/assertIsBrowser";
+
+export { onLoad };
+
+function onLoad() {
+  assertIsBrowser();
+}

package/dist/core/targets/server/pageFiles.ts

@@ -0,0 +1,4 @@
+import { setPageFiles } from "../../processing/getters/getPageFiles/index.js";
+// @ts-ignore
+import * as pageFilesExports from "virtual:reveal:importUserCode:client:server-routing";
+setPageFiles(pageFilesExports);

package/dist/core/targets/server/root.ts

@@ -0,0 +1,10 @@
+export { root };
+
+// https://stackoverflow.com/questions/46745014/alternative-for-dirname-in-node-when-using-the-experimental-modules-flag/50052194#50052194
+
+import path from "path";
+import { fileURLToPath } from "url";
+
+const filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(filename);
+const root = `${dirname}/..`;

package/dist/core/targets/server/utils.ts

@@ -0,0 +1,20 @@
+// Utils needed by Server Routing.
+
+// We assume all runtime entries will load this utils.ts file
+import { onLoad } from "./onLoad.js";
+onLoad();
+
+export * from "../../gaurds/assertions/assertSingleInstance/index.js";
+export * from "../../gaurds/assertions/checkType.js"; // Only used by Server Routing (not needed for Client Routing)
+export * from "../../gaurds/validators/hasProp.js";
+export * from "../../gaurds/validators/isCallable.js";
+export * from "../../gaurds/validators/isObject.js";
+export * from "../../hooks/executeHook.js";
+export * from "../../processing/getters/getPropAccessNotation.js";
+export * from "../../targets/url/parseUrl.js";
+export * from "../../utils/array/slice.js";
+export * from "../../utils/array/unique.js"; // Only used by Server Routing (not needed for Client Routing)
+export * from "../../gaurds/assertions/assert/index.js";
+export * from "../../processing/getters/getCurrentUrl.js";
+export * from "../../processing/getters/getGlobalObject.js";
+export * from "../../utils/object/objectAssign.js";