vite-plugin-conditional-imports 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,13 +1,13 @@
-import { ConfigEnv, Plugin, ResolvedConfig } from 'vite';
+import { ResolvedConfig, ConfigEnv, Plugin } from 'vite';
 
 interface ShouldStripContext {
     /** Raw import target as is from source code. */
     target: string;
     /**
-     * Resolved import path (relative to project root). Lazy getter — resolution
-     * runs only when this is accessed. Await it when you need the path.
+     * Resolved import path (relative to project root). Lazy, resolution runs only
+     * when you access it.
      */
-    get resolvedTarget(): Promise<string>;
+    resolvedTarget: Promise<string>;
     /** The file where the import is found, relative to project root. */
     source: string;
     /** Import attributes from `with { ... }` clause (e.g. `{ only: 'dev' }`). */
@@ -37,4 +37,4 @@ interface Options {
 }
 declare function conditionalImports(shouldStrip: ShouldStripFn, options?: Options): Plugin;
 
-export { conditionalImports,type Options, type ShouldStripContext, type ShouldStripFn };
+export { type Options, type ShouldStripContext, type ShouldStripFn, conditionalImports };

package/dist/index.js

@@ -1,158 +1,196 @@
 // src/index.ts
-import { parse, print } from "@swc/core";
-import createDebug from "debug";
 import { unlink } from "fs/promises";
+import { join as join2 } from "path";
+import createDebug from "debug";
+
+// src/check.ts
 import { join } from "path";
+import { originalPositionFor, TraceMap } from "@jridgewell/trace-mapping";
+import { Linter } from "eslint";
+
 // src/transform.ts
 import path from "path";
+import { parse, print } from "@swc/core";
 import { normalizePath } from "vite";
 
 // src/importAttributes.ts
+function getWithObject(node) {
+  return node.with ?? node.asserts;
+}
+function getAttrList(node) {
+  const withObj = getWithObject(node);
+  return withObj?.properties ?? [];
+}
+function getKey(attr) {
+  const k = "key" in attr ? attr.key : void 0;
+  return k && typeof k === "object" && "value" in k ? k.value : void 0;
+}
+function getVal(attr) {
+  const v = "value" in attr ? attr.value : void 0;
+  return v && typeof v === "object" && "value" in v ? v.value : void 0;
+}
 function getImportAttributes(node) {
-  const list = node.with && typeof node.with === "object" && Array.isArray(node.with.properties) ? node.with.properties : Array.isArray(node.attributes) ? node.attributes : Array.isArray(node.assertions) ? node.assertions : void 0;
+  const list = getAttrList(node);
   const out = {};
-  if (!list) return out;
   for (const attr of list) {
-    const key = attr.key && typeof attr.key === "object" && "value" in attr.key ? attr.key.value : void 0;
-    const val = attr.value && typeof attr.value === "object" && "value" in attr.value ? attr.value.value : void 0;
-    if (key != null && val != null) out[key] = val;
+    const key = getKey(attr);
+    const val = getVal(attr);
+    if (key != null && val != null) {
+      out[key] = val;
+    }
   }
   return out;
 }
 
 // src/transform.ts
-function toRootRelative(filePath, root) {
-  if (!path.isAbsolute(filePath)) return filePath;
+function relativeToRoot(filePath, root) {
   const rel = path.relative(root, filePath);
   if (rel.startsWith("..") || path.isAbsolute(rel)) return filePath;
   return normalizePath(rel);
 }
-function getLocalName(spec) {
-  const local = spec.local;
-  if (!local) return void 0;
-  return "value" in local ? local.value : void 0;
-}
 async function transform(code, id, shouldStrip, context) {
   const mod = await parse(code, {
     syntax: "typescript",
     tsx: id.endsWith(".tsx")
   });
-  const strippedImports = [];
-  const bindingToSourceFiles = /* @__PURE__ */ new Map();
   const resolveCache = /* @__PURE__ */ new Map();
+  const strippedImportTargets = /* @__PURE__ */ new Set();
+  const strippedImportSymbols = /* @__PURE__ */ new Set();
+  const source = relativeToRoot(id, context.config.root);
   const body = [];
   for (const item of mod.body) {
-    if (item.type !== "ImportDeclaration") {
+    if (item.type !== "ImportDeclaration" || item.typeOnly) {
       body.push(item);
       continue;
     }
     const target = item.source.value;
-    const withObject = getImportAttributes(
-      item
-    );
+    const withObject = getImportAttributes(item);
     const ctx = {
       target,
       get resolvedTarget() {
-        let p = resolveCache.get(target);
-        if (!p) {
-          p = context.resolve(target, id).then(
-            (r) => toRootRelative(r?.id ?? target, context.config.root)
-          );
-          resolveCache.set(target, p);
+        let promise2 = resolveCache.get(target);
+        if (promise2) {
+          return promise2;
         }
-        return p;
+        promise2 = context.resolve(target, id).then((r) => relativeToRoot(r?.id ?? target, context.config.root));
+        resolveCache.set(target, promise2);
+        return promise2;
       },
-      source: toRootRelative(id, context.config.root),
+      source,
       withObject,
       config: context.config,
       env: context.env
     };
-    if (!await shouldStrip(ctx)) {
-      body.push(item);
-      continue;
-    }
-    const typeOnly = "typeOnly" in item && item.typeOnly === true;
-    if (!typeOnly && item.specifiers) {
+    const promise = Promise.resolve(shouldStrip(ctx)).then((strip) => {
+      if (!strip) {
+        return item;
+      }
+      strippedImportTargets.add(target);
       for (const spec of item.specifiers) {
-        const name = getLocalName(
-          spec
-        );
-        if (name) {
-          strippedImports.push(name);
-          const list = bindingToSourceFiles.get(name) ?? [];
-          list.push(id);
-          bindingToSourceFiles.set(name, list);
-        }
+        strippedImportSymbols.add(spec.local.value);
       }
-    }
+      return null;
+    });
+    body.push(promise);
+  }
+  const results = await Promise.all(body);
+  mod.body = results.filter((item) => item != null);
+  if (strippedImportSymbols.size === 0) {
+    return null;
   }
-  mod.body = body;
-  const out = await print(mod);
-  if (out.code === code) return null;
+  const out = await print(mod, {
+    sourceMaps: true,
+    filename: source
+  });
   return {
     code: out.code,
     map: out.map ?? null,
-    strippedImports,
-    bindingToSourceFiles
+    strippedImportTargets,
+    strippedImportSymbols,
+    relativeSource: source
   };
 }
 
 // src/check.ts
-import { originalPositionFor,TraceMap } from "@jridgewell/trace-mapping";
-import { Linter } from "eslint";
-var NO_UNDEF_MSG_RE = /^'([^']+)' is not defined\.$/;
-function findUndefinedStrippedRefs(code, strippedImports, bindingToSourceFiles) {
-  if (strippedImports.size === 0) return [];
-  const linter = new Linter({ configType: "flat" });
-  const config = [
-    {
-      languageOptions: {
-        ecmaVersion: "latest",
-        sourceType: "module"
-      },
-      rules: { "no-undef": ["error"] }
-    }
-  ];
-  let messages;
-  try {
-    messages = linter.verify(code, config, "chunk.js");
-  } catch {
-    return [];
+var eslintConfig = [
+  {
+    languageOptions: {
+      ecmaVersion: "latest",
+      sourceType: "module"
+    },
+    rules: { "no-undef": ["error"] }
   }
+];
+function findUndefinedRefs(code) {
+  const linter = new Linter({ configType: "flat" });
+  const messages = linter.verify(code, eslintConfig, "chunk.js");
   const seen = /* @__PURE__ */ new Set();
-  const errors = [];
+  const refs = [];
   for (const msg of messages) {
     if (msg.ruleId !== "no-undef") continue;
-    const m = NO_UNDEF_MSG_RE.exec(msg.message);
-    const name = m?.[1];
-    if (!name || !strippedImports.has(name) || seen.has(name)) continue;
+    const name = msg.message.split("'")[1] ?? null;
+    if (!name || seen.has(name)) {
+      continue;
+    }
     seen.add(name);
-    const sourceIds = bindingToSourceFiles.get(name) ?? [];
-    errors.push({
+    refs.push({
       name,
-      sourceIds,
       line: msg.line,
       column: msg.column
     });
   }
-  return errors;
+  return refs;
 }
-function toShortPath(id) {
-  const srcMatch = id.match(/(?:^|\/)src\/(.+)$/);
-  if (srcMatch) return srcMatch[1];
-  const lastSlash = id.lastIndexOf("/");
-  return lastSlash >= 0 ? id.slice(lastSlash + 1) : id;
+function checkChunk(chunk, importSymbolsToSource, root, outputDir) {
+  const errors = [];
+  const undefinedRefs = findUndefinedRefs(chunk.code);
+  if (undefinedRefs.length === 0) {
+    return errors;
+  }
+  const moduleIdsInChunk = new Set(
+    chunk.moduleIds ?? Object.keys(chunk.modules ?? {})
+  );
+  let traceMap = null;
+  for (const undefinedRef of undefinedRefs) {
+    const sourceIds = importSymbolsToSource.get(undefinedRef.name);
+    if (!sourceIds) {
+      continue;
+    }
+    const relevantSourceIds = sourceIds.filter((id) => moduleIdsInChunk.has(id));
+    if (relevantSourceIds.length === 0) {
+      continue;
+    }
+    let sourceOfError = null;
+    if (chunk.map && undefinedRef.line != null && undefinedRef.column != null) {
+      const mapUrl = outputDir ? join(outputDir, chunk.sourcemapFileName ?? `${chunk.fileName}.map`) : null;
+      traceMap ??= new TraceMap(chunk.map, mapUrl);
+      sourceOfError = originalPositionFor(traceMap, {
+        line: undefinedRef.line,
+        column: undefinedRef.column
+      }).source;
+    }
+    const errorSourceIds = sourceOfError ? [sourceOfError] : relevantSourceIds;
+    const relativeSourceIds = outputDir ? errorSourceIds.map((id) => relativeToRoot(id, root)) : errorSourceIds;
+    errors.push(
+      `Stripped conditional import binding '${undefinedRef.name}' still in output (${relativeSourceIds.sort().join(", ")})`
+    );
+  }
+  return errors;
 }
-function traceToSource(chunkMap, line, column) {
-  try {
-    const traced = originalPositionFor(
-      new TraceMap(chunkMap),
-      { line, column }
+function checkBundle(bundle, importSymbolsToSource, root, outputDir) {
+  if (importSymbolsToSource.size === 0) {
+    return [];
+  }
+  const errors = [];
+  for (const chunkOrAsset of Object.values(bundle)) {
+    if (chunkOrAsset.type !== "chunk") {
+      continue;
+    }
+    errors.push(
+      ...checkChunk(chunkOrAsset, importSymbolsToSource, root, outputDir)
     );
-    return traced.source ?? null;
-  } catch {
-    return null;
   }
+  return errors;
 }
 
 // src/index.ts
@@ -161,8 +199,7 @@ function conditionalImports(shouldStrip, options) {
   const autoSourceMaps = options?.autoSourceMaps !== false;
   const applyInServe = options?.applyInServe === true;
   let pluginRequestedSourcemap = false;
-  const strippedImports = /* @__PURE__ */ new Set();
-  const bindingToSourceFiles = /* @__PURE__ */ new Map();
+  const importSymbolsToSource = /* @__PURE__ */ new Map();
   let cachedConfig;
   let cachedEnv;
   return {
@@ -187,12 +224,14 @@ function conditionalImports(shouldStrip, options) {
       cachedConfig = config;
     },
     buildStart() {
-      strippedImports.clear();
-      bindingToSourceFiles.clear();
+      importSymbolsToSource.clear();
     },
     async transform(code, id) {
+      if (id.includes("/node_modules/")) {
+        return null;
+      }
       if (!cachedConfig || !cachedEnv) {
-        this.error(
+        return this.error(
           "vite-plugin-conditional-imports: config or env not resolved"
         );
       }
@@ -207,61 +246,35 @@ function conditionalImports(shouldStrip, options) {
       if (!result) {
         return null;
       }
-      if (result.strippedImports.length > 0) {
-        log(
-          "stripped import in %s: %s",
-          toRootRelative(id, cachedConfig.root),
-          result.strippedImports.join(", ")
-        );
+      for (const target of result.strippedImportTargets) {
+        log("stripped import in %s: %s", result.relativeSource, target);
       }
-      for (const name of result.strippedImports) {
-        strippedImports.add(name);
-        const list = bindingToSourceFiles.get(name) ?? [];
-        const fromResult = result.bindingToSourceFiles.get(name) ?? [];
-        for (const fid of fromResult) {
-          if (!list.includes(fid)) list.push(fid);
-        }
-        bindingToSourceFiles.set(name, list);
+      for (const name of result.strippedImportSymbols) {
+        const list = importSymbolsToSource.get(name) ?? [];
+        list.push(id);
+        importSymbolsToSource.set(name, list);
       }
       return { code: result.code, map: result.map };
     },
-    generateBundle(_options, bundle) {
-      if (strippedImports.size === 0) return;
-      for (const item of Object.values(bundle)) {
-        if (item.type !== "chunk") continue;
-        const chunk = item;
-        const moduleIdsInChunk = new Set(
-          chunk.moduleIds ?? Object.keys(chunk.modules ?? {})
-        );
-        const undefinedRefs = findUndefinedStrippedRefs(
-          chunk.code,
-          strippedImports,
-          bindingToSourceFiles
-        );
-        const chunkMap = chunk.map;
-        for (const { name, sourceIds, line, column } of undefinedRefs) {
-          let toShow = sourceIds.filter(
-            (id) => moduleIdsInChunk.has(id)
-          );
-          if (toShow.length === 0) toShow = sourceIds;
-          let resolvedSingle = null;
-          if (chunkMap && line != null && column != null) {
-            resolvedSingle = traceToSource(chunkMap, line, column);
-            if (resolvedSingle != null)
-              resolvedSingle = toShortPath(resolvedSingle);
-          }
-          const origin = resolvedSingle ? ` (in: ${resolvedSingle})` : toShow.length > 0 ? ` (in: ${toShow.map(toShortPath).join(", ")})` : "";
-          this.error(
-            `Stripped conditional import binding "${name}" still in output${origin}. Guard or remove the usage so it's tree-shaken.`
-          );
-        }
+    generateBundle(options2, bundle) {
+      if (!cachedConfig) {
+        return;
+      }
+      const errors = checkBundle(
+        bundle,
+        importSymbolsToSource,
+        cachedConfig.root,
+        options2.dir
+      );
+      if (errors.length > 0) {
+        this.error(errors.join("\n"));
       }
     },
     async writeBundle(options2, bundle) {
       if (!pluginRequestedSourcemap || !options2.dir) return;
       for (const name of Object.keys(bundle)) {
         if (name.endsWith(".map")) {
-          await unlink(join(options2.dir, name)).catch(() => {
+          await unlink(join2(options2.dir, name)).catch(() => {
           });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-conditional-imports",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Strip conditional imports (only, path patterns, or custom predicate) in production builds and warn on leftover references",
   "keywords": [
     "vite",