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

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { type EsmxOptions, type COMMAND, type BuildEnvironment, type ImportMap, type SpecifierMap, type ScopesMap, Esmx } from './core';
-export { type ModuleConfig, type ParsedModuleConfig, parseModuleConfig } from './module-config';
-export { type PackConfig, type ParsedPackConfig, parsePackConfig } from './pack-config';
+export type { ModuleConfig, ModuleConfigImportMapping, ModuleConfigExportExports, ModuleConfigExportExport, ModuleConfigExportObject, ParsedModuleConfig, ParsedModuleConfigExports, ParsedModuleConfigExport, ParsedModuleConfigEnvironment, ParsedModuleConfigLink } from './module-config';
+export type { PackConfig, ParsedPackConfig } from './pack-config';
 export { type App, createApp } from './app';
 export { type RenderContextOptions, type ServerRenderHandle, type RenderFiles, RenderContext } from './render-context';
 export { isImmutableFile, type Middleware, createMiddleware, mergeMiddlewares } from './utils/middleware';
-export type { ManifestJson, ManifestJsonChunk, ManifestJsonChunkSizes, ManifestJsonChunks, ManifestJsonExport, ManifestJsonExports } from './manifest-json';
+export type { ManifestJson, ManifestJsonChunk, ManifestJsonChunks, ManifestJsonExport, ManifestJsonExports } from './manifest-json';

package/dist/index.mjs

@@ -1,12 +1,6 @@
 export {
   Esmx
 } from "./core.mjs";
-export {
-  parseModuleConfig
-} from "./module-config.mjs";
-export {
-  parsePackConfig
-} from "./pack-config.mjs";
 export { createApp } from "./app.mjs";
 export {
   RenderContext

package/dist/manifest-json.d.ts

@@ -9,15 +9,20 @@ export interface ManifestJson {
      * Import mappings
      */
     imports: Record<string, string>;
+    /**
+     * Scope-specific import mappings
+     * Type: Record<scope name, import mappings within that scope>
+     */
+    scopes: Record<string, Record<string, string>>;
     /**
      * Export item configuration
      * Type: Record<export path, export item information>
      */
     exports: ManifestJsonExports;
     /**
-     * Build output file list
+     * Build output files
      */
-    buildFiles: string[];
+    files: string[];
     /**
      * Compiled file information
      * Type: Record<source file, compilation information>
@@ -42,7 +47,7 @@ export interface ManifestJsonExport {
      * - true: Rewrite to '{serviceName}/{exportName}' format
      * - false: Maintain original import paths
      */
-    rewrite: boolean;
+    pkg: boolean;
     /**
      * File path corresponding to the export item
      */
@@ -67,24 +72,6 @@ export interface ManifestJsonChunk {
      * Other resource files.
      */
     resources: string[];
-    /**
-     * Build output sizes.
-     */
-    sizes: ManifestJsonChunkSizes;
-}
-export interface ManifestJsonChunkSizes {
-    /**
-     * JavaScript file size in bytes
-     */
-    js: number;
-    /**
-     * CSS file size in bytes
-     */
-    css: number;
-    /**
-     * Resource file size in bytes
-     */
-    resource: number;
 }
 /**
  * Get service manifest files

package/dist/module-config.d.ts

@@ -1,158 +1,53 @@
 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 type ModuleConfigImportMapping = Record<string, string | Record<BuildEnvironment, string>>;
+export type ModuleConfigExportExports = ModuleConfigExportExport[];
+export type ModuleConfigExportExport = string | ModuleConfigExportObject;
+export type ModuleConfigExportObject = Record<string, ModuleConfigExportObjectValue>;
+export type ModuleConfigExportObjectValue = string | Record<BuildEnvironment, string | boolean>;
 export interface ParsedModuleConfig {
-    /** Module name */
     name: string;
-    /** Module root directory path */
     root: string;
-    /**
-     * 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;
-    }>;
-    /** Import mapping configuration (passed through as-is) */
-    imports: Record<string, string>;
-    /** Processed export configuration */
-    exports: ParsedModuleConfigExports;
+    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;
-    /** Resolved input targets for different build environments */
-    entryPoints: Record<BuildEnvironment, string | false>;
-    /** Whether to rewrite import paths within this module */
-    rewrite: boolean;
+    file: string;
+    pkg: boolean;
+}
+export interface ParsedModuleConfigEnvironment {
+    imports: Record<string, string>;
+    exports: ParsedModuleConfigExports;
+    scopes: Record<string, Record<string, string>>;
+}
+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 declare function parseModuleConfig(name: string, root: string, config?: ModuleConfig): ParsedModuleConfig;
+export declare function getLinks(name: string, root: string, config: ModuleConfig): Record<string, ParsedModuleConfigLink>;
+export declare function getEnvironmentImports(environment: BuildEnvironment, imports?: ModuleConfigImportMapping): Record<string, string>;
+export declare function getEnvironmentScopes(environment: BuildEnvironment, scopes?: Record<string, ModuleConfigImportMapping>): Record<string, Record<string, string>>;
+export declare function getEnvironments(config: ModuleConfig, env: BuildEnvironment, moduleName: string): ParsedModuleConfigEnvironment;
+export declare function createDefaultExports(env: BuildEnvironment): ParsedModuleConfigExports;
+export declare function processStringExport(exportString: string): ParsedModuleConfigExports;
+export declare function processObjectExport(exportObject: ModuleConfigExportObject, env: BuildEnvironment): ParsedModuleConfigExports;
+export declare function resolveExportFile(config: ModuleConfigExportObjectValue, env: BuildEnvironment, name: string): string;
+export declare function processExportArray(exportArray: ModuleConfigExportExports, env: BuildEnvironment): ParsedModuleConfigExports;
+export declare function getEnvironmentExports(config: ModuleConfig, env: BuildEnvironment): ParsedModuleConfigExports;
+export declare function addPackageExportsToScopes(exports: ParsedModuleConfigExports, scopes: Record<string, Record<string, string>>, moduleName: string): Record<string, Record<string, string>>;
+export declare function parsedExportValue(value: string): ParsedModuleConfigExport;

package/dist/module-config.mjs

@@ -4,17 +4,13 @@ export function parseModuleConfig(name, root, config = {}) {
     name,
     root,
     links: getLinks(name, root, config),
-    imports: config.imports ?? {},
-    exports: getExports(config)
+    environments: {
+      client: getEnvironments(config, "client", name),
+      server: getEnvironments(config, "server", name)
+    }
   };
 }
-const PREFIX = {
-  /** Prefix for npm package exports */
-  npm: "npm:",
-  /** Prefix for source file exports */
-  root: "root:"
-};
-function getLinks(name, root, config) {
+export function getLinks(name, root, config) {
   const result = {};
   Object.entries({
     [name]: path.resolve(root, "dist"),
@@ -35,61 +31,153 @@ function getLinks(name, root, config) {
   });
   return result;
 }
-function getExports(config = {}) {
+export function getEnvironmentImports(environment, imports = {}) {
   const result = {};
-  const exports = {
-    "src/entry.client": {
-      entryPoints: {
-        client: "./src/entry.client",
-        server: false
-      }
-    },
-    "src/entry.server": {
-      entryPoints: {
-        client: false,
-        server: "./src/entry.server"
+  for (const [key, value] of Object.entries(imports)) {
+    if (typeof value === "string") {
+      result[key] = value;
+    } else {
+      const environmentValue = value[environment];
+      if (environmentValue !== void 0) {
+        result[key] = environmentValue;
       }
     }
+  }
+  return result;
+}
+export function getEnvironmentScopes(environment, scopes = {}) {
+  const result = {};
+  for (const [scopeName, scopeImports] of Object.entries(scopes)) {
+    result[scopeName] = getEnvironmentImports(environment, scopeImports);
+  }
+  return result;
+}
+export function getEnvironments(config, env, moduleName) {
+  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)) {
-          item = item.substring(PREFIX.npm.length);
-          exports[item] = {
-            rewrite: false,
-            input: item
-          };
-        } else if (item.startsWith(PREFIX.root)) {
-          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) {
+  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.assign(exports, item);
-      }
-    });
-  } else if (config.exports) {
-    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) {
+  const parsedValue = parsedExportValue(exportString);
+  return { [parsedValue.name]: parsedValue };
+}
+export function processObjectExport(exportObject, env) {
+  const exports = {};
+  Object.keys(exportObject).forEach((name) => {
+    const config = exportObject[name];
+    if (typeof config === "string") {
+      const parsedValue2 = parsedExportValue(config);
+      exports[name] = { ...parsedValue2, name };
+      return;
+    }
+    const filePath = resolveExportFile(config, env, name);
+    const parsedValue = parsedExportValue(filePath);
+    exports[name] = { ...parsedValue, name };
+  });
+  return exports;
+}
+export function resolveExportFile(config, env, name) {
+  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, env) {
+  const exports = {};
+  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, env) {
+  const exports = createDefaultExports(env);
+  if (config.exports) {
+    const userExports = processExportArray(config.exports, env);
+    Object.assign(exports, userExports);
+  }
+  return exports;
+}
+export function addPackageExportsToScopes(exports, scopes, moduleName) {
+  Object.entries(exports).forEach(([exportName, exportConfig]) => {
+    if (exportConfig.pkg) {
+      if (!scopes[""]) {
+        scopes[""] = {};
       }
+      scopes[""][exportName] = moduleName + "/" + exportName;
+    }
+  });
+  return scopes;
+}
+export function parsedExportValue(value) {
+  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,
+      pkg: false,
+      file: "./" + item
+    };
+  } else {
+    return {
+      name: value,
+      pkg: false,
+      file: value
     };
   }
-  return result;
 }