@esmx/core 3.0.0-rc.59 → 3.0.0-rc.60

package/dist/module-config.test.mjs

@@ -1,608 +1,719 @@
 import path from "node:path";
-import { describe, expect, it, vi } from "vitest";
+import { describe, expect, it } from "vitest";
 import {
-  parseModuleConfig
+  addPackageExportsToScopes,
+  createDefaultExports,
+  getEnvironmentExports,
+  getEnvironmentImports,
+  getEnvironmentScopes,
+  getEnvironments,
+  getLinks,
+  parseModuleConfig,
+  parsedExportValue,
+  processExportArray,
+  processObjectExport,
+  processStringExport,
+  resolveExportFile
 } from "./module-config.mjs";
-describe("module-config", () => {
-  const testModuleName = "test-module";
-  const testRoot = "/test/root";
+describe("Module Config Parser", () => {
   describe("parseModuleConfig", () => {
-    it("should parse empty configuration with defaults", () => {
-      const config = {};
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.name).toBe(testModuleName);
-      expect(result.root).toBe(testRoot);
-      expect(result.imports).toEqual({});
-      expect(result.links).toHaveProperty(testModuleName);
-      expect(result.exports).toHaveProperty("src/entry.client");
-      expect(result.exports).toHaveProperty("src/entry.server");
-    });
-    it("should parse configuration without config parameter", () => {
-      const result = parseModuleConfig(testModuleName, testRoot);
-      expect(result.name).toBe(testModuleName);
-      expect(result.root).toBe(testRoot);
-      expect(result.imports).toEqual({});
-    });
-    it("should parse complete configuration", () => {
+    it("should parse basic module config with name and root", () => {
+      const result = parseModuleConfig("test-module", "/test/root");
+      expect(result.name).toBe("test-module");
+      expect(result.root).toBe("/test/root");
+      expect(result.links).toBeDefined();
+      expect(result.environments).toBeDefined();
+    });
+    it("should handle empty config object", () => {
+      const result = parseModuleConfig("test-module", "/test/root", {});
+      expect(result.name).toBe("test-module");
+      expect(result.root).toBe("/test/root");
+    });
+    it("should handle undefined config parameter", () => {
+      const result = parseModuleConfig(
+        "test-module",
+        "/test/root",
+        void 0
+      );
+      expect(result.name).toBe("test-module");
+      expect(result.root).toBe("/test/root");
+    });
+    it("should process links configuration", () => {
       const config = {
         links: {
-          "shared-lib": "../shared-lib/dist",
-          "api-utils": "/absolute/path/api-utils/dist"
-        },
-        imports: {
-          axios: "shared-lib/axios",
-          lodash: "shared-lib/lodash"
-        },
-        exports: {
-          axios: "axios",
-          "src/utils/format": "./src/utils/format.ts",
-          "custom-api": "./src/api/custom.ts"
+          "custom-link": "/custom/path"
         }
       };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.name).toBe(testModuleName);
-      expect(result.root).toBe(testRoot);
-      expect(result.imports).toEqual(config.imports);
-      expect(result.links).toHaveProperty("shared-lib");
-      expect(result.links).toHaveProperty("api-utils");
-      expect(result.exports).toHaveProperty("axios");
-      expect(result.exports).toHaveProperty("src/utils/format");
-      expect(result.exports).toHaveProperty("custom-api");
-    });
-  });
-  describe("links processing", () => {
-    it("should create self-link with default dist path", () => {
-      const config = {};
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      const selfLink = result.links[testModuleName];
-      expect(selfLink).toBeDefined();
-      expect(selfLink.name).toBe(testModuleName);
-      expect(selfLink.root).toBe(path.resolve(testRoot, "dist"));
-      expect(selfLink.client).toBe(path.resolve(testRoot, "dist/client"));
-      expect(selfLink.server).toBe(path.resolve(testRoot, "dist/server"));
-      expect(selfLink.clientManifestJson).toBe(
-        path.resolve(testRoot, "dist/client/manifest.json")
-      );
-      expect(selfLink.serverManifestJson).toBe(
-        path.resolve(testRoot, "dist/server/manifest.json")
+      const result = parseModuleConfig(
+        "test-module",
+        "/test/root",
+        config
       );
+      expect(result.links["custom-link"]).toBeDefined();
+    });
+    it("should generate client and server environments", () => {
+      const result = parseModuleConfig("test-module", "/test/root");
+      expect(result.environments.client).toBeDefined();
+      expect(result.environments.server).toBeDefined();
     });
-    it("should process relative path links", () => {
+    it("should handle absolute and relative paths in links", () => {
       const config = {
         links: {
-          "shared-lib": "../shared-lib/dist"
+          absolute: "/absolute/path",
+          relative: "relative/path"
         }
       };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      const sharedLibLink = result.links["shared-lib"];
-      expect(sharedLibLink.name).toBe("shared-lib");
-      expect(sharedLibLink.root).toBe("../shared-lib/dist");
-      expect(sharedLibLink.client).toBe(
-        path.resolve(testRoot, "../shared-lib/dist/client")
-      );
-      expect(sharedLibLink.server).toBe(
-        path.resolve(testRoot, "../shared-lib/dist/server")
+      const result = parseModuleConfig(
+        "test-module",
+        "/test/root",
+        config
       );
+      expect(result.links.absolute.root).toBe("/absolute/path");
+      expect(result.links.relative.root).toBe("relative/path");
+    });
+    it("should maintain type safety across transformations", () => {
+      const result = parseModuleConfig("test-module", "/test/root");
+      expect(typeof result.name).toBe("string");
+      expect(typeof result.root).toBe("string");
+      expect(typeof result.links).toBe("object");
+      expect(typeof result.environments).toBe("object");
     });
-    it("should process absolute path links", () => {
-      const absolutePath = "/absolute/path/api-utils/dist";
+  });
+  describe("getLinks", () => {
+    it("should create default link for module name", () => {
+      const result = getLinks("test-module", "/test/root", {});
+      expect(result["test-module"]).toBeDefined();
+      expect(result["test-module"].name).toBe("test-module");
+    });
+    it("should process custom links configuration", () => {
       const config = {
         links: {
-          "api-utils": absolutePath
+          "custom-link": "/custom/path"
         }
       };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      const apiUtilsLink = result.links["api-utils"];
-      expect(apiUtilsLink.name).toBe("api-utils");
-      expect(apiUtilsLink.root).toBe(absolutePath);
-      expect(apiUtilsLink.client).toBe(
-        path.resolve(absolutePath, "client")
-      );
-      expect(apiUtilsLink.server).toBe(
-        path.resolve(absolutePath, "server")
-      );
+      const result = getLinks("test-module", "/test/root", config);
+      expect(result["custom-link"]).toBeDefined();
+      expect(result["custom-link"].name).toBe("custom-link");
+    });
+    it("should handle empty links object", () => {
+      const result = getLinks("test-module", "/test/root", {});
+      expect(Object.keys(result)).toHaveLength(1);
+      expect(result["test-module"]).toBeDefined();
+    });
+    it("should resolve absolute paths correctly", () => {
+      const config = {
+        links: {
+          absolute: "/absolute/path"
+        }
+      };
+      const result = getLinks("test-module", "/test/root", config);
+      expect(result.absolute.root).toBe("/absolute/path");
     });
-    it("should handle multiple links", () => {
+    it("should resolve relative paths from root", () => {
       const config = {
         links: {
-          lib1: "../lib1/dist",
-          lib2: "/absolute/lib2/dist",
-          lib3: "./relative/lib3/dist"
+          relative: "relative/path"
         }
       };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(Object.keys(result.links)).toHaveLength(4);
-      expect(result.links).toHaveProperty("lib1");
-      expect(result.links).toHaveProperty("lib2");
-      expect(result.links).toHaveProperty("lib3");
-      expect(result.links).toHaveProperty(testModuleName);
+      const result = getLinks("test-module", "/test/root", config);
+      expect(result.relative.root).toBe("relative/path");
+    });
+    it("should generate client and server manifest paths", () => {
+      const result = getLinks("test-module", "/test/root", {});
+      const link = result["test-module"];
+      const expectedRoot = path.resolve("/test/root", "dist");
+      expect(link.client).toBe(path.resolve(expectedRoot, "client"));
+      expect(link.clientManifestJson).toBe(
+        path.resolve(expectedRoot, "client/manifest.json")
+      );
+      expect(link.server).toBe(path.resolve(expectedRoot, "server"));
+      expect(link.serverManifestJson).toBe(
+        path.resolve(expectedRoot, "server/manifest.json")
+      );
+    });
+    it("should handle Windows path separators", () => {
+      const result = getLinks("test-module", "C:\\test\\root", {});
+      const link = result["test-module"];
+      expect(link.client).toMatch(/[/\\]/);
+      expect(link.server).toMatch(/[/\\]/);
+    });
+    it("should handle Unix path separators", () => {
+      const result = getLinks("test-module", "/test/root", {});
+      const link = result["test-module"];
+      const expectedRoot = path.resolve("/test/root", "dist");
+      expect(link.client).toBe(path.resolve(expectedRoot, "client"));
+      expect(link.server).toBe(path.resolve(expectedRoot, "server"));
+    });
+    it("should handle paths with special characters", () => {
+      const result = getLinks("test-module", "/test/root@1.0.0", {});
+      const link = result["test-module"];
+      expect(link.root).toBe(path.resolve("/test/root@1.0.0", "dist"));
+    });
+    it("should handle paths with spaces", () => {
+      const result = getLinks(
+        "test-module",
+        "/test/root with spaces",
+        {}
+      );
+      const link = result["test-module"];
+      expect(link.root).toBe(
+        path.resolve("/test/root with spaces", "dist")
+      );
     });
   });
-  describe("exports processing", () => {
-    describe("default exports", () => {
-      it("should add default entry exports", () => {
-        const config = {};
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports["src/entry.client"]).toEqual({
-          name: "src/entry.client",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/entry.client",
-            server: false
-          }
-        });
-        expect(result.exports["src/entry.server"]).toEqual({
-          name: "src/entry.server",
-          rewrite: true,
-          entryPoints: {
-            client: false,
-            server: "./src/entry.server"
+  describe("Environment Import Functions", () => {
+    describe("getEnvironmentImports", () => {
+      it("should filter imports by environment", () => {
+        const imports = {
+          react: "react",
+          vue: {
+            client: "vue",
+            server: "vue/server"
           }
-        });
+        };
+        const clientResult = getEnvironmentImports("client", imports);
+        const serverResult = getEnvironmentImports("server", imports);
+        expect(clientResult.react).toBe("react");
+        expect(clientResult.vue).toBe("vue");
+        expect(serverResult.vue).toBe("vue/server");
       });
-    });
-    describe("array format", () => {
-      it("should process npm: prefix exports", () => {
-        const config = {
-          exports: ["npm:axios", "npm:lodash"]
+      it("should handle string import values", () => {
+        const imports = {
+          react: "react"
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports.axios).toEqual({
-          name: "axios",
-          rewrite: false,
-          entryPoints: {
-            client: "axios",
-            server: "axios"
-          }
-        });
-        expect(result.exports.lodash).toEqual({
-          name: "lodash",
-          rewrite: false,
-          entryPoints: {
-            client: "lodash",
-            server: "lodash"
+        const result = getEnvironmentImports("client", imports);
+        expect(result.react).toBe("react");
+      });
+      it("should handle object import values with matching environment", () => {
+        const imports = {
+          vue: {
+            client: "vue",
+            server: "vue/server"
           }
-        });
+        };
+        const result = getEnvironmentImports("client", imports);
+        expect(result.vue).toBe("vue");
       });
-      it("should process root: prefix exports with file extensions", () => {
-        const config = {
-          exports: [
-            "root:src/utils/format.ts",
-            "root:src/components/Button.jsx",
-            "root:src/api/client.js"
-          ]
+      it("should skip imports when environment value is undefined", () => {
+        const imports = {
+          vue: {
+            client: "vue",
+            server: "vue/server"
+          }
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports["src/utils/format"]).toEqual({
-          name: "src/utils/format",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/utils/format",
-            server: "./src/utils/format"
+        const result = getEnvironmentImports("server", imports);
+        expect(result.vue).toBe("vue/server");
+      });
+      it("should handle empty imports object", () => {
+        const result = getEnvironmentImports("client", {});
+        expect(Object.keys(result)).toHaveLength(0);
+      });
+    });
+    describe("getEnvironmentScopes", () => {
+      it("should process scoped imports per environment", () => {
+        const scopes = {
+          utils: {
+            lodash: "lodash",
+            moment: {
+              client: "moment",
+              server: "moment/server"
+            }
           }
-        });
-        expect(result.exports["src/components/Button"]).toEqual({
-          name: "src/components/Button",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/components/Button",
-            server: "./src/components/Button"
+        };
+        const result = getEnvironmentScopes("client", scopes);
+        expect(result.utils.lodash).toBe("lodash");
+        expect(result.utils.moment).toBe("moment");
+      });
+      it("should handle empty scopes object", () => {
+        const result = getEnvironmentScopes("client", {});
+        expect(Object.keys(result)).toHaveLength(0);
+      });
+    });
+    describe("getEnvironments", () => {
+      it("should combine imports, exports and scopes", () => {
+        const config = {
+          imports: {
+            react: "react"
+          },
+          scopes: {
+            utils: {
+              lodash: "lodash"
+            }
           }
-        });
-        expect(result.exports["src/api/client"]).toEqual({
-          name: "src/api/client",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/api/client",
-            server: "./src/api/client"
+        };
+        const result = getEnvironments(config, "client", "test-module");
+        expect(result.imports.react).toBe("react");
+        expect(result.scopes.utils.lodash).toBe("lodash");
+        expect(result.exports).toBeDefined();
+      });
+      it("should preserve import mapping types", () => {
+        const config = {
+          imports: {
+            react: "react"
           }
-        });
-      });
-      it("should handle all supported file extensions", () => {
-        const extensions = [
-          "js",
-          "mjs",
-          "cjs",
-          "jsx",
-          "mjsx",
-          "cjsx",
-          "ts",
-          "mts",
-          "cts",
-          "tsx",
-          "mtsx",
-          "ctsx"
-        ];
+        };
+        const result = getEnvironments(config, "client", "test-module");
+        expect(typeof result.imports).toBe("object");
+        expect(typeof result.exports).toBe("object");
+        expect(typeof result.scopes).toBe("object");
+      });
+      it("should add pkg exports to scopes with empty string key", () => {
         const config = {
-          exports: extensions.map((ext) => `root:src/test.${ext}`)
+          exports: ["pkg:lodash", "pkg:react", "./src/component"]
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        extensions.forEach((ext) => {
-          expect(result.exports["src/test"]).toBeDefined();
-        });
+        const result = getEnvironments(config, "client", "test-module");
+        const emptyScope = result.scopes[""];
+        expect(emptyScope).toBeDefined();
+        expect(emptyScope.lodash).toBe("test-module/lodash");
+        expect(emptyScope.react).toBe("test-module/react");
+        expect(emptyScope["./src/component"]).toBeUndefined();
       });
-      it("should handle object exports in array", () => {
+      it("should not override existing empty string scope", () => {
         const config = {
-          exports: [
-            "npm:axios",
-            {
-              "custom-api": "./src/api/custom.ts",
-              utils: {
-                input: "./src/utils/index.ts",
-                rewrite: true
-              }
+          exports: ["pkg:lodash"],
+          scopes: {
+            "": {
+              existing: "existing-value"
             }
-          ]
-        };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports["custom-api"]).toEqual({
-          name: "custom-api",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/api/custom.ts",
-            server: "./src/api/custom.ts"
           }
-        });
-        expect(result.exports.utils).toEqual({
-          name: "utils",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/utils/index.ts",
-            server: "./src/utils/index.ts"
+        };
+        const result = getEnvironments(config, "client", "test-module");
+        const emptyScope = result.scopes[""];
+        expect(emptyScope).toBeDefined();
+        expect(emptyScope.existing).toBe("existing-value");
+        expect(emptyScope.lodash).toBe("test-module/lodash");
+      });
+    });
+    describe("addPackageExportsToScopes", () => {
+      it("should create scopes for pkg exports", () => {
+        const exports = {
+          lodash: { name: "lodash", file: "lodash", pkg: true },
+          react: { name: "react", file: "react", pkg: true },
+          "./src/component": {
+            name: "./src/component",
+            file: "./src/component",
+            pkg: false
           }
-        });
+        };
+        const scopes = {};
+        const result = addPackageExportsToScopes(
+          exports,
+          scopes,
+          "test-module"
+        );
+        const emptyScope = result[""];
+        expect(emptyScope).toBeDefined();
+        expect(emptyScope.lodash).toBe("test-module/lodash");
+        expect(emptyScope.react).toBe("test-module/react");
+        expect(emptyScope["./src/component"]).toBeUndefined();
       });
-      it("should handle invalid export strings", () => {
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => {
-        });
-        const config = {
-          exports: ["invalid-export", "another-invalid"]
+      it("should not override existing empty string scope", () => {
+        const exports = {
+          lodash: { name: "lodash", file: "lodash", pkg: true }
+        };
+        const scopes = {
+          "": {
+            existing: "existing-value"
+          }
         };
-        parseModuleConfig(testModuleName, testRoot, config);
-        expect(consoleSpy).toHaveBeenCalledWith(
-          "Invalid module export: invalid-export"
+        const result = addPackageExportsToScopes(
+          exports,
+          scopes,
+          "test-module"
         );
-        expect(consoleSpy).toHaveBeenCalledWith(
-          "Invalid module export: another-invalid"
+        const emptyScope = result[""];
+        expect(emptyScope.existing).toBe("existing-value");
+        expect(emptyScope.lodash).toBe("test-module/lodash");
+      });
+      it("should handle empty exports", () => {
+        const exports = {};
+        const scopes = {};
+        const result = addPackageExportsToScopes(
+          exports,
+          scopes,
+          "test-module"
         );
-        consoleSpy.mockRestore();
+        expect(Object.keys(result)).toHaveLength(0);
       });
     });
-    describe("object format", () => {
-      it("should process simple string mappings", () => {
-        const config = {
-          exports: {
-            axios: "axios",
-            utils: "./src/utils/index.ts"
+  });
+  describe("Export Processing Functions", () => {
+    describe("createDefaultExports", () => {
+      it("should generate client default exports", () => {
+        const result = createDefaultExports("client");
+        expect(result["src/entry.client"].file).toBe(
+          "./src/entry.client"
+        );
+        expect(result["src/entry.server"].file).toBe("");
+      });
+      it("should generate server default exports", () => {
+        const result = createDefaultExports("server");
+        expect(result["src/entry.client"].file).toBe("");
+        expect(result["src/entry.server"].file).toBe(
+          "./src/entry.server"
+        );
+      });
+      it("should handle client environment switch case", () => {
+        const result = createDefaultExports("client");
+        expect(result["src/entry.client"].file).toBe(
+          "./src/entry.client"
+        );
+        expect(result["src/entry.server"].file).toBe("");
+      });
+      it("should handle server environment switch case", () => {
+        const result = createDefaultExports("server");
+        expect(result["src/entry.client"].file).toBe("");
+        expect(result["src/entry.server"].file).toBe(
+          "./src/entry.server"
+        );
+      });
+    });
+    describe("processStringExport", () => {
+      it("should parse simple string export", () => {
+        const result = processStringExport("./src/component");
+        expect(result["./src/component"]).toBeDefined();
+        expect(result["./src/component"].file).toBe("./src/component");
+      });
+    });
+    describe("processObjectExport", () => {
+      it("should handle environment-specific exports", () => {
+        const exportObject = {
+          "./src/component": {
+            client: "./src/component.client",
+            server: "./src/component.server"
           }
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
+        const result = processObjectExport(exportObject, "client");
+        expect(result["./src/component"].file).toBe(
+          "./src/component.client"
         );
-        expect(result.exports.axios).toEqual({
-          name: "axios",
-          rewrite: true,
-          entryPoints: {
-            client: "axios",
-            server: "axios"
-          }
-        });
-        expect(result.exports.utils).toEqual({
-          name: "utils",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/utils/index.ts",
-            server: "./src/utils/index.ts"
-          }
-        });
       });
-      it("should process complete export objects", () => {
-        const config = {
-          exports: {
-            storage: {
-              entryPoints: {
-                client: "./src/storage/indexedDB.ts",
-                server: "./src/storage/filesystem.ts"
-              },
-              rewrite: true
-            },
-            "npm-package": {
-              input: "some-package",
-              rewrite: false
-            }
+      it("should process mixed string and object exports", () => {
+        const exportObject = {
+          "./src/utils": "./src/utils",
+          "./src/component": {
+            client: "./src/component.client",
+            server: "./src/component.server"
           }
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
+        const result = processObjectExport(exportObject, "client");
+        expect(result["./src/utils"].file).toBe("./src/utils");
+        expect(result["./src/component"].file).toBe(
+          "./src/component.client"
         );
-        expect(result.exports.storage).toEqual({
-          name: "storage",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/storage/indexedDB.ts",
-            server: "./src/storage/filesystem.ts"
-          }
-        });
-        expect(result.exports["npm-package"]).toEqual({
-          name: "npm-package",
-          rewrite: false,
-          entryPoints: {
-            client: "some-package",
-            server: "some-package"
-          }
-        });
       });
-      it("should handle entryPoints with false values", () => {
-        const config = {
-          exports: {
-            "client-only": {
-              entryPoints: {
-                client: "./src/client-feature.ts",
-                server: false
-              }
-            },
-            "server-only": {
-              entryPoints: {
-                client: false,
-                server: "./src/server-feature.ts"
-              }
-            }
+      it("should handle string config values in export object", () => {
+        const exportObject = {
+          "./src/utils": "./src/utils"
+        };
+        const result = processObjectExport(exportObject, "client");
+        expect(result["./src/utils"].file).toBe("./src/utils");
+      });
+      it("should handle object config values in export object", () => {
+        const exportObject = {
+          "./src/component": {
+            client: "./src/component.client",
+            server: "./src/component.server"
           }
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
+        const result = processObjectExport(exportObject, "client");
+        expect(result["./src/component"].file).toBe(
+          "./src/component.client"
         );
-        expect(result.exports["client-only"]).toEqual({
-          name: "client-only",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/client-feature.ts",
-            server: false
-          }
-        });
-        expect(result.exports["server-only"]).toEqual({
-          name: "server-only",
-          rewrite: true,
-          entryPoints: {
-            client: false,
-            server: "./src/server-feature.ts"
-          }
-        });
+      });
+      it("should handle empty export object", () => {
+        const result = processObjectExport({}, "client");
+        expect(Object.keys(result)).toHaveLength(0);
       });
     });
-    describe("mixed configurations", () => {
-      it("should handle complex mixed export configuration", () => {
+    describe("resolveExportFile", () => {
+      it("should handle string config", () => {
+        const result = resolveExportFile(
+          "./src/component",
+          "client",
+          "component"
+        );
+        expect(result).toBe("./src/component");
+      });
+      it("should return string config directly", () => {
+        const result = resolveExportFile(
+          "./src/component",
+          "client",
+          "component"
+        );
+        expect(result).toBe("./src/component");
+      });
+      it("should resolve environment-specific paths", () => {
         const config = {
-          exports: {
-            // Simple string mapping
-            simple: "./src/simple.ts",
-            // Complete object with entryPoints
-            complex: {
-              entryPoints: {
-                client: "./src/complex.client.ts",
-                server: "./src/complex.server.ts"
-              },
-              rewrite: false
-            },
-            // Object with just input
-            "with-input": {
-              input: "./src/with-input.ts"
-            },
-            // Object with just rewrite
-            "with-rewrite": {
-              rewrite: false
-            }
-          }
+          client: "./src/component.client",
+          server: "./src/component.server"
+        };
+        const result = resolveExportFile(config, "client", "component");
+        expect(result).toBe("./src/component.client");
+      });
+      it("should return empty string when value is false", () => {
+        const config = {
+          client: false,
+          server: "./src/component.server"
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
+        const result = resolveExportFile(config, "client", "component");
+        expect(result).toBe("");
+      });
+      it("should return name when value is empty string", () => {
+        const config = {
+          client: "",
+          server: "./src/component.server"
+        };
+        const result = resolveExportFile(config, "client", "component");
+        expect(result).toBe("component");
+      });
+      it("should return environment value when it's a string", () => {
+        const config = {
+          client: "./src/component.client",
+          server: "./src/component.server"
+        };
+        const result = resolveExportFile(config, "client", "component");
+        expect(result).toBe("./src/component.client");
+      });
+      it("should return name when environment value is undefined", () => {
+        const config = {
+          client: "./src/component.client"
+        };
+        const result = resolveExportFile(config, "server", "component");
+        expect(result).toBe("component");
+      });
+      it("should handle invalid config types gracefully", () => {
+        const result = resolveExportFile(
+          {},
+          "client",
+          "component"
         );
-        expect(result.exports.simple).toEqual({
-          name: "simple",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/simple.ts",
-            server: "./src/simple.ts"
-          }
-        });
-        expect(result.exports.complex).toEqual({
-          name: "complex",
-          rewrite: false,
-          entryPoints: {
-            client: "./src/complex.client.ts",
-            server: "./src/complex.server.ts"
-          }
-        });
-        expect(result.exports["with-input"]).toEqual({
-          name: "with-input",
-          rewrite: true,
-          entryPoints: {
-            client: "./src/with-input.ts",
-            server: "./src/with-input.ts"
-          }
-        });
-        expect(result.exports["with-rewrite"]).toEqual({
-          name: "with-rewrite",
-          rewrite: false,
-          entryPoints: {
-            client: "with-rewrite",
-            server: "with-rewrite"
+        expect(result).toBe("component");
+      });
+    });
+    describe("processExportArray", () => {
+      it("should combine multiple export configurations", () => {
+        const exportArray = ["./src/component1", "./src/component2"];
+        const result = processExportArray(exportArray, "client");
+        expect(result["./src/component1"]).toBeDefined();
+        expect(result["./src/component2"]).toBeDefined();
+      });
+      it("should handle string items in export array", () => {
+        const exportArray = ["./src/component"];
+        const result = processExportArray(exportArray, "client");
+        expect(result["./src/component"]).toBeDefined();
+      });
+      it("should handle object items in export array", () => {
+        const exportArray = [
+          {
+            "./src/component": "./src/component"
           }
-        });
+        ];
+        const result = processExportArray(exportArray, "client");
+        expect(result["./src/component"]).toBeDefined();
+      });
+      it("should handle empty export array", () => {
+        const result = processExportArray([], "client");
+        expect(Object.keys(result)).toHaveLength(0);
       });
     });
-    describe("default value handling", () => {
-      it("should use default rewrite value of true", () => {
+    describe("getEnvironmentExports", () => {
+      it("should merge default and user exports", () => {
         const config = {
-          exports: {
-            "test-export": {
-              input: "./src/test.ts"
-              // rewrite not specified, should default to true
-            }
-          }
+          exports: ["./src/custom"]
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports["test-export"].rewrite).toBe(true);
+        const result = getEnvironmentExports(config, "client");
+        expect(result["src/entry.client"]).toBeDefined();
+        expect(result["./src/custom"]).toBeDefined();
+      });
+      it("should handle config without exports property", () => {
+        const result = getEnvironmentExports({}, "client");
+        expect(result["src/entry.client"]).toBeDefined();
       });
-      it("should use export name as fallback for input paths", () => {
+      it("should handle config with exports property", () => {
         const config = {
-          exports: {
-            "fallback-test": {
-              // No input or entryPoints specified
-              rewrite: false
-            }
-          }
+          exports: ["./src/custom"]
         };
-        const result = parseModuleConfig(
-          testModuleName,
-          testRoot,
-          config
-        );
-        expect(result.exports["fallback-test"].entryPoints).toEqual({
-          client: "fallback-test",
-          server: "fallback-test"
-        });
+        const result = getEnvironmentExports(config, "client");
+        expect(result["./src/custom"]).toBeDefined();
       });
     });
   });
-  describe("imports processing", () => {
-    it("should pass through imports configuration unchanged", () => {
-      const imports = {
-        axios: "shared-lib/axios",
-        lodash: "shared-lib/lodash",
-        "custom-lib": "api-utils/custom"
-      };
-      const config = { imports };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.imports).toEqual(imports);
+  describe("parsedExportValue", () => {
+    it("should handle pkg: prefixed exports", () => {
+      const result = parsedExportValue("pkg:lodash");
+      expect(result.name).toBe("lodash");
+      expect(result.pkg).toBe(true);
+      expect(result.file).toBe("lodash");
     });
-    it("should handle empty imports", () => {
-      const config = {};
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.imports).toEqual({});
+    it("should handle root: prefixed exports", () => {
+      const result = parsedExportValue("root:src/component.tsx");
+      expect(result.name).toBe("src/component");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./src/component.tsx");
     });
-    it("should handle undefined imports", () => {
-      const config = {
-        links: { test: "./test" },
-        exports: ["npm:axios"]
-        // imports intentionally omitted
-      };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.imports).toEqual({});
+    it("should process regular file exports", () => {
+      const result = parsedExportValue("./src/component");
+      expect(result.name).toBe("./src/component");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./src/component");
     });
-  });
-  describe("edge cases", () => {
-    it("should handle empty exports array", () => {
-      const config = {
-        exports: []
-      };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.exports).toHaveProperty("src/entry.client");
-      expect(result.exports).toHaveProperty("src/entry.server");
-      expect(Object.keys(result.exports)).toHaveLength(2);
+    it("should handle pkg: prefixed values correctly", () => {
+      const result = parsedExportValue("pkg:@scope/package");
+      expect(result.name).toBe("@scope/package");
+      expect(result.pkg).toBe(true);
+      expect(result.file).toBe("@scope/package");
     });
-    it("should handle empty exports object", () => {
-      const config = {
-        exports: {}
-      };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.exports).toHaveProperty("src/entry.client");
-      expect(result.exports).toHaveProperty("src/entry.server");
-      expect(Object.keys(result.exports)).toHaveLength(2);
+    it("should handle root: prefixed values with extension removal", () => {
+      const result = parsedExportValue("root:src/component.tsx");
+      expect(result.name).toBe("src/component");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./src/component.tsx");
     });
-    it("should handle null and undefined values gracefully", () => {
-      const config = {
-        links: void 0,
-        imports: void 0,
-        exports: void 0
-      };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      expect(result.links).toHaveProperty(testModuleName);
-      expect(result.imports).toEqual({});
-      expect(result.exports).toHaveProperty("src/entry.client");
-      expect(result.exports).toHaveProperty("src/entry.server");
-    });
-    it("should handle special characters in module names and paths", () => {
-      const specialModuleName = "test-module_with.special@chars";
+    it("should handle root: prefixed values without extensions", () => {
+      const result = parsedExportValue("root:src/utils");
+      expect(result.name).toBe("src/utils");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./src/utils");
+    });
+    it("should handle regular values without prefixes", () => {
+      const result = parsedExportValue("./src/component.tsx");
+      expect(result.name).toBe("./src/component.tsx");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./src/component.tsx");
+    });
+    it("should preserve file extensions for non-root exports", () => {
+      const result = parsedExportValue("./src/component.tsx");
+      expect(result.file).toBe("./src/component.tsx");
+    });
+    it("should handle malformed pkg: values", () => {
+      const result = parsedExportValue("pkg:");
+      expect(result.name).toBe("");
+      expect(result.pkg).toBe(true);
+      expect(result.file).toBe("");
+    });
+    it("should handle malformed root: values", () => {
+      const result = parsedExportValue("root:");
+      expect(result.name).toBe("");
+      expect(result.pkg).toBe(false);
+      expect(result.file).toBe("./");
+    });
+    it("should handle file extensions correctly in root: prefix", () => {
+      const result = parsedExportValue("root:src/component.tsx");
+      expect(result.name).toBe("src/component");
+      expect(result.file).toBe("./src/component.tsx");
+    });
+    it("should handle nested paths in pkg: prefix", () => {
+      const result = parsedExportValue("pkg:@scope/package/subpath");
+      expect(result.name).toBe("@scope/package/subpath");
+      expect(result.pkg).toBe(true);
+      expect(result.file).toBe("@scope/package/subpath");
+    });
+  });
+  describe("Integration Tests", () => {
+    it("should work end-to-end with complex configuration", () => {
       const config = {
         links: {
-          "special-lib@1.0.0": "../special-lib/dist"
+          shared: "/shared/modules"
         },
-        exports: {
-          "special_export-name": "./src/special.ts"
-        }
+        imports: {
+          react: "react",
+          vue: {
+            client: "vue",
+            server: "vue/server"
+          }
+        },
+        scopes: {
+          utils: {
+            lodash: "lodash"
+          }
+        },
+        exports: [
+          "./src/component",
+          {
+            "./src/utils": {
+              client: "./src/utils.client",
+              server: "./src/utils.server"
+            }
+          }
+        ]
       };
       const result = parseModuleConfig(
-        specialModuleName,
-        testRoot,
+        "test-module",
+        "/test/root",
         config
       );
-      expect(result.name).toBe(specialModuleName);
-      expect(result.links).toHaveProperty("special-lib@1.0.0");
-      expect(result.exports).toHaveProperty("special_export-name");
+      expect(result.name).toBe("test-module");
+      expect(result.links.shared).toBeDefined();
+      expect(result.environments.client.imports.react).toBe("react");
+      expect(result.environments.client.imports.vue).toBe("vue");
+      expect(result.environments.server.imports.vue).toBe("vue/server");
     });
-  });
-  describe("type safety", () => {
-    it("should maintain type safety for ParsedModuleConfig", () => {
+    it("should correctly filter environment-specific exports", () => {
       const config = {
-        links: { test: "./test" },
-        imports: { axios: "test/axios" },
-        exports: ["npm:lodash"]
+        exports: [
+          {
+            "./src/component": {
+              client: "./src/component.client",
+              server: "./src/component.server"
+            }
+          }
+        ]
       };
-      const result = parseModuleConfig(
-        testModuleName,
-        testRoot,
+      const clientResult = parseModuleConfig(
+        "test-module",
+        "/test/root",
         config
       );
-      expect(typeof result.name).toBe("string");
-      expect(typeof result.root).toBe("string");
-      expect(typeof result.links).toBe("object");
-      expect(typeof result.imports).toBe("object");
-      expect(typeof result.exports).toBe("object");
+      const serverResult = parseModuleConfig(
+        "test-module",
+        "/test/root",
+        config
+      );
+      expect(
+        clientResult.environments.client.exports["./src/component"].file
+      ).toBe("./src/component.client");
+      expect(
+        serverResult.environments.server.exports["./src/component"].file
+      ).toBe("./src/component.server");
+    });
+    it("should maintain cross-environment consistency", () => {
+      const result = parseModuleConfig("test-module", "/test/root");
+      expect(
+        result.environments.client.exports["src/entry.client"].file
+      ).toBe("./src/entry.client");
+      expect(
+        result.environments.server.exports["src/entry.server"].file
+      ).toBe("./src/entry.server");
     });
-    it("should maintain type safety for ParsedModuleConfigExport", () => {
+    it("should work with path resolution across different environments", () => {
       const config = {
-        exports: ["npm:axios"]
+        links: {
+          relative: "relative/path"
+        }
       };
-      const result = parseModuleConfig(testModuleName, testRoot, config);
-      const exportConfig = result.exports.axios;
-      expect(typeof exportConfig.name).toBe("string");
-      expect(typeof exportConfig.rewrite).toBe("boolean");
-      expect(typeof exportConfig.entryPoints).toBe("object");
-      expect(typeof exportConfig.entryPoints.client).toBe("string");
-      expect(typeof exportConfig.entryPoints.server).toBe("string");
+      const result = parseModuleConfig(
+        "test-module",
+        "/test/root",
+        config
+      );
+      expect(result.links.relative.root).toBe("relative/path");
+    });
+  });
+  describe("Error Handling", () => {
+    it("should handle invalid config types gracefully in resolveExportFile", () => {
+      const result = resolveExportFile({}, "client", "component");
+      expect(result).toBe("component");
+    });
+    it("should handle malformed pkg: values in parsedExportValue", () => {
+      const result = parsedExportValue("pkg:");
+      expect(result.name).toBe("");
+      expect(result.pkg).toBe(true);
+    });
+    it("should handle malformed root: values in parsedExportValue", () => {
+      const result = parsedExportValue("root:");
+      expect(result.name).toBe("");
+      expect(result.pkg).toBe(false);
     });
   });
 });