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

package/src/module-config.ts

@@ -1,186 +1,66 @@
 import path from 'node:path';
 import type { BuildEnvironment } from './core';
 
-/**
- * Core configuration interface for the module system.
- * Defines module linking, import mapping, and export configurations.
- */
 export interface ModuleConfig {
-    /**
-     * Module linking configuration.
-     * Key is remote module name, value is module build output directory path.
-     *
-     * @example
-     * ```typescript
-     * links: {
-     *   'shared-lib': '../shared-lib/dist',
-     *   'api-utils': '/var/www/api-utils/dist'
-     * }
-     * ```
-     */
     links?: Record<string, string>;
-
-    /**
-     * Module import mapping configuration.
-     * Key is local module identifier, value is remote module path.
-     * Mainly used for standard imports of third-party libraries.
-     *
-     * @example
-     * ```typescript
-     * imports: {
-     *   'axios': 'shared-lib/axios',
-     *   'lodash': 'shared-lib/lodash'
-     * }
-     * ```
-     */
-    imports?: Record<string, string>;
-
-    /**
-     * Module export configuration.
-     * Supports multiple configuration forms: mixed array and object.
-     *
-     * @example
-     * ```typescript
-     * // Array form
-     * exports: ['npm:axios', 'root:src/utils/format.ts']
-     *
-     * // Object form
-     * exports: {
-     *   'axios': 'axios',
-     *   'utils': './src/utils/index.ts'
-     * }
-     * ```
-     */
+    imports?: ModuleConfigImportMapping;
+    scopes?: Record<string, ModuleConfigImportMapping>;
     exports?: ModuleConfigExportExports;
 }
 
-/**
- * Union type for export configuration.
- * Supports mixed array and object forms to provide flexibility
- * for different configuration scenarios.
- */
-export type ModuleConfigExportExports =
-    | Array<string | Record<string, string | ModuleConfigExportObject>>
-    | Record<string, string | ModuleConfigExportObject>;
-
-/**
- * Configuration object for individual module exports.
- * Provides fine-grained control over module export behavior.
- */
-export type ModuleConfigExportObject = {
-    /**
-     * Input file path, relative to project root directory.
-     *
-     * @example './src/utils/format'
-     */
-    input?: string;
-
-    /**
-     * Environment-specific input file configuration.
-     * Supports client and server differentiated builds.
-     * Set to `false` to disable builds for specific environments.
-     *
-     * @example
-     * ```typescript
-     * entryPoints: {
-     *   client: './src/storage/indexedDB.ts',
-     *   server: './src/storage/filesystem.ts'
-     * }
-     * ```
-     */
-    entryPoints?: Record<BuildEnvironment, string | false>;
-
-    /**
-     * Whether to rewrite import paths within modules.
-     *
-     * @default true
-     * @remarks Only needs to be false when exporting npm packages
-     */
-    rewrite?: boolean;
-};
-
-/**
- * Parsed and normalized module configuration.
- * Contains resolved paths and processed configuration data.
- */
-export interface ParsedModuleConfig {
-    /** Module name */
-    name: string;
+export type ModuleConfigImportMapping = Record<
+    string,
+    string | Record<BuildEnvironment, string>
+>;
 
-    /** Module root directory path */
-    root: string;
+export type ModuleConfigExportExports = ModuleConfigExportExport[];
 
-    /**
-     * Resolved link information for connected modules.
-     * Contains absolute paths to client/server directories and manifest files.
-     */
-    links: Record<
-        string,
-        {
-            /** Module name */
-            name: string;
-            /** Original root path (relative or absolute) */
-            root: string;
-            /** Absolute path to client build directory */
-            client: string;
-            /** Absolute path to client manifest.json */
-            clientManifestJson: string;
-            /** Absolute path to server build directory */
-            server: string;
-            /** Absolute path to server manifest.json */
-            serverManifestJson: string;
-        }
-    >;
+export type ModuleConfigExportExport = string | ModuleConfigExportObject;
 
-    /** Import mapping configuration (passed through as-is) */
-    imports: Record<string, string>;
+export type ModuleConfigExportObject = Record<
+    string,
+    ModuleConfigExportObjectValue
+>;
+export type ModuleConfigExportObjectValue =
+    | string
+    | Record<BuildEnvironment, string | boolean>;
 
-    /** Processed export configuration */
-    exports: ParsedModuleConfigExports;
+export interface ParsedModuleConfig {
+    name: string;
+    root: string;
+    links: Record<string, ParsedModuleConfigLink>;
+    environments: {
+        client: ParsedModuleConfigEnvironment;
+        server: ParsedModuleConfigEnvironment;
+    };
 }
 
-/**
- * Processed export configuration mapping.
- * Maps export names to their resolved configuration objects.
- */
 export type ParsedModuleConfigExports = Record<
     string,
     ParsedModuleConfigExport
 >;
 
-/**
- * Processed export configuration for a single module.
- * Contains resolved input targets and processing flags.
- */
 export interface ParsedModuleConfigExport {
-    /** Export name/identifier */
     name: string;
+    file: string;
+    pkg: boolean;
+}
 
-    /** Resolved input targets for different build environments */
-    entryPoints: Record<BuildEnvironment, string | false>;
+export interface ParsedModuleConfigEnvironment {
+    imports: Record<string, string>;
+    exports: ParsedModuleConfigExports;
+    scopes: Record<string, Record<string, string>>;
+}
 
-    /** Whether to rewrite import paths within this module */
-    rewrite: boolean;
+export interface ParsedModuleConfigLink {
+    name: string;
+    root: string;
+    client: string;
+    clientManifestJson: string;
+    server: string;
+    serverManifestJson: string;
 }
 
-/**
- * Parse and normalize module configuration.
- * Resolves paths, processes exports, and creates a standardized configuration object.
- *
- * @param name - Module name
- * @param root - Module root directory path
- * @param config - Raw module configuration (optional)
- * @returns Parsed and normalized module configuration
- *
- * @example
- * ```typescript
- * const parsed = parseModuleConfig('my-app', '/path/to/app', {
- *   links: { 'shared-lib': '../shared-lib/dist' },
- *   imports: { 'axios': 'shared-lib/axios' },
- *   exports: ['npm:axios', 'root:src/utils/format.ts']
- * });
- * ```
- */
 export function parseModuleConfig(
     name: string,
     root: string,
@@ -190,36 +70,19 @@ export function parseModuleConfig(
         name,
         root,
         links: getLinks(name, root, config),
-        imports: config.imports ?? {},
-        exports: getExports(config)
+        environments: {
+            client: getEnvironments(config, 'client', name),
+            server: getEnvironments(config, 'server', name)
+        }
     };
 }
 
-/**
- * Prefix constants for export configuration syntactic sugar.
- * Used to identify and process npm: and root: prefixes in export strings.
- */
-const PREFIX = {
-    /** Prefix for npm package exports */
-    npm: 'npm:',
-    /** Prefix for source file exports */
-    root: 'root:'
-} as const;
-
-/**
- * Process and resolve module linking configuration.
- * Creates absolute paths for client/server directories and manifest files.
- * Automatically includes the current module as a self-link.
- *
- * @param name - Module name
- * @param root - Module root directory path
- * @param config - Module configuration
- * @returns Resolved links configuration with absolute paths
- *
- * @internal
- */
-function getLinks(name: string, root: string, config: ModuleConfig) {
-    const result: ParsedModuleConfig['links'] = {};
+export function getLinks(
+    name: string,
+    root: string,
+    config: ModuleConfig
+): Record<string, ParsedModuleConfigLink> {
+    const result: Record<string, ParsedModuleConfigLink> = {};
     Object.entries({
         [name]: path.resolve(root, 'dist'),
         ...config.links
@@ -242,86 +105,208 @@ function getLinks(name: string, root: string, config: ModuleConfig) {
     return result;
 }
 
-/**
- * Process and normalize module exports configuration.
- * Handles different export formats (array, object, object array) and
- * processes prefix syntactic sugar (npm:, root:).
- * Automatically adds default entry exports for client and server.
- *
- * @param config - Module configuration (optional)
- * @returns Processed exports configuration
- *
- * @internal
- */
-function getExports(config: ModuleConfig = {}) {
-    const result: ParsedModuleConfig['exports'] = {};
-
-    const exports: Record<string, ModuleConfigExportObject | string> = {
-        'src/entry.client': {
-            entryPoints: {
-                client: './src/entry.client',
-                server: false
-            }
-        },
-        'src/entry.server': {
-            entryPoints: {
-                client: false,
-                server: './src/entry.server'
+export function getEnvironmentImports(
+    environment: BuildEnvironment,
+    imports: ModuleConfigImportMapping = {}
+): Record<string, string> {
+    const result: Record<string, string> = {};
+
+    for (const [key, value] of Object.entries(imports)) {
+        if (typeof value === 'string') {
+            result[key] = value;
+        } else {
+            const environmentValue = value[environment];
+            if (environmentValue !== undefined) {
+                result[key] = environmentValue;
             }
         }
+    }
+
+    return result;
+}
+
+export function getEnvironmentScopes(
+    environment: BuildEnvironment,
+    scopes: Record<string, ModuleConfigImportMapping> = {}
+): Record<string, Record<string, string>> {
+    const result: Record<string, Record<string, string>> = {};
+
+    for (const [scopeName, scopeImports] of Object.entries(scopes)) {
+        result[scopeName] = getEnvironmentImports(environment, scopeImports);
+    }
+
+    return result;
+}
+
+export function getEnvironments(
+    config: ModuleConfig,
+    env: BuildEnvironment,
+    moduleName: string
+): ParsedModuleConfigEnvironment {
+    const imports = getEnvironmentImports(env, config.imports);
+    const exports = getEnvironmentExports(config, env);
+    const scopes = getEnvironmentScopes(env, config.scopes);
+    addPackageExportsToScopes(exports, scopes, moduleName);
+    return {
+        imports,
+        exports,
+        scopes
     };
+}
 
-    if (Array.isArray(config.exports)) {
-        const FILE_EXT_REGEX =
-            /\.(js|mjs|cjs|jsx|mjsx|cjsx|ts|mts|cts|tsx|mtsx|ctsx)$/i;
-
-        config.exports.forEach((item) => {
-            if (typeof item === 'string') {
-                if (item.startsWith(PREFIX.npm)) {
-                    // npm: prefix - export npm package, maintain original import paths
-                    item = item.substring(PREFIX.npm.length);
-                    exports[item] = {
-                        rewrite: false,
-                        input: item
-                    };
-                } else if (item.startsWith(PREFIX.root)) {
-                    // root: prefix - export source file, rewrite import paths
-                    item = item
-                        .substring(PREFIX.root.length)
-                        .replace(FILE_EXT_REGEX, '');
-                    exports[item] = {
-                        input: './' + item
-                    };
-                } else {
-                    console.error(`Invalid module export: ${item}`);
+export function createDefaultExports(
+    env: BuildEnvironment
+): ParsedModuleConfigExports {
+    switch (env) {
+        case 'client':
+            return {
+                'src/entry.client': {
+                    name: 'src/entry.client',
+                    file: './src/entry.client',
+                    pkg: false
+                },
+                'src/entry.server': {
+                    name: 'src/entry.server',
+                    file: '',
+                    pkg: false
                 }
-            } else {
-                // Object configuration - merge directly
-                Object.assign(exports, item);
-            }
-        });
-    } else if (config.exports) {
-        // Object configuration - merge directly
-        Object.assign(exports, config.exports);
+            };
+        case 'server':
+            return {
+                'src/entry.client': {
+                    name: 'src/entry.client',
+                    file: '',
+                    pkg: false
+                },
+                'src/entry.server': {
+                    name: 'src/entry.server',
+                    file: './src/entry.server',
+                    pkg: false
+                }
+            };
     }
+}
 
-    for (const [name, value] of Object.entries(exports)) {
-        const opts =
-            typeof value === 'string'
-                ? {
-                      input: value
-                  }
-                : value;
-        const client = opts.entryPoints?.client ?? opts.input ?? name;
-        const server = opts.entryPoints?.server ?? opts.input ?? name;
-        result[name] = {
-            name,
-            rewrite: opts.rewrite ?? true,
-            entryPoints: {
-                client,
-                server
+export function processStringExport(
+    exportString: string
+): ParsedModuleConfigExports {
+    const parsedValue = parsedExportValue(exportString);
+    return { [parsedValue.name]: parsedValue };
+}
+
+export function processObjectExport(
+    exportObject: ModuleConfigExportObject,
+    env: BuildEnvironment
+): ParsedModuleConfigExports {
+    const exports: ParsedModuleConfigExports = {};
+
+    Object.keys(exportObject).forEach((name) => {
+        const config = exportObject[name];
+        if (typeof config === 'string') {
+            const parsedValue = parsedExportValue(config);
+            exports[name] = { ...parsedValue, name };
+            return;
+        }
+
+        const filePath = resolveExportFile(config, env, name);
+        const parsedValue = parsedExportValue(filePath);
+        exports[name] = { ...parsedValue, name };
+    });
+
+    return exports;
+}
+
+export function resolveExportFile(
+    config: ModuleConfigExportObjectValue,
+    env: BuildEnvironment,
+    name: string
+): string {
+    if (typeof config === 'string') {
+        return config;
+    }
+    const value = config[env];
+    if (typeof value === 'boolean') {
+        return value === true ? name : '';
+    } else if (typeof value === 'string') {
+        return value || name;
+    }
+    return name;
+}
+
+export function processExportArray(
+    exportArray: ModuleConfigExportExports,
+    env: BuildEnvironment
+): ParsedModuleConfigExports {
+    const exports: ParsedModuleConfigExports = {};
+
+    exportArray.forEach((item) => {
+        if (typeof item === 'string') {
+            const itemExports = processStringExport(item);
+            Object.assign(exports, itemExports);
+        } else {
+            const itemExports = processObjectExport(item, env);
+            Object.assign(exports, itemExports);
+        }
+    });
+
+    return exports;
+}
+
+export function getEnvironmentExports(
+    config: ModuleConfig,
+    env: BuildEnvironment
+): ParsedModuleConfigExports {
+    const exports = createDefaultExports(env);
+
+    if (config.exports) {
+        const userExports = processExportArray(config.exports, env);
+        Object.assign(exports, userExports);
+    }
+
+    return exports;
+}
+
+export function addPackageExportsToScopes(
+    exports: ParsedModuleConfigExports,
+    scopes: Record<string, Record<string, string>>,
+    moduleName: string
+): Record<string, Record<string, string>> {
+    Object.entries(exports).forEach(([exportName, exportConfig]) => {
+        if (exportConfig.pkg) {
+            if (!scopes['']) {
+                scopes[''] = {};
             }
+            scopes[''][exportName] = moduleName + '/' + exportName;
+        }
+    });
+
+    return scopes;
+}
+
+export function parsedExportValue(value: string): ParsedModuleConfigExport {
+    const FILE_EXT_REGEX =
+        /\.(js|mjs|cjs|jsx|mjsx|cjsx|ts|mts|cts|tsx|mtsx|ctsx)$/i;
+
+    if (value.startsWith('pkg:')) {
+        const item = value.substring('pkg:'.length);
+        return {
+            name: item,
+            pkg: true,
+            file: item
+        };
+    } else if (value.startsWith('root:')) {
+        const item = value.substring('root:'.length);
+        const name = item.replace(FILE_EXT_REGEX, '');
+        return {
+            name: name,
+            pkg: false,
+            file: './' + item
+        };
+    } else {
+        return {
+            name: value,
+            pkg: false,
+            file: value
         };
     }
-    return result;
 }

package/src/pack-config.ts

@@ -25,8 +25,8 @@ import type { Esmx } from './core';
  *     exports: [
  *       'root:src/components/button.vue',
  *       'root:src/utils/format.ts',
- *       'npm:vue',
- *       'npm:vue-router'
+ *       'pkg:vue',
+ *       'pkg:vue-router'
  *     ]
  *   },
  *   // 打包配置