@sveltejs/vite-plugin-svelte 2.0.4 → 2.1.1

package/dist/index.d.ts

@@ -158,11 +158,11 @@ interface ExperimentalOptions {
      */
     sendWarningsToBrowser?: boolean;
     /**
-     * disable svelte compile statistics
+     * disable svelte field resolve warnings
      *
      * @default false
      */
-    disableCompileStats?: 'dev' | 'build' | boolean;
+    disableSvelteResolveWarnings?: boolean;
 }
 interface InspectorOptions {
     /**

package/dist/index.js

@@ -8,6 +8,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // src/index.ts
 import fs8 from "fs";
+import { VERSION as svelteVersion } from "svelte/compiler";
+import {
+  version as viteVersion
+} from "vite";
 import { isDepExcluded as isDepExcluded2 } from "vitefu";
 
 // src/utils/log.ts
@@ -55,14 +59,19 @@ function setLevel(level) {
     _log(loggers.error, `invalid log level: ${level} `);
   }
 }
-function _log(logger, message, payload) {
+function _log(logger, message, payload, namespace) {
   if (!logger.enabled) {
     return;
   }
   if (logger.isDebug) {
-    payload !== void 0 ? logger.log(message, payload) : logger.log(message);
+    const log2 = namespace ? logger.log.extend(namespace) : logger.log;
+    payload !== void 0 ? log2(message, payload) : log2(message);
   } else {
-    logger.log(logger.color(`${(/* @__PURE__ */ new Date()).toLocaleTimeString()} [${prefix}] ${message}`));
+    logger.log(
+      logger.color(
+        `${(/* @__PURE__ */ new Date()).toLocaleTimeString()} [${prefix}${namespace ? `:${namespace}` : ""}] ${message}`
+      )
+    );
     if (payload) {
       logger.log(payload);
     }
@@ -72,12 +81,12 @@ function createLogger(level) {
   const logger = loggers[level];
   const logFn = _log.bind(null, logger);
   const logged = /* @__PURE__ */ new Set();
-  const once = function(message, payload) {
-    if (logged.has(message)) {
+  const once = function(message, payload, namespace) {
+    if (!logger.enabled || logged.has(message)) {
       return;
     }
     logged.add(message);
-    logFn.apply(null, [message, payload]);
+    logFn.apply(null, [message, payload, namespace]);
   };
   Object.defineProperty(logFn, "enabled", {
     get() {
@@ -181,6 +190,9 @@ function buildExtendedLogMessage(w) {
   }
   return parts.join("");
 }
+function isDebugNamespaceEnabled(namespace) {
+  return debug.enabled(`vite:${prefix}:${namespace}`);
+}
 
 // src/utils/error.ts
 function toRollupError(error, options) {
@@ -425,16 +437,48 @@ function addExtraPreprocessors(options, config) {
 
 // src/utils/sourcemaps.ts
 import path2 from "path";
-function mapSourcesToRelative(map, filename) {
-  if (map?.sources) {
-    map.sources = map.sources.map((s) => {
-      if (path2.isAbsolute(s)) {
-        const relative = path2.relative(filename, s);
-        return relative === "" ? path2.basename(filename) : relative;
-      } else {
-        return s;
-      }
-    });
+var IS_WINDOWS = process.platform === "win32";
+function mapToRelative(map, filename) {
+  if (!map) {
+    return;
+  }
+  const sourceRoot = map.sourceRoot;
+  const dirname2 = path2.dirname(filename);
+  const toRelative = (s) => {
+    if (!s) {
+      return s;
+    }
+    let sourcePath;
+    if (s.startsWith("file:///")) {
+      sourcePath = s.slice(IS_WINDOWS ? 8 : 7);
+    } else if (sourceRoot) {
+      const sep = sourceRoot[sourceRoot.length - 1] === "/" || s[0] === "/" ? "" : "/";
+      sourcePath = `${sourceRoot}${sep}${s}`;
+    } else {
+      sourcePath = s;
+    }
+    return path2.isAbsolute(sourcePath) ? path2.relative(dirname2, sourcePath) : sourcePath;
+  };
+  if (map.file) {
+    map.file = path2.basename(filename);
+  }
+  if (map.sources) {
+    map.sources = map.sources.map(toRelative);
+  }
+  if (map.sourceRoot) {
+    delete map.sourceRoot;
+  }
+}
+function removeLangSuffix(map, suffix) {
+  if (!map) {
+    return;
+  }
+  const removeSuffix = (s) => s?.endsWith(suffix) ? s.slice(0, -1 * suffix.length) : s;
+  if (map.file) {
+    map.file = removeSuffix(map.file);
+  }
+  if (map.sources) {
+    map.sources = map.sources.map(removeSuffix);
   }
 }
 
@@ -505,7 +549,7 @@ var _createCompileSvelte = (makeHot) => {
         compileOptions.sourcemap = preprocessed.map;
     }
     if (typeof preprocessed?.map === "object") {
-      mapSourcesToRelative(preprocessed?.map, filename);
+      mapToRelative(preprocessed?.map, filename);
     }
     if (raw && svelteRequest.query.type === "preprocessed") {
       return { preprocessed: preprocessed ?? { code } };
@@ -534,8 +578,8 @@ var _createCompileSvelte = (makeHot) => {
     if (endStat) {
       endStat();
     }
-    mapSourcesToRelative(compiled.js?.map, filename);
-    mapSourcesToRelative(compiled.css?.map, filename);
+    mapToRelative(compiled.js?.map, filename);
+    mapToRelative(compiled.css?.map, filename);
     if (!raw) {
       const hasCss = compiled.css?.code?.trim().length > 0;
       if (emitCss && hasCss) {
@@ -591,7 +635,7 @@ import { createFilter } from "vite";
 import { normalizePath } from "vite";
 import * as fs from "fs";
 var VITE_FS_PREFIX = "/@fs/";
-var IS_WINDOWS = process.platform === "win32";
+var IS_WINDOWS2 = process.platform === "win32";
 var SUPPORTED_COMPILER_OPTIONS = [
   "generate",
   "dev",
@@ -636,7 +680,7 @@ function createVirtualImportId(filename, root, type) {
   if (existsInRoot(filename, root)) {
     filename = root + filename;
   } else if (filename.startsWith(VITE_FS_PREFIX)) {
-    filename = IS_WINDOWS ? filename.slice(VITE_FS_PREFIX.length) : filename.slice(VITE_FS_PREFIX.length - 1);
+    filename = IS_WINDOWS2 ? filename.slice(VITE_FS_PREFIX.length) : filename.slice(VITE_FS_PREFIX.length - 1);
   }
   return `${filename}?${parts.join("&")}`;
 }
@@ -814,6 +858,7 @@ var SVELTE_HMR_IMPORTS = [
   "svelte-hmr"
 ];
 var SVELTE_EXPORT_CONDITIONS = ["svelte"];
+var FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE = "https://github.com/sveltejs/vite-plugin-svelte/blob/main/docs/faq.md#conflicts-in-svelte-resolve";
 
 // src/utils/options.ts
 import path5 from "path";
@@ -970,9 +1015,6 @@ function isCommonDepWithoutSvelteField(dependency) {
 }
 
 // src/utils/vite-plugin-svelte-stats.ts
-import { findClosestPkgJsonPath } from "vitefu";
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname } from "path";
 import { performance } from "perf_hooks";
 import { normalizePath as normalizePath2 } from "vite";
 var defaultCollectionOptions = {
@@ -1014,24 +1056,10 @@ function formatPackageStats(pkgStats) {
   ).join("\n");
   return table;
 }
-async function getClosestNamedPackage(file) {
-  let name = "$unknown";
-  let path10 = await findClosestPkgJsonPath(file, (pkgPath) => {
-    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
-    if (pkg.name != null) {
-      name = pkg.name;
-      return true;
-    }
-    return false;
-  });
-  path10 = normalizePath2(dirname(path10 ?? file)) + "/";
-  return { name, path: path10 };
-}
 var VitePluginSvelteStats = class {
-  constructor() {
-    // package directory -> package name
-    this._packages = [];
+  constructor(cache) {
     this._collections = [];
+    this._cache = cache;
   }
   startCollection(name, opts) {
     const options = {
@@ -1061,7 +1089,7 @@ var VitePluginSvelteStats = class {
           stats.push(stat);
           if (!hasLoggedProgress && options.logInProgress(collection, now)) {
             hasLoggedProgress = true;
-            log.info(`${name} in progress ...`);
+            log.debug(`${name} in progress ...`, void 0, "stats");
           }
         };
       },
@@ -1083,7 +1111,12 @@ var VitePluginSvelteStats = class {
       const logResult = collection.options.logResult(collection);
       if (logResult) {
         await this._aggregateStatsResult(collection);
-        log.info(`${collection.name} done.`, formatPackageStats(collection.packageStats));
+        log.debug(
+          `${collection.name} done.
+${formatPackageStats(collection.packageStats)}`,
+          void 0,
+          "stats"
+        );
       }
       const index = this._collections.indexOf(collection);
       this._collections.splice(index, 1);
@@ -1098,18 +1131,14 @@ var VitePluginSvelteStats = class {
       collection.finish = () => {
       };
     } catch (e) {
-      log.debug.once(`failed to finish stats for ${collection.name}`, e);
+      log.debug.once(`failed to finish stats for ${collection.name}
+`, e, "stats");
     }
   }
   async _aggregateStatsResult(collection) {
     const stats = collection.stats;
     for (const stat of stats) {
-      let pkg = this._packages.find((p) => stat.file.startsWith(p.path));
-      if (!pkg) {
-        pkg = await getClosestNamedPackage(stat.file);
-        this._packages.push(pkg);
-      }
-      stat.pkg = pkg.name;
+      stat.pkg = (await this._cache.getPackageInfo(stat.file)).name;
     }
     const grouped = {};
     stats.forEach((stat) => {
@@ -1252,7 +1281,7 @@ function mergeConfigs(...configs) {
   }
   return result;
 }
-function resolveOptions(preResolveOptions2, viteConfig) {
+function resolveOptions(preResolveOptions2, viteConfig, cache) {
   const css = preResolveOptions2.emitCss ? "external" : "injected";
   const defaultOptions = {
     hot: viteConfig.isProduction ? false : {
@@ -1275,11 +1304,8 @@ function resolveOptions(preResolveOptions2, viteConfig) {
   addExtraPreprocessors(merged, viteConfig);
   enforceOptionsForHmr(merged);
   enforceOptionsForProduction(merged);
-  const isLogLevelInfo = [void 0, "info"].includes(viteConfig.logLevel);
-  const disableCompileStats = merged.experimental?.disableCompileStats;
-  const statsEnabled = disableCompileStats !== true && disableCompileStats !== (merged.isBuild ? "build" : "dev");
-  if (statsEnabled && isLogLevelInfo) {
-    merged.stats = new VitePluginSvelteStats();
+  if (log.debug.enabled && isDebugNamespaceEnabled("stats")) {
+    merged.stats = new VitePluginSvelteStats(cache);
   }
   return merged;
 }
@@ -1649,6 +1675,7 @@ function ensureWatchedFile(watcher, file, root) {
 // src/utils/resolve.ts
 import path7 from "path";
 import { builtinModules } from "module";
+import { normalizePath as normalizePath4 } from "vite";
 async function resolveViaPackageJsonSvelte(importee, importer, cache) {
   if (importer && isBareImport(importee) && !isNodeInternal(importee) && !isCommonDepWithoutSvelteField(importee)) {
     const cached = cache.getResolvedSvelteField(importee, importer);
@@ -1659,7 +1686,7 @@ async function resolveViaPackageJsonSvelte(importee, importer, cache) {
     if (pkgData) {
       const { pkg, dir } = pkgData;
       if (pkg.svelte) {
-        const result = path7.resolve(dir, pkg.svelte);
+        const result = normalizePath4(path7.resolve(dir, pkg.svelte));
         cache.setResolvedSvelteField(importee, importer, result);
         return result;
       }
@@ -1719,19 +1746,19 @@ function generateSvelteMetadata(options) {
 }
 
 // src/ui/inspector/plugin.ts
-import { normalizePath as normalizePath4 } from "vite";
+import { normalizePath as normalizePath5 } from "vite";
 import path9 from "path";
 import { fileURLToPath } from "url";
 import fs6 from "fs";
 
 // src/ui/inspector/utils.ts
 var FS_PREFIX = `/@fs/`;
-var IS_WINDOWS2 = process.platform === "win32";
+var IS_WINDOWS3 = process.platform === "win32";
 var queryRE = /\?.*$/s;
 var hashRE = /#.*$/s;
 function idToFile(id) {
   if (id.startsWith(FS_PREFIX)) {
-    id = id = id.slice(IS_WINDOWS2 ? FS_PREFIX.length : FS_PREFIX.length - 1);
+    id = id = id.slice(IS_WINDOWS3 ? FS_PREFIX.length : FS_PREFIX.length - 1);
   }
   return id.replace(hashRE, "").replace(queryRE, "");
 }
@@ -1747,7 +1774,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = normalizePath4(path9.dirname(fileURLToPath(import.meta.url)));
+  const pluginPath = normalizePath5(path9.dirname(fileURLToPath(import.meta.url)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1837,6 +1864,10 @@ import 'virtual:svelte-inspector-path:load-inspector.js'` };
 }
 
 // src/utils/vite-plugin-svelte-cache.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { dirname } from "path";
+import { findClosestPkgJsonPath } from "vitefu";
+import { normalizePath as normalizePath6 } from "vite";
 var VitePluginSvelteCache = class {
   constructor() {
     this._css = /* @__PURE__ */ new Map();
@@ -1845,6 +1876,7 @@ var VitePluginSvelteCache = class {
     this._dependants = /* @__PURE__ */ new Map();
     this._resolvedSvelteFields = /* @__PURE__ */ new Map();
     this._errors = /* @__PURE__ */ new Map();
+    this._packageInfos = [];
   }
   update(compileData) {
     this._errors.delete(compileData.normalizedFilename);
@@ -1930,6 +1962,9 @@ var VitePluginSvelteCache = class {
   getResolvedSvelteField(name, importer) {
     return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
   }
+  hasResolvedSvelteField(name, importer) {
+    return this._resolvedSvelteFields.has(this._getResolvedSvelteFieldKey(name, importer));
+  }
   setResolvedSvelteField(importee, importer = void 0, resolvedSvelte) {
     this._resolvedSvelteFields.set(
       this._getResolvedSvelteFieldKey(importee, importer),
@@ -1939,7 +1974,37 @@ var VitePluginSvelteCache = class {
   _getResolvedSvelteFieldKey(importee, importer) {
     return importer ? `${importer} > ${importee}` : importee;
   }
+  async getPackageInfo(file) {
+    let info = this._packageInfos.find((pi) => file.startsWith(pi.path));
+    if (!info) {
+      info = await findPackageInfo(file);
+      this._packageInfos.push(info);
+    }
+    return info;
+  }
 };
+async function findPackageInfo(file) {
+  const info = {
+    name: "$unknown",
+    version: "0.0.0-unknown",
+    path: "$unknown"
+  };
+  let path10 = await findClosestPkgJsonPath(file, (pkgPath) => {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    if (pkg.name != null) {
+      info.name = pkg.name;
+      if (pkg.version != null) {
+        info.version = pkg.version;
+      }
+      info.svelte = pkg.svelte;
+      return true;
+    }
+    return false;
+  });
+  path10 = normalizePath6(dirname(path10 ?? file)) + "/";
+  info.path = path10;
+  return info;
+}
 
 // src/utils/load-raw.ts
 import fs7 from "fs";
@@ -2037,6 +2102,7 @@ function toRawExports(object) {
 import { preprocessCSS, resolveConfig, transformWithEsbuild } from "vite";
 var supportedStyleLangs = ["css", "less", "sass", "scss", "styl", "stylus", "postcss", "sss"];
 var supportedScriptLangs = ["ts"];
+var lang_sep = ".vite-preprocess.";
 function vitePreprocess(opts) {
   const preprocessor = {};
   if (opts?.script !== false) {
@@ -2065,7 +2131,7 @@ function viteScript() {
           }
         }
       });
-      mapSourcesToRelative(map, filename);
+      mapToRelative(map, filename);
       return {
         code,
         map
@@ -2093,12 +2159,16 @@ function viteStyle(config = {}) {
       }
       transform = getCssTransformFn(resolvedConfig);
     }
-    const moduleId = `${filename}.${lang}`;
-    const { code, map } = await transform(content, moduleId);
-    mapSourcesToRelative(map, moduleId);
+    const suffix = `${lang_sep}${lang}`;
+    const moduleId = `${filename}${suffix}`;
+    const { code, map, deps } = await transform(content, moduleId);
+    removeLangSuffix(map, suffix);
+    mapToRelative(map, filename);
+    const dependencies = deps ? Array.from(deps).filter((d) => !d.endsWith(suffix)) : void 0;
     return {
       code,
-      map: map ?? void 0
+      map: map ?? void 0,
+      dependencies
     };
   };
   style.__resolvedConfig = null;
@@ -2114,6 +2184,8 @@ function isResolvedConfig(config) {
 }
 
 // src/index.ts
+var isVite4_0 = viteVersion.startsWith("4.0");
+var isSvelte3 = svelteVersion.startsWith("3");
 function svelte(inlineOptions) {
   if (process.env.DEBUG != null) {
     log.setLevel("debug");
@@ -2125,6 +2197,7 @@ function svelte(inlineOptions) {
   let viteConfig;
   let compileSvelte2;
   let resolvedSvelteSSR;
+  let packagesWithResolveWarnings;
   const api = {};
   const plugins = [
     {
@@ -2144,7 +2217,7 @@ function svelte(inlineOptions) {
         return extraViteConfig;
       },
       async configResolved(config) {
-        options = resolveOptions(options, config);
+        options = resolveOptions(options, config, cache);
         patchResolvedViteConfig(config, options);
         requestParser = buildIdParser(options);
         compileSvelte2 = createCompileSvelte(options);
@@ -2153,6 +2226,7 @@ function svelte(inlineOptions) {
         log.debug("resolved options", options);
       },
       async buildStart() {
+        packagesWithResolveWarnings = /* @__PURE__ */ new Set();
         if (!options.prebundleSvelteLibraries)
           return;
         const isSvelteMetadataChanged = await saveSvelteMetadata(viteConfig.cacheDir, options);
@@ -2195,7 +2269,7 @@ function svelte(inlineOptions) {
             return svelteRequest.cssId;
           }
         }
-        if (ssr && importee === "svelte") {
+        if (isVite4_0 && isSvelte3 && ssr && importee === "svelte") {
           if (!resolvedSvelteSSR) {
             resolvedSvelteSSR = this.resolve("svelte/ssr", void 0, { skipSelf: true }).then(
               (svelteSSR) => {
@@ -2217,13 +2291,31 @@ function svelte(inlineOptions) {
         const isPrebundled = options.prebundleSvelteLibraries && viteConfig.optimizeDeps?.disabled !== true && viteConfig.optimizeDeps?.disabled !== (options.isBuild ? "build" : "dev") && !isDepExcluded2(importee, viteConfig.optimizeDeps?.exclude ?? []);
         if (ssr || scan || !isPrebundled) {
           try {
+            const isFirstResolve = !cache.hasResolvedSvelteField(importee, importer);
             const resolved = await resolveViaPackageJsonSvelte(importee, importer, cache);
-            if (resolved) {
-              log.debug(
-                `resolveId resolved ${resolved} via package.json svelte field of ${importee}`
+            if (isFirstResolve && resolved) {
+              const packageInfo = await cache.getPackageInfo(resolved);
+              const packageVersion = `${packageInfo.name}@${packageInfo.version}`;
+              log.debug.once(
+                `resolveId resolved ${importee} to ${resolved} via package.json svelte field of ${packageVersion}`
               );
-              return resolved;
+              try {
+                const viteResolved = (await this.resolve(importee, importer, { ...opts, skipSelf: true }))?.id;
+                if (resolved !== viteResolved) {
+                  packagesWithResolveWarnings.add(packageVersion);
+                  log.debug.enabled && log.debug.once(
+                    `resolve difference for ${packageVersion} ${importee} - svelte: "${resolved}", vite: "${viteResolved}"`
+                  );
+                }
+              } catch (e) {
+                packagesWithResolveWarnings.add(packageVersion);
+                log.debug.enabled && log.debug.once(
+                  `resolve error for ${packageVersion} ${importee} - svelte: "${resolved}", vite: ERROR`,
+                  e
+                );
+              }
             }
+            return resolved;
           } catch (e) {
             log.debug.once(
               `error trying to resolve ${importee} from ${importer} via package.json svelte field `,
@@ -2273,6 +2365,17 @@ function svelte(inlineOptions) {
       },
       async buildEnd() {
         await options.stats?.finishAll();
+        if (!options.experimental?.disableSvelteResolveWarnings && packagesWithResolveWarnings?.size > 0) {
+          log.warn(
+            `WARNING: The following packages use a svelte resolve configuration in package.json that has conflicting results and is going to cause problems future.
+
+${[
+              ...packagesWithResolveWarnings
+            ].join("\n")}
+
+Please see ${FAQ_LINK_CONFLICTS_IN_SVELTE_RESOLVE} for details.`
+          );
+        }
       }
     }
   ];