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

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/pre-v17/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: [],
+};

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/pre-v17/styles/stylesheet-processor.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Refactored caching to take into account TailwindCSS processing.
+ * - Added PostCSS plugin needed to support TailwindCSS.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylesheetProcessor = exports.InlineStyleLanguage = exports.CssUrl = void 0;
+const browserslist = require("browserslist");
+const fs_1 = require("fs");
+const esbuild_executor_1 = require("ng-packagr/lib/esbuild/esbuild-executor");
+const cache_1 = require("ng-packagr/lib/utils/cache");
+const log = require("ng-packagr/lib/utils/log");
+const path_1 = require("path");
+const autoprefixer = require("autoprefixer");
+const postcssUrl = require("postcss-url");
+const node_url_1 = require("node:url");
+const tailwindcss_1 = require("../../../../utilities/ng-packagr/tailwindcss");
+const postcss = require('postcss');
+var CssUrl;
+(function (CssUrl) {
+    CssUrl["inline"] = "inline";
+    CssUrl["none"] = "none";
+})(CssUrl || (exports.CssUrl = CssUrl = {}));
+var InlineStyleLanguage;
+(function (InlineStyleLanguage) {
+    InlineStyleLanguage["sass"] = "sass";
+    InlineStyleLanguage["scss"] = "scss";
+    InlineStyleLanguage["css"] = "css";
+    InlineStyleLanguage["less"] = "less";
+})(InlineStyleLanguage || (exports.InlineStyleLanguage = InlineStyleLanguage = {}));
+class StylesheetProcessor {
+    constructor(projectBasePath, basePath, cssUrl, includePaths, cacheDirectory, tailwindConfig) {
+        this.projectBasePath = projectBasePath;
+        this.basePath = basePath;
+        this.cssUrl = cssUrl;
+        this.includePaths = includePaths;
+        this.cacheDirectory = cacheDirectory;
+        this.tailwindConfig = tailwindConfig;
+        this.esbuild = new esbuild_executor_1.EsbuildExecutor();
+        // By default, browserslist defaults are too inclusive
+        // https://github.com/browserslist/browserslist/blob/83764ea81ffaa39111c204b02c371afa44a4ff07/index.js#L516-L522
+        // We change the default query to browsers that Angular support.
+        // https://angular.io/guide/browser-support
+        browserslist.defaults = [
+            'last 2 Chrome versions',
+            'last 1 Firefox version',
+            'last 2 Edge major versions',
+            'last 2 Safari major versions',
+            'last 2 iOS major versions',
+            'Firefox ESR',
+        ];
+        this.styleIncludePaths = [...this.includePaths];
+        let prevDir = null;
+        let currentDir = this.basePath;
+        while (currentDir !== prevDir) {
+            const p = (0, path_1.join)(currentDir, 'node_modules');
+            if ((0, fs_1.existsSync)(p)) {
+                this.styleIncludePaths.push(p);
+            }
+            prevDir = currentDir;
+            currentDir = (0, path_1.dirname)(prevDir);
+        }
+        this.browserslistData = browserslist(undefined, { path: this.basePath });
+        this.targets = transformSupportedBrowsersToTargets(this.browserslistData);
+        const tailwindSetup = (0, tailwindcss_1.getTailwindSetup)(this.projectBasePath, this.tailwindConfig);
+        if (tailwindSetup) {
+            this.cacheDirectory = undefined;
+        }
+        this.postCssProcessor = this.createPostCssProcessor(tailwindSetup);
+    }
+    async process({ filePath, content, }) {
+        const CACHE_KEY_VALUES = [
+            ...this.browserslistData,
+            ...this.styleIncludePaths,
+            this.cssUrl,
+        ].join(':');
+        let key;
+        if (this.cacheDirectory &&
+            !content.includes('@import') &&
+            !content.includes('@use')) {
+            // No transitive deps and no Tailwind directives, we can cache more aggressively.
+            key = await (0, cache_1.generateKey)(content, CACHE_KEY_VALUES);
+            const result = await (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
+            if (result) {
+                result.warnings.forEach((msg) => log.warn(msg));
+                return result.css;
+            }
+        }
+        // Render pre-processor language (sass, styl, less)
+        const renderedCss = await this.renderCss(filePath, content);
+        // We cannot cache CSS re-rendering phase, because a transitive dependency via (@import) can case different CSS output.
+        // Example a change in a mixin or SCSS variable.
+        if (!key) {
+            key = await (0, cache_1.generateKey)(renderedCss, CACHE_KEY_VALUES);
+        }
+        if (this.cacheDirectory) {
+            const cachedResult = await (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
+            if (cachedResult) {
+                cachedResult.warnings.forEach((msg) => log.warn(msg));
+                return cachedResult.css;
+            }
+        }
+        // Render postcss (autoprefixing and friends)
+        const result = await this.postCssProcessor.process(renderedCss, {
+            from: filePath,
+            to: filePath.replace((0, path_1.extname)(filePath), '.css'),
+        });
+        const warnings = result.warnings().map((w) => w.toString());
+        const { code, warnings: esBuildWarnings } = await this.esbuild.transform(result.css, {
+            loader: 'css',
+            minify: true,
+            target: this.targets,
+            sourcefile: filePath,
+        });
+        if (esBuildWarnings.length > 0) {
+            warnings.push(...(await this.esbuild.formatMessages(esBuildWarnings, {
+                kind: 'warning',
+            })));
+        }
+        if (this.cacheDirectory) {
+            await (0, cache_1.saveCacheEntry)(this.cacheDirectory, key, JSON.stringify({
+                css: code,
+                warnings,
+            }));
+        }
+        warnings.forEach((msg) => log.warn(msg));
+        return code;
+    }
+    createPostCssProcessor(tailwindSetup) {
+        const postCssPlugins = [];
+        if (tailwindSetup) {
+            postCssPlugins.push((0, tailwindcss_1.getTailwindPostCssPlugin)(tailwindSetup));
+        }
+        if (this.cssUrl !== CssUrl.none) {
+            postCssPlugins.push(postcssUrl({ url: this.cssUrl }));
+        }
+        postCssPlugins.push(autoprefixer({
+            ignoreUnknownVersions: true,
+            overrideBrowserslist: this.browserslistData,
+        }));
+        return postcss(postCssPlugins);
+    }
+    async renderCss(filePath, css) {
+        const ext = (0, path_1.extname)(filePath);
+        switch (ext) {
+            case '.sass':
+            case '.scss': {
+                return (await Promise.resolve().then(() => require('sass'))).compileString(css, {
+                    url: (0, node_url_1.pathToFileURL)(filePath),
+                    syntax: '.sass' === ext ? 'indented' : 'scss',
+                    loadPaths: this.styleIncludePaths,
+                }).css;
+            }
+            case '.less': {
+                const { css: content } = await (await Promise.resolve().then(() => require('less'))).render(css, {
+                    filename: filePath,
+                    javascriptEnabled: true,
+                    paths: this.styleIncludePaths,
+                });
+                return content;
+            }
+            case '.css':
+            default:
+                return css;
+        }
+    }
+}
+exports.StylesheetProcessor = StylesheetProcessor;
+function transformSupportedBrowsersToTargets(supportedBrowsers) {
+    const transformed = [];
+    // https://esbuild.github.io/api/#target
+    const esBuildSupportedBrowsers = new Set([
+        'safari',
+        'firefox',
+        'edge',
+        'chrome',
+        'ios',
+    ]);
+    for (const browser of supportedBrowsers) {
+        let [browserName, version] = browser.split(' ');
+        // browserslist uses the name `ios_saf` for iOS Safari whereas esbuild uses `ios`
+        if (browserName === 'ios_saf') {
+            browserName = 'ios';
+        }
+        // browserslist uses ranges `15.2-15.3` versions but only the lowest is required
+        // to perform minimum supported feature checks. esbuild also expects a single version.
+        [version] = version.split('-');
+        if (esBuildSupportedBrowsers.has(browserName)) {
+            if (browserName === 'safari' && version === 'tp') {
+                // esbuild only supports numeric versions so `TP` is converted to a high number (999) since
+                // a Technology Preview (TP) of Safari is assumed to support all currently known features.
+                version = '999';
+            }
+            transformed.push(browserName + version);
+        }
+    }
+    return transformed.length ? transformed : undefined;
+}

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-bundles.di.d.ts

@@ -0,0 +1,2 @@
+import { TransformProvider } from 'ng-packagr/lib/graph/transform.di';
+export declare const WRITE_BUNDLES_TRANSFORM: TransformProvider;

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-bundles.di.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_BUNDLES_TRANSFORM = void 0;
+const transform_di_1 = require("ng-packagr/lib/graph/transform.di");
+const write_bundles_di_1 = require("ng-packagr/lib/ng-package/entry-point/write-bundles.di");
+const options_di_1 = require("ng-packagr/lib/ng-package/options.di");
+const write_bundles_transform_1 = require("./write-bundles.transform");
+exports.WRITE_BUNDLES_TRANSFORM = (0, transform_di_1.provideTransform)({
+    provide: write_bundles_di_1.WRITE_BUNDLES_TRANSFORM_TOKEN,
+    useFactory: write_bundles_transform_1.writeBundlesTransform,
+    deps: [options_di_1.OPTIONS_TOKEN],
+});

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-bundles.transform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Removed bundling altogether.
+ */
+import { NgPackagrOptions } from 'ng-packagr/lib/ng-package/options.di';
+export declare const writeBundlesTransform: (_options: NgPackagrOptions) => import("ng-packagr/lib/graph/transform").Transform;

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

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Removed bundling altogether.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeBundlesTransform = void 0;
+const transform_1 = require("ng-packagr/lib/graph/transform");
+const writeBundlesTransform = (_options) => (0, transform_1.transformFromPromise)(async (graph) => graph);
+exports.writeBundlesTransform = writeBundlesTransform;

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-package.di.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Provide our own writePackageTransform function.
+ */
+import { TransformProvider } from 'ng-packagr/lib/graph/transform.di';
+export declare const WRITE_PACKAGE_TRANSFORM: TransformProvider;

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-package.di.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Provide our own writePackageTransform function.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WRITE_PACKAGE_TRANSFORM = void 0;
+const transform_di_1 = require("ng-packagr/lib/graph/transform.di");
+const write_package_di_1 = require("ng-packagr/lib/ng-package/entry-point/write-package.di");
+const options_di_1 = require("ng-packagr/lib/ng-package/options.di");
+const write_package_transform_1 = require("./write-package.transform");
+exports.WRITE_PACKAGE_TRANSFORM = (0, transform_di_1.provideTransform)({
+    provide: write_package_di_1.WRITE_PACKAGE_TRANSFORM_TOKEN,
+    useFactory: write_package_transform_1.nxWritePackageTransform,
+    deps: [options_di_1.OPTIONS_TOKEN],
+});

package/src/executors/ng-packagr-lite/ng-packagr-adjustments/v17+/ng-package/entry-point/write-package.transform.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Change the package.json metadata to only use the ESM2022 output.
+ */
+import { NgPackagrOptions } from 'ng-packagr/lib/ng-package/options.di';
+export declare const nxWritePackageTransform: (options: NgPackagrOptions) => import("ng-packagr/lib/graph/transform").Transform;

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

@@ -0,0 +1,285 @@
+"use strict";
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Change the package.json metadata to only use the ESM2022 output.
+ */
+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 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;
+    if (!ngEntryPoint.isSecondaryEntryPoint) {
+        devkit_1.logger.log('Copying assets');
+        try {
+            await copyAssets(graph, entryPoint, ngPackageNode);
+        }
+        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, {
+                module: relativeUnixFromDestPath(destinationFiles.esm2022),
+                typings: relativeUnixFromDestPath(destinationFiles.declarations),
+                exports: generatePackageExports(ngEntryPoint, graph),
+                // 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(destinationFiles.esm2022) }, undefined, 2));
+    }
+    devkit_1.logger.info(`Built ${ngEntryPoint.moduleId}`);
+    return graph;
+});
+exports.nxWritePackageTransform = nxWritePackageTransform;
+async function copyAssets(graph, entryPointNode, ngPackageNode) {
+    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 filePaths = await (0, glob_1.globFiles)(asset.glob, {
+            cwd: asset.input,
+            ignore: [...(asset.ignore ?? []), ...globsForceIgnored],
+            dot: true,
+            onlyFiles: true,
+            followSymbolicLinks: asset.followSymlinks,
+        });
+        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) {
+    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}`
+            : '.';
+        insertMappingOrError(subpath, {
+            types: relativeUnixFromDestPath(destinationFiles.declarations),
+            esm2022: relativeUnixFromDestPath(destinationFiles.esm2022),
+            esm: relativeUnixFromDestPath(destinationFiles.esm2022),
+            default: relativeUnixFromDestPath(destinationFiles.esm2022),
+        });
+    }
+    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-lite.impl.d.ts

@@ -0,0 +1,6 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { BuildAngularLibraryExecutorOptions } from '../package/schema';
+export declare const ngPackagrLiteExecutor: (options: BuildAngularLibraryExecutorOptions, context: ExecutorContext) => AsyncGenerator<{
+    success: boolean;
+}, any, undefined>;
+export default ngPackagrLiteExecutor;

package/src/executors/ng-packagr-lite/ng-packagr-lite.impl.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngPackagrLiteExecutor = void 0;
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const path_1 = require("path");
+const package_impl_1 = require("../package/package.impl");
+const typescript_1 = require("../utilities/typescript");
+const ng_packagr_1 = require("./ng-packagr-adjustments/ng-packagr");
+async function initializeNgPackgrLite(options, context, projectDependencies) {
+    const ngPackagr = await (0, ng_packagr_1.getNgPackagrInstance)(options);
+    ngPackagr.forProject((0, path_1.resolve)(context.root, options.project));
+    if (options.tsConfig) {
+        const remappedTsConfigFilePath = (0, buildable_libs_utils_1.createTmpTsConfig)(options.tsConfig, context.root, context.projectsConfigurations.projects[context.projectName].root, projectDependencies);
+        const tsConfig = await (0, typescript_1.parseRemappedTsConfigAndMergeDefaults)(context.root, options.tsConfig, remappedTsConfigFilePath);
+        ngPackagr.withTsConfig(tsConfig);
+    }
+    return ngPackagr;
+}
+exports.ngPackagrLiteExecutor = (0, package_impl_1.createLibraryExecutor)(initializeNgPackgrLite);
+exports.default = exports.ngPackagrLiteExecutor;

package/src/executors/ng-packagr-lite/schema.json

@@ -0,0 +1,43 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "https://json-schema.org/schema",
+  "title": "ng-packagr Target",
+  "description": "Builds a library with support for incremental builds.\n\nThis executor is meant to be used with buildable libraries in an incremental build scenario. It is similar to the `@nx/angular:package` executor but with some key differences:\n- For supported Angular versions lower than v16, it doesn't run `ngcc` automatically (`ngcc` is no longer available from Angular v16 onwards, for lower versions, it needs to be run separately beforehand if needed, this can be done in a `postinstall` hook on `package.json`).\n- It only produces ESM2022 bundles (ESM2020 for supported Angular versions lower than v16).",
+  "cli": "nx",
+  "type": "object",
+  "presets": [
+    {
+      "name": "Buildable Library with Tailwind",
+      "keys": ["project", "tailwindConfig"]
+    },
+    {
+      "name": "Updating Project Dependencies for Buildable Library",
+      "keys": ["project"]
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The file path for the ng-packagr configuration file, relative to the workspace root."
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The full path for the TypeScript configuration file, relative to the workspace root.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json",
+      "x-priority": "important"
+    },
+    "watch": {
+      "type": "boolean",
+      "description": "Whether to run a build when any file changes.",
+      "default": false
+    },
+    "tailwindConfig": {
+      "type": "string",
+      "description": "The full path for the Tailwind configuration file, relative to the workspace root. If not provided and a `tailwind.config.js` file exists in the project or workspace root, it will be used. Otherwise, Tailwind will not be configured."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["project"]
+}