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

package/dist/src/generators/setup-mf/lib/generate-config.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedOptions } from '../schema';
+export declare function generateWebpackConfig(tree: Tree, options: NormalizedOptions, appRoot: string, remotesWithPorts: {
+    remoteName: string;
+    port: number;
+}[]): void;

package/dist/src/generators/setup-mf/lib/get-remotes-with-ports.d.ts

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export declare function getRemotesWithPorts(host: Tree, options: Schema): {
+    remoteName: string;
+    port: number;
+}[];

package/dist/src/generators/setup-mf/lib/index.d.ts

@@ -0,0 +1,15 @@
+export * from './add-cypress-workaround';
+export * from './add-remote-entry';
+export * from './add-remote-to-host';
+export * from './change-build-target';
+export * from './fix-bootstrap';
+export * from './generate-config';
+export * from './get-remotes-with-ports';
+export * from './move-angular-plugin-to-dependencies';
+export * from './normalize-options';
+export * from './update-tsconfig';
+export * from './setup-host-if-dynamic';
+export * from './setup-serve-target';
+export * from './update-host-app-routes';
+export * from './remove-dead-code-from-remote';
+export * from './setup-tspath-for-remote';

package/dist/src/generators/setup-mf/lib/move-angular-plugin-to-dependencies.d.ts

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

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

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

package/dist/src/generators/setup-mf/lib/remove-dead-code-from-remote.d.ts

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

package/dist/src/generators/setup-mf/lib/setup-host-if-dynamic.d.ts

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

package/dist/src/generators/setup-mf/lib/setup-serve-target.d.ts

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

package/dist/src/generators/setup-mf/lib/setup-tspath-for-remote.d.ts

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

package/dist/src/generators/setup-mf/lib/update-host-app-routes.d.ts

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

package/dist/src/generators/setup-mf/lib/update-tsconfig.d.ts

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

package/dist/src/generators/setup-mf/setup-mf.d.ts

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

package/dist/src/generators/setup-ssr/lib/add-dependencies.d.ts

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

package/dist/src/generators/setup-ssr/lib/add-hydration.d.ts

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

package/dist/src/generators/setup-ssr/lib/add-server-file.d.ts

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

package/dist/src/generators/setup-ssr/lib/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_BROWSER_DIR = "browser";
+export declare const DEFAULT_MEDIA_DIR = "media";
+export declare const DEFAULT_SERVER_DIR = "server";

package/dist/src/generators/setup-ssr/lib/generate-files.d.ts

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

package/dist/src/generators/setup-ssr/lib/generate-server-ts-config.d.ts

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

package/dist/src/generators/setup-ssr/lib/index.d.ts

@@ -0,0 +1,9 @@
+export * from './add-dependencies';
+export * from './add-server-file';
+export * from './generate-files';
+export * from './generate-server-ts-config';
+export * from './normalize-options';
+export * from './update-project-config';
+export * from './validate-options';
+export * from './add-hydration';
+export * from './set-router-initial-navigation';

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

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

package/dist/src/generators/setup-ssr/lib/set-router-initial-navigation.d.ts

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

package/dist/src/generators/setup-ssr/lib/update-project-config.d.ts

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

package/dist/src/generators/setup-ssr/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/setup-ssr/setup-ssr.d.ts

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

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

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

package/dist/src/generators/storybook-configuration/lib/assert-compatible-storybook-version.d.ts

@@ -0,0 +1 @@
+export declare function assertCompatibleStorybookVersion(): void;

package/dist/src/generators/storybook-configuration/lib/generate-stories.d.ts

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

package/dist/src/generators/storybook-configuration/lib/generate-storybook-configuration.d.ts

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

package/dist/src/generators/storybook-configuration/storybook-configuration.d.ts

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

package/dist/src/generators/utils/add-jest.d.ts

@@ -0,0 +1,11 @@
+import { type Tree } from '@nx/devkit';
+export type AddJestOptions = {
+    name: string;
+    projectRoot: string;
+    skipPackageJson: boolean;
+    strict: boolean;
+    runtimeTsconfigFileName: 'tsconfig.app.json' | 'tsconfig.lib.json';
+    zoneless: boolean;
+    addPlugin?: boolean;
+};
+export declare function addJest(tree: Tree, options: AddJestOptions): Promise<void>;

package/dist/src/generators/utils/add-mf-env-to-inputs.d.ts

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

package/dist/src/generators/utils/add-vitest.d.ts

@@ -0,0 +1,18 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type AddVitestAngularOptions = {
+    name: string;
+    projectRoot: string;
+    skipPackageJson: boolean;
+    useNxUnitTestRunnerExecutor?: boolean;
+};
+export type AddVitestAnalogOptions = {
+    name: string;
+    projectRoot: string;
+    skipFormat: boolean;
+    skipPackageJson: boolean;
+    strict: boolean;
+    zoneless: boolean;
+    addPlugin?: boolean;
+};
+export declare function addVitestAngular(tree: Tree, options: AddVitestAngularOptions): Promise<GeneratorCallback>;
+export declare function addVitestAnalog(tree: Tree, options: AddVitestAnalogOptions): Promise<GeneratorCallback>;

package/dist/src/generators/utils/add-vitest.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addVitestAngular = addVitestAngular;
+exports.addVitestAnalog = addVitestAnalog;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const devkit_internals_1 = require("nx/src/devkit-internals");
+const semver_1 = require("semver");
+const versions_1 = require("../../utils/versions");
+const version_utils_1 = require("./version-utils");
+async function addVitestAngular(tree, options) {
+    validateVitestVersion(tree);
+    const executor = options.useNxUnitTestRunnerExecutor
+        ? '@nx/angular:unit-test'
+        : '@angular/build:unit-test';
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.name);
+    project.targets ??= {};
+    project.targets.test = { executor, options: { watch: false } };
+    (0, devkit_1.updateProjectConfiguration)(tree, options.name, project);
+    const nxJson = (0, devkit_1.readNxJson)(tree) ?? {};
+    const existing = (0, internal_1.normalizeTargetDefaults)(nxJson.targetDefaults).find((entry) => entry.executor === executor &&
+        entry.target === undefined &&
+        entry.projects === undefined &&
+        entry.plugin === undefined);
+    if (!existing) {
+        (0, internal_1.upsertTargetDefault)(tree, nxJson, {
+            executor,
+            cache: true,
+            inputs: nxJson.namedInputs && 'production' in nxJson.namedInputs
+                ? ['default', '^production']
+                : ['default', '^default'],
+        });
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    configureTypeScriptForVitest(tree, options.projectRoot);
+    addVitestScreenshotsToGitIgnore(tree);
+    if (options.skipPackageJson) {
+        return () => { };
+    }
+    const pkgVersions = (0, version_utils_1.versions)(tree, { minAngularMajorVersion: 21 });
+    const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ?? pkgVersions.angularDevkitVersion;
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@angular/build': angularDevkitVersion,
+        jsdom: pkgVersions.jsdomVersion,
+        vitest: pkgVersions.vitestVersion,
+    }, undefined, true);
+}
+async function addVitestAnalog(tree, options) {
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    const tasks = [];
+    if (!options.skipPackageJson) {
+        const angularDevkitVersion = (0, version_utils_1.getInstalledAngularDevkitVersion)(tree) ??
+            (0, version_utils_1.versions)(tree).angularDevkitVersion;
+        const devDependencies = {
+            '@angular/build': angularDevkitVersion,
+            // `@analogjs/vite-plugin-angular` (wired in by `@nx/vitest`'s
+            // configurationGenerator for `uiFramework: 'angular'`) registers
+            // an `angularVitestPlugin` whose `transform` hook downlevels
+            // `@angular/*` fesm2022 modules via
+            // `vite.transformWithOxc({ target: 'es2016', … })` so Zone.js
+            // `fakeAsync` can intercept async/await. The lowered code emits
+            // external `@oxc-project/runtime/helpers/*` imports (oxc default
+            // `HelperMode = 'Runtime'`). Nothing in the upstream chain
+            // (analogjs, @angular/core, vite, rolldown) declares the runtime
+            // in a way that's resolvable from the consumer's workspace, so
+            // it must be added here.
+            '@oxc-project/runtime': versions_1.oxcProjectRuntimeVersion,
+        };
+        // Add compatible vitest/jsdom versions BEFORE calling configurationGenerator
+        // so that @nx/vitest respects existing versions
+        if (angularMajorVersion < 21) {
+            const pkgVersions = (0, version_utils_1.versions)(tree);
+            devDependencies['vitest'] = pkgVersions.vitestVersion;
+            devDependencies['jsdom'] = pkgVersions.jsdomVersion;
+        }
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies, undefined, true));
+    }
+    (0, devkit_1.ensurePackage)('@nx/vitest', versions_1.nxVersion);
+    const { configurationGenerator, } = require('@nx/vitest/generators');
+    tasks.push(await configurationGenerator(tree, {
+        project: options.name,
+        uiFramework: 'angular',
+        testEnvironment: 'jsdom',
+        coverageProvider: 'v8',
+        addPlugin: options.addPlugin ?? false,
+        skipFormat: options.skipFormat,
+        skipPackageJson: options.skipPackageJson,
+        zoneless: options.zoneless,
+    }));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function validateVitestVersion(tree) {
+    let installedVitestVersion = null;
+    // Try to get the actual installed version from node_modules
+    try {
+        const { packageJson } = (0, devkit_internals_1.readModulePackageJson)('vitest');
+        installedVitestVersion = packageJson.version;
+    }
+    catch { }
+    const pkgVersions = (0, version_utils_1.versions)(tree, { minAngularMajorVersion: 21 });
+    const requiredRange = pkgVersions.vitestVersion;
+    if (installedVitestVersion) {
+        if (!(0, semver_1.satisfies)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The installed vitest version "${installedVitestVersion}" is not compatible with the version range Angular requires: "${requiredRange}".`);
+        }
+        return;
+    }
+    // not installed, get it from package.json
+    installedVitestVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vitest');
+    if (!installedVitestVersion) {
+        // not declared anywhere, it'll be installed with the correct version
+        return;
+    }
+    if ((0, semver_1.valid)(installedVitestVersion)) {
+        if (!(0, semver_1.satisfies)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The installed vitest version "${installedVitestVersion}" is not compatible with the version range Angular requires: "${requiredRange}".`);
+        }
+    }
+    else if ((0, semver_1.validRange)(installedVitestVersion)) {
+        // it's a range from package.json, check if it intersects with the required range
+        if (!(0, semver_1.intersects)(installedVitestVersion, requiredRange, {
+            includePrerelease: true,
+        })) {
+            throw new Error(`The declared vitest version range "${installedVitestVersion}" does not overlap with the version range Angular requires: "${requiredRange}". When installed, this may cause compatibility issues.`);
+        }
+    }
+    else {
+        // it can be anything, we don't have a way to validate it
+        // log a warning and continue
+        devkit_1.logger.warn(`The declared vitest version "${installedVitestVersion}" is not a valid semver range, ` +
+            `so we can't validate if it's compatible with the version range Angular requires: "${requiredRange}". ` +
+            `The generation will continue, but you may encounter issues if the version is not compatible.`);
+    }
+}
+function configureTypeScriptForVitest(tree, projectRoot) {
+    (0, devkit_1.writeJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.spec.json'), {
+        extends: './tsconfig.json',
+        compilerOptions: {
+            outDir: `${(0, devkit_1.offsetFromRoot)(projectRoot)}dist/out-tsc`,
+            types: ['vitest/globals'],
+        },
+        include: ['src/**/*.ts', 'src/**/*.d.ts'],
+    });
+    const projectTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json');
+    (0, devkit_1.updateJson)(tree, projectTsconfigPath, (json) => {
+        json.references ??= [];
+        if (!json.references.some((ref) => ref.path === './tsconfig.spec.json')) {
+            json.references.push({ path: './tsconfig.spec.json' });
+        }
+        return json;
+    });
+}
+function addVitestScreenshotsToGitIgnore(tree) {
+    if (tree.exists('.gitignore')) {
+        let content = tree.read('.gitignore', 'utf-8');
+        if (/^__screenshots__\/$/gm.test(content)) {
+            return;
+        }
+        content = `${content}\n__screenshots__/\n`;
+        tree.write('.gitignore', content);
+    }
+    else {
+        devkit_1.logger.warn(`Couldn't find .gitignore file to update`);
+    }
+}

package/dist/src/generators/utils/app-components-info.d.ts

@@ -0,0 +1,9 @@
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+export type ComponentMetadata = {
+    fileName: string;
+    extensionlessFileName: string;
+    path: string;
+    symbolName: string;
+};
+export declare function getAppComponentInfo(tree: Tree, componentFileSuffix: string, project: ProjectConfiguration): ComponentMetadata;
+export declare function getNxWelcomeComponentInfo(tree: Tree, componentFileSuffix: string, project: ProjectConfiguration): ComponentMetadata;

package/dist/src/generators/utils/artifact-types.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare function getComponentType(tree: Tree): string | undefined;
+export declare function getModuleTypeSeparator(tree: Tree): '-' | '.';

package/dist/src/generators/utils/assert-mf-utils.d.ts

@@ -0,0 +1 @@
+export declare function assertRspackIsCSR(bundler: 'webpack' | 'rspack', ssr: boolean): void;

package/dist/src/generators/utils/dependencies.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function addBuildableLibrariesPostCssDependencies(tree: Tree): void;

package/dist/src/generators/utils/ensure-angular-dependencies.d.ts

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

package/dist/src/generators/utils/entry-point.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function locateLibraryEntryPointFromDirectory(tree: Tree, directory: string, projectRoot: string, projectSourceRoot: string): string | null;

package/dist/src/generators/utils/export-scam.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '@nx/devkit';
+export type GenerationOptions = {
+    directory: string;
+    filePath: string;
+    name: string;
+    projectName: string;
+    modulePath: string;
+    export?: boolean;
+    inlineScam?: boolean;
+};
+export declare function exportScam(tree: Tree, options: GenerationOptions): void;

package/dist/src/generators/utils/find-module.d.ts

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import { ngModuleDecoratorProperty } from './insert-ngmodule-import';
+export declare function findModule(tree: Tree, path: string, module?: string): string;
+export declare function addToNgModule(tree: Tree, path: string, modulePath: string, name: string, className: string, fileName: string, ngModuleProperty: ngModuleDecoratorProperty, isFlat?: boolean, isExported?: boolean): void;

package/dist/src/generators/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './insert-ngmodule-import';
+export * from './find-module';

package/dist/src/generators/utils/insert-ngmodule-import.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+export type ngModuleDecoratorProperty = 'imports' | 'providers' | 'declarations' | 'exports';
+export declare function insertNgModuleProperty(tree: Tree, modulePath: string, name: string, property: ngModuleDecoratorProperty): void;
+export declare function insertNgModuleImport(tree: Tree, modulePath: string, importName: string): void;

package/dist/src/generators/utils/path.d.ts

@@ -0,0 +1 @@
+export declare function getRelativeImportToFile(sourceFilePath: string, targetFilePath: string): string;

package/dist/src/generators/utils/project.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function getProjectPrefix(tree: Tree, project: string): string | undefined;

package/dist/src/generators/utils/selector.d.ts

@@ -0,0 +1,3 @@
+import { names } from '@nx/devkit';
+export declare function buildSelector(name: string, prefix: string | undefined, projectPrefix: string | undefined, casing: keyof Pick<ReturnType<typeof names>, 'fileName' | 'propertyName'>): string;
+export declare function validateHtmlSelector(selector: string): void;

package/dist/src/generators/utils/storybook-ast/component-info.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from '@nx/devkit';
+import type { EntryPoint } from './entry-point';
+export interface ComponentInfo {
+    componentFileName: string;
+    moduleFolderPath: string;
+    name: string;
+    path: string;
+    entryPointName: string;
+}
+export declare function getComponentsInfo(tree: Tree, entryPoint: EntryPoint, moduleFilePaths: string[], projectName: string): ComponentInfo[];
+export declare function getStandaloneComponentsInfo(tree: Tree, entryPoint: EntryPoint): ComponentInfo[];

package/dist/src/generators/utils/storybook-ast/entry-point.d.ts

@@ -0,0 +1,7 @@
+import type { Tree } from '@nx/devkit';
+export type EntryPoint = {
+    name: string;
+    path: string;
+    excludeDirs?: string[];
+};
+export declare function getProjectEntryPoints(tree: Tree, projectName: string): EntryPoint[];

package/dist/src/generators/utils/storybook-ast/module-info.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '@nx/devkit';
+import type { SourceFile } from 'typescript';
+import type { EntryPoint } from './entry-point';
+export declare function getModuleDeclarations(file: SourceFile, moduleFilePath: string, projectName: string): string[];
+export declare function getModuleFilePaths(tree: Tree, entryPoint: EntryPoint): string[];

package/dist/src/generators/utils/storybook-ast/storybook-inputs.d.ts

@@ -0,0 +1,12 @@
+import type { Tree } from '@nx/devkit';
+import type { PropertyDeclaration } from 'typescript';
+export type ArgType = 'text' | 'boolean' | 'number' | 'select';
+export interface InputDescriptor {
+    name: string;
+    type: ArgType;
+    defaultValue?: string;
+}
+export declare function getInputPropertyDeclarations(tree: Tree, path: string): PropertyDeclaration[];
+export declare function getComponentProps(tree: Tree, componentPath: string, getArgsDefaultValueFn?: (property: PropertyDeclaration) => string | undefined, useDecoratorName?: boolean): InputDescriptor[];
+export declare function getArgType(property: PropertyDeclaration): ArgType;
+export declare function getArgsDefaultValue(property: PropertyDeclaration): string;

package/dist/src/generators/utils/testing.d.ts

@@ -0,0 +1,10 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema as ApplicationOptions } from '../application/schema';
+import type { Schema as HostOptions } from '../host/schema';
+import type { Schema as LibraryOptions } from '../library/schema';
+import type { Schema as RemoteOptions } from '../remote/schema';
+export declare function generateTestApplication(tree: Tree, options: ApplicationOptions): Promise<void>;
+export declare function generateTestHostApplication(tree: Tree, options: HostOptions): Promise<void>;
+export declare function generateTestRemoteApplication(tree: Tree, options: RemoteOptions): Promise<void>;
+export declare function generateTestLibrary(tree: Tree, options: LibraryOptions): Promise<void>;
+export declare function createStorybookTestWorkspaceForLib(libName: string): Promise<Tree>;

package/dist/src/generators/utils/tsconfig-utils.d.ts

@@ -0,0 +1,12 @@
+import type { Tree } from '@nx/devkit';
+import type * as ts from 'typescript';
+/**
+ * Gets the resolved value of a specific compiler option from the TypeScript configuration hierarchy.
+ *
+ * @param tree - The file system tree
+ * @param tsConfigPath - Path to the tsconfig file to resolve
+ * @param optionName - Name of the compiler option to retrieve
+ * @returns The resolved value of the compiler option, or undefined if not set
+ */
+export declare function getDefinedCompilerOption(tree: Tree, tsConfigPath: string, optionName: keyof ts.CompilerOptions): any | undefined;
+export declare function readCompilerOptionsFromTsConfig(tree: Tree, tsConfigPath: string): ts.CompilerOptions;

package/dist/src/generators/utils/types.d.ts

@@ -0,0 +1 @@
+export type Styles = 'css' | 'less' | 'scss' | 'sass';

package/dist/src/generators/utils/update-app-editor-tsconfig-excluded-files.d.ts

@@ -0,0 +1,2 @@
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+export declare function updateAppEditorTsConfigExcludedFiles(tree: Tree, projectConfig: ProjectConfiguration): void;

package/dist/src/generators/utils/update-project-root-tsconfig.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export { extractTsConfigBase } from '@nx/js';
+export declare function updateProjectRootTsConfig(host: Tree, projectRoot: string, relativePathToRootTsConfig: string, isRootProject?: boolean): void;

package/dist/src/generators/utils/validations.d.ts

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export declare function validateProject(tree: Tree, projectName: string): void;
+export declare function validateClassName(className: string): void;
+export declare function assertNotUsingTsSolutionSetup(tree: Tree, generatorName: string): void;

package/dist/src/generators/utils/version-utils.d.ts

@@ -0,0 +1,29 @@
+import { type Tree } from '@nx/devkit';
+import { type PackageCompatVersions, type SupportedVersion, supportedVersions, type VersionMap } from '../../utils/backward-compatible-versions';
+export declare function getInstalledAngularDevkitVersion(tree: Tree): string | null;
+export declare function getInstalledAngularVersion(tree: Tree): string;
+export declare function getInstalledAngularMajorVersion(tree: Tree): number;
+export declare function getInstalledAngularVersionInfo(tree: Tree): {
+    version: string;
+    major: number;
+};
+export declare function getInstalledPackageVersionInfo(tree: Tree, pkgName: string): {
+    major: number;
+    version: string;
+};
+export declare function versions(tree: Tree): PackageCompatVersions;
+export declare function versions<V extends SupportedVersion>(tree: Tree, options: {
+    minAngularMajorVersion: V;
+}): MinVersionReturnType<V>;
+/**
+ * Temporary helper to abstract away the version of angular-rspack to be installed
+ * until we stop supporting Angular 19.
+ */
+export declare function getAngularRspackVersion(tree: Tree): string;
+type TakeUntil<Arr extends readonly any[], Target> = Arr extends readonly [
+    infer Head,
+    ...infer Rest
+] ? Head extends Target ? [Head] : [Head, ...TakeUntil<Rest, Target>] : [];
+type VersionsAtLeast<MinV extends SupportedVersion> = Extract<SupportedVersion, TakeUntil<typeof supportedVersions, MinV>[number]>;
+type MinVersionReturnType<MinV extends SupportedVersion> = VersionMap[VersionsAtLeast<MinV>];
+export {};

package/dist/src/generators/web-worker/lib/add-snippet.d.ts

@@ -0,0 +1,2 @@
+import type { Tree } from '@nx/devkit';
+export declare function addSnippet(tree: Tree, name: string, path: string): void;

package/dist/src/generators/web-worker/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './normalize-options';
+export * from './add-snippet';

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

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

package/dist/src/generators/web-worker/web-worker.d.ts

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

package/dist/src/migrations/update-19-2-1/add-typescript-eslint-utils.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+export declare const typescriptEslintUtilsVersion = "^7.16.0";
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-5-0/update-angular-cli.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~18.1.0";
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-0/turn-off-dts-by-default.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export default function (tree: Tree): Promise<void>;

package/dist/src/migrations/update-19-6-0/update-angular-cli.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare const angularCliVersion = "~18.2.0";
+export default function (tree: Tree): Promise<void>;