@nx/angular 0.0.0-pr-22179-271588f

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/compile-ngc.di.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own compileNgcTransformFactory instead of the one provided by ng-packagr.
+ * - Use NX_STYLESHEET_PROCESSOR instead of STYLESHEET_PROCESSOR.
+ * - Use NX_STYLESHEET_PROCESSOR_TOKEN instead of STYLESHEET_PROCESSOR_TOKEN.
+ */
+import { InjectionToken, Provider } from 'injection-js';
+import { Transform } from 'ng-packagr/lib/graph/transform';
+import { TransformProvider } from 'ng-packagr/lib/graph/transform.di';
+export declare const NX_COMPILE_NGC_TOKEN: InjectionToken<Transform>;
+export declare const NX_COMPILE_NGC_TRANSFORM: TransformProvider;
+export declare const NX_COMPILE_NGC_PROVIDERS: Provider[];

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/compile-ngc.di.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own compileNgcTransformFactory instead of the one provided by ng-packagr.
+ * - Use NX_STYLESHEET_PROCESSOR instead of STYLESHEET_PROCESSOR.
+ * - Use NX_STYLESHEET_PROCESSOR_TOKEN instead of STYLESHEET_PROCESSOR_TOKEN.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_COMPILE_NGC_PROVIDERS = exports.NX_COMPILE_NGC_TRANSFORM = exports.NX_COMPILE_NGC_TOKEN = void 0;
+const injection_js_1 = require("injection-js");
+const transform_di_1 = require("ng-packagr/lib/graph/transform.di");
+const stylesheet_processor_di_1 = require("../../styles/stylesheet-processor.di");
+const options_di_1 = require("../options.di");
+const compile_ngc_transform_1 = require("./compile-ngc.transform");
+exports.NX_COMPILE_NGC_TOKEN = new injection_js_1.InjectionToken(`nx.v1.compileNgcTransform`);
+exports.NX_COMPILE_NGC_TRANSFORM = (0, transform_di_1.provideTransform)({
+    provide: exports.NX_COMPILE_NGC_TOKEN,
+    useFactory: compile_ngc_transform_1.compileNgcTransformFactory,
+    deps: [stylesheet_processor_di_1.NX_STYLESHEET_PROCESSOR_TOKEN, options_di_1.NX_OPTIONS_TOKEN],
+});
+exports.NX_COMPILE_NGC_PROVIDERS = [
+    stylesheet_processor_di_1.NX_STYLESHEET_PROCESSOR,
+    exports.NX_COMPILE_NGC_TRANSFORM,
+];

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/compile-ngc.transform.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own StylesheetProcessor files instead of the ones provide by ng-packagr.
+ * - Support ngcc for Angular < 16.
+ * - Support ESM2020 for Angular < 16.
+ */
+import { Transform } from 'ng-packagr/lib/graph/transform';
+import { StylesheetProcessor as StylesheetProcessorClass } from '../../styles/stylesheet-processor';
+import { NgPackagrOptions } from '../options.di';
+export declare const compileNgcTransformFactory: (StylesheetProcessor: typeof StylesheetProcessorClass, options: NgPackagrOptions) => Transform;

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/compile-ngc.transform.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own StylesheetProcessor files instead of the ones provide by ng-packagr.
+ * - Support ngcc for Angular < 16.
+ * - Support ESM2020 for Angular < 16.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileNgcTransformFactory = void 0;
+const transform_1 = require("ng-packagr/lib/graph/transform");
+const nodes_1 = require("ng-packagr/lib/ng-package/nodes");
+const tsconfig_1 = require("ng-packagr/lib/ts/tsconfig");
+const ora = require("ora");
+const path = require("path");
+const ts = require("typescript");
+const angular_version_utils_1 = require("../../../../utilities/angular-version-utils");
+const compile_source_files_1 = require("../../ngc/compile-source-files");
+const ng_compiler_cli_1 = require("../../utils/ng-compiler-cli");
+const compileNgcTransformFactory = (StylesheetProcessor, options) => {
+    return (0, transform_1.transformFromPromise)(async (graph) => {
+        const spinner = ora({
+            hideCursor: false,
+            discardStdin: false,
+        });
+        const entryPoints = graph.filter(nodes_1.isEntryPoint);
+        const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
+        const ngPackageNode = graph.find(nodes_1.isPackage);
+        const projectBasePath = ngPackageNode.data.primary.basePath;
+        try {
+            // Add paths mappings for dependencies
+            const tsConfig = (0, tsconfig_1.setDependenciesTsConfigPaths)(entryPoint.data.tsConfig, entryPoints);
+            const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+            // Compile TypeScript sources
+            const { declarations } = entryPoint.data.destinationFiles;
+            const esmModulePath = angularVersion.major < 16
+                ? entryPoint.data.destinationFiles.esm2020
+                : entryPoint.data.destinationFiles.esm2022;
+            const { basePath, cssUrl, styleIncludePaths } = entryPoint.data.entryPoint;
+            const { moduleResolutionCache } = entryPoint.cache;
+            spinner.start(`Compiling with Angular sources in Ivy ${tsConfig.options.compilationMode || 'full'} compilation mode.`);
+            let ngccProcessor;
+            if (angularVersion && angularVersion.major < 16) {
+                ngccProcessor =
+                    new (require('ng-packagr/lib/ngc/ngcc-processor').NgccProcessor)(await (0, ng_compiler_cli_1.ngccCompilerCli)(), entryPoint.cache.ngccProcessingCache, tsConfig.project, tsConfig.options, entryPoints);
+                if (!entryPoint.data.entryPoint.isSecondaryEntryPoint) {
+                    // Only run the async version of NGCC during the primary entrypoint processing.
+                    await ngccProcessor.process();
+                }
+            }
+            entryPoint.cache.stylesheetProcessor ??= new StylesheetProcessor(projectBasePath, basePath, cssUrl, styleIncludePaths, options.cacheEnabled && options.cacheDirectory, options.tailwindConfig);
+            await (0, compile_source_files_1.compileSourceFiles)(graph, tsConfig, moduleResolutionCache, options, {
+                outDir: path.dirname(esmModulePath),
+                declarationDir: path.dirname(declarations),
+                declaration: true,
+                target: angularVersion.major >= 16
+                    ? ts.ScriptTarget.ES2022
+                    : ts.ScriptTarget.ES2020,
+            }, entryPoint.cache.stylesheetProcessor, ngccProcessor);
+        }
+        catch (error) {
+            spinner.fail();
+            throw error;
+        }
+        spinner.succeed();
+        return graph;
+    });
+};
+exports.compileNgcTransformFactory = compileNgcTransformFactory;

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/entry-point.di.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use NX_COMPILE_NGC_TOKEN instead of COMPILE_NGC_TOKEN.
+ * - Use NX_COMPILE_NGC_PROVIDERS instead of COMPILE_NGC_PROVIDERS.
+ */
+import { InjectionToken, Provider } from 'injection-js';
+import { Transform } from 'ng-packagr/lib/graph/transform';
+import { TransformProvider } from 'ng-packagr/lib/graph/transform.di';
+export declare const NX_ENTRY_POINT_TRANSFORM_TOKEN: InjectionToken<Transform>;
+export declare const NX_ENTRY_POINT_TRANSFORM: TransformProvider;
+export declare const NX_ENTRY_POINT_PROVIDERS: Provider[];

package/src/executors/package/ng-packagr-adjustments/ng-package/entry-point/entry-point.di.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use NX_COMPILE_NGC_TOKEN instead of COMPILE_NGC_TOKEN.
+ * - Use NX_COMPILE_NGC_PROVIDERS instead of COMPILE_NGC_PROVIDERS.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_ENTRY_POINT_PROVIDERS = exports.NX_ENTRY_POINT_TRANSFORM = exports.NX_ENTRY_POINT_TRANSFORM_TOKEN = void 0;
+const injection_js_1 = require("injection-js");
+const transform_di_1 = require("ng-packagr/lib/graph/transform.di");
+const entry_point_transform_1 = require("ng-packagr/lib/ng-package/entry-point/entry-point.transform");
+const write_bundles_di_1 = require("ng-packagr/lib/ng-package/entry-point/write-bundles.di");
+const write_package_di_1 = require("ng-packagr/lib/ng-package/entry-point/write-package.di");
+const compile_ngc_di_1 = require("./compile-ngc.di");
+exports.NX_ENTRY_POINT_TRANSFORM_TOKEN = new injection_js_1.InjectionToken(`nx.v1.entryPointTransform`);
+exports.NX_ENTRY_POINT_TRANSFORM = (0, transform_di_1.provideTransform)({
+    provide: exports.NX_ENTRY_POINT_TRANSFORM_TOKEN,
+    useFactory: entry_point_transform_1.entryPointTransformFactory,
+    deps: [
+        compile_ngc_di_1.NX_COMPILE_NGC_TOKEN,
+        write_bundles_di_1.WRITE_BUNDLES_TRANSFORM_TOKEN,
+        write_package_di_1.WRITE_PACKAGE_TRANSFORM_TOKEN,
+    ],
+});
+exports.NX_ENTRY_POINT_PROVIDERS = [
+    exports.NX_ENTRY_POINT_TRANSFORM,
+    ...compile_ngc_di_1.NX_COMPILE_NGC_PROVIDERS,
+    write_bundles_di_1.WRITE_BUNDLES_TRANSFORM,
+    write_package_di_1.WRITE_PACKAGE_TRANSFORM,
+];

package/src/executors/package/ng-packagr-adjustments/ng-package/options.di.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Use our own options interface to add support for tailwindConfig.
+ */
+import { InjectionToken, Provider, ValueProvider } from 'injection-js';
+import { NgPackagrOptions as NgPackagrOptionsBase } from 'ng-packagr/lib/ng-package/options.di';
+export interface NgPackagrOptions extends NgPackagrOptionsBase {
+    tailwindConfig?: string;
+}
+export declare const NX_OPTIONS_TOKEN: InjectionToken<NgPackagrOptions>;
+export declare const nxProvideOptions: (options?: NgPackagrOptions) => ValueProvider;
+export declare const NX_DEFAULT_OPTIONS_PROVIDER: Provider;

package/src/executors/package/ng-packagr-adjustments/ng-package/options.di.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Use our own options interface to add support for tailwindConfig.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_DEFAULT_OPTIONS_PROVIDER = exports.nxProvideOptions = exports.NX_OPTIONS_TOKEN = void 0;
+const findCacheDirectory = require("find-cache-dir");
+const injection_js_1 = require("injection-js");
+const os_1 = require("os");
+const path_1 = require("path");
+exports.NX_OPTIONS_TOKEN = new injection_js_1.InjectionToken(`nx.v1.options`);
+const nxProvideOptions = (options = {}) => ({
+    provide: exports.NX_OPTIONS_TOKEN,
+    useValue: normalizeOptions(options),
+});
+exports.nxProvideOptions = nxProvideOptions;
+exports.NX_DEFAULT_OPTIONS_PROVIDER = (0, exports.nxProvideOptions)();
+function normalizeOptions(options = {}) {
+    const ciEnv = process.env['CI'];
+    const isCI = ciEnv?.toLowerCase() === 'true' || ciEnv === '1';
+    const { cacheEnabled = !isCI, cacheDirectory = findCachePath() } = options;
+    return {
+        ...options,
+        cacheEnabled,
+        cacheDirectory,
+    };
+}
+function findCachePath() {
+    const name = 'ng-packagr';
+    return findCacheDirectory({ name }) || (0, path_1.resolve)((0, os_1.tmpdir)(), name);
+}

package/src/executors/package/ng-packagr-adjustments/ng-package/package.di.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use NX_ENTRY_POINT_TRANSFORM_TOKEN instead of ENTRY_POINT_TRANSFORM_TOKEN.
+ * - USE NX_OPTIONS_TOKEN instead of OPTIONS_TOKEN.
+ * - USE NX_DEFAULT_OPTIONS_PROVIDER instead of DEFAULT_OPTIONS_PROVIDER.
+ */
+import { InjectionToken, Provider } from 'injection-js';
+import { Transform } from 'ng-packagr/lib/graph/transform';
+import { TransformProvider } from 'ng-packagr/lib/graph/transform.di';
+export declare const NX_PACKAGE_TRANSFORM_TOKEN: InjectionToken<Transform>;
+export declare const NX_PACKAGE_TRANSFORM: TransformProvider;
+export declare const NX_PACKAGE_PROVIDERS: Provider[];

package/src/executors/package/ng-packagr-adjustments/ng-package/package.di.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use NX_ENTRY_POINT_TRANSFORM_TOKEN instead of ENTRY_POINT_TRANSFORM_TOKEN.
+ * - USE NX_OPTIONS_TOKEN instead of OPTIONS_TOKEN.
+ * - USE NX_DEFAULT_OPTIONS_PROVIDER instead of DEFAULT_OPTIONS_PROVIDER.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_PACKAGE_PROVIDERS = exports.NX_PACKAGE_TRANSFORM = exports.NX_PACKAGE_TRANSFORM_TOKEN = void 0;
+const injection_js_1 = require("injection-js");
+const transform_di_1 = require("ng-packagr/lib/graph/transform.di");
+const analyse_sources_di_1 = require("ng-packagr/lib/ng-package/entry-point/analyse-sources.di");
+const init_tsconfig_di_1 = require("ng-packagr/lib/ng-package/entry-point/init-tsconfig.di");
+const package_transform_1 = require("ng-packagr/lib/ng-package/package.transform");
+const project_di_1 = require("ng-packagr/lib/project.di");
+const entry_point_di_1 = require("./entry-point/entry-point.di");
+const options_di_1 = require("./options.di");
+exports.NX_PACKAGE_TRANSFORM_TOKEN = new injection_js_1.InjectionToken(`nx.v1.packageTransform`);
+exports.NX_PACKAGE_TRANSFORM = (0, transform_di_1.provideTransform)({
+    provide: exports.NX_PACKAGE_TRANSFORM_TOKEN,
+    useFactory: package_transform_1.packageTransformFactory,
+    deps: [
+        project_di_1.PROJECT_TOKEN,
+        options_di_1.NX_OPTIONS_TOKEN,
+        init_tsconfig_di_1.INIT_TS_CONFIG_TOKEN,
+        analyse_sources_di_1.ANALYSE_SOURCES_TOKEN,
+        entry_point_di_1.NX_ENTRY_POINT_TRANSFORM_TOKEN,
+    ],
+});
+exports.NX_PACKAGE_PROVIDERS = [
+    exports.NX_PACKAGE_TRANSFORM,
+    options_di_1.NX_DEFAULT_OPTIONS_PROVIDER,
+    init_tsconfig_di_1.INIT_TS_CONFIG_TRANSFORM,
+    analyse_sources_di_1.ANALYSE_SOURCES_TRANSFORM,
+];

package/src/executors/package/ng-packagr-adjustments/ng-packagr.d.ts

@@ -0,0 +1,3 @@
+import { NgPackagr } from 'ng-packagr';
+import type { BuildAngularLibraryExecutorOptions } from '../../package/schema';
+export declare function getNgPackagrInstance(options: BuildAngularLibraryExecutorOptions): Promise<NgPackagr>;

package/src/executors/package/ng-packagr-adjustments/ng-packagr.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNgPackagrInstance = void 0;
+const ng_packagr_1 = require("ng-packagr");
+const angular_version_utils_1 = require("../../utilities/angular-version-utils");
+async function getNgPackagrInstance(options) {
+    const { major: angularMajorVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if (angularMajorVersion >= 17) {
+        const { STYLESHEET_PROCESSOR } = await Promise.resolve().then(() => require('../../utilities/ng-packagr/stylesheet-processor.di'));
+        const packagr = (0, ng_packagr_1.ngPackagr)();
+        packagr.withProviders([STYLESHEET_PROCESSOR]);
+        return packagr;
+    }
+    const { NX_ENTRY_POINT_PROVIDERS } = await Promise.resolve().then(() => require('./ng-package/entry-point/entry-point.di'));
+    const { nxProvideOptions } = await Promise.resolve().then(() => require('./ng-package/options.di'));
+    const { NX_PACKAGE_PROVIDERS, NX_PACKAGE_TRANSFORM } = await Promise.resolve().then(() => require('./ng-package/package.di'));
+    const packagr = new ng_packagr_1.NgPackagr([
+        ...NX_PACKAGE_PROVIDERS,
+        ...NX_ENTRY_POINT_PROVIDERS,
+        nxProvideOptions({
+            tailwindConfig: options.tailwindConfig,
+            watch: options.watch,
+        }),
+    ]);
+    packagr.withBuildTransform(NX_PACKAGE_TRANSFORM.provide);
+    return packagr;
+}
+exports.getNgPackagrInstance = getNgPackagrInstance;

package/src/executors/package/ng-packagr-adjustments/ngc/compile-source-files.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use custom StylesheetProcessor instead of the one provided by ng-packagr.
+ * - Support ngcc for Angular < 16.
+ * - Support Angular Compiler `incrementalDriver` for Angular < 16.
+ */
+import type { CompilerOptions, ParsedConfiguration } from '@angular/compiler-cli';
+import { BuildGraph } from 'ng-packagr/lib/graph/build-graph';
+import * as ts from 'typescript';
+import { NgPackagrOptions } from '../ng-package/options.di';
+import { StylesheetProcessor } from '../styles/stylesheet-processor';
+export declare function compileSourceFiles(graph: BuildGraph, tsConfig: ParsedConfiguration, moduleResolutionCache: ts.ModuleResolutionCache, options: NgPackagrOptions, extraOptions?: Partial<CompilerOptions>, stylesheetProcessor?: StylesheetProcessor, ngccProcessor?: any): Promise<void>;

package/src/executors/package/ng-packagr-adjustments/ngc/compile-source-files.js

@@ -0,0 +1,183 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use custom StylesheetProcessor instead of the one provided by ng-packagr.
+ * - Support ngcc for Angular < 16.
+ * - Support Angular Compiler `incrementalDriver` for Angular < 16.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileSourceFiles = void 0;
+const nodes_1 = require("ng-packagr/lib/ng-package/nodes");
+const log = require("ng-packagr/lib/utils/log");
+const cache_compiler_host_1 = require("ng-packagr/lib/ts/cache-compiler-host");
+const node_path_1 = require("node:path");
+const ts = require("typescript");
+const angular_version_utils_1 = require("../../../utilities/angular-version-utils");
+const ng_compiler_cli_1 = require("../../../utilities/ng-compiler-cli");
+async function compileSourceFiles(graph, tsConfig, moduleResolutionCache, options, extraOptions, stylesheetProcessor, ngccProcessor) {
+    const { NgtscProgram, formatDiagnostics } = await (0, ng_compiler_cli_1.ngCompilerCli)();
+    const { cacheDirectory, watch, cacheEnabled } = options;
+    const tsConfigOptions = {
+        ...tsConfig.options,
+        ...extraOptions,
+    };
+    const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
+    const ngPackageNode = graph.find(nodes_1.isPackage);
+    const inlineStyleLanguage = ngPackageNode.data.inlineStyleLanguage;
+    const cacheDir = cacheEnabled && cacheDirectory;
+    if (cacheDir) {
+        tsConfigOptions.incremental ??= true;
+        tsConfigOptions.tsBuildInfoFile ??= (0, node_path_1.join)(cacheDir, `tsbuildinfo/${entryPoint.data.entryPoint.flatModuleFile}.tsbuildinfo`);
+    }
+    let tsCompilerHost = (0, cache_compiler_host_1.cacheCompilerHost)(graph, entryPoint, tsConfigOptions, moduleResolutionCache, stylesheetProcessor, inlineStyleLanguage);
+    if (ngccProcessor) {
+        tsCompilerHost =
+            require('ng-packagr/lib/ts/ngcc-transform-compiler-host').ngccTransformCompilerHost(tsCompilerHost, tsConfigOptions, ngccProcessor, moduleResolutionCache);
+    }
+    const cache = entryPoint.cache;
+    const sourceFileCache = cache.sourcesFileCache;
+    let usingBuildInfo = false;
+    let oldBuilder = cache.oldBuilder;
+    if (!oldBuilder && cacheDir) {
+        oldBuilder = ts.readBuilderProgram(tsConfigOptions, tsCompilerHost);
+        usingBuildInfo = true;
+    }
+    // Create the Angular specific program that contains the Angular compiler
+    const angularProgram = new NgtscProgram(tsConfig.rootNames, tsConfigOptions, tsCompilerHost, cache.oldNgtscProgram);
+    const angularCompiler = angularProgram.compiler;
+    const { ignoreForDiagnostics, ignoreForEmit } = angularCompiler;
+    // SourceFile versions are required for builder programs.
+    // The wrapped host inside NgtscProgram adds additional files that will not have versions.
+    const typeScriptProgram = angularProgram.getTsProgram();
+    (0, cache_compiler_host_1.augmentProgramWithVersioning)(typeScriptProgram);
+    let builder;
+    if (watch || cacheDir) {
+        builder = cache.oldBuilder =
+            ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, tsCompilerHost, oldBuilder);
+        cache.oldNgtscProgram = angularProgram;
+    }
+    else {
+        builder = ts.createEmitAndSemanticDiagnosticsBuilderProgram(typeScriptProgram, tsCompilerHost);
+    }
+    // Update semantic diagnostics cache
+    const affectedFiles = new Set();
+    // Analyze affected files when in watch mode for incremental type checking
+    if ('getSemanticDiagnosticsOfNextAffectedFile' in builder) {
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const result = builder.getSemanticDiagnosticsOfNextAffectedFile(undefined, (sourceFile) => {
+                // If the affected file is a TTC shim, add the shim's original source file.
+                // This ensures that changes that affect TTC are typechecked even when the changes
+                // are otherwise unrelated from a TS perspective and do not result in Ivy codegen changes.
+                // For example, changing @Input property types of a directive used in another component's
+                // template.
+                if (ignoreForDiagnostics.has(sourceFile) &&
+                    sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                    // This file name conversion relies on internal compiler logic and should be converted
+                    // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                    const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                    const originalSourceFile = builder.getSourceFile(originalFilename);
+                    if (originalSourceFile) {
+                        affectedFiles.add(originalSourceFile);
+                    }
+                    return true;
+                }
+                return false;
+            });
+            if (!result) {
+                break;
+            }
+            affectedFiles.add(result.affected);
+        }
+        // Add all files with associated template type checking files.
+        // Stored TS build info does not have knowledge of the AOT compiler or the typechecking state of the templates.
+        // To ensure that errors are reported correctly, all AOT component diagnostics need to be analyzed even if build
+        // info is present.
+        if (usingBuildInfo) {
+            for (const sourceFile of builder.getSourceFiles()) {
+                if (ignoreForDiagnostics.has(sourceFile) &&
+                    sourceFile.fileName.endsWith('.ngtypecheck.ts')) {
+                    // This file name conversion relies on internal compiler logic and should be converted
+                    // to an official method when available. 15 is length of `.ngtypecheck.ts`
+                    const originalFilename = sourceFile.fileName.slice(0, -15) + '.ts';
+                    const originalSourceFile = builder.getSourceFile(originalFilename);
+                    if (originalSourceFile) {
+                        affectedFiles.add(originalSourceFile);
+                    }
+                }
+            }
+        }
+    }
+    // Collect program level diagnostics
+    const allDiagnostics = [
+        ...angularCompiler.getOptionDiagnostics(),
+        ...builder.getOptionsDiagnostics(),
+        ...builder.getGlobalDiagnostics(),
+    ];
+    // Required to support asynchronous resource loading
+    // Must be done before creating transformers or getting template diagnostics
+    await angularCompiler.analyzeAsync();
+    // Collect source file specific diagnostics
+    for (const sourceFile of builder.getSourceFiles()) {
+        if (ignoreForDiagnostics.has(sourceFile)) {
+            continue;
+        }
+        allDiagnostics.push(...builder.getDeclarationDiagnostics(sourceFile), ...builder.getSyntacticDiagnostics(sourceFile), ...builder.getSemanticDiagnostics(sourceFile));
+        // Declaration files cannot have template diagnostics
+        if (sourceFile.isDeclarationFile) {
+            continue;
+        }
+        // Only request Angular template diagnostics for affected files to avoid
+        // overhead of template diagnostics for unchanged files.
+        if (affectedFiles.has(sourceFile)) {
+            const angularDiagnostics = angularCompiler.getDiagnosticsForFile(sourceFile, affectedFiles.size === 1
+                ? /** OptimizeFor.SingleFile **/ 0
+                : /** OptimizeFor.WholeProgram */ 1);
+            allDiagnostics.push(...angularDiagnostics);
+            sourceFileCache.updateAngularDiagnostics(sourceFile, angularDiagnostics);
+        }
+    }
+    const otherDiagnostics = [];
+    const errorDiagnostics = [];
+    for (const diagnostic of allDiagnostics) {
+        if (diagnostic.category === ts.DiagnosticCategory.Error) {
+            errorDiagnostics.push(diagnostic);
+        }
+        else {
+            otherDiagnostics.push(diagnostic);
+        }
+    }
+    if (otherDiagnostics.length) {
+        log.msg(formatDiagnostics(errorDiagnostics));
+    }
+    if (errorDiagnostics.length) {
+        throw new Error(formatDiagnostics(errorDiagnostics));
+    }
+    const transformers = angularCompiler.prepareEmit().transformers;
+    if ('getSemanticDiagnosticsOfNextAffectedFile' in builder) {
+        while (builder.emitNextAffectedFile((fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+            if (fileName.endsWith('.tsbuildinfo')) {
+                tsCompilerHost.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles);
+            }
+        })) {
+            // empty
+        }
+    }
+    const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    const incrementalCompilation = angularVersion.major < 16
+        ? angularCompiler.incrementalDriver
+        : angularCompiler.incrementalCompilation;
+    for (const sourceFile of builder.getSourceFiles()) {
+        if (ignoreForEmit.has(sourceFile)) {
+            continue;
+        }
+        if (incrementalCompilation.safeToSkipEmit(sourceFile)) {
+            continue;
+        }
+        builder.emit(sourceFile, undefined, undefined, undefined, transformers);
+        incrementalCompilation.recordSuccessfulEmit(sourceFile);
+    }
+}
+exports.compileSourceFiles = compileSourceFiles;

package/src/executors/package/ng-packagr-adjustments/styles/stylesheet-processor.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Refactored caching to take into account TailwindCSS processing.
+ * - Added PostCSS plugin needed to support TailwindCSS.
+ */
+export declare enum CssUrl {
+    inline = "inline",
+    none = "none"
+}
+export interface Result {
+    css: string;
+    warnings: string[];
+    error?: string;
+}
+export declare class StylesheetProcessor {
+    private readonly projectBasePath;
+    private readonly basePath;
+    private readonly cssUrl?;
+    private readonly includePaths?;
+    private cacheDirectory?;
+    private readonly tailwindConfig?;
+    private browserslistData;
+    private targets;
+    private postCssProcessor;
+    private esbuild;
+    private styleIncludePaths;
+    constructor(projectBasePath: string, basePath: string, cssUrl?: CssUrl, includePaths?: string[], cacheDirectory?: string | false, tailwindConfig?: string);
+    process({ filePath, content, }: {
+        filePath: string;
+        content: string;
+    }): Promise<string>;
+    private createPostCssProcessor;
+    private renderCss;
+}

package/src/executors/package/ng-packagr-adjustments/styles/stylesheet-processor.di.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own StylesheetProcessor instead of the one provided by ng-packagr.
+ */
+import { FactoryProvider, InjectionToken } from 'injection-js';
+import { StylesheetProcessor } from './stylesheet-processor';
+export declare const NX_STYLESHEET_PROCESSOR_TOKEN: InjectionToken<StylesheetProcessor>;
+export declare const NX_STYLESHEET_PROCESSOR: FactoryProvider;

package/src/executors/package/ng-packagr-adjustments/styles/stylesheet-processor.di.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own StylesheetProcessor instead of the one provided by ng-packagr.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NX_STYLESHEET_PROCESSOR = exports.NX_STYLESHEET_PROCESSOR_TOKEN = void 0;
+const injection_js_1 = require("injection-js");
+const stylesheet_processor_1 = require("./stylesheet-processor");
+exports.NX_STYLESHEET_PROCESSOR_TOKEN = new injection_js_1.InjectionToken(`nx.v1.stylesheetProcessor`);
+exports.NX_STYLESHEET_PROCESSOR = {
+    provide: exports.NX_STYLESHEET_PROCESSOR_TOKEN,
+    useFactory: () => stylesheet_processor_1.StylesheetProcessor,
+    deps: [],
+};