@esmx/core 3.0.0-rc.10

package/src/utils/cache.ts

@@ -0,0 +1,68 @@
+/**
+ * 缓存处理函数的类型定义
+ *
+ * @template T - 缓存数据的类型
+ * @param name - 缓存项的唯一标识符
+ * @param fetch - 获取数据的异步函数
+ * @returns 返回缓存的数据或新获取的数据
+ *
+ * @example
+ * ```ts
+ * const cache = createCache(true);
+ *
+ * // 第一次调用会执行 fetch 函数
+ * const data1 = await cache('key', async () => {
+ *   return await fetchSomeData();
+ * });
+ *
+ * // 第二次调用会直接返回缓存的结果
+ * const data2 = await cache('key', async () => {
+ *   return await fetchSomeData();
+ * });
+ * ```
+ */
+export type CacheHandle = <T>(
+    name: string,
+    fetch: () => Promise<T>
+) => Promise<T>;
+
+/**
+ * 创建一个缓存处理函数
+ *
+ * @param enable - 是否启用缓存功能
+ * @returns 返回一个缓存处理函数
+ *
+ * @description
+ * 当 enable 为 true 时，会创建一个带有内存缓存的处理函数，相同的 name 只会执行一次 fetch。
+ * 当 enable 为 false 时，每次调用都会执行 fetch 函数，不会缓存结果。
+ *
+ * @example
+ * ```ts
+ * // 创建一个启用缓存的处理函数
+ * const cacheEnabled = createCache(true);
+ *
+ * // 创建一个禁用缓存的处理函数
+ * const cacheDisabled = createCache(false);
+ *
+ * // 使用缓存处理函数
+ * const result = await cacheEnabled('userProfile', async () => {
+ *   return await fetchUserProfile(userId);
+ * });
+ * ```
+ */
+export function createCache(enable: boolean) {
+    if (enable) {
+        const map = new Map<string, any>();
+        return async <T>(name: string, fetch: () => Promise<T>): Promise<T> => {
+            if (map.has(name)) {
+                return map.get(name);
+            }
+            const result = await fetch();
+            map.set(name, result);
+            return result;
+        };
+    }
+    return <T>(name: string, fetch: () => Promise<T>): Promise<T> => {
+        return fetch();
+    };
+}

package/src/utils/import-map.ts

@@ -0,0 +1,47 @@
+import path from 'node:path';
+
+import { pathWithoutIndex } from './path-without-index';
+
+import type { ImportMap, SpecifierMap } from '@esmx/import';
+import type { RuntimeTarget } from '../esmx';
+import type { ManifestJson } from '../manifest-json';
+import type { ParsedModuleConfig } from '../module-config';
+
+/**
+ * 获取导入映射对象
+ */
+export async function getImportMap(
+    target: RuntimeTarget,
+    manifests: readonly ManifestJson[],
+    moduleConfig: ParsedModuleConfig
+): Promise<ImportMap> {
+    const imports: SpecifierMap = {};
+    if (target === 'client') {
+        for (const manifest of manifests) {
+            for (const [name, value] of Object.entries(manifest.exports)) {
+                imports[`${manifest.name}/${name}`] =
+                    `/${manifest.name}/${value}`;
+            }
+        }
+    } else {
+        for (const manifest of manifests) {
+            const link = moduleConfig.links.find(
+                (item) => item.name === manifest.name
+            );
+            if (!link) {
+                throw new Error(
+                    `'${manifest.name}' service did not find module config`
+                );
+            }
+            for (const [name, value] of Object.entries(manifest.exports)) {
+                imports[`${manifest.name}/${name}`] = path.resolve(
+                    link.root,
+                    'server',
+                    value
+                );
+            }
+        }
+    }
+    pathWithoutIndex(imports);
+    return { imports };
+}

package/src/utils/middleware.ts

@@ -0,0 +1,118 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import path from 'node:path';
+import send from 'send';
+import type { Esmx } from '../esmx';
+
+/**
+ * 中间件函数类型定义
+ *
+ * @description
+ * 中间件是一个函数，用于处理 HTTP 请求。它接收请求对象、响应对象和下一个中间件函数作为参数。
+ * 中间件可以执行以下操作：
+ * - 修改请求和响应对象
+ * - 结束请求-响应循环
+ * - 调用下一个中间件
+ *
+ * @example
+ * ```ts
+ * // 创建一个简单的日志中间件
+ * const loggerMiddleware: Middleware = (req, res, next) => {
+ *   console.log(`${req.method} ${req.url}`);
+ *   next();
+ * };
+ * ```
+ */
+export type Middleware = (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: Function
+) => void;
+
+const reFinal = /\.final\.[a-zA-Z0-9]+$/;
+/**
+ * 判断文件路径是否是一个符合 esmx 规范的不可变文件
+ * @param path 文件路径
+ */
+export function isImmutableFile(filename: string) {
+    return reFinal.test(filename);
+}
+
+/**
+ * 创建 Esmx 应用的中间件
+ *
+ * @param esmx - Esmx 实例
+ * @returns 返回一个处理静态资源的中间件
+ *
+ * @description
+ * 该函数创建一个中间件，用于处理模块的静态资源请求。它会：
+ * - 根据模块配置创建对应的静态资源中间件
+ * - 处理资源的缓存控制
+ * - 支持不可变文件的长期缓存
+ *
+ * @example
+ * ```ts
+ * import { Esmx, createMiddleware } from '@esmx/core';
+ *
+ * const esmx = new Esmx();
+ * const middleware = createMiddleware(esmx);
+ *
+ * // 在 HTTP 服务器中使用
+ * server.use(middleware);
+ * ```
+ */
+export function createMiddleware(esmx: Esmx): Middleware {
+    const middlewares = esmx.moduleConfig.links.map((item): Middleware => {
+        const base = `/${item.name}/`;
+        const baseUrl = new URL(`file:`);
+        const root = path.resolve(item.root, 'client');
+        // const reFinal = /\.final\.[a-zA-Z0-9]+$/;
+        return (req, res, next) => {
+            const url = req.url ?? '/';
+            const { pathname } = new URL(req.url ?? '/', baseUrl);
+
+            if (!url.startsWith(base) || req.method !== 'GET') {
+                next();
+                return;
+            }
+
+            send(req, pathname.substring(base.length - 1), {
+                root
+            })
+                .on('headers', () => {
+                    if (isImmutableFile(pathname)) {
+                        res.setHeader(
+                            'cache-control',
+                            'public, max-age=31536000, immutable'
+                        );
+                    } else {
+                        res.setHeader('cache-control', 'no-cache');
+                    }
+                })
+                .pipe(res);
+        };
+    });
+    return mergeMiddlewares(middlewares);
+}
+
+/**
+ * 将多个中间件，合并成一个中间件执行
+ * @param middlewares 中间件列表
+ * @returns
+ */
+export function mergeMiddlewares(middlewares: Middleware[]): Middleware {
+    return (req, res, next) => {
+        let index = 0;
+        function dispatch() {
+            if (index < middlewares.length) {
+                middlewares[index](req, res, () => {
+                    index++;
+                    dispatch();
+                });
+                return;
+            } else {
+                next();
+            }
+        }
+        dispatch();
+    };
+}

package/src/utils/path-without-index.ts

@@ -0,0 +1,9 @@
+export function pathWithoutIndex(i: Record<string, string>) {
+    const s = '/index';
+    Object.entries(i).forEach(([k, v]) => {
+        if (k.endsWith(s)) {
+            k = k.substring(0, k.length - s.length);
+            i[k] = v;
+        }
+    });
+}

package/src/utils/resolve-path.ts

@@ -0,0 +1,33 @@
+import path from 'node:path';
+
+export type ProjectPath =
+    | './'
+    | 'dist'
+    | 'dist/index.js'
+    | 'dist/package.json'
+    | 'dist/client'
+    | 'dist/client/manifest.json'
+    | 'dist/client/css'
+    | 'dist/client/images'
+    | 'dist/client/media'
+    | 'dist/client/fonts'
+    | 'dist/client/workers'
+    | 'dist/client/importmap'
+    | 'dist/client/versions/latest.tgz'
+    | 'dist/server'
+    | 'dist/server/manifest.json'
+    | 'dist/node'
+    | 'dist/node/src/entry.node.js'
+    | 'src'
+    | 'src/entry.node.ts'
+    | 'src/entry.client.ts'
+    | 'src/entry.server.ts'
+    | 'package.json';
+
+export function resolvePath(
+    root: string,
+    projectPath: ProjectPath,
+    ...args: string[]
+): string {
+    return path.resolve(root, projectPath, ...args);
+}

package/src/utils/static-import-lexer.ts

@@ -0,0 +1,85 @@
+import type fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+
+import * as esmLexer from 'es-module-lexer';
+
+/**
+ * 从 JS 代码中获取静态 import 的模块名列表。也许不能并发多个调用，没实验过。
+ * @param code js 代码
+ * @returns `Promise<string[]>` 静态 import 的模块名列表
+ */
+export async function getImportsFromJsCode(code: string) {
+    await esmLexer.init;
+    const [imports] = esmLexer.parse(code);
+    // 静态导入 && 拥有模块名
+    return imports
+        .filter((item) => item.t === 1 && item.n)
+        .map((item) => item.n as string);
+}
+
+/**
+ * 从 JS 文件中获取静态 import 的模块名列表。
+ * @param filepath js 文件路径
+ * @returns `Promise<string[]>` 静态 import 的模块名列表
+ */
+export async function getImportsFromJsFile(
+    filepath: fs.PathLike | fs.promises.FileHandle
+) {
+    const source = await fsp.readFile(filepath, 'utf-8');
+    return getImportsFromJsCode(source);
+}
+
+import type { ImportMap, SpecifierMap } from '@esmx/import';
+import type { ParsedModuleConfig } from '../module-config';
+
+export type ImportPreloadInfo = SpecifierMap;
+/**
+ * 获取导入的预加载信息。
+ * @param specifier 模块名
+ * @param importMap 导入映射对象
+ * @param moduleConfig 模块配置
+ * @returns
+ *   - `Promise<{ [specifier: string]: ImportPreloadPathString }>` 模块名和文件路径的映射对象
+ *   - `null` specifier 不存在
+ */
+export async function getImportPreloadInfo(
+    specifier: string,
+    importMap: ImportMap,
+    moduleConfig: ParsedModuleConfig
+) {
+    const importInfo = importMap.imports;
+    if (!importInfo || !(specifier in importInfo)) {
+        return null;
+    }
+
+    const ans: ImportPreloadInfo = {};
+
+    const needHandles: string[][] = [[specifier]];
+    // 词法分析是耗时操作，因此处理的文件越少越快，换句话说就是深度越浅越快，因此这里使用广度优先搜索
+    while (needHandles.length) {
+        const needHandle: string[] = [];
+        for (const specifier of needHandles.shift()!) {
+            let filepath = importInfo[specifier];
+            const splitRes = filepath.split('/');
+            if (splitRes[0] === '') splitRes.shift();
+            const name = splitRes.shift() + '';
+            const link = moduleConfig.links.find((item) => item.name === name);
+            if (!link) {
+                continue;
+            }
+            filepath = path.join(link.root, 'client', ...splitRes);
+            const imports = await getImportsFromJsFile(filepath);
+            imports.forEach((specifier) => {
+                // 如果模块名在 importMap 中存在，且没处理过
+                if (specifier in importInfo && !ans[specifier]) {
+                    ans[specifier] = importInfo[specifier];
+                    needHandle.push(specifier);
+                }
+            });
+        }
+        needHandle.length && needHandles.push(needHandle);
+    }
+
+    return ans;
+}