@interfere/vitest-config 1.0.0 → 1.0.1-alpha.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @interfere/vitest-config
+
+## 1.0.1-alpha.0
+
+### Patch Changes
+
+- [`477492c`](https://github.com/interfere-inc/repo/commit/477492c61dc69df8e270871b57483bd2bfcb7100) Thanks [@skve](https://github.com/skve)! - Progress

package/library.ts

@@ -1,6 +1,160 @@
-import { defineConfig } from "vitest/config";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { configDefaults, defineConfig } from "vitest/config";
+
+// Find monorepo root by walking up from this config file
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+const findRoot = (dir: string): string => {
+  if (existsSync(resolve(dir, "pnpm-workspace.yaml"))) {
+    return dir;
+  }
+
+  const parent = dirname(dir);
+
+  if (parent === dir) {
+    throw new Error("Could not find monorepo root");
+  }
+
+  return findRoot(parent);
+};
+
+const root = findRoot(__dirname);
+
+type PackageImportsMap = Record<
+  string,
+  { "@source"?: string; default?: string; types?: string }
+>;
+
+const packageJsonCache = new Map<
+  string,
+  { root: string; imports: PackageImportsMap } | null
+>();
+
+const findPackageRootForFile = (startFile: string) => {
+  let dir = dirname(startFile);
+
+  while (dir.startsWith(root)) {
+    const pj = resolve(dir, "package.json");
+    if (existsSync(pj)) {
+      return dir;
+    }
+    const parent = dirname(dir);
+
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+
+  return null;
+};
+
+const getPackageImportsForFile = (filePath: string) => {
+  const pkgRoot = findPackageRootForFile(filePath);
+  if (!pkgRoot) {
+    return null;
+  }
+
+  const cached = packageJsonCache.get(pkgRoot);
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  try {
+    const raw = readFileSync(resolve(pkgRoot, "package.json"), "utf8");
+    const parsed = JSON.parse(raw) as { imports?: PackageImportsMap };
+    const value = { root: pkgRoot, imports: parsed.imports ?? {} };
+    packageJsonCache.set(pkgRoot, value);
+    return value;
+  } catch {
+    packageJsonCache.set(pkgRoot, null);
+    return null;
+  }
+};
+
+const resolveSubpathImport = (
+  id: string,
+  importer: string | undefined
+): string | null => {
+  const getMappedTargetPath = (target: {
+    "@source"?: string;
+    default?: string;
+  }) => target["@source"] ?? target.default ?? null;
+
+  const getWildcardMatch = (pattern: string, specifier: string) => {
+    const starIndex = pattern.indexOf("*");
+    if (starIndex === -1) {
+      return null;
+    }
+
+    const prefix = pattern.slice(0, starIndex);
+    const suffix = pattern.slice(starIndex + 1);
+    if (!(specifier.startsWith(prefix) && specifier.endsWith(suffix))) {
+      return null;
+    }
+
+    return specifier.slice(prefix.length, specifier.length - suffix.length);
+  };
+
+  const pkg = getPackageImportsForFile(
+    importer ?? resolve(process.cwd(), "package.json")
+  );
+  if (!pkg) {
+    return null;
+  }
+
+  const entries = Object.entries(pkg.imports);
+
+  const exact = entries.find(([key]) => key === id);
+  if (exact) {
+    const mapped = getMappedTargetPath(exact[1]);
+    if (!mapped) {
+      return null;
+    }
+
+    return resolve(pkg.root, mapped);
+  }
+
+  for (const [key, target] of entries) {
+    const match = getWildcardMatch(key, id);
+    if (!match) {
+      continue;
+    }
+
+    const mapped = getMappedTargetPath(target);
+    if (!mapped) {
+      return null;
+    }
+
+    return resolve(pkg.root, mapped.replace("*", match));
+  }
+
+  return null;
+};
 
 export default defineConfig({
+  plugins: [
+    {
+      name: "interfere:package-imports",
+      enforce: "pre",
+      resolveId(id, importer) {
+        if (!id.startsWith("#")) {
+          return null;
+        }
+
+        return resolveSubpathImport(id, importer) ?? null;
+      },
+    },
+  ],
+  resolve: {
+    // Use @source condition so package exports resolve to .ts source files
+    // NOTE: `resolve.conditions` replaces Vite's defaults, so we keep the defaults and add `@source`.
+    // Default per Vite docs: ["module", "browser", "development|production"]
+    conditions: ["@source", "module", "browser", "development|production"],
+  },
   test: {
     environment: "node",
     globals: true,
@@ -9,17 +163,28 @@ export default defineConfig({
     sequence: {
       concurrent: false,
     },
+    exclude: [...configDefaults.exclude, "test/playwright/**"],
     coverage: {
+      provider: "v8",
       exclude: [
+        ...(configDefaults.coverage?.exclude ?? []),
+        // Test files
+        "**/*.test.*",
+        "**/*.spec.*",
         "__tests__/**",
-        "**/*.test.ts",
-        "**/*.test.tsx",
+        // Config files
+        "**/*.config.*",
+        "env.ts",
+        "keys.ts",
+        // Type declarations
         "**/*.d.ts",
-        "vitest.config.ts",
+        // Build artifacts
         "dist/**",
-        "node_modules/**",
-        ".turbo/**",
         "coverage/**",
+        ".next/**",
+        ".turbo/**",
+        // Next.js app boilerplate
+        "src/app/layout.tsx",
       ],
     },
   },

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@interfere/vitest-config",
-  "version": "1.0.0",
+  "version": "1.0.1-alpha.0",
   "license": "MIT",
   "type": "module",
-  "dependencies": {
-    "@total-typescript/ts-reset": "^0.6.1"
+  "exports": {
+    "./library": "./library.ts"
   },
   "devDependencies": {
-    "vitest": "^4.0.1"
+    "vitest": "^4.0.16"
   },
   "publishConfig": {
     "access": "public"