@cedarjs/vite 0.0.4

package/dist/streaming/streamHelpers.js

@@ -0,0 +1,192 @@
+import path from "node:path";
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { makeFilePath } from "../utils.js";
+import { createBufferedTransformStream } from "./transforms/bufferedTransform.js";
+import { createTimeoutTransform } from "./transforms/cancelTimeoutTransform.js";
+import { createServerInjectionTransform } from "./transforms/serverInjectionTransform.js";
+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 = 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 = createBufferedTransformStream();
+  const serverInjectionTransform = createServerInjectionTransform({
+    injectionState,
+    createElement,
+    ServerInjectedHtml,
+    renderToString,
+    onlyOnFlush: waitForAllReady
+  });
+  const controller = new AbortController();
+  const timeoutHandle = setTimeout(() => {
+    controller.abort();
+  }, 1e4);
+  const timeoutTransform = 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 = getPaths().web.distSsr;
+  const rdServerPath = makeFilePath(path.join(distSsr, "rd-server.mjs"));
+  const reactPath = makeFilePath(path.join(distSsr, "__rwjs__react.mjs"));
+  const locationPath = makeFilePath(path.join(distSsr, "__rwjs__location.mjs"));
+  const ServerAuthProviderPath = makeFilePath(
+    path.join(distSsr, "__rwjs__server_auth_provider.mjs")
+  );
+  const ServerInjectPath = makeFilePath(
+    path.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);
+}
+export {
+  importModule,
+  reactRenderToStreamResponse
+};

package/dist/streaming/transforms/bufferedTransform.d.ts

@@ -0,0 +1,2 @@
+export declare function createBufferedTransformStream(): TransformStream<any, any>;
+//# sourceMappingURL=bufferedTransform.d.ts.map

package/dist/streaming/transforms/bufferedTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bufferedTransform.d.ts","sourceRoot":"","sources":["../../../src/streaming/transforms/bufferedTransform.ts"],"names":[],"mappings":"AAGA,wBAAgB,6BAA6B,8BAwC5C"}

package/dist/streaming/transforms/bufferedTransform.js

@@ -0,0 +1,37 @@
+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;
+    }
+  });
+}
+export {
+  createBufferedTransformStream
+};

package/dist/streaming/transforms/cancelTimeoutTransform.d.ts

@@ -0,0 +1,2 @@
+export declare function createTimeoutTransform(timeoutHandle: NodeJS.Timeout): TransformStream<any, any>;
+//# sourceMappingURL=cancelTimeoutTransform.d.ts.map

package/dist/streaming/transforms/cancelTimeoutTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cancelTimeoutTransform.d.ts","sourceRoot":"","sources":["../../../src/streaming/transforms/cancelTimeoutTransform.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,MAAM,CAAC,OAAO,6BAMnE"}

package/dist/streaming/transforms/cancelTimeoutTransform.js

@@ -0,0 +1,10 @@
+function createTimeoutTransform(timeoutHandle) {
+  return new TransformStream({
+    flush() {
+      clearTimeout(timeoutHandle);
+    }
+  });
+}
+export {
+  createTimeoutTransform
+};

package/dist/streaming/transforms/encode-decode.d.ts

@@ -0,0 +1,3 @@
+export declare function encodeText(input: string): Uint8Array;
+export declare function decodeText(input: Uint8Array | undefined): string;
+//# sourceMappingURL=encode-decode.d.ts.map

package/dist/streaming/transforms/encode-decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-decode.d.ts","sourceRoot":"","sources":["../../../src/streaming/transforms/encode-decode.ts"],"names":[],"mappings":"AAEA,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,cAEvC;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,UAEvD"}

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

@@ -0,0 +1,11 @@
+const textDecoder = new TextDecoder();
+function encodeText(input) {
+  return new TextEncoder().encode(input);
+}
+function decodeText(input) {
+  return textDecoder.decode(input, { stream: true });
+}
+export {
+  decodeText,
+  encodeText
+};

package/dist/streaming/transforms/serverInjectionTransform.d.ts

@@ -0,0 +1,16 @@
+import type React from 'react';
+import type RDServerModule from 'react-dom/server';
+import type { RenderCallback } from '@cedarjs/web';
+import type * as ServerInjectModule from '@cedarjs/web/dist/components/ServerInject';
+type ServerInjectType = typeof ServerInjectModule;
+type RDServerType = typeof RDServerModule;
+type CreateServerInjectionArgs = {
+    injectionState: Set<RenderCallback>;
+    createElement: React['createElement'];
+    ServerInjectedHtml: ServerInjectType['ServerInjectedHtml'];
+    renderToString: RDServerType['renderToString'];
+    onlyOnFlush?: boolean;
+};
+export declare function createServerInjectionTransform({ injectionState, createElement, ServerInjectedHtml, renderToString, onlyOnFlush, }: CreateServerInjectionArgs): TransformStream<any, any>;
+export {};
+//# sourceMappingURL=serverInjectionTransform.d.ts.map

package/dist/streaming/transforms/serverInjectionTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverInjectionTransform.d.ts","sourceRoot":"","sources":["../../../src/streaming/transforms/serverInjectionTransform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,cAAc,MAAM,kBAAkB,CAAA;AAElD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAElD,OAAO,KAAK,KAAK,kBAAkB,MAAM,2CAA2C,CAAA;AAIpF,KAAK,gBAAgB,GAAG,OAAO,kBAAkB,CAAA;AACjD,KAAK,YAAY,GAAG,OAAO,cAAc,CAAA;AAEzC,KAAK,yBAAyB,GAAG;IAC/B,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,CAAA;IACnC,aAAa,EAAE,KAAK,CAAC,eAAe,CAAC,CAAA;IACrC,kBAAkB,EAAE,gBAAgB,CAAC,oBAAoB,CAAC,CAAA;IAC1D,cAAc,EAAE,YAAY,CAAC,gBAAgB,CAAC,CAAA;IAC9C,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,wBAAgB,8BAA8B,CAAC,EAC7C,cAAc,EACd,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,WAAmB,GACpB,EAAE,yBAAyB,6BAkE3B"}

package/dist/streaming/transforms/serverInjectionTransform.js

@@ -0,0 +1,60 @@
+import { encodeText } from "./encode-decode.js";
+function createServerInjectionTransform({
+  injectionState,
+  createElement,
+  ServerInjectedHtml,
+  renderToString,
+  onlyOnFlush = false
+}) {
+  const transformStream = new TransformStream({
+    transform(chunk, controller) {
+      if (onlyOnFlush) {
+        controller.enqueue(chunk);
+      } else {
+        const mergedBytes = insertHtml(chunk);
+        controller.enqueue(mergedBytes);
+      }
+    },
+    flush(controller) {
+      const mergedBytes = insertHtml();
+      controller.enqueue(mergedBytes);
+      const moveTagsScript = encodeText(`<script>document.querySelectorAll('body [data-rwjs-head]').forEach((el) => {
+        document.querySelectorAll('head ' + el.tagName).forEach((e) => {
+          if (
+            el.tagName === 'TITLE' ||
+            (el.tagName === 'META' &&
+              el.getAttribute('name') === e.getAttribute('name') &&
+              el.getAttribute('property') === e.getAttribute('property'))
+          ) {
+            e.remove();
+          }
+          document.head.appendChild(el);
+        });
+      });
+        </script>`);
+      controller.enqueue(moveTagsScript);
+    }
+  });
+  return transformStream;
+  function insertHtml(chunk) {
+    const serverHtmlOutput = renderToString(
+      createElement(ServerInjectedHtml, {
+        injectionState
+      })
+    );
+    const injectedBytes = encodeText(serverHtmlOutput);
+    if (chunk !== void 0) {
+      const mergedBytes = new Uint8Array(chunk.length + injectedBytes.length);
+      mergedBytes.set(chunk);
+      mergedBytes.set(injectedBytes, chunk.length);
+      return mergedBytes;
+    } else {
+      const injectedHtmlOutput = new Uint8Array(injectedBytes.length);
+      injectedHtmlOutput.set(injectedBytes);
+      return injectedHtmlOutput;
+    }
+  }
+}
+export {
+  createServerInjectionTransform
+};

package/dist/streaming/triggerRouteHooks.d.ts

@@ -0,0 +1,26 @@
+import type { ViteDevServer } from 'vite';
+import type { MetaHook, RouteHookOutput, TagDescriptor } from '@cedarjs/web';
+interface RouteHooks {
+    meta?: MetaHook;
+}
+interface TriggerRouteHooksParam {
+    routeHooks: RouteHooks;
+    req: Request;
+    parsedParams?: Record<string, any>;
+    previousOutput?: RouteHookOutput;
+}
+export declare const triggerRouteHooks: ({ routeHooks, req, parsedParams, previousOutput, }: TriggerRouteHooksParam) => Promise<{
+    meta: TagDescriptor[];
+}>;
+interface LoadAndRunRouteHooks {
+    paths: (string | null | undefined)[];
+    reqMeta: {
+        req: Request;
+        parsedParams?: Record<string, any>;
+    };
+    viteDevServer?: ViteDevServer;
+    previousOutput?: RouteHookOutput;
+}
+export declare const loadAndRunRouteHooks: ({ paths, reqMeta, viteDevServer, previousOutput, }: LoadAndRunRouteHooks) => Promise<RouteHookOutput>;
+export {};
+//# sourceMappingURL=triggerRouteHooks.d.ts.map

package/dist/streaming/triggerRouteHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triggerRouteHooks.d.ts","sourceRoot":"","sources":["../../src/streaming/triggerRouteHooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAGzC,OAAO,KAAK,EACV,QAAQ,EAER,eAAe,EACf,aAAa,EACd,MAAM,cAAc,CAAA;AAErB,UAAU,UAAU;IAClB,IAAI,CAAC,EAAE,QAAQ,CAAA;CAChB;AAED,UAAU,sBAAsB;IAC9B,UAAU,EAAE,UAAU,CAAA;IACtB,GAAG,EAAE,OAAO,CAAA;IACZ,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAClC,cAAc,CAAC,EAAE,eAAe,CAAA;CACjC;AAED,eAAO,MAAM,iBAAiB,uDAK3B,sBAAsB;;EA4BxB,CAAA;AAED,UAAU,oBAAoB;IAC5B,KAAK,EAAE,CAAC,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,EAAE,CAAA;IACpC,OAAO,EAAE;QACP,GAAG,EAAE,OAAO,CAAA;QACZ,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;KACnC,CAAA;IACD,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,cAAc,CAAC,EAAE,eAAe,CAAA;CACjC;AAMD,eAAO,MAAM,oBAAoB,uDAK9B,oBAAoB,KAAG,OAAO,CAAC,eAAe,CAyChD,CAAA"}

package/dist/streaming/triggerRouteHooks.js

@@ -0,0 +1,71 @@
+import { parseSearch } from "@cedarjs/router/util";
+const triggerRouteHooks = async ({
+  routeHooks,
+  req,
+  parsedParams = {},
+  previousOutput
+}) => {
+  const event = {
+    params: parsedParams,
+    headers: req.headers || {},
+    query: parseSearch(req.url),
+    // cookies: req.cookies || {}, // TODO (STREAMING) we probably need some sort of cookie parser
+    // TODO (STREAMING) called app routeHook, but its just the previous output
+    appRouteHook: previousOutput
+  };
+  let meta = previousOutput?.meta || [];
+  try {
+    const metaRouteHookOutput = await routeHooks?.meta?.(event) || [];
+    const currentMeta = Array.isArray(metaRouteHookOutput) ? metaRouteHookOutput : [metaRouteHookOutput];
+    meta = [...meta, ...currentMeta];
+  } catch (e) {
+    throw new Error(`Error in meta hook: ${e.message}`);
+  }
+  return {
+    meta
+  };
+};
+const defaultRouteHookOutput = {
+  meta: []
+};
+const loadAndRunRouteHooks = async ({
+  paths = [],
+  reqMeta,
+  viteDevServer,
+  previousOutput = defaultRouteHookOutput
+}) => {
+  const loadModule = async (path) => {
+    return viteDevServer ? viteDevServer.ssrLoadModule(path) : import(path);
+  };
+  let currentRouteHooks;
+  let rhOutput = defaultRouteHookOutput;
+  const routeHookPath = paths.shift();
+  try {
+    if (routeHookPath) {
+      currentRouteHooks = await loadModule(routeHookPath);
+      rhOutput = await triggerRouteHooks({
+        routeHooks: currentRouteHooks,
+        req: reqMeta.req,
+        parsedParams: reqMeta.parsedParams,
+        previousOutput
+      });
+    }
+    if (paths.length > 0) {
+      return loadAndRunRouteHooks({
+        paths,
+        reqMeta,
+        previousOutput: rhOutput,
+        viteDevServer
+      });
+    } else {
+      return rhOutput;
+    }
+  } catch (e) {
+    console.error(`Error loading route hooks in ${routeHookPath}}`);
+    throw e;
+  }
+};
+export {
+  loadAndRunRouteHooks,
+  triggerRouteHooks
+};

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+/**
+ *
+ * Sub+Superset of RouteSpec returned by getProjectRoutes()
+ * in packages/internal/src/routes.ts
+ *
+ * Differences:
+ * - has path to routeHook (which is not available until after build)
+ * - bundle doesn't exist before build, comes from vite build manifest. Used in script injection
+ *
+ * **All** of these properties are used by the prod FE server
+ */
+import type { RWRouteManifestItem } from '@cedarjs/internal';
+import type { TagDescriptor } from '@cedarjs/web';
+import type { MiddlewareReg } from './middleware/types.js';
+export type RWRouteManifest = Record<PathDefinition, RWRouteManifestItem>;
+type PathDefinition = string;
+export type ServerEntryType = React.FunctionComponent<{
+    css: string[];
+    meta: TagDescriptor[];
+}>;
+export type EntryServer = {
+    registerMiddleware?: () => Promise<MiddlewareReg> | MiddlewareReg;
+    ServerEntry: ServerEntryType;
+    default: never;
+} | {
+    registerMiddleware?: () => Promise<MiddlewareReg> | MiddlewareReg;
+    ServerEntry: never;
+    default: ServerEntryType;
+};
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAC5D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAA;AAE1D,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,cAAc,EAAE,mBAAmB,CAAC,CAAA;AAEzE,KAAK,cAAc,GAAG,MAAM,CAAA;AAE5B,MAAM,MAAM,eAAe,GAAG,KAAK,CAAC,iBAAiB,CAAC;IACpD,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,IAAI,EAAE,aAAa,EAAE,CAAA;CACtB,CAAC,CAAA;AAEF,MAAM,MAAM,WAAW,GACnB;IACE,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAA;IACjE,WAAW,EAAE,eAAe,CAAA;IAC5B,OAAO,EAAE,KAAK,CAAA;CACf,GACD;IACE,kBAAkB,CAAC,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,GAAG,aAAa,CAAA;IACjE,WAAW,EAAE,KAAK,CAAA;IAClB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA"}

package/dist/utils.d.ts

@@ -0,0 +1,14 @@
+import type { Request as ExpressRequest } from 'express';
+import type { ViteDevServer } from 'vite';
+import type { EntryServer } from './types.js';
+export declare function stripQueryStringAndHashFromPath(url: string): string;
+export declare function ensureProcessDirWeb(webDir?: string): void;
+/**
+ * Converts a file path to a URL path (file://...)
+ * Without this, absolute paths can't be imported on Windows
+ */
+export declare function makeFilePath(path: string): string;
+export declare function ssrLoadEntryServer(viteDevServer: ViteDevServer): Promise<EntryServer>;
+export declare function convertExpressHeaders(expressDistinctHeaders: ExpressRequest['headersDistinct']): Headers;
+export declare const getFullUrl: (req: ExpressRequest, rscEnabled: boolean) => string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,SAAS,CAAA;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAA;AAIzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,MAAM,UAE1D;AAID,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,MAA4B,QAYvE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAExC;AAED,wBAAsB,kBAAkB,CAAC,aAAa,EAAE,aAAa,wBAYpE;AAED,wBAAgB,qBAAqB,CACnC,sBAAsB,EAAE,cAAc,CAAC,iBAAiB,CAAC,WAc1D;AAED,eAAO,MAAM,UAAU,QAAS,cAAc,cAAc,OAAO,WAiBlE,CAAA"}

package/dist/utils.js

@@ -0,0 +1,62 @@
+import { pathToFileURL } from "node:url";
+import { getPaths } from "@cedarjs/project-config";
+function stripQueryStringAndHashFromPath(url) {
+  return url.split("?")[0].split("#")[0];
+}
+function ensureProcessDirWeb(webDir = getPaths().web.base) {
+  if (process.cwd() !== webDir) {
+    console.error("\u26A0\uFE0F  Warning: CWD is ", process.cwd());
+    console.warn("~".repeat(50));
+    console.warn(
+      "The cwd must be web/. Please use `yarn rw <command>` or run the command from the web/ directory."
+    );
+    console.log(`Changing cwd to ${webDir}....`);
+    console.log();
+    process.chdir(webDir);
+  }
+}
+function makeFilePath(path) {
+  return pathToFileURL(path).href;
+}
+async function ssrLoadEntryServer(viteDevServer) {
+  const rwPaths = getPaths();
+  if (!rwPaths.web.entryServer) {
+    throw new Error("entryServer not defined");
+  }
+  return viteDevServer.ssrLoadModule(
+    rwPaths.web.entryServer
+    // Have to type cast here because ssrLoadModule just returns a generic
+    // Record<string, any> type
+  );
+}
+function convertExpressHeaders(expressDistinctHeaders) {
+  const headers = new Headers();
+  for (const name in expressDistinctHeaders) {
+    const values = expressDistinctHeaders[name];
+    if (Array.isArray(values)) {
+      for (const value of values) {
+        headers.append(name, value);
+      }
+    }
+  }
+  return headers;
+}
+const getFullUrl = (req, rscEnabled) => {
+  const baseUrl = req.protocol + "://" + req.headers.host;
+  const url = new URL(req.originalUrl || "", baseUrl);
+  const pathname = url.searchParams.get("__rwjs__pathname");
+  const search = url.searchParams.get("__rwjs__search");
+  let pathnamePlusSearch = req.originalUrl;
+  if (rscEnabled && pathname !== null && search !== null) {
+    pathnamePlusSearch = pathname + "?" + search;
+  }
+  return baseUrl + pathnamePlusSearch;
+};
+export {
+  convertExpressHeaders,
+  ensureProcessDirWeb,
+  getFullUrl,
+  makeFilePath,
+  ssrLoadEntryServer,
+  stripQueryStringAndHashFromPath
+};

package/inject/reactRefresh.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-undef */
+
+import RefreshRuntime from '/@react-refresh'
+RefreshRuntime.injectIntoGlobalHook(window)
+window.$RefreshReg$ = () => {}
+window.$RefreshSig$ = () => (type) => type
+window.__vite_plugin_react_preamble_installed__ = true