vite-plugin-react-server 0.3.0 → 0.3.4

package/scripts/bump-version.mjs

@@ -0,0 +1,68 @@
+import fs from 'node:fs/promises'
+import path from 'node:path'
+
+
+/**
+ * Bumps the version of the package.
+ * @param {'major' | 'minor' | 'patch'} type - The type of version to bump.
+ */
+async function bumpVersion(type) {
+  // Read package.json
+  const packageJson = JSON.parse(
+    await fs.readFile(path.resolve('package.json'), 'utf-8')
+  )
+  const packageLockJson = JSON.parse(
+    await fs.readFile(path.resolve('package-lock.json'), 'utf-8')
+  )
+
+  // Parse current version
+  const [major, minor, patch] = packageJson.version.split('.').map(Number)
+
+  // Calculate new version
+  /**
+   * The new version of the package.
+   * @type {string}
+   */
+  let newVersion
+  switch (type) {
+    case 'major':
+      newVersion = `${major + 1}.0.0`
+      break
+    case 'minor':
+      newVersion = `${major}.${minor + 1}.0`
+      break
+    case 'patch':
+      newVersion = `${major}.${minor}.${patch + 1}`
+      break
+  }
+
+  // Update both files
+  packageJson.version = newVersion
+  packageLockJson.version = newVersion
+  packageLockJson.packages[''].version = newVersion
+
+  // Write back
+  await fs.writeFile(
+    path.resolve('package.json'),
+    JSON.stringify(packageJson, null, 2) + '\n'
+  )
+  await fs.writeFile(
+    path.resolve('package-lock.json'),
+    JSON.stringify(packageLockJson, null, 2) + '\n'
+  )
+
+  console.log(`Version bumped to ${newVersion}`)
+}
+
+// Get version type from command line argument
+/**
+ * The type of version to bump.
+ * @type {'major' | 'minor' | 'patch'}
+ */
+const type = process.argv[2]
+if (!type || !['major', 'minor', 'patch'].includes(type)) {
+  console.error('Please specify version type: major, minor, or patch')
+  process.exit(1)
+}
+
+bumpVersion(type).catch(console.error) 

package/scripts/check-react-version.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const PATCH_RECONCILER_VERSION = '19.1.0-experimental-b3a95caf-20250113'
+const ALTERNATIVE_REACT_VERSION = '0.0.0-experimental-b3a95caf-20250113'
+const STUB_ESM_VERSION = `0.0.1`
+const PATCH_FILE = `react-server-dom-esm+${STUB_ESM_VERSION}.patch`
+
+async function main() {
+  try {
+    // Read installed React version
+    const reactPkgPath = path.resolve(process.cwd(), 'node_modules/react/package.json')
+    const reactPkg = JSON.parse(await fs.readFile(reactPkgPath, 'utf-8'))
+    const installedVersion = reactPkg.version
+
+    // Get our patch file from our package
+    const ourPatchPath = path.resolve(__dirname, `../patches/${PATCH_FILE}`)
+    let patchContent = await fs.readFile(ourPatchPath, 'utf-8')
+
+    // Replace the version in the patch content
+    patchContent = patchContent.replace(
+      new RegExp(PATCH_RECONCILER_VERSION, 'g'),
+      installedVersion
+    ).replace(
+      new RegExp(ALTERNATIVE_REACT_VERSION, 'g'),
+      installedVersion
+    )
+
+    // Create patches dir in user's project
+    const userPatchesDir = path.resolve(process.cwd(), 'patches')
+    await fs.mkdir(userPatchesDir, { recursive: true })
+
+    // Write the patch file - use stub version for filename
+    const newFileName = `react-server-dom-esm+${STUB_ESM_VERSION}.patch`
+    const newPatchPath = path.resolve(userPatchesDir, newFileName)
+    await fs.writeFile(newPatchPath, patchContent)
+
+    console.log(`Updated patch to match React version ${installedVersion}`)
+  } catch (error) {
+    
+  }
+}
+
+main() 

package/src/assertServerCondition.ts

@@ -0,0 +1,13 @@
+function assertServerCondition<P extends typeof process>(p: P): asserts p is P & { env: { NODE_OPTIONS: string } } {
+    const nodeOptions = p.env['NODE_OPTIONS'];
+    if (!nodeOptions?.match(/--conditions[= ]react-server/)) {
+        if(!nodeOptions?.match(/--conditions/)) {
+            console.warn(`process.env['NODE_OPTIONS'] is missing \`--conditions\` flag, it should be like \`--conditions=react-server\` or \`--conditions react-server\`, but was ${JSON.stringify(process.env['NODE_OPTIONS'])}`);
+        }
+        if(!nodeOptions?.match(/react-server/)) {
+            throw new Error(`process.env['NODE_OPTIONS'] is missing \`react-server\` flag, it should be like \`--conditions=react-server\` or \`--conditions react-server\`, but was ${JSON.stringify(process.env['NODE_OPTIONS'])}`);
+        }
+    }
+    return undefined;
+  };
+assertServerCondition(process);

package/src/build/createBuildConfig.ts

@@ -1,62 +1,43 @@
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
 import type { InlineConfig } from "vite";
-import { DEFAULT_CONFIG } from "../options.js";
-import type { StreamPluginOptions } from "../types.js";
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import type { ResolvedUserConfig, ResolvedUserOptions } from "../types.js";
+import type { InputOption } from "rollup";
+import { mergeInputs } from "./mergeInputs.js";
+import { createInputNormalizer } from "../helpers/inputNormalizer.js";
 
 type CreateBuildConfigOptions = {
+  input: InputOption;
+  userOptions:  ResolvedUserOptions;
+  userConfig: ResolvedUserConfig;
   root: string;
-  base: string;
-  outDir: string;
-  entries: string[];
-  options?: StreamPluginOptions;
+  moduleBaseExceptions: string[];
 };
 
+
 export function createBuildConfig({
   root,
-  base,
-  outDir,
-  entries,
-  options,
+  input,
+  userOptions,
+  userConfig,
+  moduleBaseExceptions
 }: CreateBuildConfigOptions) {
-  // Transform entries into proper input format with unique keys
-  const entryInputs = Object.fromEntries(
-    entries.map((entry) => {
-      // Get the path relative to root
-      const relativePath = entry.replace(root + "/", "");
-      // Create a unique key based on the full path
-      const key = relativePath.replace(/\.[^/.]+$/, ""); // Remove extension
-
-      return [key, entry];
-    })
-  );
-
-  const workerPath = options?.workerPath
-    ? resolve(root, options.workerPath)
-    : resolve(__dirname, "..", DEFAULT_CONFIG.WORKER_PATH);
+  const { output, input: inputConfig, ...restRollupOptions } =
+    userConfig.build.rollupOptions ?? {};
 
-  const loaderPath = options?.loaderPath
-    ? resolve(root, options.loaderPath)
-    : resolve(__dirname, "..", DEFAULT_CONFIG.LOADER_PATH);
+  let mergedInputs = mergeInputs(input, inputConfig);
 
+  let inputNormalizer = createInputNormalizer({
+    root,
+  });
+  if(typeof mergedInputs === 'object' && mergedInputs != null) {
+    mergedInputs = Object.fromEntries(Object.entries(mergedInputs).map(inputNormalizer));
+  }
   const config: InlineConfig = {
     configFile: false,
-    root,
-    base,
+    ...userConfig,
     build: {
-      target: "node18",
-      ssr: true,
-      ssrEmitAssets: false,
-      manifest: true,
-      ssrManifest: true,
-      outDir,
+      ...userConfig.build,
       rollupOptions: {
-        input: {
-          ...entryInputs,
-          worker: workerPath,
-          loader: loaderPath,
-        },
+        input: mergedInputs,
         output: {
           format: "esm",
           preserveModules: true,
@@ -65,7 +46,9 @@ export function createBuildConfig({
           entryFileNames: "[name].js",
           chunkFileNames: "[name].js",
           assetFileNames: "[name][extname]",
+          ...output,
         },
+        ...restRollupOptions,
       },
     },
   };

package/src/build/mergeInputs.ts

@@ -0,0 +1,42 @@
+import type { InputOption } from "rollup";
+
+export const mergeAsArray = (entries: InputOption) => {
+  return Array.isArray(entries)
+    ? entries
+    : typeof entries === "object" && entries != null
+    ? Object.values(entries)
+    : typeof entries === "string"
+    ? [entries]
+    : [];
+};
+export const mergeAsObject = (entries: InputOption) => {
+  return Array.isArray(entries)
+    ? Object.fromEntries(entries.map((entry) => [entry, entry]))
+    : typeof entries === "object" && entries != null
+    ? entries
+    : typeof entries === "string"
+    ? { [entries]: entries }
+    : {};
+};
+
+export const mergeInputs = (
+  input: InputOption,
+  input2: InputOption | undefined
+) => {
+  if (!input2) return input;
+  return Array.isArray(input)
+    ? [...input, ...mergeAsArray(input2)]
+    : typeof input === "string"
+    ? [input, ...mergeAsArray(input2)]
+    : input != null && typeof input2 === "object" && input2 != null
+    ? { ...input, ...mergeAsObject(input2) }
+    : input != null
+    ? input
+    : Array.isArray(input2)
+    ? input2
+    : typeof input2 === "object" && input2 != null
+    ? input2
+    : typeof input2 === "string"
+    ? input2
+    : [];
+};

package/src/helpers/inputNormalizer.ts

@@ -0,0 +1,22 @@
+import { relative } from "node:path";
+
+type NormalizedInputOptions = {
+  // will automatically remove this part
+  root?: string;
+};
+
+export const createInputNormalizer =
+  (
+    {
+      root = process.cwd(),
+    }: NormalizedInputOptions = {} as NormalizedInputOptions
+  ) =>
+  ([key, path]: [string, string]) =>
+    [
+      key,
+      path.startsWith(root)
+        ? relative(root, path)
+        : path.startsWith("/")
+        ? path
+        : `/${path}`,
+    ];

package/src/helpers/normalizedRelativePath.ts

@@ -4,56 +4,56 @@ type NormalizedRelativePathOptions = {
   // will automatically remove this part
   root: string;
   // will automatically see this as a optional extra part of the rootDir that will be removed
-  outDir: string | string[];
+  outDir: string;
   // will ensure it always starts with this path, if it does not it will be added
   moduleBase: string;
   // will ensure it never starts with a leading /, which in some cases is needed (vite entry), other cases it is not for example from project root /
   noLeadingSlash: boolean;
+  // will ensure it never ends with a trailing /
+  noTrailingSlash: boolean;
+  // allowed exception to moduleBase rules
+  moduleBaseExceptions: string[];
 };
 
 export const createNormalizedRelativePath = (
   options: NormalizedRelativePathOptions = {
     root: process.cwd(),
-    outDir: ["dist", "build"],
+    outDir: "dist",
     moduleBase: "src",
     noLeadingSlash: false,
+    noTrailingSlash: false,
+    moduleBaseExceptions: [],
   }
 ) => {
-  const base =
+  let base =
     options.noLeadingSlash && options.moduleBase.startsWith("/")
       ? options.moduleBase.slice(1)
       : options.moduleBase;
-  const removeOutDir = Array.isArray(options.outDir)
-    ? (path: string) =>
-        (options.outDir as string[])
-          .map((dir) => path.startsWith(dir))
-          .some((v) => v)
-          ? path.slice(options.outDir[0].length)
-          : path
-    : (path: string) =>
-        (options.outDir as string) === path
-          ? path.slice(options.outDir.length)
-          : path;
+  if (options.noTrailingSlash && base.endsWith("/")) {
+    base = base.slice(0, -1);
+  }
+  const removeOutDir = (path: string) =>
+    (options.outDir as string) === path
+      ? path.slice(options.outDir.length)
+      : path;
 
   const removeRoot = (path: string) => {
-    const normalized = normalizePath(path);
-    const relative = normalized.startsWith(options.root)
-      ? normalized.slice(options.root.length)
-      : normalized;
+    const relative = path.startsWith(options.root)
+      ? path.slice(options.root.length)
+      : path;
     return relative;
   };
 
   const ensureModuleBase = (path: string) => {
+    let transformed = path;
     if (options.noLeadingSlash && path.startsWith("/")) {
-      return path.slice(1);
+      transformed = path.slice(1);
     }
-    if (!path.startsWith(base)) {
-      throw new Error(
-        `Path ${path} does not start with module base ${base}, this will not work down the line.`
-      );
+    if (options.noTrailingSlash && transformed.endsWith("/")) {
+      transformed = transformed.slice(0, -1);
     }
-    return path;
+    return transformed;
   };
 
-  return (path: string) => ensureModuleBase(removeOutDir(removeRoot(path)));
+  return (path: string) => ensureModuleBase(removeOutDir(removeRoot(normalizePath(path))));
 };

package/src/helpers/tryManifest.ts

@@ -1,13 +1,20 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+import type { Manifest } from "vite";
 
-type TryManifestOptions = {
+type TryManifestOptions<SSR extends boolean> = {
   root: string;
   outDir: string;
-  ssrManifest: boolean;
+  ssrManifest: SSR;
 };
 
-export function tryManifest(options: TryManifestOptions) {
+export function tryManifest<SSR extends boolean>(options: TryManifestOptions<SSR>): {
+  type: "success";
+  manifest: SSR extends true ? Record<string, string[]> : Manifest;
+} | {
+  type: "error";
+  error: Error;
+} {
   const manifestPath = resolve(
     options.root,
     options.outDir,
@@ -15,9 +22,16 @@ export function tryManifest(options: TryManifestOptions) {
     options.ssrManifest ? "ssr-manifest.json" : "manifest.json"
   );
   try {
-    return JSON.parse(readFileSync(manifestPath, "utf-8"));
+    const result=  JSON.parse(readFileSync(manifestPath, "utf-8"));
+    return {
+      type: "success",
+      manifest: result,
+    }
   } catch (e) {
     console.log("No manifest found", manifestPath);
-    return null;
+    return {
+      type: "error",
+      error: e as Error,
+    }
   }
 }

package/src/html/createPageLoader.ts

@@ -71,6 +71,8 @@ export const createPageLoader = ({
     outDir,
     moduleBase,
     noLeadingSlash: true,
+    noTrailingSlash: true,
+    moduleBaseExceptions: [],
   });
   return async (id: string) => {
     const normalizedId = pathNormalizer(id);