fully-react/dist/entry-rsc.development.js

React Server for Vite

import { lazy } from 'react';
import { renderToReadableStream } from 'react-server-dom-webpack/server.edge';
import { AsyncLocalStorage } from 'node:async_hooks';
import { webcrypto } from 'node:crypto';
import { jsx } from 'react/jsx-runtime';

// src/server/webpack.ts
function dynamicImport(chunk) {
  return import(
    /* @vite-ignore */
    chunk
  );
}
function setupWebpackEnv(load = dynamicImport) {
  const globalEnv = globalThis;
  globalEnv.moduleCache = globalEnv.moduleCache ?? /* @__PURE__ */ new Map();
  globalEnv.__webpack_chunk_load__ = async (chunk) => {
    console.log("Loading chunk", chunk);
    globalEnv.moduleCache.set(chunk, await load(chunk));
  };
  globalEnv.__webpack_require__ = (id) => {
    console.log("Requiring chunk", id);
    if (!globalEnv.moduleCache.has(id))
      throw new Error(`Module ${id} not found`);
    return globalEnv.moduleCache.get(id);
  };
  globalEnv.__webpack_chunk_get__ = async (id) => {
    if (!globalEnv.moduleCache.has(id))
      return await load(id);
    return globalEnv.moduleCache.get(id);
  };
  return { load };
}
function createModuleMapProxy(resolve = (id) => id) {
  return new Proxy(
    {},
    {
      get(_, prop) {
        const [id, name] = String(prop).split("#", 2);
        return {
          id,
          chunks: [resolve(id)],
          name
        };
      }
    }
  );
}

// src/shared/redirect.ts
var REDIRECT_ERROR_CODE = "REDIRECT";
function isRedirectError(error) {
  return typeof error?.digest === "string" && error.digest.startsWith(REDIRECT_ERROR_CODE + ";") && error.digest.length > REDIRECT_ERROR_CODE.length + 1;
}

// src/shared/not-found.ts
var NOT_FOUND_ERROR_CODE = "REACT_NOT_FOUND";
function isNotFoundError(error) {
  return error?.digest === NOT_FOUND_ERROR_CODE;
}
var requestAsyncContext = globalThis.requestAsyncContext ?? new AsyncLocalStorage();
globalThis.requestAsyncContext = requestAsyncContext;
function createDevRenderer() {
  setupWebpackEnv();
  const clientModuleMap = createModuleMapProxy();
  globalThis.crypto = webcrypto;
  const env = {
    findAssets: async () => {
      const { default: devServer } = await import('./dev-server-5DV7YDFZ.js');
      const { collectStyles } = await import('./dev-2OHA6MHS.js');
      const styles = await collectStyles(devServer, ["~/root"]);
      return [
        // @ts-ignore
        ...Object.entries(styles ?? {}).map(([key, value]) => ({
          type: "style",
          style: value,
          src: key
        }))
      ];
    },
    lazyComponent: (id) => {
      return lazy(() => import(
        /* @vite-ignore */
        id
      ));
    },
    manifests: {
      // @ts-ignore
      routesConfig: globalThis.routesConfig
    }
  };
  globalThis.env = env;
  return async (src, props) => {
    return requestAsyncContext.run(
      {
        request: new Request(props.url, {
          headers: props.headers
        }),
        response: {}
      },
      async () => {
        const { default: devServer } = await import('./dev-server-5DV7YDFZ.js');
        const { default: Root } = await devServer.ssrLoadModule("~/root");
        return renderToReadableStream(
          /* @__PURE__ */ jsx(Root, { ...props }),
          clientModuleMap,
          {
            onError: (error) => {
              if (isNotFoundError(error) || isRedirectError(error)) {
                return error.digest;
              }
              console.log("Errror while React server render");
              console.log(error);
            }
          }
        );
      }
    );
  };
}
async function entry_rsc_default(src, props, env) {
  const render = createDevRenderer() ;
  return await render(src, props, env);
}

export { entry_rsc_default as default };