vite-plugin-react-server 1.1.12 → 1.1.13

package/plugin/config/resolveOptions.ts

@@ -1,39 +1,17 @@
 import type { PreRenderedAsset } from "rollup";
 import type { PreRenderedChunk } from "rollup";
-import type { StreamPluginOptions, ResolvedUserOptions } from "../types.js";
+import type {
+  StreamPluginOptions,
+  ResolvedUserOptions,
+  PagePropOpt,
+  InlineCssOpt,
+} from "../types.js";
 import { DEFAULT_CONFIG } from "./defaults.js";
 import { join } from "node:path";
 import { pluginRoot } from "../root.js";
 import { CssCollector } from "../components/css-collector.js";
 import { createInputNormalizer } from "../helpers/inputNormalizer.js";
-
-// ============================================================================
-// Utility Functions
-// ============================================================================
-
-/**
- * Resolves a matcher pattern to a function that tests paths
- */
-const resolveAutoDiscoverMatcher = (
-  options: undefined | string | RegExp | ((path: string) => boolean),
-  fallback: RegExp | ((path: string) => boolean)
-) => {
-  if (!options) {
-    if (typeof fallback === "function") {
-      return fallback;
-    } else {
-      return (path: string) => fallback.test(path);
-    }
-  }
-  if (typeof options === "string") {
-    const matcher = new RegExp(options);
-    return (path: string) => matcher.test(path);
-  } else if (typeof options === "function") {
-    return options;
-  } else {
-    return (path: string) => options.test(path);
-  }
-};
+import { resolveAutoDiscoverMatcher } from "./resolveAutoDiscoverMatcher.js";
 
 /**
  * Ensures a path ends with .js extension
@@ -72,13 +50,13 @@ const registerPath = (
 // ============================================================================
 
 export const resolveOptions = <
-  InlineCSS extends boolean | undefined = boolean | undefined
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
 >(
-  options: StreamPluginOptions<InlineCSS>
+  options: StreamPluginOptions<T, InlineCSS>
 ):
-  | { type: "success"; userOptions: ResolvedUserOptions<InlineCSS> }
+  | { type: "success"; userOptions: ResolvedUserOptions<T, InlineCSS> }
   | { type: "error"; error: Error } => {
-    
   // Basic configuration
   const projectRoot = options.projectRoot ?? process.cwd();
   const {
@@ -102,40 +80,81 @@ export const resolveOptions = <
   const assetsDir =
     options.build?.assetsDir ?? `${DEFAULT_CONFIG.CLIENT_ASSETS_DIR}`;
 
-  // Path normalization helpers
-  const ensureModuleBase = (n: string | null) => {
-    if (!n) return "";
-    return n.startsWith(moduleBase + "/") ? n.slice(moduleBase.length + 1) : n;
-  };
+  // Build options
+  const preserveModulesRoot =
+    options.build?.preserveModulesRoot ??
+    DEFAULT_CONFIG.BUILD.preserveModulesRoot;
+
+  // Module path configuration
+  const moduleBase =
+    typeof options.moduleBase === "string"
+      ? options.moduleBase
+      : DEFAULT_CONFIG.MODULE_BASE;
+
+  const moduleBasePath =
+    typeof options.moduleBasePath === "string"
+      ? options.moduleBasePath
+      : process.env.VITE_BASE_URL ?? DEFAULT_CONFIG.MODULE_BASE_PATH;
 
-  const hasWrongRoot = !projectRoot.startsWith("/");
-  if (hasWrongRoot) {
-    console.warn("projectRoot is not a full path", projectRoot);
+  const moduleBaseURL =
+    typeof options.moduleBaseURL === "string"
+      ? options.moduleBaseURL
+      : process.env.VITE_BASE_URL ?? DEFAULT_CONFIG.MODULE_BASE_URL;
+
+  const moduleRootPath =
+    typeof options.moduleRootPath === "string"
+      ? options.moduleRootPath
+      : join(projectRoot, outDir, client);
+
+  const publicOrigin =
+    typeof options.publicOrigin === "string"
+      ? options.publicOrigin
+      : process.env.VITE_PUBLIC_ORIGIN ?? DEFAULT_CONFIG.PUBLIC_ORIGIN;
+
+  // Worker and loader paths
+  const rscWorkerPath =
+    typeof options.rscWorkerPath === "string"
+      ? join(projectRoot, options.rscWorkerPath)
+      : join(pluginRoot, DEFAULT_CONFIG.RSC_WORKER_PATH);
+
+  const htmlWorkerPath =
+    typeof options.htmlWorkerPath === "string"
+      ? join(projectRoot, options.htmlWorkerPath)
+      : join(pluginRoot, DEFAULT_CONFIG.HTML_WORKER_PATH);
+
+  const loaderPath =
+    typeof options.loaderPath === "string"
+      ? join(projectRoot, options.loaderPath)
+      : join(pluginRoot, DEFAULT_CONFIG.LOADER_PATH);
+  // these will never be cleaned up, because, we are resolving the user options
+  // and it's assumed they are relevant until the process stops
+  if (process.env.VITE_BASE_URL !== moduleBaseURL) {
+    process.env.VITE_BASE_URL = moduleBaseURL;
   }
-  /**
-   * If the defined project root is already wrong, we keep it as is.
-   * Otherwise, we remove the leading slash as a representation of the wrong root.
-   */
-  const wrongRoot = !hasWrongRoot ? projectRoot.slice(1) : projectRoot;
-
-  const ensureNoRoot = (n: string | null) => {
-    if (typeof n !== "string" || n === "") {
-      return "";
-    }
-    // if the path starts with the wrong root, we remove the wrong root
-    if (n.startsWith(wrongRoot)) {
-      return n.slice(wrongRoot.length + 1);
-    }
-    // if the path starts with the project root, we remove the project root
-    return n.startsWith(projectRoot + "/")
-      ? n.slice(projectRoot.length + 1)
-      : n;
-  };
+  if (process.env.VITE_PUBLIC_ORIGIN !== publicOrigin) {
+    process.env.VITE_PUBLIC_ORIGIN = publicOrigin;
+  }
+
+  const normalizer =
+    options.normalizer ??
+    createInputNormalizer({
+      root: projectRoot,
+      preserveModulesRoot:
+        preserveModulesRoot === true ? moduleBase : undefined,
+      removeExtension: true,
+      moduleBasePath,
+    });
 
+  const testModuleExtension = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.moduleExtension,
+    DEFAULT_CONFIG.AUTO_DISCOVER.moduleExtension
+  );
   // Auto-discovery pattern matchers
   const testModulePattern = resolveAutoDiscoverMatcher(
     options.autoDiscover?.modulePattern,
-    DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern
+    options.autoDiscover?.moduleExtension
+      ? (id: string) => testModuleExtension(id.toLowerCase())
+      : DEFAULT_CONFIG.AUTO_DISCOVER.modulePattern
   );
 
   const testJson = resolveAutoDiscoverMatcher(
@@ -160,12 +179,20 @@ export const resolveOptions = <
 
   const testClientComponents = resolveAutoDiscoverMatcher(
     options.autoDiscover?.clientComponents,
-    DEFAULT_CONFIG.AUTO_DISCOVER.clientComponents
+    options.autoDiscover?.moduleExtension
+      ? (id: string) =>
+          testModuleExtension(id.toLowerCase()) &&
+          /(\.|\/)?client(\.|\/)/.test(id.toLowerCase())
+      : DEFAULT_CONFIG.AUTO_DISCOVER.clientComponents
   );
 
   const testServerFunctions = resolveAutoDiscoverMatcher(
     options.autoDiscover?.serverFunctions,
-    DEFAULT_CONFIG.AUTO_DISCOVER.serverFunctions
+    options.autoDiscover?.moduleExtension
+      ? (id: string) =>
+          testModuleExtension(id.toLowerCase()) &&
+          /(\.|\/)?server(\.|\/)/.test(id.toLowerCase())
+      : DEFAULT_CONFIG.AUTO_DISCOVER.serverFunctions
   );
 
   const testNodeOnly = resolveAutoDiscoverMatcher(
@@ -175,12 +202,20 @@ export const resolveOptions = <
 
   const testPropsPattern = resolveAutoDiscoverMatcher(
     options.autoDiscover?.propsPattern,
-    DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern
+    options.autoDiscover?.moduleExtension
+      ? (id: string) =>
+          testModuleExtension(id.toLowerCase()) &&
+          /(\.|\/)?props(\.|\/)/.test(id.toLowerCase())
+      : DEFAULT_CONFIG.AUTO_DISCOVER.propsPattern
   );
 
   const testPagePattern = resolveAutoDiscoverMatcher(
     options.autoDiscover?.pagePattern,
-    DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern
+    options.autoDiscover?.moduleExtension
+      ? (id: string) =>
+          testModuleExtension(id.toLowerCase()) &&
+          /(\.|\/)?page(\.|\/)/.test(id.toLowerCase())
+      : DEFAULT_CONFIG.AUTO_DISCOVER.pagePattern
   );
 
   const testCssModule = resolveAutoDiscoverMatcher(
@@ -203,10 +238,21 @@ export const resolveOptions = <
     DEFAULT_CONFIG.AUTO_DISCOVER.dotFiles
   );
 
-  // Build options
-  const preserveModulesRoot =
-    options.build?.preserveModulesRoot ??
-    DEFAULT_CONFIG.BUILD.preserveModulesRoot;
+  const isServerFunction = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.isServerFunction,
+    options.autoDiscover?.serverDirective
+      ? (code: string) =>
+          code.match(options.autoDiscover?.serverDirective!) !== null
+      : DEFAULT_CONFIG.AUTO_DISCOVER.serverDirective
+  );
+
+  const isClientComponent = resolveAutoDiscoverMatcher(
+    options.autoDiscover?.isClientComponent,
+    options.autoDiscover?.clientDirective
+      ? (code: string) =>
+          code.match(options.autoDiscover?.clientDirective!) !== null
+      : DEFAULT_CONFIG.AUTO_DISCOVER.clientDirective
+  );
 
   const hashOption =
     typeof options.build?.hash === "string"
@@ -304,45 +350,47 @@ export const resolveOptions = <
         return hash(`${n.name}.js`, ssr);
       }
     }
-    return hash(
-      addModuleExtension(getOutputPath(ensureModuleBase(ensureNoRoot(n.name)))),
-      ssr
-    );
+    return hash(addModuleExtension(getOutputPath(normalizer(n.name)[0])), ssr);
   };
 
   const chunkFile = (n: PreRenderedChunk, ssr: boolean) => {
-    return hash(
-      addModuleExtension(
-        getOutputPath(ensureModuleBase(ensureNoRoot("_" + n.name)))
-      ),
-      ssr
-    );
+    return hash(addModuleExtension(getOutputPath(normalizer(n.name)[0])), ssr);
   };
 
   const assetFile = (n: PreRenderedAsset, ssr: boolean) => {
-    return hash(getOutputPath(ensureModuleBase(ensureNoRoot(n.names[0]))), ssr);
+    return hash(getOutputPath(normalizer(n.names[0])[0]), ssr);
   };
 
   const moduleID =
     typeof options.moduleID === "function"
       ? options.moduleID
       : (id: string) => {
-          if (moduleBasePath !== "" && !id.startsWith(moduleBasePath)) {
-            id = join(moduleBasePath, id);
+          // First normalize the path to handle any leading/trailing slashes
+          let normalizedId = id.replace(/^\/+|\/+$/g, "");
+
+          // If moduleBasePath is set and id doesn't start with it, add it
+          if (
+            moduleBasePath !== "" &&
+            !normalizedId.startsWith(moduleBasePath)
+          ) {
+            normalizedId = join(moduleBasePath, normalizedId);
           }
-          if (!id.startsWith("/")) {
-            if (id.startsWith(moduleBase)) {
-              id = id.slice(moduleBase.length);
+
+          // Handle moduleBase in production
+          if (process.env["NODE_ENV"] === "production") {
+            if (normalizedId.startsWith(moduleBase)) {
+              normalizedId = normalizedId.slice(moduleBase.length);
+            } else if (normalizedId.startsWith("/" + moduleBase)) {
+              normalizedId = normalizedId.slice(moduleBase.length + 1);
             }
-            id = "/" + id;
           }
-          if (id.startsWith("/" + moduleBase)) {
-            id = id.slice(moduleBase.length + 1);
-            if (!id.startsWith("/")) {
-              id = "/" + id;
-            }
+
+          // Ensure the path starts with a slash
+          if (!normalizedId.startsWith("/")) {
+            normalizedId = "/" + normalizedId;
           }
-          return id;
+
+          return normalizedId;
         };
 
   const rscOutputPath =
@@ -377,59 +425,17 @@ export const resolveOptions = <
         : assetFile,
   };
 
-  // Module path configuration
-  const moduleBase =
-    typeof options.moduleBase === "string"
-      ? options.moduleBase
-      : DEFAULT_CONFIG.MODULE_BASE;
-
-  const moduleBasePath =
-    typeof options.moduleBasePath === "string"
-      ? options.moduleBasePath
-      : process.env.VITE_BASE_URL ?? DEFAULT_CONFIG.MODULE_BASE_PATH;
-
-  const moduleBaseURL =
-    typeof options.moduleBaseURL === "string"
-      ? options.moduleBaseURL
-      : process.env.VITE_BASE_URL ?? DEFAULT_CONFIG.MODULE_BASE_URL;
-
-  const moduleRootPath =
-    typeof options.moduleRootPath === "string"
-      ? options.moduleRootPath
-      : join(projectRoot, outDir, client);
-
-  const publicOrigin =
-    typeof options.publicOrigin === "string"
-      ? options.publicOrigin
-      : process.env.VITE_PUBLIC_ORIGIN ?? DEFAULT_CONFIG.PUBLIC_ORIGIN;
-
-  // Worker and loader paths
-  const rscWorkerPath =
-    typeof options.rscWorkerPath === "string"
-      ? join(projectRoot, options.rscWorkerPath)
-      : join(pluginRoot, DEFAULT_CONFIG.RSC_WORKER_PATH);
-
-  const htmlWorkerPath =
-    typeof options.htmlWorkerPath === "string"
-      ? join(projectRoot, options.htmlWorkerPath)
-      : join(pluginRoot, DEFAULT_CONFIG.HTML_WORKER_PATH);
-
-  const loaderPath =
-    typeof options.loaderPath === "string"
-      ? join(projectRoot, options.loaderPath)
-      : join(pluginRoot, DEFAULT_CONFIG.LOADER_PATH);
-  // these will never be cleaned up, because, we are resolving the user options
-  // and it's assumed they are relevant until the process stops
-  if (process.env.VITE_BASE_URL !== moduleBaseURL) {
-    process.env.VITE_BASE_URL = moduleBaseURL;
-  }
-  if (process.env.VITE_PUBLIC_ORIGIN !== publicOrigin) {
-    process.env.VITE_PUBLIC_ORIGIN = publicOrigin;
-  }
   // Auto-discovery configuration
   const autoDiscover = {
     moduleExtension:
-      options.autoDiscover?.moduleExtension ?? DEFAULT_CONFIG.MODULE_EXTENSION,
+      options.autoDiscover?.moduleExtension ??
+      DEFAULT_CONFIG.AUTO_DISCOVER.moduleExtension,
+    serverDirective:
+      options.autoDiscover?.serverDirective ??
+      DEFAULT_CONFIG.AUTO_DISCOVER.serverDirective,
+    clientDirective:
+      options.autoDiscover?.clientDirective ??
+      DEFAULT_CONFIG.AUTO_DISCOVER.clientDirective,
     modulePattern: testModulePattern,
     cssPattern: testCss,
     jsonPattern: testJson,
@@ -444,17 +450,9 @@ export const resolveOptions = <
     virtualPattern: testVirtual,
     htmlPattern: testHtml,
     rscPattern: testRsc,
+    isServerFunction: isServerFunction,
+    isClientComponent: isClientComponent,
   };
-
-  const normalizer =
-    options.normalizer ??
-    createInputNormalizer({
-      root: projectRoot,
-      preserveModulesRoot:
-        preserveModulesRoot === true ? moduleBase : undefined,
-      removeExtension: true,
-      moduleBasePath,
-    });
   const pipeableStreamOptions = options.pipeableStreamOptions
     ? options.pipeableStreamOptions
     : {};
@@ -486,7 +484,6 @@ export const resolveOptions = <
           inlineCss: options.css?.inlineCss ?? DEFAULT_CONFIG.CSS.inlineCss,
           inlineThreshold:
             options.css?.inlineThreshold ?? DEFAULT_CONFIG.CSS.inlineThreshold,
-          purgeCss: options.css?.purgeCss ?? DEFAULT_CONFIG.CSS.purgeCss,
           inlinePatterns:
             options.css?.inlinePatterns ?? DEFAULT_CONFIG.CSS.inlinePatterns,
           linkPatterns:
@@ -497,10 +494,10 @@ export const resolveOptions = <
         loaderPath: loaderPath,
         clientEntry: options.clientEntry ?? DEFAULT_CONFIG.CLIENT_ENTRY,
         serverEntry: options.serverEntry ?? DEFAULT_CONFIG.SERVER_ENTRY,
-        moduleBaseExceptions: options.moduleBaseExceptions ?? [],
+        //   moduleBaseExceptions: options.moduleBaseExceptions ?? [],
         autoDiscover: autoDiscover,
         pipeableStreamOptions,
-      } as ResolvedUserOptions<InlineCSS>,
+      } as ResolvedUserOptions<T, InlineCSS>,
     };
   } catch (error) {
     return {

package/plugin/config/resolveUserConfig.ts

@@ -3,6 +3,8 @@ import type {
   ResolvedUserConfig,
   ResolvedUserOptions,
   AutoDiscoveredFiles,
+  PagePropOpt,
+  InlineCssOpt,
 } from "../types.js";
 import { join } from "node:path";
 import type { OutputOptions, PreRenderedAsset, PreRenderedChunk } from "rollup";
@@ -10,11 +12,14 @@ import { DEFAULT_CONFIG } from "./defaults.js";
 
 let stashedUserConfig: Record<string, ResolvedUserConfig | null> = {};
 
-export type ResolveUserConfigProps = {
+export type ResolveUserConfigProps<
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
+> = {
   condition: "react-client" | "react-server";
   config: UserConfig;
   configEnv: ConfigEnv;
-  userOptions: ResolvedUserOptions;
+  userOptions: ResolvedUserOptions<T, InlineCSS>;
   autoDiscoveredFiles: Pick<AutoDiscoveredFiles, "inputs" | "staticManifest">;
 };
 
@@ -22,13 +27,16 @@ export type ResolveUserConfigReturn =
   | { type: "success"; userConfig: ResolvedUserConfig }
   | { type: "error"; error: Error };
 
-export function resolveUserConfig({
+export function resolveUserConfig<
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
+>({
   condition,
   config,
   configEnv,
   userOptions,
   autoDiscoveredFiles,
-}: ResolveUserConfigProps): ResolveUserConfigReturn {
+}: ResolveUserConfigProps<T, InlineCSS>): ResolveUserConfigReturn {
   const ssr =
     typeof config.build?.ssr === "boolean"
       ? config.build?.ssr
@@ -62,6 +70,9 @@ export function resolveUserConfig({
     fallback: (info: T, ssr: boolean) => string,
     ssr: boolean
   ) => {
+    if ("source" in info && info.source === "") {
+      return "";
+    }
     if (!ssr || !input) {
       return fallback(info, false);
     }
@@ -234,6 +245,7 @@ export function resolveUserConfig({
       // client build options
       build: {
         ...config.build,
+        modulePreload: config.build?.modulePreload ?? false,
         emptyOutDir: config.build?.emptyOutDir ?? true,
         outDir: config.build?.outDir ?? join(userOptions.build.outDir, envDir),
         assetsDir: config.build?.assetsDir ?? userOptions.build.assetsDir,
@@ -246,7 +258,9 @@ export function resolveUserConfig({
         minify: minify,
         rollupOptions: {
           ...config.build?.rollupOptions,
-          input: autoDiscoveredFiles.inputs,
+          input: {
+            ...autoDiscoveredFiles.inputs,
+          },
           output: newOutput,
           preserveEntrySignatures:
             config.build?.rollupOptions?.preserveEntrySignatures ??
@@ -285,6 +299,7 @@ export function resolveUserConfig({
       // server build options
       build: {
         ...config.build,
+        modulePreload: config.build?.modulePreload ?? false,
         emptyOutDir: config.build?.emptyOutDir ?? true,
         outDir: config.build?.outDir ?? join(userOptions.build.outDir, envDir),
         target: config.build?.target ?? "node18",

package/plugin/error/toError.ts

@@ -1,19 +1,53 @@
+import type { Logger } from "vite";
+
 export function toError(error: unknown): {
   name: string;
   message: string;
   stack?: string;
+  cause?: unknown;
 } {
+  if(typeof error === "string") {
+    return {
+      name: "Error",
+      message: error,
+      stack: undefined,
+      cause: undefined,
+    };
+  }
   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",
+        message: "message" in error ? typeof error.message === "string" ? error.message : JSON.stringify(error.message) : "Unknown Error",
         stack: "stack" in error ? String(error.stack) : undefined,
+        cause: "cause" in error ? toError(error.cause) : error,
       }
     : {
         name: "Unknown Error",
         message: typeof error === "string" ? error : "Unknown Error",
         stack: undefined,
+        cause: error,
       };
 }
+
+export function logError(error: unknown, logger: Logger | Console = console) {
+  const err = toError(error);
+  if (process.env["NODE_ENV"] !== "production") {
+    console.trace(err)
+    
+    if (err.stack && err.stack.includes(err.message)) {
+      logger.error(err.stack);
+    } else if (err.stack) {
+      logger.error(err.message + "\n" + err.stack, {
+        error: err,
+      });
+    } else {
+      logger.error(err.message, {
+        error: err,
+      });
+    }
+  } else {
+    logger.error(err.message);
+  }
+}

package/plugin/helpers/cleanObject.ts

@@ -1,44 +1,105 @@
 import type { SerializableRecord } from "../types.js";
 
 // Helper function to serialize RegExp objects
-function serializeRegExp(regex: RegExp): { source: string; flags: string; __isRegExp: boolean } {
+function serializeRegExp(regex: RegExp): {
+  source: string;
+  flags: string;
+  __isRegExp: boolean;
+} {
   return {
     source: regex.source,
     flags: regex.flags,
-    __isRegExp: true
+    __isRegExp: true,
   };
 }
 
-export function cleanObject<T>(obj: T, knownNonSerializableFunctions: Set<string> = new Set(), currentPath: string = ''): SerializableRecord & T {
-  if (obj === null || obj === undefined) return obj as Extract<SerializableRecord, T>;
-  if (typeof obj !== 'object') return obj as Extract<SerializableRecord, T>;
-  if (obj instanceof RegExp) return serializeRegExp(obj) as unknown as Extract<SerializableRecord, T>;
+const isSerializable = (
+  x: unknown
+): x is
+  | number
+  | bigint
+  | boolean
+  | string
+  | undefined
+  | null
+  | Uint8Array
+  | Uint16Array
+  | Uint32Array
+  | Int8Array
+  | Int16Array
+  | Int32Array => {
+  return (
+    typeof x === "number" ||
+    typeof x === "bigint" ||
+    typeof x === "boolean" ||
+    typeof x === "string" ||
+    x instanceof Buffer ||
+    (Array.isArray(x) &&
+      (!x.length ||
+        x instanceof Uint8Array ||
+        x instanceof Uint16Array ||
+        x instanceof Uint32Array ||
+        x instanceof Int8Array ||
+        x instanceof Int16Array ||
+        x instanceof Int32Array))
+  );
+};
+
+export function cleanObject<T>(
+  obj: T,
+  knownNonSerializableFunctions: Set<string> = new Set(),
+  currentPath: string = ""
+): SerializableRecord & T {
+  if (typeof obj !== "object" || obj == null) return obj as Extract<SerializableRecord, T>;
+  if (isSerializable(obj)) return obj as Extract<SerializableRecord, T>;
+
   if (Array.isArray(obj)) {
-    return obj.map((x, i) => cleanObject(x, knownNonSerializableFunctions, `${currentPath}[${i}]`)).filter(x => x !== undefined) as Extract<SerializableRecord, T>;
+    return obj
+      .map((x, i) =>
+        cleanObject(x, knownNonSerializableFunctions, `${currentPath}[${i}]`)
+      )
+      .filter((x) => x !== undefined) as Extract<SerializableRecord, T>;
   }
-  
+  if (obj instanceof RegExp)
+    return serializeRegExp(obj) as unknown as Extract<SerializableRecord, T>;
+
   const result: Record<string, any> = {};
   for (const [key, value] of Object.entries(obj)) {
     const fullPath = currentPath ? `${currentPath}.${key}` : key;
-    const normalizedPath = fullPath.replace(/\[\d+\]/g, '[]');
+    const normalizedPath = fullPath.replace(/\[\d+\]/g, "[]");
     // Skip if it's a function or known non-serializable property
-    if (typeof value === 'function' || knownNonSerializableFunctions.has(normalizedPath) || knownNonSerializableFunctions.has(key)) {
+    if(isSerializable(value)) {
+      result[key] = value;
+      continue;
+    }
+    if (
+      typeof value === "function" ||
+      knownNonSerializableFunctions.has(normalizedPath) ||
+      knownNonSerializableFunctions.has(key)
+    ) {
       continue;
     }
 
     // Handle nested objects
-    if (typeof value === 'object' && value !== null) {
+    if (typeof value === "object" && value !== null) {
       // Check if the object has any functions
       const hasFunctions = Object.entries(value).some(([k, v]) => {
         const nestedPath = `${normalizedPath}.${k}`;
-        return typeof v === 'function' || knownNonSerializableFunctions.has(nestedPath);
+        return (
+          typeof v === "function" ||
+          knownNonSerializableFunctions.has(nestedPath)
+        );
       });
 
       if (hasFunctions) {
         continue;
       }
 
-      const cleaned = cleanObject(value, knownNonSerializableFunctions, `${normalizedPath}.${key}`);
+      const cleaned = cleanObject(
+        value,
+        knownNonSerializableFunctions,
+        `${normalizedPath}.${key}`
+      );
       if (cleaned !== undefined && Object.keys(cleaned).length > 0) {
         result[key] = cleaned;
       }
@@ -46,5 +107,8 @@ export function cleanObject<T>(obj: T, knownNonSerializableFunctions: Set<string
       result[key] = value;
     }
   }
-  return (Object.keys(result).length > 0 ? result : {}) as Extract<SerializableRecord, T>;
-}
+  return (Object.keys(result).length > 0 ? result : {}) as Extract<
+    SerializableRecord,
+    T
+  >;
+}