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

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

@@ -1,490 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,10 +0,0 @@
-// 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

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

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

@@ -1,6 +0,0 @@
-// 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;
-}