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

package/dist/utils/cache.d.ts

@@ -1,21 +1,21 @@
 /**
- * 缓存处理函数的类型定义
+ * Type definition for cache handling function
  *
- * @template T - 缓存数据的类型
- * @param name - 缓存项的唯一标识符
- * @param fetch - 获取数据的异步函数
- * @returns 返回缓存的数据或新获取的数据
+ * @template T - Type of cached data
+ * @param name - Unique identifier for the cache item
+ * @param fetch - Asynchronous function to fetch data
+ * @returns Returns cached data or newly fetched data
  *
  * @example
  * ```ts
  * const cache = createCache(true);
  *
- * // 第一次调用会执行 fetch 函数
+ * // First call will execute the fetch function
  * const data1 = await cache('key', async () => {
  *   return await fetchSomeData();
  * });
  *
- * // 第二次调用会直接返回缓存的结果
+ * // Second call will directly return the cached result
  * const data2 = await cache('key', async () => {
  *   return await fetchSomeData();
  * });
@@ -23,24 +23,24 @@
  */
 export type CacheHandle = <T>(name: string, fetch: () => Promise<T>) => Promise<T>;
 /**
- * 创建一个缓存处理函数
+ * Create a cache handling function
  *
- * @param enable - 是否启用缓存功能
- * @returns 返回一个缓存处理函数
+ * @param enable - Whether to enable caching functionality
+ * @returns Returns a cache handling function
  *
  * @description
- * 当 enable 为 true 时，会创建一个带有内存缓存的处理函数，相同的 name 只会执行一次 fetch。
- * 当 enable 为 false 时，每次调用都会执行 fetch 函数，不会缓存结果。
+ * When enable is true, it creates a processing function with memory cache, the same name will only execute fetch once.
+ * When enable is false, each call will execute the fetch function and will not cache the result.
  *
  * @example
  * ```ts
- * // 创建一个启用缓存的处理函数
+ * // Create a cache-enabled processing function
  * const cacheEnabled = createCache(true);
  *
- * // 创建一个禁用缓存的处理函数
+ * // Create a cache-disabled processing function
  * const cacheDisabled = createCache(false);
  *
- * // 使用缓存处理函数
+ * // Use the cache processing function
  * const result = await cacheEnabled('userProfile', async () => {
  *   return await fetchUserProfile(userId);
  * });

package/dist/utils/middleware.d.ts

@@ -1,18 +1,18 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Esmx } from '../core';
 /**
- * 中间件函数类型定义
+ * Middleware function type definition
  *
  * @description
- * 中间件是一个函数，用于处理 HTTP 请求。它接收请求对象、响应对象和下一个中间件函数作为参数。
- * 中间件可以执行以下操作：
- * - 修改请求和响应对象
- * - 结束请求-响应循环
- * - 调用下一个中间件
+ * Middleware is a function used to handle HTTP requests. It receives the request object, response object, and the next middleware function as parameters.
+ * Middleware can perform the following operations:
+ * - Modify request and response objects
+ * - End the request-response cycle
+ * - Call the next middleware
  *
  * @example
  * ```ts
- * // 创建一个简单的日志中间件
+ * // Create a simple logging middleware
  * const loggerMiddleware: Middleware = (req, res, next) => {
  *   console.log(`${req.method} ${req.url}`);
  *   next();
@@ -21,21 +21,21 @@ import type { Esmx } from '../core';
  */
 export type Middleware = (req: IncomingMessage, res: ServerResponse, next: Function) => void;
 /**
- * 判断文件路径是否是一个符合 esmx 规范的不可变文件
- * @param path 文件路径
+ * Determine if a file path is an immutable file that complies with esmx specifications
+ * @param path File path
  */
 export declare function isImmutableFile(filename: string): boolean;
 /**
- * 创建 Esmx 应用的中间件
+ * Create middleware for Esmx application
  *
- * @param esmx - Esmx 实例
- * @returns 返回一个处理静态资源的中间件
+ * @param esmx - Esmx instance
+ * @returns Returns a middleware that handles static resources
  *
  * @description
- * 该函数创建一个中间件，用于处理模块的静态资源请求。它会：
- * - 根据模块配置创建对应的静态资源中间件
- * - 处理资源的缓存控制
- * - 支持不可变文件的长期缓存
+ * This function creates a middleware to handle static resource requests for modules. It will:
+ * - Create corresponding static resource middleware based on module configuration
+ * - Handle cache control for resources
+ * - Support long-term caching for immutable files
  *
  * @example
  * ```ts
@@ -44,14 +44,14 @@ export declare function isImmutableFile(filename: string): boolean;
  * const esmx = new Esmx();
  * const middleware = createMiddleware(esmx);
  *
- * // 在 HTTP 服务器中使用
+ * // Use in HTTP server
  * server.use(middleware);
  * ```
  */
 export declare function createMiddleware(esmx: Esmx): Middleware;
 /**
- * 将多个中间件，合并成一个中间件执行
- * @param middlewares 中间件列表
+ * Merge multiple middlewares into one middleware execution
+ * @param middlewares List of middlewares
  * @returns
  */
 export declare function mergeMiddlewares(middlewares: Middleware[]): Middleware;

package/dist/utils/static-import-lexer.d.ts

@@ -2,26 +2,26 @@ import type fs from 'node:fs';
 import type { ImportMap, SpecifierMap } from '@esmx/import';
 import type { ParsedModuleConfig } from '../module-config';
 /**
- * 从 JS 代码中获取静态 import 的模块名列表。也许不能并发多个调用，没实验过。
- * @param code js 代码
- * @returns `Promise<string[]>` 静态 import 的模块名列表
+ * Get the list of statically imported module names from JS code. Maybe cannot handle multiple concurrent calls, not tested.
+ * @param code JS code
+ * @returns `Promise<string[]>` List of statically imported module names
  */
 export declare function getImportsFromJsCode(code: string): Promise<string[]>;
 /**
- * 从 JS 文件中获取静态 import 的模块名列表。
- * @param filepath js 文件路径
- * @returns `Promise<string[]>` 静态 import 的模块名列表
+ * Get the list of statically imported module names from a JS file.
+ * @param filepath JS file path
+ * @returns `Promise<string[]>` List of statically imported module names
  */
 export declare function getImportsFromJsFile(filepath: fs.PathLike | fs.promises.FileHandle): Promise<string[]>;
 export type ImportPreloadInfo = SpecifierMap;
 /**
- * 获取导入的预加载信息。
- * @param specifier 模块名
- * @param importMap 导入映射对象
- * @param moduleConfig 模块配置
+ * Get import preload information.
+ * @param specifier Module name
+ * @param importMap Import map object
+ * @param moduleConfig Module configuration
  * @returns
- *   - `Promise<{ [specifier: string]: ImportPreloadPathString }>` 模块名和文件路径的映射对象
- *   - `null` specifier 不存在
+ *   - `Promise<{ [specifier: string]: ImportPreloadPathString }>` Mapping object of module names to file paths
+ *   - `null` specifier does not exist
  */
 export declare function getImportPreloadInfo(specifier: string, importMap: ImportMap, moduleConfig: ParsedModuleConfig): Promise<{
     [k: string]: string;

package/dist/utils/static-import-lexer.mjs

@@ -16,7 +16,7 @@ export async function getImportPreloadInfo(specifier, importMap, moduleConfig) {
     return null;
   }
   const ans = {
-    // 入口文件也放入预加载列表
+    // Entry file is also added to the preload list
     [specifier]: importInfo[specifier]
   };
   const needHandles = [specifier];

package/package.json

@@ -59,7 +59,7 @@
         "build": "unbuild"
     },
     "dependencies": {
-        "@esmx/import": "3.0.0-rc.60",
+        "@esmx/import": "3.0.0-rc.62",
         "@types/serialize-javascript": "^5.0.4",
         "es-module-lexer": "^1.7.0",
         "find": "^0.3.0",
@@ -77,7 +77,7 @@
         "unbuild": "3.6.0",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.60",
+    "version": "3.0.0-rc.62",
     "type": "module",
     "private": false,
     "exports": {
@@ -100,5 +100,5 @@
         "template",
         "public"
     ],
-    "gitHead": "615e91c617e0a58796c591643c6a2e1d2a1f0a76"
+    "gitHead": "e5a1e811403bf1db4437dff88c3ea8bc6b576f64"
 }

package/src/app.ts

@@ -9,21 +9,21 @@ import {
 import { type Middleware, createMiddleware } from './utils/middleware';
 
 /**
- * 应用程序实例接口。
+ * Application instance interface.
  *
- * App 是 Esmx 框架的应用抽象，提供了统一的接口来管理应用的生命周期、
- * 静态资源和服务端渲染。
+ * App is the application abstraction of the Esmx framework, providing a unified interface
+ * to manage application lifecycle, static assets, and server-side rendering.
  *
  * @example
  * ```ts
  * // entry.node.ts
  * export default {
- *   // 开发环境配置
+ *   // Development environment configuration
  *   async devApp(esmx) {
  *     return import('@esmx/rspack').then((m) =>
  *       m.createRspackHtmlApp(esmx, {
  *         config(rc) {
- *           // 自定义 Rspack 配置
+ *           // Custom Rspack configuration
  *         }
  *       })
  *     );
@@ -33,17 +33,17 @@ import { type Middleware, createMiddleware } from './utils/middleware';
  */
 export interface App {
     /**
-     * 静态资源处理中间件。
+     * Static asset processing middleware.
      *
-     * 开发环境：
-     * - 处理源码的静态资源请求
-     * - 支持实时编译和热更新
-     * - 使用 no-cache 缓存策略
+     * Development environment:
+     * - Handles static asset requests from source code
+     * - Supports real-time compilation and hot reloading
+     * - Uses no-cache strategy
      *
-     * 生产环境：
-     * - 处理构建后的静态资源
-     * - 支持不可变文件的长期缓存（.final.xxx）
-     * - 优化的资源加载策略
+     * Production environment:
+     * - Handles built static assets
+     * - Supports long-term caching for immutable files (.final.xxx)
+     * - Optimized asset loading strategy
      *
      * @example
      * ```ts
@@ -53,14 +53,14 @@ export interface App {
     middleware: Middleware;
 
     /**
-     * 服务端渲染函数。
+     * Server-side rendering function.
      *
-     * 根据运行环境提供不同实现：
-     * - 生产环境（start）：加载构建后的服务端入口文件（entry.server）执行渲染
-     * - 开发环境（dev）：加载源码中的服务端入口文件执行渲染
+     * Provides different implementations based on the runtime environment:
+     * - Production environment (start): Loads the built server entry file (entry.server) to execute rendering
+     * - Development environment (dev): Loads the server entry file from source code to execute rendering
      *
-     * @param options - 渲染选项
-     * @returns 返回渲染上下文，包含渲染结果
+     * @param options - Rendering options
+     * @returns Returns the rendering context containing the rendering result
      *
      * @example
      * ```ts
@@ -73,30 +73,30 @@ export interface App {
     render: (options?: RenderContextOptions) => Promise<RenderContext>;
 
     /**
-     * 生产环境构建函数。
-     * 用于资源打包和优化。
+     * Production environment build function.
+     * Used for asset packaging and optimization.
      *
-     * @returns 构建成功返回 true，失败返回 false
+     * @returns Returns true for successful build, false for failed build
      */
     build?: () => Promise<boolean>;
 
     /**
-     * 资源清理函数。
-     * 用于关闭服务器、断开连接等。
+     * Resource cleanup function.
+     * Used for shutting down servers, disconnecting connections, etc.
      *
-     * @returns 清理成功返回 true，失败返回 false
+     * @returns Returns true for successful cleanup, false for failed cleanup
      */
     destroy?: () => Promise<boolean>;
 }
 
 /**
- * 创建生产环境的应用程序实例，开发环境不可用。
+ * Create an application instance for production environment, not available in development environment.
  */
 export async function createApp(esmx: Esmx, command: COMMAND): Promise<App> {
     const render =
         command === esmx.COMMAND.start
-            ? await createStartRender(esmx) // 提供实际的渲染函数
-            : createErrorRender(esmx); // 提供错误提示渲染函数
+            ? await createStartRender(esmx) // Provides actual rendering function
+            : createErrorRender(esmx); // Provides error prompt rendering function
     return {
         middleware: createMiddleware(esmx),
         render
@@ -104,16 +104,16 @@ export async function createApp(esmx: Esmx, command: COMMAND): Promise<App> {
 }
 
 /**
- * 创建生产环境渲染函数。
- * 加载构建后的服务端入口文件（entry.server）执行渲染。
+ * Create production environment rendering function.
+ * Loads the built server entry file (entry.server) to execute rendering.
  *
- * @param esmx - Esmx 实例
- * @returns 返回渲染函数
+ * @param esmx - Esmx instance
+ * @returns Returns the rendering function
  * @internal
  *
  * @example
  * ```ts
- * // 服务端入口文件 (entry.server)
+ * // Server entry file (entry.server)
  * export default async function render(rc: RenderContext) {
  *   rc.html = '<html>...</html>';
  * }