@sveltejs/vite-plugin-svelte 1.0.0-next.40 → 1.0.0-next.41

package/dist/index.js

@@ -536,7 +536,7 @@ var SVELTE_HMR_IMPORTS = [
 ];
 
 // src/utils/options.ts
-import path3 from "path";
+import path4 from "path";
 
 // src/utils/dependencies.ts
 import path2 from "path";
@@ -566,7 +566,7 @@ function findRootSvelteDependencies(root, cwdFallback = true) {
   ].filter((dep) => !is_common_without_svelte_field(dep));
   return getSvelteDependencies(deps, root);
 }
-function getSvelteDependencies(deps, pkgDir, path7 = []) {
+function getSvelteDependencies(deps, pkgDir, path8 = []) {
   const result = [];
   const localRequire = createRequire2(`${pkgDir}/package.json`);
   const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
@@ -574,18 +574,18 @@ function getSvelteDependencies(deps, pkgDir, path7 = []) {
     const type = getSvelteDependencyType(pkg);
     if (!type)
       continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path7 });
+    result.push({ name: pkg.name, type, pkg, dir, path: path8 });
     if (type === "component-library" && pkg.dependencies) {
       let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path7.includes(name));
+      const circular = dependencyNames.filter((name) => path8.includes(name));
       if (circular.length > 0) {
-        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path7.concat(x).join(">")));
-        dependencyNames = dependencyNames.filter((name) => !path7.includes(name));
+        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path8.concat(x).join(">")));
+        dependencyNames = dependencyNames.filter((name) => !path8.includes(name));
       }
-      if (path7.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path7.join(">")}`);
+      if (path8.length === 3) {
+        log.debug.once(`encountered deep svelte dependency tree: ${path8.join(">")}`);
       }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path7.concat(pkg.name)));
+      result.push(...getSvelteDependencies(dependencyNames, dir, path8.concat(pkg.name)));
     }
   }
   return result;
@@ -766,7 +766,9 @@ function esbuildSveltePlugin(options) {
   return {
     name: "vite-plugin-svelte:optimize-svelte",
     setup(build) {
-      disableVitePrebundleSvelte(build);
+      var _a;
+      if ((_a = build.initialOptions.plugins) == null ? void 0 : _a.some((v) => v.name === "vite:dep-scan"))
+        return;
       const svelteExtensions = (options.extensions ?? [".svelte"]).map((ext) => ext.slice(1));
       const svelteFilter = new RegExp(`\\.(` + svelteExtensions.join("|") + `)(\\?.*)?$`);
       build.onLoad({ filter: svelteFilter }, async ({ path: filename }) => {
@@ -781,23 +783,6 @@ function esbuildSveltePlugin(options) {
     }
   };
 }
-function disableVitePrebundleSvelte(build) {
-  var _a;
-  const viteDepPrebundlePlugin = (_a = build.initialOptions.plugins) == null ? void 0 : _a.find((v) => v.name === "vite:dep-pre-bundle");
-  if (!viteDepPrebundlePlugin)
-    return;
-  const _setup = viteDepPrebundlePlugin.setup.bind(viteDepPrebundlePlugin);
-  viteDepPrebundlePlugin.setup = function(build2) {
-    const _onResolve = build2.onResolve.bind(build2);
-    build2.onResolve = function(options, callback) {
-      if (options.filter.source.includes("svelte")) {
-        options.filter = new RegExp(options.filter.source.replace("|svelte", ""), options.filter.flags);
-      }
-      return _onResolve(options, callback);
-    };
-    return _setup(build2);
-  };
-}
 async function compileSvelte(options, { filename, code }) {
   var _a, _b;
   const compileOptions = __spreadProps(__spreadValues({}, options.compilerOptions), {
@@ -885,6 +870,7 @@ async function buildSourceMap(from, to, filename) {
 }
 
 // src/utils/preprocess.ts
+import path3 from "path";
 var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss"];
 var supportedScriptLangs = ["ts"];
 function createViteScriptPreprocessor() {
@@ -925,7 +911,7 @@ function createViteStylePreprocessor(config) {
     const moduleId = `${filename}.${lang}`;
     const transformResult = await pluginTransform(content, moduleId);
     if (((_b = (_a = transformResult.map) == null ? void 0 : _a.sources) == null ? void 0 : _b[0]) === moduleId) {
-      transformResult.map.sources[0] = filename;
+      transformResult.map.sources[0] = path3.basename(filename);
     }
     return {
       code: transformResult.code,
@@ -950,7 +936,10 @@ function createInjectScopeEverythingRulePreprocessorGroup() {
       s.append(" *{}");
       return {
         code: s.toString(),
-        map: s.generateDecodedMap({ source: filename, hires: true })
+        map: s.generateDecodedMap({
+          source: filename ? path3.basename(filename) : void 0,
+          hires: true
+        })
       };
     }
   };
@@ -1168,7 +1157,7 @@ function enforceOptionsForProduction(options) {
   }
 }
 function resolveViteRoot(viteConfig) {
-  return normalizePath2(viteConfig.root ? path3.resolve(viteConfig.root) : process.cwd());
+  return normalizePath2(viteConfig.root ? path4.resolve(viteConfig.root) : process.cwd());
 }
 function buildExtraViteConfig(options, config) {
   const svelteDeps = findRootSvelteDependencies(options.root);
@@ -1181,19 +1170,28 @@ function buildExtraViteConfig(options, config) {
   if (options.isServe) {
     extraViteConfig.optimizeDeps = buildOptimizeDepsForSvelte(svelteDeps, options, config.optimizeDeps);
   }
+  if (options.experimental.prebundleSvelteLibraries) {
+    extraViteConfig.optimizeDeps = __spreadProps(__spreadValues({}, extraViteConfig.optimizeDeps), {
+      extensions: options.extensions ?? [".svelte"],
+      esbuildOptions: {
+        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+        } }]
+      }
+    });
+  }
   extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config, extraViteConfig);
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
+function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
   const include = [];
   const exclude = ["svelte-hmr"];
   const isIncluded = (dep) => {
     var _a;
-    return include.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.include) == null ? void 0 : _a.includes(dep));
+    return include.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.include) == null ? void 0 : _a.includes(dep));
   };
   const isExcluded = (dep) => {
     var _a;
-    return exclude.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
+    return exclude.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
   };
   if (!isExcluded("svelte")) {
     const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
@@ -1203,14 +1201,7 @@ function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
     log.debug('"svelte" is excluded in optimizeDeps.exclude, skipped adding it to include.');
   }
   if (options.experimental.prebundleSvelteLibraries) {
-    return {
-      include,
-      exclude,
-      esbuildOptions: {
-        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-        } }]
-      }
-    };
+    return { include, exclude };
   }
   svelteDeps = svelteDeps.filter((dep) => dep.type === "component-library");
   const svelteDepsToExclude = Array.from(new Set(svelteDeps.map((dep) => dep.name))).filter((dep) => !isIncluded(dep));
@@ -1332,8 +1323,8 @@ var VitePluginSvelteCache = class {
       return this._js.get(svelteRequest.normalizedFilename);
     }
   }
-  getDependants(path7) {
-    const dependants = this._dependants.get(path7);
+  getDependants(path8) {
+    const dependants = this._dependants.get(path8);
     return dependants ? [...dependants] : [];
   }
   getResolvedSvelteField(name, importer) {
@@ -1349,7 +1340,7 @@ var VitePluginSvelteCache = class {
 
 // src/utils/watch.ts
 import fs5 from "fs";
-import path4 from "path";
+import path5 from "path";
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
   if (!server) {
@@ -1388,7 +1379,7 @@ function setupWatchers(options, cache, requestParser) {
       server.restart();
     }
   };
-  const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path4.join(root, cfg));
+  const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path5.join(root, cfg));
   const restartOnConfigAdd = (filename) => {
     if (possibleSvelteConfigs.includes(filename)) {
       triggerViteRestart(filename);
@@ -1418,12 +1409,12 @@ function setupWatchers(options, cache, requestParser) {
 }
 function ensureWatchedFile(watcher, file, root) {
   if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs5.existsSync(file)) {
-    watcher.add(path4.resolve(file));
+    watcher.add(path5.resolve(file));
   }
 }
 
 // src/utils/resolve.ts
-import path5 from "path";
+import path6 from "path";
 import { builtinModules, createRequire as createRequire4 } from "module";
 function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !is_common_without_svelte_field(importee)) {
@@ -1436,7 +1427,7 @@ function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = path5.resolve(dir, pkg.svelte);
+        const result = path6.resolve(dir, pkg.svelte);
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1447,7 +1438,7 @@ function isNodeInternal(importee) {
   return importee.startsWith("node:") || builtinModules.includes(importee);
 }
 function isBareImport(importee) {
-  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || path5.isAbsolute(importee)) {
+  if (!importee || importee[0] === "." || importee[0] === "\0" || importee.includes(":") || path6.isAbsolute(importee)) {
     return false;
   }
   const parts = importee.split("/");
@@ -1462,9 +1453,8 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-import fs6 from "fs";
-import path6 from "path";
-import { optimizeDeps } from "vite";
+import { promises as fs6 } from "fs";
+import path7 from "path";
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
   "configFile",
@@ -1473,23 +1463,20 @@ var PREBUNDLE_SENSITIVE_OPTIONS = [
   "ignorePluginPreprocessors",
   "preprocess"
 ];
-async function handleOptimizeDeps(options, viteConfig) {
-  if (!options.experimental.prebundleSvelteLibraries || !viteConfig.cacheDir)
-    return;
-  const viteMetadataPath = findViteMetadataPath(viteConfig.cacheDir);
-  if (!viteMetadataPath)
-    return;
-  const svelteMetadataPath = path6.resolve(viteMetadataPath, "../_svelte_metadata.json");
-  const currentSvelteMetadata = JSON.stringify(generateSvelteMetadata(options), (_, value) => {
+async function saveSvelteMetadata(cacheDir, options) {
+  const svelteMetadata = generateSvelteMetadata(options);
+  const svelteMetadataPath = path7.resolve(cacheDir, "_svelte_metadata.json");
+  const currentSvelteMetadata = JSON.stringify(svelteMetadata, (_, value) => {
     return typeof value === "function" ? value.toString() : value;
   });
-  if (fs6.existsSync(svelteMetadataPath)) {
-    const existingSvelteMetadata = fs6.readFileSync(svelteMetadataPath, "utf8");
-    if (existingSvelteMetadata === currentSvelteMetadata)
-      return;
+  let existingSvelteMetadata;
+  try {
+    existingSvelteMetadata = await fs6.readFile(svelteMetadataPath, "utf8");
+  } catch {
   }
-  await optimizeDeps(viteConfig, true);
-  fs6.writeFileSync(svelteMetadataPath, currentSvelteMetadata);
+  await fs6.mkdir(cacheDir, { recursive: true });
+  await fs6.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
   const metadata = {};
@@ -1498,14 +1485,6 @@ function generateSvelteMetadata(options) {
   }
   return metadata;
 }
-function findViteMetadataPath(cacheDir) {
-  const metadataPaths = ["_metadata.json", "deps/_metadata.json"];
-  for (const metadataPath of metadataPaths) {
-    const viteMetadataPath = path6.resolve(cacheDir, metadataPath);
-    if (fs6.existsSync(viteMetadataPath))
-      return viteMetadataPath;
-  }
-}
 
 // src/index.ts
 function svelte(inlineOptions) {
@@ -1542,7 +1521,12 @@ function svelte(inlineOptions) {
       log.debug("resolved options", options);
     },
     async buildStart() {
-      await handleOptimizeDeps(options, viteConfig);
+      if (!options.experimental.prebundleSvelteLibraries)
+        return;
+      const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
+      if (isSvelteMetadataChanged) {
+        viteConfig.server.force = true;
+      }
     },
     configureServer(server) {
       options.server = server;