@sveltejs/vite-plugin-svelte 1.0.0-next.33 → 1.0.0-next.37

package/dist/index.js

@@ -89,7 +89,7 @@ function _log(logger, message, payload) {
 function createLogger(level) {
   const logger = loggers[level];
   const logFn = _log.bind(null, logger);
-  const logged = new Set();
+  const logged = /* @__PURE__ */ new Set();
   const once = function(message, payload) {
     if (logged.has(message)) {
       return;
@@ -164,7 +164,10 @@ function buildExtendedLogMessage(w) {
     parts.push(":", w.start.line, ":", w.start.column);
   }
   if (w.message) {
-    parts.push(" ", w.message);
+    if (parts.length > 0) {
+      parts.push(" ");
+    }
+    parts.push(w.message);
   }
   return parts.join("");
 }
@@ -181,7 +184,7 @@ async function handleHotUpdate(compileSvelte2, ctx, svelteRequest, cache, option
   const content = await read();
   const compileData = await compileSvelte2(svelteRequest, content, options);
   cache.update(compileData);
-  const affectedModules = new Set();
+  const affectedModules = /* @__PURE__ */ new Set();
   const cssModule = server.moduleGraph.getModuleById(svelteRequest.cssId);
   const mainModule = server.moduleGraph.getModuleById(svelteRequest.id);
   const cssUpdated = cssModule && cssChanged(cachedCss, compileData.compiled.css);
@@ -245,16 +248,14 @@ import { compile, preprocess, walk } from "svelte/compiler";
 import { createMakeHot } from "svelte-hmr";
 
 // src/utils/hash.ts
-import {
-  createHash
-} from "crypto";
-var hashes = Object.create(null);
+import * as crypto from "crypto";
+var hashes = /* @__PURE__ */ Object.create(null);
 var hash_length = 12;
 function safeBase64Hash(input) {
   if (hashes[input]) {
     return hashes[input];
   }
-  const md5 = createHash("md5");
+  const md5 = crypto.createHash("md5");
   md5.update(input);
   const hash = toSafe(md5.digest("base64")).substr(0, hash_length);
   hashes[input] = hash;
@@ -294,7 +295,12 @@ var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequ
   }
   let preprocessed;
   if (options.preprocess) {
-    preprocessed = await preprocess(code, options.preprocess, { filename });
+    try {
+      preprocessed = await preprocess(code, options.preprocess, { filename });
+    } catch (e) {
+      e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
+      throw e;
+    }
     if (preprocessed.dependencies)
       dependencies.push(...preprocessed.dependencies);
     if (preprocessed.map)
@@ -357,9 +363,7 @@ function createCompileSvelte(options) {
 // src/utils/id.ts
 import { createFilter } from "@rollup/pluginutils";
 import { normalizePath } from "vite";
-import {
-  existsSync
-} from "fs";
+import * as fs from "fs";
 var VITE_FS_PREFIX = "/@fs/";
 var IS_WINDOWS = process.platform === "win32";
 function splitId(id) {
@@ -413,7 +417,7 @@ function existsInRoot(filename, root) {
   if (filename.startsWith(VITE_FS_PREFIX)) {
     return false;
   }
-  return existsSync(root + filename);
+  return fs.existsSync(root + filename);
 }
 function stripRoot(normalizedFilename, normalizedRoot) {
   return normalizedFilename.startsWith(normalizedRoot + "/") ? normalizedFilename.slice(normalizedRoot.length) : normalizedFilename;
@@ -562,7 +566,7 @@ function findRootSvelteDependencies(root, cwdFallback = true) {
   ].filter((dep) => !is_common_without_svelte_field(dep));
   return getSvelteDependencies(deps, root);
 }
-function getSvelteDependencies(deps, pkgDir, path6 = []) {
+function getSvelteDependencies(deps, pkgDir, path7 = []) {
   const result = [];
   const localRequire = createRequire2(`${pkgDir}/package.json`);
   const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
@@ -570,18 +574,18 @@ function getSvelteDependencies(deps, pkgDir, path6 = []) {
     const type = getSvelteDependencyType(pkg);
     if (!type)
       continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path6 });
+    result.push({ name: pkg.name, type, pkg, dir, path: path7 });
     if (type === "component-library" && pkg.dependencies) {
       let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path6.includes(name));
+      const circular = dependencyNames.filter((name) => path7.includes(name));
       if (circular.length > 0) {
-        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path6.concat(x).join(">")));
-        dependencyNames = dependencyNames.filter((name) => !path6.includes(name));
+        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));
       }
-      if (path6.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path6.join(">")}`);
+      if (path7.length === 3) {
+        log.debug.once(`encountered deep svelte dependency tree: ${path7.join(">")}`);
       }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path6.concat(pkg.name)));
+      result.push(...getSvelteDependencies(dependencyNames, dir, path7.concat(pkg.name)));
     }
   }
   return result;
@@ -695,15 +699,15 @@ import { promises as fs4 } from "fs";
 import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
 
 // src/utils/error.ts
-function toRollupError(error) {
-  const { filename, frame, start, code, name } = error;
+function toRollupError(error, options) {
+  const { filename, frame, start, code, name, stack } = error;
   const rollupError = {
     name,
     id: filename,
     message: buildExtendedLogMessage(error),
     frame: formatFrameForVite(frame),
     code,
-    stack: ""
+    stack: options.isBuild || options.isDebug || !frame ? stack : ""
   };
   if (start) {
     rollupError.loc = {
@@ -714,8 +718,8 @@ function toRollupError(error) {
   }
   return rollupError;
 }
-function toESBuildError(error) {
-  const { filename, frame, start } = error;
+function toESBuildError(error, options) {
+  const { filename, frame, start, stack } = error;
   const partialMessage = {
     text: buildExtendedLogMessage(error)
   };
@@ -727,6 +731,9 @@ function toESBuildError(error) {
       lineText: lineFromFrame(start.line, frame)
     };
   }
+  if (options.isBuild || options.isDebug || !frame) {
+    partialMessage.detail = stack;
+  }
   return partialMessage;
 }
 function lineFromFrame(lineNo, frame) {
@@ -759,7 +766,7 @@ function esbuildSveltePlugin(options) {
           const contents = await compileSvelte(options, { filename, code });
           return { contents };
         } catch (e) {
-          return { errors: [toESBuildError(e)] };
+          return { errors: [toESBuildError(e, options)] };
         }
       });
     }
@@ -792,7 +799,12 @@ async function compileSvelte(options, { filename, code }) {
   });
   let preprocessed;
   if (options.preprocess) {
-    preprocessed = await preprocess2(code, options.preprocess, { filename });
+    try {
+      preprocessed = await preprocess2(code, options.preprocess, { filename });
+    } catch (e) {
+      e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
+      throw e;
+    }
     if (preprocessed.map)
       compileOptions.sourcemap = preprocessed.map;
   }
@@ -875,7 +887,8 @@ function createViteScriptPreprocessor() {
       loader: lang,
       tsconfigRaw: {
         compilerOptions: {
-          importsNotUsedAsValues: "preserve"
+          importsNotUsedAsValues: "preserve",
+          preserveValueImports: true
         }
       }
     });
@@ -1039,7 +1052,7 @@ function validateSourceMapOutputWrapper(group, i) {
 }
 
 // src/utils/options.ts
-var knownOptions = new Set([
+var knownOptions = /* @__PURE__ */ new Set([
   "configFile",
   "include",
   "exclude",
@@ -1076,7 +1089,8 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
     experimental: __spreadValues(__spreadValues(__spreadValues({}, defaultOptions == null ? void 0 : defaultOptions.experimental), svelteConfig == null ? void 0 : svelteConfig.experimental), inlineOptions == null ? void 0 : inlineOptions.experimental),
     root: viteConfigWithResolvedRoot.root,
     isBuild: viteEnv.command === "build",
-    isServe: viteEnv.command === "serve"
+    isServe: viteEnv.command === "serve",
+    isDebug: process.env.DEBUG != null
   });
   if (svelteConfig == null ? void 0 : svelteConfig.configFile) {
     merged.configFile = svelteConfig.configFile;
@@ -1093,6 +1107,7 @@ function resolveOptions(preResolveOptions2, viteConfig) {
   };
   const merged = __spreadProps(__spreadValues(__spreadValues({}, defaultOptions), preResolveOptions2), {
     compilerOptions: __spreadValues(__spreadValues({}, defaultOptions.compilerOptions), preResolveOptions2.compilerOptions),
+    root: viteConfig.root,
     isProduction: viteConfig.isProduction
   });
   addExtraPreprocessors(merged, viteConfig);
@@ -1160,16 +1175,16 @@ function buildExtraViteConfig(options, config, configEnv) {
   extraViteConfig.ssr = buildSSROptionsForSvelte(svelteDeps, options, config);
   return extraViteConfig;
 }
-function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps) {
+function buildOptimizeDepsForSvelte(svelteDeps, options, optimizeDeps2) {
   const include = [];
   const exclude = ["svelte-hmr"];
   const isIncluded = (dep) => {
     var _a;
-    return include.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.include) == null ? void 0 : _a.includes(dep));
+    return include.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.include) == null ? void 0 : _a.includes(dep));
   };
   const isExcluded = (dep) => {
     var _a;
-    return exclude.includes(dep) || ((_a = optimizeDeps == null ? void 0 : optimizeDeps.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
+    return exclude.includes(dep) || ((_a = optimizeDeps2 == null ? void 0 : optimizeDeps2.exclude) == null ? void 0 : _a.some((id) => dep === id || id.startsWith(`${dep}/`)));
   };
   if (!isExcluded("svelte")) {
     const svelteImportsToInclude = SVELTE_IMPORTS.filter((x) => x !== "svelte/ssr");
@@ -1235,10 +1250,11 @@ function patchResolvedViteConfig(viteConfig, options) {
 // src/utils/vite-plugin-svelte-cache.ts
 var VitePluginSvelteCache = class {
   constructor() {
-    this._css = new Map();
-    this._js = new Map();
-    this._dependencies = new Map();
-    this._dependants = new Map();
+    this._css = /* @__PURE__ */ new Map();
+    this._js = /* @__PURE__ */ new Map();
+    this._dependencies = /* @__PURE__ */ new Map();
+    this._dependants = /* @__PURE__ */ new Map();
+    this._resolvedSvelteFields = /* @__PURE__ */ new Map();
   }
   update(compileData) {
     this.updateCSS(compileData);
@@ -1262,7 +1278,7 @@ var VitePluginSvelteCache = class {
     const added = dependencies.filter((d) => !prevDependencies.includes(d));
     added.forEach((d) => {
       if (!this._dependants.has(d)) {
-        this._dependants.set(d, new Set());
+        this._dependants.set(d, /* @__PURE__ */ new Set());
       }
       this._dependants.get(d).add(compileData.filename);
     });
@@ -1300,10 +1316,19 @@ var VitePluginSvelteCache = class {
       return this._js.get(svelteRequest.normalizedFilename);
     }
   }
-  getDependants(path6) {
-    const dependants = this._dependants.get(path6);
+  getDependants(path7) {
+    const dependants = this._dependants.get(path7);
     return dependants ? [...dependants] : [];
   }
+  getResolvedSvelteField(name, importer) {
+    return this._resolvedSvelteFields.get(this._getResolvedSvelteFieldKey(name, importer));
+  }
+  setResolvedSvelteField(importee, importer = void 0, resolvedSvelte) {
+    this._resolvedSvelteFields.set(this._getResolvedSvelteFieldKey(importee, importer), resolvedSvelte);
+  }
+  _getResolvedSvelteFieldKey(importee, importer) {
+    return importer ? `${importer} > ${importee}` : importee;
+  }
 };
 
 // src/utils/watch.ts
@@ -1335,7 +1360,6 @@ function setupWatchers(options, cache, requestParser) {
     }
   };
   const triggerViteRestart = (filename) => {
-    var _a;
     if (serverConfig.middlewareMode) {
       const message = "Svelte config change detected, restart your dev process to apply the changes.";
       log.info(message, filename);
@@ -1345,7 +1369,7 @@ function setupWatchers(options, cache, requestParser) {
       });
     } else {
       log.info(`svelte config changed: restarting vite server. - file: ${filename}`);
-      server.restart(!!((_a = options.experimental) == null ? void 0 : _a.prebundleSvelteLibraries));
+      server.restart();
     }
   };
   const possibleSvelteConfigs = knownSvelteConfigNames.map((cfg) => path4.join(root, cfg));
@@ -1384,17 +1408,30 @@ function ensureWatchedFile(watcher, file, root) {
 
 // src/utils/resolve.ts
 import path5 from "path";
-import fs6 from "fs";
-import relative from "require-relative";
-function resolveViaPackageJsonSvelte(importee, importer) {
-  if (importer && isBareImport(importee)) {
-    const importeePkgFile = relative.resolve(`${importee}/package.json`, path5.dirname(importer));
-    const importeePkg = JSON.parse(fs6.readFileSync(importeePkgFile, { encoding: "utf-8" }));
-    if (importeePkg.svelte) {
-      return path5.resolve(path5.dirname(importeePkgFile), importeePkg.svelte);
+import { builtinModules, createRequire as createRequire4 } from "module";
+function resolveViaPackageJsonSvelte(importee, importer, cache) {
+  if (importer && isBareImport(importee) && !isNodeInternal(importee) && !is_common_without_svelte_field(importee)) {
+    const cached = cache.getResolvedSvelteField(importee, importer);
+    if (cached) {
+      return cached;
+    }
+    const localRequire = createRequire4(importer);
+    const pkgData = resolveDependencyData(importee, localRequire);
+    if (pkgData) {
+      const { pkg, dir } = pkgData;
+      if (pkg.svelte) {
+        const result = path5.resolve(dir, pkg.svelte);
+        cache.setResolvedSvelteField(importee, importer, result);
+        return result;
+      }
+    } else {
+      throw new Error(`failed to resolve package.json of ${importee} imported by ${importer}`);
     }
   }
 }
+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)) {
     return false;
@@ -1410,6 +1447,44 @@ function isBareImport(importee) {
   }
 }
 
+// src/utils/optimizer.ts
+import fs6 from "fs";
+import path6 from "path";
+import { optimizeDeps } from "vite";
+var PREBUNDLE_SENSITIVE_OPTIONS = [
+  "compilerOptions",
+  "configFile",
+  "experimental",
+  "extensions",
+  "ignorePluginPreprocessors",
+  "preprocess"
+];
+async function handleOptimizeDeps(options, viteConfig) {
+  if (!options.experimental.prebundleSvelteLibraries || !viteConfig.cacheDir)
+    return;
+  const viteMetadataPath = path6.resolve(viteConfig.cacheDir, "_metadata.json");
+  if (!fs6.existsSync(viteMetadataPath))
+    return;
+  const svelteMetadataPath = path6.resolve(viteConfig.cacheDir, "_svelte_metadata.json");
+  const currentSvelteMetadata = JSON.stringify(generateSvelteMetadata(options), (_, value) => {
+    return typeof value === "function" ? value.toString() : value;
+  });
+  if (fs6.existsSync(svelteMetadataPath)) {
+    const existingSvelteMetadata = fs6.readFileSync(svelteMetadataPath, "utf8");
+    if (existingSvelteMetadata === currentSvelteMetadata)
+      return;
+  }
+  await optimizeDeps(viteConfig, true);
+  fs6.writeFileSync(svelteMetadataPath, currentSvelteMetadata);
+}
+function generateSvelteMetadata(options) {
+  const metadata = {};
+  for (const key of PREBUNDLE_SENSITIVE_OPTIONS) {
+    metadata[key] = options[key];
+  }
+  return metadata;
+}
+
 // src/index.ts
 function svelte(inlineOptions) {
   if (process.env.DEBUG != null) {
@@ -1417,7 +1492,7 @@ function svelte(inlineOptions) {
   }
   validateInlineOptions(inlineOptions);
   const cache = new VitePluginSvelteCache();
-  const pkg_export_errors = new Set();
+  const pkg_resolve_errors = /* @__PURE__ */ new Set();
   let requestParser;
   let options;
   let viteConfig;
@@ -1445,6 +1520,9 @@ function svelte(inlineOptions) {
       viteConfig = config;
       log.debug("resolved options", options);
     },
+    async buildStart() {
+      await handleOptimizeDeps(options, viteConfig);
+    },
     configureServer(server) {
       options.server = server;
       setupWatchers(options, cache, requestParser);
@@ -1491,21 +1569,13 @@ function svelte(inlineOptions) {
         return resolvedSvelteSSR;
       }
       try {
-        const resolved = resolveViaPackageJsonSvelte(importee, importer);
+        const resolved = resolveViaPackageJsonSvelte(importee, importer, cache);
         if (resolved) {
           log.debug(`resolveId resolved ${resolved} via package.json svelte field of ${importee}`);
           return resolved;
         }
       } catch (err) {
-        switch (err.code) {
-          case "ERR_PACKAGE_PATH_NOT_EXPORTED":
-            pkg_export_errors.add(importee);
-            return null;
-          case "MODULE_NOT_FOUND":
-            return null;
-          default:
-            throw err;
-        }
+        pkg_resolve_errors.add(importee);
       }
     },
     async transform(code, id, opts) {
@@ -1531,7 +1601,7 @@ function svelte(inlineOptions) {
       try {
         compileData = await compileSvelte2(svelteRequest, code, options);
       } catch (e) {
-        throw toRollupError(e);
+        throw toRollupError(e, options);
       }
       logCompilerWarnings(compileData.compiled.warnings, options);
       cache.update(compileData);
@@ -1553,8 +1623,10 @@ function svelte(inlineOptions) {
       }
     },
     buildEnd() {
-      if (pkg_export_errors.size > 0) {
-        log.warn(`The following packages did not export their \`package.json\` file so we could not check the "svelte" field. If you had difficulties importing svelte components from a package, then please contact the author and ask them to export the package.json file.`, Array.from(pkg_export_errors, (s) => `- ${s}`).join("\n"));
+      if (pkg_resolve_errors.size > 0) {
+        log.warn(`vite-plugin-svelte was unable to find package.json of the following packages and wasn't able to resolve via their "svelte" field.
+					If you had difficulties importing svelte components from a package, then please contact the author and ask them to export the package.json file.
+					${Array.from(pkg_resolve_errors, (s) => `- ${s}`).join("\n")}`.replace(/\t/g, ""));
       }
     }
   };