@revealui/core 0.0.1-pre.0 → 0.0.1-pre.2

package/dist/core/gaurds/assertions/assertIsNotBrowser/base.ts

@@ -1,9 +0,0 @@
-import { isBrowser } from "../../validators/isBrowser";
-import { assert } from "../assert/base";
-
-export { assertIsNotBrowser };
-
-/** Ensure we don't bloat the client-side */
-function assertIsNotBrowser() {
-  assert(!isBrowser());
-}

package/dist/core/gaurds/assertions/assertIsNotBrowser/index.ts

@@ -1 +0,0 @@
-export * from "./base.js";

package/dist/core/gaurds/assertions/assertIsNotProductionRuntime/base.ts

@@ -1,71 +0,0 @@
-// Mechanism to ensure code isn't loaded by production runtime
-
-import getGlobalObject from "../../../processing/getters/getGlobalObject";
-import { createDebugger } from "../../debugger";
-import { isVitest } from "../../validators/isVitest";
-import { assert } from "../assert/base";
-import { assertIsNotBrowser } from "../assertIsNotBrowser";
-import { assertUsage } from "../assertUsage";
-
-export {
-  assertEnv,
-  assertIsNotProductionRuntime,
-  markEnvAsRevealPluginLoaded,
-  markEnvAsViteDev,
-  markEnvAsVitePreview,
-  revealVitePluginLoadedInProductionError,
-};
-
-assertIsNotBrowser();
-const debug = createDebugger("reveal:setup");
-const revealVitePluginLoadedInProductionError = `Loading Reveal's Vite plugin (the reveal/plugin module) is prohibited in production.`;
-
-const env = getGlobalObject<{
-  shouldNotBeProduction?: true;
-  isViteDev?: true;
-  isVitePreview?: true;
-  isRevealPluginLoaded?: true;
-}>("utils/assertIsNotProductionRuntime.ts", {});
-
-// Called by Reveal modules that want to ensure that they aren't loaded by the server runtime in production
-function assertIsNotProductionRuntime(): void | undefined {
-  if (debug.isActivated)
-    debug("assertIsNotProductionRuntime()", new Error().stack);
-  env.shouldNotBeProduction = true;
-}
-
-// Called by Vite hook configureServer()
-function markEnvAsViteDev(): void | undefined {
-  if (debug.isActivated) debug("markEnvAsViteDev()", new Error().stack);
-  env.isViteDev = true;
-}
-// Called by Vite hook configurePreviewServer()
-function markEnvAsVitePreview(): void | undefined {
-  if (debug.isActivated) debug("markEnvAsVitePreview()", new Error().stack);
-  env.isVitePreview = true;
-}
-// Called by ../node/plugin/index.ts
-function markEnvAsRevealPluginLoaded() {
-  if (debug.isActivated)
-    debug("markEnvAsRevealPluginLoaded()", new Error().stack);
-  env.isRevealPluginLoaded = true;
-}
-// Called by ../node/runtime/index.ts
-function assertEnv(): void | undefined {
-  if (debug.isActivated) debug("assertEnv()", new Error().stack);
-  if (isVitest()) return;
-  const isProduction = !env.isViteDev && !env.isVitePreview;
-  if (isProduction) {
-    // Seems to be the only reliable way to assert that the user doesn't load Reveal's Vite plugin in production. (The other assert() that uses process.env.NODE_ENV doesn't work if the user sets the process.env.NODE_ENV value later.)
-    assertUsage(
-      !env.isRevealPluginLoaded,
-      revealVitePluginLoadedInProductionError,
-    );
-    // This assert() is the main goal of this file: it ensures assertIsNotProductionRuntime()
-    assert(!env.shouldNotBeProduction);
-  } else {
-    // This assert() is obious and boring
-    assert(env.shouldNotBeProduction);
-    assert(env.isRevealPluginLoaded);
-  }
-}

package/dist/core/gaurds/assertions/assertIsNotProductionRuntime/index.ts

@@ -1 +0,0 @@
-export * from "./base.js";

package/dist/core/gaurds/assertions/assertKeys/base.ts

@@ -1,31 +0,0 @@
-export { assertKeys };
-
-import pc from "@brillout/picocolors";
-import { joinEnglish } from "../../../utils/string/joinEnglish";
-import { assertUsage } from "../assertUsage";
-
-function assertKeys<Keys extends readonly string[]>(
-  obj: Record<string, unknown>,
-  keysExpected: Keys,
-  errPrefix: string,
-): asserts obj is { [key in Keys[number]]?: unknown } {
-  const keysUnknown: string[] = [];
-  const keys = Object.keys(obj);
-  for (const key of keys) {
-    if (!keysExpected.includes(key)) {
-      keysUnknown.push(key);
-    }
-  }
-  if (keysUnknown.length !== 0) {
-    assertUsage(
-      false,
-      [
-        errPrefix,
-        `unknown key${keysUnknown.length === 1 ? "" : "s"}`,
-        joinEnglish(keysUnknown, "and", pc.cyan) + ".",
-        "Only following keys are allowed:",
-        joinEnglish(keysExpected, "and", pc.cyan) + ".",
-      ].join(" "),
-    );
-  }
-}

package/dist/core/gaurds/assertions/assertKeys/index.ts

@@ -1 +0,0 @@
-export * from "./base.js";

package/dist/core/gaurds/assertions/assertNoInfiniteHttpRedirect.ts

@@ -1,55 +0,0 @@
-export { assertNoInfiniteHttpRedirect };
-
-import pc from "@brillout/picocolors";
-import { assert, assertUsage } from "../../renderer/stream/utils.js";
-import getGlobalObject from "../../processing/getters/getGlobalObject.js";
-
-type Graph = Record<string, Set<string>>;
-const globalObject = getGlobalObject<{ redirectGraph: Graph }>(
-  "assertNoInfiniteHttpRedirect.ts",
-  {
-    redirectGraph: {},
-  },
-);
-
-function assertNoInfiniteHttpRedirect(
-  urlRedirectTarget: string,
-  urlLogical: string,
-) {
-  if (!urlRedirectTarget.startsWith("/")) {
-    // We assume that urlRedirectTarget points to an origin that is external (not the same origin), and we can therefore assume that the app doesn't define an infinite loop (in itself).
-    //  - There isn't a reliable way to check whether the redirect points to an external origin or the same origin. For same origins, we assume/hope the user to pass the URL without origin.
-    //    ```js
-    //    // For same-origin, the user usually/hopefully passes a URL without origin
-    //    renderPage({ urlOriginal: '/some/pathname' })
-    //    ```
-    return;
-  }
-  assert(urlLogical.startsWith("/"));
-  const graph = copy(globalObject.redirectGraph);
-  graph[urlRedirectTarget] ??= new Set();
-  graph[urlRedirectTarget]!.add(urlLogical);
-  validate(graph);
-  globalObject.redirectGraph = graph;
-}
-
-function copy(G: Graph): Graph {
-  return Object.fromEntries(
-    Object.entries(G).map(([key, val]) => [key, new Set(val)]),
-  );
-}
-
-// Adapted from: https://stackoverflow.com/questions/60904464/detect-cycle-in-directed-graph/60907076#60907076
-function validate(G: Graph) {
-  Object.keys(G).forEach((n) => check(G, n, []));
-}
-function check(G: Graph, n: string, path: string[]) {
-  if (path.includes(n)) {
-    const cycle = path.slice(path.indexOf(n)).concat(n);
-    assertUsage(
-      false,
-      `Infinite loop of HTTP URL redirects: ${cycle.map(pc.cyan).join(" -> ")}`,
-    );
-  }
-  G[n]?.forEach((node) => check(G, node, [...path, n]));
-}

package/dist/core/gaurds/assertions/assertNodeEnv/base.ts

@@ -1,120 +0,0 @@
-// This file serves the following three purposes:
-//   1. Upon building the app, we ensure the right NODE_ENV value is set.
-//      - Both Vue and React use NODE_ENV for enabling production-specific features:
-//        - Vue: https://github.com/vuejs/core/blob/f66a75ea75c8aece065b61e2126b4c5b2338aa6e/packages/vue/index.js
-//        - React: https://github.com/facebook/react/blob/01ab35a9a731dec69995fbd28f3ac7eaad11e183/packages/react/npm/index.js
-//      - Setting NODE_ENV to 'production' doesn't seem to make any sense in development.
-//      - With React upon building the app, setting NODE_ENV to a value other than 'production' triggers an error: https://github.com/revealjs/reveal/issues/1469#issuecomment-1969301797
-//      - With Vue upon building the app, NODE_ENV can be set to a value other than 'production', e.g. 'development'.
-//   2. Ensure Vite isn't loaded in production.
-//      - We currently only check whether Vite's development middleware is instantiated (i.e. whether Vite's `createServer()` was called). Is there a way to detect whether Vite's code is loaded?
-//   3. Ensure NODE_ENV isn't mistakenly set to a wrong value.
-
-// TODO: to fully implement the aforementioned points we need to implement a [new setting `allowNodeEnv`](https://github.com/revealjs/reveal/issues/1528)
-
-export {
-  assertNodeEnv_build,
-  assertNodeEnv_onRevealPluginLoad,
-  assertNodeEnv_runtime,
-}
-// Vite already handles build
-export { handleNodeEnv_prerender, handleNodeEnv_vitePluginVercel }
-
-import pc from "@brillout/picocolors"
-import { assertIsNotBrowser } from "../assertIsNotBrowser"
-import { revealVitePluginLoadedInProductionError } from "../assertIsNotProductionRuntime"
-import { assertWarning } from "../assertWarning"
-
-assertIsNotBrowser()
-
-function assertNodeEnv_build() {
-  assertNodeEnvIsNotDev("building")
-}
-
-function assertNodeEnv_runtime(isViteDev: boolean) {
-  const nodeEnv = getNodeEnv()
-  if (nodeEnv === null || nodeEnv === "test") return
-  const isNodeDev = isNodeEnvDev()
-  // Calling Vite's createServer() is enough for hasViteDevServer to be true, even without actually adding Vite's development middleware to the server: https://github.com/revealjs/reveal/issues/792#issuecomment-1516830759
-  if (isViteDev === isNodeDev) return
-  const nodeEnvDesc = getNodeEnvDesc()
-  // TODO: make it assertUsage() again once #1528 is implemented.
-  const errMsg = `Running ${
-    isViteDev ? pc.cyan("$ vite dev") : "app in production"
-  } while the ${nodeEnvDesc} which is contradictory, see https://reveal.dev/NODE_ENV` as const
-  assertWarning(false, errMsg, { onlyOnce: true })
-}
-
-function assertNodeEnv_onRevealPluginLoad() {
-  const nodeEnv = getNodeEnv()
-  if (nodeEnv === "test") return
-  // TODO: make it assertUsage() again once #1528 is implemented.
-  assertWarning(
-    /* We can enable this assertion after reveal's CLI is implemented and using Vite's CLI is deprecated (we can then check whether the context is a `$ reveal build`).
-    isNodeEnvDev() || isrevealCliBuild(),
-    /*/
-    isNodeEnvDev() || (true as boolean),
-    ///*/
-    [
-      pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`),
-      "(which reveal interprets as a non-development environment https://reveal.dev/NODE_ENV)",
-      "while the reveal/plugin module is loaded.",
-      revealVitePluginLoadedInProductionError,
-    ].join(" "),
-    { onlyOnce: true }
-  )
-}
-
-function handleNodeEnv_prerender() {
-  const assertNodeEnv = () => assertNodeEnvIsNotDev("pre-rendering")
-  if (getNodeEnv()) assertNodeEnv()
-  setNodeEnvToProduction()
-  assertNodeEnv()
-}
-
-function handleNodeEnv_vitePluginVercel() {
-  setNodeEnvToProduction()
-}
-
-function getNodeEnv(): null | undefined | string {
-  if (typeof process === "undefined") return null
-  return process.env.NODE_ENV
-}
-
-function setNodeEnvToProduction(): void | undefined {
-  // The statement `process.env['NODE_ENV'] = 'production'` chokes webpack v4
-  const proc = process
-  const { env } = proc
-  env.NODE_ENV = "production"
-}
-
-function isNodeEnvDev(): boolean {
-  const nodeEnv = getNodeEnv()
-  if (!nodeEnv) return true
-  if (["development", "dev"].includes(nodeEnv)) return true
-  // That's quite aggressive, let's see if some user complains
-  return false
-}
-
-function getNodeEnvDesc(): `environment is set to be a ${string} environment by process.env.NODE_ENV === ${string}` {
-  const nodeEnv = getNodeEnv()
-  const isDev = isNodeEnvDev()
-  const nodeEnvDesc = `environment is set to be a ${
-    (isDev ? "development" : "production") as string
-  } environment by ${pc.cyan(`process.env.NODE_ENV === ${JSON.stringify(nodeEnv)}`)}` as const
-  return nodeEnvDesc
-}
-
-function assertNodeEnvIsNotDev(operation: "building" | "pre-rendering") {
-  const isDev = isNodeEnvDev()
-  if (!isDev) return
-  const nodeEnvDesc = getNodeEnvDesc()
-  // TODO: make it assertUsage() again once #1528 is implemented.
-  assertWarning(
-    false,
-    `The ${nodeEnvDesc} which is forbidden upon ${operation}, see https://reveal.dev/NODE_ENV`,
-    {
-      onlyOnce: true,
-    }
-  )
-}

package/dist/core/gaurds/assertions/assertNodeEnv/index.ts

@@ -1 +0,0 @@
-export * from "./base.js";

package/dist/core/gaurds/assertions/assertNodeVersion/base.ts

@@ -1,11 +0,0 @@
-import { isNodeJS } from "../../validators/isNodeJS";
-import { assertVersion } from "../assertVersion";
-
-export { assertNodeVersion };
-
-// node_modules/reveal/package.json#engines.node isn't enough as users can ignore it
-function assertNodeVersion() {
-	if (!isNodeJS()) return;
-	const version = process.versions.node;
-	assertVersion("Node.js", version, "22.0.0");
-}

package/dist/core/gaurds/assertions/assertNodeVersion/index.ts

@@ -1 +0,0 @@
-export * from "./base";

package/dist/core/gaurds/assertions/assertOnBeforeRenderHookReturn.ts

@@ -1,37 +0,0 @@
-export { assertOnBeforeRenderHookReturn };
-
-import pc from "@brillout/picocolors";
-
-import { assertHookReturnedObject } from "./assertHookReturnedObject.js";
-import { assertPageContextProvidedByUser } from "./assertPageContextProvidedByUser.js";
-import { assertUsage } from "./assertUsage/base.js";
-import { isPlainObject } from "../validators/isPlainObject.js";
-
-function assertOnBeforeRenderHookReturn<Keys extends readonly string[]>(
-  hookReturnValue: unknown,
-  hookFilePath: string,
-): asserts hookReturnValue is
-  | undefined
-  | null
-  | { [key in Keys[number]]?: unknown } {
-  if (hookReturnValue === undefined || hookReturnValue === null) {
-    return;
-  }
-  const errPrefix =
-    `The onBeforeRender() hook defined by ${hookFilePath}` as const;
-  assertUsage(
-    isPlainObject(hookReturnValue),
-    `${errPrefix} should return a plain JavaScript object, ${pc.cyan("undefined")}, or ${pc.cyan("null")}`,
-  );
-  assertHookReturnedObject(
-    hookReturnValue,
-    ["pageContext"] as const,
-    errPrefix,
-  );
-  if (hookReturnValue.pageContext) {
-    assertPageContextProvidedByUser(hookReturnValue["pageContext"], {
-      hookName: "onBeforeRender",
-      hookFilePath,
-    });
-  }
-}

package/dist/core/gaurds/assertions/assertPageContextProvidedByUser.ts

@@ -1,60 +0,0 @@
-export { assertPageContextProvidedByUser }
-
-import pc from "@brillout/picocolors"
-import { isObject } from "../validators/isObject"
-import { assert } from "./assert"
-import { assertUsage } from "./assertUsage"
-import { assertWarning } from "./assertWarning"
-
-function assertPageContextProvidedByUser(
-  pageContextProvidedByUser: unknown,
-  {
-    hookName,
-    hookFilePath,
-  }: {
-    hookFilePath: string
-    hookName: "onBeforeRender" | "onRenderHtml" | "onBeforeRoute"
-  }
-): asserts pageContextProvidedByUser is Record<string, unknown> {
-  if (
-    pageContextProvidedByUser === undefined ||
-    pageContextProvidedByUser === null
-  )
-    return
-
-  assert(!hookName.endsWith(")"))
-  const errPrefix = `The ${pc.cyan("pageContext")} object provided by the ${
-    hookName as string
-  }() hook defined by ${hookFilePath}` as const
-
-  assertUsage(
-    isObject(pageContextProvidedByUser),
-    `${errPrefix} should be an object (but it's ${pc.cyan(
-      `typeof pageContext === ${JSON.stringify(typeof pageContextProvidedByUser)}`
-    )} instead)`
-  )
-
-  assertUsage(
-    !("_objectCreatedByReveal" in pageContextProvidedByUser),
-    `${errPrefix} shouldn't be the whole ${pc.cyan(
-      "pageContext"
-    )} object, see https://reveal.dev/pageContext-manipulation#do-not-return-entire-pagecontext`
-  )
-
-  // In principle, it's possible to use onBeforeRoute()` to override and define the whole routing.
-  // Is that a good idea to allow users to do this? Beyond deep integration with Vue Router or React Router, is there a use case for this?
-  assertWarning(
-    !("pageId" in pageContextProvidedByUser),
-    `${errPrefix} sets ${pc.cyan(
-      "pageContext.pageId"
-    )} which means that Reveal's routing is overriden. This is an experimental feature: make sure to contact a Reveal maintainer before using this.`,
-    { onlyOnce: true }
-  )
-
-  assertUsage(
-    !("is404" in pageContextProvidedByUser),
-    `${errPrefix} sets ${pc.cyan("pageContext.is404")} which is forbidden, use ${pc.cyan(
-      "throw render()"
-    )} instead, see https://reveal.dev/render`
-  )
-}

package/dist/core/gaurds/assertions/assertPluginManifest.ts

@@ -1,41 +0,0 @@
-export { assertPluginManifest }
-export type { PluginManifest }
-
-import { projectInfo } from "../../globals/versions/projectInfo.js"
-import { hasProp } from "../validators/hasProp.js"
-import { isPlainObject } from "../validators/isPlainObject.js"
-import { assert } from "./assert/index.js"
-import { assertRuntimeManifest } from "./assertRuntimeManifest.js"
-import { assertUsage } from "./assertUsage/index.js"
-import { checkType } from "./checkType.js"
-
-type PluginManifest = {
-  version: string
-  baseServer: string
-  baseAssets: string | null
-  usesClientRouter: boolean
-  includeAssetsImportedByServer: boolean
-  redirects: Record<string, string>
-  trailingSlash: boolean
-  disableUrlNormalization: boolean
-}
-function assertPluginManifest(
-  pluginManifest: unknown
-): asserts pluginManifest is PluginManifest {
-  assert(isPlainObject(pluginManifest))
-  assertUsage(
-    pluginManifest.version === projectInfo.projectVersion,
-    `Re-build your app (you're using reveal@${projectInfo.projectVersion} but your app was built with reveal@${pluginManifest.version})`
-  )
-  assertRuntimeManifest(pluginManifest)
-  assert(hasProp(pluginManifest, "usesClientRouter", "boolean"))
-  assert(hasProp(pluginManifest, "version", "string"))
-  // Avoid:
-  // ```
-  // Uncaught (in promise) TypeError: Cannot set property manifestKeyMap of #<Object> which has only a getter
-  // ```
-  // We removed manifestKeyMap, maybe this isn't needed anymore.
-  // See https://github.com/revealjs/reveal/issues/596
-  const pluginManifestClone = { ...pluginManifest }
-  checkType<PluginManifest>(pluginManifestClone)
-}

package/dist/core/gaurds/assertions/assertPlusFileExport.ts

@@ -1,66 +0,0 @@
-export { assertPlusFileExport };
-
-import pc from "@brillout/picocolors";
-import { assert } from "./assert/base";
-import { assertUsage } from "./assertUsage";
-import { assertWarning } from "./assertWarning";
-
-const EXPORTS_IGNORE = [
-  // vite-plugin-solid adds `export { $$registrations }`
-  "$$registrations",
-  // @vitejs/plugin-vue adds `export { _rerender_only }`
-  "_rerender_only",
-];
-
-// Tolerate `export { frontmatter }` in .mdx files
-const TOLERATE_SIDE_EXPORTS = [".md", ".mdx"] as const;
-
-function assertPlusFileExport(
-  fileExports: Record<string, unknown>,
-  filePathToShowToUser: string,
-  configName: string,
-) {
-  const exportNames = Object.keys(fileExports).filter(
-    (exportName) => !EXPORTS_IGNORE.includes(exportName),
-  );
-  const isValid = (exportName: string) =>
-    exportName === "default" || exportName === configName;
-  const exportNamesValid = exportNames.filter(isValid);
-  const exportNamesInvalid = exportNames.filter((e) => !isValid(e));
-
-  if (exportNamesValid.length === 1 && exportNamesInvalid.length === 0) {
-    return;
-  }
-
-  const exportDefault = pc.code("export default");
-  const exportNamed = pc.code(`export { ${configName} }`);
-  assert(exportNamesValid.length <= 2);
-  if (exportNamesValid.length === 0) {
-    assertUsage(
-      false,
-      `${filePathToShowToUser} should have a ${exportNamed} or ${exportDefault}`,
-    );
-  }
-  if (exportNamesValid.length === 2) {
-    assertWarning(
-      false,
-      `${filePathToShowToUser} is ambiguous: remove ${exportDefault} or ${exportNamed}`,
-      {
-        onlyOnce: true,
-      },
-    );
-  }
-  if (
-    !TOLERATE_SIDE_EXPORTS.some((ext) => filePathToShowToUser.endsWith(ext))
-  ) {
-    exportNamesInvalid.forEach((exportInvalid) => {
-      assertWarning(
-        false,
-        `${filePathToShowToUser} unexpected ${pc.cyan(`export { ${exportInvalid} }`)}`,
-        {
-          onlyOnce: true,
-        },
-      );
-    });
-  }
-}

package/dist/core/gaurds/assertions/assertRoutingType/base.ts

@@ -1,41 +0,0 @@
-export { assertClientRouting, assertServerRouting, checkIfClientRouting }
-
-import pc from "@brillout/picocolors"
-
-import getGlobalObject from "../../../processing/getters/getGlobalObject"
-import { isBrowser } from "../../validators/isBrowser"
-import { assertUsage } from "../assertUsage"
-import { assertWarning } from "../assertWarning"
-
-const state = getGlobalObject<{ isClientRouting?: boolean }>(
-  "utils/assertRouterType.ts",
-  {}
-)
-
-function assertClientRouting() {
-  assertNoContradiction(checkIfClientRouting())
-  state.isClientRouting = true
-}
-
-function checkIfClientRouting(): boolean {
-  return state.isClientRouting !== false
-}
-
-function assertServerRouting() {
-  assertNoContradiction(state.isClientRouting !== true)
-  state.isClientRouting = false
-}
-
-function assertNoContradiction(noContradiction: boolean) {
-  // If an assertion fails because of a wrong usage, then we assume that the user is trying to import from 'reveal/client/router' while not setting `clientRouting` to `true`. Note that 'reveal/client' only exports the type `PageContextBuiltInClient` and that the package.json#exports entry 'reveal/client' will eventually be removed.
-  assertUsage(
-    isBrowser(),
-    `${pc.cyan("import { something } from 'reveal/client/router'")} is forbidden on the server-side`,
-    { showStackTrace: true }
-  )
-  assertWarning(
-    noContradiction,
-    "You shouldn't `import { something } from 'reveal/client/router'` when using Server Routing. The 'reveal/client/router' utilities work only with Client Routing. In particular, don't `import { navigate }` nor `import { prefetch }` as they unnecessarily bloat your client-side bundle sizes.",
-    { showStackTrace: true, onlyOnce: true }
-  )
-}

package/dist/core/gaurds/assertions/assertRoutingType/index.ts

@@ -1 +0,0 @@
-export * from "./base.js";

package/dist/core/gaurds/assertions/assertRuntimeManifest.ts

@@ -1,34 +0,0 @@
-import { isBaseAssets } from "../../targets/url/parseUrlExtras";
-import { castType, checkType, isBaseServer } from "../../utils";
-import { hasProp } from "../validators/hasProp";
-import { isObject } from "../validators/isObject";
-import { assert } from "./assert";
-
-export { assertRuntimeManifest };
-export type { RuntimeManifest };
-
-type RuntimeManifest = {
-  baseServer: string;
-  baseAssets: string;
-  includeAssetsImportedByServer: boolean;
-  redirects: Record<string, string>;
-  trailingSlash: boolean;
-  disableUrlNormalization: boolean;
-};
-
-function assertRuntimeManifest(
-  obj: unknown,
-): asserts obj is RuntimeManifest & Record<string, unknown> {
-  assert(obj);
-  assert(isObject(obj));
-  assert(hasProp(obj, "baseServer", "string"));
-  assert(hasProp(obj, "baseAssets", "string"));
-  assert(isBaseServer(obj.baseServer));
-  assert(isBaseAssets(obj.baseAssets));
-  assert(hasProp(obj, "includeAssetsImportedByServer", "boolean"));
-  assert(hasProp(obj, "redirects", "object"));
-  castType<{ redirects: Record<string, string> }>(obj);
-  assert(hasProp(obj, "trailingSlash", "boolean"));
-  assert(hasProp(obj, "disableUrlNormalization", "boolean"));
-  checkType<RuntimeManifest>(obj);
-}