@nx/angular 23.0.0-pr.35465.2bc2643 → 23.0.0-rc.0

package/dist/src/generators/library/lib/add-children.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addChildren = addChildren;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const route_utils_1 = require("../../../utils/nx-devkit/route-utils");
+const internal_1 = require("@nx/js/internal");
+let tsModule;
+function addChildren(tree, options) {
+    if (!tree.exists(options.parent)) {
+        throw new Error(`Cannot find '${options.parent}'`);
+    }
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const routeFileSource = tree.read(options.parent, 'utf-8');
+    const constName = options.standalone
+        ? `${(0, devkit_1.names)(options.name).propertyName}Routes`
+        : `${(0, devkit_1.names)(options.fileName).propertyName}Routes`;
+    const importPath = options.importPath;
+    let sourceFile = tsModule.createSourceFile(options.parent, routeFileSource, tsModule.ScriptTarget.Latest, true);
+    if (!options.standalone) {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, options.parent, options.moduleName);
+    }
+    sourceFile = (0, js_1.insertImport)(tree, sourceFile, options.parent, options.standalone ? constName : `${options.moduleName}, ${constName}`, importPath);
+    const route = `{ path: '${(0, devkit_1.names)(options.fileName).fileName}', children: ${constName} }`;
+    (0, route_utils_1.addRoute)(tree, options.parent, route, false, constName, importPath);
+}

package/dist/src/generators/library/lib/add-load-children.d.ts

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

package/dist/src/generators/library/lib/add-load-children.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLoadChildren = addLoadChildren;
+const devkit_1 = require("@nx/devkit");
+const route_utils_1 = require("../../../utils/nx-devkit/route-utils");
+const internal_1 = require("@nx/js/internal");
+let tsModule;
+function addLoadChildren(tree, options) {
+    if (!tree.exists(options.parent)) {
+        throw new Error(`Cannot find '${options.parent}'`);
+    }
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const moduleSource = tree.read(options.parent, 'utf-8');
+    const sourceFile = tsModule.createSourceFile(options.parent, moduleSource, tsModule.ScriptTarget.Latest, true);
+    const route = `{ path: '${(0, devkit_1.names)(options.fileName).fileName}', loadChildren: () => import('${options.importPath}').then(m => m.${options.standalone
+        ? `${(0, devkit_1.names)(options.name).propertyName}Routes`
+        : options.moduleName}) }`;
+    (0, route_utils_1.addRoute)(tree, options.parent, route);
+}

package/dist/src/generators/library/lib/add-module.d.ts

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

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

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { AngularProjectConfiguration } from '../../../utils/types';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function addProject(tree: Tree, libraryOptions: NormalizedSchema['libraryOptions']): Promise<AngularProjectConfiguration>;

package/dist/src/generators/library/lib/add-project.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProject = addProject;
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const internal_2 = require("@nx/js/internal");
+async function addProject(tree, libraryOptions) {
+    const project = {
+        name: libraryOptions.name,
+        root: libraryOptions.projectRoot,
+        sourceRoot: (0, devkit_1.joinPathFragments)(libraryOptions.projectRoot, 'src'),
+        prefix: libraryOptions.prefix,
+        tags: libraryOptions.parsedTags,
+        projectType: 'library',
+        targets: {},
+    };
+    if (libraryOptions.buildable || libraryOptions.publishable) {
+        const executor = libraryOptions.publishable
+            ? '@nx/angular:package'
+            : '@nx/angular:ng-packagr-lite';
+        (0, internal_1.addBuildTargetDefaults)(tree, executor);
+        project.targets.build = {
+            executor,
+            outputs: ['{workspaceRoot}/dist/{projectRoot}'],
+            options: {
+                project: `${libraryOptions.projectRoot}/ng-package.json`,
+                tsConfig: `${libraryOptions.projectRoot}/tsconfig.lib.json`,
+            },
+            configurations: {
+                production: {
+                    tsConfig: `${libraryOptions.projectRoot}/tsconfig.lib.prod.json`,
+                },
+                development: {},
+            },
+            defaultConfiguration: 'production',
+        };
+        if (libraryOptions.publishable) {
+            const nxJson = (0, devkit_1.readJson)(tree, 'nx.json');
+            await (0, internal_2.addReleaseConfigForNonTsSolution)(tree, libraryOptions.name, project);
+        }
+    }
+    (0, devkit_1.addProjectConfiguration)(tree, libraryOptions.name, project);
+    return project;
+}

package/dist/src/generators/library/lib/add-standalone-component.d.ts

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

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

@@ -0,0 +1,4 @@
+import type { Tree } from '@nx/devkit';
+import type { AngularProjectConfiguration } from '../../../utils/types';
+import type { NormalizedSchema } from './normalized-schema';
+export declare function createFiles(tree: Tree, options: NormalizedSchema, project: AngularProjectConfiguration): void;

package/dist/src/generators/library/lib/create-files.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFiles = createFiles;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/internal");
+const semver_1 = require("semver");
+const test_runners_1 = require("../../../utils/test-runners");
+const version_utils_1 = require("../../utils/version-utils");
+function createFiles(tree, options, project) {
+    const rootOffset = (0, devkit_1.offsetFromRoot)(options.libraryOptions.projectRoot);
+    const libNames = (0, devkit_1.names)(options.libraryOptions.fileName);
+    const pathToComponent = options.componentOptions.flat
+        ? options.libraryOptions.fileName
+        : (0, devkit_1.joinPathFragments)(options.libraryOptions.fileName, options.libraryOptions.fileName);
+    const version = (0, version_utils_1.getInstalledAngularVersion)(tree);
+    const { major, minor } = (0, semver_1.parse)(version);
+    const componentType = options.componentOptions.type
+        ? (0, devkit_1.names)(options.componentOptions.type).className
+        : '';
+    const componentFileSuffix = options.componentOptions.type
+        ? `.${options.componentOptions.type}`
+        : '';
+    const substitutions = {
+        libName: options.libraryOptions.name,
+        libFileName: options.libraryOptions.fileName,
+        libClassName: libNames.className,
+        libPropertyName: libNames.propertyName,
+        unitTesting: options.libraryOptions.unitTestRunner !== test_runners_1.UnitTestRunner.None,
+        rootTsConfig: (0, devkit_1.joinPathFragments)(rootOffset, (0, js_1.getRootTsConfigFileName)(tree)),
+        skipModule: options.libraryOptions.skipModule,
+        projectRoot: options.libraryOptions.projectRoot,
+        routing: options.libraryOptions.routing,
+        pathToComponent,
+        importPath: options.libraryOptions.importPath,
+        rootOffset,
+        angularPeerDepVersion: `^${major}.${minor}.0`,
+        componentType,
+        componentFileSuffix,
+        moduleTypeSeparator: options.libraryOptions.moduleTypeSeparator,
+        tpl: '',
+    };
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/base'), options.libraryOptions.projectRoot, substitutions);
+    if (options.libraryOptions.standalone) {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/standalone-components'), options.libraryOptions.projectRoot, substitutions);
+    }
+    else {
+        (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/ng-module'), options.libraryOptions.projectRoot, substitutions);
+        if (options.libraryOptions.skipModule) {
+            tree.delete(options.libraryOptions.modulePath);
+        }
+    }
+    if (!options.libraryOptions.routing) {
+        tree.delete((0, devkit_1.joinPathFragments)((0, internal_1.getProjectSourceRoot)(project, tree), `lib/lib.routes.ts`));
+    }
+    if (!options.libraryOptions.buildable &&
+        !options.libraryOptions.publishable) {
+        tree.delete((0, devkit_1.joinPathFragments)(project.root, `tsconfig.lib.prod.json`));
+        tree.delete((0, devkit_1.joinPathFragments)(project.root, `ng-package.json`));
+        tree.delete((0, devkit_1.joinPathFragments)(project.root, `package.json`));
+    }
+}

package/dist/src/generators/library/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, schema: Schema): Promise<NormalizedSchema>;

package/dist/src/generators/library/lib/normalize-options.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = normalizeOptions;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/devkit/internal");
+const test_runners_1 = require("../../../utils/test-runners");
+const artifact_types_1 = require("../../utils/artifact-types");
+const version_utils_1 = require("../../utils/version-utils");
+async function normalizeOptions(host, schema) {
+    schema.standalone = schema.standalone ?? true;
+    // Create a schema with populated default values
+    const options = {
+        buildable: false,
+        linter: 'eslint',
+        publishable: false,
+        skipFormat: false,
+        // Publishable libs cannot use `full` yet, so if its false then use the passed value or default to `full`
+        compilationMode: schema.publishable
+            ? 'partial'
+            : (schema.compilationMode ?? 'full'),
+        skipModule: schema.skipModule || schema.standalone,
+        ...schema,
+    };
+    await (0, internal_1.ensureRootProjectName)(options, 'library');
+    const { projectName, names: projectNames, projectRoot, importPath, } = await (0, internal_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+    });
+    const fileName = projectNames.projectFileName;
+    const moduleName = `${(0, devkit_1.names)(fileName).className}Module`;
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    const moduleTypeSeparator = (0, artifact_types_1.getModuleTypeSeparator)(host);
+    const modulePath = `${projectRoot}/src/lib/${fileName}${moduleTypeSeparator}module.ts`;
+    const { major: angularMajorVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(host);
+    const unitTestRunner = options.unitTestRunner ??
+        (angularMajorVersion >= 21 && (options.buildable || options.publishable)
+            ? test_runners_1.UnitTestRunner.VitestAngular
+            : angularMajorVersion >= 21
+                ? test_runners_1.UnitTestRunner.VitestAnalog
+                : test_runners_1.UnitTestRunner.Jest);
+    const ngCliSchematicLibRoot = projectName;
+    const allNormalizedOptions = {
+        ...options,
+        linter: options.linter ?? 'eslint',
+        unitTestRunner,
+        prefix: options.prefix ?? 'lib',
+        name: projectName,
+        projectRoot,
+        entryFile: 'index',
+        moduleName,
+        modulePath,
+        parsedTags,
+        fileName,
+        importPath,
+        ngCliSchematicLibRoot,
+        skipTests: unitTestRunner === 'none' ? true : options.skipTests,
+        standaloneComponentName: `${(0, devkit_1.names)(projectNames.projectSimpleName).className}Component`,
+        moduleTypeSeparator,
+    };
+    const { displayBlock, inlineStyle, inlineTemplate, viewEncapsulation, changeDetection, style, skipTests, selector, skipSelector, flat, ...libraryOptions } = allNormalizedOptions;
+    const componentType = (0, artifact_types_1.getComponentType)(host);
+    return {
+        libraryOptions,
+        componentOptions: {
+            name: fileName,
+            standalone: libraryOptions.standalone,
+            displayBlock,
+            inlineStyle,
+            inlineTemplate,
+            viewEncapsulation,
+            changeDetection,
+            style,
+            skipTests,
+            selector,
+            skipSelector,
+            flat,
+            type: componentType,
+        },
+    };
+}

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

@@ -0,0 +1,55 @@
+import { UnitTestRunner } from '../../../utils/test-runners';
+import type { Linter, LinterType } from '@nx/eslint';
+export interface NormalizedSchema {
+    libraryOptions: {
+        directory: string;
+        name?: string;
+        skipFormat?: boolean;
+        addModuleSpec?: boolean;
+        sourceDir?: string;
+        buildable?: boolean;
+        publishable?: boolean;
+        importPath?: string;
+        spec?: boolean;
+        commonModule?: boolean;
+        routing?: boolean;
+        lazy?: boolean;
+        parent?: string;
+        tags?: string;
+        strict?: boolean;
+        compilationMode?: 'full' | 'partial';
+        setParserOptionsProject?: boolean;
+        skipModule?: boolean;
+        skipPackageJson?: boolean;
+        skipPostInstall?: boolean;
+        skipTsConfig?: boolean;
+        standalone?: boolean;
+        linter: Linter | LinterType;
+        unitTestRunner: UnitTestRunner;
+        prefix: string;
+        fileName: string;
+        projectRoot: string;
+        entryFile: string;
+        modulePath: string;
+        moduleName: string;
+        parsedTags: string[];
+        ngCliSchematicLibRoot: string;
+        standaloneComponentName: string;
+        moduleTypeSeparator: '-' | '.';
+    };
+    componentOptions: {
+        name: string;
+        standalone?: boolean;
+        displayBlock?: boolean;
+        inlineStyle?: boolean;
+        inlineTemplate?: boolean;
+        viewEncapsulation?: 'Emulated' | 'None' | 'ShadowDom';
+        changeDetection?: 'Default' | 'OnPush';
+        style?: 'css' | 'scss' | 'sass' | 'less' | 'none';
+        skipTests?: boolean;
+        selector?: string;
+        skipSelector?: boolean;
+        flat?: boolean;
+        type?: string;
+    };
+}

package/dist/src/generators/library/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/library/lib/update-lib-package-npm-scope.d.ts

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

package/dist/src/generators/library/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['libraryOptions']): void;

package/dist/src/generators/library/lib/update-tsconfig-files.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTsConfigFiles = updateTsConfigFiles;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const internal_1 = require("@nx/js/internal");
+const semver_1 = require("semver");
+const tsconfig_utils_1 = require("../../utils/tsconfig-utils");
+const update_project_root_tsconfig_1 = require("../../utils/update-project-root-tsconfig");
+const version_utils_1 = require("../../utils/version-utils");
+function updateTsConfigFiles(tree, options) {
+    (0, js_1.extractTsConfigBase)(tree);
+    updateProjectConfig(tree, options);
+    updateProjectIvyConfig(tree, options);
+    // Only add tsconfig path mapping if skipTsConfig is not true
+    if (!options.skipTsConfig) {
+        (0, js_1.addTsConfigPath)(tree, options.importPath, [
+            (0, devkit_1.joinPathFragments)(options.projectRoot, './src', 'index.ts'),
+        ]);
+    }
+    const compilerOptions = {
+        skipLibCheck: true,
+        experimentalDecorators: true,
+        importHelpers: true,
+        isolatedModules: true,
+        target: 'es2022',
+        moduleResolution: 'bundler',
+        ...(options.strict
+            ? {
+                strict: true,
+                noImplicitOverride: true,
+                noPropertyAccessFromIndexSignature: true,
+                noImplicitReturns: true,
+                noFallthroughCasesInSwitch: true,
+            }
+            : {}),
+    };
+    const rootTsConfigPath = (0, js_1.getRootTsConfigFileName)(tree);
+    const { major: angularMajorVersion, version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+    if ((0, semver_1.gte)(angularVersion, '19.1.0')) {
+        // Angular started warning about emitDecoratorMetadata and isolatedModules
+        // in v19.1.0. If enabled in the root tsconfig, we need to disable it.
+        if ((0, tsconfig_utils_1.getDefinedCompilerOption)(tree, rootTsConfigPath, 'emitDecoratorMetadata') === true) {
+            compilerOptions.emitDecoratorMetadata = false;
+        }
+    }
+    if (angularMajorVersion >= 21) {
+        compilerOptions.moduleResolution = 'bundler';
+    }
+    if (angularMajorVersion >= 20) {
+        compilerOptions.module = 'preserve';
+    }
+    else {
+        compilerOptions.module = 'es2022';
+    }
+    const tsconfigPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json');
+    (0, devkit_1.updateJson)(tree, tsconfigPath, (json) => {
+        json.compilerOptions = {
+            ...json.compilerOptions,
+            ...compilerOptions,
+        };
+        json.compilerOptions = (0, internal_1.getNeededCompilerOptionOverrides)(tree, json.compilerOptions, rootTsConfigPath);
+        if (options.strict) {
+            json.angularCompilerOptions = {
+                ...json.angularCompilerOptions,
+                strictInjectionParameters: true,
+                strictInputAccessModifiers: true,
+                typeCheckHostBindings: angularMajorVersion === 20 ? true : undefined,
+                strictTemplates: true,
+            };
+        }
+        return json;
+    });
+    if (options.unitTestRunner === 'jest') {
+        const tsconfigSpecPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.spec.json');
+        (0, devkit_1.updateJson)(tree, tsconfigSpecPath, (json) => {
+            json.compilerOptions = {
+                ...json.compilerOptions,
+                module: 'commonjs',
+                moduleResolution: 'node10',
+            };
+            json.compilerOptions = (0, internal_1.getNeededCompilerOptionOverrides)(tree, json.compilerOptions, tsconfigPath);
+            return json;
+        });
+    }
+}
+function updateProjectConfig(host, options) {
+    (0, devkit_1.updateJson)(host, `${options.projectRoot}/tsconfig.lib.json`, (json) => {
+        json.include = ['src/**/*.ts'];
+        json.exclude = [
+            ...new Set([
+                ...(json.exclude || []),
+                'src/**/*.spec.ts',
+                'src/**/*.test.ts',
+            ]),
+        ];
+        return json;
+    });
+    // tsconfig.json
+    (0, update_project_root_tsconfig_1.updateProjectRootTsConfig)(host, options.projectRoot, (0, js_1.getRelativePathToRootTsConfig)(host, options.projectRoot));
+}
+function updateProjectIvyConfig(host, options) {
+    if (options.buildable || options.publishable) {
+        return (0, devkit_1.updateJson)(host, `${options.projectRoot}/tsconfig.lib.prod.json`, (json) => {
+            json.angularCompilerOptions['compilationMode'] =
+                options.compilationMode === 'full' ? undefined : 'partial';
+            return json;
+        });
+    }
+}

package/dist/src/generators/library/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/library/lib/validate-options.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = validateOptions;
+const test_runners_1 = require("../../../utils/test-runners");
+const version_utils_1 = require("../../utils/version-utils");
+function validateOptions(tree, options) {
+    if (!options.routing && options.lazy) {
+        throw new Error(`To use "--lazy" option, "--routing" must also be set.`);
+    }
+    if (options.publishable === true && !options.importPath) {
+        throw new Error(`For publishable libs you have to provide a proper "--importPath" which needs to be a valid npm package name (e.g. my-awesome-lib or @myorg/my-lib)`);
+    }
+    if (options.unitTestRunner === test_runners_1.UnitTestRunner.VitestAngular) {
+        const { major: angularMajorVersion, version: angularVersion } = (0, version_utils_1.getInstalledAngularVersionInfo)(tree);
+        if (angularMajorVersion < 21) {
+            throw new Error(`The "vitest-angular" unit test runner requires Angular v21 or higher. ` +
+                `Detected Angular v${angularVersion}. Use "vitest-analog" or "jest" instead.`);
+        }
+        if (!options.buildable && !options.publishable) {
+            throw new Error(`The "vitest-angular" unit test runner requires the library to be buildable or publishable. ` +
+                `Use "vitest-analog" or "jest" instead.`);
+        }
+    }
+}

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

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

package/dist/src/generators/library/library.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.libraryGenerator = libraryGenerator;
+const tslib_1 = require("tslib");
+const internal_1 = require("@nx/devkit/internal");
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const internal_2 = require("@nx/js/internal");
+const init_1 = tslib_1.__importDefault(require("../../generators/init/init"));
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const test_runners_1 = require("../../utils/test-runners");
+const add_linting_1 = tslib_1.__importDefault(require("../add-linting/add-linting"));
+const add_jest_1 = require("../utils/add-jest");
+const add_vitest_1 = require("../utils/add-vitest");
+const dependencies_1 = require("../utils/dependencies");
+const ensure_angular_dependencies_1 = require("../utils/ensure-angular-dependencies");
+const validations_1 = require("../utils/validations");
+const version_utils_1 = require("../utils/version-utils");
+const add_module_1 = require("./lib/add-module");
+const add_project_1 = require("./lib/add-project");
+const add_standalone_component_1 = require("./lib/add-standalone-component");
+const create_files_1 = require("./lib/create-files");
+const normalize_options_1 = require("./lib/normalize-options");
+const set_generator_defaults_1 = require("./lib/set-generator-defaults");
+const update_lib_package_npm_scope_1 = require("./lib/update-lib-package-npm-scope");
+const update_tsconfig_files_1 = require("./lib/update-tsconfig-files");
+const validate_options_1 = require("./lib/validate-options");
+async function libraryGenerator(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, validations_1.assertNotUsingTsSolutionSetup)(tree, 'library');
+    (0, validate_options_1.validateOptions)(tree, schema);
+    const options = await (0, normalize_options_1.normalizeOptions)(tree, schema);
+    const { libraryOptions } = options;
+    const pkgVersions = (0, version_utils_1.versions)(tree);
+    await (0, js_1.initGenerator)(tree, {
+        ...libraryOptions,
+        js: false,
+        skipFormat: true,
+    });
+    await (0, init_1.default)(tree, { ...libraryOptions, skipFormat: true });
+    if (!libraryOptions.skipPackageJson) {
+        // if zone.js is not installed, we'll never install it as a dependency
+        // from the library generator
+        (0, ensure_angular_dependencies_1.ensureAngularDependencies)(tree, /*zoneless*/ true);
+    }
+    const project = await (0, add_project_1.addProject)(tree, libraryOptions);
+    (0, create_files_1.createFiles)(tree, options, project);
+    const unitTestRunnerTask = await addUnitTestRunner(tree, libraryOptions);
+    (0, update_tsconfig_files_1.updateTsConfigFiles)(tree, libraryOptions);
+    updateNpmScopeIfBuildableOrPublishable(tree, libraryOptions);
+    (0, set_generator_defaults_1.setGeneratorDefaults)(tree, options);
+    if (!libraryOptions.standalone) {
+        (0, add_module_1.addModule)(tree, libraryOptions);
+    }
+    else {
+        await (0, add_standalone_component_1.addStandaloneComponent)(tree, options);
+    }
+    await addLinting(tree, libraryOptions);
+    if ((libraryOptions.buildable || libraryOptions.publishable) &&
+        !libraryOptions.skipPackageJson) {
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+            'ng-packagr': pkgVersions.ngPackagrVersion,
+        }, undefined, true);
+        (0, dependencies_1.addBuildableLibrariesPostCssDependencies)(tree);
+    }
+    if (!libraryOptions.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    const tasks = [
+        unitTestRunnerTask,
+        () => (0, devkit_1.installPackagesTask)(tree),
+    ];
+    if (libraryOptions.publishable) {
+        tasks.push(await (0, internal_2.releaseTasks)(tree));
+    }
+    tasks.push(() => (0, internal_1.logShowProjectCommand)(libraryOptions.name));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+async function addUnitTestRunner(host, options) {
+    const zoneless = (0, devkit_1.getDependencyVersionFromPackageJson)(host, 'zone.js') === null;
+    switch (options.unitTestRunner) {
+        case test_runners_1.UnitTestRunner.Jest:
+            await (0, add_jest_1.addJest)(host, {
+                name: options.name,
+                projectRoot: options.projectRoot,
+                skipPackageJson: options.skipPackageJson,
+                strict: options.strict,
+                runtimeTsconfigFileName: 'tsconfig.lib.json',
+                zoneless,
+            });
+            return () => { };
+        case test_runners_1.UnitTestRunner.VitestAngular:
+            return (0, add_vitest_1.addVitestAngular)(host, {
+                name: options.name,
+                projectRoot: options.projectRoot,
+                skipPackageJson: options.skipPackageJson,
+                useNxUnitTestRunnerExecutor: true,
+            });
+        case test_runners_1.UnitTestRunner.VitestAnalog:
+            return (0, add_vitest_1.addVitestAnalog)(host, {
+                name: options.name,
+                projectRoot: options.projectRoot,
+                skipFormat: options.skipFormat,
+                skipPackageJson: options.skipPackageJson,
+                strict: options.strict,
+                zoneless,
+            });
+        default:
+            return () => { };
+    }
+}
+function updateNpmScopeIfBuildableOrPublishable(host, options) {
+    if (options.buildable || options.publishable) {
+        (0, update_lib_package_npm_scope_1.updateLibPackageNpmScope)(host, options);
+    }
+}
+async function addLinting(host, options) {
+    if (options.linter === 'none') {
+        return;
+    }
+    await (0, add_linting_1.default)(host, {
+        projectName: options.name,
+        projectRoot: options.projectRoot,
+        prefix: options.prefix,
+        unitTestRunner: options.unitTestRunner,
+        setParserOptionsProject: options.setParserOptionsProject,
+        skipFormat: true,
+        skipPackageJson: options.skipPackageJson,
+    });
+}
+exports.default = libraryGenerator;