@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getPageContextRequestUrl.ts

@@ -0,0 +1,22 @@
+export {
+  doNotCreateExtraDirectory,
+  getPageContextRequestUrl,
+  pageContextJsonFileExtension,
+}
+
+// This module isn't loaded by the client-side of Server Routing => we don't inlcude `urlToFile` to `./utils.ts`
+import { urlToFile } from "../../targets/url/urlToFile.js"
+
+const pageContextJsonFileExtension = ".pageContext.json"
+// `/some-base-url/index.pageContext.json` instead of `/some-base-url.pageContext.json` in order to comply to common reverse proxy setups, see https://github.com/revealjs/reveal/issues/443
+const doNotCreateExtraDirectory = false
+
+// See node/renderPage/handlePageContextRequestUrl.ts
+function getPageContextRequestUrl(url: string): string {
+  const pageContextRequestUrl = urlToFile(
+    url,
+    pageContextJsonFileExtension,
+    doNotCreateExtraDirectory
+  )
+  return pageContextRequestUrl
+}

package/dist/core/processing/getters/getPageContextSerializedInHtml.ts

@@ -0,0 +1,32 @@
+// import { parse } from "@brillout/json-serializer/parse";
+import { assert } from "../../gaurds/assertions/assert/base.js"
+import { assertUsage } from "../../gaurds/assertions/assertUsage/base.js"
+import { hasProp } from "../../targets/server/utils.js"
+import { parse } from "../parsers/parseTransform.js"
+
+export { getPageContextSerializedInHtml }
+
+function getPageContextSerializedInHtml(): {
+  pageId: string
+  routeParams: Record<string, string>
+} {
+  // elem should exist because:
+  // 1. <script id="reveal_pageContext" type="application/json"> appears before the <script> that loads Reveal's client runtime (which includes this file)
+  // 2. <script id="reveal_pageContext" type="application/json"> is neither async nor defer
+  // See https://github.com/revealjs/reveal/pull/1271
+  const id = "reveal_pageContext"
+  const elem = document.getElementById(id)
+  assertUsage(
+    elem,
+    // It seems like it can be missing because of malformed HTML: https://github.com/revealjs/reveal/issues/913
+    `Couldn't find #${id} (which Reveal automatically injects in the HTML): make sure it exists (i.e. don't remove it and make sure your HTML isn't malformed)`
+  )
+  const pageContextJson = elem.textContent
+  assert(pageContextJson)
+
+  const pageContextSerializedInHtml = parse(pageContextJson)
+  assert(hasProp(pageContextSerializedInHtml, "pageId", "string"))
+  assert(hasProp(pageContextSerializedInHtml, "routeParams", "string{}"))
+
+  return pageContextSerializedInHtml
+}

package/dist/core/processing/getters/getPageContextUrlComputed.ts

@@ -0,0 +1,410 @@
+export { assertPageContextUrl, getPageContextUrlComputed }
+export type {
+  PageContextUrlClient,
+  PageContextUrlInternal,
+  PageContextUrlServer,
+  PageContextUrlSource,
+}
+
+import {
+  UrlPublic,
+  assert,
+  assertWarning,
+  changeEnumerable,
+  isBrowser,
+  isPlainObject,
+  isPropertyGetter,
+  parseUrl,
+} from "../../utils/index.js"
+// =====================
+// File determining the URL logic.
+// URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// =====================
+
+import { objectDefineProperty } from "../../utils/object/objectDefineProperty.js"
+
+// TODO/v1-release: move pageContext.urlParsed to pageContext.url
+type PageContextUrlComputed = {
+  /** Parsed information about the current URL */
+  urlParsed: UrlPublic
+  /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+  urlPathname: string
+}
+
+type PageContextUrl = {
+  /** The URL of the HTTP request */
+  urlOriginal: string
+} & PageContextUrlComputed
+
+type PageContextUrlInternal = PageContextUrl & {
+  _urlRewrite: string | null
+}
+
+type PageContextUrlClient = PageContextUrl
+
+type PageContextUrlServer = PageContextUrl & {
+  urlParsed: Omit<PageContextUrl["urlParsed"], HashProps> & {
+    /** Only available on the client-side */
+    hash: ""
+    /** Only available on the client-side */
+    hashString: null
+  }
+}
+
+type HashProps = "hash" | "hashString" | "hashOriginal"
+
+function getPageContextUrlComputed(
+  pageContext: PageContextUrlSource
+): PageContextUrlComputed {
+  assert(typeof pageContext.urlOriginal === "string")
+  assertPageContextUrlComputed(pageContext)
+
+  const pageContextUrlComputed = {}
+  objectDefineProperty(pageContextUrlComputed, "urlPathname", {
+    get: urlPathnameGetter,
+    enumerable: true,
+    configurable: true,
+  })
+  objectDefineProperty(pageContextUrlComputed, "urlParsed", {
+    get: urlParsedGetter,
+    enumerable: true,
+    configurable: true,
+  })
+
+  return pageContextUrlComputed
+}
+
+type PageContextUrlSource = {
+  urlOriginal: string
+  urlLogical?: string
+  _urlRewrite: string | null
+  _baseServer: string
+  _urlHandler: null | ((url: string) => string)
+}
+
+function getUrlParsed(pageContext: PageContextUrlSource) {
+  let urlResolved: string
+  let baseToBeRemoved: boolean
+
+  if (pageContext.urlLogical) {
+    urlResolved = pageContext.urlLogical
+    baseToBeRemoved = false
+  } else if (pageContext._urlRewrite) {
+    urlResolved = pageContext._urlRewrite
+    baseToBeRemoved = false
+  } else {
+    urlResolved = pageContext.urlOriginal
+    baseToBeRemoved = true
+  }
+  assert(urlResolved && typeof urlResolved === "string")
+
+  let urlHandler = pageContext._urlHandler
+  if (!urlHandler) urlHandler = (url: string) => url
+  urlResolved = urlHandler(urlResolved)
+
+  const baseServer = !baseToBeRemoved ? "/" : pageContext._baseServer
+
+  return parseUrl(urlResolved, baseServer)
+}
+
+function urlPathnameGetter(this: PageContextUrlSource) {
+  const { pathname } = getUrlParsed(this)
+  const urlPathname = pathname
+  assert(urlPathname.startsWith("/"))
+  return urlPathname
+}
+
+function urlParsedGetter(this: PageContextUrlSource) {
+  const {
+    // remove hasBaseServer as it isn't part of UrlPublic
+    // hasBaseServer: _,
+    ...urlParsed
+  } = getUrlParsed(this)
+
+  const hashIsAvailable = isBrowser()
+  const warnHashNotAvailable = (prop: HashProps) => {
+    assertWarning(
+      hashIsAvailable,
+      `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`,
+      { onlyOnce: true, showStackTrace: true }
+    )
+  }
+
+  const urlParsedEnhanced: UrlPublic = {
+    ...urlParsed,
+    get hash() {
+      warnHashNotAvailable("hash")
+      return urlParsed.hash
+    },
+  }
+
+  changeEnumerable(urlParsedEnhanced, "hashString", false)
+  if (!hashIsAvailable) {
+    changeEnumerable(urlParsedEnhanced, "hash", false)
+    changeEnumerable(urlParsedEnhanced, "hashOriginal", false)
+  }
+
+  return urlParsedEnhanced
+}
+
+function assertPageContextUrl(
+  pageContext: { urlOriginal: string } & PageContextUrlClient
+) {
+  assert(typeof pageContext.urlOriginal === "string")
+  assert(typeof pageContext.urlPathname === "string")
+  assert(isPlainObject(pageContext.urlParsed))
+  assert(pageContext.urlPathname === pageContext.urlParsed.pathname)
+  assertPageContextUrlComputed(pageContext)
+}
+
+function assertPageContextUrlComputed(pageContext: object) {
+  if ("urlPathname" in pageContext) {
+    assert(typeof pageContext.urlPathname === "string")
+    assert(isPropertyGetter(pageContext, "urlPathname"))
+    assert(isPropertyGetter(pageContext, "urlParsed"))
+  } else {
+    assert(!("urlParsed" in pageContext))
+  }
+}
+
+// export { assertPageContextUrl, getPageContextUrlComputed };
+// export type {
+//   PageContextUrlClient,
+//   PageContextUrlInternal,
+//   PageContextUrlServer,
+//   PageContextUrlSource,
+// };
+
+// // =====================
+// // File determining the URL logic.
+// // URLs need to be computed, because the user can modify the URL e.g. with onBeforeRoute() for i18n.
+// // =====================
+
+// import { objectDefineProperty } from "../../src/utils/objectDefineProperty.js";
+// import {
+//   assert,
+//   assertWarning,
+//   changeEnumerable,
+//   isBrowser,
+//   isPlainObject,
+//   isPropertyGetter,
+//   parseUrl,
+//   type UrlPublic,
+// } from "./utils.js";
+
+// // TODO/v1-release: move pageContext.urlParsed to pageContext.url
+// type PageContextUrlComputed = {
+//   /** Parsed information about the current URL */
+//   urlParsed: UrlPublic;
+//   /** The URL pathname, e.g. `/product/42` of `https://example.com/product/42?details=yes#reviews` */
+//   urlPathname: string;
+//   /** @deprecated */
+//   url: string;
+// };
+
+// type PageContextUrl = {
+//   /** The URL of the HTTP request */
+//   urlOriginal: string;
+// } & PageContextUrlComputed;
+// type PageContextUrlInternal = PageContextUrl & {
+//   _urlRewrite: string | null;
+// };
+// type PageContextUrlClient = PageContextUrl;
+// type PageContextUrlServer = PageContextUrl & {
+//   urlParsed: Omit<PageContextUrl["urlParsed"], HashProps> & {
+//     /** Only available on the client-side */
+//     hash: "";
+//     /** Only available on the client-side */
+//     hashString: null;
+//     /** @deprecated */
+//     hashOriginal: null;
+//   };
+// };
+// type HashProps = "hash" | "hashString" | "hashOriginal";
+
+// function getPageContextUrlComputed(
+//   pageContext: PageContextUrlSource,
+// ): PageContextUrlComputed {
+//   assert(typeof pageContext.urlOriginal === "string");
+//   assertPageContextUrlComputed(pageContext);
+
+//   const pageContextUrlComputed = {};
+//   objectDefineProperty(pageContextUrlComputed, "urlPathname", {
+//     get: urlPathnameGetter,
+//     enumerable: true,
+//     configurable: true,
+//   });
+//   objectDefineProperty(pageContextUrlComputed, "url", {
+//     get: urlGetter,
+//     enumerable: false,
+//     configurable: true,
+//   });
+//   objectDefineProperty(pageContextUrlComputed, "urlParsed", {
+//     get: urlParsedGetter,
+//     enumerable: true,
+//     configurable: true,
+//   });
+
+//   return pageContextUrlComputed;
+// }
+
+// type PageContextUrlSource = {
+//   urlOriginal: string;
+//   urlLogical?: string;
+//   _urlRewrite: string | null;
+//   _baseServer: string;
+//   _urlHandler: null | ((url: string) => string);
+// };
+// function getUrlParsed(pageContext: PageContextUrlSource) {
+//   // Example of i18n app using `throw render()`:
+//   //  1. User goes to '/fr-FR/admin'.
+//   //  2. The first onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/admin': the pathname of pageContext.urlOriginal, since both pageContext.urlLogical and pageContext._urlRewrite are undefined) and sets pageContext.urlLogical to '/admin'.
+//   //  3. A guard() hooks accesses pageContext.urlPathname (its value is '/admin': the pathname of pageContext.urlLogical) and calls `throw render('/fr-FR/login')`
+//   //  4. reveal create a new pageContext object (pageContext.urlLogical is erased) and sets pageContext._urlRewrite to '/fr-FR/login'. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
+//   //  5. The second onBeforeRoute() call accesses pageContext.urlPathname (its value is '/fr-FR/login': the pathname of pageContext._urlRewrite, since pageContext.urlLogical is undefined) and sets pageContext.urlLogical to '/login'.
+//   //  6. The value of pageContext.urlPathname is now '/login': the pathname of `pageContext.urlLogical`. (While pageContext.urlOriginal is still '/fr-FR/admin'.)
+//   // Reproduction: https://github.com/revealjs/reveal/discussions/1436#discussioncomment-8142023
+
+//   // Determine logical URL
+//   let urlResolved: string;
+//   let baseToBeRemoved: boolean;
+//   if (pageContext.urlLogical) {
+//     // Set by onBeforeRoute()
+//     urlResolved = pageContext.urlLogical;
+//     baseToBeRemoved = false;
+//   } else if (pageContext._urlRewrite) {
+//     // Set by `throw render()`
+//     urlResolved = pageContext._urlRewrite;
+//     baseToBeRemoved = false;
+//   } else {
+//     // Set by renderPage()
+//     urlResolved = pageContext.urlOriginal;
+//     baseToBeRemoved = true;
+//   }
+//   assert(urlResolved && typeof urlResolved === "string");
+
+//   // Remove .pageContext.json
+//   let urlHandler = pageContext._urlHandler;
+//   if (!urlHandler) urlHandler = (url: string) => url;
+//   urlResolved = urlHandler(urlResolved);
+
+//   // Remove Base URL.
+//   // - We assume there isn't any Base URL to the URLs set by the user at `throw render()` and onBeforeRoute()
+//   //   - This makes sense because the Base URL is merely a setting: ideally the user should write code that doesn't know anything about it (so that the user can remove/add/change Base URL without having to modify any code).
+//   // - pageContext.urlOriginal is the URL of the HTTP request and thus contains the Base URL.
+//   const baseServer = !baseToBeRemoved ? "/" : pageContext._baseServer;
+
+//   // Parse URL
+//   return parseUrl(urlResolved, baseServer);
+// }
+// function urlPathnameGetter(this: PageContextUrlSource) {
+//   const { pathname } = getUrlParsed(this);
+//   const urlPathname = pathname;
+//   assert(urlPathname.startsWith("/"));
+//   return urlPathname;
+// }
+// function urlGetter(this: PageContextUrlSource) {
+//   // TODO/v1-release: remove
+//   assertWarning(
+//     false,
+//     "`pageContext.url` is outdated. Use `pageContext.urlPathname`, `pageContext.urlParsed`, or `pageContext.urlOriginal` instead. (See https://reveal.dev/migration/0.4.23 for more information.)",
+//     { onlyOnce: true, showStackTrace: true },
+//   );
+//   return urlPathnameGetter.call(this);
+// }
+// function urlParsedGetter(this: PageContextUrlSource) {
+//   const {
+//     // remove hasBaseServer as it isn't part of UrlPublic
+//     hasBaseServer: _,
+//     ...urlParsed
+//   } = getUrlParsed(this);
+
+//   const hashIsAvailable = isBrowser();
+//   const warnHashNotAvailable = (prop: HashProps) => {
+//     assertWarning(
+//       hashIsAvailable,
+//       `pageContext.urlParsed.${prop} isn't available on the server-side (HTTP requests don't include the URL hash)`,
+//       { onlyOnce: true, showStackTrace: true },
+//     );
+//   };
+
+//   const urlParsedEnhanced: UrlPublic = {
+//     ...urlParsed,
+//     get hash() {
+//       warnHashNotAvailable("hash");
+//       return urlParsed.hash;
+//     },
+//     get hashOriginal() {
+//       warnHashNotAvailable("hashOriginal");
+//       return urlParsed.hashOriginal;
+//     },
+//     // TODO/next-major-release: remove
+//     get hashString() {
+//       assertWarning(
+//         false,
+//         "pageContext.urlParsed.hashString has been renamed to pageContext.urlParsed.hashOriginal",
+//         {
+//           onlyOnce: true,
+//           showStackTrace: true,
+//         },
+//       );
+//       warnHashNotAvailable("hashString");
+//       return urlParsed.hashOriginal;
+//     },
+//     // TODO/next-major-release: remove
+//     get searchString() {
+//       assertWarning(
+//         false,
+//         "pageContext.urlParsed.searchString has been renamed to pageContext.urlParsed.searchOriginal",
+//         { onlyOnce: true, showStackTrace: true },
+//       );
+//       return urlParsed.searchOriginal;
+//     },
+//   };
+
+//   changeEnumerable(urlParsedEnhanced, "hashString", false);
+//   changeEnumerable(urlParsedEnhanced, "searchString", false);
+//   if (!hashIsAvailable) {
+//     changeEnumerable(urlParsedEnhanced, "hash", false);
+//     changeEnumerable(urlParsedEnhanced, "hashOriginal", false);
+//   }
+
+//   return urlParsedEnhanced;
+// }
+
+// function assertPageContextUrl(
+//   pageContext: { urlOriginal: string } & PageContextUrlClient,
+// ) {
+//   assert(typeof pageContext.urlOriginal === "string");
+//   assert(typeof pageContext.urlPathname === "string");
+//   assert(isPlainObject(pageContext.urlParsed));
+//   assert(pageContext.urlPathname === pageContext.urlParsed.pathname);
+//   assertPageContextUrlComputed(pageContext);
+// }
+
+// function assertPageContextUrlComputed(pageContext: object) {
+//   /*
+//   If the isPropertyGetter() assertions fail then it's most likely because Object.assign() was used instead of `objectAssign()`:
+//   ```js
+//   const PageContextUrlComputed = getPageContextUrlComputed(pageContext)
+
+//   // ❌ Breaks the property descriptors/getters of pageContext defined by getPageContextUrlComputed() such as pageContext.urlPathname
+//   Object.assign(pageContext, pageContextUrlComputed)
+
+//   // ❌ Also breaks property descriptors/getters
+//   const pageContext = { ...pageContextUrlComputed }
+
+//   // ✅ Preserves property descriptors/getters (see objectAssign() implementation)
+//   objectAssign(pageContext, pageContextUrlComputed)
+//   ```
+//   */
+//   if ("urlPathname" in pageContext) {
+//     assert(typeof pageContext.urlPathname === "string");
+//     assert(isPropertyGetter(pageContext, "urlPathname"));
+//     assert(isPropertyGetter(pageContext, "urlParsed"));
+//     assert(isPropertyGetter(pageContext, "url"));
+//   } else {
+//     assert(!("urlParsed" in pageContext));
+//     assert(!("url" in pageContext));
+//   }
+// }

package/dist/core/processing/getters/getPageElement.tsx

@@ -0,0 +1,148 @@
+import React, { JSX, Suspense, useEffect } from "react"
+
+import { PageContextProvider } from "../../../ui/providers/PageContextProvider"
+// import updateCurrentPath from "../core/updateCurrentPath";
+import {
+  ExtendedPageContextClient,
+  ExtendedPageContextServer,
+  PageContextClient,
+  PageContextServer,
+} from "../../../types/interfaces/context"
+
+// Transform the incoming pageContext to match the expected structure
+function transformPageContext(
+  pageContext: PageContextServer | PageContextClient
+) {
+  return { ...pageContext }
+}
+
+function getPageElement(
+  pageContext: ExtendedPageContextClient | ExtendedPageContextServer
+): {
+  page: JSX.Element
+  renderPromise: Promise<void>
+} {
+  const { Page, config: { Loading } = {} } = pageContext
+
+  let page = Page ? <Page /> : null
+
+  // Wrapping
+  const addSuspense = (el: React.JSX.Element | null) => {
+    if (!Loading || !("layout" in Loading)) return el
+
+    // Use Loading.layout only if it's a valid React component
+    return Loading.layout ? (
+      <Suspense fallback={<Loading.layout />}>{el}</Suspense>
+    ) : (
+      el
+    )
+  }
+
+  page = addSuspense(page)
+
+  // Inner and outer wrapping
+  ;[
+    ...(pageContext.config.Layout || []),
+    ...(pageContext.config.Wrapper || []),
+  ].forEach((Wrap) => {
+    page = <Wrap>{page}</Wrap>
+    page = addSuspense(page)
+  })
+
+  // Now, transform and wrap with PageContextProvider
+  const transformedPageContext = transformPageContext(pageContext)
+  page = (
+    <PageContextProvider pageContext={transformedPageContext}>
+      {page}
+    </PageContextProvider>
+  )
+
+  let renderPromiseResolve!: () => void
+  let renderPromise = new Promise<void>((r) => (renderPromiseResolve = r))
+  page = (
+    <RenderPromiseProvider renderPromiseResolve={renderPromiseResolve}>
+      {page}
+    </RenderPromiseProvider>
+  )
+
+  if (pageContext.config.reactStrictMode !== false) {
+    page = <React.StrictMode>{page}</React.StrictMode>
+  }
+
+  return { page, renderPromise }
+}
+
+function RenderPromiseProvider({
+  children,
+  renderPromiseResolve,
+}: {
+  children: React.ReactNode
+  renderPromiseResolve: () => void
+}) {
+  useEffect(renderPromiseResolve)
+  return <>{children}</>
+}
+
+export { getPageElement }
+
+// export { getPageElement };
+
+// import React, { Suspense, useEffect } from "react";
+// import type { PageContext } from "reveal/types";
+// import { PageContextProvider } from "../hooks/usePageContext.js";
+
+// function getPageElement(pageContext: PageContext): {
+//   page: JSX.Element;
+//   renderPromise: Promise<void>;
+// } {
+//   const {
+//     Page,
+//     config: { Loading },
+//   } = pageContext;
+//   let page = Page ? <Page /> : null;
+
+//   // Wrapping
+//   const addSuspense = (el: React.JSX.Element | null) => {
+//     if (!Loading?.layout) return el;
+//     return <Suspense fallback={<Loading.layout />}>{page}</Suspense>;
+//   };
+//   page = addSuspense(page);
+//   [
+//     // Inner wrapping
+//     ...(pageContext.config.Layout || []),
+//     // Outer wrapping
+//     ...(pageContext.config.Wrapper || []),
+//   ].forEach((Wrap) => {
+//     page = <Wrap>{page}</Wrap>;
+//     page = addSuspense(page);
+//   });
+
+//   page = (
+//     <PageContextProvider pageContext={pageContext}>{page}</PageContextProvider>
+//   );
+
+//   let renderPromiseResolve!: () => void;
+//   let renderPromise = new Promise<void>((r) => (renderPromiseResolve = r));
+//   page = (
+//     <RenderPromiseProvider renderPromiseResolve={renderPromiseResolve}>
+//       {page}
+//     </RenderPromiseProvider>
+//   );
+
+//   if (pageContext.config.reactStrictMode !== false) {
+//     page = <React.StrictMode>{page}</React.StrictMode>;
+//   }
+
+//   return { page, renderPromise };
+// }
+
+// function RenderPromiseProvider({
+//   children,
+//   renderPromiseResolve,
+// }: {
+//   children: React.ReactNode;
+//   renderPromiseResolve: () => void;
+// }) {
+//   useEffect(renderPromiseResolve);
+//   return children;
+// }

package/dist/core/processing/getters/getPageFiles/analyzeClientSide.ts

@@ -0,0 +1,50 @@
+export { analyzeClientSide };
+
+import type { PageConfigRuntime } from "../../../../types/interfaces/page.js";
+import { getConfigValueRuntime } from "../getConfigValue.js";
+import { ClientDependency } from "../../../../types/interfaces/client.js";
+import {PageFile} from "../../../__internal/index.js";
+
+export type AnalysisResult = {
+  isClientRuntimeLoaded: boolean;
+  isClientRouting: boolean;
+  isHtmlOnly: boolean;
+  clientEntries: string[];
+  clientDependencies: ClientDependency[];
+  pageFilesClientSide: PageFile[];
+  pageFilesServerSide: PageFile[];
+};
+
+function analyzeClientSide(
+  pageConfig: PageConfigRuntime | null,
+  pageFilesAll: PageFile[],
+  pageId: string,
+): AnalysisResult {
+  // V1 design
+  if (pageConfig) {
+    const isClientRouting =
+      getConfigValueRuntime(pageConfig, "clientRouting", "boolean")?.value ??
+      false;
+    const isClientRuntimeLoaded =
+      getConfigValueRuntime(pageConfig, "isClientRuntimeLoaded", "boolean")
+        ?.value ?? false;
+    return {
+      isClientRuntimeLoaded,
+      isClientRouting,
+      isHtmlOnly: false,
+      clientEntries: [],
+      clientDependencies: [],
+      pageFilesClientSide: [],
+      pageFilesServerSide: [],
+    };
+  }
+  return {
+    isClientRuntimeLoaded: false,
+    isClientRouting: false,
+    isHtmlOnly: false,
+    clientEntries: [],
+    clientDependencies: [],
+    pageFilesClientSide: [],
+    pageFilesServerSide: [],
+  };
+}