@nx/angular 17.0.3 → 17.0.4

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

@@ -3,10 +3,8 @@
  * Adapted from the original ng-packagr source.
  *
  * Changes made:
- * - Added the filePath parameter to the cache key.
  * - Refactored caching to take into account TailwindCSS processing.
- * - Added PostCSS plugins needed to support TailwindCSS.
- * - Added watch mode parameter.
+ * - Added PostCSS plugin needed to support TailwindCSS.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StylesheetProcessor = exports.InlineStyleLanguage = exports.CssUrl = void 0;
@@ -16,11 +14,10 @@ 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 postcssPresetEnv = require("postcss-preset-env");
+const autoprefixer = require("autoprefixer");
 const postcssUrl = require("postcss-url");
 const node_url_1 = require("node:url");
-const angular_version_utils_1 = require("../../../utilities/angular-version-utils");
-const tailwindcss_1 = require("../../../utilities/tailwindcss");
+const tailwindcss_1 = require("../../../../utilities/ng-packagr/tailwindcss");
 const postcss = require('postcss');
 var CssUrl;
 (function (CssUrl) {
@@ -35,20 +32,20 @@ var InlineStyleLanguage;
     InlineStyleLanguage["less"] = "less";
 })(InlineStyleLanguage || (exports.InlineStyleLanguage = InlineStyleLanguage = {}));
 class StylesheetProcessor {
-    constructor(basePath, cssUrl, includePaths, cacheDirectory, watch, tailwindConfig) {
-        // By default, browserslist defaults are too inclusive
-        // https://github.com/browserslist/browserslist/blob/83764ea81ffaa39111c204b02c371afa44a4ff07/index.js#L516-L522
+    constructor(projectBasePath, basePath, cssUrl, includePaths, cacheDirectory, tailwindConfig) {
+        this.projectBasePath = projectBasePath;
         this.basePath = basePath;
         this.cssUrl = cssUrl;
         this.includePaths = includePaths;
         this.cacheDirectory = cacheDirectory;
-        this.watch = watch;
         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 version',
+            'last 2 Chrome versions',
             'last 1 Firefox version',
             'last 2 Edge major versions',
             'last 2 Safari major versions',
@@ -68,17 +65,24 @@ class StylesheetProcessor {
         }
         this.browserslistData = browserslist(undefined, { path: this.basePath });
         this.targets = transformSupportedBrowsersToTargets(this.browserslistData);
-        this.tailwindSetup = (0, tailwindcss_1.getTailwindSetup)(this.basePath, this.tailwindConfig);
-        this.postCssProcessor = this.createPostCssPlugins();
+        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') &&
-            !this.containsTailwindDirectives(content)) {
+            !content.includes('@use')) {
             // No transitive deps and no Tailwind directives, we can cache more aggressively.
-            key = await (0, cache_1.generateKey)(content, ...this.browserslistData, filePath);
+            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));
@@ -87,18 +91,16 @@ class StylesheetProcessor {
         }
         // Render pre-processor language (sass, styl, less)
         const renderedCss = await this.renderCss(filePath, content);
-        let containsTailwindDirectives = false;
+        // 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) {
-            containsTailwindDirectives = this.containsTailwindDirectives(renderedCss);
-            if (!containsTailwindDirectives) {
-                // No Tailwind directives to process by PostCSS, we can return cached results
-                if (!key) {
-                    key = await (0, cache_1.generateKey)(renderedCss, ...this.browserslistData, filePath);
-                }
-                const cachedResult = await this.getCachedResult(key);
-                if (cachedResult) {
-                    return cachedResult;
-                }
+            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)
@@ -106,15 +108,6 @@ class StylesheetProcessor {
             from: filePath,
             to: filePath.replace((0, path_1.extname)(filePath), '.css'),
         });
-        if (this.cacheDirectory && containsTailwindDirectives) {
-            // We had Tailwind directives to process by PostCSS, only now
-            // is safe to return cached results
-            key = await (0, cache_1.generateKey)(result.css, ...this.browserslistData, filePath);
-            const cachedResult = await this.getCachedResult(key);
-            if (cachedResult) {
-                return cachedResult;
-            }
-        }
         const warnings = result.warnings().map((w) => w.toString());
         const { code, warnings: esBuildWarnings } = await this.esbuild.transform(result.css, {
             loader: 'css',
@@ -136,29 +129,17 @@ class StylesheetProcessor {
         warnings.forEach((msg) => log.warn(msg));
         return code;
     }
-    async getCachedResult(key) {
-        const cachedResult = await (0, cache_1.readCacheEntry)(this.cacheDirectory, key);
-        if (cachedResult) {
-            cachedResult.warnings.forEach((msg) => log.warn(msg));
-            return cachedResult.css;
-        }
-        return undefined;
-    }
-    containsTailwindDirectives(content) {
-        return (this.tailwindSetup && tailwindcss_1.tailwindDirectives.some((d) => content.includes(d)));
-    }
-    createPostCssPlugins() {
+    createPostCssProcessor(tailwindSetup) {
         const postCssPlugins = [];
+        if (tailwindSetup) {
+            postCssPlugins.push((0, tailwindcss_1.getTailwindPostCssPlugin)(tailwindSetup));
+        }
         if (this.cssUrl !== CssUrl.none) {
             postCssPlugins.push(postcssUrl({ url: this.cssUrl }));
         }
-        if (this.tailwindSetup) {
-            postCssPlugins.push(...(0, tailwindcss_1.getTailwindPostCssPlugins)(this.tailwindSetup, this.styleIncludePaths, this.watch));
-        }
-        postCssPlugins.push(postcssPresetEnv({
-            browsers: this.browserslistData,
-            autoprefixer: true,
-            stage: 3,
+        postCssPlugins.push(autoprefixer({
+            ignoreUnknownVersions: true,
+            overrideBrowserslist: this.browserslistData,
         }));
         return postcss(postCssPlugins);
     }
@@ -167,25 +148,11 @@ class StylesheetProcessor {
         switch (ext) {
             case '.sass':
             case '.scss': {
-                const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
-                if (angularVersion && angularVersion.major < 15) {
-                    return (await Promise.resolve().then(() => require('sass')))
-                        .renderSync({
-                        file: filePath,
-                        data: css,
-                        indentedSyntax: '.sass' === ext,
-                        importer: customSassImporter,
-                        includePaths: this.styleIncludePaths,
-                    })
-                        .css.toString();
-                }
-                return (await Promise.resolve().then(() => require('sass')))
-                    .compileString(css, {
+                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.toString();
+                }).css;
             }
             case '.less': {
                 const { css: content } = await (await Promise.resolve().then(() => require('less'))).render(css, {
@@ -221,10 +188,7 @@ function transformSupportedBrowsersToTargets(supportedBrowsers) {
         // 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 (browserName === 'ie') {
-            transformed.push('edge12');
-        }
-        else if (esBuildSupportedBrowsers.has(browserName)) {
+        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.
@@ -235,14 +199,3 @@ function transformSupportedBrowsersToTargets(supportedBrowsers) {
     }
     return transformed.length ? transformed : undefined;
 }
-function customSassImporter(url, prev) {
-    // NB: Sass importer should always be sync as otherwise it will cause
-    // sass to go in the async path which is slower.
-    if (url[0] !== '~') {
-        return undefined;
-    }
-    return {
-        file: url.slice(1),
-        prev,
-    };
-}

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.js

@@ -2,31 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ngPackagrLiteExecutor = void 0;
 const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
-const ng_packagr_1 = require("ng-packagr");
 const path_1 = require("path");
 const package_impl_1 = require("../package/package.impl");
 const typescript_1 = require("../utilities/typescript");
-const entry_point_di_1 = require("./ng-packagr-adjustments/ng-package/entry-point/entry-point.di");
-const options_di_1 = require("./ng-packagr-adjustments/ng-package/options.di");
-const package_di_1 = require("./ng-packagr-adjustments/ng-package/package.di");
+const ng_packagr_1 = require("./ng-packagr-adjustments/ng-packagr");
 async function initializeNgPackgrLite(options, context, projectDependencies) {
-    const packager = new ng_packagr_1.NgPackagr([
-        // Add default providers to this list.
-        ...package_di_1.NX_PACKAGE_PROVIDERS,
-        ...entry_point_di_1.NX_ENTRY_POINT_PROVIDERS,
-        (0, options_di_1.nxProvideOptions)({
-            tailwindConfig: options.tailwindConfig,
-            watch: options.watch,
-        }),
-    ]);
-    packager.forProject((0, path_1.resolve)(context.root, options.project));
-    packager.withBuildTransform(package_di_1.NX_PACKAGE_TRANSFORM.provide);
+    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);
-        packager.withTsConfig(tsConfig);
+        ngPackagr.withTsConfig(tsConfig);
     }
-    return packager;
+    return ngPackagr;
 }
 exports.ngPackagrLiteExecutor = (0, package_impl_1.createLibraryExecutor)(initializeNgPackgrLite);
 exports.default = exports.ngPackagrLiteExecutor;

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

@@ -1,7 +1,7 @@
 {
   "version": 2,
   "outputCapture": "direct-nodejs",
-  "$schema": "http://json-schema.org/schema",
+  "$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",

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

@@ -24,9 +24,11 @@ const compileNgcTransformFactory = (StylesheetProcessor, options) => {
             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 {
-            const entryPoint = graph.find((0, nodes_1.isEntryPointInProgress)());
-            const entryPoints = graph.filter(nodes_1.isEntryPoint);
             // Add paths mappings for dependencies
             const tsConfig = (0, tsconfig_1.setDependenciesTsConfigPaths)(entryPoint.data.tsConfig, entryPoints);
             const angularVersion = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
@@ -47,7 +49,7 @@ const compileNgcTransformFactory = (StylesheetProcessor, options) => {
                     await ngccProcessor.process();
                 }
             }
-            entryPoint.cache.stylesheetProcessor ??= new StylesheetProcessor(basePath, cssUrl, styleIncludePaths, options.cacheEnabled && options.cacheDirectory, options.watch, options.tailwindConfig);
+            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),

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>;