@esmx/core 3.0.0-rc.59 → 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/import-map.d.ts

@@ -1,4 +1,4 @@
-import type { ImportMap } from '@esmx/import';
+import type { ImportMap, ScopesMap, SpecifierMap } from '@esmx/import';
 export interface ImportMapManifest {
     name: string;
     imports: Record<string, string>;
@@ -6,11 +6,15 @@ export interface ImportMapManifest {
         name: string;
         file: string;
         identifier: string;
-        rewrite: boolean;
+        pkg: boolean;
     }>;
+    scopes: Record<string, Record<string, string>>;
 }
-export declare function getImportMap({ manifests, getFile, getScope }: {
+export interface GetImportMapOptions {
     manifests: readonly ImportMapManifest[];
-    getScope: (name: string) => string;
+    getScope: (name: string, scope: string) => string;
     getFile: (name: string, file: string) => string;
-}): ImportMap;
+}
+export declare function buildImportsMap(manifests: readonly ImportMapManifest[], getFile: (name: string, file: string) => string): SpecifierMap;
+export declare function buildScopesMap(imports: SpecifierMap, manifests: readonly ImportMapManifest[], getScope: (name: string, scope: string) => string): ScopesMap;
+export declare function getImportMap({ manifests, getFile, getScope }: GetImportMapOptions): ImportMap;

package/dist/utils/import-map.mjs

@@ -1,35 +1,48 @@
 import { pathWithoutIndex } from "./path-without-index.mjs";
-export function getImportMap({
-  manifests,
-  getFile,
-  getScope
-}) {
+export function buildImportsMap(manifests, getFile) {
   const imports = {};
-  const scopes = {};
-  Object.values(manifests).forEach((manifest) => {
-    const scopeImports = {};
-    Object.entries(manifest.exports).forEach(([key, exportItem]) => {
-      if (typeof exportItem === "string") {
-        throw new Error(
-          `Detected incompatible legacy manifest format in ${manifest.name}. Please upgrade your ESMX dependencies first, then rebuild and redeploy your service.`
-        );
-      }
+  manifests.forEach((manifest) => {
+    Object.entries(manifest.exports).forEach(([, exportItem]) => {
       const file = getFile(manifest.name, exportItem.file);
       imports[exportItem.identifier] = file;
-      if (!exportItem.rewrite) {
-        scopeImports[exportItem.name] = file;
-      }
     });
-    if (Object.keys(scopeImports).length || Object.keys(imports).length) {
-      scopes[getScope(manifest.name)] = scopeImports;
-    }
   });
-  pathWithoutIndex(imports);
-  Object.values(manifests).forEach((manifest) => {
+  manifests.forEach((manifest) => {
     Object.entries(manifest.imports).forEach(([name, identifier]) => {
-      scopes[getScope(manifest.name)][name] = imports[identifier] ?? identifier;
+      const fullName = `${manifest.name}/${name}`;
+      imports[fullName] = imports[identifier] ?? identifier;
+    });
+  });
+  pathWithoutIndex(imports);
+  return imports;
+}
+export function buildScopesMap(imports, manifests, getScope) {
+  const scopes = {};
+  manifests.forEach((manifest) => {
+    if (!manifest.scopes) {
+      return;
+    }
+    Object.entries(manifest.scopes).forEach(([scopeName, specifierMap]) => {
+      const scopedImports = {};
+      Object.entries(specifierMap).forEach(
+        ([specifierName, identifier]) => {
+          scopedImports[specifierName] = imports[identifier] ?? identifier;
+        }
+      );
+      const scopePath = imports[`${manifest.name}/${scopeName}`] ?? `/${scopeName}`;
+      const scopeKey = getScope(manifest.name, scopePath);
+      scopes[scopeKey] = scopedImports;
     });
   });
+  return scopes;
+}
+export function getImportMap({
+  manifests,
+  getFile,
+  getScope
+}) {
+  const imports = buildImportsMap(manifests, getFile);
+  const scopes = buildScopesMap(imports, manifests, getScope);
   return {
     imports,
     scopes