@cedarjs/router 0.0.4

package/dist/rsc/RscRoutes.js

@@ -0,0 +1,100 @@
+import { use, useState, useEffect } from "react";
+import { createFromFetch, encodeReply } from "react-server-dom-webpack/client";
+import { RscCache } from "./RscCache.js";
+const BASE_PATH = "/rw-rsc/";
+const rscCache = new RscCache();
+let updateCurrentRscCacheKey = (key) => {
+  console.error("updateCurrentRscCacheKey called before it was set");
+  console.error("updateCurrentRscCacheKey key", key);
+};
+function onStreamFinished(fetchPromise, onFinished) {
+  return fetchPromise.then((response) => response.clone().text()).then(onFinished);
+}
+async function rsaFetch(serializedLocation, rsaId, rsaArgs) {
+  const rscId = "_";
+  const searchParams = new URLSearchParams();
+  searchParams.set("action_id", rsaId);
+  const url = BASE_PATH + rscId + "?" + searchParams + "&" + serializedLocation;
+  let body = "";
+  try {
+    body = await encodeReply(rsaArgs);
+  } catch (e) {
+    console.error("Error encoding Server Action arguments", e);
+  }
+  return fetch(url, {
+    method: "POST",
+    body,
+    headers: { "rw-rsc": "1" }
+  });
+}
+function rscFetch(serializedLocation) {
+  const rscId = "__rwjs__Routes";
+  return fetch(BASE_PATH + rscId + "?" + serializedLocation, {
+    headers: { "rw-rsc": "1" }
+  });
+}
+function rscFetchRoutes(serializedLocation) {
+  console.log(
+    "rscFetchRoutes :: args:\n    serializedProps: " + serializedLocation
+  );
+  const rscCacheKey = serializedLocation;
+  const cached = rscCache.get(rscCacheKey);
+  if (cached) {
+    console.log("rscFetchRoutes :: cache hit for", rscCacheKey);
+    return cached;
+  } else {
+    console.log("rscFetchRoutes :: cache miss for", rscCacheKey);
+  }
+  const options = {
+    // React will hold on to `callServer` and use that when it detects a server
+    // action is invoked (like `action={onSubmit}` in a <form> element). So for
+    // now at least we need to send it with every RSC request, so React knows
+    // what `callServer` method to use for server actions inside the RSC.
+    // TODO (RSC): Need to figure out the types for callServer
+    // @ts-expect-error types
+    callServer: async function(rsaId, args) {
+      console.log("RscRoutes :: callServer rsaId", rsaId, "args", args);
+      const rscCacheKey2 = `${serializedLocation}::${rsaId}::${Date.now()}`;
+      const responsePromise = rsaFetch(serializedLocation, rsaId, args);
+      onStreamFinished(responsePromise, () => {
+        updateCurrentRscCacheKey(rscCacheKey2);
+      });
+      const modelPromise2 = createFromFetch(responsePromise, options);
+      rscCache.set(rscCacheKey2, modelPromise2);
+      const model = await modelPromise2;
+      return model.__rwjs__rsa_data;
+    }
+  };
+  const modelPromise = createFromFetch(rscFetch(serializedLocation), options);
+  rscCache.set(rscCacheKey, modelPromise);
+  return modelPromise;
+}
+const RscRoutes = ({ pathname, search }) => {
+  const serializedLocation = `__rwjs__pathname=${pathname}&__rwjs__search=${search}`;
+  const [currentRscCacheKey, setCurrentRscCacheKey] = useState(() => {
+    console.log("RscRoutes :: useState initial value");
+    rscFetchRoutes(serializedLocation);
+    return serializedLocation;
+  });
+  useEffect(() => {
+    console.log("RscRoutes :: useEffect set updateCurrentRscCacheKey");
+    updateCurrentRscCacheKey = (key) => {
+      console.log("RscRoutes inside updateCurrentRscCacheKey", key);
+      setCurrentRscCacheKey(key);
+    };
+  }, []);
+  useEffect(() => {
+    console.log("RscRoutes :: useEffect about to call rscFetchRoutes");
+    rscFetchRoutes(serializedLocation);
+    setCurrentRscCacheKey(serializedLocation);
+  }, [serializedLocation]);
+  console.log("RscRoutes :: rendering cache entry for\n" + currentRscCacheKey);
+  const rscModelPromise = rscCache.get(currentRscCacheKey);
+  if (!rscModelPromise) {
+    throw new Error("Missing RSC cache entry for " + currentRscCacheKey);
+  }
+  return use(rscModelPromise).__rwjs__Routes[0];
+};
+export {
+  RscRoutes
+};

package/dist/rsc/ServerRouteLoader.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import type { Spec } from '../page.js';
+interface Props {
+    path: string;
+    spec: Spec;
+    params?: Record<string, string>;
+    whileLoadingPage?: () => React.ReactNode | null;
+    children?: React.ReactNode;
+}
+export declare const ServerRouteLoader: ({ spec, params }: Props) => React.JSX.Element;
+export {};
+//# sourceMappingURL=ServerRouteLoader.d.ts.map

package/dist/rsc/ServerRouteLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ServerRouteLoader.d.ts","sourceRoot":"","sources":["../../src/rsc/ServerRouteLoader.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAmB,MAAM,OAAO,CAAA;AAEvC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,gBAAgB,CAAC,EAAE,MAAM,KAAK,CAAC,SAAS,GAAG,IAAI,CAAA;IAC/C,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAC3B;AAED,eAAO,MAAM,iBAAiB,qBAAsB,KAAK,sBA+BxD,CAAA"}

package/dist/rsc/ServerRouteLoader.js

@@ -0,0 +1,31 @@
+import React, { Suspense } from "react";
+const ServerRouteLoader = ({ spec, params }) => {
+  const LazyRouteComponent = spec.LazyComponent;
+  if (params) {
+    delete params["ref"];
+    delete params["key"];
+  }
+  return /* @__PURE__ */ React.createElement(Suspense, { fallback: /* @__PURE__ */ React.createElement("div", null, "Loading...") }, /* @__PURE__ */ React.createElement(LazyRouteComponent, { ...params }), /* @__PURE__ */ React.createElement(
+    "div",
+    {
+      id: "redwood-announcer",
+      style: {
+        position: "absolute",
+        top: 0,
+        width: 1,
+        height: 1,
+        padding: 0,
+        overflow: "hidden",
+        clip: "rect(0, 0, 0, 0)",
+        whiteSpace: "nowrap",
+        border: 0
+      },
+      role: "alert",
+      "aria-live": "assertive",
+      "aria-atomic": "true"
+    }
+  ));
+};
+export {
+  ServerRouteLoader
+};

package/dist/rsc/ServerRouter.d.ts

@@ -0,0 +1,11 @@
+import type { ReactNode } from 'react';
+import React from 'react';
+import type { RouterContextProviderProps } from '../router-context.js';
+import type { TrailingSlashesTypes } from '../util.js';
+export interface RouterProps extends Omit<RouterContextProviderProps, 'routes' | 'activeRouteName'> {
+    trailingSlashes?: TrailingSlashesTypes;
+    pageLoadingDelay?: number;
+    children: ReactNode;
+}
+export declare const Router: React.FC<RouterProps>;
+//# sourceMappingURL=ServerRouter.d.ts.map

package/dist/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/rsc/ServerRouter.js

@@ -0,0 +1,136 @@
+import React from "react";
+import { getAuthState, getLocation } from "@cedarjs/server-store";
+import { analyzeRoutes } from "../analyzeRoutes.js";
+import { namedRoutes } from "../namedRoutes.js";
+import { normalizePage } from "../page.js";
+import { SplashPage } from "../splash-page.js";
+import { matchPath, parseSearch, replaceParams, validatePath } from "../util.js";
+import { ServerRouteLoader } from "./ServerRouteLoader.js";
+const Router = ({ paramTypes, children }) => {
+  const location = getLocation();
+  console.log("ServerRouter.tsx location", location);
+  const analyzedRoutes = 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(namedRoutes, namedRoutesMap);
+  const hasGeneratedRoutes = Object.keys(namedRoutes).length > 0;
+  const shouldShowSplash = !hasRootRoute && location.pathname === "/" || !hasGeneratedRoutes;
+  if (shouldShowSplash && typeof SplashPage !== "undefined") {
+    return /* @__PURE__ */ React.createElement(
+      SplashPage,
+      {
+        hasGeneratedRoutes,
+        allStandardRoutes: pathRouteMap
+      }
+    );
+  }
+  if (!activeRoutePath) {
+    if (NotFoundPage) {
+      return /* @__PURE__ */ React.createElement(
+        ServerRouteLoader,
+        {
+          spec: 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`);
+  }
+  validatePath(path, name || path);
+  const { params: pathParams } = matchPath(path, location.pathname, {
+    userParamTypes: paramTypes
+  });
+  const searchParams = parseSearch(location.search);
+  const allParams = { ...searchParams, ...pathParams };
+  let redirectPath = void 0;
+  if (redirect) {
+    if (redirect.startsWith("/")) {
+      redirectPath = 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 = replaceParams(redirectRouteObject.path, allParams);
+    }
+  }
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, !redirectPath && page && /* @__PURE__ */ React.createElement(
+    WrappedPage,
+    {
+      sets,
+      routeLoaderElement: /* @__PURE__ */ React.createElement(
+        ServerRouteLoader,
+        {
+          path,
+          spec: normalizePage(page),
+          params: allParams,
+          whileLoadingPage
+        }
+      )
+    }
+  ));
+};
+function hasRole(requiredRoles) {
+  const { roles } = getAuthState();
+  const requiredRolesArray = Array.isArray(requiredRoles) ? requiredRoles : [requiredRoles];
+  return requiredRolesArray.some((role) => roles.includes(role));
+}
+const AuthenticatedRoute = ({
+  children,
+  roles
+}) => {
+  const { isAuthenticated } = getAuthState();
+  const isAuthorized = isAuthenticated && (!roles || hasRole(roles));
+  if (isAuthorized) {
+    return /* @__PURE__ */ React.createElement(React.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 React.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__ */ React.createElement(AuthenticatedRoute, { ...set.props, unauthenticated }, wrapped);
+    }
+    return wrapped;
+  }, routeLoaderElement);
+};
+export {
+  Router
+};

package/dist/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/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/rsc/SsrRouter.js

@@ -0,0 +1,22 @@
+import React, { useMemo } from "react";
+import { analyzeRoutes } from "../analyzeRoutes.js";
+import { LocationProvider, useLocation } from "../location.js";
+import { namedRoutes } from "../namedRoutes.js";
+import { renderRoutesSsr } from "./clientSsr.js";
+const Router = ({ paramTypes, children }) => {
+  return /* @__PURE__ */ React.createElement(LocationProvider, null, /* @__PURE__ */ React.createElement(LocationAwareRouter, { paramTypes }, children));
+};
+const LocationAwareRouter = ({ paramTypes, children }) => {
+  const { pathname } = useLocation();
+  const { namedRoutesMap } = useMemo(() => {
+    return analyzeRoutes(children, {
+      currentPathName: pathname,
+      userParamTypes: paramTypes
+    });
+  }, [pathname, children, paramTypes]);
+  Object.assign(namedRoutes, namedRoutesMap);
+  return renderRoutesSsr(pathname);
+};
+export {
+  Router
+};

package/dist/rsc/clientSsr.d.ts

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

package/dist/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/rsc/clientSsr.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { getPaths } from "@cedarjs/project-config";
+import { moduleMap } from "./ssrModuleMap.js";
+import { importRsdwClient, importRsdwServer, importReact } from "./utils.js";
+import { makeFilePath } from "./utils.js";
+async function getEntries() {
+  const entriesPath = getPaths().web.distRscEntries;
+  const entries = await import(makeFilePath(entriesPath));
+  return entries;
+}
+async function getRoutesComponent() {
+  const { serverEntries } = await getEntries();
+  const entryPath = path.join(
+    getPaths().web.distRsc,
+    serverEntries["__rwjs__Routes"]
+  );
+  console.log("getRoutesComponent entryPath", entryPath);
+  const routesModule = await import(makeFilePath(entryPath));
+  return routesModule.default;
+}
+function resolveClientEntryForProd(filePath, clientEntries) {
+  const basePath = getPaths().web.distSsr;
+  const entriesFile = getPaths().web.distRscEntries;
+  const baseDir = path.dirname(entriesFile);
+  const absoluteClientEntries = Object.fromEntries(
+    Object.entries(clientEntries).map(([key, val]) => {
+      let fullKey = path.join(baseDir, key);
+      if (process.platform === "win32") {
+        fullKey = fullKey.replaceAll("\\", "/");
+      }
+      return [fullKey, basePath + path.sep + val];
+    })
+  );
+  const filePathSlash = filePath.replaceAll("\\", "/");
+  const clientEntry = absoluteClientEntries[filePathSlash];
+  console.log("resolveClientEntryForProd during SSR - clientEntry", clientEntry);
+  if (!clientEntry) {
+    if (absoluteClientEntries["*"] === "*") {
+      return basePath + path.relative(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 importReact();
+  const { renderToReadableStream } = await importRsdwServer();
+  console.log("clientSsr.ts right before renderToReadableStream");
+  const stream = renderToReadableStream(createElement(Routes), bundlerConfig);
+  const { createFromReadableStream } = await importRsdwClient();
+  const data = createFromReadableStream(stream, {
+    ssrManifest: { moduleMap, moduleLoading: null }
+  });
+  rscCache.set(pathname, data);
+  return data;
+}
+export {
+  renderRoutesSsr
+};

package/dist/rsc/rscCss.d.ts

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

package/dist/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/rsc/rscCss.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { getPaths } from "@cedarjs/project-config";
+function getRscStylesheetLinkGenerator(existingLinks) {
+  const clientBuildManifestPath = path.join(
+    getPaths().web.distBrowser,
+    "client-build-manifest.json"
+  );
+  const clientBuildManifest = JSON.parse(
+    fs.readFileSync(clientBuildManifestPath, "utf-8")
+  );
+  const clientCss = extractCssMappingFromManifest(clientBuildManifest);
+  const serverBuildManifestPath = path.join(
+    getPaths().web.distRsc,
+    "server-build-manifest.json"
+  );
+  const serverBuildManifest = JSON.parse(
+    fs.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;
+}
+export {
+  getRscStylesheetLinkGenerator
+};

package/dist/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/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/rsc/ssrModuleMap.js

@@ -0,0 +1,25 @@
+import { makeFilePath } from "./utils.js";
+const moduleMap = new Proxy(
+  {},
+  {
+    get(_target, filePath) {
+      return new Proxy(
+        {},
+        {
+          get(_target2, name) {
+            filePath = makeFilePath(filePath);
+            const manifestEntry = {
+              id: filePath,
+              chunks: [filePath],
+              name
+            };
+            return manifestEntry;
+          }
+        }
+      );
+    }
+  }
+);
+export {
+  moduleMap
+};

package/dist/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/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/rsc/utils.js

@@ -0,0 +1,31 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { getPaths } from "@cedarjs/project-config";
+function makeFilePath(path2) {
+  return pathToFileURL(path2).href;
+}
+async function importReact() {
+  const distSsr = getPaths().web.distSsr;
+  const reactPath = makeFilePath(path.join(distSsr, "__rwjs__react.mjs"));
+  return (await import(reactPath)).default;
+}
+async function importRsdwClient() {
+  const distSsr = getPaths().web.distSsr;
+  const rsdwClientPath = makeFilePath(
+    path.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"
+  );
+}
+export {
+  importReact,
+  importRsdwClient,
+  importRsdwServer,
+  makeFilePath
+};

package/dist/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/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"}

package/dist/rsc-link.js

@@ -0,0 +1,7 @@
+import React, { forwardRef } from "react";
+const Link = forwardRef(({ to, ...rest }, ref) => {
+  return /* @__PURE__ */ React.createElement("a", { href: to, ref, ...rest });
+});
+export {
+  Link
+};