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

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

@@ -0,0 +1,194 @@
+"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.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 = {}));
+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/package/ng-packagr-adjustments/utils/ng-compiler-cli.d.ts

@@ -0,0 +1 @@
+export declare function ngccCompilerCli(): Promise<any>;

package/src/executors/package/ng-packagr-adjustments/utils/ng-compiler-cli.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngccCompilerCli = void 0;
+async function ngccCompilerCli() {
+    const compilerCliModule = await new Function(`return import('@angular/compiler-cli/ngcc');`)();
+    return compilerCliModule.process
+        ? compilerCliModule
+        : compilerCliModule.default;
+}
+exports.ngccCompilerCli = ngccCompilerCli;

package/src/executors/package/package.impl.d.ts

@@ -0,0 +1,16 @@
+import type { ExecutorContext } from '@nx/devkit';
+import { type DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+import type { NgPackagr } from 'ng-packagr';
+import type { BuildAngularLibraryExecutorOptions } from './schema';
+/**
+ * Creates an executor function that executes the library build of an Angular
+ * package using ng-packagr.
+ * @param initializeNgPackagr function that returns an ngPackagr instance to use for the build.
+ */
+export declare function createLibraryExecutor(initializeNgPackagr: (options: BuildAngularLibraryExecutorOptions, context: ExecutorContext, projectDependencies: DependentBuildableProjectNode[]) => Promise<NgPackagr>): (options: BuildAngularLibraryExecutorOptions, context: ExecutorContext) => AsyncGenerator<{
+    success: boolean;
+}, any, undefined>;
+export declare const packageExecutor: (options: BuildAngularLibraryExecutorOptions, context: ExecutorContext) => AsyncGenerator<{
+    success: boolean;
+}, any, undefined>;
+export default packageExecutor;

package/src/executors/package/package.impl.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packageExecutor = exports.createLibraryExecutor = void 0;
+const rxjs_for_await_1 = require("@nx/devkit/src/utils/rxjs-for-await");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const path_1 = require("path");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const typescript_1 = require("../utilities/typescript");
+const ng_packagr_1 = require("./ng-packagr-adjustments/ng-packagr");
+async function initializeNgPackagr(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;
+}
+/**
+ * Creates an executor function that executes the library build of an Angular
+ * package using ng-packagr.
+ * @param initializeNgPackagr function that returns an ngPackagr instance to use for the build.
+ */
+function createLibraryExecutor(initializeNgPackagr) {
+    return async function* (options, context) {
+        const { target, dependencies, topLevelDependencies } = (0, buildable_libs_utils_1.calculateProjectBuildableDependencies)(context.taskGraph, context.projectGraph, context.root, context.projectName, context.targetName, context.configurationName);
+        if (!(0, buildable_libs_utils_1.checkDependentProjectsHaveBeenBuilt)(context.root, context.projectName, context.targetName, dependencies)) {
+            return Promise.resolve({ success: false });
+        }
+        if (options.watch) {
+            return yield* (0, rxjs_for_await_1.eachValueFrom)((0, rxjs_1.from)(initializeNgPackagr(options, context, dependencies)).pipe((0, operators_1.switchMap)((packagr) => packagr.watch()), (0, operators_1.mapTo)({ success: true })));
+        }
+        return (0, rxjs_1.from)(initializeNgPackagr(options, context, dependencies))
+            .pipe((0, operators_1.switchMap)((packagr) => packagr.build()), (0, operators_1.mapTo)({ success: true }))
+            .toPromise();
+    };
+}
+exports.createLibraryExecutor = createLibraryExecutor;
+exports.packageExecutor = createLibraryExecutor(initializeNgPackagr);
+exports.default = exports.packageExecutor;

package/src/executors/package/schema.d.ts

@@ -0,0 +1,6 @@
+export interface BuildAngularLibraryExecutorOptions {
+  project: string;
+  tailwindConfig?: string;
+  tsConfig?: string;
+  watch?: boolean;
+}

package/src/executors/package/schema.json

@@ -0,0 +1,45 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "$schema": "https://json-schema.org/schema",
+  "title": "ng-packagr Target",
+  "description": "Builds and packages an Angular library producing an output following the Angular Package Format (APF) to be distributed as an NPM package.\n\nThis executor is similar to the `@angular-devkit/build-angular:ng-packagr` with additional support for incremental builds.",
+  "cli": "nx",
+  "type": "object",
+  "presets": [
+    {
+      "name": "Publishable Library with Tailwind",
+      "keys": ["project", "tailwindConfig"]
+    },
+    {
+      "name": "Updating Project Dependencies for Publishable 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. _Note: starting with Angular v17, this option is no longer used and the configuration will be picked up if exists at the project or workspace root_.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tailwind.config@(.js|.cjs|.mjs|.ts)"
+    }
+  },
+  "additionalProperties": false,
+  "required": ["project"]
+}

package/src/executors/utilities/angular-version-utils.d.ts

@@ -0,0 +1,6 @@
+export type VersionInfo = {
+    major: number;
+    version: string;
+};
+export declare function getInstalledAngularVersionInfo(): VersionInfo | null;
+export declare function getInstalledPackageVersionInfo(pkgName: string): VersionInfo | null;

package/src/executors/utilities/angular-version-utils.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledPackageVersionInfo = exports.getInstalledAngularVersionInfo = void 0;
+const package_json_1 = require("nx/src/utils/package-json");
+const semver_1 = require("semver");
+function getInstalledAngularVersionInfo() {
+    return getInstalledPackageVersionInfo('@angular/core');
+}
+exports.getInstalledAngularVersionInfo = getInstalledAngularVersionInfo;
+function getInstalledPackageVersionInfo(pkgName) {
+    try {
+        const { packageJson: { version }, } = (0, package_json_1.readModulePackageJson)(pkgName);
+        return { major: (0, semver_1.major)(version), version };
+    }
+    catch {
+        return null;
+    }
+}
+exports.getInstalledPackageVersionInfo = getInstalledPackageVersionInfo;

package/src/executors/utilities/buildable-libs.d.ts

@@ -0,0 +1,6 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type DependentBuildableProjectNode } from '@nx/js/src/utils/buildable-libs-utils';
+export declare function createTmpTsConfigForBuildableLibs(tsConfigPath: string, context: ExecutorContext): {
+    tsConfigPath: string;
+    dependencies: DependentBuildableProjectNode[];
+};

package/src/executors/utilities/buildable-libs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTmpTsConfigForBuildableLibs = void 0;
+const devkit_1 = require("@nx/devkit");
+const buildable_libs_utils_1 = require("@nx/js/src/utils/buildable-libs-utils");
+const path_1 = require("path");
+function createTmpTsConfigForBuildableLibs(tsConfigPath, context) {
+    let dependencies;
+    const result = (0, buildable_libs_utils_1.calculateProjectDependencies)(context.projectGraph ?? (0, devkit_1.readCachedProjectGraph)(), context.root, context.projectName, context.targetName, context.configurationName);
+    dependencies = result.dependencies;
+    const tmpTsConfigPath = (0, buildable_libs_utils_1.createTmpTsConfig)((0, path_1.join)(context.root, tsConfigPath), context.root, result.target.data.root, dependencies);
+    process.env.NX_TSCONFIG_PATH = tmpTsConfigPath;
+    const tmpTsConfigPathWithoutWorkspaceRoot = tmpTsConfigPath.replace(context.root, '');
+    return { tsConfigPath: tmpTsConfigPathWithoutWorkspaceRoot, dependencies };
+}
+exports.createTmpTsConfigForBuildableLibs = createTmpTsConfigForBuildableLibs;

package/src/executors/utilities/esbuild-extensions.d.ts

@@ -0,0 +1,10 @@
+import type { IndexHtmlTransform } from '@angular-devkit/build-angular/src/utils/index-file/index-html-generator';
+import type { Plugin } from 'esbuild';
+import type { Connect } from 'vite';
+export type PluginSpec = {
+    path: string;
+    options: any;
+};
+export declare function loadPlugins(plugins: string[] | PluginSpec[] | undefined, tsConfig: string): Promise<Plugin[]>;
+export declare function loadMiddleware(middlewareFns: string[] | undefined, tsConfig: string): Promise<Connect.NextHandleFunction[]>;
+export declare function loadIndexHtmlTransformer(indexHtmlTransformerPath: string, tsConfig: string): Promise<IndexHtmlTransform>;

package/src/executors/utilities/esbuild-extensions.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIndexHtmlTransformer = exports.loadMiddleware = exports.loadPlugins = void 0;
+const internal_1 = require("@nx/js/src/internal");
+const module_loader_1 = require("./module-loader");
+async function loadPlugins(plugins, tsConfig) {
+    if (!plugins?.length) {
+        return [];
+    }
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    try {
+        return await Promise.all(plugins.map((plugin) => loadPlugin(plugin)));
+    }
+    finally {
+        cleanupTranspiler();
+    }
+}
+exports.loadPlugins = loadPlugins;
+async function loadPlugin(pluginSpec) {
+    const pluginPath = typeof pluginSpec === 'string' ? pluginSpec : pluginSpec.path;
+    let plugin = await (0, module_loader_1.loadModule)(pluginPath);
+    if (typeof plugin === 'function') {
+        plugin =
+            typeof pluginSpec === 'object' ? plugin(pluginSpec.options) : plugin();
+    }
+    return plugin;
+}
+async function loadMiddleware(middlewareFns, tsConfig) {
+    if (!middlewareFns?.length) {
+        return [];
+    }
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    try {
+        return await Promise.all(middlewareFns.map((fnPath) => (0, module_loader_1.loadModule)(fnPath)));
+    }
+    finally {
+        cleanupTranspiler();
+    }
+}
+exports.loadMiddleware = loadMiddleware;
+async function loadIndexHtmlTransformer(indexHtmlTransformerPath, tsConfig) {
+    const cleanupTranspiler = (0, internal_1.registerTsProject)(tsConfig);
+    try {
+        return await (0, module_loader_1.loadModule)(indexHtmlTransformerPath);
+    }
+    finally {
+        cleanupTranspiler();
+    }
+}
+exports.loadIndexHtmlTransformer = loadIndexHtmlTransformer;

package/src/executors/utilities/module-loader.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+export declare function loadModule<T = any>(path: string): Promise<T>;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+export declare function loadEsmModule<T>(modulePath: string | URL): Promise<T>;

package/src/executors/utilities/module-loader.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEsmModule = exports.loadModule = void 0;
+const path_1 = require("path");
+const node_url_1 = require("node:url");
+async function loadModule(path) {
+    switch ((0, path_1.extname)(path)) {
+        case '.mjs': {
+            const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+            return result.default ?? result;
+        }
+        case '.cjs': {
+            const result = require(path);
+            return result.default ?? result;
+        }
+        default:
+            // it can be CommonJS or ESM, try both
+            try {
+                const result = require(path);
+                return result.default ?? result;
+            }
+            catch (e) {
+                if (e.code === 'ERR_REQUIRE_ESM') {
+                    const result = await loadEsmModule((0, node_url_1.pathToFileURL)(path));
+                    return result.default ?? result;
+                }
+                throw e;
+            }
+    }
+}
+exports.loadModule = loadModule;
+/**
+ * Lazily compiled dynamic import loader function.
+ */
+let load;
+/**
+ * This uses a dynamic import to load a module which may be ESM.
+ * CommonJS code can load ESM code via a dynamic import. Unfortunately, TypeScript
+ * will currently, unconditionally downlevel dynamic import into a require call.
+ * require calls cannot load ESM code and will result in a runtime error. To workaround
+ * this, a Function constructor is used to prevent TypeScript from changing the dynamic import.
+ * Once TypeScript provides support for keeping the dynamic import this workaround can
+ * be dropped.
+ *
+ * @param modulePath The path of the module to load.
+ * @returns A Promise that resolves to the dynamically imported module.
+ */
+function loadEsmModule(modulePath) {
+    load ??= new Function('modulePath', `return import(modulePath);`);
+    return load(modulePath);
+}
+exports.loadEsmModule = loadEsmModule;

package/src/executors/utilities/ng-compiler-cli.d.ts

@@ -0,0 +1 @@
+export declare function ngCompilerCli(): Promise<typeof import('@angular/compiler-cli')>;

package/src/executors/utilities/ng-compiler-cli.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngCompilerCli = void 0;
+const module_loader_1 = require("./module-loader");
+function ngCompilerCli() {
+    return (0, module_loader_1.loadEsmModule)('@angular/compiler-cli');
+}
+exports.ngCompilerCli = ngCompilerCli;

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

@@ -0,0 +1,27 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Use our own function to get the TailwindCSS config path to support a
+ * config at the root of the workspace.
+ */
+export declare enum CssUrl {
+    inline = "inline",
+    none = "none"
+}
+export declare class StylesheetProcessor {
+    private readonly projectBasePath;
+    private readonly basePath;
+    private readonly cssUrl?;
+    private readonly includePaths?;
+    private readonly cacheDirectory?;
+    private renderWorker;
+    constructor(projectBasePath: string, basePath: string, cssUrl?: CssUrl, includePaths?: string[], cacheDirectory?: string | false);
+    process({ filePath, content, }: {
+        filePath: string;
+        content: string;
+    }): Promise<string>;
+    /** Destory workers in pool. */
+    destroy(): void;
+    private createRenderWorker;
+}

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

@@ -0,0 +1,2 @@
+import { FactoryProvider } from 'injection-js';
+export declare const STYLESHEET_PROCESSOR: FactoryProvider;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STYLESHEET_PROCESSOR = void 0;
+const stylesheet_processor_di_1 = require("ng-packagr/lib/styles/stylesheet-processor.di");
+const stylesheet_processor_1 = require("./stylesheet-processor");
+exports.STYLESHEET_PROCESSOR = {
+    provide: stylesheet_processor_di_1.STYLESHEET_PROCESSOR_TOKEN,
+    useFactory: () => stylesheet_processor_1.StylesheetProcessor,
+    deps: [],
+};