@cedarjs/vite 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Cedar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bins/rw-vite-build.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import fs from 'node:fs'
+
+import yargsParser from 'yargs-parser'
+
+import { getConfig, getPaths } from '@cedarjs/project-config'
+import { buildWeb } from '@cedarjs/vite/build'
+import { buildFeServer } from '@cedarjs/vite/buildFeServer'
+
+const rwPaths = getPaths()
+
+const { webDir, verbose } = yargsParser(process.argv.slice(2), {
+  string: ['webDir'],
+  boolean: ['verbose'],
+})
+
+if (!webDir) {
+  console.error(
+    'Please pass the full path to the web side using the --webDir argument',
+  )
+  process.exit(1)
+}
+
+if (!fs.existsSync(webDir)) {
+  console.error(`Could not find web directory at ${webDir}`)
+  process.exit(1)
+}
+
+if (!fs.existsSync(`${webDir}/package.json`)) {
+  console.error(`${webDir} does not appear to be a Redwood web directory`)
+  process.exit(1)
+}
+
+/**
+ * Build the web side of a Redwood project using Vite
+ * @param {string} webDir - The path to the web side of the project
+ */
+const buildWebSide = async (webDir) => {
+  const configFile = rwPaths.web.viteConfig
+
+  if (!configFile) {
+    throw new Error('Could not locate your web/vite.config.{js,ts} file')
+  }
+
+  if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = 'production'
+  }
+
+  if (getConfig().experimental?.streamingSsr?.enabled) {
+    // Webdir checks handled in the rwjs/vite package in new build system
+    await buildFeServer({ verbose, webDir })
+  } else {
+    // Ensure cwd to be web: required for postcss/tailwind to work correctly
+    process.chdir(webDir)
+    // Right now, the buildWeb function looks up the config file from project-config
+    // In the future, if we have multiple web spaces we could pass in the cwd here
+    buildWeb({ verbose })
+  }
+}
+
+buildWebSide(webDir)

package/bins/rw-vite-dev.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { createServer } from 'vite'
+import yargsParser from 'yargs-parser'
+
+import { getPaths } from '@cedarjs/project-config'
+
+const rwPaths = getPaths()
+
+const startDevServer = async () => {
+  const configFile = rwPaths.web.viteConfig
+
+  if (!configFile) {
+    throw new Error('Could not locate your web/vite.config.{js,ts} file')
+  }
+
+  // Tries to maintain the same options as vite's dev cli
+  // See here: https://github.com/vitejs/vite/blob/main/packages/vite/src/node/cli.ts#L103
+  // e.g. yarn rw dev web --fwd="--force"
+  const {
+    force: forceOptimize,
+    forwardedServerArgs,
+    debug,
+  } = yargsParser(process.argv.slice(2), {
+    boolean: ['https', 'open', 'strictPort', 'force', 'cors', 'debug'],
+    number: ['port'],
+  })
+
+  const devServer = await createServer({
+    configFile,
+    envFile: false, // env file is handled by plugins in the redwood-vite plugin
+    optimizeDeps: {
+      // This is the only value that isn't a server option
+      force: forceOptimize,
+    },
+    server: forwardedServerArgs,
+    logLevel: debug ? 'info' : undefined,
+  })
+
+  await devServer.listen()
+
+  process.stdin.on('data', async (data) => {
+    const str = data.toString().trim().toLowerCase()
+    if (str === 'rs' || str === 'restart') {
+      await devServer.restart(true)
+    }
+  })
+
+  devServer.printUrls()
+
+  if (debug) {
+    console.log('~~~ Vite Server Config ~~~')
+    console.log(JSON.stringify(devServer.config, ' ', 2))
+    console.log('~~~~~~~~~~~~~~~~~~~~~~~~~~')
+  }
+}
+
+startDevServer()

package/bins/vite.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'
+
+const require = createRequire(import.meta.url)
+const vitePath = require.resolve('vite/package.json')
+const requireFromVite = createRequire(vitePath)
+
+const bins = requireFromVite('./package.json')['bin']
+
+// @MARK: This is temporary hack, speak to Dom about this...
+// What is the correct way to proxy a bin with yarn 3 when its a ES module?
+import(`${vitePath.replace('package.json', '')}/${bins['vite']}`)

package/dist/build/build.d.ts

@@ -0,0 +1,21 @@
+import * as babel from '@babel/core';
+import type { Flags } from '@cedarjs/babel-config';
+export declare const cleanWebBuild: () => void;
+export declare function prebuildWebFile(srcPath: string, flags?: Flags): Promise<babel.BabelFileResult | null>;
+export declare function transform(srcPath: string): Promise<string>;
+/**
+ * Remove RedwoodJS "magic" from a user's code leaving JavaScript behind.
+ *
+ * Currently only used for debugging purposes
+ */
+export declare const prebuildWebFiles: (srcFiles: string[], flags?: Flags) => Promise<(string | undefined)[]>;
+interface BuildOptions {
+    verbose?: boolean;
+}
+/**
+ * Builds the web side with Vite, but not used in the buildHandler currently
+ * because we want to set the process.cwd to web.base
+ */
+export declare const buildWeb: ({ verbose }: BuildOptions) => Promise<import("rollup").RollupOutput | import("rollup").RollupOutput[] | import("rollup").RollupWatcher>;
+export {};
+//# sourceMappingURL=build.d.ts.map

package/dist/build/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/build/build.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,aAAa,CAAA;AAIpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAA;AAIlD,eAAO,MAAM,aAAa,YAIzB,CAAA;AAED,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,KAAU,yCAUvE;AAED,wBAAsB,SAAS,CAAC,OAAO,EAAE,MAAM,mBAS9C;AAED;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,aAAoB,MAAM,EAAE,UAAU,KAAK,oCA8BvE,CAAA;AAED,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,gBAAuB,YAAY,8GAoBvD,CAAA"}

package/dist/build/build.js

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import path from "node:path";
+import * as babel from "@babel/core";
+import fse from "fs-extra";
+import { transformWithEsbuild } from "vite";
+import { getWebSideDefaultBabelConfig } from "@cedarjs/babel-config";
+import { getPaths } from "@cedarjs/project-config";
+const cleanWebBuild = () => {
+  const rwjsPaths = getPaths();
+  fse.removeSync(rwjsPaths.web.dist);
+  fse.removeSync(path.join(rwjsPaths.generated.prebuild, "web"));
+};
+async function prebuildWebFile(srcPath, flags = {}) {
+  const code = fs.readFileSync(srcPath, "utf-8");
+  const config = getWebSideDefaultBabelConfig(flags);
+  const result = babel.transform(code, {
+    ...config,
+    cwd: getPaths().web.base,
+    filename: srcPath
+  });
+  return result;
+}
+async function transform(srcPath) {
+  const code = fs.readFileSync(srcPath, "utf-8");
+  const loader = path.extname(srcPath).match(/^\.m?ts/) ? "tsx" : "jsx";
+  const transformed = await transformWithEsbuild(code, srcPath, {
+    loader
+  });
+  return transformed.code;
+}
+const prebuildWebFiles = async (srcFiles, flags) => {
+  const rwjsPaths = getPaths();
+  const processFile = async (srcPath) => {
+    const relativePathFromSrc = path.relative(rwjsPaths.base, srcPath);
+    const dstPath = path.join(rwjsPaths.generated.prebuild, relativePathFromSrc).replace(/\.(ts)$/, ".js");
+    try {
+      const result = await prebuildWebFile(srcPath, flags);
+      if (!result?.code) {
+        throw new Error("No code returned from prebuildWebFile");
+      }
+      fs.mkdirSync(path.dirname(dstPath), { recursive: true });
+      fs.writeFileSync(dstPath, result.code);
+    } catch {
+      console.warn("Error:", srcPath, "could not prebuilt.");
+      return void 0;
+    }
+    return dstPath;
+  };
+  const promises = [];
+  for (const srcPath of srcFiles) {
+    promises.push(processFile(srcPath));
+  }
+  return await Promise.all(promises);
+};
+const buildWeb = async ({ verbose }) => {
+  const { build } = await import("vite");
+  const viteConfig = getPaths().web.viteConfig;
+  if (process.cwd() !== getPaths().web.base) {
+    throw new Error(
+      "Looks like you are running the command from the wrong dir, this can lead to unintended consequences on CSS processing"
+    );
+  }
+  if (!viteConfig) {
+    throw new Error("Could not locate your web/vite.config.{js,ts} file");
+  }
+  return build({
+    configFile: viteConfig,
+    envFile: false,
+    logLevel: verbose ? "info" : "warn"
+  });
+};
+export {
+  buildWeb,
+  cleanWebBuild,
+  prebuildWebFile,
+  prebuildWebFiles,
+  transform
+};

package/dist/buildFeServer.d.ts

@@ -0,0 +1,6 @@
+export interface BuildOptions {
+    verbose?: boolean;
+    webDir?: string;
+}
+export declare const buildFeServer: ({ verbose, webDir }?: BuildOptions) => Promise<void>;
+//# sourceMappingURL=buildFeServer.d.ts.map

package/dist/buildFeServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildFeServer.d.ts","sourceRoot":"","sources":["../src/buildFeServer.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,YAAY;IAC3B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,eAAO,MAAM,aAAa,yBAA+B,YAAY,kBA0CpE,CAAA"}

package/dist/buildFeServer.js

@@ -0,0 +1,39 @@
+import { getConfig, getPaths } from "@cedarjs/project-config";
+import { buildWeb } from "./build/build.js";
+import { buildRouteHooks } from "./buildRouteHooks.js";
+import { buildRouteManifest } from "./buildRouteManifest.js";
+import { buildRscClientAndServer } from "./buildRscClientAndServer.js";
+import { buildForStreamingServer } from "./streaming/buildForStreamingServer.js";
+import { ensureProcessDirWeb } from "./utils.js";
+const buildFeServer = async ({ verbose, webDir } = {}) => {
+  ensureProcessDirWeb(webDir);
+  const rwPaths = getPaths();
+  const rwConfig = getConfig();
+  const viteConfigPath = rwPaths.web.viteConfig;
+  const rscEnabled = rwConfig.experimental?.rsc?.enabled;
+  const streamingSsrEnabled = rwConfig.experimental?.streamingSsr?.enabled;
+  if (!viteConfigPath) {
+    throw new Error(
+      "Vite config not found. You need to setup your project with Vite using `yarn rw setup vite`"
+    );
+  }
+  if (!rwPaths.web.entryServer || !rwPaths.web.entryClient) {
+    throw new Error(
+      "Vite entry points not found. Please check that your project has an entry.client.{jsx,tsx} and entry.server.{jsx,tsx} file in the web/src directory."
+    );
+  }
+  if (rscEnabled) {
+    await buildRscClientAndServer({ verbose });
+  } else {
+    await buildForStreamingServer({ verbose });
+  }
+  if (streamingSsrEnabled && !rscEnabled) {
+    console.log("Building client for streaming SSR...\n");
+    await buildWeb({ verbose });
+  }
+  await buildRouteHooks(verbose, rwPaths);
+  await buildRouteManifest();
+};
+export {
+  buildFeServer
+};

package/dist/buildRouteHooks.d.ts

@@ -0,0 +1,3 @@
+import type { Paths } from '@cedarjs/project-config';
+export declare function buildRouteHooks(verbose: boolean | undefined, rwPaths: Paths): Promise<void>;
+//# sourceMappingURL=buildRouteHooks.d.ts.map

package/dist/buildRouteHooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRouteHooks.d.ts","sourceRoot":"","sources":["../src/buildRouteHooks.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AAGpD,wBAAsB,eAAe,CACnC,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,OAAO,EAAE,KAAK,iBAuCf"}

package/dist/buildRouteHooks.js

@@ -0,0 +1,45 @@
+import { build as esbuildBuild } from "esbuild";
+import {
+  getRouteHookBabelPlugins,
+  transformWithBabel
+} from "@cedarjs/babel-config";
+import { findRouteHooksSrc } from "@cedarjs/internal/dist/files.js";
+import { getPaths } from "@cedarjs/project-config";
+async function buildRouteHooks(verbose, rwPaths) {
+  const allRouteHooks = findRouteHooksSrc();
+  const runRwBabelTransformsPlugin = {
+    name: "rw-esbuild-babel-transform",
+    setup(build) {
+      build.onLoad({ filter: /\.(js|ts|tsx|jsx)$/ }, async (args) => {
+        const transformedCode = await transformWithBabel(args.path, [
+          ...getRouteHookBabelPlugins()
+        ]);
+        if (transformedCode?.code) {
+          return {
+            contents: transformedCode.code,
+            loader: "js"
+          };
+        }
+        throw new Error(`Could not transform file: ${args.path}`);
+      });
+    }
+  };
+  await esbuildBuild({
+    absWorkingDir: getPaths().web.base,
+    entryPoints: allRouteHooks,
+    platform: "node",
+    target: "node16",
+    // @MARK Disable splitting and esm, because Redwood web modules don't support esm yet
+    // outExtension: { '.js': '.mjs' },
+    // format: 'esm',
+    // splitting: true,
+    bundle: true,
+    plugins: [runRwBabelTransformsPlugin],
+    packages: "external",
+    logLevel: verbose ? "info" : "error",
+    outdir: rwPaths.web.distRouteHooks
+  });
+}
+export {
+  buildRouteHooks
+};

package/dist/buildRouteManifest.d.ts

@@ -0,0 +1,6 @@
+/**
+ * RSC build. Step 6.
+ * Generate a route manifest file for the web server side.
+ */
+export declare function buildRouteManifest(): Promise<void>;
+//# sourceMappingURL=buildRouteManifest.d.ts.map

package/dist/buildRouteManifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRouteManifest.d.ts","sourceRoot":"","sources":["../src/buildRouteManifest.ts"],"names":[],"mappings":"AAWA;;;GAGG;AACH,wBAAsB,kBAAkB,kBAgDvC"}

package/dist/buildRouteManifest.js

@@ -0,0 +1,58 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import url from "node:url";
+import { getProjectRoutes } from "@cedarjs/internal/dist/routes.js";
+import { getAppRouteHook, getPaths } from "@cedarjs/project-config";
+async function buildRouteManifest() {
+  const rwPaths = getPaths();
+  const buildManifestUrl = url.pathToFileURL(
+    path.join(getPaths().web.distBrowser, "client-build-manifest.json")
+  ).href;
+  const clientBuildManifest = (await import(buildManifestUrl, { with: { type: "json" } })).default;
+  const routesList = getProjectRoutes();
+  const routeManifest = routesList.reduce((acc, route) => {
+    acc[route.pathDefinition] = {
+      name: route.name,
+      bundle: route.relativeFilePath ? (
+        // @TODO(RSC_DC): this no longer resolves to anything i.e. its always null
+        // Because the clientBuildManifest has no pages, because all pages are Server-components?
+        // This may be a non-issue, because RSC pages don't need a client bundle per page (or atleast not the same bundle)
+        clientBuildManifest[route.relativeFilePath]?.file ?? null
+      ) : null,
+      matchRegexString: route.matchRegexString,
+      // NOTE this is the path definition, not the actual path
+      // E.g. /blog/post/{id:Int}
+      pathDefinition: route.pathDefinition,
+      hasParams: route.hasParams,
+      routeHooks: FIXME_constructRouteHookPath(route.routeHooks),
+      redirect: route.redirect ? {
+        to: route.redirect?.to,
+        permanent: false
+      } : null,
+      relativeFilePath: route.relativeFilePath,
+      isPrivate: route.isPrivate,
+      unauthenticated: route.unauthenticated,
+      roles: route.roles,
+      pageIdentifier: route.pageIdentifier
+    };
+    return acc;
+  }, {});
+  console.log("routeManifest", JSON.stringify(routeManifest, null, 2));
+  const webRouteManifest = rwPaths.web.routeManifest;
+  await fs.mkdir(rwPaths.web.distSsr, { recursive: true });
+  return fs.writeFile(webRouteManifest, JSON.stringify(routeManifest, null, 2));
+}
+const FIXME_constructRouteHookPath = (routeHookSrcPath) => {
+  const rwPaths = getPaths();
+  if (!routeHookSrcPath) {
+    return null;
+  }
+  if (getAppRouteHook()) {
+    return path.relative(rwPaths.web.src, routeHookSrcPath).replace(".ts", ".js");
+  } else {
+    return path.relative(path.join(rwPaths.web.src, "pages"), routeHookSrcPath).replace(".ts", ".js");
+  }
+};
+export {
+  buildRouteManifest
+};

package/dist/buildRscClientAndServer.d.ts

@@ -0,0 +1,4 @@
+export declare const buildRscClientAndServer: ({ verbose, }: {
+    verbose?: boolean;
+}) => Promise<void>;
+//# sourceMappingURL=buildRscClientAndServer.d.ts.map

package/dist/buildRscClientAndServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildRscClientAndServer.d.ts","sourceRoot":"","sources":["../src/buildRscClientAndServer.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,uBAAuB,iBAEjC;IACD,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB,kBAkCA,CAAA"}

package/dist/buildRscClientAndServer.js

@@ -0,0 +1,30 @@
+import { rscBuildAnalyze } from "./rsc/rscBuildAnalyze.js";
+import { rscBuildClient } from "./rsc/rscBuildClient.js";
+import { rscBuildCopyCssAssets } from "./rsc/rscBuildCopyCssAssets.js";
+import { rscBuildEntriesMappings } from "./rsc/rscBuildEntriesFile.js";
+import { rscBuildForServer } from "./rsc/rscBuildForServer.js";
+import { rscBuildForSsr } from "./rsc/rscBuildForSsr.js";
+import { rscBuildRwEnvVars } from "./rsc/rscBuildRwEnvVars.js";
+const buildRscClientAndServer = async ({
+  verbose = false
+}) => {
+  const { clientEntryFiles, serverEntryFiles } = await rscBuildAnalyze();
+  const clientBuildOutput = await rscBuildClient(clientEntryFiles);
+  const ssrBuildOutput = await rscBuildForSsr({ clientEntryFiles, verbose });
+  const serverBuildOutput = await rscBuildForServer(
+    clientEntryFiles,
+    serverEntryFiles,
+    {}
+  );
+  await rscBuildCopyCssAssets(serverBuildOutput);
+  await rscBuildEntriesMappings(
+    clientBuildOutput,
+    ssrBuildOutput,
+    serverBuildOutput,
+    clientEntryFiles
+  );
+  await rscBuildRwEnvVars();
+};
+export {
+  buildRscClientAndServer
+};

package/dist/bundled/react-server-dom-webpack.server.d.ts

@@ -0,0 +1,2 @@
+export { decodeReply, decodeReplyFromBusboy, } from 'react-server-dom-webpack/server';
+//# sourceMappingURL=react-server-dom-webpack.server.d.ts.map

package/dist/bundled/react-server-dom-webpack.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-server-dom-webpack.server.d.ts","sourceRoot":"","sources":["../../src/bundled/react-server-dom-webpack.server.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,WAAW,EACX,qBAAqB,GACtB,MAAM,iCAAiC,CAAA"}