@sveltejs/vite-plugin-svelte 1.2.0 → 1.3.1

package/dist/index.js

@@ -7,7 +7,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import fs8 from "fs";
+import fs7 from "fs";
 import { isDepExcluded as isDepExcluded2 } from "vitefu";
 
 // src/utils/log.ts
@@ -289,81 +289,105 @@ function toSafe(base64) {
 
 // src/utils/compile.ts
 var scriptLangRE = /<script [^>]*lang=["']?([^"' >]+)["']?[^>]*>/;
-var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequest, code, options) {
-  const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
-  const { emitCss = true } = options;
-  const dependencies = [];
-  const compileOptions = {
-    ...options.compilerOptions,
-    filename,
-    generate: ssr ? "ssr" : "dom",
-    format: "esm"
-  };
-  if (options.hot && options.emitCss) {
-    const hash = `s-${safeBase64Hash(normalizedFilename)}`;
-    log.debug(`setting cssHash ${hash} for ${normalizedFilename}`);
-    compileOptions.cssHash = () => hash;
-  }
-  if (ssr && compileOptions.enableSourcemap !== false) {
-    if (typeof compileOptions.enableSourcemap === "object") {
-      compileOptions.enableSourcemap.css = false;
-    } else {
-      compileOptions.enableSourcemap = { js: true, css: false };
+var _createCompileSvelte = (makeHot) => {
+  let stats;
+  return async function compileSvelte2(svelteRequest, code, options) {
+    const { filename, normalizedFilename, cssId, ssr } = svelteRequest;
+    const { emitCss = true } = options;
+    const dependencies = [];
+    if (options.stats) {
+      if (options.isBuild) {
+        if (!stats) {
+          stats = options.stats.startCollection(`${ssr ? "ssr" : "dom"} compile`, {
+            logInProgress: () => false
+          });
+        }
+      } else {
+        if (ssr && !stats) {
+          stats = options.stats.startCollection("ssr compile");
+        }
+        if (!ssr && stats) {
+          stats.finish();
+          stats = void 0;
+        }
+      }
     }
-  }
-  let preprocessed;
-  if (options.preprocess) {
-    try {
-      preprocessed = await preprocess(code, options.preprocess, { filename });
-    } catch (e) {
-      e.message = `Error while preprocessing ${filename}${e.message ? ` - ${e.message}` : ""}`;
-      throw e;
+    const compileOptions = {
+      ...options.compilerOptions,
+      filename,
+      generate: ssr ? "ssr" : "dom",
+      format: "esm"
+    };
+    if (options.hot && options.emitCss) {
+      const hash = `s-${safeBase64Hash(normalizedFilename)}`;
+      log.debug(`setting cssHash ${hash} for ${normalizedFilename}`);
+      compileOptions.cssHash = () => hash;
     }
-    if (preprocessed.dependencies)
-      dependencies.push(...preprocessed.dependencies);
-    if (preprocessed.map)
-      compileOptions.sourcemap = preprocessed.map;
-  }
-  const finalCode = preprocessed ? preprocessed.code : code;
-  const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
-    filename,
-    code: finalCode,
-    compileOptions
-  });
-  if (dynamicCompileOptions && log.debug.enabled) {
-    log.debug(
-      `dynamic compile options for  ${filename}: ${JSON.stringify(dynamicCompileOptions)}`
-    );
-  }
-  const finalCompileOptions = dynamicCompileOptions ? {
-    ...compileOptions,
-    ...dynamicCompileOptions
-  } : compileOptions;
-  const compiled = compile(finalCode, finalCompileOptions);
-  const hasCss = compiled.css?.code?.trim().length > 0;
-  if (emitCss && hasCss) {
-    compiled.js.code += `
+    if (ssr && compileOptions.enableSourcemap !== false) {
+      if (typeof compileOptions.enableSourcemap === "object") {
+        compileOptions.enableSourcemap.css = false;
+      } else {
+        compileOptions.enableSourcemap = { js: true, css: false };
+      }
+    }
+    let preprocessed;
+    if (options.preprocess) {
+      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)
+        compileOptions.sourcemap = preprocessed.map;
+    }
+    const finalCode = preprocessed ? preprocessed.code : code;
+    const dynamicCompileOptions = await options.experimental?.dynamicCompileOptions?.({
+      filename,
+      code: finalCode,
+      compileOptions
+    });
+    if (dynamicCompileOptions && log.debug.enabled) {
+      log.debug(
+        `dynamic compile options for  ${filename}: ${JSON.stringify(dynamicCompileOptions)}`
+      );
+    }
+    const finalCompileOptions = dynamicCompileOptions ? {
+      ...compileOptions,
+      ...dynamicCompileOptions
+    } : compileOptions;
+    const endStat = stats?.start(filename);
+    const compiled = compile(finalCode, finalCompileOptions);
+    if (endStat) {
+      endStat();
+    }
+    const hasCss = compiled.css?.code?.trim().length > 0;
+    if (emitCss && hasCss) {
+      compiled.js.code += `
 import ${JSON.stringify(cssId)};
 `;
-  }
-  if (!ssr && makeHot) {
-    compiled.js.code = makeHot({
-      id: filename,
-      compiledCode: compiled.js.code,
-      hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
+    }
+    if (!ssr && makeHot) {
+      compiled.js.code = makeHot({
+        id: filename,
+        compiledCode: compiled.js.code,
+        hotOptions: { ...options.hot, injectCss: options.hot?.injectCss === true && hasCss },
+        compiled,
+        originalCode: code,
+        compileOptions: finalCompileOptions
+      });
+    }
+    compiled.js.dependencies = dependencies;
+    return {
+      filename,
+      normalizedFilename,
+      lang: code.match(scriptLangRE)?.[1] || "js",
       compiled,
-      originalCode: code,
-      compileOptions: finalCompileOptions
-    });
-  }
-  compiled.js.dependencies = dependencies;
-  return {
-    filename,
-    normalizedFilename,
-    lang: code.match(scriptLangRE)?.[1] || "js",
-    compiled,
-    ssr,
-    dependencies
+      ssr,
+      dependencies
+    };
   };
 };
 function buildMakeHot(options) {
@@ -463,7 +487,7 @@ function buildIdParser(options) {
 }
 
 // src/utils/options.ts
-import { normalizePath as normalizePath2 } from "vite";
+import { normalizePath as normalizePath3 } from "vite";
 
 // src/utils/load-svelte-config.ts
 import { createRequire } from "module";
@@ -571,12 +595,13 @@ var SVELTE_HMR_IMPORTS = [
   "svelte-hmr/runtime/proxy-adapter-dom.js",
   "svelte-hmr"
 ];
+var SVELTE_EXPORT_CONDITIONS = ["svelte"];
 
 // src/utils/options.ts
 import path4 from "path";
 
 // src/utils/esbuild.ts
-import { promises as fs3 } from "fs";
+import { readFileSync } from "fs";
 import { compile as compile2, preprocess as preprocess2 } from "svelte/compiler";
 
 // src/utils/error.ts
@@ -673,19 +698,28 @@ function esbuildSveltePlugin(options) {
         return;
       const svelteExtensions = (options.extensions ?? [".svelte"]).map((ext) => ext.slice(1));
       const svelteFilter = new RegExp(`\\.(` + svelteExtensions.join("|") + `)(\\?.*)?$`);
+      let statsCollection;
+      build.onStart(() => {
+        statsCollection = options.stats?.startCollection("prebundle libraries", {
+          logResult: (c) => c.stats.length > 1
+        });
+      });
       build.onLoad({ filter: svelteFilter }, async ({ path: filename }) => {
-        const code = await fs3.readFile(filename, "utf8");
+        const code = readFileSync(filename, "utf8");
         try {
-          const contents = await compileSvelte(options, { filename, code });
+          const contents = await compileSvelte(options, { filename, code }, statsCollection);
           return { contents };
         } catch (e) {
           return { errors: [toESBuildError(e, options)] };
         }
       });
+      build.onEnd(() => {
+        statsCollection?.finish();
+      });
     }
   };
 }
-async function compileSvelte(options, { filename, code }) {
+async function compileSvelte(options, { filename, code }, statsCollection) {
   let css = options.compilerOptions.css;
   if (css !== "none") {
     css = isCssString ? "injected" : true;
@@ -721,7 +755,11 @@ async function compileSvelte(options, { filename, code }) {
     ...compileOptions,
     ...dynamicCompileOptions
   } : compileOptions;
+  const endStat = statsCollection?.start(filename);
   const compiled = compile2(finalCode, finalCompileOptions);
+  if (endStat) {
+    endStat();
+  }
   return compiled.js.code + "//# sourceMappingURL=" + compiled.js.map.toUrl();
 }
 
@@ -993,7 +1031,7 @@ import {
 
 // src/utils/dependencies.ts
 import path3 from "path";
-import fs4 from "fs/promises";
+import fs3 from "fs/promises";
 import { findDepPkgJsonPath } from "vitefu";
 async function resolveDependencyData(dep, parent) {
   const depDataPath = await findDepPkgJsonPath(dep, parent);
@@ -1002,7 +1040,7 @@ async function resolveDependencyData(dep, parent) {
   try {
     return {
       dir: path3.dirname(depDataPath),
-      pkg: JSON.parse(await fs4.readFile(depDataPath, "utf-8"))
+      pkg: JSON.parse(await fs3.readFile(depDataPath, "utf-8"))
     };
   } catch {
     return void 0;
@@ -1053,6 +1091,165 @@ 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 = {
+  logInProgress: (c, now) => now - c.collectionStart > 500 && c.stats.length > 1,
+  logResult: () => true
+};
+function humanDuration(n) {
+  return n < 100 ? `${n.toFixed(1)}ms` : `${(n / 1e3).toFixed(2)}s`;
+}
+function formatPackageStats(pkgStats) {
+  const statLines = pkgStats.map((pkgStat) => {
+    const duration = pkgStat.duration;
+    const avg = duration / pkgStat.files;
+    return [pkgStat.pkg, `${pkgStat.files}`, humanDuration(duration), humanDuration(avg)];
+  });
+  statLines.unshift(["package", "files", "time", "avg"]);
+  const columnWidths = statLines.reduce(
+    (widths, row) => {
+      for (let i = 0; i < row.length; i++) {
+        const cell = row[i];
+        if (widths[i] < cell.length) {
+          widths[i] = cell.length;
+        }
+      }
+      return widths;
+    },
+    statLines[0].map(() => 0)
+  );
+  const table = statLines.map(
+    (row) => row.map((cell, i) => {
+      if (i === 0) {
+        return cell.padEnd(columnWidths[i], " ");
+      } else {
+        return cell.padStart(columnWidths[i], " ");
+      }
+    }).join("	")
+  ).join("\n");
+  return table;
+}
+async function getClosestNamedPackage(file) {
+  let name = "$unknown";
+  let path9 = await findClosestPkgJsonPath(file, (pkgPath) => {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    if (pkg.name != null) {
+      name = pkg.name;
+      return true;
+    }
+    return false;
+  });
+  path9 = normalizePath2(dirname(path9 ?? file)) + "/";
+  return { name, path: path9 };
+}
+var VitePluginSvelteStats = class {
+  constructor() {
+    this._packages = [];
+    this._collections = [];
+  }
+  startCollection(name, opts) {
+    const options = {
+      ...defaultCollectionOptions,
+      ...opts
+    };
+    const stats = [];
+    const collectionStart = performance.now();
+    const _this = this;
+    let hasLoggedProgress = false;
+    const collection = {
+      name,
+      options,
+      stats,
+      collectionStart,
+      finished: false,
+      start(file) {
+        if (collection.finished) {
+          throw new Error("called after finish() has been used");
+        }
+        file = normalizePath2(file);
+        const start = performance.now();
+        const stat = { file, start, end: start };
+        return () => {
+          const now = performance.now();
+          stat.end = now;
+          stats.push(stat);
+          if (!hasLoggedProgress && options.logInProgress(collection, now)) {
+            hasLoggedProgress = true;
+            log.info(`${name} in progress ...`);
+          }
+        };
+      },
+      async finish() {
+        await _this._finish(collection);
+      }
+    };
+    _this._collections.push(collection);
+    return collection;
+  }
+  async finishAll() {
+    await Promise.all(this._collections.map((c) => c.finish()));
+  }
+  async _finish(collection) {
+    try {
+      collection.finished = true;
+      const now = performance.now();
+      collection.duration = now - collection.collectionStart;
+      const logResult = collection.options.logResult(collection);
+      if (logResult) {
+        await this._aggregateStatsResult(collection);
+        log.info(`${collection.name} done.`, formatPackageStats(collection.packageStats));
+      }
+      const index = this._collections.indexOf(collection);
+      this._collections.splice(index, 1);
+      collection.stats.length = 0;
+      collection.stats = [];
+      if (collection.packageStats) {
+        collection.packageStats.length = 0;
+        collection.packageStats = [];
+      }
+      collection.start = () => () => {
+      };
+      collection.finish = () => {
+      };
+    } catch (e) {
+      log.debug.once(`failed to finish stats for ${collection.name}`, e);
+    }
+  }
+  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;
+    }
+    const grouped = {};
+    stats.forEach((stat) => {
+      const pkg = stat.pkg;
+      let group = grouped[pkg];
+      if (!group) {
+        group = grouped[pkg] = {
+          files: 0,
+          duration: 0,
+          pkg
+        };
+      }
+      group.files += 1;
+      group.duration += stat.end - stat.start;
+    });
+    const groups = Object.values(grouped);
+    groups.sort((a, b) => b.duration - a.duration);
+    collection.packageStats = groups;
+  }
+};
+
 // src/utils/options.ts
 var cssAsString = atLeastSvelte("3.53.0");
 var allowedPluginOptions = /* @__PURE__ */ new Set([
@@ -1138,16 +1335,18 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
     ...viteUserConfig,
     root: resolveViteRoot(viteUserConfig)
   };
+  const isBuild = viteEnv.command === "build";
   const defaultOptions = {
     extensions: [".svelte"],
-    emitCss: true
+    emitCss: true,
+    prebundleSvelteLibraries: !isBuild
   };
   const svelteConfig = convertPluginOptions(
     await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions)
   );
   const extraOptions = {
     root: viteConfigWithResolvedRoot.root,
-    isBuild: viteEnv.command === "build",
+    isBuild,
     isServe: viteEnv.command === "serve",
     isDebug: process.env.DEBUG != null
   };
@@ -1194,6 +1393,12 @@ 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();
+  }
   return merged;
 }
 function enforceOptionsForHmr(options) {
@@ -1284,13 +1489,14 @@ function handleDeprecatedOptions(options) {
   }
 }
 function resolveViteRoot(viteConfig) {
-  return normalizePath2(viteConfig.root ? path4.resolve(viteConfig.root) : process.cwd());
+  return normalizePath3(viteConfig.root ? path4.resolve(viteConfig.root) : process.cwd());
 }
 async function buildExtraViteConfig(options, config) {
   const extraViteConfig = {
     resolve: {
       mainFields: [...SVELTE_RESOLVE_MAIN_FIELDS],
-      dedupe: [...SVELTE_IMPORTS, ...SVELTE_HMR_IMPORTS]
+      dedupe: [...SVELTE_IMPORTS, ...SVELTE_HMR_IMPORTS],
+      conditions: [...SVELTE_EXPORT_CONDITIONS]
     }
   };
   const extraSvelteConfig = buildExtraConfigForSvelte(config);
@@ -1324,25 +1530,65 @@ async function buildExtraViteConfig(options, config) {
     ]
   };
   if (options.prebundleSvelteLibraries) {
-    extraViteConfig.optimizeDeps.extensions = options.extensions ?? [".svelte"];
-    extraViteConfig.optimizeDeps.esbuildOptions = {
-      plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
-      } }]
+    extraViteConfig.optimizeDeps = {
+      ...extraViteConfig.optimizeDeps,
+      extensions: options.extensions ?? [".svelte"],
+      esbuildOptions: {
+        plugins: [{ name: facadeEsbuildSveltePluginName, setup: () => {
+        } }]
+      }
     };
   }
   if ((options.hot == null || options.hot === true || options.hot && options.hot.partialAccept !== false) && config.experimental?.hmrPartialAccept !== false) {
     log.debug('enabling "experimental.hmrPartialAccept" in vite config');
     extraViteConfig.experimental = { hmrPartialAccept: true };
   }
+  validateViteConfig(extraViteConfig, config, options);
   return extraViteConfig;
 }
+function validateViteConfig(extraViteConfig, config, options) {
+  const { prebundleSvelteLibraries, isBuild } = options;
+  if (prebundleSvelteLibraries) {
+    const isEnabled = (option) => option !== true && option !== (isBuild ? "build" : "dev");
+    const logWarning = (name, value, recommendation) => log.warn.once(
+      `Incompatible options: \`prebundleSvelteLibraries: true\` and vite \`${name}: ${JSON.stringify(
+        value
+      )}\` ${isBuild ? "during build." : "."} ${recommendation}`
+    );
+    const viteOptimizeDepsDisabled = config.optimizeDeps?.disabled ?? "build";
+    const isOptimizeDepsEnabled = isEnabled(viteOptimizeDepsDisabled);
+    if (!isBuild && !isOptimizeDepsEnabled) {
+      logWarning(
+        "optimizeDeps.disabled",
+        viteOptimizeDepsDisabled,
+        'Forcing `optimizeDeps.disabled: "build"`. Disable prebundleSvelteLibraries or update your vite config to enable optimizeDeps during dev.'
+      );
+      extraViteConfig.optimizeDeps.disabled = "build";
+    } else if (isBuild && isOptimizeDepsEnabled) {
+      logWarning(
+        "optimizeDeps.disabled",
+        viteOptimizeDepsDisabled,
+        "Disable optimizeDeps or prebundleSvelteLibraries for build if you experience errors."
+      );
+    }
+  }
+}
 async function buildExtraConfigForDependencies(options, config) {
   const depsConfig = await crawlFrameworkPkgs({
     root: options.root,
     isBuild: options.isBuild,
     viteUserConfig: config,
     isFrameworkPkgByJson(pkgJson) {
-      return !!pkgJson.svelte;
+      let hasSvelteCondition = false;
+      if (typeof pkgJson.exports === "object") {
+        JSON.stringify(pkgJson.exports, (key, value) => {
+          if (SVELTE_EXPORT_CONDITIONS.includes(key)) {
+            hasSvelteCondition = true;
+          }
+          return value;
+        });
+      }
+      return hasSvelteCondition || !!pkgJson.svelte;
     },
     isSemiFrameworkPkgByJson(pkgJson) {
       return !!pkgJson.dependencies?.svelte || !!pkgJson.peerDependencies?.svelte;
@@ -1408,113 +1654,8 @@ function patchResolvedViteConfig(viteConfig, options) {
   }
 }
 
-// src/utils/vite-plugin-svelte-cache.ts
-var VitePluginSvelteCache = class {
-  constructor() {
-    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();
-    this._errors = /* @__PURE__ */ new Map();
-  }
-  update(compileData) {
-    this._errors.delete(compileData.normalizedFilename);
-    this.updateCSS(compileData);
-    this.updateJS(compileData);
-    this.updateDependencies(compileData);
-  }
-  has(svelteRequest) {
-    const id = svelteRequest.normalizedFilename;
-    return this._errors.has(id) || this._js.has(id) || this._css.has(id);
-  }
-  setError(svelteRequest, error) {
-    this.remove(svelteRequest, true);
-    this._errors.set(svelteRequest.normalizedFilename, error);
-  }
-  updateCSS(compileData) {
-    this._css.set(compileData.normalizedFilename, compileData.compiled.css);
-  }
-  updateJS(compileData) {
-    if (!compileData.ssr) {
-      this._js.set(compileData.normalizedFilename, compileData.compiled.js);
-    }
-  }
-  updateDependencies(compileData) {
-    const id = compileData.normalizedFilename;
-    const prevDependencies = this._dependencies.get(id) || [];
-    const dependencies = compileData.dependencies;
-    this._dependencies.set(id, dependencies);
-    const removed = prevDependencies.filter((d) => !dependencies.includes(d));
-    const added = dependencies.filter((d) => !prevDependencies.includes(d));
-    added.forEach((d) => {
-      if (!this._dependants.has(d)) {
-        this._dependants.set(d, /* @__PURE__ */ new Set());
-      }
-      this._dependants.get(d).add(compileData.filename);
-    });
-    removed.forEach((d) => {
-      this._dependants.get(d).delete(compileData.filename);
-    });
-  }
-  remove(svelteRequest, keepDependencies = false) {
-    const id = svelteRequest.normalizedFilename;
-    let removed = false;
-    if (this._errors.delete(id)) {
-      removed = true;
-    }
-    if (this._js.delete(id)) {
-      removed = true;
-    }
-    if (this._css.delete(id)) {
-      removed = true;
-    }
-    if (!keepDependencies) {
-      const dependencies = this._dependencies.get(id);
-      if (dependencies) {
-        removed = true;
-        dependencies.forEach((d) => {
-          const dependants = this._dependants.get(d);
-          if (dependants && dependants.has(svelteRequest.filename)) {
-            dependants.delete(svelteRequest.filename);
-          }
-        });
-        this._dependencies.delete(id);
-      }
-    }
-    return removed;
-  }
-  getCSS(svelteRequest) {
-    return this._css.get(svelteRequest.normalizedFilename);
-  }
-  getJS(svelteRequest) {
-    if (!svelteRequest.ssr) {
-      return this._js.get(svelteRequest.normalizedFilename);
-    }
-  }
-  getError(svelteRequest) {
-    return this._errors.get(svelteRequest.normalizedFilename);
-  }
-  getDependants(path9) {
-    const dependants = this._dependants.get(path9);
-    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
-import fs5 from "fs";
+import fs4 from "fs";
 import path5 from "path";
 function setupWatchers(options, cache, requestParser) {
   const { server, configFile: svelteConfigFile } = options;
@@ -1526,7 +1667,7 @@ function setupWatchers(options, cache, requestParser) {
   const emitChangeEventOnDependants = (filename) => {
     const dependants = cache.getDependants(filename);
     dependants.forEach((dependant) => {
-      if (fs5.existsSync(dependant)) {
+      if (fs4.existsSync(dependant)) {
         log.debug(
           `emitting virtual change event for "${dependant}" because depdendency "${filename}" changed`
         );
@@ -1587,7 +1728,7 @@ function setupWatchers(options, cache, requestParser) {
   });
 }
 function ensureWatchedFile(watcher, file, root) {
-  if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs5.existsSync(file)) {
+  if (file && !file.startsWith(root + "/") && !file.includes("\0") && fs4.existsSync(file)) {
     watcher.add(path5.resolve(file));
   }
 }
@@ -1631,7 +1772,7 @@ function isBareImport(importee) {
 }
 
 // src/utils/optimizer.ts
-import { promises as fs6 } from "fs";
+import { promises as fs5 } from "fs";
 import path7 from "path";
 var PREBUNDLE_SENSITIVE_OPTIONS = [
   "compilerOptions",
@@ -1649,11 +1790,11 @@ async function saveSvelteMetadata(cacheDir, options) {
   });
   let existingSvelteMetadata;
   try {
-    existingSvelteMetadata = await fs6.readFile(svelteMetadataPath, "utf8");
+    existingSvelteMetadata = await fs5.readFile(svelteMetadataPath, "utf8");
   } catch {
   }
-  await fs6.mkdir(cacheDir, { recursive: true });
-  await fs6.writeFile(svelteMetadataPath, currentSvelteMetadata);
+  await fs5.mkdir(cacheDir, { recursive: true });
+  await fs5.writeFile(svelteMetadataPath, currentSvelteMetadata);
   return currentSvelteMetadata !== existingSvelteMetadata;
 }
 function generateSvelteMetadata(options) {
@@ -1665,10 +1806,10 @@ function generateSvelteMetadata(options) {
 }
 
 // src/ui/inspector/plugin.ts
-import { normalizePath as normalizePath3 } from "vite";
+import { normalizePath as normalizePath4 } from "vite";
 import path8 from "path";
 import { fileURLToPath } from "url";
-import fs7 from "fs";
+import fs6 from "fs";
 
 // src/ui/inspector/utils.ts
 var FS_PREFIX = `/@fs/`;
@@ -1693,7 +1834,7 @@ var defaultInspectorOptions = {
   customStyles: true
 };
 function getInspectorPath() {
-  const pluginPath = normalizePath3(path8.dirname(fileURLToPath(import.meta.url)));
+  const pluginPath = normalizePath4(path8.dirname(fileURLToPath(import.meta.url)));
   return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
 }
 function svelteInspector() {
@@ -1745,8 +1886,8 @@ function svelteInspector() {
         return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
       } else if (id.startsWith(inspectorPath)) {
         const file = idToFile(id);
-        if (fs7.existsSync(file)) {
-          return await fs7.promises.readFile(file, "utf-8");
+        if (fs6.existsSync(file)) {
+          return await fs6.promises.readFile(file, "utf-8");
         } else {
           log.error(`failed to find file for svelte-inspector: ${file}, referenced by id ${id}.`);
         }
@@ -1782,6 +1923,111 @@ import 'virtual:svelte-inspector-path:load-inspector.js'` };
   };
 }
 
+// src/utils/vite-plugin-svelte-cache.ts
+var VitePluginSvelteCache = class {
+  constructor() {
+    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();
+    this._errors = /* @__PURE__ */ new Map();
+  }
+  update(compileData) {
+    this._errors.delete(compileData.normalizedFilename);
+    this.updateCSS(compileData);
+    this.updateJS(compileData);
+    this.updateDependencies(compileData);
+  }
+  has(svelteRequest) {
+    const id = svelteRequest.normalizedFilename;
+    return this._errors.has(id) || this._js.has(id) || this._css.has(id);
+  }
+  setError(svelteRequest, error) {
+    this.remove(svelteRequest, true);
+    this._errors.set(svelteRequest.normalizedFilename, error);
+  }
+  updateCSS(compileData) {
+    this._css.set(compileData.normalizedFilename, compileData.compiled.css);
+  }
+  updateJS(compileData) {
+    if (!compileData.ssr) {
+      this._js.set(compileData.normalizedFilename, compileData.compiled.js);
+    }
+  }
+  updateDependencies(compileData) {
+    const id = compileData.normalizedFilename;
+    const prevDependencies = this._dependencies.get(id) || [];
+    const dependencies = compileData.dependencies;
+    this._dependencies.set(id, dependencies);
+    const removed = prevDependencies.filter((d) => !dependencies.includes(d));
+    const added = dependencies.filter((d) => !prevDependencies.includes(d));
+    added.forEach((d) => {
+      if (!this._dependants.has(d)) {
+        this._dependants.set(d, /* @__PURE__ */ new Set());
+      }
+      this._dependants.get(d).add(compileData.filename);
+    });
+    removed.forEach((d) => {
+      this._dependants.get(d).delete(compileData.filename);
+    });
+  }
+  remove(svelteRequest, keepDependencies = false) {
+    const id = svelteRequest.normalizedFilename;
+    let removed = false;
+    if (this._errors.delete(id)) {
+      removed = true;
+    }
+    if (this._js.delete(id)) {
+      removed = true;
+    }
+    if (this._css.delete(id)) {
+      removed = true;
+    }
+    if (!keepDependencies) {
+      const dependencies = this._dependencies.get(id);
+      if (dependencies) {
+        removed = true;
+        dependencies.forEach((d) => {
+          const dependants = this._dependants.get(d);
+          if (dependants && dependants.has(svelteRequest.filename)) {
+            dependants.delete(svelteRequest.filename);
+          }
+        });
+        this._dependencies.delete(id);
+      }
+    }
+    return removed;
+  }
+  getCSS(svelteRequest) {
+    return this._css.get(svelteRequest.normalizedFilename);
+  }
+  getJS(svelteRequest) {
+    if (!svelteRequest.ssr) {
+      return this._js.get(svelteRequest.normalizedFilename);
+    }
+  }
+  getError(svelteRequest) {
+    return this._errors.get(svelteRequest.normalizedFilename);
+  }
+  getDependants(path9) {
+    const dependants = this._dependants.get(path9);
+    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/index.ts
 function svelte(inlineOptions) {
   if (process.env.DEBUG != null) {
@@ -1846,7 +2092,7 @@ function svelte(inlineOptions) {
           }
           if (viteConfig.assetsInclude(filename)) {
             log.debug(`load returns raw content for ${filename}`);
-            return fs8.readFileSync(filename, "utf-8");
+            return fs7.readFileSync(filename, "utf-8");
           }
         }
       },
@@ -1940,6 +2186,9 @@ function svelte(inlineOptions) {
             throw toRollupError(e, options);
           }
         }
+      },
+      async buildEnd() {
+        await options.stats?.finishAll();
       }
     }
   ];