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

package/src/module-config.test.ts

@@ -1,798 +1,797 @@
 import path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { describe, expect, it } from 'vitest';
 import {
     type ModuleConfig,
-    type ModuleConfigExportExports,
-    type ModuleConfigExportObject,
-    type ParsedModuleConfig,
-    type ParsedModuleConfigExport,
-    parseModuleConfig
+    addPackageExportsToScopes,
+    createDefaultExports,
+    getEnvironmentExports,
+    getEnvironmentImports,
+    getEnvironmentScopes,
+    getEnvironments,
+    getLinks,
+    parseModuleConfig,
+    parsedExportValue,
+    processExportArray,
+    processObjectExport,
+    processStringExport,
+    resolveExportFile
 } from './module-config';
 
-describe('module-config', () => {
-    const testModuleName = 'test-module';
-    const testRoot = '/test/root';
-
+describe('Module Config Parser', () => {
     describe('parseModuleConfig', () => {
-        it('should parse empty configuration with defaults', () => {
-            // Arrange
-            const config: ModuleConfig = {};
+        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();
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        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');
+        });
 
-            // Assert
-            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 handle undefined config parameter', () => {
+            const result = parseModuleConfig(
+                'test-module',
+                '/test/root',
+                undefined
+            );
+            expect(result.name).toBe('test-module');
+            expect(result.root).toBe('/test/root');
         });
 
-        it('should parse configuration without config parameter', () => {
-            // Arrange & Act
-            const result = parseModuleConfig(testModuleName, testRoot);
+        it('should process links configuration', () => {
+            const config: ModuleConfig = {
+                links: {
+                    'custom-link': '/custom/path'
+                }
+            };
+            const result = parseModuleConfig(
+                'test-module',
+                '/test/root',
+                config
+            );
+            expect(result.links['custom-link']).toBeDefined();
+        });
 
-            // Assert
-            expect(result.name).toBe(testModuleName);
-            expect(result.root).toBe(testRoot);
-            expect(result.imports).toEqual({});
+        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 parse complete configuration', () => {
-            // Arrange
+        it('should handle absolute and relative paths in links', () => {
             const config: ModuleConfig = {
                 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'
+                    absolute: '/absolute/path',
+                    relative: 'relative/path'
                 }
             };
+            const result = parseModuleConfig(
+                'test-module',
+                '/test/root',
+                config
+            );
+            expect(result.links.absolute.root).toBe('/absolute/path');
+            expect(result.links.relative.root).toBe('relative/path');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
-
-            // Assert
-            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');
+        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');
         });
     });
 
-    describe('links processing', () => {
-        it('should create self-link with default dist path', () => {
-            // Arrange
-            const config: ModuleConfig = {};
-
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
-
-            // Assert
-            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')
-            );
+    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 relative path links', () => {
-            // Arrange
+        it('should process custom links configuration', () => {
             const config: ModuleConfig = {
                 links: {
-                    'shared-lib': '../shared-lib/dist'
+                    'custom-link': '/custom/path'
                 }
             };
+            const result = getLinks('test-module', '/test/root', config);
+            expect(result['custom-link']).toBeDefined();
+            expect(result['custom-link'].name).toBe('custom-link');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
-
-            // Assert
-            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')
-            );
+        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 process absolute path links', () => {
-            // Arrange
-            const absolutePath = '/absolute/path/api-utils/dist';
+        it('should resolve absolute paths correctly', () => {
             const config: ModuleConfig = {
                 links: {
-                    'api-utils': absolutePath
+                    absolute: '/absolute/path'
                 }
             };
-
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
-
-            // Assert
-            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.absolute.root).toBe('/absolute/path');
         });
 
-        it('should handle multiple links', () => {
-            // Arrange
+        it('should resolve relative paths from root', () => {
             const config: ModuleConfig = {
                 links: {
-                    lib1: '../lib1/dist',
-                    lib2: '/absolute/lib2/dist',
-                    lib3: './relative/lib3/dist'
+                    relative: 'relative/path'
                 }
             };
+            const result = getLinks('test-module', '/test/root', config);
+            expect(result.relative.root).toBe('relative/path');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        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'));
+        });
 
-            // Assert
-            expect(Object.keys(result.links)).toHaveLength(4); // 3 + self-link
-            expect(result.links).toHaveProperty('lib1');
-            expect(result.links).toHaveProperty('lib2');
-            expect(result.links).toHaveProperty('lib3');
-            expect(result.links).toHaveProperty(testModuleName);
+        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', () => {
-                // Arrange
-                const config: ModuleConfig = {};
-
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
+    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);
 
-                // Assert
-                expect(result.exports['src/entry.client']).toEqual({
-                    name: 'src/entry.client',
-                    rewrite: true,
-                    entryPoints: {
-                        client: './src/entry.client',
-                        server: false
+                expect(clientResult.react).toBe('react');
+                expect(clientResult.vue).toBe('vue');
+                expect(serverResult.vue).toBe('vue/server');
+            });
+
+            it('should handle string import values', () => {
+                const imports = {
+                    react: 'react'
+                };
+                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'
                     }
-                });
-
-                expect(result.exports['src/entry.server']).toEqual({
-                    name: 'src/entry.server',
-                    rewrite: true,
-                    entryPoints: {
-                        client: false,
-                        server: './src/entry.server'
+                };
+                const result = getEnvironmentImports('client', imports);
+                expect(result.vue).toBe('vue');
+            });
+
+            it('should skip imports when environment value is undefined', () => {
+                const imports = {
+                    vue: {
+                        client: 'vue',
+                        server: 'vue/server'
                     }
-                });
+                };
+                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('array format', () => {
-            it('should process npm: prefix exports', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    exports: ['npm:axios', 'npm:lodash']
+        describe('getEnvironmentScopes', () => {
+            it('should process scoped imports per environment', () => {
+                const scopes = {
+                    utils: {
+                        lodash: 'lodash',
+                        moment: {
+                            client: 'moment',
+                            server: 'moment/server'
+                        }
+                    }
                 };
+                const result = getEnvironmentScopes('client', scopes);
+                expect(result.utils.lodash).toBe('lodash');
+                expect(result.utils.moment).toBe('moment');
+            });
 
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
+            it('should handle empty scopes object', () => {
+                const result = getEnvironmentScopes('client', {});
+                expect(Object.keys(result)).toHaveLength(0);
+            });
+        });
 
-                // Assert
-                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'
+        describe('getEnvironments', () => {
+            it('should combine imports, exports and scopes', () => {
+                const config: ModuleConfig = {
+                    imports: {
+                        react: 'react'
+                    },
+                    scopes: {
+                        utils: {
+                            lodash: 'lodash'
+                        }
                     }
-                });
+                };
+                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 process root: prefix exports with file extensions', () => {
-                // Arrange
+            it('should preserve import mapping types', () => {
                 const config: ModuleConfig = {
-                    exports: [
-                        'root:src/utils/format.ts',
-                        'root:src/components/Button.jsx',
-                        'root:src/api/client.js'
-                    ]
+                    imports: {
+                        react: 'react'
+                    }
                 };
+                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');
+            });
 
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
-
-                // Assert
-                expect(result.exports['src/utils/format']).toEqual({
-                    name: 'src/utils/format',
-                    rewrite: true,
-                    entryPoints: {
-                        client: './src/utils/format',
-                        server: './src/utils/format'
-                    }
-                });
-
-                expect(result.exports['src/components/Button']).toEqual({
-                    name: 'src/components/Button',
-                    rewrite: true,
-                    entryPoints: {
-                        client: './src/components/Button',
-                        server: './src/components/Button'
-                    }
-                });
-
-                expect(result.exports['src/api/client']).toEqual({
-                    name: 'src/api/client',
-                    rewrite: true,
-                    entryPoints: {
-                        client: './src/api/client',
-                        server: './src/api/client'
-                    }
-                });
-            });
-
-            it('should handle all supported file extensions', () => {
-                // Arrange
-                const extensions = [
-                    'js',
-                    'mjs',
-                    'cjs',
-                    'jsx',
-                    'mjsx',
-                    'cjsx',
-                    'ts',
-                    'mts',
-                    'cts',
-                    'tsx',
-                    'mtsx',
-                    'ctsx'
-                ];
+            it('should add pkg exports to scopes with empty string key', () => {
                 const config: ModuleConfig = {
-                    exports: extensions.map((ext) => `root:src/test.${ext}`)
+                    exports: ['pkg:lodash', 'pkg:react', './src/component']
                 };
-
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
-
-                // Assert
-                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', () => {
-                // Arrange
+            it('should not override existing empty string scope', () => {
                 const config: ModuleConfig = {
-                    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 = 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');
+            });
+        });
 
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
+        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: Record<string, Record<string, string>> = {};
+                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();
+            });
 
-                // Assert
-                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'
+            it('should not override existing empty string scope', () => {
+                const exports = {
+                    lodash: { name: 'lodash', file: 'lodash', pkg: true }
+                };
+                const scopes = {
+                    '': {
+                        existing: 'existing-value'
                     }
-                });
+                };
+                const result = addPackageExportsToScopes(
+                    exports,
+                    scopes,
+                    'test-module'
+                );
+                const emptyScope = result[''];
+                expect(emptyScope.existing).toBe('existing-value');
+                expect(emptyScope.lodash).toBe('test-module/lodash');
             });
 
-            it('should handle invalid export strings', () => {
-                // Arrange
-                const consoleSpy = vi
-                    .spyOn(console, 'error')
-                    .mockImplementation(() => {});
-                const config: ModuleConfig = {
-                    exports: ['invalid-export', 'another-invalid']
-                };
+            it('should handle empty exports', () => {
+                const exports = {};
+                const scopes: Record<string, Record<string, string>> = {};
+                const result = addPackageExportsToScopes(
+                    exports,
+                    scopes,
+                    'test-module'
+                );
+                expect(Object.keys(result)).toHaveLength(0);
+            });
+        });
+    });
 
-                // Act
-                parseModuleConfig(testModuleName, testRoot, config);
+    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('');
+            });
 
-                // Assert
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    'Invalid module export: invalid-export'
+            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'
                 );
-                expect(consoleSpy).toHaveBeenCalledWith(
-                    'Invalid module export: another-invalid'
+            });
+
+            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('');
+            });
 
-                consoleSpy.mockRestore();
+            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('object format', () => {
-            it('should process simple string mappings', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    exports: {
-                        axios: 'axios',
-                        utils: './src/utils/index.ts'
+        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'
                     }
                 };
-
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
+                const result = processObjectExport(exportObject, 'client');
+                expect(result['./src/component'].file).toBe(
+                    './src/component.client'
                 );
-
-                // Assert
-                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', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    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'
                     }
                 };
-
-                // Act
-                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'
                 );
+            });
 
-                // Assert
-                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 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 entryPoints with false values', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    exports: {
-                        'client-only': {
-                            entryPoints: {
-                                client: './src/client-feature.ts',
-                                server: false
-                            }
-                        },
-                        'server-only': {
-                            entryPoints: {
-                                client: false,
-                                server: './src/server-feature.ts'
-                            }
-                        }
+            it('should handle object config values in export object', () => {
+                const exportObject = {
+                    './src/component': {
+                        client: './src/component.client',
+                        server: './src/component.server'
                     }
                 };
-
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
+                const result = processObjectExport(exportObject, 'client');
+                expect(result['./src/component'].file).toBe(
+                    './src/component.client'
                 );
+            });
 
-                // Assert
-                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', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    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
-                        }
-                    }
-                };
-
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
+        describe('resolveExportFile', () => {
+            it('should handle string config', () => {
+                const result = resolveExportFile(
+                    './src/component',
+                    'client',
+                    'component'
                 );
+                expect(result).toBe('./src/component');
+            });
 
-                // Assert
-                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'
-                    }
-                });
+            it('should return string config directly', () => {
+                const result = resolveExportFile(
+                    './src/component',
+                    'client',
+                    'component'
+                );
+                expect(result).toBe('./src/component');
             });
-        });
 
-        describe('default value handling', () => {
-            it('should use default rewrite value of true', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    exports: {
-                        'test-export': {
-                            input: './src/test.ts'
-                            // rewrite not specified, should default to true
-                        }
-                    }
+            it('should resolve environment-specific paths', () => {
+                const config = {
+                    client: './src/component.client',
+                    server: './src/component.server'
                 };
+                const result = resolveExportFile(config, 'client', 'component');
+                expect(result).toBe('./src/component.client');
+            });
 
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
+            it('should return empty string when value is false', () => {
+                const config = {
+                    client: false as const,
+                    server: './src/component.server'
+                };
+                const result = resolveExportFile(config, 'client', 'component');
+                expect(result).toBe('');
+            });
 
-                // Assert
-                expect(result.exports['test-export'].rewrite).toBe(true);
+            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 use export name as fallback for input paths', () => {
-                // Arrange
-                const config: ModuleConfig = {
-                    exports: {
-                        'fallback-test': {
-                            // No input or entryPoints specified
-                            rewrite: false
-                        }
-                    }
+            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');
+            });
 
-                // Act
-                const result = parseModuleConfig(
-                    testModuleName,
-                    testRoot,
-                    config
-                );
+            it('should return name when environment value is undefined', () => {
+                const config = {
+                    client: './src/component.client'
+                } as any;
+                const result = resolveExportFile(config, 'server', 'component');
+                expect(result).toBe('component');
+            });
 
-                // Assert
-                expect(result.exports['fallback-test'].entryPoints).toEqual({
-                    client: 'fallback-test',
-                    server: 'fallback-test'
-                });
+            it('should handle invalid config types gracefully', () => {
+                const result = resolveExportFile(
+                    {} as any,
+                    'client',
+                    'component'
+                );
+                expect(result).toBe('component');
             });
         });
-    });
 
-    describe('imports processing', () => {
-        it('should pass through imports configuration unchanged', () => {
-            // Arrange
-            const imports = {
-                axios: 'shared-lib/axios',
-                lodash: 'shared-lib/lodash',
-                'custom-lib': 'api-utils/custom'
-            };
-            const config: ModuleConfig = { imports };
+        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();
+            });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+            it('should handle string items in export array', () => {
+                const exportArray = ['./src/component'];
+                const result = processExportArray(exportArray, 'client');
+                expect(result['./src/component']).toBeDefined();
+            });
 
-            // Assert
-            expect(result.imports).toEqual(imports);
+            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);
+            });
         });
 
-        it('should handle empty imports', () => {
-            // Arrange
-            const config: ModuleConfig = {};
+        describe('getEnvironmentExports', () => {
+            it('should merge default and user exports', () => {
+                const config: ModuleConfig = {
+                    exports: ['./src/custom']
+                };
+                const result = getEnvironmentExports(config, 'client');
+                expect(result['src/entry.client']).toBeDefined();
+                expect(result['./src/custom']).toBeDefined();
+            });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+            it('should handle config without exports property', () => {
+                const result = getEnvironmentExports({}, 'client');
+                expect(result['src/entry.client']).toBeDefined();
+            });
 
-            // Assert
-            expect(result.imports).toEqual({});
+            it('should handle config with exports property', () => {
+                const config: ModuleConfig = {
+                    exports: ['./src/custom']
+                };
+                const result = getEnvironmentExports(config, 'client');
+                expect(result['./src/custom']).toBeDefined();
+            });
         });
+    });
 
-        it('should handle undefined imports', () => {
-            // Arrange
-            const config: ModuleConfig = {
-                links: { test: './test' },
-                exports: ['npm:axios']
-                // imports intentionally omitted
-            };
+    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');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        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');
+        });
 
-            // Assert
-            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', () => {
-            // Arrange
-            const config: ModuleConfig = {
-                exports: []
-            };
+        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');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        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');
+        });
 
-            // Assert
-            // Should still have default exports
-            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 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 empty exports object', () => {
-            // Arrange
-            const config: ModuleConfig = {
-                exports: {}
-            };
+        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');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        it('should preserve file extensions for non-root exports', () => {
+            const result = parsedExportValue('./src/component.tsx');
+            expect(result.file).toBe('./src/component.tsx');
+        });
 
-            // Assert
-            // Should still have default exports
-            expect(result.exports).toHaveProperty('src/entry.client');
-            expect(result.exports).toHaveProperty('src/entry.server');
-            expect(Object.keys(result.exports)).toHaveLength(2);
+        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 null and undefined values gracefully', () => {
-            // Arrange
-            const config: ModuleConfig = {
-                links: undefined,
-                imports: undefined,
-                exports: undefined
-            };
+        it('should handle malformed root: values', () => {
+            const result = parsedExportValue('root:');
+            expect(result.name).toBe('');
+            expect(result.pkg).toBe(false);
+            expect(result.file).toBe('./');
+        });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+        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');
+        });
 
-            // Assert
-            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 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');
         });
+    });
 
-        it('should handle special characters in module names and paths', () => {
-            // Arrange
-            const specialModuleName = 'test-module_with.special@chars';
+    describe('Integration Tests', () => {
+        it('should work end-to-end with complex configuration', () => {
             const config: ModuleConfig = {
                 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'
+                        }
+                    }
+                ]
             };
-
-            // Act
             const result = parseModuleConfig(
-                specialModuleName,
-                testRoot,
+                'test-module',
+                '/test/root',
                 config
             );
-
-            // Assert
-            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', () => {
-            // Arrange
+        it('should correctly filter environment-specific exports', () => {
             const config: ModuleConfig = {
-                links: { test: './test' },
-                imports: { axios: 'test/axios' },
-                exports: ['npm:lodash']
+                exports: [
+                    {
+                        './src/component': {
+                            client: './src/component.client',
+                            server: './src/component.server'
+                        }
+                    }
+                ]
             };
-
-            // Act
-            const result: ParsedModuleConfig = parseModuleConfig(
-                testModuleName,
-                testRoot,
+            const clientResult = parseModuleConfig(
+                'test-module',
+                '/test/root',
+                config
+            );
+            const serverResult = parseModuleConfig(
+                'test-module',
+                '/test/root',
                 config
             );
 
-            // Assert
-            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');
+            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', () => {
-            // Arrange
+        it('should work with path resolution across different environments', () => {
             const config: ModuleConfig = {
-                exports: ['npm:axios']
+                links: {
+                    relative: 'relative/path'
+                }
             };
+            const result = parseModuleConfig(
+                'test-module',
+                '/test/root',
+                config
+            );
+            expect(result.links.relative.root).toBe('relative/path');
+        });
+    });
 
-            // Act
-            const result = parseModuleConfig(testModuleName, testRoot, config);
+    describe('Error Handling', () => {
+        it('should handle invalid config types gracefully in resolveExportFile', () => {
+            const result = resolveExportFile({} as any, '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);
+        });
 
-            // Assert
-            const exportConfig: ParsedModuleConfigExport = 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');
+        it('should handle malformed root: values in parsedExportValue', () => {
+            const result = parsedExportValue('root:');
+            expect(result.name).toBe('');
+            expect(result.pkg).toBe(false);
         });
     });
 });