@revealui/core 0.0.1-pre.0

package/dist/core/processing/getters/getRevealConfig/transpileAndExecuteFile.ts

@@ -0,0 +1,490 @@
+export {
+  getConfigBuildErrorFormatted,
+  getConfigExecutionErrorIntroMsg,
+  isTemporaryBuildFile,
+  transpileAndExecuteFile,
+}
+
+import { import_ } from "@brillout/import"
+import pc from "@brillout/picocolors"
+import {
+  build,
+  type BuildOptions,
+  type BuildResult,
+  formatMessages,
+  type Message,
+} from "esbuild"
+import fs from "fs"
+import path from "path"
+import "source-map-support/register.js"
+import {
+  assert,
+  assertFilePathAbsoluteFilesystem,
+  assertIsNotProductionRuntime,
+  assertIsNpmPackageImport,
+  assertPosixPath,
+  assertUsage,
+  assertWarning,
+  createDebugger,
+  getRandomId,
+  isObject,
+  isPlainJavaScriptFile,
+  toPosixPath,
+} from "../../../../plugins/utils.js"
+import { FilePathResolved } from "../../../../types/interfaces/file.js"
+import { getFilePathAbsoluteUserRootDir } from "../getFilePath.js"
+import { revealConfigDependencies } from "./index.js"
+import { transformPointerImports } from "./transformPointerImports.js"
+
+assertIsNotProductionRuntime()
+const debug = createDebugger("reveal:pointer-imports")
+
+async function transpileAndExecuteFile(
+  filePath: FilePathResolved,
+  userRootDir: string,
+  isConfigFile: boolean | "is-extension-config"
+): Promise<{ fileExports: Record<string, unknown> }> {
+  const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath
+  const fileExtension = getFileExtension(filePathAbsoluteFilesystem)
+
+  assertUsage(
+    isPlainJavaScriptFile(filePathAbsoluteFilesystem),
+    `${filePathToShowToUserResolved} has file extension .${fileExtension} but a config file can only be a JavaScript/TypeScript file`
+  )
+  const isHeader = isHeaderFile(filePathAbsoluteFilesystem)
+  if (isHeader) {
+    assertWarning(
+      false,
+      `${pc.cyan(
+        ".h.js"
+      )} files are deprecated: simply renaming ${filePathToShowToUserResolved} to ${removeHeaderFileExtension(
+        filePathToShowToUserResolved
+      )} is usually enough, although you may occasionally need to use ${pc.cyan(
+        "with { type: 'pointer' }"
+      )} as explained at https://reveal.dev/config#pointer-imports`,
+      { onlyOnce: true }
+    )
+  }
+
+  if (
+    isConfigFile === "is-extension-config" &&
+    !isHeader &&
+    fileExtension.endsWith("js")
+  ) {
+    // This doesn't track dependencies => we should never use this for user land configs
+    const fileExports = await executeFile(filePathAbsoluteFilesystem, filePath)
+    return { fileExports }
+  } else {
+    const transformImports = isConfigFile && (isHeader ? "all" : true)
+    const code = await transpileFile(filePath, transformImports, userRootDir)
+    const fileExports = await executeTranspiledFile(filePath, code)
+    return { fileExports }
+  }
+}
+
+async function transpileFile(
+  filePath: FilePathResolved,
+  transformImports: boolean | "all",
+  userRootDir: string
+) {
+  const { filePathAbsoluteFilesystem, filePathToShowToUserResolved } = filePath
+
+  assertPosixPath(filePathAbsoluteFilesystem)
+  revealConfigDependencies.add(filePathAbsoluteFilesystem)
+
+  if (debug.isActivated) debug("transpile", filePathToShowToUserResolved)
+  let { code, pointerImports } = await transpileWithEsbuild(
+    filePath,
+    userRootDir,
+    transformImports
+  )
+  if (debug.isActivated)
+    debug(`code, post esbuild (${filePathToShowToUserResolved})`, code)
+
+  let isImportTransformed = false
+  if (transformImports) {
+    const codeMod = transformPointerImports(
+      code,
+      filePathToShowToUserResolved,
+      pointerImports
+    )
+    if (codeMod) {
+      code = codeMod
+      isImportTransformed = true
+      if (debug.isActivated)
+        debug(
+          `code, post pointer imports transform (${filePathToShowToUserResolved})`,
+          code
+        )
+    }
+  }
+  if (!isImportTransformed) {
+    if (debug.isActivated)
+      debug(`code, no pointer imports (${filePathToShowToUserResolved})`)
+  }
+  return code
+}
+
+async function transpileWithEsbuild(
+  filePath: FilePathResolved,
+  userRootDir: string,
+  transformImports: boolean | "all"
+) {
+  const entryFilePath = filePath.filePathAbsoluteFilesystem
+  const entryFileDir = path.posix.dirname(entryFilePath)
+  const options: BuildOptions = {
+    platform: "node",
+    entryPoints: [entryFilePath],
+    sourcemap: "inline",
+    write: false,
+    target: ["node14.18", "node16"],
+    outfile: path.posix.join(
+      // Needed for correct inline source map
+      entryFileDir,
+      // `write: false` => no file is actually emitted
+      "NEVER_EMITTED.js"
+    ),
+    logLevel: "silent",
+    format: "esm",
+    absWorkingDir: userRootDir,
+    // Disable tree-shaking to avoid dead-code elimination, so that unused imports aren't removed.
+    // Esbuild still sometimes removes unused imports because of TypeScript: https://github.com/evanw/esbuild/issues/3034
+    treeShaking: false,
+    minify: false,
+    metafile: true,
+    bundle: true,
+  }
+
+  let pointerImports: Record<string, boolean> = {}
+  options.plugins = [
+    // Determine whether an import should be:
+    //  - A pointer import
+    //  - Externalized
+    {
+      name: "reveal-esbuild",
+      setup(build) {
+        // https://github.com/brillout/esbuild-playground
+        build.onResolve({ filter: /.*/ }, async (args) => {
+          if (args.kind !== "import-statement") return
+
+          // Avoid infinite loop: https://github.com/evanw/esbuild/issues/3095#issuecomment-1546916366
+          const useEsbuildResolver = "useEsbuildResolver"
+          if (args.pluginData?.[useEsbuildResolver]) return
+          const { path, ...opts } = args
+          opts.pluginData = { [useEsbuildResolver]: true }
+
+          const resolved = await build.resolve(path, opts)
+
+          if (resolved.errors.length > 0) {
+            /* We could do the following to let Node.js throw the error, but we don't because the error shown by esbuild is prettier: the Node.js error refers to the transpiled [build-f7i251e0iwnw]+config.ts.mjs whereas esbuild refers to the source +config.ts file.
+            pointerImports[args.path] = false
+            return { external: true }
+            */
+            cleanEsbuildErrors(resolved.errors)
+            // Let esbuild throw the error
+            return resolved
+          }
+
+          assert(resolved.path)
+          const importPathResolved = toPosixPath(resolved.path)
+          const importPathOriginal = args.path
+
+          // Esbuild resolves path aliases.
+          // - Enabling us to use:
+          //   - assertIsNpmPackageImport()
+          //   - isNpmPackageImport(str, { cannotBePathAlias: true })
+          assertFilePathAbsoluteFilesystem(importPathResolved)
+
+          // reveal-{react,vue,solid} follow the convention that their config export resolves to a file named +config.js
+          //  - This is temporary, see comment below.
+          const isRevealExtensionImport =
+            importPathResolved.endsWith("+config.js")
+
+          const isPointerImport =
+            transformImports === "all" ||
+            // .jsx, .vue, .svg, ... => obviously not config code => pointer import
+            !isPlainJavaScriptFile(importPathResolved) ||
+            // Import of a reveal extension config => make it a pointer import because we want to show nice error messages (that can display whether a config has been set by the user or by a reveal extension).
+            //  - TODO/eventually: stop doing this and, instead, let Node.js directly load reveal-{react,vue,solid} while enforcing reveal extensions to set 'name' in their +config.js file.
+            //    - reveal@0.4.162 already started soft-requiring reveal extensions to set the name config
+            isRevealExtensionImport
+
+          assertPosixPath(importPathResolved)
+          const isNodeModules = importPathResolved.includes("/node_modules/")
+
+          const isExternal =
+            isPointerImport ||
+            // Performance: npm package imports can be externalized. (We could as well let esbuild transpile /node_modules/ code but it's useless as /node_modules/ code is already built. It would unnecessarily slow down transpilation.)
+            isNodeModules
+
+          if (!isExternal) {
+            // User-land config code (i.e. not runtime code) => let esbuild transpile it
+            assert(!isPointerImport && !isNodeModules)
+            if (debug.isActivated)
+              debug("onResolved()", {
+                args,
+                resolved,
+                isPointerImport,
+                isExternal,
+              })
+            return resolved
+          }
+
+          let importPathTranspiled: string
+          assertPosixPath(importPathOriginal)
+          if (
+            importPathOriginal.startsWith("./") ||
+            importPathOriginal.startsWith("../")
+          ) {
+            importPathTranspiled = importPathResolved
+          } else {
+            // `importPathOriginal` is either:
+            //  - Npm package import
+            //  - Path alias
+            const filePathAbsoluteUserRootDir = getFilePathAbsoluteUserRootDir({
+              filePathAbsoluteFilesystem: importPathResolved,
+              userRootDir,
+            })
+            // We assuming that path aliases always resolve inside `userRootDir`.
+            if (filePathAbsoluteUserRootDir && !isNodeModules) {
+              // `importPathOriginal` is a path alias.
+              // - We have to use esbuild's path alias resolution, because:
+              //   - reveal doesn't resolve path aliases at all.
+              //   - Node.js doesn't support `tsconfig.js#compilerOptions.paths`.
+              // - Esbuild path alias resolution seems to be reliable, e.g. it supports `tsconfig.js#compilerOptions.paths`.
+              importPathTranspiled = importPathResolved
+            } else {
+              // `importPathOriginal` is an npm package import.
+              assertIsNpmPackageImport(importPathOriginal)
+              // For less confusing error messages, let the resolution be handled by reveal or Node.js.
+              importPathTranspiled = importPathOriginal
+            }
+          }
+
+          if (debug.isActivated)
+            debug("onResolved()", {
+              args,
+              resolved,
+              importPathTranspiled,
+              isPointerImport,
+              isExternal,
+            })
+          assert(isExternal)
+          assert(
+            // Import of runtime code => handled by reveal
+            isPointerImport ||
+              // Import of config code => loaded by Node.js at build-time
+              isNodeModules
+          )
+          pointerImports[importPathTranspiled] = isPointerImport
+          return { external: true, path: importPathTranspiled }
+        })
+      },
+    },
+    // Track dependencies
+    {
+      name: "reveal:dependency-tracker",
+      setup(b) {
+        b.onLoad({ filter: /./ }, (args) => {
+          // We collect the dependency `args.path` in case the bulid fails (upon build error => error is thrown => no metafile)
+          let { path } = args
+          path = toPosixPath(path)
+          revealConfigDependencies.add(path)
+          return undefined
+        })
+        /* To exhaustively collect all dependencies upon build failure, we would also need to use onResolve().
+         *  - Because onLoad() isn't call if the config dependency can't be resolved.
+         *  - For example, the following breaks auto-reload (the config is stuck in its error state and the user needs to touch the importer for the config to reload):
+         *    ```bash
+         *    mv ./some-config-dependency.js /tmp/ && mv /tmp/some-config-dependency.js .
+         *    ```
+         *  - But implementing a fix is complex and isn't worth it.
+        b.onResolve(...)
+        */
+      },
+    },
+  ]
+
+  let result: BuildResult
+  try {
+    result = await build(options)
+  } catch (err) {
+    await formatBuildErr(err, filePath)
+    throw err
+  }
+
+  // Track dependencies
+  assert(result.metafile)
+  Object.keys(result.metafile.inputs).forEach((filePathRelative) => {
+    filePathRelative = toPosixPath(filePathRelative)
+    assertPosixPath(userRootDir)
+    const filePathAbsoluteFilesystem = path.posix.join(
+      userRootDir,
+      filePathRelative
+    )
+    revealConfigDependencies.add(filePathAbsoluteFilesystem)
+  })
+
+  const code = result.outputFiles![0]!.text
+  assert(typeof code === "string")
+  return { code, pointerImports }
+}
+
+async function executeTranspiledFile(filePath: FilePathResolved, code: string) {
+  const { filePathAbsoluteFilesystem } = filePath
+  // Alternative to using a temporary file: https://github.com/vitejs/vite/pull/13269
+  //  - But seems to break source maps, so I don't think it's worth it
+  const filePathTmp = getTemporaryBuildFilePath(filePathAbsoluteFilesystem)
+  fs.writeFileSync(filePathTmp, code)
+  const clean = () => fs.unlinkSync(filePathTmp)
+  let fileExports: Record<string, unknown> = {}
+  try {
+    fileExports = await executeFile(filePathTmp, filePath)
+  } finally {
+    clean()
+  }
+  return fileExports
+}
+
+async function executeFile(
+  filePathToExecuteAbsoluteFilesystem: string,
+  filePathSourceFile: FilePathResolved
+) {
+  let fileExports: Record<string, unknown> = {}
+  try {
+    fileExports = await import_(filePathToExecuteAbsoluteFilesystem)
+  } catch (err) {
+    triggerPrepareStackTrace(err)
+    const errIntroMsg = getErrIntroMsg("execute", filePathSourceFile)
+    assert(isObject(err))
+    execErrIntroMsg.set(err, errIntroMsg)
+    throw err
+  }
+  // Return a plain JavaScript object:
+  //  - import() returns `[Module: null prototype] { default: { onRenderClient: '...' }}`
+  //  - We don't need this special object.
+  fileExports = { ...fileExports }
+  return fileExports
+}
+
+const formatted = "_formatted"
+function getConfigBuildErrorFormatted(err: unknown): null | string {
+  if (!isObject(err)) return null
+  if (!(formatted in err)) return null
+  assert(typeof err[formatted] === "string")
+  return err[formatted]
+}
+async function formatBuildErr(
+  err: unknown,
+  filePath: FilePathResolved
+): Promise<void> {
+  assert(isObject(err) && err.errors)
+  const msgEsbuild = (
+    await formatMessages(err.errors as any, {
+      kind: "error",
+      color: true,
+    })
+  )
+    .map((m) => m.trim())
+    .join("\n")
+  const msgIntro = getErrIntroMsg("transpile", filePath)
+  err[formatted] = `${msgIntro}\n${msgEsbuild}`
+}
+
+const execErrIntroMsg = new WeakMap<object, string>()
+function getConfigExecutionErrorIntroMsg(err: unknown): string | null {
+  if (!isObject(err)) return null
+  const errIntroMsg = execErrIntroMsg.get(err)
+  return errIntroMsg ?? null
+}
+
+function getTemporaryBuildFilePath(filePathAbsoluteFilesystem: string): string {
+  assertPosixPath(filePathAbsoluteFilesystem)
+  const dirname = path.posix.dirname(filePathAbsoluteFilesystem)
+  const filename = path.posix.basename(filePathAbsoluteFilesystem)
+  // Syntax with semicolon `build:${/*...*/}` doesn't work on Windows: https://github.com/revealjs/reveal/issues/800#issuecomment-1517329455
+  const filePathTmp = path.posix.join(
+    dirname,
+    `${filename}.build-${getRandomId(12)}.mjs`
+  )
+  assert(isTemporaryBuildFile(filePathTmp))
+  return filePathTmp
+}
+function isTemporaryBuildFile(filePath: string): boolean {
+  assertPosixPath(filePath)
+  const fileName = path.posix.basename(filePath)
+  return /\.build-[a-z0-9]{12}\.mjs$/.test(fileName)
+}
+
+function isHeaderFile(filePath: string) {
+  assertPosixPath(filePath)
+  const fileExtensions = getFileExtensions(filePath)
+  return fileExtensions.includes("h")
+}
+function getFileExtensions(filePath: string) {
+  const fileExtensions = path.posix.basename(filePath).split(".").slice(1)
+  return fileExtensions
+}
+function getFileExtension(filePath: string): string {
+  const fileExtensions = path.posix.basename(filePath).split(".").slice(1)
+  return fileExtensions.pop()!
+}
+function removeHeaderFileExtension(filePath: string) {
+  assertPosixPath(filePath)
+  const fileName = path.posix.basename(filePath)
+  const fileNameParts = fileName.split(".")
+  const fileNamePartsMod = fileNameParts.filter((p) => p !== "h")
+  assert(fileNamePartsMod.length < fileNameParts.length)
+  const fileNameMod = fileNamePartsMod.join(".")
+  return path.posix.join(path.posix.dirname(filePath), fileNameMod)
+}
+
+// Needed for the npm package 'source-map-support'. The Error.prepareStackTrace() hook of 'source-map-support' needs to be called before the file containing the source map is removed. The clean() call above removes the transpiled file from disk but it contains the inline source map.
+function triggerPrepareStackTrace(err: unknown) {
+  if (isObject(err)) {
+    // Accessing err.stack triggers prepareStackTrace()
+    const { stack } = err
+    // Ensure no compiler removes the line above
+    if (1 + 1 === 3) console.log("I_AM_NEVER_SHOWN" + stack)
+  }
+}
+
+function getErrIntroMsg(
+  operation: "transpile" | "execute",
+  filePath: FilePathResolved
+) {
+  const { filePathToShowToUserResolved } = filePath
+  const msg = [
+    // prettier ignore
+    pc.red(`Failed to ${operation}`),
+    pc.bold(pc.red(filePathToShowToUserResolved)),
+    pc.red(`because:`),
+  ].join(" ")
+  return msg
+}
+
+function cleanEsbuildErrors(errors: Message[]) {
+  errors.forEach(
+    (e) =>
+      (e.notes = e.notes.filter(
+        (note) =>
+          // Remove note:
+          // ```shell
+          // You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+          // ```
+          //
+          // From error:
+          // ```shell
+          // ✘ [ERROR] Could not resolve "#root/renderer/onRenderHtml_typo" [plugin reveal-esbuild]
+          //
+          //    renderer/+config.h.js:1:29:
+          //      1 │ import { onRenderHtml } from "#root/renderer/onRenderHtml_typo"
+          //        ╵                              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+          //
+          //  You can mark the path "#root/renderer/onRenderHtml_typo" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.
+          //
+          // ```
+          !note.text.includes("as external to exclude it from the bundle")
+      ))
+  )
+}

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

@@ -0,0 +1,27 @@
+export default getTagAttributesString;
+export type { TagAttributes };
+
+type TagAttributes = Record<
+  string,
+  string | number | boolean | undefined | null
+>;
+
+function getTagAttributesString(tagAttributes: TagAttributes): string {
+  const tagAttributesString = Object.entries(tagAttributes)
+    .filter(
+      ([_key, value]) =>
+        value !== false && value !== null && value !== undefined,
+    )
+    .map(
+      ([key, value]) =>
+        `${ensureIsValidAttributeName(key)}=${JSON.stringify(String(value))}`,
+    )
+    .join(" ");
+  if (tagAttributesString.length === 0) return "";
+  return ` ${tagAttributesString}`;
+}
+
+function ensureIsValidAttributeName(str: string): string {
+  if (/^[a-z][a-z0-9\-]*$/i.test(str) && !str.endsWith("-")) return str;
+  throw new Error(`Invalid HTML tag attribute name ${JSON.stringify(str)}`);
+}

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

@@ -0,0 +1,9 @@
+export function getTerminalWidth(): number | undefined {
+  // https://stackoverflow.com/questions/30335637/get-width-of-terminal-in-node-js/30335724#30335724
+  return (
+    (typeof process !== "undefined" &&
+      typeof process.stdout !== "undefined" &&
+      process.stdout.columns) ||
+    undefined
+  );
+}

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

@@ -0,0 +1,6 @@
+export function getValuePrintable(value: unknown): null | string {
+  if (([null, undefined] as unknown[]).includes(value)) return String(value);
+  if (["boolean", "number", "string"].includes(typeof value))
+    return JSON.stringify(value);
+  return null;
+}

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

@@ -0,0 +1,47 @@
+export { getViteDevScript }
+
+import pc from "@brillout/picocolors"
+import { assert } from "../../gaurds/assertions/assert"
+import { assertUsage } from "../../gaurds/assertions/assertUsage"
+import { assertWarning } from "../../gaurds/assertions/assertWarning"
+import { getGlobalContext } from "../../globals/contexts"
+
+async function getViteDevScript(): Promise<string> {
+  const globalContext = getGlobalContext()
+  if (globalContext.isProduction) {
+    return ""
+  }
+  const { viteDevServer } = globalContext
+
+  const fakeHtmlBegin = "<html> <head>" // White space to test whether user is using a minifier
+  const fakeHtmlEnd = "</head><body></body></html>"
+  let fakeHtml = fakeHtmlBegin + fakeHtmlEnd
+  fakeHtml = await viteDevServer.transformIndexHtml("/", fakeHtml)
+  assertUsage(
+    !fakeHtml.includes("vite-plugin-pwa"),
+    `The HTML transformer of ${pc.cyan(
+      "vite-plugin-pwa"
+    )} cannot be applied, see workaround at https://github.com/revealjs/reveal/issues/388#issuecomment-1199280084`
+  )
+  assertUsage(
+    !fakeHtml.startsWith(fakeHtmlBegin.replace(" ", "")),
+    "Vite plugins that minify the HTML are not supported by reveal, see https://github.com/revealjs/reveal/issues/224"
+  )
+  assertUsage(
+    fakeHtml.startsWith(fakeHtmlBegin) && fakeHtml.endsWith(fakeHtmlEnd),
+    "You are using a Vite Plugin that transforms the HTML in a way that conflicts with reveal. Create a new GitHub ticket to discuss a solution."
+  )
+  const viteInjection = fakeHtml.slice(
+    fakeHtmlBegin.length,
+    -1 * fakeHtmlEnd.length
+  )
+  assert(viteInjection.includes("script"))
+  assertWarning(
+    !viteInjection.includes("import("),
+    "Unexpected Vite HMR code. Reach out to a reveal maintainer on GitHub.",
+    { onlyOnce: true }
+  )
+
+  const viteDevScript = viteInjection
+  return viteDevScript
+}

package/dist/core/processing/iterators/analyzePage.ts

@@ -0,0 +1,65 @@
+export { analyzePage }
+
+import { ClientDependency } from "../../../types/interfaces/client.js"
+import { PageConfigRuntime } from "../../../types/interfaces/page.js"
+import {PageFile} from "../../__internal/index.js"
+import { getVirtualFileIdPageConfigValuesAll } from "../../files/virtual-files/virtualFilePageConfigValuesAll.js"
+import { getGlobalContext } from "../../globals/contexts/globalContext/index.js"
+import { getConfigValueRuntime } from "../getters/getConfigValue.js"
+import type { AnalysisResult } from "../getters/getPageFiles/analyzeClientSide.js"
+import { analyzeClientSide } from "../getters/getPageFiles/analyzeClientSide.js"
+import { getRevealClientEntry } from "../getters/getRevealClientEntry.js"
+
+function analyzePage(
+  pageFilesAll: PageFile[],
+  pageConfig: null | PageConfigRuntime,
+  pageId: string
+): AnalysisResult {
+  if (pageConfig) {
+    const { isClientRuntimeLoaded, isClientRouting } = analyzeClientSide(
+      pageConfig,
+      pageFilesAll,
+      pageId
+    )
+    const clientEntries: string[] = []
+    const clientFilePath =
+      getConfigValueRuntime(pageConfig, "client", "string")?.value ?? null
+    if (clientFilePath) clientEntries.push(clientFilePath)
+    if (isClientRuntimeLoaded)
+      clientEntries.push(getRevealClientEntry(isClientRouting))
+    const clientDependencies: ClientDependency[] = []
+    clientDependencies.push({
+      id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, true),
+      onlyAssets: isClientRuntimeLoaded ? false : true,
+      eagerlyImported: false,
+    })
+    // In production we inject the import of the server virtual module with ?extractAssets inside the client virtual module
+    if (!getGlobalContext().isProduction) {
+      clientDependencies.push({
+        id: getVirtualFileIdPageConfigValuesAll(pageConfig.pageId, false),
+        onlyAssets: true,
+        eagerlyImported: false,
+      })
+    }
+
+    clientEntries.forEach((clientEntry) => {
+      clientDependencies.push({
+        id: clientEntry,
+        onlyAssets: false,
+        eagerlyImported: false,
+      })
+    })
+    return {
+      isClientRuntimeLoaded,
+      isHtmlOnly: !isClientRuntimeLoaded,
+      isClientRouting,
+      clientEntries,
+      clientDependencies,
+      // pageFilesClientSide and pageFilesServerSide are only used for debugging
+      pageFilesClientSide: [],
+      pageFilesServerSide: [],
+    }
+  } else {
+    return analyzeClientSide(null, pageFilesAll, pageId)
+  }
+}

package/dist/core/processing/iterators/includes.ts

@@ -0,0 +1,10 @@
+// https://stackoverflow.com/questions/56565528/typescript-const-assertions-how-to-use-array-prototype-includes/74213179#74213179
+/** Same as Array.prototype.includes() but with type inference */
+export function includes<T>(values: readonly T[], x: unknown): x is T {
+  return values.includes(x as any);
+}
+/*
+export function includes<Arr extends any[] | readonly any[]>(arr: Arr, el: unknown): el is Arr[number] {
+  return arr.includes(el as any)
+}
+*/

package/dist/core/processing/iterators/index.ts

@@ -0,0 +1,2 @@
+export * from "./objectKeys.js";
+export * from "./includes.js";

package/dist/core/processing/iterators/objectKeys.ts

@@ -0,0 +1,6 @@
+// https://stackoverflow.com/questions/52856496/typescript-object-keys-return-string
+// https://github.com/sindresorhus/ts-extras/blob/main/source/object-keys.ts
+/** Same as Object.keys() but with type inference */
+export function objectKeys<T extends object>(obj: T): (keyof T)[] {
+  return Object.keys(obj) as any;
+}