@nx/angular 23.0.0-beta.24 → 23.0.0-beta.25

package/dist/src/executors/extract-i18n/extract-i18n.impl.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = extractI18nExecutor;
+const devkit_1 = require("@nx/devkit");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const builder_package_1 = require("../utilities/builder-package");
+const patch_builder_context_1 = require("../utilities/patch-builder-context");
+async function* extractI18nExecutor(options, context) {
+    const parsedBuildTarget = (0, devkit_1.parseTargetString)(options.buildTarget, context);
+    const buildTargetProjectConfiguration = (0, project_graph_1.readCachedProjectConfiguration)(parsedBuildTarget.project);
+    const buildTarget = buildTargetProjectConfiguration.targets[parsedBuildTarget.target];
+    const isUsingEsbuildBuilder = [
+        '@angular/build:application',
+        '@angular-devkit/build-angular:application',
+        '@angular-devkit/build-angular:browser-esbuild',
+        '@nx/angular:application',
+        '@nx/angular:browser-esbuild',
+    ].includes(buildTarget.executor);
+    const builderContext = await (0, ngcli_adapter_1.createBuilderContext)({
+        builderName: '@nx/angular:extract-i18n',
+        description: 'Extracts i18n messages from source code.',
+        optionSchema: require('./schema.json'),
+    }, context);
+    /**
+     * The Angular CLI extract-i18n builder make some decisions based on the build
+     * target builder but it only considers `@angular-devkit/build-angular:*`
+     * builders. Since we are using a custom builder, we patch the context to
+     * handle `@nx/angular:*` executors.
+     */
+    (0, patch_builder_context_1.patchBuilderContext)(builderContext, isUsingEsbuildBuilder, parsedBuildTarget);
+    (0, builder_package_1.assertBuilderPackageIsInstalled)('@angular-devkit/build-angular');
+    const { executeExtractI18nBuilder } = await import('@angular-devkit/build-angular');
+    return await executeExtractI18nBuilder(options, builderContext);
+}

package/dist/src/executors/extract-i18n/utils/validate-options.d.ts

@@ -0,0 +1,2 @@
+import type { ExtractI18nExecutorOptions } from '../schema';
+export declare function validateOptions(options: ExtractI18nExecutorOptions): void;

package/dist/src/executors/module-federation-dev-server/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './normalize-options';
+export * from './start-dev-remotes';

package/dist/src/executors/module-federation-dev-server/lib/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(schema: Schema): NormalizedSchema;

package/dist/src/executors/module-federation-dev-server/lib/start-dev-remotes.d.ts

@@ -0,0 +1,5 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext, type ProjectConfiguration } from '@nx/devkit';
+export declare function startRemotes(remotes: string[], workspaceProjects: Record<string, ProjectConfiguration>, options: Pick<Schema, 'devRemotes' | 'verbose'>, context: ExecutorContext, target?: 'serve' | 'serve-static'): Promise<AsyncIterable<{
+    success: boolean;
+}>[]>;

package/dist/src/executors/module-federation-dev-server/module-federation-dev-server.impl.d.ts

@@ -0,0 +1,4 @@
+import { type ExecutorContext } from '@nx/devkit';
+import { type Schema } from './schema';
+export declare function moduleFederationDevServerExecutor(schema: Schema, context: ExecutorContext): AsyncGenerator<any, any, any>;
+export default moduleFederationDevServerExecutor;

package/dist/src/executors/module-federation-ssr-dev-server/lib/normalize-options.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(options: Schema): NormalizedSchema;

package/dist/src/executors/module-federation-ssr-dev-server/lib/start-dev-remotes.d.ts

@@ -0,0 +1,5 @@
+import { type Schema } from '../schema';
+import { type ExecutorContext, type ProjectConfiguration } from '@nx/devkit';
+export declare function startRemotes(remotes: string[], workspaceProjects: Record<string, ProjectConfiguration>, options: Pick<Schema, 'devRemotes' | 'verbose'>, context: ExecutorContext): Promise<AsyncIterable<{
+    success: boolean;
+}>[]>;

package/dist/src/executors/module-federation-ssr-dev-server/module-federation-ssr-dev-server.impl.d.ts

@@ -0,0 +1,4 @@
+import { type ExecutorContext } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function moduleFederationSsrDevServerExecutor(schema: Schema, context: ExecutorContext): AsyncGenerator<import("@angular-devkit/build-angular").SSRDevServerBuilderOutput, any, any>;
+export default moduleFederationSsrDevServerExecutor;

package/dist/src/executors/module-federation-ssr-dev-server/module-federation-ssr-dev-server.impl.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moduleFederationSsrDevServerExecutor = moduleFederationSsrDevServerExecutor;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const internal_2 = require("@nx/module-federation/internal");
+const internal_3 = require("@nx/web/internal");
+const fs_1 = require("fs");
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const project_graph_1 = require("nx/src/project-graph/project-graph");
+const path_1 = require("path");
+const module_federation_1 = require("../../builders/utilities/module-federation");
+const builder_package_1 = require("../utilities/builder-package");
+const normalize_options_1 = require("./lib/normalize-options");
+const start_dev_remotes_1 = require("./lib/start-dev-remotes");
+const module_federation_deprecation_1 = require("../../utils/module-federation-deprecation");
+// This is required to ensure that the webpack version used by the Module Federation is the same as the one used by the builders.
+const Module = require('module');
+const originalResolveFilename = Module._resolveFilename;
+const patchedWebpackPath = require.resolve('webpack', {
+    paths: [require.resolve('@angular-devkit/build-angular')],
+});
+// Override the resolve function
+Module._resolveFilename = function (request, parent, isMain, options) {
+    // Intercept webpack specifically
+    if (request === 'webpack') {
+        // Force webpack to resolve from your specific path
+        return patchedWebpackPath;
+    }
+    // For all other modules, use the original resolver
+    return originalResolveFilename.call(this, request, parent, isMain, options);
+};
+async function* moduleFederationSsrDevServerExecutor(schema, context) {
+    (0, module_federation_deprecation_1.warnAngularMfDevSsrExecutorDeprecation)();
+    const options = (0, normalize_options_1.normalizeOptions)(schema);
+    (0, builder_package_1.assertBuilderPackageIsInstalled)('@angular-devkit/build-angular');
+    const { executeSSRDevServerBuilder } = await import('@angular-devkit/build-angular');
+    const currIter = (0, internal_1.eachValueFrom)(executeSSRDevServerBuilder(options, await (0, ngcli_adapter_1.createBuilderContext)({
+        builderName: '@nx/angular:webpack-server',
+        description: 'Build a ssr application',
+        optionSchema: require('../../builders/webpack-server/schema.json'),
+    }, context)));
+    if (options.isInitialHost === false) {
+        return yield* currIter;
+    }
+    const { projects: workspaceProjects } = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(context.projectGraph);
+    const project = workspaceProjects[context.projectName];
+    let pathToManifestFile;
+    if (options.pathToManifestFile) {
+        const userPathToManifestFile = (0, path_1.join)(context.root, options.pathToManifestFile);
+        if (!(0, fs_1.existsSync)(userPathToManifestFile)) {
+            throw new Error(`The provided Module Federation manifest file path does not exist. Please check the file exists at "${userPathToManifestFile}".`);
+        }
+        else if ((0, path_1.extname)(options.pathToManifestFile) !== '.json') {
+            throw new Error(`The Module Federation manifest file must be a JSON. Please ensure the file at ${userPathToManifestFile} is a JSON.`);
+        }
+        pathToManifestFile = userPathToManifestFile;
+    }
+    else {
+        pathToManifestFile = (0, module_federation_1.getDynamicMfManifestFile)(project, context.root);
+    }
+    (0, module_federation_1.validateDevRemotes)({ devRemotes: options.devRemotes }, workspaceProjects);
+    const { remotes, staticRemotesIter, devRemoteIters } = await (0, internal_2.startRemoteIterators)(options, context, start_dev_remotes_1.startRemotes, pathToManifestFile, 'angular', true);
+    const removeBaseUrlEmission = (iter) => (0, internal_1.mapAsyncIterable)(iter, (v) => ({
+        ...v,
+        baseUrl: undefined,
+    }));
+    const combined = (0, internal_1.combineAsyncIterables)(removeBaseUrlEmission(staticRemotesIter), ...(devRemoteIters ? devRemoteIters.map(removeBaseUrlEmission) : []), (0, internal_1.createAsyncIterable)(async ({ next, done }) => {
+        if (!options.isInitialHost) {
+            done();
+            return;
+        }
+        if (remotes.remotePorts.length) {
+            devkit_1.logger.info(`Nx All remotes started, server ready at http://localhost:${options.port}`);
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+            done();
+            return;
+        }
+        try {
+            const portsToWaitFor = staticRemotesIter && options.staticRemotesPort
+                ? [options.staticRemotesPort, ...remotes.remotePorts]
+                : [...remotes.remotePorts];
+            await Promise.all(portsToWaitFor.map((port) => (0, internal_3.waitForPortOpen)(port, {
+                retries: 480,
+                retryDelay: 2500,
+                host: 'localhost',
+            })));
+            next({ success: true, baseUrl: `http://localhost:${options.port}` });
+        }
+        catch (error) {
+            throw new Error(`Failed to start remotes. Check above for any errors.`, {
+                cause: error,
+            });
+        }
+        finally {
+            done();
+        }
+    }));
+    let refs = 2 + (devRemoteIters?.length ?? 0);
+    for await (const result of combined) {
+        if (result.success === false)
+            throw new Error('Remotes failed to start');
+        if (result.success)
+            refs--;
+        if (refs === 0)
+            break;
+    }
+    return yield* currIter;
+}
+exports.default = moduleFederationSsrDevServerExecutor;

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

@@ -0,0 +1,6 @@
+import type { NgEntryPoint as NgEntryPointBase } from 'ng-packagr/src/lib/ng-package/entry-point/entry-point';
+import type { NgPackageConfig } from 'ng-packagr/src/ng-package.schema';
+export type NgEntryPointType = NgEntryPointBase & {
+    primaryDestinationPath?: string;
+};
+export declare function createNgEntryPoint(packageJson: Record<string, any>, ngPackageJson: NgPackageConfig, basePath: string, secondaryData?: Record<string, any>): NgEntryPointType;

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

@@ -0,0 +1,2 @@
+import type { TransformProvider } from 'ng-packagr/src/lib/graph/transform.di';
+export declare function getWriteBundlesTransformProvider(): TransformProvider;

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

@@ -0,0 +1,10 @@
+/**
+ * Adapted from the original ng-packagr.
+ *
+ * Changes made:
+ * - Removed bundling altogether.
+ * - Write the ESM2022 outputs to the file system.
+ * - Fake the FESM2022 outputs pointing them to the ESM2022 outputs.
+ */
+import type { NgPackagrOptions } from 'ng-packagr/src/lib/ng-package/options.di';
+export declare const writeBundlesTransform: (_options: NgPackagrOptions) => import("ng-packagr/src/lib/graph/transform").Transform;

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

@@ -0,0 +1,2 @@
+import { type NgPackagr } from 'ng-packagr';
+export declare function getNgPackagrInstance(): Promise<NgPackagr>;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNgPackagrInstance = getNgPackagrInstance;
+const ng_packagr_1 = require("ng-packagr");
+async function getNgPackagrInstance() {
+    const { getWriteBundlesTransformProvider } = await import('./ng-package/entry-point/write-bundles.di.js');
+    const { getStylesheetProcessorFactoryProvider } = await import('../../utilities/ng-packagr/stylesheet-processor.di.js');
+    const packagr = (0, ng_packagr_1.ngPackagr)();
+    packagr.withProviders([
+        getWriteBundlesTransformProvider(),
+        getStylesheetProcessorFactoryProvider(),
+    ]);
+    return packagr;
+}

package/dist/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, any>;
+export default ngPackagrLiteExecutor;

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

@@ -0,0 +1,2 @@
+import { type NgPackagr } from 'ng-packagr';
+export declare function getNgPackagrInstance(): Promise<NgPackagr>;

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNgPackagrInstance = getNgPackagrInstance;
+const ng_packagr_1 = require("ng-packagr");
+async function getNgPackagrInstance() {
+    const { getStylesheetProcessorFactoryProvider } = await import('../../utilities/ng-packagr/stylesheet-processor.di.js');
+    const packagr = (0, ng_packagr_1.ngPackagr)();
+    packagr.withProviders([getStylesheetProcessorFactoryProvider()]);
+    return packagr;
+}

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

@@ -0,0 +1,16 @@
+import type { ExecutorContext } from '@nx/devkit';
+import { type DependentBuildableProjectNode } from '@nx/js/internal';
+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, any>;
+export declare const packageExecutor: (options: BuildAngularLibraryExecutorOptions, context: ExecutorContext) => AsyncGenerator<{
+    success: boolean;
+}, any, any>;
+export default packageExecutor;

package/dist/src/executors/unit-test/unit-test.impl.d.ts

@@ -0,0 +1,4 @@
+import type { BuilderOutput } from '@angular-devkit/architect';
+import type { ExecutorContext } from '@nx/devkit';
+import type { UnitTestExecutorOptions } from './schema';
+export default function unitTestExecutor(options: UnitTestExecutorOptions, context: ExecutorContext): AsyncIterable<BuilderOutput>;

package/dist/src/executors/unit-test/unit-test.impl.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = unitTestExecutor;
+const ngcli_adapter_1 = require("nx/src/adapter/ngcli-adapter");
+const targets_1 = require("../../utils/targets");
+const semver_1 = require("semver");
+const angular_version_utils_1 = require("../utilities/angular-version-utils");
+const builder_package_1 = require("../utilities/builder-package");
+const esbuild_extensions_1 = require("../utilities/esbuild-extensions");
+async function* unitTestExecutor(options, context) {
+    validateOptions(options);
+    const { plugins: pluginPaths, indexHtmlTransformer: indexHtmlTransformerPath, ...delegateExecutorOptions } = options;
+    const plugins = await (0, esbuild_extensions_1.loadPlugins)(pluginPaths, options.tsConfig);
+    const indexHtmlTransformer = indexHtmlTransformerPath
+        ? await (0, esbuild_extensions_1.loadIndexHtmlTransformer)(indexHtmlTransformerPath, options.tsConfig)
+        : undefined;
+    const builderContext = await (0, ngcli_adapter_1.createBuilderContext)({
+        builderName: '@nx/angular:unit-test',
+        description: 'Run application unit tests.',
+        optionSchema: require('./schema.json'),
+    }, context);
+    const buildTargetSpecifier = options.buildTarget ?? `::development`;
+    const buildTarget = (0, targets_1.targetFromTargetString)(buildTargetSpecifier, context.projectName, 'build');
+    patchBuilderContext(builderContext, buildTarget);
+    (0, builder_package_1.assertBuilderPackageIsInstalled)('@angular/build');
+    const { executeUnitTestBuilder } = await import('@angular/build');
+    return yield* executeUnitTestBuilder(delegateExecutorOptions, builderContext, {
+        codePlugins: plugins,
+        indexHtmlTransformer,
+    });
+}
+function validateOptions(options) {
+    const { version: angularVersion, major: angularMajorVersion } = (0, angular_version_utils_1.getInstalledAngularVersionInfo)();
+    if (angularMajorVersion < 21) {
+        throw new Error(`The "unit-test" executor is only available for Angular versions >= 21.0.0. You are currently using version ${angularVersion}.`);
+    }
+    if ((0, semver_1.lt)(angularVersion, '21.2.0')) {
+        if (options.headless !== undefined) {
+            throw new Error(`The "headless" option requires Angular version 21.2.0 or greater. You are currently using version ${angularVersion}.`);
+        }
+    }
+}
+/**
+ * The Angular CLI unit-test builder only accepts the `@angular/build:application`
+ * and `@angular/build:ng-packagr` builders. We need to patch the builder context
+ * so that it accepts the `@nx/angular:*` executors.
+ *
+ * https://github.com/angular/angular-cli/blob/f9de11d67d3e0e0524372819583bc77756596d4f/packages/angular/build/src/builders/unit-test/builder.ts#L246-L262
+ */
+function patchBuilderContext(context, buildTarget) {
+    const executorToBuilderMap = new Map([
+        ['@nx/angular:application', '@angular/build:application'],
+        ['@nx/angular:ng-packagr-lite', '@angular/build:ng-packagr'],
+        ['@nx/angular:package', '@angular/build:ng-packagr'],
+    ]);
+    const originalGetBuilderNameForTarget = context.getBuilderNameForTarget;
+    context.getBuilderNameForTarget = async (target) => {
+        const builderName = await originalGetBuilderNameForTarget(target);
+        if (executorToBuilderMap.has(builderName)) {
+            return executorToBuilderMap.get(builderName);
+        }
+        return builderName;
+    };
+    const originalGetTargetOptions = context.getTargetOptions;
+    context.getTargetOptions = async (target) => {
+        const options = await originalGetTargetOptions(target);
+        if (target.project === buildTarget.project &&
+            target.target === buildTarget.target &&
+            target.configuration === buildTarget.configuration) {
+            cleanBuildTargetOptions(options);
+        }
+        return options;
+    };
+}
+function cleanBuildTargetOptions(options) {
+    if ('buildLibsFromSource' in options ||
+        'indexHtmlTransformer' in options ||
+        'plugins' in options) {
+        delete options.buildLibsFromSource;
+        delete options.indexHtmlTransformer;
+        delete options.plugins;
+    }
+    return options;
+}

package/dist/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/dist/src/executors/utilities/buildable-libs.d.ts

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

package/dist/src/executors/utilities/builder-package.d.ts

@@ -0,0 +1 @@
+export declare function assertBuilderPackageIsInstalled(packageName: string): void;

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

@@ -0,0 +1,10 @@
+import type { buildApplication } from '@angular/build';
+type Plugin = Parameters<typeof buildApplication>[2]['codePlugins'][number];
+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<any[]>;
+export declare function loadIndexHtmlTransformer(indexHtmlTransformerPath: string, tsConfig: string): Promise<any>;
+export {};

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

@@ -0,0 +1,14 @@
+export declare function loadModule<T = any>(path: string, tsConfig?: 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 = any>(modulePath: string | URL): Promise<T>;

package/dist/src/executors/utilities/ng-packagr/ng-packagr-version.d.ts

@@ -0,0 +1,2 @@
+import { type VersionInfo } from '../angular-version-utils';
+export declare function getNgPackagrVersionInfo(): VersionInfo;

package/dist/src/executors/utilities/ng-packagr/package-imports.d.ts

@@ -0,0 +1,3 @@
+type NgPackagrImportPath = `ng-packagr/src/${string}`;
+export declare function importNgPackagrPath<T>(path: NgPackagrImportPath, ngPackagrMajorVersion: number): T;
+export {};

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

@@ -0,0 +1,14 @@
+/**
+ * Adapted from the original ng-packagr source.
+ *
+ * Changes made:
+ * - Add the project root to the search directories.
+ */
+import type { NgPackageEntryConfig } from 'ng-packagr/src/ng-entrypoint.schema';
+export declare enum CssUrl {
+    inline = "inline",
+    none = "none"
+}
+export declare function getStylesheetProcessor(): new (projectBasePath: string, basePath: string, cssUrl?: CssUrl, includePaths?: string[], sass?: NgPackageEntryConfig['lib']['sass'], cacheDirectory?: string | false, watch?: boolean) => {
+    [key: string]: any;
+};

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

@@ -0,0 +1,2 @@
+import type { FactoryProvider } from 'injection-js';
+export declare function getStylesheetProcessorFactoryProvider(): FactoryProvider;

package/dist/src/executors/utilities/ng-packagr/tailwindcss.d.ts

@@ -0,0 +1 @@
+export declare function getTailwindConfigPath(projectRoot: string, workspaceRoot: string): string | undefined;

package/dist/src/executors/utilities/patch-builder-context.d.ts

@@ -0,0 +1,3 @@
+import type { BuilderContext } from '@angular-devkit/architect';
+import type { Target } from '@nx/devkit';
+export declare function patchBuilderContext(context: BuilderContext, isUsingEsbuildBuilder: boolean, buildTarget: Target): void;

package/dist/src/executors/utilities/typescript.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Adapted from a private function at ng-packagr
+ * https://github.com/ng-packagr/ng-packagr/blob/main/src/lib/ts/tsconfig.ts#L12:
+ *
+ * Changes made:
+ * - Added an extra function that updates the configFilePath in the returned parsed options
+ * to be the original tsconfig file.
+ */
+/**
+ * Proxy function that ensures the configFilePath option points to the original file path.
+ */
+export declare function parseRemappedTsConfigAndMergeDefaults(workspaceRoot: string, originalFilePath: string, remappedFilePath: string): Promise<any>;

package/dist/src/generators/add-linting/add-linting.d.ts

@@ -0,0 +1,4 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import type { AddLintingGeneratorSchema } from './schema';
+export declare function addLintingGenerator(tree: Tree, options: AddLintingGeneratorSchema): Promise<GeneratorCallback>;
+export default addLintingGenerator;

package/dist/src/generators/add-linting/lib/add-angular-eslint-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export declare function addAngularEsLintDependencies(tree: Tree, projectName: string): GeneratorCallback;

package/dist/src/generators/add-linting/lib/buildable-project.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function isBuildableLibraryProject(tree: Tree, projectName: string): boolean;

package/dist/src/generators/application/application.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function applicationGenerator(tree: Tree, schema: Schema): Promise<GeneratorCallback>;
+export default applicationGenerator;

package/dist/src/generators/application/lib/add-e2e.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addE2e(tree: Tree, options: NormalizedSchema): Promise<number>;

package/dist/src/generators/application/lib/add-linting.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addLinting(host: Tree, options: NormalizedSchema): Promise<void>;

package/dist/src/generators/application/lib/add-proxy-config.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addProxyConfig(host: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/add-serve-static-target.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addServeStaticTarget(tree: Tree, options: NormalizedSchema, port: number): void;

package/dist/src/generators/application/lib/add-unit-test-runner.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addUnitTestRunner(host: Tree, options: NormalizedSchema): Promise<GeneratorCallback>;

package/dist/src/generators/application/lib/create-files.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function createFiles(tree: Tree, options: NormalizedSchema, rootOffset: string): Promise<void>;

package/dist/src/generators/application/lib/create-project.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function createProject(tree: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/enable-strict-type-checking.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function enableStrictTypeChecking(host: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/index.d.ts

@@ -0,0 +1,13 @@
+export * from './add-e2e';
+export * from './add-linting';
+export * from './add-proxy-config';
+export * from './add-serve-static-target';
+export * from './add-unit-test-runner';
+export * from './create-files';
+export * from './create-project';
+export * from './enable-strict-type-checking';
+export * from './normalize-options';
+export * from './normalized-schema';
+export * from './set-generator-defaults';
+export * from './update-tsconfig-files';
+export * from './validate-options';

package/dist/src/generators/application/lib/normalize-options.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function normalizeOptions(host: Tree, options: Partial<Schema>, isRspack?: boolean): Promise<NormalizedSchema>;

package/dist/src/generators/application/lib/normalized-schema.d.ts

@@ -0,0 +1,15 @@
+import { E2eTestRunner, UnitTestRunner } from '../../../utils/test-runners';
+import type { Schema } from '../schema';
+import { Linter, LinterType } from '@nx/eslint';
+export interface NormalizedSchema extends Schema {
+    linter: Linter | LinterType;
+    unitTestRunner: UnitTestRunner;
+    e2eTestRunner: E2eTestRunner;
+    prefix: string;
+    appProjectRoot: string;
+    appProjectSourceRoot: string;
+    e2eProjectName: string;
+    e2eProjectRoot: string;
+    parsedTags: string[];
+    outputPath: string;
+}

package/dist/src/generators/application/lib/set-generator-defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function setGeneratorDefaults(tree: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/update-tsconfig-files.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function updateTsconfigFiles(tree: Tree, options: NormalizedSchema): void;

package/dist/src/generators/application/lib/validate-options.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function validateOptions(tree: Tree, options: Schema): void;

package/dist/src/generators/component/component.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from './schema';
+export declare function componentGenerator(tree: Tree, rawOptions: Schema): Promise<void>;
+export default componentGenerator;

package/dist/src/generators/component/lib/component.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from '../schema';
+export declare function exportComponentInEntryPoint(tree: Tree, schema: NormalizedSchema): void;

package/dist/src/generators/component/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './component';
+export * from './module';
+export * from './normalize-options';
+export * from './set-generator-defaults';

package/dist/src/generators/component/lib/module.d.ts

@@ -0,0 +1,8 @@
+import type { Tree } from '@nx/devkit';
+export type ModuleOptions = {
+    directory: string;
+    module?: string;
+    moduleExt?: string;
+    routingModuleExt?: string;
+};
+export declare function findModuleFromOptions(tree: Tree, options: ModuleOptions, projectRoot: string): string;

package/dist/src/generators/component/lib/normalize-options.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeOptions(tree: Tree, options: Schema): Promise<NormalizedSchema>;

package/dist/src/generators/component/lib/set-generator-defaults.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from '../schema';
+export declare function setGeneratorDefaults(tree: Tree, options: NormalizedSchema): void;