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

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/pre-v17/ng-package/entry-point/write-package.transform.js

@@ -0,0 +1,319 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Change the package.json metadata to only use the ESM2022 output.
+ * - Change the package.json metadata to only use the ESM2020 output (Angular < 16).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nxWritePackageTransform = void 0;
+const devkit_1 = require("@nx/devkit");
+const node_1 = require("ng-packagr/lib/graph/node");
+const transform_1 = require("ng-packagr/lib/graph/transform");
+const nodes_1 = require("ng-packagr/lib/ng-package/nodes");
+const fs_1 = require("ng-packagr/lib/utils/fs");
+const glob_1 = require("ng-packagr/lib/utils/glob");
+const path_1 = require("ng-packagr/lib/utils/path");
+const path = require("path");
+const angular_version_utils_1 = require("../../../../../utilities/angular-version-utils");
+const nxWritePackageTransform = (options) => (0, transform_1.transformFromPromise)(async (graph) => {
+    const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
+    const ngEntryPoint = entryPoint.data.entryPoint;
+    const ngPackageNode = graph.find(nodes_1.isPackage);
+    const ngPackage = ngPackageNode.data;
+    const { destinationFiles } = entryPoint.data;
+    const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if (!ngEntryPoint.isSecondaryEntryPoint) {
+        devkit_1.logger.log('Copying assets');
+        try {
+            await copyAssets(graph, entryPoint, ngPackageNode, angularVersion);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    // 6. WRITE PACKAGE.JSON
+    const relativeUnixFromDestPath = (filePath) => (0, path_1.ensureUnixPath)(path.relative(ngEntryPoint.destinationPath, filePath));
+    if (!ngEntryPoint.isSecondaryEntryPoint) {
+        try {
+            devkit_1.logger.info('Writing package manifest');
+            if (!options.watch) {
+                const primary = ngPackageNode.data.primary;
+                await (0, fs_1.writeFile)(path.join(primary.destinationPath, '.npmignore'), `# Nested package.json's are only needed for development.\n**/package.json`);
+            }
+            await writePackageJson(ngEntryPoint, ngPackage, {
+                // backward compat for Angular < 16
+                ...(angularVersion.major < 16
+                    ? {
+                        module: relativeUnixFromDestPath(destinationFiles.esm2020),
+                        es2020: relativeUnixFromDestPath(destinationFiles.esm2020),
+                        esm2020: relativeUnixFromDestPath(destinationFiles.esm2020),
+                    }
+                    : {
+                        module: relativeUnixFromDestPath(destinationFiles.esm2022),
+                    }),
+                typings: relativeUnixFromDestPath(destinationFiles.declarations),
+                exports: generatePackageExports(ngEntryPoint, graph, angularVersion),
+                // webpack v4+ specific flag to enable advanced optimizations and code splitting
+                sideEffects: ngEntryPoint.packageJson.sideEffects ?? false,
+            }, !!options.watch);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    else if (ngEntryPoint.isSecondaryEntryPoint) {
+        if (options.watch) {
+            // Update the watch version of the primary entry point `package.json` file.
+            // this is needed because of Webpack's 5 `cachemanagedpaths`
+            // https://github.com/ng-packagr/ng-packagr/issues/2069
+            const primary = ngPackageNode.data.primary;
+            const packageJsonPath = path.join(primary.destinationPath, 'package.json');
+            if (await (0, fs_1.exists)(packageJsonPath)) {
+                const packageJson = JSON.parse(await (0, fs_1.readFile)(packageJsonPath, { encoding: 'utf8' }));
+                packageJson.version = generateWatchVersion();
+                await (0, fs_1.writeFile)(path.join(primary.destinationPath, 'package.json'), JSON.stringify(packageJson, undefined, 2));
+            }
+        }
+        // Write a package.json in each secondary entry-point
+        // This is need for esbuild to secondary entry-points in dist correctly.
+        await (0, fs_1.writeFile)(path.join(ngEntryPoint.destinationPath, 'package.json'), JSON.stringify({
+            module: relativeUnixFromDestPath(angularVersion.major < 16
+                ? destinationFiles.esm2020
+                : destinationFiles.esm2022),
+        }, undefined, 2));
+    }
+    devkit_1.logger.info(`Built ${ngEntryPoint.moduleId}`);
+    return graph;
+});
+exports.nxWritePackageTransform = nxWritePackageTransform;
+async function copyAssets(graph, entryPointNode, ngPackageNode, angularVersion) {
+    const ngPackage = ngPackageNode.data;
+    const globsForceIgnored = [
+        '.gitkeep',
+        '**/.DS_Store',
+        '**/Thumbs.db',
+        `${ngPackage.dest}/**`,
+    ];
+    const assets = [];
+    for (const assetPath of ngPackage.assets) {
+        let asset;
+        if (typeof assetPath === 'object') {
+            asset = { ...assetPath };
+        }
+        else {
+            const [isDir, isFile] = await (0, fs_1.stat)(path.join(ngPackage.src, assetPath))
+                .then((stats) => [stats.isDirectory(), stats.isFile()])
+                .catch(() => [false, false]);
+            if (isDir) {
+                asset = { glob: '**/*', input: assetPath, output: assetPath };
+            }
+            else if (isFile) {
+                // filenames are their own glob
+                asset = {
+                    glob: path.basename(assetPath),
+                    input: path.dirname(assetPath),
+                    output: path.dirname(assetPath),
+                };
+            }
+            else {
+                asset = { glob: assetPath, input: '/', output: '/' };
+            }
+        }
+        asset.input = path.join(ngPackage.src, asset.input);
+        asset.output = path.join(ngPackage.dest, asset.output);
+        const isAncestorPath = (target, datum) => path.relative(datum, target).startsWith('..');
+        if (isAncestorPath(asset.input, ngPackage.src)) {
+            throw new Error('Cannot read assets from a location outside of the project root.');
+        }
+        if (isAncestorPath(asset.output, ngPackage.dest)) {
+            throw new Error('Cannot write assets to a location outside of the output path.');
+        }
+        assets.push(asset);
+    }
+    for (const asset of assets) {
+        const globOptions = {
+            cwd: asset.input,
+            ignore: [...(asset.ignore ?? []), ...globsForceIgnored],
+            dot: true,
+        };
+        if (angularVersion.major < 16) {
+            // versions lower than v16 support these properties
+            globOptions.cache = ngPackageNode.cache.globCache;
+            globOptions.nodir = true;
+            globOptions.follow = asset.followSymlinks;
+        }
+        else {
+            // starting in v16 these properties are supported
+            globOptions.onlyFiles = true;
+            globOptions.followSymbolicLinks = asset.followSymlinks;
+        }
+        const filePaths = await (0, glob_1.globFiles)(asset.glob, globOptions);
+        for (const filePath of filePaths) {
+            const fileSrcFullPath = path.join(asset.input, filePath);
+            const fileDestFullPath = path.join(asset.output, filePath);
+            const nodeUri = (0, nodes_1.fileUrl)((0, path_1.ensureUnixPath)(fileSrcFullPath));
+            let node = graph.get(nodeUri);
+            if (!node) {
+                node = new node_1.Node(nodeUri);
+                graph.put(node);
+            }
+            entryPointNode.dependsOn(node);
+            await (0, fs_1.copyFile)(fileSrcFullPath, fileDestFullPath);
+        }
+    }
+}
+/**
+ * Creates and writes a `package.json` file of the entry point used by the `node_module`
+ * resolution strategies.
+ *
+ * #### Example
+ *
+ * A consumer of the entry point depends on it by `import {..} from '@my/module/id';`.
+ * The module id `@my/module/id` will be resolved to the `package.json` file that is written by
+ * this build step.
+ * The properties `main`, `module`, `typings` (and so on) in the `package.json` point to the
+ * flattened JavaScript bundles, type definitions, (...).
+ *
+ * @param entryPoint An entry point of an Angular package / library
+ * @param additionalProperties Additional properties, e.g. binary artefacts (bundle files), to merge into `package.json`
+ */
+async function writePackageJson(entryPoint, pkg, additionalProperties, isWatchMode) {
+    // set additional properties
+    const packageJson = { ...entryPoint.packageJson, ...additionalProperties };
+    // read tslib version from `@angular/compiler` so that our tslib
+    // version at least matches that of angular if we use require('tslib').version
+    // it will get what installed and not the minimum version nor if it is a `~` or `^`
+    // this is only required for primary
+    if (isWatchMode) {
+        // Needed because of Webpack's 5 `cachemanagedpaths`
+        // https://github.com/angular/angular-cli/issues/20962
+        packageJson.version = generateWatchVersion();
+    }
+    if (!packageJson.peerDependencies?.tslib &&
+        !packageJson.dependencies?.tslib) {
+        const { peerDependencies: angularPeerDependencies = {}, dependencies: angularDependencies = {}, } = require('@angular/compiler/package.json');
+        const tsLibVersion = angularPeerDependencies.tslib || angularDependencies.tslib;
+        if (tsLibVersion) {
+            packageJson.dependencies = {
+                ...packageJson.dependencies,
+                tslib: tsLibVersion,
+            };
+        }
+    }
+    else if (packageJson.peerDependencies?.tslib) {
+        devkit_1.logger.warn(`'tslib' is no longer recommended to be used as a 'peerDependencies'. Moving it to 'dependencies'.`);
+        packageJson.dependencies = {
+            ...(packageJson.dependencies || {}),
+            tslib: packageJson.peerDependencies.tslib,
+        };
+        delete packageJson.peerDependencies.tslib;
+    }
+    // Verify non-peerDependencies as they can easily lead to duplicate installs or version conflicts
+    // in the node_modules folder of an application
+    const allowedList = pkg.allowedNonPeerDependencies.map((value) => new RegExp(value));
+    try {
+        checkNonPeerDependencies(packageJson, 'dependencies', allowedList);
+    }
+    catch (e) {
+        await (0, fs_1.rmdir)(entryPoint.destinationPath, { recursive: true });
+        throw e;
+    }
+    // Removes scripts from package.json after build
+    if (packageJson.scripts) {
+        if (pkg.keepLifecycleScripts !== true) {
+            devkit_1.logger.info(`Removing scripts section in package.json as it's considered a potential security vulnerability.`);
+            delete packageJson.scripts;
+        }
+        else {
+            devkit_1.logger.warn(`You enabled keepLifecycleScripts explicitly. The scripts section in package.json will be published to npm.`);
+        }
+    }
+    // keep the dist package.json clean
+    // this will not throw if ngPackage field does not exist
+    delete packageJson.ngPackage;
+    const packageJsonPropertiesToDelete = [
+        'stylelint',
+        'prettier',
+        'browserslist',
+        'devDependencies',
+        'jest',
+        'workspaces',
+        'husky',
+    ];
+    for (const prop of packageJsonPropertiesToDelete) {
+        if (prop in packageJson) {
+            delete packageJson[prop];
+            devkit_1.logger.info(`Removing ${prop} section in package.json.`);
+        }
+    }
+    packageJson.name = entryPoint.moduleId;
+    await (0, fs_1.writeFile)(path.join(entryPoint.destinationPath, 'package.json'), JSON.stringify(packageJson, undefined, 2));
+}
+function checkNonPeerDependencies(packageJson, property, allowed) {
+    if (!packageJson[property]) {
+        return;
+    }
+    for (const dep of Object.keys(packageJson[property])) {
+        if (!allowed.some((regex) => regex.test(dep))) {
+            devkit_1.logger.warn(`Distributing npm packages with '${property}' is not recommended. Please consider adding ${dep} to 'peerDependencies' or remove it from '${property}'.`);
+            throw new Error(`Dependency ${dep} must be explicitly allowed using the "allowedNonPeerDependencies" option.`);
+        }
+    }
+}
+/**
+ * Generates the `package.json` package exports following APF v13.
+ * This is supposed to match with: https://github.com/angular/angular/blob/e0667efa6eada64d1fb8b143840689090fc82e52/packages/bazel/src/ng_package/packager.ts#L415.
+ */
+function generatePackageExports({ destinationPath, packageJson }, graph, angularVersion) {
+    const exports = packageJson.exports
+        ? JSON.parse(JSON.stringify(packageJson.exports))
+        : {};
+    const insertMappingOrError = (subpath, mapping) => {
+        exports[subpath] ??= {};
+        const subpathExport = exports[subpath];
+        // Go through all conditions that should be inserted. If the condition is already
+        // manually set of the subpath export, we throw an error. In general, we allow for
+        // additional conditions to be set. These will always precede the generated ones.
+        for (const conditionName of Object.keys(mapping)) {
+            if (subpathExport[conditionName] !== undefined) {
+                devkit_1.logger.warn(`Found a conflicting export condition for "${subpath}". The "${conditionName}" ` +
+                    `condition would be overridden by ng-packagr. Please unset it.`);
+            }
+            // **Note**: The order of the conditions is preserved even though we are setting
+            // the conditions once at a time (the latest assignment will be at the end).
+            subpathExport[conditionName] = mapping[conditionName];
+        }
+    };
+    const relativeUnixFromDestPath = (filePath) => './' + (0, path_1.ensureUnixPath)(path.relative(destinationPath, filePath));
+    insertMappingOrError('./package.json', { default: './package.json' });
+    const entryPoints = graph.filter(nodes_1.isEntryPoint);
+    for (const entryPoint of entryPoints) {
+        const { destinationFiles, isSecondaryEntryPoint } = entryPoint.data.entryPoint;
+        const subpath = isSecondaryEntryPoint
+            ? `./${destinationFiles.directory}`
+            : '.';
+        // backward compat for Angular < 16
+        const mapping = angularVersion.major < 16
+            ? {
+                types: relativeUnixFromDestPath(destinationFiles.declarations),
+                es2020: relativeUnixFromDestPath(destinationFiles.esm2020),
+                esm2020: relativeUnixFromDestPath(destinationFiles.esm2020),
+                default: relativeUnixFromDestPath(destinationFiles.esm2020),
+            }
+            : {
+                esm2022: relativeUnixFromDestPath(destinationFiles.esm2022),
+                esm: relativeUnixFromDestPath(destinationFiles.esm2022),
+                default: relativeUnixFromDestPath(destinationFiles.esm2022),
+            };
+        insertMappingOrError(subpath, mapping);
+    }
+    return exports;
+}
+/**
+ * Generates a new version for the package `package.json` when runing in watch mode.
+ */
+function generateWatchVersion() {
+    return `0.0.0-watch+${Date.now()}`;
+}

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/pre-v17/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/ng-packagr-lite/ng-packagr-adjustments/pre-v17/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/ng-packagr-lite/ng-packagr-adjustments/pre-v17/ng-package/package.di.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * 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 type { Provider } from 'injection-js';
+import { InjectionToken } from 'injection-js';
+import type { Transform } from 'ng-packagr/lib/graph/transform';
+export declare const NX_PACKAGE_TRANSFORM_TOKEN: InjectionToken<Transform>;
+export declare const NX_PACKAGE_TRANSFORM: import("ng-packagr/lib/graph/transform.di").TransformProvider;
+export declare const NX_PACKAGE_PROVIDERS: Provider[];

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/pre-v17/ng-package/package.di.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * 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/ng-packagr-lite/ng-packagr-adjustments/pre-v17/ngc/compile-source-files.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use custom StylesheetProcessor instead of the one provided by ng-packagr.
+ * - 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): Promise<void>;

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

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use custom StylesheetProcessor instead of the one provided by ng-packagr.
+ * - 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 cache_compiler_host_1 = require("ng-packagr/lib/ts/cache-compiler-host");
+const log = require("ng-packagr/lib/utils/log");
+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) {
+    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`);
+    }
+    const tsCompilerHost = (0, cache_compiler_host_1.cacheCompilerHost)(graph, entryPoint, tsConfigOptions, moduleResolutionCache, stylesheetProcessor, inlineStyleLanguage);
+    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/ng-packagr-lite/ng-packagr-adjustments/pre-v17/styles/stylesheet-processor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 declare enum InlineStyleLanguage {
+    sass = "sass",
+    scss = "scss",
+    css = "css",
+    less = "less"
+}
+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/ng-packagr-lite/ng-packagr-adjustments/pre-v17/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;