@sveltejs/vite-plugin-svelte 1.0.0-next.43 → 1.0.0-next.46

package/dist/index.d.ts

@@ -46,11 +46,13 @@ interface Options {
      */
     emitCss?: boolean;
     /**
-     * The options to be passed to the Svelte compiler
+     * The options to be passed to the Svelte compiler. A few options are set by default,
+     * including `dev` and `css`. However, some options are non-configurable, like
+     * `filename`, `format`, `generate`, and `cssHash` (in dev).
      *
      * @see https://svelte.dev/docs#svelte_compile
      */
-    compilerOptions?: CompileOptions;
+    compilerOptions?: Omit<CompileOptions, 'filename' | 'format' | 'generate'>;
     /**
      * Handles warning emitted from the Svelte compiler
      */

package/dist/index.js

@@ -26,7 +26,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 
 // src/index.ts
-import fs7 from "fs";
+import fs8 from "fs";
 
 // src/utils/log.ts
 import { cyan, yellow, red } from "kleur/colors";
@@ -280,7 +280,8 @@ var _createCompileSvelte = (makeHot) => async function compileSvelte2(svelteRequ
   const dependencies = [];
   const compileOptions = __spreadProps(__spreadValues({}, options.compilerOptions), {
     filename,
-    generate: ssr ? "ssr" : "dom"
+    generate: ssr ? "ssr" : "dom",
+    format: "esm"
   });
   if (options.hot && options.emitCss) {
     const hash = `s-${safeBase64Hash(normalizedFilename)}`;
@@ -571,7 +572,7 @@ function findRootSvelteDependencies(root, cwdFallback = true) {
   ].filter((dep) => !is_common_without_svelte_field(dep));
   return getSvelteDependencies(deps, root);
 }
-function getSvelteDependencies(deps, pkgDir, path8 = []) {
+function getSvelteDependencies(deps, pkgDir, path9 = []) {
   const result = [];
   const localRequire = createRequire2(`${pkgDir}/package.json`);
   const resolvedDeps = deps.map((dep) => resolveDependencyData(dep, localRequire)).filter(Boolean);
@@ -579,18 +580,18 @@ function getSvelteDependencies(deps, pkgDir, path8 = []) {
     const type = getSvelteDependencyType(pkg);
     if (!type)
       continue;
-    result.push({ name: pkg.name, type, pkg, dir, path: path8 });
+    result.push({ name: pkg.name, type, pkg, dir, path: path9 });
     if (type === "component-library" && pkg.dependencies) {
       let dependencyNames = Object.keys(pkg.dependencies);
-      const circular = dependencyNames.filter((name) => path8.includes(name));
+      const circular = dependencyNames.filter((name) => path9.includes(name));
       if (circular.length > 0) {
-        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));
+        log.warn.enabled && log.warn(`skipping circular svelte dependencies in automated vite optimizeDeps handling`, circular.map((x) => path9.concat(x).join(">")));
+        dependencyNames = dependencyNames.filter((name) => !path9.includes(name));
       }
-      if (path8.length === 3) {
-        log.debug.once(`encountered deep svelte dependency tree: ${path8.join(">")}`);
+      if (path9.length === 3) {
+        log.debug.once(`encountered deep svelte dependency tree: ${path9.join(">")}`);
       }
-      result.push(...getSvelteDependencies(dependencyNames, dir, path8.concat(pkg.name)));
+      result.push(...getSvelteDependencies(dependencyNames, dir, path9.concat(pkg.name)));
     }
   }
   return result;
@@ -1083,10 +1084,7 @@ async function preResolveOptions(inlineOptions = {}, viteUserConfig, viteEnv) {
   });
   const defaultOptions = {
     extensions: [".svelte"],
-    emitCss: true,
-    compilerOptions: {
-      format: "esm"
-    }
+    emitCss: true
   };
   const svelteConfig = await loadSvelteConfig(viteConfigWithResolvedRoot, inlineOptions);
   const extraOptions = {
@@ -1123,6 +1121,7 @@ function resolveOptions(preResolveOptions2, viteConfig) {
     isProduction: viteConfig.isProduction
   };
   const merged = mergeConfigs(defaultOptions, preResolveOptions2, extraOptions);
+  removeIgnoredOptions(merged);
   addExtraPreprocessors(merged, viteConfig);
   enforceOptionsForHmr(merged);
   enforceOptionsForProduction(merged);
@@ -1171,6 +1170,20 @@ function enforceOptionsForProduction(options) {
     }
   }
 }
+function removeIgnoredOptions(options) {
+  const ignoredCompilerOptions = ["generate", "format", "filename"];
+  if (options.hot && options.emitCss) {
+    ignoredCompilerOptions.push("cssHash");
+  }
+  const passedCompilerOptions = Object.keys(options.compilerOptions || {});
+  const passedIgnored = passedCompilerOptions.filter((o) => ignoredCompilerOptions.includes(o));
+  if (passedIgnored.length) {
+    log.warn(`The following Svelte compilerOptions are controlled by vite-plugin-svelte and essential to its functionality. User-specified values are ignored. Please remove them from your configuration: ${passedIgnored.join(", ")}`);
+    passedIgnored.forEach((ignored) => {
+      delete options.compilerOptions[ignored];
+    });
+  }
+}
 function resolveViteRoot(viteConfig) {
   return normalizePath2(viteConfig.root ? path4.resolve(viteConfig.root) : process.cwd());
 }
@@ -1340,8 +1353,8 @@ var VitePluginSvelteCache = class {
       return this._js.get(svelteRequest.normalizedFilename);
     }
   }
-  getDependants(path8) {
-    const dependants = this._dependants.get(path8);
+  getDependants(path9) {
+    const dependants = this._dependants.get(path9);
     return dependants ? [...dependants] : [];
   }
   getResolvedSvelteField(name, importer) {
@@ -1506,7 +1519,10 @@ function generateSvelteMetadata(options) {
 }
 
 // src/ui/inspector/plugin.ts
-import { createRequire as createRequire5 } from "module";
+import { normalizePath as normalizePath3 } from "vite";
+import path8 from "path";
+import { fileURLToPath } from "url";
+import fs7 from "fs";
 var defaultInspectorOptions = {
   toggleKeyCombo: process.platform === "win32" ? "control-shift" : "meta-shift",
   holdMode: false,
@@ -1514,11 +1530,16 @@ var defaultInspectorOptions = {
   toggleButtonPos: "top-right",
   customStyles: true
 };
+function getInspectorPath() {
+  const pluginPath = normalizePath3(path8.dirname(fileURLToPath(import.meta.url)));
+  return pluginPath.replace(/\/vite-plugin-svelte\/dist$/, "/vite-plugin-svelte/src/ui/inspector/");
+}
 function svelteInspector() {
-  let root;
-  let rootRequire;
+  const inspectorPath = getInspectorPath();
+  log.debug.enabled && log.debug(`svelte inspector path: ${inspectorPath}`);
   let inspectorOptions;
-  let append_to;
+  let appendTo;
+  let disabled = false;
   return {
     name: "vite-plugin-svelte:inspector",
     apply: "serve",
@@ -1530,51 +1551,49 @@ function svelteInspector() {
         inspectorOptions = __spreadValues(__spreadValues({}, defaultInspectorOptions), vps.api.options.experimental.inspector);
       }
       if (!vps || !inspectorOptions) {
-        this.resolveId = this.load = this.transformIndexHtml = this.transform = () => {
-        };
+        log.debug("inspector disabled, could not find config");
+        disabled = true;
       } else {
-        root = config.root || process.cwd();
-        rootRequire = createRequire5(root);
         if (vps.api.options.kit && !inspectorOptions.appendTo) {
-          const out_dir = vps.api.options.kit.outDir || ".svelte-kit";
+          const out_dir = path8.basename(vps.api.options.kit.outDir || ".svelte-kit");
           inspectorOptions.appendTo = `${out_dir}/runtime/client/start.js`;
         }
-        append_to = inspectorOptions.appendTo;
+        appendTo = inspectorOptions.appendTo;
       }
     },
     async resolveId(importee, importer, options) {
-      if (options == null ? void 0 : options.ssr) {
+      if ((options == null ? void 0 : options.ssr) || disabled) {
         return;
       }
-      if (importee === "virtual:svelte-inspector-options") {
+      if (importee.startsWith("virtual:svelte-inspector-options")) {
         return importee;
-      }
-      if (importee.startsWith("virtual:svelte-inspector:")) {
-        const file = importee.replace("virtual:svelte-inspector:", "@sveltejs/vite-plugin-svelte/src/ui/inspector/");
-        const path8 = rootRequire.resolve(file);
-        if (path8) {
-          return path8;
-        } else {
-          log.error.once(`failed to resolve ${file} for ${importee} from ${root}`);
-        }
+      } else if (importee.startsWith("virtual:svelte-inspector-path:")) {
+        const resolved = importee.replace("virtual:svelte-inspector-path:", inspectorPath);
+        log.debug.enabled && log.debug(`resolved ${importee} with ${resolved}`);
+        return resolved;
       }
     },
-    load(id) {
+    async load(id, options) {
+      if ((options == null ? void 0 : options.ssr) || disabled) {
+        return;
+      }
       if (id === "virtual:svelte-inspector-options") {
         return `export default ${JSON.stringify(inspectorOptions ?? {})}`;
+      } else if (id.startsWith(inspectorPath)) {
+        return await fs7.promises.readFile(id, "utf-8");
       }
     },
     transform(code, id, options) {
-      if ((options == null ? void 0 : options.ssr) || !append_to) {
+      if ((options == null ? void 0 : options.ssr) || disabled || !appendTo) {
         return;
       }
-      if (id.endsWith(append_to)) {
+      if (id.endsWith(appendTo)) {
         return { code: `${code}
-import 'virtual:svelte-inspector:load-inspector.ts'` };
+import 'virtual:svelte-inspector-path:load-inspector.js'` };
       }
     },
     transformIndexHtml(html) {
-      if (append_to) {
+      if (disabled || appendTo) {
         return;
       }
       return {
@@ -1585,7 +1604,7 @@ import 'virtual:svelte-inspector:load-inspector.ts'` };
             injectTo: "body",
             attrs: {
               type: "module",
-              src: "/@id/virtual:svelte-inspector:load-inspector.ts"
+              src: "/@id/virtual:svelte-inspector-path:load-inspector.js"
             }
           }
         ]
@@ -1659,7 +1678,7 @@ function svelte(inlineOptions) {
           }
           if (viteConfig.assetsInclude(filename)) {
             log.debug(`load returns raw content for ${filename}`);
-            return fs7.readFileSync(filename, "utf-8");
+            return fs8.readFileSync(filename, "utf-8");
           }
         }
       },