vite-plugin-react-server 1.1.9 → 1.1.11

package/plugin/config/resolveUserConfig.ts

@@ -6,6 +6,7 @@ import type {
 } from "../types.js";
 import { join } from "node:path";
 import type { OutputOptions, PreRenderedAsset, PreRenderedChunk } from "rollup";
+import { DEFAULT_CONFIG } from "./defaults.js";
 
 let stashedUserConfig: Record<string, ResolvedUserConfig | null> = {};
 
@@ -31,7 +32,12 @@ export function resolveUserConfig({
   const ssr =
     typeof config.build?.ssr === "boolean"
       ? config.build?.ssr
-      : Boolean(configEnv.isSsrBuild) || condition === "react-server";
+      : Boolean(configEnv.isSsrBuild) ||
+        condition === "react-server" ||
+        (typeof process.env["VITE_SSR"] === "string"
+          ? process.env["VITE_SSR"] === "true" ||
+            process.env["VITE_SSR"] === "1"
+          : Boolean(process.env["VITE_SSR"]));
   const envDir =
     condition === "react-client" && ssr
       ? userOptions.build.client
@@ -59,40 +65,86 @@ export function resolveUserConfig({
     if (!ssr || !input) {
       return fallback(info, false);
     }
-    const [, value] = userOptions.normalizer(
-      input
-    );
+    const [, value] = userOptions.normalizer(input);
     const entry = autoDiscoveredFiles.staticManifest[value];
-    if(entry?.name && info.type === 'asset' && userOptions.autoDiscover.cssPattern(value)) {
-      const withoutExt = entry.name?.split('.')[0]
-      const found = entry.css?.find(css => css.startsWith(withoutExt as string))
-      if(found) {
-        return found
+    if (
+      entry?.name &&
+      info.type === "asset" &&
+      userOptions.autoDiscover.cssPattern(value)
+    ) {
+      const withoutExt = entry.name?.split(".")[0];
+      const found = entry.css?.find((css) =>
+        css.startsWith(withoutExt as string)
+      );
+      if (found) {
+        return found;
       } else {
-        return entry.file
+        return entry.file;
       }
-    }
-    if (entry) {
-      return entry.file
+    } else if (entry) {
+      return entry.file;
     }
     return fallback(info, true);
   };
+  const userDefinedOutput = config.build?.rollupOptions?.output;
+  const hasOtherOutput =
+    Array.isArray(userDefinedOutput) && userDefinedOutput.length > 1;
+  const hasValidOutput = userDefinedOutput && !hasOtherOutput;
+  const hasObjectOutput =
+    userDefinedOutput &&
+    !hasOtherOutput &&
+    typeof userDefinedOutput === "object" &&
+    userDefinedOutput !== null;
+
+  const userDefinedAssetFileNames = hasObjectOutput
+    ? "assetFileNames" in userDefinedOutput
+      ? userDefinedOutput.assetFileNames
+      : undefined
+    : // find the other asset file names
+    hasOtherOutput
+    ? (userDefinedOutput.find((o) => o.assetFileNames) as OutputOptions)
+        .assetFileNames
+    : undefined;
+
+  const userDefinedChunkFileNames = hasValidOutput
+    ? "chunkFileNames" in userDefinedOutput
+      ? userDefinedOutput.chunkFileNames
+      : undefined
+    : undefined;
+  const userDefinedEntryFileNames = hasValidOutput
+    ? "entryFileNames" in userDefinedOutput
+      ? userDefinedOutput.entryFileNames
+      : undefined
+    : undefined;
+
+  let stashedReturns: Record<string, string> = {};
   const pluginOutput = {
     preserveModulesRoot: userOptions.build.preserveModulesRoot
       ? userOptions.moduleBase
       : undefined,
-    entryFileNames: (info) => {
-      const input = info.facadeModuleId
-      return handleSsrName(info,  input, userOptions.build.entryFile, ssr);
-    },
-    assetFileNames: (i) => {
-      const input = i.originalFileNames[0]
-      return handleSsrName(i, input, userOptions.build.assetFile, ssr);
-    },
-    chunkFileNames: (i) => {
-      const input = i.facadeModuleId 
-      return handleSsrName(i, input, userOptions.build.chunkFile, ssr);
-    },
+    entryFileNames:
+      userDefinedEntryFileNames ??
+      ((info) => {
+        const input = info.facadeModuleId;
+        return handleSsrName(info, input, userOptions.build.entryFile, ssr);
+      }),
+    assetFileNames: process.env["VITEST"]
+      ? undefined
+      : userDefinedAssetFileNames ??
+        ((i) => {
+          const input = i.originalFileNames[0];
+          if (!stashedReturns[input]) {
+            const r = handleSsrName(i, input, userOptions.build.assetFile, ssr);
+            stashedReturns[input] = r;
+          }
+          return stashedReturns[input];
+        }),
+    chunkFileNames:
+      userDefinedChunkFileNames ??
+      ((i) => {
+        const input = i.facadeModuleId;
+        return handleSsrName(i, input, userOptions.build.chunkFile, ssr);
+      }),
     format: "esm",
     exports: "named",
   } satisfies OutputOptions;
@@ -103,32 +155,71 @@ export function resolveUserConfig({
       config.build?.rollupOptions?.output !== null
     ? [config.build?.rollupOptions?.output, pluginOutput]
     : pluginOutput;
-  const vitePrefix = config.envPrefix ?? "VITE_";
-  const mode =
-    process.env["NODE_ENV"] === "development"
-      ? "development"
-      : config.mode
-      ? config.mode
-      : configEnv.mode
-      ? configEnv.mode
-      : configEnv.command === "build"
-      ? "production"
-      : "development";
+  const vitePrefix = config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX;
+  const mode = config.mode ?? process.env["VITE_MODE"];
   const minify = config.build?.minify;
-  const safeParseURL = (() => {
-    try {
-      return new URL(userOptions.moduleBasePath, userOptions.moduleBaseURL).href;
-    } catch (error) {
-      return userOptions.moduleBaseURL + userOptions.moduleBasePath;
-    }
-  })();
+
+  const srrConfig = {
+    ...config.ssr,
+    target: config.ssr?.target ?? "node",
+    optimizeDeps: {
+      ...config.ssr?.optimizeDeps,
+      include: config.ssr?.optimizeDeps?.include ?? [
+        "react",
+        "react-dom",
+        "react-server-dom-esm/client",
+      ],
+    },
+    resolve: {
+      ...config.ssr?.resolve,
+      externalConditions: config.ssr?.resolve?.externalConditions ?? [
+        "react-server",
+      ],
+    },
+  };
+  let publicOrigin =
+    userOptions.publicOrigin ?? process.env.VITE_PUBLIC_ORIGIN ?? "";
+  let PROD = mode === "production";
+  let DEV = mode === "development";
+  if (configEnv.command === "serve" && !configEnv.isPreview) {
+    publicOrigin = `http${config.server?.https ? "s" : ""}://${
+      typeof config.server?.host === "string"
+        ? config.server?.host
+        : "localhost"
+    }:${typeof config.server?.port === "number" ? config.server?.port : 5173}`;
+  }
+  const ssrDefine = ssr
+    ? {
+        [`process.env.${vitePrefix}SSR`]: `${ssr}`,
+        [`process.env.${vitePrefix}DEV`]: `${DEV}`,
+        [`process.env.${vitePrefix}PROD`]: `${PROD}`,
+        [`process.env.${vitePrefix}MODE`]: `"${mode}"`,
+        [`process.env.${vitePrefix}BASE_URL`]: `"${userOptions.moduleBaseURL}"`,
+        [`process.env.${vitePrefix}PUBLIC_ORIGIN`]: `"${publicOrigin}"`,
+      }
+    : {};
+  const define = {
+    ...config.define,
+    [`import.meta.env.PUBLIC_ORIGIN`]: `"${publicOrigin}"`,
+    ...ssrDefine,
+  };
+  // these will never be cleaned up, because, we are resolving the user config
+  // and it's assumed the thread closes after this and we don't want
+  // it to change after the config has been resolved
+  if (process.env.VITE_BASE_URL !== userOptions.moduleBaseURL) {
+    process.env.VITE_BASE_URL = userOptions.moduleBaseURL;
+  }
+  if (process.env.VITE_PUBLIC_ORIGIN !== publicOrigin) {
+    process.env.VITE_PUBLIC_ORIGIN = publicOrigin;
+  }
+
   if (condition === "react-client") {
     // client plugin build options (client plugin still outputs server files)
     const clientConfig = {
       ...config,
       root: root,
       mode: mode,
-      base: safeParseURL,
+      base: userOptions.moduleBaseURL,
       envPrefix: vitePrefix,
       resolve: {
         ...config.resolve,
@@ -138,31 +229,18 @@ export function resolveUserConfig({
           "react-server-dom-esm/client",
         ],
       },
-      ssr: {
-        ...config.ssr,
-        target: config.ssr?.target ?? "node",
-        optimizeDeps: {
-          ...config.ssr?.optimizeDeps,
-          include: config.ssr?.optimizeDeps?.include ?? [
-            "react",
-            "react-dom",
-            "react-server-dom-esm/client",
-          ],
-        },
-        resolve: {
-          ...config.ssr?.resolve,
-          externalConditions: config.ssr?.resolve?.externalConditions ?? [
-            "react-server",
-          ],
-        },
-      },
+      define: define,
+      ssr: srrConfig,
       // client build options
       build: {
         ...config.build,
         emptyOutDir: config.build?.emptyOutDir ?? true,
         outDir: config.build?.outDir ?? join(userOptions.build.outDir, envDir),
         assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,
-        copyPublicDir: typeof config.build?.copyPublicDir === "boolean" ? config.build?.copyPublicDir : !ssr,
+        copyPublicDir:
+          typeof config.build?.copyPublicDir === "boolean"
+            ? config.build?.copyPublicDir
+            : !ssr,
         // modern browsers
         target: config.build?.target ?? ["esnext"],
         minify: minify,
@@ -194,7 +272,7 @@ export function resolveUserConfig({
       ...config,
       root: root,
       mode: mode,
-      base: userOptions.moduleBasePath,
+      base: userOptions.moduleBaseURL,
       envPrefix: vitePrefix,
       resolve: {
         ...config.resolve,
@@ -202,39 +280,8 @@ export function resolveUserConfig({
           "react-server",
         ],
       },
-      define: {
-        ...config.define,
-        [`process.env.${vitePrefix}SSR`]: `"1"`,
-        [`process.env.${vitePrefix}DEV`]: `"${mode === "development" ? "1" : "0"}"`,
-        [`process.env.${vitePrefix}PROD`]: `"${mode === "production" ? "1" : "0"}"`,
-        [`process.env.${vitePrefix}MODE`]: `"${mode}"`,
-        [`process.env.${vitePrefix}BASE_URL`]: `"${
-          userOptions.moduleBasePath === "" ||
-          userOptions.moduleBasePath === "/"
-            ? "/"
-            : !userOptions.moduleBasePath.endsWith("/")
-            ? userOptions.moduleBasePath + "/"
-            : userOptions.moduleBasePath
-        }"`,
-      },
-      ssr: {
-        ...config.ssr,
-        target: config.ssr?.target ?? "node",
-        optimizeDeps: {
-          ...config.ssr?.optimizeDeps,
-          include: config.ssr?.optimizeDeps?.include ?? [
-            "react",
-            "react-dom",
-            "react-server-dom-esm/client",
-          ],
-        },
-        resolve: {
-          ...config.ssr?.resolve,
-          externalConditions: config.ssr?.resolve?.externalConditions ?? [
-            "react-server",
-          ],
-        },
-      },
+      define: define,
+      ssr: srrConfig,
       // server build options
       build: {
         ...config.build,
@@ -252,7 +299,7 @@ export function resolveUserConfig({
         copyPublicDir:
           typeof config.build?.copyPublicDir === "boolean"
             ? config.build?.copyPublicDir
-            : false,
+            : !ssr,
         assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,
         // Ensure CSS files are output to static directory
         cssCodeSplit:

package/plugin/env/index.ts

@@ -0,0 +1 @@
+export * from './plugin.js';

package/plugin/env/plugin.ts

@@ -0,0 +1,78 @@
+import type { Plugin } from "vite";
+import { resolveConfigDefine, resolveEnv } from "../config/resolveEnv.js";
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+import { userProjectRoot } from "../root.js";
+const isBuild = process.argv[process.argv.length - 1] === "build";
+const isPreview = process.argv.findIndex((arg) => arg === "preview") !== -1;
+
+
+// Set up environment variables from .env files as early as possible
+// This is to ensure that the env variables are available even in the config file,
+// and you can use process.env to configure the plugin.
+const cleanupInitialUserConfigEnv = resolveEnv(
+  process.env["NODE_ENV"] || (isBuild || isPreview ? "production" : "development"),
+  userProjectRoot,
+  DEFAULT_CONFIG.ENV_PREFIX
+);
+
+/**
+ * This plugin can be used to set up the environment defined in the env file
+ * and the `define` clause in the vite config to be directly assigned to the process.env,
+ * making it available in workers, server components and plugin hooks like config, configureServer, etc.
+ *
+ * You can also set these variable in the package.json script like `VITE_PUBLIC_ORIGIN=https://example.com npm run build`
+ * The default ones like `VITE_DEV` etc, are set to the default values if not defined in the env file or the `define` clause.
+ *
+ * If they do end up in the build, the define clause replaces process.env.VITE_BASE_URL etc, same like it
+ * replaces `import.meta.env.BASE_URL`.
+ *
+ * While using node.process.env is dangerous as it may expose valuable information to the client, the define clause
+ * replaces them in the build so it's safe as long as you stick to simple stuff like const baseUrl = process.env.VITE_BASE_URL
+ * would be the same as writing const baseUrl = import.meta.env.BASE_URL. But this plugin doesn't enable that feature nor does
+ * it return any config, it just sets the process.env variables at a early momemt and deletes them after the build unless they were
+ * already set in the environment.
+ * 
+ * This plugin will not override process.env variable that were previously set, and will remove any values that it did set after the bundle closes.
+ * ```example
+ * const config = {
+ *    moduleBase: 'src',
+ *    // loaded from either .env file or existing process.env, based on the NODE_ENV
+ *    publicOrigin: process.env.VITE_PUBLIC_ORIGIN,
+ * }
+ * ```
+ * @returns
+ */
+export function envPlugin(): Plugin {
+  let cleanupEnv: (() => void) | undefined;
+  return {
+    name: "vite-plugin-react-server:env",
+    enforce: "pre",
+    config(config, { mode }) {
+      const invalidEnv =
+        (mode !== undefined && mode !== process.env.VITE_MODE) ||
+        (config.root !== undefined && config.root !== userProjectRoot);
+      if (invalidEnv) {
+        cleanupInitialUserConfigEnv();
+      }
+      // Clean up any previous env setup
+      const cleanupUserConfigEnv = invalidEnv
+        ? resolveEnv(
+            mode || process.env.VITE_MODE,
+            config.root ?? userProjectRoot,
+            config.envPrefix ?? DEFAULT_CONFIG.ENV_PREFIX
+          )
+        : cleanupInitialUserConfigEnv;
+      const cleanupUserConfig = resolveConfigDefine(config);
+
+      // Combine cleanup functions
+      cleanupEnv = () => {
+        cleanupUserConfig();
+        cleanupUserConfigEnv();
+      };
+    },
+    closeBundle() {
+      // Clean up environment variables when the bundle is closed
+      cleanupEnv?.();
+    },
+  };
+}

package/plugin/error/toError.ts

@@ -0,0 +1,19 @@
+export function toError(error: unknown): {
+  name: string;
+  message: string;
+  stack?: string;
+} {
+  return error instanceof Error
+    ? error
+    : typeof error === "object" && error !== null
+    ? {
+        name: "name" in error ? String(error.name) : "Unknown Error",
+        message: "message" in error ? String(error.message) : "Unknown Error",
+        stack: "stack" in error ? String(error.stack) : undefined,
+      }
+    : {
+        name: "Unknown Error",
+        message: typeof error === "string" ? error : "Unknown Error",
+        stack: undefined,
+      };
+}

package/plugin/file-preserver/plugin.ts

@@ -0,0 +1,117 @@
+import type { OutputAsset } from "rollup";
+import type { ESBuildOptions, Plugin as VitePlugin } from "vite";
+import { transformWithEsbuild } from "vite";
+import { writeFile } from "node:fs/promises";
+import { join, sep } from "node:path";
+/**
+ * Bundling with vite may have some side effects, this plugin is a workaround to prevent
+ * the side effects from happening to the files we want to preserve. It's used as a plugin
+ * to build this plugin, but you can also use it as a standalone plugin for your projects to have
+ * the same effect.
+ * @example
+ * ```tsx
+ * import { filePreserverPlugin } from "vite-plugin-react-server/file-preserver";
+ *
+ * export default defineConfig({
+ *   plugins: [filePreserverPlugin("utils/env")], // don't include the extension
+ * });
+ * ```
+ * The typescript file will not be transformed by vite, only by esbuild, so you can preserve your import.meta.env
+ * and use it in your client boundary files.
+ */
+export function filePreserverPlugin(fileName: string | string[]): VitePlugin[] {
+  let sources: {
+    id: string;
+    originalCode: string;
+    transformedCode: string;
+    map: string;
+  }[] = [];
+  let pluginName =
+    typeof fileName === "string" ? fileName : fileName.slice(3).join("-");
+  let outDir: string = "dist";
+  let root: string = process.cwd();
+  let esbuildOptions: ESBuildOptions = {
+    jsxDev: false,
+    supported: { "import-meta": true },
+    target: "esnext",
+    format: "esm",
+  };
+  let shouldPreserve = Array.isArray(fileName)
+    ? (id: string) => fileName.some((f) => id.includes(f))
+    : (id: string) => id.includes(fileName);
+  return [
+    {
+      name: `vite:preserver-${pluginName}:post`,
+      enforce: "post",
+      apply: "build",
+      async transform(_code: string, id: string) {
+        if (!shouldPreserve(id)) return;
+        const normalId = id.replace(root + sep, "");
+        const found = sources.findIndex((s) => s.id === normalId);
+        if (found === -1) {
+          throw new Error(`Source not registered by pre hook for ${id}`);
+        }
+        return {
+          code: sources[found].transformedCode,
+          map: sources[found].map,
+          id: sources[found].id,
+        };
+      },
+      async writeBundle(_options, bundle) {
+        if (sources.length === 0) return;
+        const entries = Object.entries(bundle);
+        const mapEntries = entries.filter(
+          (entry): entry is [string, OutputAsset] => {
+            return (
+              entry[1].fileName.endsWith(".map") &&
+              shouldPreserve(entry[1].fileName)
+            );
+          }
+        );
+        if (mapEntries.length === 0) {
+          return;
+        }
+        // even though we're returning the new source map, it might just write ;;;; to the file
+        for (const source of sources) {
+          for (const [fileName, outputAsset] of mapEntries) {
+            const ourMap = source.map;
+            const path = join(root, outDir, fileName);
+            if (outputAsset.source !== ourMap) {
+              await writeFile(path, ourMap);
+            }
+          }
+        }
+      },
+    },
+    {
+      name: `vite:preserver-${pluginName}:pre`,
+      apply: "build",
+      enforce: "pre",
+      configResolved(config) {
+        outDir = config.build.outDir;
+        root = config.root;
+        esbuildOptions = config.esbuild || esbuildOptions;
+      },
+      async transform(code: string, id: string) {
+        if (!shouldPreserve(id)) return;
+        const found = sources.find((s) => s.id === id);
+        if (found) {
+          throw new Error(`Source already exists for ${id}`);
+        }
+        const result = await transformWithEsbuild(code, id, esbuildOptions);
+        const source = {
+          id: id.replace(root + sep, ""),
+          originalCode: code,
+          transformedCode: result.code,
+          map: JSON.stringify(result.map),
+        };
+        sources.push(source);
+        return {
+          id: source.id,
+          code: source.transformedCode,
+          map: source.map,
+        };
+      },
+    },
+  ];
+}

package/plugin/helpers/createCssProps.tsx

@@ -76,14 +76,22 @@ export const createCssProps = ({
         : {}),
     } as CssContent<true>;
   }
+  const joined = normalizedId.startsWith(moduleBasePath) ? normalizedId : join(moduleBasePath, normalizedId);
+  const moduleBaseHasTrailingSlash = moduleBaseURL.endsWith("/");
+  const joinedHasLeadingSlash = joined.startsWith("/");
   const safeParseURL = (() => {
-    try {
-      return new URL(join(moduleBasePath, normalizedId), moduleBaseURL).href;
-    } catch (error) {
-      // if the url is not valid, we return the moduleBaseURL + the normalizedId
-      // dont make it a argument of join or it will mangle something like http:// into http:/
-      return moduleBaseURL + join(moduleBasePath, normalizedId);
+    if(joined.startsWith(moduleBaseHasTrailingSlash ? moduleBaseURL.slice(0, -1) : moduleBaseURL)) {
+      return joined;
     }
+    try {
+      if (moduleBaseURL.includes("//")) {
+        // relative to moduleBaseURL
+        return new URL(joinedHasLeadingSlash ? joined.slice(1) : joined, moduleBaseURL).href;
+      }
+    } catch (error) {}
+    // if the url is not valid, we return the moduleBaseURL + the normalizedId
+    // dont make it a argument of join or it will mangle something like http:// into http:/
+    return moduleBaseURL + (!moduleBaseHasTrailingSlash && !joinedHasLeadingSlash ? "/" : "") + (moduleBaseHasTrailingSlash ? joined.slice(1) : joined);
   })();
   // Default case
   return {

package/plugin/helpers/createRscStream.tsx

@@ -1,4 +1,4 @@
-import { React, ReactDOMServer } from "../vendor.server.js";
+import { React, ReactDOMServer } from "../vendor/vendor.server.js";
 import type { CreateHandlerOptions, StreamMetrics } from "../types.js";
 import { performance } from "node:perf_hooks";
 export function createRscStream<

package/plugin/helpers/formatMetrics.ts

@@ -32,6 +32,6 @@ Stream:
 `.trim();
 }
 
-export function logMetrics(metrics: RenderMetrics) {
-  console.log(formatMetrics(metrics));
+export function logMetrics(metrics: RenderMetrics, logger: {info: (message: string) => void} = console) {
+  logger.info(formatMetrics(metrics));
 } 

package/plugin/helpers/getRouteFiles.ts

@@ -17,7 +17,7 @@ type GetRouteFilesError = {
 export const getRouteFiles = async (
   route: string,
   autoDiscoveredFiles: AutoDiscoveredFiles,
-  userOptions: ResolvedUserOptions
+  userOptions: Pick<ResolvedUserOptions, "Page" | "props" | "moduleBasePath">
 ): Promise<GetRouteFilesSuccess | GetRouteFilesError> => {
   if (autoDiscoveredFiles.urlMap.has(route)) {
     const { page, props } = autoDiscoveredFiles.urlMap.get(route)!;
@@ -32,6 +32,7 @@ export const getRouteFiles = async (
     return { type: "error", error };
   }
   if (!userOptions.props) {
+    autoDiscoveredFiles.urlMap.set(route, { page: Page, props: undefined });
     return { type: "success", page: Page, props: undefined };
   }
   const {
@@ -43,5 +44,6 @@ export const getRouteFiles = async (
   if (propsType === "error") {
     return { type: "error", error: propsError };
   }
+  autoDiscoveredFiles.urlMap.set(route, { page: Page, props });
   return { type: "success", page: Page, props };
 };

package/plugin/helpers/index.ts

@@ -0,0 +1,38 @@
+// Route and file handling
+export * from "./getRouteFiles.js";
+export * from "./resolvePage.js";
+export * from "./resolveProps.js";
+export * from "./resolvePageAndProps.js";
+export * from "./requestInfo.js";
+export * from "./requestToRoute.js";
+
+// Configuration and options
+export * from "./serializeUserOptions.js";
+export * from "./cleanObject.js";
+export * from "./inputNormalizer.js";
+
+// CSS handling
+export * from "./collectBundleManifestCss.js";
+export * from "./collectManifestCss.js";
+export * from "./collectViteModuleGraphCss.js";
+export * from "./createCssProps.jsx";
+
+// Stream and handler creation
+export * from "./createRscStream.jsx";
+export * from "./createHandler.js";
+export * from "./createEventHandler.js";
+
+// Metrics and monitoring
+export * from "./formatMetrics.js";
+export * from "./metrics.js";
+
+// Manifest handling
+export * from "./tryManifest.js";
+export * from "./getBundleManifest.js";
+
+// Module handling
+export * from "./moduleRefs.js";
+
+// Utility functions
+export * from "./stashReturnValue.js";
+export * from "./defaultFileWriter.js";