jest-preset-angular 15.0.2 → 15.0.3

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## [15.0.3](https://github.com/thymikee/jest-preset-angular/compare/v15.0.2...v15.0.3) (2025-10-17)
+
+
+### Bug Fixes
+
+* handle `processWithEsbuild` transform option ([6779107](https://github.com/thymikee/jest-preset-angular/commit/67791077ea20b3a7f3dcf237ecbe35f2f9decd3f))
+
+
+
 ## [15.0.2](https://github.com/thymikee/jest-preset-angular/compare/v15.0.1...v15.0.2) (2025-10-01)
 
 
@@ -63,6 +72,15 @@
 
 
 
+## [14.6.2](https://github.com/thymikee/jest-preset-angular/compare/v14.6.1...v14.6.2) (2025-10-17)
+
+
+### Bug Fixes
+
+* handle `processWithEsbuild` transform option ([6779107](https://github.com/thymikee/jest-preset-angular/commit/67791077ea20b3a7f3dcf237ecbe35f2f9decd3f))
+
+
+
 ## [14.6.1](https://github.com/thymikee/jest-preset-angular/compare/v14.6.0...v14.6.1) (2025-07-21)
 
 

package/build/config/config.d.ts

@@ -0,0 +1,4 @@
+import type { TsJestTransformerOptions } from 'ts-jest';
+export type NgJestTransformerOptions = TsJestTransformerOptions & {
+    processWithEsbuild?: string[];
+};

package/build/config/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/config/global-setup.d.ts

@@ -0,0 +1 @@
+export declare const globalSetup: () => Promise<void>;

package/build/config/global-setup.js

@@ -0,0 +1,21 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalSetup = void 0;
+const ngcc_jest_processor_1 = require("../utils/ngcc-jest-processor");
+const globalSetup = () => __awaiter(void 0, void 0, void 0, function* () {
+    const ngJestConfig = globalThis.ngJest;
+    const tsconfig = ngJestConfig === null || ngJestConfig === void 0 ? void 0 : ngJestConfig.tsconfig;
+    if (!(ngJestConfig === null || ngJestConfig === void 0 ? void 0 : ngJestConfig.skipNgcc)) {
+        (0, ngcc_jest_processor_1.runNgccJestProcessor)(tsconfig);
+    }
+});
+exports.globalSetup = globalSetup;

package/build/config/ng-jest-config.js

@@ -9,6 +9,9 @@ class NgJestConfig extends ts_jest_1.ConfigSet {
     constructor(jestConfig, parentLogger) {
         super(jestConfig, parentLogger);
         const jestGlobalsConfig = jestConfig?.globals?.ngJest ?? Object.create(null);
+        if (jestGlobalsConfig.processWithEsbuild) {
+            this.logger.warn('Specifying `processWithEsbuild` in `ngJest` config is deprecated and will be removed in the next major version. Please follow this documentation https://thymikee.github.io/jest-preset-angular/docs/getting-started/options#processing-with-esbuild instead.');
+        }
         this.processWithEsbuild = (0, jest_util_1.globsToMatcher)([
             ...(jestGlobalsConfig.processWithEsbuild ?? []),
             ...defaultProcessWithEsbuildPatterns,

package/build/environments/jest-env-jsdom-abstract.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from 'node:vm';
+import type { EnvironmentContext, JestEnvironment, JestEnvironmentConfig } from '@jest/environment';
+import { LegacyFakeTimers, ModernFakeTimers } from '@jest/fake-timers';
+import type { Global } from '@jest/types';
+import { ModuleMocker } from 'jest-mock';
+import type * as jsdom from 'jsdom';
+type Win = Window & Global.Global & {
+    Error: {
+        stackTraceLimit: number;
+    };
+};
+export default abstract class BaseJSDOMEnvironment implements JestEnvironment<number> {
+    dom: jsdom.JSDOM | null;
+    fakeTimers: LegacyFakeTimers<number> | null;
+    fakeTimersModern: ModernFakeTimers | null;
+    global: Win;
+    private errorEventListener;
+    moduleMocker: ModuleMocker | null;
+    customExportConditions: string[];
+    private readonly _configuredExportConditions?;
+    protected constructor(config: JestEnvironmentConfig, context: EnvironmentContext, jsdomModule: typeof jsdom);
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+    exportConditions(): Array<string>;
+    getVmContext(): Context | null;
+}
+export {};

package/build/environments/jest-env-jsdom-abstract.js

@@ -0,0 +1,122 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fake_timers_1 = require("@jest/fake-timers");
+const jest_mock_1 = require("jest-mock");
+const jest_util_1 = require("jest-util");
+function isString(value) {
+    return typeof value === 'string';
+}
+class BaseJSDOMEnvironment {
+    constructor(config, context, jsdomModule) {
+        this.customExportConditions = ['browser'];
+        const { projectConfig } = config;
+        const { JSDOM, ResourceLoader, VirtualConsole } = jsdomModule;
+        const virtualConsole = new VirtualConsole();
+        virtualConsole.sendTo(context.console, { omitJSDOMErrors: true });
+        virtualConsole.on('jsdomError', (error) => {
+            context.console.error(error);
+        });
+        this.dom = new JSDOM(typeof projectConfig.testEnvironmentOptions.html === 'string'
+            ? projectConfig.testEnvironmentOptions.html
+            : '<!DOCTYPE html>', Object.assign({ pretendToBeVisual: true, resources: typeof projectConfig.testEnvironmentOptions.userAgent === 'string'
+                ? new ResourceLoader({
+                    userAgent: projectConfig.testEnvironmentOptions.userAgent,
+                })
+                : undefined, runScripts: 'dangerously', url: 'http://localhost/', virtualConsole }, projectConfig.testEnvironmentOptions));
+        const global = (this.global = this.dom.window);
+        if (global == null) {
+            throw new Error('JSDOM did not return a Window object');
+        }
+        global.global = global;
+        this.global.Error.stackTraceLimit = 100;
+        (0, jest_util_1.installCommonGlobals)(global, projectConfig.globals);
+        this.errorEventListener = (event) => {
+            if (userErrorListenerCount === 0 && event.error != null) {
+                process.emit('uncaughtException', event.error);
+            }
+        };
+        global.addEventListener('error', this.errorEventListener);
+        const originalAddListener = global.addEventListener.bind(global);
+        const originalRemoveListener = global.removeEventListener.bind(global);
+        let userErrorListenerCount = 0;
+        global.addEventListener = function (...args) {
+            if (args[0] === 'error') {
+                userErrorListenerCount++;
+            }
+            return originalAddListener.apply(this, args);
+        };
+        global.removeEventListener = function (...args) {
+            if (args[0] === 'error') {
+                userErrorListenerCount--;
+            }
+            return originalRemoveListener.apply(this, args);
+        };
+        if ('customExportConditions' in projectConfig.testEnvironmentOptions) {
+            const { customExportConditions } = projectConfig.testEnvironmentOptions;
+            if (Array.isArray(customExportConditions) && customExportConditions.every(isString)) {
+                this._configuredExportConditions = customExportConditions;
+            }
+            else {
+                throw new Error('Custom export conditions specified but they are not an array of strings');
+            }
+        }
+        this.moduleMocker = new jest_mock_1.ModuleMocker(global);
+        this.fakeTimers = new fake_timers_1.LegacyFakeTimers({
+            config: projectConfig,
+            global: global,
+            moduleMocker: this.moduleMocker,
+            timerConfig: {
+                idToRef: (id) => id,
+                refToId: (ref) => ref,
+            },
+        });
+        this.fakeTimersModern = new fake_timers_1.ModernFakeTimers({
+            config: projectConfig,
+            global: global,
+        });
+    }
+    setup() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    teardown() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.fakeTimers) {
+                this.fakeTimers.dispose();
+            }
+            if (this.fakeTimersModern) {
+                this.fakeTimersModern.dispose();
+            }
+            if (this.global != null) {
+                if (this.errorEventListener) {
+                    this.global.removeEventListener('error', this.errorEventListener);
+                }
+                this.global.close();
+            }
+            this.errorEventListener = null;
+            this.global = null;
+            this.dom = null;
+            this.fakeTimers = null;
+            this.fakeTimersModern = null;
+        });
+    }
+    exportConditions() {
+        var _a;
+        return (_a = this._configuredExportConditions) !== null && _a !== void 0 ? _a : this.customExportConditions;
+    }
+    getVmContext() {
+        if (this.dom) {
+            return this.dom.getInternalVMContext();
+        }
+        return null;
+    }
+}
+exports.default = BaseJSDOMEnvironment;

package/build/environments/mockable-jsdom.d.ts

@@ -0,0 +1,6 @@
+import * as jsdom from 'jsdom';
+export declare class MockableJSDOM extends jsdom.JSDOM {
+    #private;
+    constructor(html?: string, options?: jsdom.ConstructorOptions);
+    get window(): jsdom.DOMWindow;
+}

package/build/environments/mockable-jsdom.js

@@ -0,0 +1,153 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockableJSDOM = void 0;
+const jsdom = __importStar(require("jsdom"));
+class DummyLocation {
+    _hash = '';
+    _host = '';
+    _hostname = '';
+    _href = '';
+    _origin = '';
+    _pathname = '';
+    _port = '';
+    _protocol = '';
+    _search = '';
+    get hash() {
+        return this._hash;
+    }
+    set hash(value) {
+        this._hash = value;
+    }
+    get host() {
+        return this._host;
+    }
+    set host(value) {
+        this._host = value;
+    }
+    get hostname() {
+        return this._hostname;
+    }
+    set hostname(value) {
+        this._hostname = value;
+    }
+    get href() {
+        return this._href;
+    }
+    set href(value) {
+        this._href = value;
+    }
+    get origin() {
+        return this._origin;
+    }
+    set origin(value) {
+        this._origin = value;
+    }
+    get pathname() {
+        return this._pathname;
+    }
+    set pathname(value) {
+        this._pathname = value;
+    }
+    get port() {
+        return this._port;
+    }
+    set port(value) {
+        this._port = value;
+    }
+    get protocol() {
+        return this._protocol;
+    }
+    set protocol(value) {
+        this._protocol = value;
+    }
+    get search() {
+        return this._search;
+    }
+    set search(value) {
+        this._search = value;
+    }
+    toString() {
+        return this._href;
+    }
+    assign(url) {
+        this._href = String(url);
+    }
+    reload() { }
+    replace(url) {
+        this._href = String(url);
+    }
+}
+class MockableJSDOM extends jsdom.JSDOM {
+    #mockLocation = new DummyLocation();
+    #originalWindow;
+    #documentProxy;
+    #windowProxy;
+    constructor(html, options) {
+        super(html, options);
+        this.#originalWindow = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Object.getPrototypeOf(this)), 'window').get.call(this);
+        this.#documentProxy = new Proxy(this.#originalWindow.document, {
+            get: (target, prop, receiver) => {
+                if (prop !== 'location')
+                    return Reflect.get(target, prop, receiver);
+                return this.#mockLocation;
+            },
+            set: (target, prop, value, receiver) => {
+                if (prop === 'location') {
+                    return true;
+                }
+                return Reflect.set(target, prop, value, receiver);
+            },
+        });
+        this.#windowProxy = new Proxy(this.#originalWindow, {
+            get: (target, prop, receiver) => {
+                switch (prop) {
+                    case 'document':
+                        return this.#documentProxy;
+                    case 'location':
+                        return this.#mockLocation;
+                    default: {
+                        const value = Reflect.get(target, prop, target);
+                        return value;
+                    }
+                }
+            },
+        });
+    }
+    get window() {
+        return this.#windowProxy;
+    }
+}
+exports.MockableJSDOM = MockableJSDOM;

package/build/ng-jest-transformer.d.ts

@@ -1,8 +1,9 @@
 import type { TransformedSource } from '@jest/transform';
-import { type TsJestTransformerOptions, ConfigSet, TsJestTransformer, type TsJestTransformOptions } from 'ts-jest';
+import { ConfigSet, TsJestTransformer, type TsJestTransformOptions } from 'ts-jest';
+import type { NgJestTransformerOptions } from './config/config';
 export declare class NgJestTransformer extends TsJestTransformer {
     #private;
-    constructor(tsJestConfig?: TsJestTransformerOptions);
+    constructor(transformerConfig?: NgJestTransformerOptions);
     protected _createConfigSet(config: TsJestTransformOptions['config'] | undefined): ConfigSet;
     protected _createCompiler(configSet: ConfigSet, cacheFS: Map<string, string>): void;
     private get version();

package/build/ng-jest-transformer.js

@@ -4,6 +4,7 @@ exports.NgJestTransformer = void 0;
 const node_crypto_1 = require("node:crypto");
 const bs_logger_1 = require("bs-logger");
 const esbuild_1 = require("esbuild");
+const jest_util_1 = require("jest-util");
 const ts_jest_1 = require("ts-jest");
 const compiler_utils_1 = require("ts-jest/dist/legacy/compiler/compiler-utils");
 const ng_jest_compiler_1 = require("./compiler/ng-jest-compiler");
@@ -35,7 +36,9 @@ const sha1 = (...data) => {
 };
 class NgJestTransformer extends ts_jest_1.TsJestTransformer {
     #ngJestLogger;
-    constructor(tsJestConfig) {
+    #processWithEsbuild;
+    constructor(transformerConfig) {
+        const { processWithEsbuild, ...tsJestConfig } = transformerConfig ?? {};
         super(tsJestConfig);
         this.#ngJestLogger = (0, bs_logger_1.createLogger)({
             context: {
@@ -45,6 +48,7 @@ class NgJestTransformer extends ts_jest_1.TsJestTransformer {
             },
             targets: process.env.NG_JEST_LOG ?? undefined,
         });
+        this.#processWithEsbuild = (0, jest_util_1.globsToMatcher)(processWithEsbuild ?? []);
     }
     _createConfigSet(config) {
         return new ng_jest_config_1.NgJestConfig(config);
@@ -57,7 +61,7 @@ class NgJestTransformer extends ts_jest_1.TsJestTransformer {
     }
     process(fileContent, filePath, transformOptions) {
         const configSet = super._configsFor(transformOptions);
-        if (configSet.processWithEsbuild(filePath)) {
+        if (configSet.processWithEsbuild(filePath) || this.#processWithEsbuild(filePath)) {
             this.#ngJestLogger.debug({ filePath }, 'process with esbuild');
             const compilerOpts = configSet.parsedTsConfig.options;
             const useESM = transformOptions.supportsStaticESM && configSet.useESM;

package/build/resolvers/ng-jest-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { SyncResolver } from 'jest-resolve';
+declare const ngJestResolver: SyncResolver;
+export = ngJestResolver;

package/build/resolvers/ng-jest-resolver.js

@@ -0,0 +1,7 @@
+"use strict";
+const ngJestResolver = (path, options) => {
+    return options.defaultResolver(path, Object.assign(Object.assign({}, options), { packageFilter(pkg) {
+            return Object.assign(Object.assign({}, pkg), { main: pkg.main || pkg.es2015 || pkg.module });
+        } }));
+};
+module.exports = ngJestResolver;