jest-preset-angular 14.2.3 → 14.3.0

package/CHANGELOG.md

@@ -1,3 +1,51 @@
+## [14.3.0](https://github.com/thymikee/jest-preset-angular/compare/v14.2.4...v14.3.0) (2024-11-15)
+
+
+### Features
+
+* feat: add new setup test env functions ([21c0238](https://github.com/thymikee/jest-preset-angular/commit/21c0238)), closes [#354](https://github.com/thymikee/jest-preset-angular/issues/354) [#2755](https://github.com/thymikee/jest-preset-angular/issues/2755)
+* feat: build package with type definitions ([a269daa](https://github.com/thymikee/jest-preset-angular/commit/a269daa))
+* feat: deprecate `setup-jest.js` and `setup-jest.mjs` ([a304036](https://github.com/thymikee/jest-preset-angular/commit/a304036))
+
+
+### Code Refactoring
+
+* test: switch example app test config files to ts ([e61f1ff](https://github.com/thymikee/jest-preset-angular/commit/e61f1ff))
+
+
+## DEPRECATIONS
+
+Importing `setup-jest.js`/`setup-jest.mjs` directly is deprecated. The files will be removed in the future.
+
+Please use "setupZoneTestEnv" function instead. Example:
+
+For CJS
+```
+// setup-jest.ts
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env';
+
+setupZoneTestEnv();
+```
+
+For ESM
+```
+// setup-jest.ts
+import { setupZoneTestEnv } from 'jest-preset-angular/setup-env/index.mjs';
+
+setupZoneTestEnv();
+```
+
+
+
+## [14.2.4](https://github.com/thymikee/jest-preset-angular/compare/v14.2.3...v14.2.4) (2024-09-12)
+
+
+### Bug Fixes
+
+* build: ensure build step runs before publishing ([3a602db](https://github.com/thymikee/jest-preset-angular/commit/3a602db))
+
+
+
 ## [14.2.3](https://github.com/thymikee/jest-preset-angular/compare/v14.2.2...v14.2.3) (2024-09-12)
 
 

package/README.md

@@ -5,7 +5,7 @@
 <p align="center">
     <a href="https://actions-badge.atrox.dev/thymikee/jest-preset-angular/goto?ref=main"><img alt="Build Status" src="https://img.shields.io/endpoint.svg?url=https%3A%2F%2Factions-badge.atrox.dev%2Fthymikee%2Fjest-preset-angular%2Fbadge%3Fref%3Dmain&style=flat-square" /></a>
     <a href="https://www.npmjs.com/package/jest-preset-angular"><img src="https://img.shields.io/npm/v/jest-preset-angular/latest.svg?style=flat-square" alt="NPM Version" /></a>
-    <a href="https://github.com/thymikee/jest-preset-angular/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/jest-preset-angular.svg?style=flat-square" alt="GitHub license" /></a>
+    <a href="https://github.com/thymikee/jest-preset-angular/blob/main/LICENSE.md"><img src="https://img.shields.io/npm/l/jest-preset-angular.svg?style=flat-square" alt="GitHub license" /></a>
 </p>
 
 > Our online documentation is available at https://thymikee.github.io/jest-preset-angular/

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

@@ -0,0 +1,11 @@
+import { type TsJestAstTransformer, TsCompiler, type ConfigSet } from 'ts-jest';
+import type ts from 'typescript';
+export declare class NgJestCompiler extends TsCompiler {
+    readonly configSet: ConfigSet;
+    readonly jestCacheFS: Map<string, string>;
+    private readonly _defaultLibDirPath;
+    private readonly _libSourceFileCache;
+    constructor(configSet: ConfigSet, jestCacheFS: Map<string, string>);
+    protected _transpileOutput(fileContent: string, filePath: string): ts.TranspileOutput;
+    protected _makeTransformers(customTransformers: TsJestAstTransformer): ts.CustomTransformers;
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NgJestCompiler = void 0;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const ts_jest_1 = require("ts-jest");
+const jit_transform_1 = require("../transformers/jit_transform");
+const replace_resources_1 = require("../transformers/replace-resources");
+class NgJestCompiler extends ts_jest_1.TsCompiler {
+    constructor(configSet, jestCacheFS) {
+        super(configSet, jestCacheFS);
+        this.configSet = configSet;
+        this.jestCacheFS = jestCacheFS;
+        this._libSourceFileCache = new Map();
+        this._logger.debug('created NgJestCompiler');
+        this._defaultLibDirPath = node_path_1.default.dirname(this._ts.getDefaultLibFilePath(this._compilerOptions));
+    }
+    _transpileOutput(fileContent, filePath) {
+        var _a;
+        const scriptTarget = (_a = this._compilerOptions.target) !== null && _a !== void 0 ? _a : this._ts.ScriptTarget.Latest;
+        const sourceFile = this._ts.createSourceFile(filePath, fileContent, scriptTarget);
+        const compilerHost = {
+            getSourceFile: (fileName) => {
+                var _a;
+                if (fileName === node_path_1.default.normalize(filePath)) {
+                    return sourceFile;
+                }
+                let libSourceFile = this._libSourceFileCache.get(fileName);
+                if (!libSourceFile) {
+                    const libFilePath = node_path_1.default.join(this._defaultLibDirPath, fileName);
+                    const libFileContent = (_a = this._ts.sys.readFile(libFilePath)) !== null && _a !== void 0 ? _a : '';
+                    if (libFileContent) {
+                        libSourceFile = this._ts.createSourceFile(fileName, libFileContent, scriptTarget);
+                        this._libSourceFileCache.set(fileName, libSourceFile);
+                    }
+                }
+                return libSourceFile;
+            },
+            writeFile: () => { },
+            getDefaultLibFileName: () => 'lib.d.ts',
+            useCaseSensitiveFileNames: () => false,
+            getCanonicalFileName: (fileName) => fileName,
+            getCurrentDirectory: () => '',
+            getNewLine: () => node_os_1.default.EOL,
+            fileExists: (fileName) => fileName === filePath,
+            readFile: () => '',
+            directoryExists: () => true,
+            getDirectories: () => [],
+        };
+        this.program = this._ts.createProgram([filePath], this._compilerOptions, compilerHost);
+        return this._ts.transpileModule(fileContent, {
+            fileName: filePath,
+            transformers: this._makeTransformers(this.configSet.resolvedTransformers),
+            compilerOptions: this._compilerOptions,
+            reportDiagnostics: this.configSet.shouldReportDiagnostics(filePath),
+        });
+    }
+    _makeTransformers(customTransformers) {
+        var _a;
+        const allTransformers = super._makeTransformers(customTransformers);
+        return Object.assign(Object.assign(Object.assign({}, allTransformers.after), allTransformers.afterDeclarations), { before: [
+                ...((_a = allTransformers.before) !== null && _a !== void 0 ? _a : []),
+                (0, replace_resources_1.replaceResources)(this.program),
+                (0, jit_transform_1.angularJitApplicationTransform)(this.program),
+            ] });
+    }
+}
+exports.NgJestCompiler = NgJestCompiler;

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.d.ts

@@ -0,0 +1,9 @@
+import type { Logger } from 'bs-logger';
+import { globsToMatcher } from 'jest-util';
+import { type RawCompilerOptions, ConfigSet, type TsJestTransformOptions } from 'ts-jest';
+import type { ParsedCommandLine } from 'typescript';
+export declare class NgJestConfig extends ConfigSet {
+    readonly processWithEsbuild: ReturnType<typeof globsToMatcher>;
+    constructor(jestConfig: TsJestTransformOptions['config'] | undefined, parentLogger?: Logger | undefined);
+    protected _resolveTsConfig(compilerOptions?: RawCompilerOptions, resolvedConfigFile?: string): ParsedCommandLine;
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NgJestConfig = void 0;
+const jest_util_1 = require("jest-util");
+const ts_jest_1 = require("ts-jest");
+const defaultProcessWithEsbuildPatterns = ['**/*.mjs'];
+class NgJestConfig extends ts_jest_1.ConfigSet {
+    constructor(jestConfig, parentLogger) {
+        var _a, _b, _c;
+        super(jestConfig, parentLogger);
+        const jestGlobalsConfig = (_b = (_a = jestConfig === null || jestConfig === void 0 ? void 0 : jestConfig.globals) === null || _a === void 0 ? void 0 : _a.ngJest) !== null && _b !== void 0 ? _b : Object.create(null);
+        this.processWithEsbuild = (0, jest_util_1.globsToMatcher)([
+            ...((_c = jestGlobalsConfig.processWithEsbuild) !== null && _c !== void 0 ? _c : []),
+            ...defaultProcessWithEsbuildPatterns,
+        ]);
+    }
+    _resolveTsConfig(compilerOptions, resolvedConfigFile) {
+        const result = super._resolveTsConfig(compilerOptions, resolvedConfigFile);
+        result.options.enableIvy = true;
+        result.options.noEmitOnError = false;
+        result.options.suppressOutputPathCheck = true;
+        result.options.allowEmptyCodegenFiles = false;
+        result.options.annotationsAs = 'decorators';
+        result.options.enableResourceInlining = false;
+        result.options.allowJs = true;
+        return result;
+    }
+}
+exports.NgJestConfig = NgJestConfig;

package/build/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const TEMPLATE_URL = "templateUrl";
+export declare const STYLE_URLS = "styleUrls";
+export declare const STYLE_URL = "styleUrl";
+export declare const STYLES = "styles";
+export declare const TEMPLATE = "template";
+export declare const REQUIRE = "require";
+export declare const COMPONENT = "Component";

package/build/constants.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPONENT = exports.REQUIRE = exports.TEMPLATE = exports.STYLES = exports.STYLE_URL = exports.STYLE_URLS = exports.TEMPLATE_URL = void 0;
+exports.TEMPLATE_URL = 'templateUrl';
+exports.STYLE_URLS = 'styleUrls';
+exports.STYLE_URL = 'styleUrl';
+exports.STYLES = 'styles';
+exports.TEMPLATE = 'template';
+exports.REQUIRE = 'require';
+exports.COMPONENT = 'Component';

package/build/index.d.ts

@@ -0,0 +1,6 @@
+import type { TsJestTransformerOptions } from 'ts-jest';
+import { NgJestTransformer } from './ng-jest-transformer';
+declare const _default: {
+    createTransformer: (tsJestConfig?: TsJestTransformerOptions) => NgJestTransformer;
+};
+export default _default;

package/build/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ng_jest_transformer_1 = require("./ng-jest-transformer");
+exports.default = {
+    createTransformer: (tsJestConfig) => new ng_jest_transformer_1.NgJestTransformer(tsJestConfig),
+};

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

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

package/build/ng-jest-transformer.js

@@ -0,0 +1,66 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _NgJestTransformer_ngJestLogger;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NgJestTransformer = void 0;
+const bs_logger_1 = require("bs-logger");
+const esbuild_1 = require("esbuild");
+const ts_jest_1 = require("ts-jest");
+const ng_jest_compiler_1 = require("./compiler/ng-jest-compiler");
+const ng_jest_config_1 = require("./config/ng-jest-config");
+class NgJestTransformer extends ts_jest_1.TsJestTransformer {
+    constructor(tsJestConfig) {
+        var _a;
+        super(tsJestConfig);
+        _NgJestTransformer_ngJestLogger.set(this, void 0);
+        __classPrivateFieldSet(this, _NgJestTransformer_ngJestLogger, (0, bs_logger_1.createLogger)({
+            context: {
+                [bs_logger_1.LogContexts.package]: 'jest-preset-angular',
+                [bs_logger_1.LogContexts.logLevel]: bs_logger_1.LogLevels.trace,
+                version: require('../package.json').version,
+            },
+            targets: (_a = process.env.NG_JEST_LOG) !== null && _a !== void 0 ? _a : undefined,
+        }), "f");
+    }
+    _createConfigSet(config) {
+        return new ng_jest_config_1.NgJestConfig(config);
+    }
+    _createCompiler(configSet, cacheFS) {
+        this._compiler = new ng_jest_compiler_1.NgJestCompiler(configSet, cacheFS);
+    }
+    process(fileContent, filePath, transformOptions) {
+        const configSet = super._configsFor(transformOptions);
+        if (configSet.processWithEsbuild(filePath)) {
+            __classPrivateFieldGet(this, _NgJestTransformer_ngJestLogger, "f").debug({ filePath }, 'process with esbuild');
+            const compilerOpts = configSet.parsedTsConfig.options;
+            const { code, map } = (0, esbuild_1.transformSync)(fileContent, {
+                loader: 'js',
+                format: transformOptions.supportsStaticESM && configSet.useESM ? 'esm' : 'cjs',
+                target: compilerOpts.target === configSet.compilerModule.ScriptTarget.ES2015 ? 'es2015' : 'es2016',
+                sourcemap: compilerOpts.sourceMap,
+                sourcefile: filePath,
+                sourcesContent: true,
+                sourceRoot: compilerOpts.sourceRoot,
+            });
+            return {
+                code,
+                map,
+            };
+        }
+        else {
+            return super.process(fileContent, filePath, transformOptions);
+        }
+    }
+}
+exports.NgJestTransformer = NgJestTransformer;
+_NgJestTransformer_ngJestLogger = new WeakMap();

package/build/presets/index.d.ts

@@ -0,0 +1,39 @@
+import type { TsJestTransformerOptions } from 'ts-jest';
+declare const defaultTransformerOptions: TsJestTransformerOptions;
+declare const defaultPreset: {
+    transformIgnorePatterns: string[];
+    transform: {
+        '^.+\\.(ts|js|mjs|html|svg)$': (string | import("ts-jest").TsJestGlobalOptions)[];
+    };
+    testEnvironment?: string | undefined;
+    moduleFileExtensions?: string[] | undefined;
+    snapshotSerializers?: string[] | undefined;
+};
+declare const defaultEsmPreset: {
+    extensionsToTreatAsEsm: string[];
+    moduleNameMapper: {
+        tslib: string;
+    };
+    transform: {
+        '^.+\\.(ts|js|html|svg)$': (string | {
+            useESM: boolean;
+            tsconfig?: boolean | string | import("ts-jest").RawCompilerOptions;
+            isolatedModules?: boolean;
+            compiler?: "typescript" | "ttypescript" | string;
+            astTransformers?: import("ts-jest").ConfigCustomTransformer;
+            diagnostics?: boolean | {
+                pretty?: boolean;
+                ignoreCodes?: number | string | Array<number | string>;
+                exclude?: string[];
+                warnOnly?: boolean;
+            };
+            babelConfig?: boolean | string | import("ts-jest").BabelConfig;
+            stringifyContentPathRegex?: string | RegExp;
+        })[];
+    };
+    transformIgnorePatterns: string[];
+    testEnvironment?: string | undefined;
+    moduleFileExtensions?: string[] | undefined;
+    snapshotSerializers?: string[] | undefined;
+};
+export { defaultPreset, defaultEsmPreset, defaultTransformerOptions };

package/build/presets/index.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTransformerOptions = exports.defaultEsmPreset = exports.defaultPreset = void 0;
+const serializers_1 = __importDefault(require("../serializers"));
+const baseConfig = {
+    testEnvironment: 'jsdom',
+    moduleFileExtensions: ['ts', 'html', 'js', 'json', 'mjs'],
+    snapshotSerializers: serializers_1.default,
+};
+const defaultTransformerOptions = {
+    tsconfig: '<rootDir>/tsconfig.spec.json',
+    stringifyContentPathRegex: '\\.(html|svg)$',
+};
+exports.defaultTransformerOptions = defaultTransformerOptions;
+const defaultPreset = Object.assign(Object.assign({}, baseConfig), { transformIgnorePatterns: ['node_modules/(?!.*\\.mjs$)'], transform: {
+        '^.+\\.(ts|js|mjs|html|svg)$': ['jest-preset-angular', defaultTransformerOptions],
+    } });
+exports.defaultPreset = defaultPreset;
+const defaultEsmPreset = Object.assign(Object.assign({}, baseConfig), { extensionsToTreatAsEsm: ['.ts'], moduleNameMapper: {
+        tslib: 'tslib/tslib.es6.js',
+    }, transform: {
+        '^.+\\.(ts|js|html|svg)$': [
+            'jest-preset-angular',
+            Object.assign(Object.assign({}, defaultTransformerOptions), { useESM: true }),
+        ],
+    }, transformIgnorePatterns: ['node_modules/(?!tslib)'] });
+exports.defaultEsmPreset = defaultEsmPreset;

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;

package/build/serializers/html-comment.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    serialize: () => string;
+    test: (value: any) => boolean;
+};
+export = _default;

package/build/serializers/html-comment.js

@@ -0,0 +1,8 @@
+"use strict";
+const HTML_ELEMENT_REGEXP = /Comment/;
+const test = (value) => (value === null || value === void 0 ? void 0 : value.nodeType) === 8 && value.constructor !== undefined && HTML_ELEMENT_REGEXP.test(value.constructor.name);
+const serialize = () => '';
+module.exports = {
+    serialize,
+    test,
+};

package/build/serializers/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export = _default;

package/build/serializers/index.js

@@ -0,0 +1,6 @@
+"use strict";
+module.exports = [
+    'jest-preset-angular/build/serializers/html-comment',
+    'jest-preset-angular/build/serializers/ng-snapshot',
+    'jest-preset-angular/build/serializers/no-ng-attributes',
+];

package/build/serializers/ng-snapshot.d.ts

@@ -0,0 +1,11 @@
+import type { OldPlugin } from 'pretty-format';
+type PluginPrintFnArgs = Parameters<OldPlugin['print']>;
+type NgSnapshotOptions = {
+    omitAllCompAttrs?: boolean;
+};
+type PluginPrintFn = (fixture: PluginPrintFnArgs[0], printer: PluginPrintFnArgs[1], indent: PluginPrintFnArgs[2], opts: PluginPrintFnArgs[3] & NgSnapshotOptions, colors: PluginPrintFnArgs[4]) => string;
+declare const _default: {
+    print: PluginPrintFn;
+    test: (arg0: any) => boolean;
+};
+export = _default;

package/build/serializers/ng-snapshot.js

@@ -0,0 +1,48 @@
+"use strict";
+const attributesToRemovePatterns = ['__ngContext__'];
+const removeTrailingWhiteSpaces = (serializedComponent) => {
+    return serializedComponent.replace(/\n^\s*\n/gm, '\n');
+};
+const print = (fixture, printer, indent, opts, colors) => {
+    const { componentRef, componentInstance } = fixture;
+    const componentDef = componentRef.componentType.ɵcmp;
+    const componentName = componentDef.selectors[0][0];
+    const nodes = Array.from(componentRef.location.nativeElement.childNodes).map(printer).join('');
+    let serializedComponent = '';
+    if (opts.omitAllCompAttrs) {
+        serializedComponent = '<' + componentName + '>\n' + indent(nodes) + '\n</' + componentName + '>';
+    }
+    else {
+        const attributes = Object.keys(componentInstance).filter((key) => !attributesToRemovePatterns.includes(key));
+        const componentAttrs = attributes
+            .sort()
+            .map((attribute) => {
+            const compAttrVal = componentInstance[attribute];
+            return (opts.spacing +
+                indent(`${colors.prop.open}${attribute}${colors.prop.close}=`) +
+                colors.value.open +
+                (compAttrVal && compAttrVal.constructor
+                    ? `{[Function ${compAttrVal.constructor.name}]}`
+                    : `"${compAttrVal}"`) +
+                colors.value.close);
+        })
+            .join('');
+        serializedComponent =
+            '<' +
+                componentName +
+                componentAttrs +
+                (componentAttrs.length ? '\n' : '') +
+                '>\n' +
+                indent(nodes) +
+                '\n</' +
+                componentName +
+                '>';
+    }
+    serializedComponent = removeTrailingWhiteSpaces(serializedComponent);
+    return serializedComponent;
+};
+const test = (val) => !!val && typeof val === 'object' && 'componentRef' in val;
+module.exports = {
+    print,
+    test,
+};

package/build/serializers/no-ng-attributes.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    serialize: (val: any, config: import("pretty-format").Config, indentation: string, depth: number, refs: import("pretty-format").Refs, printer: import("pretty-format").Printer) => string;
+    test: (arg0: any) => boolean;
+};
+export = _default;

package/build/serializers/no-ng-attributes.js

@@ -0,0 +1,57 @@
+"use strict";
+const pretty_format_1 = require("pretty-format");
+const jestDOMElementSerializer = pretty_format_1.plugins.DOMElement;
+const attributesToRemovePatterns = ['ng-reflect', '_nghost', '_ngcontent', 'ng-version'];
+const attributesToClean = {
+    class: [/^(?:mat|cdk|ng).*-\w*\d+-\d+$/, /^ng-star-inserted$/],
+    id: [/^(?:mat|cdk|ng).*-\d+$/],
+    for: [/^(?:mat|cdk|ng).*-\d+$/],
+    'aria-owns': [/^(?:mat|cdk|ng).*-\d+$/],
+    'aria-labelledby': [/^(?:mat|cdk|ng).*-\d+$/],
+    'aria-controls': [/^(?:mat|cdk|ng).*-\d+$/],
+};
+const hasAttributesToRemove = (attribute) => attributesToRemovePatterns.some((removePattern) => attribute.name.startsWith(removePattern));
+const hasAttributesToClean = (attribute) => Object.keys(attributesToClean).some((removePatternKey) => attribute.name === removePatternKey);
+const removeAngularAttributes = (node) => {
+    const nodeCopy = node.cloneNode(true);
+    Object.values(nodeCopy.attributes)
+        .filter(hasAttributesToRemove)
+        .forEach((attribute) => nodeCopy.attributes.removeNamedItem(attribute.name));
+    return nodeCopy;
+};
+const cleanAngularClasses = (node) => {
+    const nodeCopy = node.cloneNode(true);
+    Object.values(nodeCopy.attributes)
+        .filter(hasAttributesToClean)
+        .forEach((attribute) => {
+        attribute.value = attribute.value
+            .split(' ')
+            .filter((attrValue) => !attributesToClean[attribute.name].some((attributeCleanRegex) => attributeCleanRegex.test(attrValue)))
+            .join(' ');
+        if (attribute.value === '') {
+            nodeCopy.attributes.removeNamedItem(attribute.name);
+        }
+        else {
+            nodeCopy.attributes.setNamedItem(attribute);
+        }
+    });
+    return nodeCopy;
+};
+const shouldSerializeElement = (val) => {
+    return Object.values(val.attributes).some((attribute) => hasAttributesToRemove(attribute) || hasAttributesToClean(attribute));
+};
+const serialize = (node, ...rest) => {
+    let nodeCopy = removeAngularAttributes(node);
+    nodeCopy = cleanAngularClasses(nodeCopy);
+    return jestDOMElementSerializer.serialize(nodeCopy, ...rest);
+};
+const test = (val) => {
+    if (!val || !(val instanceof Element)) {
+        return false;
+    }
+    return jestDOMElementSerializer.test(val) && shouldSerializeElement(val);
+};
+module.exports = {
+    serialize,
+    test,
+};

package/build/transformers/esm_interop_inject.cjs

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.import_meta_url = void 0;
+exports.import_meta_url = require('url').pathToFileURL(__filename);

package/build/transformers/esm_interop_inject.d.cts

@@ -0,0 +1 @@
+export const import_meta_url: import("url").URL;