vite-plugin-conditional-imports 0.1.0

package/README.md

@@ -0,0 +1,78 @@
+# vite-plugin-conditional-imports
+
+[![npm version](https://img.shields.io/npm/v/vite-plugin-conditional-imports.svg)](https://www.npmjs.com/package/vite-plugin-conditional-imports)
+
+> Vite plugin to strip imports conditionally.
+
+Typical use case:
+
+```js
+import debug from './debug' with { only: 'dev' }
+
+if (import.meta.env.DEV) {
+  debug()
+}
+```
+
+This plugin can be configured to strip the `./debug` import when
+building for production. Then we rely on Rollup's tree shaking to remove
+the dead code during a production build.
+
+If we forget to guard dev code, the plugin notices missing references in
+the chunk output and **fails the build**.
+
+You can also perform stripping based on the import path itself.
+
+## Usage
+
+Strip based on `import with` metadata:
+
+```js
+import { defineConfig } from 'vite'
+import { conditionalImports } from 'vite-plugin-conditional-imports'
+
+export default defineConfig({
+  plugins: [
+    conditionalImports(ctx => {
+      // Strip in production when import has `with { only: 'dev' }`
+      return ctx.config.mode === 'production' && ctx.withObject?.only === 'dev'
+    }),
+  ],
+})
+```
+
+Strip based on path:
+
+```js
+export default defineConfig({
+  plugins: [
+    conditionalImports(async ctx => {
+      // Strip in production when import paths contains `/dev/`
+      return (
+        ctx.config.mode === 'production' &&
+        (await ctx.resolvedTarget).includes('/dev/')
+      )
+    }),
+  ],
+})
+```
+
+## Context object
+
+| Property         | Description                                                                                                                                         |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `target`         | Import specifier as written in source (e.g. `./dev-only.js`, `@lib/custom`).                                                                        |
+| `resolvedTarget` | `Promise<string>`, resolved path relative to Vite's `config.root`. Lazy: resolution runs only when you access it (e.g. `await ctx.resolvedTarget`). |
+| `source`         | Path of the file that contains the import, relative to `config.root`.                                                                               |
+| `withObject`     | Import attributes from `with { ... }` (e.g. `{ only: 'dev' }`).                                                                                     |
+| `config`         | Resolved Vite config (`config.mode`, `config.build.ssr`, etc.).                                                                                     |
+| `env`            | Vite config env (`env.mode`, `env.ssrBuild`, etc.).                                                                                                 |
+
+## Extra options
+
+You can pass an options object after the callback functon with the following properties:
+
+| Option           | Type      | Default | Description                                                                                                                                                                                                                                                                                                                          |
+| ---------------- | --------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `autoSourceMaps` | `boolean` | `true`  | When `true`, the plugin enables Vite sourcemaps (if not set) and uses them to resolve error locations to the original file. When `false`, it does not touch the config, and if source maps are not already enabled, it falls back to reporting all files where a given import was stripped, which is less useful, but builds faster. |
+| `applyInServe`   | `boolean` | `false` | Set to `true` to also use the plugin with `vite serve`.                                                                                                                                                                                                                                                                              |

package/dist/index.cjs

@@ -0,0 +1,298 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  conditionalImports: () => conditionalImports
+});
+module.exports = __toCommonJS(index_exports);
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+
+// src/options.ts
+var DEFAULT_STRIP_IN_MODES = ["production"];
+function normalizeOptions(options = {}) {
+  return {
+    stripInModes: options.stripInModes ?? [...DEFAULT_STRIP_IN_MODES],
+    onlyActiveInModes: options.onlyActiveInModes ?? {},
+    pathPatterns: options.pathPatterns ?? [],
+    shouldStrip: options.shouldStrip
+  };
+}
+
+// src/transform.ts
+var import_core = require("@swc/core");
+
+// src/importAttributes.ts
+function getOnlyAttribute(node) {
+  const list = "attributes" in node && Array.isArray(node.attributes) ? node.attributes : "assertions" in node && Array.isArray(node.assertions) ? node.assertions : void 0;
+  if (!list) return void 0;
+  for (const attr of list) {
+    const key = attr.key && typeof attr.key === "object" && "value" in attr.key ? attr.key.value : void 0;
+    if (key === "only" && attr.value) {
+      const val = typeof attr.value === "object" && "value" in attr.value ? attr.value.value : void 0;
+      return val;
+    }
+  }
+  return void 0;
+}
+
+// src/resolve.ts
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_meta = {};
+var require2 = (0, import_node_module.createRequire)(import_meta.url);
+var resolveSync = require2("resolve/sync");
+function resolveSpecifier(specifier, importerId) {
+  if (specifier.startsWith("\0")) return specifier;
+  const basedir = (0, import_node_path.dirname)(importerId);
+  try {
+    return resolveSync(specifier, {
+      basedir,
+      preserveSymlinks: false,
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".json"]
+    });
+  } catch {
+    return specifier;
+  }
+}
+
+// src/shouldStrip.ts
+var import_minimatch = require("minimatch");
+function shouldStripImport(specifier, importerId, resolvedSpecifier, options, currentMode, stripInModes, onlyValueFromImport) {
+  if (!stripInModes.includes(currentMode)) return false;
+  if (onlyValueFromImport != null) {
+    const activeModes = options.onlyActiveInModes[onlyValueFromImport];
+    if (activeModes != null && !activeModes.includes(currentMode)) return true;
+  }
+  for (const pattern of options.pathPatterns) {
+    if ((0, import_minimatch.minimatch)(resolvedSpecifier, pattern, { matchBase: true })) return true;
+  }
+  if (options.shouldStrip?.(resolvedSpecifier, importerId)) return true;
+  return false;
+}
+
+// src/transform.ts
+function getLocalName(spec) {
+  const local = spec.local;
+  if (!local) return void 0;
+  return "value" in local ? local.value : void 0;
+}
+async function transformModule(code, id, options, currentMode) {
+  const mod = await (0, import_core.parse)(code, {
+    syntax: "typescript",
+    tsx: /\.tsx$/.test(id)
+  });
+  const strippedBindings = [];
+  const bindingToSourceFiles = /* @__PURE__ */ new Map();
+  const resolvedSpecifierCache = /* @__PURE__ */ new Map();
+  const body = mod.body.filter((item) => {
+    if (item.type !== "ImportDeclaration") return true;
+    const src = item.source.value;
+    const resolved = resolvedSpecifierCache.get(src) ?? resolveSpecifier(src, id);
+    resolvedSpecifierCache.set(src, resolved);
+    const onlyValue = getOnlyAttribute(
+      item
+    );
+    const strip = shouldStripImport(
+      src,
+      id,
+      resolved,
+      {
+        pathPatterns: options.pathPatterns,
+        onlyActiveInModes: options.onlyActiveInModes,
+        shouldStrip: options.shouldStrip
+      },
+      currentMode,
+      options.stripInModes,
+      onlyValue
+    );
+    if (!strip) return true;
+    const typeOnly = "typeOnly" in item && item.typeOnly === true;
+    if (!typeOnly && item.specifiers) {
+      for (const spec of item.specifiers) {
+        const name = getLocalName(
+          spec
+        );
+        if (name) {
+          strippedBindings.push(name);
+          const list = bindingToSourceFiles.get(name) ?? [];
+          list.push(id);
+          bindingToSourceFiles.set(name, list);
+        }
+      }
+    }
+    return false;
+  });
+  mod.body = body;
+  const out = await (0, import_core.print)(mod);
+  if (out.code === code) return null;
+  return {
+    code: out.code,
+    map: out.map ?? null,
+    strippedBindings,
+    bindingToSourceFiles
+  };
+}
+
+// src/check.ts
+var import_eslint = require("eslint");
+var import_trace_mapping = require("@jridgewell/trace-mapping");
+var NO_UNDEF_MSG_RE = /^'([^']+)' is not defined\.$/;
+function findUndefinedStrippedRefs(code, strippedBindings, bindingToSourceFiles) {
+  if (strippedBindings.size === 0) return [];
+  const linter = new import_eslint.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 [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const errors = [];
+  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 || !strippedBindings.has(name) || seen.has(name)) continue;
+    seen.add(name);
+    const sourceIds = bindingToSourceFiles.get(name) ?? [];
+    errors.push({
+      name,
+      sourceIds,
+      line: msg.line,
+      column: msg.column
+    });
+  }
+  return errors;
+}
+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 traceToSource(chunkMap, line, column) {
+  try {
+    const traced = (0, import_trace_mapping.originalPositionFor)(
+      new import_trace_mapping.TraceMap(chunkMap),
+      { line, column }
+    );
+    return traced.source ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+function conditionalImports(options = {}) {
+  const opts = normalizeOptions(options);
+  let currentMode = "development";
+  let pluginRequestedSourcemap = false;
+  const strippedBindings = /* @__PURE__ */ new Set();
+  const bindingToSourceFiles = /* @__PURE__ */ new Map();
+  return {
+    name: "vite-plugin-conditional-imports",
+    enforce: "pre",
+    config(userConfig, env) {
+      if (env.command === "build" && userConfig.build?.sourcemap == null) {
+        pluginRequestedSourcemap = true;
+        return { build: { sourcemap: "hidden" } };
+      }
+    },
+    configResolved(config) {
+      currentMode = config.mode;
+    },
+    buildStart() {
+      strippedBindings.clear();
+      bindingToSourceFiles.clear();
+    },
+    async transform(code, id) {
+      if (!opts.stripInModes.includes(currentMode)) return null;
+      if (!/\.(tsx?|jsx?|mts|mjs)$/.test(id)) return null;
+      const result = await transformModule(code, id, opts, currentMode);
+      if (!result) return null;
+      for (const name of result.strippedBindings) {
+        strippedBindings.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);
+      }
+      return { code: result.code, map: result.map };
+    },
+    generateBundle(_options, bundle) {
+      if (!opts.stripInModes.includes(currentMode) || strippedBindings.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,
+          strippedBindings,
+          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.`
+          );
+        }
+      }
+    },
+    async writeBundle(options2, bundle) {
+      if (!pluginRequestedSourcemap || !options2.dir) return;
+      for (const name of Object.keys(bundle)) {
+        if (name.endsWith(".map")) {
+          await (0, import_promises.unlink)((0, import_node_path2.join)(options2.dir, name)).catch(() => {
+          });
+        }
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  conditionalImports
+});

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import { ConfigEnv, Plugin, ResolvedConfig } 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.
+     */
+    get 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' }`). */
+    withObject: Record<string, string>;
+    /** Vite config. */
+    config: ResolvedConfig;
+    /** Vite env. */
+    env: ConfigEnv;
+}
+type ShouldStripFn = (ctx: ShouldStripContext) => boolean | Promise<boolean>;
+interface Options {
+    /**
+     * When `true` (default), the plugin enables Vite source maps (`hidden` mode)
+     * and uses them to resolve error locations and provide more useful error
+     * messages. If source maps were initially off, the source maps are removed
+     * after the build.
+     *
+     * If you don't want this plugin to touch your source maps configuration and
+     * output folder, set this to `false`.
+     */
+    autoSourceMaps?: boolean;
+    /**
+     * When `false` (default), the plugin only runs in `vite build`. If you set it
+     * to `true`, it also runs in `vite serve`.
+     */
+    applyInServe?: boolean;
+}
+declare function conditionalImports(shouldStrip: ShouldStripFn, options?: Options): Plugin;
+
+export { conditionalImports,type Options, type ShouldStripContext, type ShouldStripFn };

package/dist/index.js

@@ -0,0 +1,273 @@
+// src/index.ts
+import { parse, print } from "@swc/core";
+import createDebug from "debug";
+import { unlink } from "fs/promises";
+import { join } from "path";
+// src/transform.ts
+import path from "path";
+import { normalizePath } from "vite";
+
+// src/importAttributes.ts
+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 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;
+  }
+  return out;
+}
+
+// src/transform.ts
+function toRootRelative(filePath, root) {
+  if (!path.isAbsolute(filePath)) return filePath;
+  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 body = [];
+  for (const item of mod.body) {
+    if (item.type !== "ImportDeclaration") {
+      body.push(item);
+      continue;
+    }
+    const target = item.source.value;
+    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);
+        }
+        return p;
+      },
+      source: toRootRelative(id, context.config.root),
+      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) {
+      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);
+        }
+      }
+    }
+  }
+  mod.body = body;
+  const out = await print(mod);
+  if (out.code === code) return null;
+  return {
+    code: out.code,
+    map: out.map ?? null,
+    strippedImports,
+    bindingToSourceFiles
+  };
+}
+
+// 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 [];
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const errors = [];
+  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;
+    seen.add(name);
+    const sourceIds = bindingToSourceFiles.get(name) ?? [];
+    errors.push({
+      name,
+      sourceIds,
+      line: msg.line,
+      column: msg.column
+    });
+  }
+  return errors;
+}
+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 traceToSource(chunkMap, line, column) {
+  try {
+    const traced = originalPositionFor(
+      new TraceMap(chunkMap),
+      { line, column }
+    );
+    return traced.source ?? null;
+  } catch {
+    return null;
+  }
+}
+
+// src/index.ts
+var log = createDebug("vite-plugin-conditional-imports");
+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();
+  let cachedConfig;
+  let cachedEnv;
+  return {
+    name: "vite-plugin-conditional-imports",
+    enforce: "pre",
+    apply: applyInServe ? void 0 : "build",
+    config(userConfig, env) {
+      cachedEnv = env;
+      if (!autoSourceMaps) {
+        return;
+      }
+      if (env.command === "build" && (userConfig.build?.sourcemap == null || userConfig.build?.sourcemap === false)) {
+        pluginRequestedSourcemap = true;
+        return {
+          build: {
+            sourcemap: "hidden"
+          }
+        };
+      }
+    },
+    configResolved(config) {
+      cachedConfig = config;
+    },
+    buildStart() {
+      strippedImports.clear();
+      bindingToSourceFiles.clear();
+    },
+    async transform(code, id) {
+      if (!cachedConfig || !cachedEnv) {
+        this.error(
+          "vite-plugin-conditional-imports: config or env not resolved"
+        );
+      }
+      if (!/\.(tsx?|jsx?|mts|mjs)$/.test(id)) {
+        return null;
+      }
+      const result = await transform(code, id, shouldStrip, {
+        resolve: this.resolve,
+        config: cachedConfig,
+        env: cachedEnv
+      });
+      if (!result) {
+        return null;
+      }
+      if (result.strippedImports.length > 0) {
+        log(
+          "stripped import in %s: %s",
+          toRootRelative(id, cachedConfig.root),
+          result.strippedImports.join(", ")
+        );
+      }
+      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);
+      }
+      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.`
+          );
+        }
+      }
+    },
+    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(() => {
+          });
+        }
+      }
+    }
+  };
+}
+export {
+  conditionalImports
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "vite-plugin-conditional-imports",
+  "version": "0.1.0",
+  "description": "Strip conditional imports (only, path patterns, or custom predicate) in production builds and warn on leftover references",
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "conditional-imports",
+    "tree-shake"
+  ],
+  "license": "MIT",
+  "author": "Val (https://val.codejam.info)",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "repository": "EveToolsHQ/vite-plugin-conditional-imports",
+  "dependencies": {
+    "@jridgewell/trace-mapping": "^0.3.31",
+    "@swc/core": "^1.15.11",
+    "debug": "^4.4.3",
+    "eslint": "^9.39.2"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.39.2",
+    "@types/debug": "^4.1.12",
+    "@types/node": "^25.1.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-import-x": "^4.16.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-unused-imports": "^4.3.0",
+    "minimatch": "^10.1.1",
+    "prettier": "^3.8.1",
+    "rollup": "^4.57.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.54.0",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.18"
+  },
+  "peerDependencies": {
+    "vite": ">=5.0.0"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": false
+    }
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --tsconfig tsconfig.build.json",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}