Merge branch 'main' into claude/fix-bun-test-globals-issue-4007

Removed the logic that would skip injecting test globals when importing from
any test framework (@jest/globals, vitest, or bun:test). Now test globals are
always available when inject_jest_globals is enabled, providing a consistent
experience regardless of which test framework imports are used.

This allows mixing explicit imports with global usage patterns for all test
frameworks, not just bun:test.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/ast/Parser.zig

@@ -1184,20 +1184,6 @@ pub const Parser = struct {
         if (p.options.features.inject_jest_globals) outer: {
             var jest: *Jest = &p.jest;
 
-            for (p.import_records.items) |*item| {
-                // skip if they did import it
-                if (strings.eqlComptime(item.path.text, "bun:test") or strings.eqlComptime(item.path.text, "@jest/globals") or strings.eqlComptime(item.path.text, "vitest")) {
-                    if (p.options.features.runtime_transpiler_cache) |cache| {
-                        // If we rewrote import paths, we need to disable the runtime transpiler cache
-                        if (!strings.eqlComptime(item.path.text, "bun:test")) {
-                            cache.input_hash = null;
-                        }
-                    }
-
-                    break :outer;
-                }
-            }
-
             // if they didn't use any of the jest globals, don't inject it, I guess.
             const items_count = brk: {
                 var count: usize = 0;

test/regression/issue/test-import-multiple-globals.test.ts

@@ -0,0 +1,21 @@
+import { mock, spyOn } from "bun:test";
+
+const mockTrue = mock(() => true);
+const mockFalse = mock(() => false);
+
+test("should work with multiple imports from bun:test", () => {
+  expect(mockTrue()).toEqual(true);
+  expect(mockFalse()).toEqual(false);
+});
+
+describe("spyOn should work", () => {
+  const obj = { foo: () => "original" };
+
+  beforeEach(() => {
+    spyOn(obj, "foo").mockReturnValue("mocked");
+  });
+
+  it("should spy on methods", () => {
+    expect(obj.foo()).toBe("mocked");
+  });
+});

test/regression/issue/test-import-namespace.test.ts

@@ -0,0 +1,16 @@
+import * as BunTest from "bun:test";
+
+const mockTrue = BunTest.mock(() => true);
+
+test("should work with namespace import from bun:test", () => {
+  expect(mockTrue()).toEqual(true);
+});
+
+describe("namespace import with globals should work", () => {
+  it("should have access to test globals", () => {
+    expect(typeof test).toBe("function");
+    expect(typeof describe).toBe("function");
+    expect(typeof it).toBe("function");
+    expect(typeof expect).toBe("function");
+  });
+});

test/regression/issue/test-import-with-globals.test.ts

@@ -0,0 +1,7 @@
+import { mock } from "bun:test";
+
+const mockTrue = mock(() => true);
+
+test("should work with explicit import from bun:test", () => {
+  expect(mockTrue()).toEqual(true);
+});

test/regression/issue/test-jest-globals-import.test.ts

@@ -0,0 +1,13 @@
+import { expect as jestExpect, test as jestTest } from "@jest/globals";
+
+// Test that bun's test globals are still available even with @jest/globals import
+test("should have bun test globals available with @jest/globals import", () => {
+  expect(typeof test).toBe("function");
+  expect(typeof expect).toBe("function");
+  expect(typeof describe).toBe("function");
+});
+
+// Test that jest imports also work
+jestTest("jest imports should work too", () => {
+  jestExpect(1 + 1).toBe(2);
+});

test/regression/issue/test-mixed-imports.test.ts

@@ -0,0 +1,25 @@
+// Test mixing named imports with default globals usage
+import { mock } from "bun:test";
+
+const mockPath = mock(() => "/mocked/path");
+
+test("should work with mixed imports", () => {
+  // Using imported mock
+  expect(mockPath()).toEqual("/mocked/path");
+
+  // Using global test functions
+  expect("a/b").toBe("a/b");
+});
+
+describe("mixed imports should not interfere", () => {
+  beforeAll(() => {
+    // This should work - beforeAll should be available as global
+  });
+
+  it("should have all test globals available", () => {
+    expect(typeof beforeAll).toBe("function");
+    expect(typeof afterAll).toBe("function");
+    expect(typeof beforeEach).toBe("function");
+    expect(typeof afterEach).toBe("function");
+  });
+});