Fix ignore support in wds.js

Ignoring files outside the project directory, or folders at any level, was broken. This fixes it!

Author: airhorns

spec/ProjectConfig.spec.ts

@@ -0,0 +1,305 @@
+import fs from "fs-extra";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import { beforeEach, describe, expect, it } from "vitest";
+import { projectConfig } from "../src/ProjectConfig.js";
+
+const dirname = fileURLToPath(new URL(".", import.meta.url));
+
+describe("ProjectConfig", () => {
+  beforeEach(() => {
+    projectConfig.cache.clear?.();
+  });
+
+  describe("default configuration", () => {
+    it("should load default config when wds.js does not exist", async () => {
+      const nonExistentRoot = path.join(dirname, "fixtures/configs/non-existent");
+      await fs.ensureDir(nonExistentRoot);
+
+      const config = await projectConfig(nonExistentRoot);
+
+      expect(config.root).toBe(nonExistentRoot);
+      expect(config.extensions).toEqual([".ts", ".tsx", ".jsx"]);
+      expect(config.esm).toBe(true);
+      expect(config.includeGlob).toBe("**/*{.ts,.tsx,.jsx}");
+      // Default ignores should be applied
+      expect(config.includedMatcher("node_modules/package/index.ts")).toBe(false);
+      expect(config.includedMatcher("types.d.ts")).toBe(false);
+      expect(config.includedMatcher(".git/config.ts")).toBe(false);
+
+      await fs.remove(nonExistentRoot);
+    });
+
+    it("should set cacheDir relative to root", async () => {
+      const nonExistentRoot = path.join(dirname, "fixtures/configs/non-existent2");
+      await fs.ensureDir(nonExistentRoot);
+
+      const config = await projectConfig(nonExistentRoot);
+
+      expect(config.cacheDir).toBe(path.join(nonExistentRoot, "node_modules/.cache/wds"));
+
+      await fs.remove(nonExistentRoot);
+    });
+  });
+
+  describe("config file loading", () => {
+    it("should load empty config and merge with defaults", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.root).toBe(configRoot);
+      expect(config.extensions).toEqual([".ts", ".tsx", ".jsx"]);
+      expect(config.esm).toBe(true);
+    });
+
+    it("should use config from existing wds.js", async () => {
+      const configRoot = path.join(dirname, "fixtures/src/files_with_config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.root).toBe(configRoot);
+      expect(config.swc).toBeDefined();
+      expect((config.swc as any).jsc.target).toBe("es5");
+    });
+
+    it("should merge custom extensions with defaults", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/with-extensions");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.extensions).toEqual([".ts", ".js"]);
+      expect(config.includeGlob).toBe("**/*{.ts,.js}");
+    });
+  });
+
+  describe("file ignores", () => {
+    it("should work with both absolute and relative paths", async () => {
+      const configRoot = path.join(dirname, "fixtures/src/files_with_config");
+
+      const config = await projectConfig(configRoot);
+
+      // Relative paths
+      expect(config.includedMatcher("simple.ts")).toBe(true);
+      expect(config.includedMatcher("ignored.ts")).toBe(false);
+
+      // Absolute paths
+      expect(config.includedMatcher(path.join(configRoot, "simple.ts"))).toBe(true);
+      expect(config.includedMatcher(path.join(configRoot, "ignored.ts"))).toBe(false);
+
+      // Absolute paths outside root should be rejected
+      expect(config.includedMatcher("/some/other/path/file.ts")).toBe(false);
+    });
+
+    it("should match files with configured extensions", async () => {
+      const configRoot = path.join(dirname, "fixtures/src/files_with_config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("simple.ts")).toBe(true);
+      expect(config.includedMatcher("test.tsx")).toBe(true);
+      expect(config.includedMatcher("test.jsx")).toBe(true);
+    });
+
+    it("should not match files with wrong extensions", async () => {
+      const configRoot = path.join(dirname, "fixtures/src/files_with_config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("test.js")).toBe(false);
+      expect(config.includedMatcher("test.py")).toBe(false);
+      expect(config.includedMatcher("README.md")).toBe(false);
+    });
+
+    it("should not match explicitly ignored files", async () => {
+      const configRoot = path.join(dirname, "fixtures/src/files_with_config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("ignored.ts")).toBe(false);
+      expect(config.includedMatcher("simple.ts")).toBe(true);
+    });
+
+    it("should not match .d.ts files", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("types.d.ts")).toBe(false);
+      expect(config.includedMatcher("src/types.d.ts")).toBe(false);
+      expect(config.includedMatcher("types.ts")).toBe(true);
+    });
+
+    it("should not match files in node_modules", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("node_modules/package/index.ts")).toBe(false);
+      expect(config.includedMatcher("src/node_modules/package/index.ts")).toBe(false);
+    });
+
+    it("should not match the .git directory", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher(".git")).toBe(false);
+    });
+
+    it("should not match files in .git directory", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher(".git/config.ts")).toBe(false);
+      expect(config.includedMatcher(".git/hooks/pre-commit.ts")).toBe(false);
+    });
+
+    it("should match files with glob pattern ignores", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/basic-ignore");
+
+      const config = await projectConfig(configRoot);
+
+      expect(config.includedMatcher("src/file.ts")).toBe(true);
+      expect(config.includedMatcher("src/ignored/file.ts")).toBe(false);
+      expect(config.includedMatcher("file.test.ts")).toBe(false);
+      expect(config.includedMatcher("src/file.test.ts")).toBe(false);
+    });
+
+    it("should not match files outside project root even if they match extensions", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/empty-config");
+
+      const config = await projectConfig(configRoot);
+
+      // These paths are outside the project root
+      const outsideFile1 = path.resolve(configRoot, "../../outside-file.ts");
+      const outsideFile2 = path.resolve(configRoot, "../sibling/file.tsx");
+
+      // Make paths relative to config root for micromatch
+      const relativeOutside1 = path.relative(configRoot, outsideFile1);
+      const relativeOutside2 = path.relative(configRoot, outsideFile2);
+
+      // Files starting with ../ are outside the root
+      expect(relativeOutside1.startsWith("..")).toBe(true);
+      expect(relativeOutside2.startsWith("..")).toBe(true);
+
+      // The matcher should not match files outside the project root
+      // This tests the actual behavior of micromatch with cwd option
+      expect(config.includedMatcher(relativeOutside1)).toBe(false);
+      expect(config.includedMatcher(relativeOutside2)).toBe(false);
+    });
+
+    it("should not match directories outside project root", async () => {
+      const configRoot = path.join(dirname, "fixtures/configs/outside-root");
+
+      const config = await projectConfig(configRoot);
+      const exampleDir = path.join(path.dirname(path.dirname(configRoot)), "tmp");
+
+      // Should work with both relative and absolute paths
+      const relativeDir = path.relative(configRoot, exampleDir);
+      const relativeFile = path.relative(configRoot, path.join(exampleDir, "file.ts"));
+
+      expect(config.includedMatcher(relativeDir)).toBe(false);
+      expect(config.includedMatcher(relativeFile)).toBe(false);
+
+      // Should also work with absolute paths (and reject files outside root)
+      expect(config.includedMatcher(exampleDir)).toBe(false);
+      expect(config.includedMatcher(path.join(exampleDir, "file.ts"))).toBe(false);
+    });
+
+    it("should handle absolute paths in ignore patterns", async () => {
+      const tempRoot = path.join(dirname, "fixtures/configs/temp-absolute");
+      await fs.ensureDir(tempRoot);
+      const absoluteIgnore = "/some/absolute/path/*.ts";
+      await fs.writeFile(path.join(tempRoot, "wds.js"), `module.exports = { ignore: ["${absoluteIgnore}"] };`);
+
+      const config = await projectConfig(tempRoot);
+
+      // Absolute path patterns should be preserved and work
+      expect(config.includedMatcher("/some/absolute/path/file.ts")).toBe(false);
+      expect(config.includedMatcher("src/file.ts")).toBe(true);
+
+      await fs.remove(tempRoot);
+    });
+
+    it("should handle complex relative patterns outside root", async () => {
+      const tempRoot = path.join(dirname, "fixtures/configs/temp-complex");
+      await fs.ensureDir(tempRoot);
+      await fs.writeFile(path.join(tempRoot, "wds.js"), `module.exports = { ignore: ["../../../**/*.test.ts", "../../sibling/**"] };`);
+
+      const config = await projectConfig(tempRoot);
+
+      // Test that files matching these patterns are excluded
+      expect(config.includedMatcher("../../../some/file.test.ts")).toBe(false);
+      expect(config.includedMatcher("../../sibling/file.ts")).toBe(false);
+      expect(config.includedMatcher("src/file.ts")).toBe(true);
+
+      await fs.remove(tempRoot);
+    });
+  });
+
+  describe("cacheDir resolution", () => {
+    it("should resolve relative cacheDirs to absolute paths", async () => {
+      const tempRoot = path.join(dirname, "fixtures/configs/temp-cache");
+      await fs.ensureDir(tempRoot);
+      await fs.writeFile(path.join(tempRoot, "wds.js"), "module.exports = { cacheDir: '.cache/wds' };");
+
+      const config = await projectConfig(tempRoot);
+
+      expect(config.cacheDir).toBe(path.join(tempRoot, ".cache/wds"));
+      expect(path.isAbsolute(config.cacheDir)).toBe(true);
+
+      await fs.remove(tempRoot);
+    });
+
+    it("should keep absolute cacheDirs as-is", async () => {
+      const tempRoot = path.join(dirname, "fixtures/configs/temp-cache-abs");
+      const absoluteCacheDir = "/tmp/wds-cache";
+      await fs.ensureDir(tempRoot);
+      await fs.writeFile(path.join(tempRoot, "wds.js"), `module.exports = { cacheDir: "${absoluteCacheDir}" };`);
+
+      const config = await projectConfig(tempRoot);
+
+      expect(config.cacheDir).toBe(absoluteCacheDir);
+
+      await fs.remove(tempRoot);
+    });
+  });
+
+  it("should handle config with default export", async () => {
+    const tempRoot = path.join(dirname, "fixtures/configs/temp-default");
+    await fs.ensureDir(tempRoot);
+    await fs.writeFile(path.join(tempRoot, "wds.js"), "module.exports.default = { extensions: ['.ts'] };");
+
+    const config = await projectConfig(tempRoot);
+
+    expect(config.extensions).toEqual([".ts"]);
+
+    await fs.remove(tempRoot);
+  });
+
+  it("should handle config with esm: false", async () => {
+    const tempRoot = path.join(dirname, "fixtures/configs/temp-cjs");
+    await fs.ensureDir(tempRoot);
+    await fs.writeFile(path.join(tempRoot, "wds.js"), "module.exports = { esm: false };");
+
+    const config = await projectConfig(tempRoot);
+
+    expect(config.esm).toBe(false);
+
+    await fs.remove(tempRoot);
+  });
+
+  it("should generate correct includeGlob based on extensions", async () => {
+    const tempRoot = path.join(dirname, "fixtures/configs/temp-glob");
+    await fs.ensureDir(tempRoot);
+    await fs.writeFile(path.join(tempRoot, "wds.js"), "module.exports = { extensions: ['.ts', '.js', '.mjs'] };");
+
+    const config = await projectConfig(tempRoot);
+
+    expect(config.includeGlob).toBe("**/*{.ts,.js,.mjs}");
+
+    await fs.remove(tempRoot);
+  });
+});

spec/SwcCompiler.test.ts

@@ -44,7 +44,7 @@ test("throws if the file is ignored", async () => {
   expect(error).toBeTruthy();
   expect(error?.ignoredFile).toBeTruthy();
   expect(error?.message).toMatch(
-    /File .+ignored\.ts is imported but not being built because it is explicitly ignored in the wds project config\. It is being ignored by the provided glob pattern 'ignored\.ts', remove this pattern from the project config or don't import this file to fix./
+    /File .+ignored\.ts is imported but not being built because it is explicitly ignored in the wds project config\. It is being ignored by the provided glob pattern '\*\*\/ignored\.ts', remove this pattern from the project config or don't import this file to fix./
   );
 });
 

spec/fixtures/configs/basic-ignore/wds.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ignore: ["ignored/", "*.test.ts"]
+};

spec/fixtures/configs/empty-config/wds.js

@@ -0,0 +1 @@
+module.exports = {};

spec/fixtures/configs/outside-root/wds.js

@@ -0,0 +1,3 @@
+module.exports = {
+    ignore: ["../../some-external-file.ts", "../../../other-file.tsx", "../../tmp"]
+};

spec/fixtures/configs/with-extensions/wds.js

@@ -0,0 +1,4 @@
+module.exports = {
+    extensions: [".ts", ".js"],
+    ignore: ["**/*.spec.ts"]
+};

src/ProjectConfig.ts

@@ -17,6 +17,11 @@ export interface ProjectConfig {
   root: string;
   ignore: string[];
   includeGlob: string;
+  /**
+   * Checks if a file should be included in compilation.
+   * Accepts both absolute and relative paths (relative to project root).
+   * Returns false for files outside the project root.
+   */
   includedMatcher: (filePath: string) => boolean;
   swc?: SwcConfig;
   esm?: boolean;
@@ -66,9 +71,32 @@ export const projectConfig = _.memoize(async (root: string): Promise<ProjectConf
   }
 
   // build inclusion glob and matcher
-  result.ignore = _.uniq([`node_modules`, `**/*.d.ts`, `.git/**`, ...result.ignore]);
+  // Normalize ignore patterns to ensure they work correctly with micromatch
+  const normalizedIgnore = result.ignore.map((pattern) => {
+    // If pattern doesn't start with **, ./, ../, or /, prepend **/ to match at any depth
+    if (!pattern.startsWith("**/") && !pattern.startsWith("./") && !pattern.startsWith("../") && !pattern.startsWith("/")) {
+      pattern = `**/${pattern}`;
+    }
+    if (pattern.endsWith("/")) {
+      pattern = `${pattern}**`;
+    }
+    return pattern;
+  });
+
+  result.ignore = _.uniq([`**/node_modules/**`, `**/*.d.ts`, `**/.git/**`, ...normalizedIgnore]);
   result.includeGlob = `**/*{${result.extensions.join(",")}}`;
-  result.includedMatcher = micromatch.matcher(result.includeGlob, { cwd: result.root, ignore: result.ignore });
+
+  // Create a matcher that works with both absolute and relative paths
+  const relativeMatcher = micromatch.matcher(result.includeGlob, { cwd: result.root, ignore: result.ignore });
+  result.includedMatcher = (filePath: string) => {
+    if (path.isAbsolute(filePath)) {
+      const relativePath = path.relative(result.root, filePath);
+      // Don't match files outside the project root
+      if (relativePath.startsWith("..")) return false;
+      return relativeMatcher(relativePath);
+    }
+    return relativeMatcher(filePath);
+  };
 
   return result;
 });