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

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

@@ -17,4 +17,34 @@ export interface GetImportMapOptions {
 }
 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;
+/**
+ * Fixes Chrome's nested scope resolution bug in import maps.
+ *
+ * Chrome has a bug where nested scopes in import maps are not resolved correctly.
+ * For example, when you have both "/shared-modules/" and "/shared-modules/vue2/" scopes,
+ * Chrome fails to properly apply the more specific nested scope.
+ *
+ * This function works around the bug by:
+ * 1. Sorting scopes by path depth (shallow paths first, deeper paths last)
+ * 2. Manually applying scopes to matching imports in the correct order
+ *
+ * @example
+ * Problematic import map that fails in Chrome:
+ * ```json
+ * {
+ *   "scopes": {
+ *     "/shared-modules/": {
+ *       "vue": "/shared-modules/vue.d8c7a640.final.mjs"
+ *     },
+ *     "/shared-modules/vue2/": {
+ *       "vue": "/shared-modules/vue2.9b4efaf3.final.mjs"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @see https://github.com/guybedford/es-module-shims/issues/529
+ * @see https://issues.chromium.org/issues/453147451
+ */
+export declare function fixNestedScopesResolution(importMap: Required<ImportMap>): Required<ImportMap>;
+export declare function getImportMap({ manifests, getFile, getScope }: GetImportMapOptions): Required<ImportMap>;

package/dist/utils/import-map.mjs

@@ -36,6 +36,24 @@ export function buildScopesMap(imports, manifests, getScope) {
   });
   return scopes;
 }
+export function fixNestedScopesResolution(importMap) {
+  Object.entries(importMap.scopes).sort(([pathA], [pathB]) => {
+    const depthA = pathA.split("/").length;
+    const depthB = pathB.split("/").length;
+    return depthA - depthB;
+  }).forEach(([scopePath, scopeMappings]) => {
+    Object.values(importMap.imports).forEach((importPath) => {
+      if (importPath.startsWith(scopePath)) {
+        importMap.scopes[importPath] = {
+          ...importMap.scopes[importPath],
+          ...scopeMappings
+        };
+      }
+    });
+    Reflect.deleteProperty(importMap.scopes, scopePath);
+  });
+  return importMap;
+}
 export function getImportMap({
   manifests,
   getFile,