@cedarjs/vite 0.0.4

package/dist/cjs/streaming/buildForStreamingServer.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildForStreamingServer_exports = {};
+__export(buildForStreamingServer_exports, {
+  buildForStreamingServer: () => buildForStreamingServer
+});
+module.exports = __toCommonJS(buildForStreamingServer_exports);
+var import_vite = require("vite");
+var import_vite_plugin_cjs_interop = require("vite-plugin-cjs-interop");
+var import_project_config = require("@cedarjs/project-config");
+async function buildForStreamingServer({
+  verbose = false
+}) {
+  console.log("Starting streaming server build...\n");
+  const rwPaths = (0, import_project_config.getPaths)();
+  if (!rwPaths.web.viteConfig) {
+    throw new Error("Vite config not found");
+  }
+  await (0, import_vite.build)({
+    configFile: rwPaths.web.viteConfig,
+    plugins: [
+      (0, import_vite_plugin_cjs_interop.cjsInterop)({
+        dependencies: [
+          // Skip ESM modules: rwjs/auth, rwjs/web, rwjs/auth-*-middleware, rwjs/router
+          "@cedarjs/forms",
+          "@cedarjs/prerender/*",
+          "@cedarjs/auth-*-api",
+          "@cedarjs/auth-*-web"
+        ]
+      })
+    ],
+    build: {
+      // TODO (RSC): Remove `minify: false` when we don't need to debug as often
+      minify: false,
+      outDir: rwPaths.web.distSsr,
+      ssr: true,
+      emptyOutDir: true
+    },
+    envFile: false,
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV)
+    },
+    logLevel: verbose ? "info" : "warn"
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildForStreamingServer
+});

package/dist/cjs/streaming/collectCss.js

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var collectCss_exports = {};
+__export(collectCss_exports, {
+  collectCssPaths: () => collectCssPaths,
+  componentsModules: () => componentsModules
+});
+module.exports = __toCommonJS(collectCss_exports);
+var import_vite = require("vite");
+const componentsModules = (components, vite) => {
+  const matchedModules = /* @__PURE__ */ new Set();
+  components.forEach((component) => {
+    const modules = vite.moduleGraph.getModulesByFile((0, import_vite.normalizePath)(component));
+    modules?.forEach((mod) => {
+      matchedModules.add(mod);
+    });
+  });
+  return matchedModules;
+};
+const collectCssPaths = (mods, cssLinks = /* @__PURE__ */ new Set(), checkedComponents = /* @__PURE__ */ new Set()) => {
+  for (const mod of mods) {
+    if (mod.file?.endsWith(".scss") || mod.file?.endsWith(".css") || mod.file?.endsWith(".less")) {
+      cssLinks.add(mod.url);
+    }
+    if (mod.importedModules.size > 0 && !checkedComponents.has(mod.id)) {
+      checkedComponents.add(mod.id);
+      collectCssPaths(mod.importedModules, cssLinks, checkedComponents);
+    }
+  }
+  return cssLinks;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  collectCssPaths,
+  componentsModules
+});

package/dist/cjs/streaming/createReactStreamingHandler.js

@@ -0,0 +1,173 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createReactStreamingHandler_exports = {};
+__export(createReactStreamingHandler_exports, {
+  createReactStreamingHandler: () => createReactStreamingHandler
+});
+module.exports = __toCommonJS(createReactStreamingHandler_exports);
+var import_path = __toESM(require("path"), 1);
+var import_fetch = require("@whatwg-node/fetch");
+var import_isbot = require("isbot");
+var import_AuthProviderState = require("@cedarjs/auth/dist/AuthProvider/AuthProviderState.js");
+var import_project_config = require("@cedarjs/project-config");
+var import_util = require("@cedarjs/router/util");
+var import_middleware = require("@cedarjs/web/middleware");
+var import_invokeMiddleware = require("../middleware/invokeMiddleware.js");
+var import_utils = require("../utils.js");
+var import_streamHelpers = require("./streamHelpers.js");
+var import_triggerRouteHooks = require("./triggerRouteHooks.js");
+const isbot = (0, import_isbot.createIsbotFromList)(
+  import_isbot.list.filter((record) => !record.includes("chrome-lighthouse"))
+);
+const createReactStreamingHandler = async ({
+  routes,
+  clientEntryPath,
+  getStylesheetLinks,
+  getMiddlewareRouter
+}, viteDevServer) => {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const rwConfig = (0, import_project_config.getConfig)();
+  const isProd = !viteDevServer;
+  const middlewareRouter = await getMiddlewareRouter();
+  let entryServerImport;
+  let fallbackDocumentImport;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  if (isProd) {
+    if (rscEnabled) {
+      entryServerImport = await import((0, import_utils.makeFilePath)(rwPaths.web.distSsrEntryServer));
+    } else {
+      entryServerImport = await import((0, import_utils.makeFilePath)(rwPaths.web.distSsrEntryServer));
+    }
+    fallbackDocumentImport = await import((0, import_utils.makeFilePath)(rwPaths.web.distSsrDocument));
+  }
+  return async (req) => {
+    let mwResponse = import_middleware.MiddlewareResponse.next();
+    let decodedAuthState = {
+      ...import_AuthProviderState.middlewareDefaultAuthProviderState,
+      cookieHeader: req.headers.get("cookie"),
+      roles: []
+    };
+    let currentRoute;
+    let parsedParams = {};
+    const currentUrl = new URL(req.url);
+    for (const route of routes) {
+      const { match, ...rest } = (0, import_util.matchPath)(
+        route.pathDefinition,
+        currentUrl.pathname
+      );
+      if (match) {
+        currentRoute = route;
+        parsedParams = rest;
+        break;
+      }
+    }
+    const cssLinks = getStylesheetLinks(currentRoute);
+    if (middlewareRouter) {
+      const matchedMw = middlewareRouter.find(req.method, req.url);
+      [mwResponse, decodedAuthState] = await (0, import_invokeMiddleware.invoke)(
+        req,
+        matchedMw?.handler,
+        {
+          route: currentRoute,
+          cssPaths: cssLinks,
+          params: matchedMw?.params,
+          viteDevServer
+        }
+      );
+      if (mwResponse.isRedirect() || mwResponse.body) {
+        return mwResponse.toResponse();
+      }
+    }
+    if (!currentRoute) {
+      throw new Error("404 handling not implemented");
+    }
+    if (currentRoute.redirect) {
+      return new import_fetch.Response(null, {
+        status: 302,
+        headers: {
+          Location: currentRoute.redirect.to
+        }
+      });
+    }
+    if (!isProd) {
+      entryServerImport = await (0, import_utils.ssrLoadEntryServer)(viteDevServer);
+      fallbackDocumentImport = await viteDevServer.ssrLoadModule(
+        rwPaths.web.document
+      );
+    }
+    const ServerEntry = entryServerImport.ServerEntry || entryServerImport.default;
+    const FallbackDocument = fallbackDocumentImport.Document || fallbackDocumentImport.default;
+    let metaTags = [];
+    let routeHookPath = currentRoute.routeHooks;
+    if (isProd) {
+      routeHookPath = currentRoute.routeHooks ? import_path.default.join(rwPaths.web.distRouteHooks, currentRoute.routeHooks) : null;
+    }
+    const routeHookOutput = await (0, import_triggerRouteHooks.loadAndRunRouteHooks)({
+      paths: [(0, import_project_config.getAppRouteHook)(isProd), routeHookPath],
+      reqMeta: {
+        req,
+        parsedParams
+      },
+      viteDevServer
+    });
+    metaTags = routeHookOutput.meta;
+    const jsBundles = [viteDevServer ? clientEntryPath : "/" + clientEntryPath];
+    if (currentRoute.bundle) {
+      jsBundles.push("/" + currentRoute.bundle);
+    }
+    const isSeoCrawler = isbot(req.headers.get("user-agent") || "");
+    const reactResponse = await (0, import_streamHelpers.reactRenderToStreamResponse)(
+      mwResponse,
+      {
+        ServerEntry,
+        FallbackDocument,
+        currentUrl,
+        metaTags,
+        cssLinks,
+        isProd,
+        jsBundles,
+        authState: decodedAuthState
+      },
+      {
+        waitForAllReady: isSeoCrawler,
+        onError: (err) => {
+          if (!isProd && viteDevServer) {
+            viteDevServer.ssrFixStacktrace(err);
+          }
+          console.error(err);
+        }
+      }
+    );
+    return reactResponse;
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createReactStreamingHandler
+});

package/dist/cjs/streaming/streamHelpers.js

@@ -0,0 +1,228 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var streamHelpers_exports = {};
+__export(streamHelpers_exports, {
+  importModule: () => importModule,
+  reactRenderToStreamResponse: () => reactRenderToStreamResponse
+});
+module.exports = __toCommonJS(streamHelpers_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_utils = require("../utils.js");
+var import_bufferedTransform = require("./transforms/bufferedTransform.js");
+var import_cancelTimeoutTransform = require("./transforms/cancelTimeoutTransform.js");
+var import_serverInjectionTransform = require("./transforms/serverInjectionTransform.js");
+const import_meta = {};
+const rscWebpackShims = `globalThis.__rw_module_cache__ ||= new Map();
+
+globalThis.__webpack_chunk_load__ ||= (id) => {
+  console.log('rscWebpackShims chunk load id', id)
+  return import(id).then((mod) => {
+    console.log('rscWebpackShims chunk load mod', mod)
+
+    // checking mod.default to better support CJS. If it's an object, it's
+    // likely a CJS module. Otherwise it's probably an ES module with a
+    // default export
+    if (mod.default && typeof mod.default === 'object') {
+      return globalThis.__rw_module_cache__.set(id, mod.default)
+    }
+
+    return globalThis.__rw_module_cache__.set(id, mod)
+  })
+};
+
+globalThis.__webpack_require__ ||= (id) => {
+  console.log('rscWebpackShims require id', id)
+  return globalThis.__rw_module_cache__.get(id)
+};
+`;
+async function reactRenderToStreamResponse(mwRes, renderOptions, streamOptions) {
+  const { waitForAllReady = false } = streamOptions;
+  const {
+    ServerEntry,
+    FallbackDocument,
+    currentUrl,
+    metaTags,
+    cssLinks,
+    isProd,
+    jsBundles = [],
+    authState
+  } = renderOptions;
+  if (!isProd) {
+    jsBundles.push(
+      new URL("../../inject/reactRefresh.js", import_meta.url).pathname
+    );
+  }
+  const assetMap = JSON.stringify({
+    css: cssLinks,
+    meta: metaTags
+  });
+  const rscEnabled = (0, import_project_config.getConfig)().experimental?.rsc?.enabled;
+  const { createElement } = rscEnabled ? await importModule("__rwjs__react") : await import("react");
+  const {
+    createInjector,
+    ServerHtmlProvider,
+    ServerInjectedHtml
+  } = rscEnabled ? await importModule("__rwjs__server_inject") : await import("@cedarjs/web/serverInject");
+  const { renderToString } = rscEnabled ? await importModule("rd-server") : await import("react-dom/server");
+  const { injectionState, injectToPage } = createInjector();
+  const bufferTransform = (0, import_bufferedTransform.createBufferedTransformStream)();
+  const serverInjectionTransform = (0, import_serverInjectionTransform.createServerInjectionTransform)({
+    injectionState,
+    createElement,
+    ServerInjectedHtml,
+    renderToString,
+    onlyOnFlush: waitForAllReady
+  });
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    controller.abort();
+  }, 1e4);
+  const timeoutTransform = (0, import_cancelTimeoutTransform.createTimeoutTransform)(timeoutHandle);
+  const { ServerAuthProvider } = rscEnabled ? await importModule("__rwjs__server_auth_provider") : await import("@cedarjs/auth/dist/AuthProvider/ServerAuthProvider.js");
+  const { LocationProvider } = rscEnabled ? await importModule("__rwjs__location") : await import("@cedarjs/router/location");
+  const renderRoot = (url) => {
+    return createElement(
+      ServerAuthProvider,
+      {
+        value: authState
+      },
+      createElement(
+        LocationProvider,
+        {
+          location: url
+        },
+        createElement(
+          ServerHtmlProvider,
+          {
+            value: injectToPage
+          },
+          createElement(ServerEntry, {
+            css: cssLinks,
+            meta: metaTags
+          })
+        )
+      )
+    );
+  };
+  const bootstrapOptions = {
+    bootstrapScriptContent: (
+      // Only insert assetMap if client side JS will be loaded
+      jsBundles.length > 0 ? `window.__REDWOOD__ASSET_MAP = ${assetMap}; ${rscWebpackShims}` : void 0
+    ),
+    bootstrapModules: jsBundles
+  };
+  const { renderToReadableStream } = rscEnabled ? await importModule("rd-server") : await import("react-dom/server.edge");
+  try {
+    let didErrorOutsideShell = false;
+    const renderToStreamOptions = {
+      ...bootstrapOptions,
+      signal: controller.signal,
+      onError: (err) => {
+        didErrorOutsideShell = true;
+        console.error("\u{1F53B} Caught error outside shell");
+        streamOptions.onError?.(err);
+      }
+    };
+    const root = renderRoot(currentUrl);
+    const reactStream = await renderToReadableStream(root, renderToStreamOptions);
+    if (waitForAllReady) {
+      await reactStream.allReady;
+    }
+    const transformsToApply = [
+      !waitForAllReady && bufferTransform,
+      serverInjectionTransform,
+      !waitForAllReady && timeoutTransform
+    ];
+    const outputStream = applyStreamTransforms(
+      reactStream,
+      transformsToApply
+    );
+    mwRes.status = didErrorOutsideShell ? 500 : 200;
+    mwRes.body = outputStream;
+    mwRes.headers.set("content-type", "text/html");
+    return mwRes.toResponse();
+  } catch (e) {
+    console.error("\u{1F53B} Failed to render shell");
+    streamOptions.onError?.(e);
+    const fallbackShell = await renderToReadableStream(
+      FallbackDocument({
+        children: null,
+        css: cssLinks,
+        meta: metaTags
+      }),
+      bootstrapOptions
+    );
+    mwRes.status = 500;
+    mwRes.body = fallbackShell;
+    mwRes.headers.set("content-type", "text/html");
+    return mwRes.toResponse();
+  } finally {
+    clearTimeout(timeoutHandle);
+  }
+}
+function applyStreamTransforms(reactStream, transformsToApply) {
+  let outputStream = reactStream;
+  for (const transform of transformsToApply) {
+    if (!transform) {
+      continue;
+    }
+    outputStream = outputStream.pipeThrough(transform);
+  }
+  return outputStream;
+}
+async function importModule(mod) {
+  const distSsr = (0, import_project_config.getPaths)().web.distSsr;
+  const rdServerPath = (0, import_utils.makeFilePath)(import_node_path.default.join(distSsr, "rd-server.mjs"));
+  const reactPath = (0, import_utils.makeFilePath)(import_node_path.default.join(distSsr, "__rwjs__react.mjs"));
+  const locationPath = (0, import_utils.makeFilePath)(import_node_path.default.join(distSsr, "__rwjs__location.mjs"));
+  const ServerAuthProviderPath = (0, import_utils.makeFilePath)(
+    import_node_path.default.join(distSsr, "__rwjs__server_auth_provider.mjs")
+  );
+  const ServerInjectPath = (0, import_utils.makeFilePath)(
+    import_node_path.default.join(distSsr, "__rwjs__server_inject.mjs")
+  );
+  if (mod === "rd-server") {
+    return (await import(rdServerPath)).default;
+  } else if (mod === "__rwjs__react") {
+    return (await import(reactPath)).default;
+  } else if (mod === "__rwjs__location") {
+    return await import(locationPath);
+  } else if (mod === "__rwjs__server_auth_provider") {
+    return await import(ServerAuthProviderPath);
+  } else if (mod === "__rwjs__server_inject") {
+    return await import(ServerInjectPath);
+  }
+  throw new Error("Unknown module " + mod);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importModule,
+  reactRenderToStreamResponse
+});

package/dist/cjs/streaming/transforms/bufferedTransform.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bufferedTransform_exports = {};
+__export(bufferedTransform_exports, {
+  createBufferedTransformStream: () => createBufferedTransformStream
+});
+module.exports = __toCommonJS(bufferedTransform_exports);
+const queueTask = setImmediate;
+function createBufferedTransformStream() {
+  let bufferedBytes = new Uint8Array();
+  let pendingFlush = null;
+  const flushBuffer = (controller) => {
+    if (!pendingFlush) {
+      pendingFlush = new Promise((resolve) => {
+        queueTask(() => {
+          controller.enqueue(bufferedBytes);
+          bufferedBytes = new Uint8Array();
+          pendingFlush = null;
+          resolve();
+        });
+      });
+    }
+  };
+  return new TransformStream({
+    transform(chunk, controller) {
+      const newBufferedBytes = new Uint8Array(
+        bufferedBytes.length + chunk.length
+      );
+      newBufferedBytes.set(bufferedBytes);
+      newBufferedBytes.set(chunk, bufferedBytes.length);
+      bufferedBytes = newBufferedBytes;
+      flushBuffer(controller);
+    },
+    flush() {
+      if (pendingFlush) {
+        return pendingFlush;
+      }
+      return;
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBufferedTransformStream
+});

package/dist/cjs/streaming/transforms/cancelTimeoutTransform.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cancelTimeoutTransform_exports = {};
+__export(cancelTimeoutTransform_exports, {
+  createTimeoutTransform: () => createTimeoutTransform
+});
+module.exports = __toCommonJS(cancelTimeoutTransform_exports);
+function createTimeoutTransform(timeoutHandle) {
+  return new TransformStream({
+    flush() {
+      clearTimeout(timeoutHandle);
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTimeoutTransform
+});

package/dist/cjs/streaming/transforms/encode-decode.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var encode_decode_exports = {};
+__export(encode_decode_exports, {
+  decodeText: () => decodeText,
+  encodeText: () => encodeText
+});
+module.exports = __toCommonJS(encode_decode_exports);
+const textDecoder = new TextDecoder();
+function encodeText(input) {
+  return new TextEncoder().encode(input);
+}
+function decodeText(input) {
+  return textDecoder.decode(input, { stream: true });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeText,
+  encodeText
+});