@nuxt/webpack-builder 3.5.2 → 3.5.3

package/dist/index.mjs

@@ -13,6 +13,7 @@ import MagicString from 'magic-string';
 import { hash } from 'ohash';
 import escapeRE from 'escape-string-regexp';
 import { findStaticImports, parseStaticImport, createCommonJS } from 'mlly';
+import 'node:fs';
 import { createFsFromVolume, Volume } from 'memfs';
 import VirtualModulesPlugin from 'webpack-virtual-modules';
 import querystring from 'node:querystring';
@@ -31,6 +32,15 @@ import { normalizeWebpackManifest } from 'vue-bundle-renderer';
 import hash$1 from 'hash-sum';
 import fse from 'fs-extra';
 
+function matchWithStringOrRegex(value, matcher) {
+  if (typeof matcher === "string") {
+    return value === matcher;
+  } else if (matcher instanceof RegExp) {
+    return matcher.test(value);
+  }
+  return false;
+}
+
 const stringTypes = ["Literal", "TemplateLiteral"];
 const NUXT_LIB_RE = /node_modules\/nuxt3?\//;
 const SUPPORTED_EXT_RE = /\.(m?[jt]sx?|vue)/;
@@ -55,11 +65,37 @@ const composableKeysPlugin = createUnplugin((options) => {
       let imports;
       let count = 0;
       const relativeID = isAbsolute(id) ? relative(options.rootDir, id) : id;
-      walk(this.parse(script, {
+      const { pathname: relativePathname } = parseURL(relativeID);
+      const ast = this.parse(script, {
         sourceType: "module",
         ecmaVersion: "latest"
-      }), {
+      });
+      let scopeTracker = new ScopeTracker();
+      const varCollector = new ScopedVarsCollector();
+      walk(ast, {
+        enter(_node) {
+          if (_node.type === "BlockStatement") {
+            scopeTracker.enterScope();
+            varCollector.refresh(scopeTracker.curScopeKey);
+          } else if (_node.type === "FunctionDeclaration" && _node.id) {
+            varCollector.addVar(_node.id.name);
+          } else if (_node.type === "VariableDeclarator") {
+            varCollector.collect(_node.id);
+          }
+        },
+        leave(_node) {
+          if (_node.type === "BlockStatement") {
+            scopeTracker.leaveScope();
+            varCollector.refresh(scopeTracker.curScopeKey);
+          }
+        }
+      });
+      scopeTracker = new ScopeTracker();
+      walk(ast, {
         enter(_node) {
+          if (_node.type === "BlockStatement") {
+            scopeTracker.enterScope();
+          }
           if (_node.type !== "CallExpression" || _node.callee.type !== "Identifier") {
             return;
           }
@@ -68,11 +104,20 @@ const composableKeysPlugin = createUnplugin((options) => {
           if (!name || !keyedFunctions.has(name) || node.arguments.length >= maxLength) {
             return;
           }
-          imports = imports || detectImportNames(script);
+          imports = imports || detectImportNames(script, composableMeta);
           if (imports.has(name)) {
             return;
           }
           const meta = composableMeta[name];
+          if (varCollector.hasVar(scopeTracker.curScopeKey, name)) {
+            let skip = true;
+            if (meta.source) {
+              skip = !matchWithStringOrRegex(relativePathname, meta.source);
+            }
+            if (skip) {
+              return;
+            }
+          }
           if (node.arguments.length >= meta.argumentLength) {
             return;
           }
@@ -100,6 +145,11 @@ const composableKeysPlugin = createUnplugin((options) => {
             codeIndex + node.end - 1,
             (node.arguments.length && !endsWithComma ? ", " : "") + "'$" + hash(`${relativeID}-${++count}`) + "'"
           );
+        },
+        leave(_node) {
+          if (_node.type === "BlockStatement") {
+            scopeTracker.leaveScope();
+          }
         }
       });
       if (s.hasChanged()) {
@@ -111,23 +161,94 @@ const composableKeysPlugin = createUnplugin((options) => {
     }
   };
 });
+class ScopeTracker {
+  constructor() {
+    this.scopeIndexStack = [0];
+    this.curScopeKey = "0";
+  }
+  getKey() {
+    return this.scopeIndexStack.slice(0, -1).join("-");
+  }
+  enterScope() {
+    this.scopeIndexStack.push(0);
+    this.curScopeKey = this.getKey();
+  }
+  leaveScope() {
+    this.scopeIndexStack.pop();
+    this.curScopeKey = this.getKey();
+    this.scopeIndexStack[this.scopeIndexStack.length - 1]++;
+  }
+}
+class ScopedVarsCollector {
+  constructor() {
+    this.all = /* @__PURE__ */ new Map();
+    this.curScopeKey = "0";
+  }
+  refresh(scopeKey) {
+    this.curScopeKey = scopeKey;
+  }
+  addVar(name) {
+    let vars = this.all.get(this.curScopeKey);
+    if (!vars) {
+      vars = /* @__PURE__ */ new Set();
+      this.all.set(this.curScopeKey, vars);
+    }
+    vars.add(name);
+  }
+  hasVar(scopeKey, name) {
+    const indices = scopeKey.split("-").map(Number);
+    for (let i = indices.length; i > 0; i--) {
+      if (this.all.get(indices.slice(0, i).join("-"))?.has(name)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  collect(n) {
+    const t = n.type;
+    if (t === "Identifier") {
+      this.addVar(n.name);
+    } else if (t === "RestElement") {
+      this.collect(n.argument);
+    } else if (t === "AssignmentPattern") {
+      this.collect(n.left);
+    } else if (t === "ArrayPattern") {
+      n.elements.forEach((e) => e && this.collect(e));
+    } else if (t === "ObjectPattern") {
+      n.properties.forEach((p) => {
+        if (p.type === "RestElement") {
+          this.collect(p);
+        } else {
+          this.collect(p.value);
+        }
+      });
+    }
+  }
+}
 const NUXT_IMPORT_RE = /nuxt|#app|#imports/;
-function detectImportNames(code) {
+function detectImportNames(code, composableMeta) {
   const imports = findStaticImports(code);
   const names = /* @__PURE__ */ new Set();
   for (const i of imports) {
+    let addName = function(name) {
+      const source = composableMeta[name]?.source;
+      if (source && matchWithStringOrRegex(i.specifier, source)) {
+        return;
+      }
+      names.add(namedImports[name]);
+    };
     if (NUXT_IMPORT_RE.test(i.specifier)) {
       continue;
     }
     const { namedImports, defaultImport, namespacedImport } = parseStaticImport(i);
     for (const name in namedImports || {}) {
-      names.add(namedImports[name]);
+      addName(namedImports[name]);
     }
     if (defaultImport) {
-      names.add(defaultImport);
+      addName(defaultImport);
     }
     if (namespacedImport) {
-      names.add(namespacedImport);
+      addName(namespacedImport);
     }
   }
   return names;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuxt/webpack-builder",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "repository": "nuxt/nuxt",
   "license": "MIT",
   "type": "module",
@@ -31,11 +31,11 @@
     "hash-sum": "^2.0.0",
     "lodash-es": "^4.17.21",
     "magic-string": "^0.30.0",
-    "memfs": "^3.5.1",
+    "memfs": "^3.5.2",
     "mini-css-extract-plugin": "^2.7.6",
     "mlly": "^1.3.0",
     "ohash": "^1.1.2",
-    "pathe": "^1.1.0",
+    "pathe": "^1.1.1",
     "pify": "^6.1.0",
     "postcss": "^8.4.24",
     "postcss-import": "^15.1.0",
@@ -47,25 +47,25 @@
     "unplugin": "^1.3.1",
     "url-loader": "^4.1.1",
     "vue-bundle-renderer": "^1.0.3",
-    "vue-loader": "^17.1.2",
-    "webpack": "^5.84.1",
-    "webpack-bundle-analyzer": "^4.8.0",
+    "vue-loader": "^17.2.2",
+    "webpack": "^5.85.1",
+    "webpack-bundle-analyzer": "^4.9.0",
     "webpack-dev-middleware": "^6.1.1",
     "webpack-hot-middleware": "^2.25.3",
     "webpack-virtual-modules": "^0.5.0",
     "webpackbar": "^5.0.2",
-    "@nuxt/kit": "3.5.2"
+    "@nuxt/kit": "3.5.3"
   },
   "devDependencies": {
-    "@types/fs-extra": "^11.0.1",
-    "@types/lodash-es": "^4.17.7",
-    "@types/pify": "^5.0.1",
-    "@types/webpack-bundle-analyzer": "^4.6.0",
-    "@types/webpack-hot-middleware": "^2.25.6",
-    "@types/webpack-virtual-modules": "^0.1.1",
+    "@types/fs-extra": "11.0.1",
+    "@types/lodash-es": "4.17.7",
+    "@types/pify": "5.0.1",
+    "@types/webpack-bundle-analyzer": "4.6.0",
+    "@types/webpack-hot-middleware": "2.25.6",
+    "@types/webpack-virtual-modules": "0.1.1",
     "unbuild": "latest",
     "vue": "3.3.4",
-    "@nuxt/schema": "3.5.2"
+    "@nuxt/schema": "3.5.3"
   },
   "peerDependencies": {
     "vue": "^3.3.4"