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

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

@@ -1,341 +0,0 @@
-export { getHtmlTags }
-export type { HtmlTag, InjectFilterEntry, PreloadFilter }
-
-import pc from "@brillout/picocolors"
-
-import { PageConfigRuntime } from "../../../types/interfaces/page.js"
-import type { PageContextInjectAssets } from "../../assets/index.js"
-import { inferAssetTag, inferPreloadTag } from "../../assets/inferHtmlTags.js"
-import { mergeScriptTags } from "../../assets/mergeScriptTags.js"
-import { sanitizeJson } from "../../assets/sanitizeJson.js"
-import { assert } from "../../gaurds/assertions/assert/index.js"
-import { assertUsage } from "../../gaurds/assertions/assertUsage/index.js"
-import { assertWarning } from "../../gaurds/assertions/assertWarning/index.js"
-import { freezePartial } from "../../gaurds/normalization/freezePartial.js"
-import { isObject } from "../../gaurds/validators/isObject.js"
-import { getGlobalContext } from "../../globals/contexts/index.js"
-import { StreamFromReactStreamingPackage } from "../../renderer/stream/react-streaming.js"
-import {
-  PageContextSerialization,
-  serializePageContextClientSide,
-} from "../serializers/serializePageContextClientSide.js"
-import { getConfigDefinedAt } from "./getConfigDefinedAt.js"
-import { getConfigValueRuntime } from "./getConfigValue.js"
-import { PageAsset } from "./getPageAssets.js"
-import { getPageConfig } from "./getPageConfig.js"
-
-const stamp = "__injectFilterEntry"
-
-type PreloadFilter =
-  | null
-  | ((assets: InjectFilterEntry[]) => InjectFilterEntry[])
-type PreloadFilterInject = false | "HTML_BEGIN" | "HTML_END"
-/** Filter what assets reveal injects in the HTML.
- *
- * https://reveal.dev/injectFilter
- */
-type InjectFilterEntry = {
-  src: string
-  assetType: null | PageAsset["assetType"]
-  mediaType: null | PageAsset["mediaType"]
-  /** Whether src is a root in the dependency graph.
-   *  - For JavaScript this means whether src is imported by a dynamic import() statement.
-   *  - All CSS files have `isEntry: true`
-   */
-  isEntry: boolean
-  inject: PreloadFilterInject
-}
-
-type Position = "HTML_BEGIN" | "HTML_END" | "HTML_STREAM"
-type HtmlTag = {
-  htmlTag: string | (() => string)
-  position: Position
-}
-function getHtmlTags(
-  pageContext: { _isStream: boolean } & PageContextInjectAssets,
-  streamFromReactStreamingPackage: null | StreamFromReactStreamingPackage,
-  injectFilter: PreloadFilter,
-  pageAssets: PageAsset[],
-  viteDevScript: string,
-  isStream: boolean
-) {
-  assert([true, false].includes(pageContext._isHtmlOnly))
-  const isHtmlOnly = pageContext._isHtmlOnly
-  const { isProduction } = getGlobalContext()
-  const injectScriptsAt = getInjectScriptsAt(
-    pageContext.pageId,
-    pageContext._pageConfigs
-  )
-
-  const injectFilterEntries: InjectFilterEntry[] = pageAssets
-    .filter((asset) => {
-      if (asset.isEntry && asset.assetType === "script") {
-        // We could allow the user to change the position of <script> but we currently don't:
-        //  - Because of mergeScriptEntries()
-        //  - We would need to add HTML_STREAM to to PreloadFilterInject
-        // To suppor this, we should add the JavaScript entry to injectFilterEntries (with an `src` value of `null`)
-        return false
-      }
-      return true
-    })
-    .map((asset) => {
-      const inject = (() => {
-        if (!isProduction) {
-          // In development, we should always load assets as soon as possible, in order to eagerly process assets (e.g. applying the transform() hooks of Vite plugins) which are lazily discovered.
-          return "HTML_BEGIN"
-        }
-        if (asset.assetType === "style" || asset.assetType === "font") {
-          return "HTML_BEGIN"
-        }
-        if (asset.assetType === "script") {
-          if (isHtmlOnly) return false
-          return "HTML_END"
-        }
-        return false
-      })()
-      const entry: InjectFilterEntry = {
-        ...asset,
-        inject,
-        // @ts-ignore
-        [stamp]: true,
-      }
-      return entry
-    })
-  assertInjectFilterEntries(injectFilterEntries)
-
-  // ==============
-  // injectFilter()
-  // ==============
-  if (injectFilter && isProduction) {
-    Object.seal(injectFilterEntries) // `Object.seal()` instead of `Object.freeze()` to allow the user to `assets.sort()`
-    Object.values(injectFilterEntries).forEach((entry) =>
-      freezePartial(entry, {
-        inject: (val) =>
-          val === false || val === "HTML_BEGIN" || val === "HTML_END",
-      })
-    )
-    // Call the user's injectFilter() hook https://reveal.dev/injectFilter
-    const res = injectFilter(injectFilterEntries)
-    assertUsage(
-      res === undefined,
-      `injectFilter() should return ${pc.cyan("undefined")}, see https://reveal.dev/injectFilter`
-    )
-    assertInjectFilterUsage(injectFilterEntries)
-  }
-
-  const htmlTags: HtmlTag[] = []
-
-  // ==============
-  // Non-JavaScript
-  // ==============
-  injectFilterEntries
-    .filter((asset) => asset.assetType !== "script" && asset.inject)
-    .forEach((asset) => {
-      if (!asset.inject) return
-      const htmlTag = asset.isEntry
-        ? inferAssetTag(asset)
-        : inferPreloadTag(asset)
-      htmlTags.push({ htmlTag, position: asset.inject })
-    })
-
-  // ==========
-  // JavaScript
-  // ==========
-  // - By default, we place the entry <script> towards the end of the HTML for better performance.
-  //   - Performance-wise, it's more interesting to start showing the page (parse HTML and load CSS) before starting loading scripts.
-  //   - But with HTML streaming, in order to support [Progressive Rendering](https://reveal.dev/streaming#progressive-rendering), the entry <script> should be injected earlier instead.
-  // - The entry <script> shouldn't be `<script defer>` upon HTML streaming, otherwise progressive hydration while SSR streaming won't work.
-  // - `<script id="reveal_pageContext" type="application/json">` (the `pageContext` JSON) should be fully sent before reveal's client runtime starts executing.
-  //   - Otherwise, race condition "SyntaxError: Unterminated string in JSON": https://github.com/revealjs/reveal/issues/567
-  //   - `<script id="reveal_pageContext" type="application/json">` must appear before the entry <script> (which loads reveal's client runtime).
-  //   - `<script id="reveal_pageContext" type="application/json">` can't be async nor defer.
-  const positionJavaScriptDefault = "HTML_END"
-  const positionJavaScriptEntry = (() => {
-    if (injectScriptsAt !== null) {
-      if (pageContext._pageContextPromise) {
-        assertWarning(
-          injectScriptsAt === "HTML_END" || !isStream,
-          `You're setting injectScriptsAt to ${pc.code(
-            JSON.stringify(injectScriptsAt)
-          )} while using HTML streaming with a pageContext promise (https://reveal.dev/streaming#initial-data-after-stream-end) which is contradictory: the pageContext promise is skipped.`,
-          { onlyOnce: true }
-        )
-      }
-      if (injectScriptsAt === "HTML_STREAM" && !isStream) {
-        return positionJavaScriptDefault
-      }
-      return injectScriptsAt
-    }
-    if (pageContext._pageContextPromise) {
-      // - If there is a pageContext._pageContextPromise then <script id="reveal_pageContext" type="application/json"> needs to await for it.
-      // - pageContext._pageContextPromise is typically resolved only after the page's components are rendered and the stream ended.
-      // - https://reveal.dev/streaming#initial-data-after-stream-end
-      return positionJavaScriptDefault
-    }
-    if (
-      streamFromReactStreamingPackage &&
-      !streamFromReactStreamingPackage.hasStreamEnded()
-    ) {
-      // If there is a stream then, in order to support progressive hydration, inject the JavaScript during the stream after React(/Vue/Solid/...) resolved the first suspense boundary.
-      return "HTML_STREAM"
-    }
-    return positionJavaScriptDefault
-  })()
-  if (pageContext._pageContextPromise && streamFromReactStreamingPackage) {
-    assertWarning(
-      false,
-      "We recommend against using HTML streaming and a pageContext promise (https://reveal.dev/streaming#initial-data-after-stream-end) at the same time, because progressive hydration (https://reveal.dev/streaming#progressive-rendering) won't work.",
-      { onlyOnce: true }
-    )
-  }
-  // <script id="reveal_pageContext" type="application/json">
-  if (!isHtmlOnly) {
-    htmlTags.push({
-      htmlTag: () =>
-        // Needs to be called after resolvePageContextPromise()
-        getPageContextJsonScriptTag(pageContext),
-      position: positionJavaScriptEntry,
-    })
-  }
-  // The JavaScript entry <script> tag
-  const scriptEntry = mergeScriptEntries(pageAssets, viteDevScript)
-  if (scriptEntry) {
-    htmlTags.push({
-      htmlTag: scriptEntry,
-      position: positionJavaScriptEntry,
-    })
-  }
-  // Preload tags
-  injectFilterEntries
-    .filter((asset) => asset.assetType === "script")
-    .forEach((asset) => {
-      assert(!asset.isEntry) // Users cannot re-order JavaScript entries, see creation of injectFilterEntries
-      const htmlTag = inferPreloadTag(asset)
-      if (!asset.inject) return
-      // Ideally, instead of this conditional ternary operator, we should add HTML_STREAM to PreloadFilterInject
-      const position =
-        asset.inject === "HTML_END" ? positionJavaScriptEntry : asset.inject
-      htmlTags.push({ htmlTag, position })
-    })
-
-  return htmlTags
-}
-
-function mergeScriptEntries(
-  pageAssets: PageAsset[],
-  viteDevScript: string
-): null | string {
-  const scriptEntries = pageAssets.filter(
-    (pageAsset) => pageAsset.isEntry && pageAsset.assetType === "script"
-  )
-  const scriptTagsHtml = `${viteDevScript}${scriptEntries.map((asset) => inferAssetTag(asset)).join("")}`
-  const scriptTag = mergeScriptTags(scriptTagsHtml)
-  return scriptTag
-}
-
-function getPageContextJsonScriptTag(
-  pageContext: PageContextSerialization
-): string {
-  const pageContextSerialized = sanitizeJson(
-    serializePageContextClientSide(pageContext)
-  )
-  const htmlTag = `<script id="reveal_pageContext" type="application/json">${pageContextSerialized}</script>`
-
-  // Used by contra.com https://github.com/gajus
-  // @ts-expect-error
-  pageContext._pageContextHtmlTag = htmlTag
-
-  return htmlTag
-}
-
-function assertInjectFilterEntries(injectFilterEntries: InjectFilterEntry[]) {
-  try {
-    checkForWrongUsage(injectFilterEntries)
-  } catch (err) {
-    if (
-      (err as undefined | { message: string })?.message.includes(
-        "[Wrong Usage]"
-      )
-    ) {
-      assert(false)
-    }
-    throw err
-  }
-}
-
-function assertInjectFilterUsage(injectFilterEntries: InjectFilterEntry[]) {
-  checkForWrongUsage(injectFilterEntries)
-  checkForWarnings(injectFilterEntries)
-}
-function checkForWrongUsage(injectFilterEntries: InjectFilterEntry[]) {
-  injectFilterEntries.forEach((entry, i) => {
-    assertUsage(isObject(entry), `[injectFilter()] Entry ${i} isn't an object`)
-    assertUsage(
-      typeof entry.src === "string",
-      `[injectFilter()] Entry ${i} is missing property ${pc.cyan("src")}`
-    )
-    assertUsage(
-      (entry as Record<string, unknown>)[stamp] === true,
-      `[injectFilter()] Entry ${i} (${entry.src}) isn't the original object, see https://reveal.dev/injectFilter`
-    )
-    assert([false, "HTML_BEGIN", "HTML_END"].includes(entry.inject))
-    assert(entry.assetType === null || typeof entry.assetType === "string")
-    assert(entry.mediaType === null || typeof entry.mediaType === "string")
-    assert(typeof entry.isEntry === "boolean")
-    assert(Object.keys(entry).length === 6)
-  })
-}
-function checkForWarnings(injectFilterEntries: InjectFilterEntry[]) {
-  injectFilterEntries.forEach((a) => {
-    /*
-    if (a.assetType === 'script' && a.isEntry) {
-      assertUsage(a.inject, `[injectFilter()] ${a.src} needs to be injected`)
-    }
-    */
-    if (a.assetType === "style" && a.isEntry) {
-      // In development, Vite automatically inject styles, but we still inject `<link rel="stylesheet" type="text/css" href="${src}">` tags in order to avoid FOUC (flash of unstyled content).
-      //  - https://github.com/vitejs/vite/issues/2282
-      //  - https://github.com/revealjs/reveal/issues/261
-      assertWarning(
-        a.inject,
-        `[injectFilter()] We recommend against not injecting ${a.src}`,
-        {
-          onlyOnce: true,
-        }
-      )
-    }
-    if (a.assetType === "script") {
-      assertWarning(
-        a.inject,
-        `[injectFilter()] We recommend against not preloading JavaScript (${a.src})`,
-        {
-          onlyOnce: true,
-        }
-      )
-    }
-  })
-}
-function getInjectScriptsAt(
-  pageId: string,
-  pageConfigs: PageConfigRuntime[]
-): null | Position {
-  if (pageConfigs.length === 0) return null // only support V1 design
-  const pageConfig = getPageConfig(pageId, pageConfigs)
-  const configValue = getConfigValueRuntime(pageConfig, "injectScriptsAt")
-  if (!configValue) return null
-  const injectScriptsAt = configValue.value
-  assert(configValue.definedAtData)
-  const configDefinedAt = getConfigDefinedAt(
-    "Config",
-    "injectScriptsAt",
-    configValue.definedAtData
-  )
-  assertUsage(
-    injectScriptsAt === null ||
-      injectScriptsAt === "HTML_BEGIN" ||
-      injectScriptsAt === "HTML_END" ||
-      injectScriptsAt === "HTML_STREAM",
-    `${configDefinedAt} has an invalid value`
-  )
-  return injectScriptsAt
-}

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

@@ -1,122 +0,0 @@
-// Purpose of this file:
-//  - Swallow redundant error messages (Vite is buggy and emits the same error multiple times)
-//  - Prepend "[request(n)]" tag to Vite logs
-
-// The mechanism is skipped if the runtime doesn't support Async Hooks:
-//  - Bun doesn't support Async Hooks: https://github.com/oven-sh/bun/issues/1832
-//  - Node.js and Deno support Async Hooks
-
-// We purposely don't use config.logger.hasErrorLogged(err) because:
-// - We don't trust Vite with such details
-//   - Example of Vite bug leading to swallowing of errors: https://github.com/vitejs/vite/issues/12631
-// - We dedupe errors ourself with getHttpRequestAsyncStore().shouldErrorBeSwallowed()
-
-export { getHttpRequestAsyncStore, installHttpRequestAsyncStore };
-
-import type { AsyncLocalStorage as AsyncLocalStorageType } from "node:async_hooks";
-import { isDeepStrictEqual } from "node:util";
-import {
-  assert,
-  assertIsNotProductionRuntime,
-  isObject,
-  unique,
-} from "../../../plugins/utils.js";
-import { isEquivalentErrorWithCodeSnippet } from "../../gaurds/logger/loggerNotProd/errorWithCodeSnippet.js";
-import { getConfigBuildErrorFormatted } from "./getRevealConfig/transpileAndExecuteFile.js";
-import { renderPage_addWrapper } from "../../renderer/page/index.js";
-import { logErrorDebugNote } from "../../gaurds/logger/loggerNotProd.js";
-
-assertIsNotProductionRuntime();
-
-type HttpRequestAsyncStore = {
-  httpRequestId: number;
-  // Error swallowing mechanism
-  shouldErrorBeSwallowed: (err: unknown) => boolean;
-  markErrorAsLogged: (err: unknown) => void;
-  errorDebugNoteAlreadyShown: boolean;
-};
-let asyncLocalStorage: null | AsyncLocalStorageType<HttpRequestAsyncStore> =
-  null;
-
-async function installHttpRequestAsyncStore(): Promise<void> {
-  let mod: typeof import("node:async_hooks");
-  try {
-    mod = await import("node:async_hooks");
-  } catch {
-    return;
-  }
-  asyncLocalStorage = new mod.AsyncLocalStorage();
-  renderPage_addWrapper(async (httpRequestId, renderPage) => {
-    assert(asyncLocalStorage);
-
-    const loggedErrors = new Set<unknown>();
-    const markErrorAsLogged = (err: unknown) => {
-      loggedErrors.add(err);
-    };
-
-    const shouldErrorBeSwallowed = (err: unknown) => {
-      if (
-        loggedErrors.has(err) ||
-        Array.from(loggedErrors).some((errAlreadyLogged) =>
-          isEquivalent(err, errAlreadyLogged),
-        )
-      ) {
-        // In principle, some random message can be shown between the non-swallowed error and this logErrorDebugNote() call.
-        // We take a leap of faith that it happens only seldomly and that it's worth the risk.
-        logErrorDebugNote();
-        return true;
-      } else {
-        return false;
-      }
-    };
-
-    const store = {
-      httpRequestId,
-      markErrorAsLogged,
-      shouldErrorBeSwallowed,
-      errorDebugNoteAlreadyShown: false,
-    };
-    const pageContextReturn = await asyncLocalStorage.run(store, renderPage);
-    return { pageContextReturn };
-  });
-  return;
-}
-
-function getHttpRequestAsyncStore(): null | undefined | HttpRequestAsyncStore {
-  if (asyncLocalStorage === null) return null;
-  const store = asyncLocalStorage.getStore();
-  assert(store === undefined || isObject(store));
-  return store;
-}
-
-function isEquivalent(err1: unknown, err2: unknown) {
-  if (err1 === err2) return true;
-  if (!isObject(err1) || !isObject(err2)) return false;
-
-  {
-    const errMsgFormatted1 = getConfigBuildErrorFormatted(err1);
-    const errMsgFormatted2 = getConfigBuildErrorFormatted(err2);
-    if (errMsgFormatted1 && errMsgFormatted1 === errMsgFormatted2) return true;
-  }
-
-  if (isEquivalentErrorWithCodeSnippet(err1, err2)) return true;
-
-  if (
-    unique([
-      // error.message and error.stack aren't enumerable and therefore not listed by Object.keys()
-      "message",
-      "stack",
-      ...Object.keys(err1),
-      ...Object.keys(err2),
-    ]).every((k) => {
-      // isDeepStrictEqual() need to compare error.position wich is an object.
-      if (isDeepStrictEqual(err1[k], err2[k])) return true;
-      // console.log('diff', k)
-      return false;
-    })
-  ) {
-    return true;
-  }
-
-  return false;
-}

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

@@ -1,177 +0,0 @@
-export { getHttpResponseBody, getHttpResponseBodyStreamHandlers }
-export type { HttpResponseBody }
-
-import pc from "@brillout/picocolors"
-import { RenderHook } from "../../renderer/page/executeOnRenderHtmlHook.js"
-import { getHtmlString, type HtmlRender } from "../../renderer/stream/html.js"
-import {
-  StreamReadableNode,
-  StreamReadableWeb,
-  StreamWritableNode,
-  StreamWritableWeb,
-  getStreamName,
-  getStreamReadableNode,
-  getStreamReadableWeb,
-  inferStreamName,
-  isStream,
-  isStreamPipeNode,
-  isStreamPipeWeb,
-  isStreamReadableNode,
-  isStreamReadableWeb,
-  isStreamWritableNode,
-  isStreamWritableWeb,
-  pipeToStreamWritableNode,
-  pipeToStreamWritableWeb,
-} from "../../renderer/stream/index.js"
-import { assert, assertUsage } from "../../renderer/stream/utils.js"
-
-const streamDocs = "See https://reveal.dev/streaming for more information."
-
-type HttpResponseBody = {
-  body: string
-  pipe: (writable: StreamWritableWeb | StreamWritableNode) => void
-  getReadableWebStream: () => StreamReadableWeb
-  getReadableNodeStream: () => Promise<StreamReadableNode>
-  getBody: () => Promise<string>
-}
-
-function getHttpResponseBody(
-  htmlRender: HtmlRender,
-  renderHook: null | RenderHook
-) {
-  if (typeof htmlRender !== "string") {
-    assertUsage(
-      false,
-      getErrMsg(
-        htmlRender,
-        renderHook,
-        "body",
-        `Use ${pc.cyan("pageContext.httpResponse.pipe()")} instead`
-      )
-    )
-  }
-  const body = htmlRender
-  return body
-}
-
-function getHttpResponseBodyStreamHandlers(
-  htmlRender: HtmlRender,
-  renderHook: null | RenderHook
-) {
-  return {
-    pipe(writable: StreamWritableNode | StreamWritableWeb) {
-      const getErrMsgMixingStreamTypes = (
-        writableType: "Web Writable" | "Node.js Writable"
-      ) =>
-        `The ${getErrMsgBody(htmlRender, renderHook)} while a ${
-          writableType as string
-        } was passed to pageContext.httpResponse.pipe() which is contradictory. You cannot mix a Web Stream with a Node.js Stream.` as const
-      if (isStreamWritableWeb(writable)) {
-        const success = pipeToStreamWritableWeb(htmlRender, writable)
-        if (success) {
-          return
-        } else {
-          assert(
-            isStreamReadableNode(htmlRender) || isStreamPipeNode(htmlRender)
-          )
-          assertUsage(false, getErrMsgMixingStreamTypes("Web Writable"))
-        }
-      }
-      if (isStreamWritableNode(writable)) {
-        const success = pipeToStreamWritableNode(htmlRender, writable)
-        if (success) {
-          return
-        } else {
-          assert(isStreamReadableWeb(htmlRender) || isStreamPipeWeb(htmlRender))
-          assertUsage(false, getErrMsgMixingStreamTypes("Node.js Writable"))
-        }
-      }
-      assertUsage(
-        false,
-        `The argument ${pc.cyan("writable")} passed to ${pc.cyan(
-          "pageContext.httpResponse.pipe(writable)"
-        )} doesn't seem to be ${getStreamName("writable", "web")} nor ${getStreamName("writable", "node")}.`
-      )
-    },
-    getReadableWebStream() {
-      const webStream = getStreamReadableWeb(htmlRender)
-      if (webStream === null) {
-        assertUsage(
-          false,
-          getErrMsg(
-            htmlRender,
-            renderHook,
-            "getReadableWebStream()",
-            getFixMsg("readable", "web")
-          )
-        )
-      }
-      return webStream
-    },
-    async getReadableNodeStream() {
-      const nodeStream = await getStreamReadableNode(htmlRender)
-      if (nodeStream === null) {
-        assertUsage(
-          false,
-          getErrMsg(
-            htmlRender,
-            renderHook,
-            "getReadableNodeStream()",
-            getFixMsg("readable", "node")
-          )
-        )
-      }
-      return nodeStream
-    },
-    async getBody(): Promise<string> {
-      const body = await getHtmlString(htmlRender)
-      return body
-    },
-  }
-
-  function getFixMsg(kind: "pipe" | "readable", type: "web" | "node") {
-    const streamName = getStreamName(kind, type)
-    assert(["a ", "an ", "the "].some((s) => streamName.startsWith(s)))
-    assert(renderHook)
-    const { hookFilePath, hookName } = renderHook
-    return `Make sure the ${hookName}() defined by ${hookFilePath} hook provides ${streamName} instead`
-  }
-}
-
-function getErrMsg(
-  htmlRender: HtmlRender,
-  renderHook: null | RenderHook,
-  method: string,
-  msgAddendum?: string
-) {
-  assert(!msgAddendum || !msgAddendum.endsWith("."))
-  const errMsgBody = getErrMsgBody(htmlRender, renderHook)
-  return [
-    `pageContext.httpResponse.${method} can't be used because the ${errMsgBody}`,
-    msgAddendum,
-    streamDocs,
-  ]
-    .filter(Boolean)
-    .join(". ")
-}
-function getErrMsgBody(htmlRender: HtmlRender, renderHook: null | RenderHook) {
-  assert(renderHook)
-  const { hookFilePath, hookName } = renderHook
-  const hookReturnType = getHookReturnType(htmlRender)
-  assert(["a ", "an ", "the "].some((s) => hookReturnType.startsWith(s)))
-  const errMsgBody =
-    `${hookName as string}()\ hook defined by ${hookFilePath} provides ${
-      hookReturnType as string
-    }` as const
-  assert(!errMsgBody.endsWith(" "))
-  return errMsgBody
-}
-function getHookReturnType(htmlRender: HtmlRender) {
-  if (typeof htmlRender === "string") {
-    return "an HTML string"
-  } else if (isStream(htmlRender)) {
-    return inferStreamName(htmlRender)
-  } else {
-    assert(false)
-  }
-}