weapp-vite 5.7.1 → 5.8.0

package/dist/auto-import-components/resolvers.cjs

@@ -1,12 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkA5DD7GKXcjs = require('../chunk-A5DD7GKX.cjs');
+var _chunkQKFYCWOCcjs = require('../chunk-QKFYCWOC.cjs');
 
 // src/auto-import-components/resolvers/index.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 // src/auto-import-components/resolvers/tdesign.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 var _shared = require('@weapp-core/shared');
 
 // src/auto-import-components/resolvers/json/tdesign.json
@@ -124,10 +124,10 @@ var TDesignResolver = (opts) => {
 };
 
 // src/auto-import-components/resolvers/types.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 // src/auto-import-components/resolvers/vant.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 
 // src/auto-import-components/resolvers/json/vant.json

package/dist/auto-import-components/resolvers.mjs

@@ -1,6 +1,6 @@
 import {
   init_esm_shims
-} from "../chunk-SSQGJIB5.mjs";
+} from "../chunk-TZWATIK3.mjs";
 
 // src/auto-import-components/resolvers/index.ts
 init_esm_shims();

package/dist/auto-routes.cjs

@@ -1,20 +1,20 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
-var _chunkT4OVF4GPcjs = require('./chunk-T4OVF4GP.cjs');
-require('./chunk-MQBCRXCD.cjs');
-require('./chunk-G6EZVEVT.cjs');
+var _chunkLZJAPKF7cjs = require('./chunk-LZJAPKF7.cjs');
+require('./chunk-JKNSNXOE.cjs');
+require('./chunk-RMHCFT5Q.cjs');
 
 
-var _chunkA5DD7GKXcjs = require('./chunk-A5DD7GKX.cjs');
+var _chunkQKFYCWOCcjs = require('./chunk-QKFYCWOC.cjs');
 
 // src/auto-routes.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 // src/context/index.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 // src/context/CompilerContext.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 
 // src/auto-routes.ts
 function createGetter(resolver) {
@@ -24,7 +24,7 @@ function createGetter(resolver) {
     get: resolver
   };
 }
-var ctx = _chunkT4OVF4GPcjs.getCompilerContext.call(void 0, );
+var ctx = _chunkLZJAPKF7cjs.getCompilerContext.call(void 0, );
 var service = ctx.autoRoutesService;
 var routes = {};
 Object.defineProperties(routes, {

package/dist/auto-routes.mjs

@@ -1,11 +1,11 @@
 import {
   getCompilerContext
-} from "./chunk-O4FBXXL3.mjs";
-import "./chunk-N463WDOG.mjs";
-import "./chunk-2SUWUB42.mjs";
+} from "./chunk-DHQDH7RC.mjs";
+import "./chunk-RJVVY5EI.mjs";
+import "./chunk-SSYIWHY2.mjs";
 import {
   init_esm_shims
-} from "./chunk-SSQGJIB5.mjs";
+} from "./chunk-TZWATIK3.mjs";
 
 // src/auto-routes.ts
 init_esm_shims();

package/dist/{chunk-GGLONZVQ.cjs → chunk-3AGZHFSV.cjs}

@@ -2,20 +2,20 @@
 
 
 
-var _chunkT4OVF4GPcjs = require('./chunk-T4OVF4GP.cjs');
+var _chunkLZJAPKF7cjs = require('./chunk-LZJAPKF7.cjs');
 
 
-var _chunkA5DD7GKXcjs = require('./chunk-A5DD7GKX.cjs');
+var _chunkQKFYCWOCcjs = require('./chunk-QKFYCWOC.cjs');
 
 // src/createContext.ts
-_chunkA5DD7GKXcjs.init_cjs_shims.call(void 0, );
+_chunkQKFYCWOCcjs.init_cjs_shims.call(void 0, );
 async function createCompilerContext(options) {
   const key = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.key]), () => ( "default"));
   if (!_optionalChain([options, 'optionalAccess', _2 => _2.key])) {
-    _chunkT4OVF4GPcjs.resetCompilerContext.call(void 0, key);
+    _chunkLZJAPKF7cjs.resetCompilerContext.call(void 0, key);
   }
-  _chunkT4OVF4GPcjs.setActiveCompilerContextKey.call(void 0, key);
-  const ctx = _chunkT4OVF4GPcjs.getCompilerContext.call(void 0, key);
+  _chunkLZJAPKF7cjs.setActiveCompilerContextKey.call(void 0, key);
+  const ctx = _chunkLZJAPKF7cjs.getCompilerContext.call(void 0, key);
   const { configService, scanService, autoRoutesService } = ctx;
   await configService.load(options);
   if (autoRoutesService) {

package/dist/{chunk-O4FBXXL3.mjs → chunk-DHQDH7RC.mjs}

@@ -3,7 +3,7 @@ import {
   __require,
   __toESM,
   init_esm_shims
-} from "./chunk-SSQGJIB5.mjs";
+} from "./chunk-TZWATIK3.mjs";
 
 // ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
 var require_debug = __commonJS({
@@ -11922,8 +11922,39 @@ import { Buffer as Buffer2 } from "buffer";
 import { posix as path10 } from "pathe";
 var SHARED_CHUNK_VIRTUAL_PREFIX = "weapp_shared_virtual";
 var SUB_PACKAGE_SHARED_DIR = "weapp-shared";
-var DEFAULT_SHARED_CHUNK_STRATEGY = "duplicate";
+var DEFAULT_SHARED_CHUNK_STRATEGY = "hoist";
+function markTakeModuleImporter(moduleId, importerId) {
+  if (!moduleId || !importerId) {
+    return;
+  }
+  const importers = takeImportersMap.get(moduleId);
+  if (importers) {
+    importers.add(importerId);
+  } else {
+    takeImportersMap.set(moduleId, /* @__PURE__ */ new Set([importerId]));
+  }
+}
+function resetTakeImportRegistry() {
+  takeImportersMap.clear();
+  forceDuplicateSharedChunks.clear();
+  sharedChunkDiagnostics.clear();
+}
+function getTakeImporters(moduleId) {
+  return takeImportersMap.get(moduleId);
+}
+function markForceDuplicateSharedChunk(sharedName) {
+  if (!sharedName) {
+    return;
+  }
+  forceDuplicateSharedChunks.add(sharedName);
+  forceDuplicateSharedChunks.add(`${sharedName}.js`);
+}
+function isForceDuplicateSharedChunk(fileName) {
+  return forceDuplicateSharedChunks.has(fileName);
+}
 var sharedChunkDiagnostics = /* @__PURE__ */ new Map();
+var takeImportersMap = /* @__PURE__ */ new Map();
+var forceDuplicateSharedChunks = /* @__PURE__ */ new Set();
 function resolveSharedChunkName(options) {
   const {
     id,
@@ -11933,7 +11964,42 @@ function resolveSharedChunkName(options) {
     strategy,
     forceDuplicateTester
   } = options;
+  const subPackageRootList = Array.from(subPackageRoots);
   const moduleInfo = ctx.getModuleInfo(id);
+  const takeImporters = getTakeImporters(id);
+  if (takeImporters?.size) {
+    const takeSharedName = resolveTakeSharedChunkName({
+      id,
+      ctx,
+      relativeAbsoluteSrcRoot,
+      subPackageRoots: subPackageRootList,
+      importers: Array.from(takeImporters)
+    });
+    if (takeSharedName) {
+      return takeSharedName;
+    }
+  }
+  if (strategy === "hoist") {
+    const relativeId = relativeAbsoluteSrcRoot(id);
+    const moduleRoot = resolveSubPackagePrefix(relativeId, subPackageRootList);
+    if (moduleRoot) {
+      assertModuleScopedToRoot({
+        moduleInfo,
+        moduleRoot,
+        relativeAbsoluteSrcRoot,
+        subPackageRoots: subPackageRootList,
+        moduleId: id
+      });
+      if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+        return void 0;
+      }
+      return path10.join(moduleRoot, "common");
+    }
+    if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
+      return void 0;
+    }
+    return "common";
+  }
   if (!moduleInfo?.importers || moduleInfo.importers.length <= 1) {
     return void 0;
   }
@@ -11941,7 +12007,7 @@ function resolveSharedChunkName(options) {
     ctx,
     importers: moduleInfo.importers,
     relativeAbsoluteSrcRoot,
-    subPackageRoots: Array.from(subPackageRoots),
+    subPackageRoots: subPackageRootList,
     forceDuplicateTester
   });
   const keys = Object.keys(summary);
@@ -11954,9 +12020,7 @@ function resolveSharedChunkName(options) {
   }
   const hasMainImporter = keys.includes("");
   if (strategy === "duplicate" && !hasMainImporter) {
-    const combination = keys.filter(Boolean).sort().join("+");
-    const combinationSegment = combination ? `${combination}/` : "";
-    const sharedName = `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+    const sharedName = createSharedChunkNameFromKeys(keys);
     if (ignoredMainImporters.length) {
       sharedChunkDiagnostics.set(sharedName, {
         ignoredMainImporters: Array.from(new Set(ignoredMainImporters))
@@ -12107,8 +12171,60 @@ function resolveSubPackagePrefix(fileName, subPackageRoots) {
   }
   return "";
 }
+function resolveTakeSharedChunkName(options) {
+  const {
+    ctx,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    importers
+  } = options;
+  if (!importers.length) {
+    return void 0;
+  }
+  const { summary } = summarizeImportPrefixes({
+    ctx,
+    importers,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots
+  });
+  const keys = Object.keys(summary).filter(Boolean);
+  if (!keys.length) {
+    return void 0;
+  }
+  const sharedName = createSharedChunkNameFromKeys(keys);
+  markForceDuplicateSharedChunk(sharedName);
+  return sharedName;
+}
+function createSharedChunkNameFromKeys(keys) {
+  const sanitize = (value) => value.replace(/[\\/]+/g, "_");
+  const combination = keys.filter(Boolean).map(sanitize).sort().join("+");
+  const combinationSegment = combination ? `${combination}/` : "";
+  return `${SHARED_CHUNK_VIRTUAL_PREFIX}/${combinationSegment}common`;
+}
+function assertModuleScopedToRoot(options) {
+  const {
+    moduleInfo,
+    moduleRoot,
+    relativeAbsoluteSrcRoot,
+    subPackageRoots,
+    moduleId
+  } = options;
+  if (!moduleRoot || !moduleInfo?.importers?.length) {
+    return;
+  }
+  for (const importer of moduleInfo.importers) {
+    const importerRoot = resolveSubPackagePrefix(relativeAbsoluteSrcRoot(importer), subPackageRoots);
+    if (importerRoot !== moduleRoot) {
+      const moduleLabel = relativeAbsoluteSrcRoot(moduleId);
+      const importerLabel = relativeAbsoluteSrcRoot(importer);
+      throw new Error(
+        `[subpackages] \u6A21\u5757 "${moduleLabel}" \u4F4D\u4E8E\u5206\u5305 "${moduleRoot}"\uFF0C\u4F46\u88AB "${importerLabel}" \u5F15\u7528\uFF0C\u8BF7\u5C06\u8BE5\u6A21\u5757\u79FB\u52A8\u5230\u4E3B\u5305\u6216\u516C\u5171\u76EE\u5F55\u4EE5\u8FDB\u884C\u8DE8\u5206\u5305\u5171\u4EAB\u3002`
+      );
+    }
+  }
+}
 function applySharedChunkStrategy(bundle, options) {
-  if (options.strategy !== "duplicate") {
+  if (options.strategy !== "duplicate" && forceDuplicateSharedChunks.size === 0) {
     return;
   }
   if (!this) {
@@ -12128,13 +12244,17 @@ function applySharedChunkStrategy(bundle, options) {
     if (importers.length === 0) {
       continue;
     }
+    const sourceMapKeys = collectSourceMapKeys(fileName, chunk);
+    const sourceMapAssetInfo = findSourceMapAsset(bundle, sourceMapKeys);
+    const resolvedSourceMap = resolveSourceMapSource(originalMap, sourceMapAssetInfo?.asset.source);
     const importerMap = /* @__PURE__ */ new Map();
     let hasMainImporter = false;
+    const shouldForceDuplicate = isForceDuplicateSharedChunk(originalSharedFileName);
     for (const importerFile of importers) {
       const root = resolveSubPackagePrefix(importerFile, subPackageRoots);
       if (!root) {
         hasMainImporter = true;
-        break;
+        continue;
       }
       const duplicateBaseName = path10.basename(fileName);
       const intendedFileName = path10.join(root, SUB_PACKAGE_SHARED_DIR, duplicateBaseName);
@@ -12149,12 +12269,28 @@ function applySharedChunkStrategy(bundle, options) {
         });
       }
     }
-    if (hasMainImporter || importerMap.size === 0) {
-      consumeSharedChunkDiagnostics(originalSharedFileName);
+    const importerToChunk = /* @__PURE__ */ new Map();
+    const duplicates = [];
+    const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
+    const shouldRetainOriginalChunk = shouldForceDuplicate && hasMainImporter;
+    if ((hasMainImporter || importerMap.size === 0) && (!shouldForceDuplicate || importerMap.size === 0)) {
       let finalFileName = chunk.fileName;
       if (fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
         const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
         chunk.fileName = newFileName;
+        if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+          chunk.sourcemapFileName = `${newFileName}.map`;
+        }
+        const targetKey = `${newFileName}.map`;
+        emitSourceMapAsset(this, targetKey, sourceMapAssetInfo, resolvedSourceMap);
+        for (const mapKey of sourceMapKeys) {
+          if (!mapKey || mapKey === targetKey) {
+            continue;
+          }
+          if (bundle[mapKey]) {
+            delete bundle[mapKey];
+          }
+        }
         finalFileName = newFileName;
       }
       options.onFallback?.({
@@ -12165,20 +12301,40 @@ function applySharedChunkStrategy(bundle, options) {
       });
       continue;
     }
-    const importerToChunk = /* @__PURE__ */ new Map();
-    const duplicates = [];
-    const diagnostics = consumeSharedChunkDiagnostics(originalSharedFileName);
+    if (shouldRetainOriginalChunk && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`)) {
+      const newFileName = fileName.slice(SHARED_CHUNK_VIRTUAL_PREFIX.length + 1);
+      chunk.fileName = newFileName;
+      if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+        chunk.sourcemapFileName = `${newFileName}.map`;
+      }
+      const targetKey = `${newFileName}.map`;
+      emitSourceMapAsset(this, targetKey, sourceMapAssetInfo, resolvedSourceMap);
+      for (const mapKey of sourceMapKeys) {
+        if (!mapKey || mapKey === targetKey) {
+          continue;
+        }
+        if (bundle[mapKey]) {
+          delete bundle[mapKey];
+        }
+      }
+      options.onFallback?.({
+        sharedFileName: originalSharedFileName,
+        finalFileName: newFileName,
+        reason: "main-package",
+        importers: [...importers]
+      });
+    }
     for (const { newFileName, importers: importerFiles } of importerMap.values()) {
       this.emitFile({
         type: "asset",
         fileName: newFileName,
         source: originalCode
       });
-      if (originalMap) {
+      if (resolvedSourceMap) {
         this.emitFile({
           type: "asset",
           fileName: `${newFileName}.map`,
-          source: typeof originalMap === "string" ? originalMap : JSON.stringify(originalMap)
+          source: cloneSourceLike(resolvedSourceMap)
         });
       }
       for (const importerFile of importerFiles) {
@@ -12190,15 +12346,12 @@ function applySharedChunkStrategy(bundle, options) {
       });
     }
     updateImporters(bundle, importerToChunk, fileName);
-    delete bundle[fileName];
-    const candidateMapKeys = /* @__PURE__ */ new Set();
-    candidateMapKeys.add(`${fileName}.map`);
-    if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
-      candidateMapKeys.add(chunk.sourcemapFileName);
-    }
-    for (const mapKey of candidateMapKeys) {
-      if (mapKey && bundle[mapKey]) {
-        delete bundle[mapKey];
+    if (!shouldRetainOriginalChunk) {
+      delete bundle[fileName];
+      for (const mapKey of sourceMapKeys) {
+        if (mapKey && bundle[mapKey]) {
+          delete bundle[mapKey];
+        }
       }
     }
     const chunkBytes = typeof originalCode === "string" ? Buffer2.byteLength(originalCode, "utf8") : void 0;
@@ -12208,7 +12361,8 @@ function applySharedChunkStrategy(bundle, options) {
       duplicates,
       ignoredMainImporters: diagnostics?.ignoredMainImporters,
       chunkBytes,
-      redundantBytes
+      redundantBytes,
+      retainedInMain: shouldRetainOriginalChunk
     });
   }
 }
@@ -12226,6 +12380,27 @@ function consumeSharedChunkDiagnostics(fileName) {
   }
   return void 0;
 }
+function emitSourceMapAsset(ctx, targetFileName, sourceMapAssetInfo, fallbackSource) {
+  if (!targetFileName) {
+    return;
+  }
+  if (sourceMapAssetInfo?.asset && isSourceLike(sourceMapAssetInfo.asset.source)) {
+    ctx.emitFile({
+      type: "asset",
+      fileName: targetFileName,
+      source: cloneSourceLike(sourceMapAssetInfo.asset.source),
+      name: sourceMapAssetInfo.asset.name
+    });
+    return;
+  }
+  if (fallbackSource) {
+    ctx.emitFile({
+      type: "asset",
+      fileName: targetFileName,
+      source: cloneSourceLike(fallbackSource)
+    });
+  }
+}
 function isSharedVirtualChunk(fileName, output) {
   return output?.type === "chunk" && fileName.startsWith(`${SHARED_CHUNK_VIRTUAL_PREFIX}/`);
 }
@@ -12406,6 +12581,55 @@ function createRelativeImport(fromFile, toFile) {
   }
   return `./${relative3}`;
 }
+function collectSourceMapKeys(fileName, chunk) {
+  const keys = /* @__PURE__ */ new Set();
+  if (fileName) {
+    keys.add(`${fileName}.map`);
+  }
+  if (typeof chunk.sourcemapFileName === "string" && chunk.sourcemapFileName) {
+    keys.add(chunk.sourcemapFileName);
+  }
+  return keys;
+}
+function findSourceMapAsset(bundle, candidateKeys) {
+  for (const key of candidateKeys) {
+    if (!key) {
+      continue;
+    }
+    const entry = bundle[key];
+    if (entry?.type === "asset") {
+      return {
+        asset: entry,
+        key
+      };
+    }
+  }
+  return void 0;
+}
+function resolveSourceMapSource(originalMap, assetSource) {
+  if (originalMap) {
+    if (typeof originalMap === "string") {
+      return originalMap;
+    }
+    if (originalMap instanceof Uint8Array || Buffer2.isBuffer(originalMap)) {
+      return Buffer2.from(originalMap);
+    }
+    return JSON.stringify(originalMap);
+  }
+  if (isSourceLike(assetSource)) {
+    return cloneSourceLike(assetSource);
+  }
+  return void 0;
+}
+function isSourceLike(source) {
+  return typeof source === "string" || source instanceof Uint8Array || Buffer2.isBuffer(source);
+}
+function cloneSourceLike(source) {
+  if (typeof source === "string") {
+    return source;
+  }
+  return Buffer2.from(source);
+}
 
 // src/runtime/advancedChunks.ts
 function testByReg2DExpList(reg2DExpList) {
@@ -23891,11 +24115,69 @@ function weappVite(ctx, subPackageMeta) {
     watchFilesSnapshot: []
   };
   return [
+    createTakeQueryPlugin(state),
     createWxssResolverPlugin(state),
     createCoreLifecyclePlugin(state),
     createRequireAnalysisPlugin(state)
   ];
 }
+var TAKE_DIRECTIVE_PREFIX = "take:";
+function normalizeTakeRequest(source) {
+  if (!source) {
+    return null;
+  }
+  if (source.startsWith(TAKE_DIRECTIVE_PREFIX)) {
+    const id = source.slice(TAKE_DIRECTIVE_PREFIX.length);
+    if (!id) {
+      return null;
+    }
+    return {
+      id,
+      legacy: false
+    };
+  }
+  if (!source.includes("?")) {
+    return null;
+  }
+  const [filename, rawQuery] = source.split("?", 2);
+  if (!rawQuery) {
+    return null;
+  }
+  const params = new URLSearchParams(rawQuery);
+  if (!params.has("take")) {
+    return null;
+  }
+  return {
+    id: filename,
+    legacy: true
+  };
+}
+function createTakeQueryPlugin(_state) {
+  return {
+    name: "weapp-vite:pre:take-query",
+    enforce: "pre",
+    buildStart() {
+      resetTakeImportRegistry();
+    },
+    async resolveId(source, importer) {
+      const takeRequest = normalizeTakeRequest(source);
+      if (!takeRequest) {
+        return null;
+      }
+      const resolved = await this.resolve(takeRequest.id, importer, { skipSelf: true });
+      if (resolved?.id) {
+        markTakeModuleImporter(resolved.id, importer);
+        if (takeRequest.legacy) {
+          logger_default.warn(
+            `"${source}" detected: the ?take query is deprecated, please migrate to the "take:" prefix (e.g. "take:${takeRequest.id}")`
+          );
+        }
+        return resolved;
+      }
+      return null;
+    }
+  };
+}
 function createWxssResolverPlugin(_state) {
   return {
     name: "weapp-vite:pre:wxss",
@@ -24045,7 +24327,7 @@ function createCoreLifecyclePlugin(state) {
         const duplicateWarningBytes = Number(configService.weappViteConfig?.chunks?.duplicateWarningBytes ?? 0);
         const shouldWarnOnDuplicate = Number.isFinite(duplicateWarningBytes) && duplicateWarningBytes > 0;
         let redundantBytesTotal = 0;
-        const handleDuplicate = shouldLogChunks || shouldWarnOnDuplicate ? ({ duplicates, ignoredMainImporters, chunkBytes, redundantBytes }) => {
+        const handleDuplicate = shouldLogChunks || shouldWarnOnDuplicate ? ({ duplicates, ignoredMainImporters, chunkBytes, redundantBytes, retainedInMain, sharedFileName }) => {
           if (shouldWarnOnDuplicate) {
             const duplicateCount = duplicates.length;
             const computedRedundant = typeof redundantBytes === "number" ? redundantBytes : typeof chunkBytes === "number" ? chunkBytes * Math.max(duplicateCount - 1, 0) : 0;
@@ -24064,6 +24346,9 @@ function createCoreLifecyclePlugin(state) {
             const subPackageList = Array.from(subPackageSet).join("\u3001") || "\u76F8\u5173\u5206\u5305";
             const ignoredHint = ignoredMainImporters?.length ? `\uFF0C\u5FFD\u7565\u4E3B\u5305\u5F15\u7528\uFF1A${ignoredMainImporters.join("\u3001")}` : "";
             logger_default.info(`[subpackages] \u5206\u5305 ${subPackageList} \u5171\u4EAB\u6A21\u5757\u5DF2\u590D\u5236\u5230\u5404\u81EA weapp-shared/common.js\uFF08${totalReferences} \u5904\u5F15\u7528${ignoredHint}\uFF09`);
+            if (retainedInMain) {
+              logger_default.warn(`[subpackages] \u6A21\u5757 ${sharedFileName} \u540C\u65F6\u88AB\u4E3B\u5305\u5F15\u7528\uFF0C\u56E0\u6B64\u4ECD\u4FDD\u7559\u5728\u4E3B\u5305 common.js\uFF0C\u5E76\u590D\u5236\u5230 ${subPackageList}\uFF0C\u8BF7\u786E\u8BA4\u662F\u5426\u9700\u8981\u5C06\u6E90\u4EE3\u7801\u79FB\u52A8\u5230\u4E3B\u5305\u6216\u516C\u5171\u76EE\u5F55\u3002`);
+            }
           }
         } : void 0;
         applySharedChunkStrategy.call(this, bundle, {
@@ -24928,6 +25213,46 @@ function createMergeFactories(options) {
     injectBuiltinAliases(inlineConfig);
     return inlineConfig;
   }
+  function normalizePluginOptions(option) {
+    const normalized = [];
+    if (!option) {
+      return normalized;
+    }
+    if (Array.isArray(option)) {
+      for (const entry of option) {
+        normalized.push(...normalizePluginOptions(entry));
+      }
+      return normalized;
+    }
+    normalized.push(option);
+    return normalized;
+  }
+  function isNamedPlugin(option, name) {
+    return typeof option === "object" && option !== null && "name" in option && option.name === name;
+  }
+  function arrangePlugins(config, subPackageMeta) {
+    const existing = normalizePluginOptions(config.plugins);
+    const tsconfigPlugins = [];
+    const others = [];
+    for (const entry of existing) {
+      if (!entry) {
+        continue;
+      }
+      if (isNamedPlugin(entry, "vite-tsconfig-paths")) {
+        tsconfigPlugins.push(entry);
+        continue;
+      }
+      if (isNamedPlugin(entry, WEAPP_VITE_CONTEXT_PLUGIN_NAME)) {
+        continue;
+      }
+      others.push(entry);
+    }
+    config.plugins = [
+      vitePluginWeapp(ctx, subPackageMeta),
+      ...others,
+      ...tsconfigPlugins
+    ];
+  }
   function merge(subPackageMeta, ...configs) {
     ensureConfigService();
     const currentOptions = getOptions2();
@@ -24964,7 +25289,6 @@ function createMergeFactories(options) {
         {
           root: currentOptions.cwd,
           mode: "development",
-          plugins: [vitePluginWeapp(ctx, subPackageMeta)],
           define: getDefineImportMetaEnv(),
           build: {
             watch: {
@@ -24984,6 +25308,7 @@ function createMergeFactories(options) {
           }
         }
       );
+      arrangePlugins(inline, subPackageMeta);
       injectBuiltinAliases(inline);
       return inline;
     }
@@ -24992,9 +25317,6 @@ function createMergeFactories(options) {
       ...configs,
       {
         root: currentOptions.cwd,
-        plugins: [
-          vitePluginWeapp(ctx, subPackageMeta)
-        ],
         mode: "production",
         define: getDefineImportMetaEnv(),
         build: {
@@ -25006,6 +25328,7 @@ function createMergeFactories(options) {
         }
       }
     );
+    arrangePlugins(inlineConfig, subPackageMeta);
     inlineConfig.logLevel = "info";
     injectBuiltinAliases(inlineConfig);
     const currentRoot = subPackageMeta?.subPackage.root;

package/dist/{chunk-ZMX6CFVX.mjs → chunk-ED4S52HS.mjs}

@@ -1,6 +1,6 @@
 import {
   init_esm_shims
-} from "./chunk-SSQGJIB5.mjs";
+} from "./chunk-TZWATIK3.mjs";
 
 // src/types/external.ts
 init_esm_shims();