@cedarjs/router 0.0.4

package/dist/cjs/rsc/ServerRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerRouter.d.ts","sourceRoot":"","sources":["../../../src/rsc/ServerRouter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,MAAM,OAAO,CAAA;AAQzB,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAA;AAEtE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAKtD,MAAM,WAAW,WACf,SAAQ,IAAI,CAAC,0BAA0B,EAAE,QAAQ,GAAG,iBAAiB,CAAC;IACtE,eAAe,CAAC,EAAE,oBAAoB,CAAA;IACtC,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED,eAAO,MAAM,MAAM,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,CA4GxC,CAAA"}

package/dist/cjs/rsc/ServerRouter.js

@@ -0,0 +1,170 @@
+"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 ServerRouter_exports = {};
+__export(ServerRouter_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(ServerRouter_exports);
+var import_react = __toESM(require("react"), 1);
+var import_server_store = require("@cedarjs/server-store");
+var import_analyzeRoutes = require("../analyzeRoutes.js");
+var import_namedRoutes = require("../namedRoutes.js");
+var import_page = require("../page.js");
+var import_splash_page = require("../splash-page.js");
+var import_util = require("../util.js");
+var import_ServerRouteLoader = require("./ServerRouteLoader.js");
+const Router = ({ paramTypes, children }) => {
+  const location = (0, import_server_store.getLocation)();
+  console.log("ServerRouter.tsx location", location);
+  const analyzedRoutes = (0, import_analyzeRoutes.analyzeRoutes)(children, {
+    currentPathName: location.pathname,
+    // @TODO We haven't handled this with SSR/Streaming yet.
+    // May need a babel plugin to extract userParamTypes from Routes.tsx
+    userParamTypes: paramTypes
+  });
+  const {
+    pathRouteMap,
+    hasRootRoute,
+    namedRoutesMap,
+    NotFoundPage,
+    activeRoutePath
+  } = analyzedRoutes;
+  Object.assign(import_namedRoutes.namedRoutes, namedRoutesMap);
+  const hasGeneratedRoutes = Object.keys(import_namedRoutes.namedRoutes).length > 0;
+  const shouldShowSplash = !hasRootRoute && location.pathname === "/" || !hasGeneratedRoutes;
+  if (shouldShowSplash && typeof import_splash_page.SplashPage !== "undefined") {
+    return /* @__PURE__ */ import_react.default.createElement(
+      import_splash_page.SplashPage,
+      {
+        hasGeneratedRoutes,
+        allStandardRoutes: pathRouteMap
+      }
+    );
+  }
+  if (!activeRoutePath) {
+    if (NotFoundPage) {
+      return /* @__PURE__ */ import_react.default.createElement(
+        import_ServerRouteLoader.ServerRouteLoader,
+        {
+          spec: (0, import_page.normalizePage)(NotFoundPage),
+          path: location.pathname
+        }
+      );
+    }
+    return null;
+  }
+  const { path, page, name, redirect, whileLoadingPage, sets } = pathRouteMap[activeRoutePath];
+  if (!path) {
+    throw new Error(`Route "${name}" needs to specify a path`);
+  }
+  (0, import_util.validatePath)(path, name || path);
+  const { params: pathParams } = (0, import_util.matchPath)(path, location.pathname, {
+    userParamTypes: paramTypes
+  });
+  const searchParams = (0, import_util.parseSearch)(location.search);
+  const allParams = { ...searchParams, ...pathParams };
+  let redirectPath = void 0;
+  if (redirect) {
+    if (redirect.startsWith("/")) {
+      redirectPath = (0, import_util.replaceParams)(redirect, allParams);
+    } else {
+      const redirectRouteObject = Object.values(pathRouteMap).find(
+        (route) => route.name === redirect
+      );
+      if (!redirectRouteObject) {
+        throw new Error(
+          `Redirect target route "${redirect}" does not exist for route "${name}"`
+        );
+      }
+      redirectPath = (0, import_util.replaceParams)(redirectRouteObject.path, allParams);
+    }
+  }
+  return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, !redirectPath && page && /* @__PURE__ */ import_react.default.createElement(
+    WrappedPage,
+    {
+      sets,
+      routeLoaderElement: /* @__PURE__ */ import_react.default.createElement(
+        import_ServerRouteLoader.ServerRouteLoader,
+        {
+          path,
+          spec: (0, import_page.normalizePage)(page),
+          params: allParams,
+          whileLoadingPage
+        }
+      )
+    }
+  ));
+};
+function hasRole(requiredRoles) {
+  const { roles } = (0, import_server_store.getAuthState)();
+  const requiredRolesArray = Array.isArray(requiredRoles) ? requiredRoles : [requiredRoles];
+  return requiredRolesArray.some((role) => roles.includes(role));
+}
+const AuthenticatedRoute = ({
+  children,
+  roles
+}) => {
+  const { isAuthenticated } = (0, import_server_store.getAuthState)();
+  const isAuthorized = isAuthenticated && (!roles || hasRole(roles));
+  if (isAuthorized) {
+    return /* @__PURE__ */ import_react.default.createElement(import_react.default.Fragment, null, children);
+  }
+  if (!isAuthenticated) {
+    throw new Error("401 Unauthorized");
+  }
+  throw new Error("403 Forbidden");
+};
+const WrappedPage = ({ routeLoaderElement, sets }) => {
+  if (!sets || sets.length === 0) {
+    return routeLoaderElement;
+  }
+  return sets.reduceRight((acc, set) => {
+    let wrapped = set.wrappers.reduceRight((acc2, Wrapper, index) => {
+      return import_react.default.createElement(
+        Wrapper,
+        { ...set.props, key: set.id + "-" + index },
+        acc2
+      );
+    }, acc);
+    if (set.isPrivate) {
+      const unauthenticated = set.props.unauthenticated;
+      if (!unauthenticated || typeof unauthenticated !== "string") {
+        throw new Error(
+          "You must specify an `unauthenticated` route when using PrivateSet"
+        );
+      }
+      wrapped = /* @__PURE__ */ import_react.default.createElement(AuthenticatedRoute, { ...set.props, unauthenticated }, wrapped);
+    }
+    return wrapped;
+  }, routeLoaderElement);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router
+});

package/dist/cjs/rsc/SsrRouter.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { RouterProps } from '../router.js';
+export declare const Router: ({ paramTypes, children }: RouterProps) => React.JSX.Element;
+//# sourceMappingURL=SsrRouter.d.ts.map

package/dist/cjs/rsc/SsrRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SsrRouter.d.ts","sourceRoot":"","sources":["../../../src/rsc/SsrRouter.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkB,MAAM,OAAO,CAAA;AAKtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAI/C,eAAO,MAAM,MAAM,6BAA8B,WAAW,sBAQ3D,CAAA"}

package/dist/cjs/rsc/SsrRouter.js

@@ -0,0 +1,56 @@
+"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 SsrRouter_exports = {};
+__export(SsrRouter_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(SsrRouter_exports);
+var import_react = __toESM(require("react"), 1);
+var import_analyzeRoutes = require("../analyzeRoutes.js");
+var import_location = require("../location.js");
+var import_namedRoutes = require("../namedRoutes.js");
+var import_clientSsr = require("./clientSsr.js");
+const Router = ({ paramTypes, children }) => {
+  return /* @__PURE__ */ import_react.default.createElement(import_location.LocationProvider, null, /* @__PURE__ */ import_react.default.createElement(LocationAwareRouter, { paramTypes }, children));
+};
+const LocationAwareRouter = ({ paramTypes, children }) => {
+  const { pathname } = (0, import_location.useLocation)();
+  const { namedRoutesMap } = (0, import_react.useMemo)(() => {
+    return (0, import_analyzeRoutes.analyzeRoutes)(children, {
+      currentPathName: pathname,
+      userParamTypes: paramTypes
+    });
+  }, [pathname, children, paramTypes]);
+  Object.assign(import_namedRoutes.namedRoutes, namedRoutesMap);
+  return (0, import_clientSsr.renderRoutesSsr)(pathname);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router
+});

package/dist/cjs/rsc/clientSsr.d.ts

@@ -0,0 +1,2 @@
+export declare function renderRoutesSsr(pathname: string): Promise<any>;
+//# sourceMappingURL=clientSsr.d.ts.map

package/dist/cjs/rsc/clientSsr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientSsr.d.ts","sourceRoot":"","sources":["../../../src/rsc/clientSsr.ts"],"names":[],"mappings":"AAuEA,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,gBA2DrD"}

package/dist/cjs/rsc/clientSsr.js

@@ -0,0 +1,114 @@
+"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 clientSsr_exports = {};
+__export(clientSsr_exports, {
+  renderRoutesSsr: () => renderRoutesSsr
+});
+module.exports = __toCommonJS(clientSsr_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_ssrModuleMap = require("./ssrModuleMap.js");
+var import_utils = require("./utils.js");
+var import_utils2 = require("./utils.js");
+async function getEntries() {
+  const entriesPath = (0, import_project_config.getPaths)().web.distRscEntries;
+  const entries = await import((0, import_utils2.makeFilePath)(entriesPath));
+  return entries;
+}
+async function getRoutesComponent() {
+  const { serverEntries } = await getEntries();
+  const entryPath = import_node_path.default.join(
+    (0, import_project_config.getPaths)().web.distRsc,
+    serverEntries["__rwjs__Routes"]
+  );
+  console.log("getRoutesComponent entryPath", entryPath);
+  const routesModule = await import((0, import_utils2.makeFilePath)(entryPath));
+  return routesModule.default;
+}
+function resolveClientEntryForProd(filePath, clientEntries) {
+  const basePath = (0, import_project_config.getPaths)().web.distSsr;
+  const entriesFile = (0, import_project_config.getPaths)().web.distRscEntries;
+  const baseDir = import_node_path.default.dirname(entriesFile);
+  const absoluteClientEntries = Object.fromEntries(
+    Object.entries(clientEntries).map(([key, val]) => {
+      let fullKey = import_node_path.default.join(baseDir, key);
+      if (process.platform === "win32") {
+        fullKey = fullKey.replaceAll("\\", "/");
+      }
+      return [fullKey, basePath + import_node_path.default.sep + val];
+    })
+  );
+  const filePathSlash = filePath.replaceAll("\\", "/");
+  const clientEntry = absoluteClientEntries[filePathSlash];
+  console.log("resolveClientEntryForProd during SSR - clientEntry", clientEntry);
+  if (!clientEntry) {
+    if (absoluteClientEntries["*"] === "*") {
+      return basePath + import_node_path.default.relative((0, import_project_config.getPaths)().base, filePathSlash);
+    }
+    throw new Error("No client entry found for " + filePathSlash);
+  }
+  return clientEntry;
+}
+const rscCache = /* @__PURE__ */ new Map();
+async function renderRoutesSsr(pathname) {
+  console.log("renderRoutesSsr pathname", pathname);
+  const cached = rscCache.get(pathname);
+  if (cached) {
+    return cached;
+  }
+  const Routes = await getRoutesComponent();
+  console.log("clientSsr.ts getEntries()", await getEntries());
+  const clientEntries = (await getEntries()).ssrEntries;
+  const bundlerConfig = new Proxy(
+    {},
+    {
+      get(_target, encodedId) {
+        console.log("Proxy get encodedId", encodedId);
+        const [filePath, name] = encodedId.split("#");
+        const id = resolveClientEntryForProd(filePath, clientEntries);
+        console.log("clientSsr.ts::Proxy id", id);
+        return { id, chunks: [id], name, async: true };
+      }
+    }
+  );
+  const { createElement } = await (0, import_utils.importReact)();
+  const { renderToReadableStream } = await (0, import_utils.importRsdwServer)();
+  console.log("clientSsr.ts right before renderToReadableStream");
+  const stream = renderToReadableStream(createElement(Routes), bundlerConfig);
+  const { createFromReadableStream } = await (0, import_utils.importRsdwClient)();
+  const data = createFromReadableStream(stream, {
+    ssrManifest: { moduleMap: import_ssrModuleMap.moduleMap, moduleLoading: null }
+  });
+  rscCache.set(pathname, data);
+  return data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderRoutesSsr
+});

package/dist/cjs/rsc/rscCss.d.ts

@@ -0,0 +1,2 @@
+export declare function getRscStylesheetLinkGenerator(existingLinks?: string[]): () => string[];
+//# sourceMappingURL=rscCss.d.ts.map

package/dist/cjs/rsc/rscCss.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rscCss.d.ts","sourceRoot":"","sources":["../../../src/rsc/rscCss.ts"],"names":[],"mappings":"AAaA,wBAAgB,6BAA6B,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,kBAiCrE"}

package/dist/cjs/rsc/rscCss.js

@@ -0,0 +1,94 @@
+"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 rscCss_exports = {};
+__export(rscCss_exports, {
+  getRscStylesheetLinkGenerator: () => getRscStylesheetLinkGenerator
+});
+module.exports = __toCommonJS(rscCss_exports);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+function getRscStylesheetLinkGenerator(existingLinks) {
+  const clientBuildManifestPath = import_node_path.default.join(
+    (0, import_project_config.getPaths)().web.distBrowser,
+    "client-build-manifest.json"
+  );
+  const clientBuildManifest = JSON.parse(
+    import_node_fs.default.readFileSync(clientBuildManifestPath, "utf-8")
+  );
+  const clientCss = extractCssMappingFromManifest(clientBuildManifest);
+  const serverBuildManifestPath = import_node_path.default.join(
+    (0, import_project_config.getPaths)().web.distRsc,
+    "server-build-manifest.json"
+  );
+  const serverBuildManifest = JSON.parse(
+    import_node_fs.default.readFileSync(serverBuildManifestPath, "utf-8")
+  );
+  const serverCss = extractCssMappingFromManifest(serverBuildManifest);
+  const allCss = /* @__PURE__ */ new Set();
+  for (const cssList of clientCss.values()) {
+    for (const css of cssList) {
+      allCss.add(css);
+    }
+  }
+  for (const cssList of serverCss.values()) {
+    for (const css of cssList) {
+      allCss.add(css);
+    }
+  }
+  const cssLinks = Array.from(allCss);
+  return () => [...existingLinks || [], ...cssLinks];
+}
+function extractCssMappingFromManifest(manifest) {
+  const manifestCss = /* @__PURE__ */ new Map();
+  const lookupCssAssets = (id) => {
+    const assets = [];
+    const asset = manifest[id];
+    if (!asset) {
+      return assets;
+    }
+    if (asset.css) {
+      assets.push(...asset.css);
+    }
+    if (asset.imports) {
+      for (const importId of asset.imports) {
+        assets.push(...lookupCssAssets(importId));
+      }
+    }
+    return assets;
+  };
+  for (const key of Object.keys(manifest)) {
+    manifestCss.set(key, lookupCssAssets(key));
+  }
+  return manifestCss;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRscStylesheetLinkGenerator
+});

package/dist/cjs/rsc/ssrModuleMap.d.ts

@@ -0,0 +1,14 @@
+type SSRModuleMap = null | {
+    [clientId: string]: {
+        [clientExportName: string]: ClientReferenceManifestEntry;
+    };
+};
+type ClientReferenceManifestEntry = ImportManifestEntry;
+type ImportManifestEntry = {
+    id: string;
+    chunks: string[];
+    name: string;
+};
+export declare const moduleMap: SSRModuleMap;
+export {};
+//# sourceMappingURL=ssrModuleMap.d.ts.map

package/dist/cjs/rsc/ssrModuleMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ssrModuleMap.d.ts","sourceRoot":"","sources":["../../../src/rsc/ssrModuleMap.ts"],"names":[],"mappings":"AAEA,KAAK,YAAY,GAAG,IAAI,GAAG;IACzB,CAAC,QAAQ,EAAE,MAAM,GAAG;QAClB,CAAC,gBAAgB,EAAE,MAAM,GAAG,4BAA4B,CAAA;KACzD,CAAA;CACF,CAAA;AACD,KAAK,4BAA4B,GAAG,mBAAmB,CAAA;AACvD,KAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,MAAM,CAAA;IAEV,MAAM,EAAE,MAAM,EAAE,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAMD,eAAO,MAAM,SAAS,EAAE,YAuBvB,CAAA"}

package/dist/cjs/rsc/ssrModuleMap.js

@@ -0,0 +1,49 @@
+"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 ssrModuleMap_exports = {};
+__export(ssrModuleMap_exports, {
+  moduleMap: () => moduleMap
+});
+module.exports = __toCommonJS(ssrModuleMap_exports);
+var import_utils = require("./utils.js");
+const moduleMap = new Proxy(
+  {},
+  {
+    get(_target, filePath) {
+      return new Proxy(
+        {},
+        {
+          get(_target2, name) {
+            filePath = (0, import_utils.makeFilePath)(filePath);
+            const manifestEntry = {
+              id: filePath,
+              chunks: [filePath],
+              name
+            };
+            return manifestEntry;
+          }
+        }
+      );
+    }
+  }
+);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  moduleMap
+});

package/dist/cjs/rsc/utils.d.ts

@@ -0,0 +1,20 @@
+import type { default as RSDWClientModule } from 'react-server-dom-webpack/client.edge';
+import type { default as RSDWServerModule } from 'react-server-dom-webpack/server.edge';
+type RSDWClientType = typeof RSDWClientModule;
+type RSDWServerType = typeof RSDWServerModule;
+export declare function makeFilePath(path: string): string;
+/**
+ * See vite/streamHelpers.ts.
+ *
+ * This function ensures we load the same version of rsdw_client to prevent multiple instances of React
+ */
+export declare function importReact(): Promise<any>;
+/**
+ * See vite/streamHelpers.ts.
+ *
+ * This function ensures we load the same version of rsdw_client to prevent multiple instances of React
+ */
+export declare function importRsdwClient(): Promise<RSDWClientType>;
+export declare function importRsdwServer(): Promise<RSDWServerType>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/cjs/rsc/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/rsc/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AACvF,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,sCAAsC,CAAA;AAIvF,KAAK,cAAc,GAAG,OAAO,gBAAgB,CAAA;AAC7C,KAAK,cAAc,GAAG,OAAO,gBAAgB,CAAA;AAE7C,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,UAExC;AAED;;;;GAIG;AACH,wBAAsB,WAAW,iBAKhC;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,cAAc,CAAC,CAOhE;AAED,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,cAAc,CAAC,CAWhE"}

package/dist/cjs/rsc/utils.js

@@ -0,0 +1,68 @@
+"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 utils_exports = {};
+__export(utils_exports, {
+  importReact: () => importReact,
+  importRsdwClient: () => importRsdwClient,
+  importRsdwServer: () => importRsdwServer,
+  makeFilePath: () => makeFilePath
+});
+module.exports = __toCommonJS(utils_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var import_project_config = require("@cedarjs/project-config");
+function makeFilePath(path2) {
+  return (0, import_node_url.pathToFileURL)(path2).href;
+}
+async function importReact() {
+  const distSsr = (0, import_project_config.getPaths)().web.distSsr;
+  const reactPath = makeFilePath(import_node_path.default.join(distSsr, "__rwjs__react.mjs"));
+  return (await import(reactPath)).default;
+}
+async function importRsdwClient() {
+  const distSsr = (0, import_project_config.getPaths)().web.distSsr;
+  const rsdwClientPath = makeFilePath(
+    import_node_path.default.join(distSsr, "__rwjs__rsdw-client.mjs")
+  );
+  return (await import(rsdwClientPath)).default;
+}
+async function importRsdwServer() {
+  const dynamicImport = "";
+  return import(
+    /* @vite-ignore */
+    dynamicImport + "react-server-dom-webpack/server.edge"
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importReact,
+  importRsdwClient,
+  importRsdwServer,
+  makeFilePath
+});

package/dist/cjs/rsc-link.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface LinkProps {
+    to: string;
+}
+export declare const Link: React.ForwardRefExoticComponent<LinkProps & React.AnchorHTMLAttributes<HTMLAnchorElement> & React.RefAttributes<HTMLAnchorElement>>;
+//# sourceMappingURL=rsc-link.d.ts.map

package/dist/cjs/rsc-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rsc-link.d.ts","sourceRoot":"","sources":["../../src/rsc-link.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqB,MAAM,OAAO,CAAA;AAEzC,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;CACX;AAmBD,eAAO,MAAM,IAAI,qIAKf,CAAA"}