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

package/dist/src/generators/ng-add/utilities/types.d.ts

@@ -0,0 +1,31 @@
+import type { ProjectConfiguration } from '@nx/devkit';
+export type MigrationProjectConfiguration = {
+    config: ProjectConfiguration;
+    name: string;
+};
+export type WorkspaceProjects = {
+    apps: MigrationProjectConfiguration[];
+    libs: MigrationProjectConfiguration[];
+};
+export type ProjectMigrationInfo = {
+    name: string;
+    oldRoot: string;
+    oldSourceRoot: string;
+    newRoot: string;
+    newSourceRoot: string;
+};
+export type WorkspaceRootFileType = 'karma' | 'eslint';
+export type WorkspaceRootFileTypesInfo = Record<WorkspaceRootFileType, boolean>;
+export type ValidationError = {
+    message?: string;
+    messageGroup?: {
+        title: string;
+        messages: string[];
+    };
+    hint?: string;
+};
+export type ValidationResult = ValidationError[] | null;
+export type Target = {
+    builders: string[];
+    acceptMultipleDefinitions?: boolean;
+};

package/dist/src/generators/ng-add/utilities/validation-logging.d.ts

@@ -0,0 +1,3 @@
+import type { ValidationError } from './types';
+export declare function arrayToString(array: string[]): string;
+export declare function getProjectValidationResultMessage(validationResult: ValidationError[]): string;

package/dist/src/generators/ng-add/utilities/workspace.d.ts

@@ -0,0 +1,17 @@
+import type { Tree } from '@nx/devkit';
+import type { ProjectMigrator } from '../migrators';
+import type { GeneratorOptions } from '../schema';
+import type { WorkspaceRootFileTypesInfo } from './types';
+export declare function validateWorkspace(tree: Tree): void;
+export declare function createNxJson(tree: Tree, options: GeneratorOptions, defaultProject: string | undefined): void;
+export declare function updateWorkspaceConfigDefaults(tree: Tree): void;
+export declare function updateRootTsConfig(tree: Tree): void;
+export declare function updatePackageJson(tree: Tree): void;
+export declare function updateRootEsLintConfig(tree: Tree, existingEsLintConfig: any | undefined, unitTestRunner?: string): Promise<void>;
+export declare function cleanupEsLintPackages(tree: Tree): void;
+export declare function createWorkspaceFiles(tree: Tree): Promise<void>;
+export declare function createRootKarmaConfig(tree: Tree): void;
+export declare function getWorkspaceRootFileTypesInfo(tree: Tree, migrators: ProjectMigrator[]): WorkspaceRootFileTypesInfo;
+export declare function updateVsCodeRecommendedExtensions(tree: Tree): void;
+export declare function deleteAngularJson(tree: Tree): void;
+export declare function deleteGitKeepFilesIfNotNeeded(tree: Tree): void;

package/dist/src/generators/ng-add/utilities/workspace.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateWorkspace = validateWorkspace;
+exports.createNxJson = createNxJson;
+exports.updateWorkspaceConfigDefaults = updateWorkspaceConfigDefaults;
+exports.updateRootTsConfig = updateRootTsConfig;
+exports.updatePackageJson = updatePackageJson;
+exports.updateRootEsLintConfig = updateRootEsLintConfig;
+exports.cleanupEsLintPackages = cleanupEsLintPackages;
+exports.createWorkspaceFiles = createWorkspaceFiles;
+exports.createRootKarmaConfig = createRootKarmaConfig;
+exports.getWorkspaceRootFileTypesInfo = getWorkspaceRootFileTypesInfo;
+exports.updateVsCodeRecommendedExtensions = updateVsCodeRecommendedExtensions;
+exports.deleteAngularJson = deleteAngularJson;
+exports.deleteGitKeepFilesIfNotNeeded = deleteGitKeepFilesIfNotNeeded;
+const devkit_1 = require("@nx/devkit");
+const eslint_1 = require("@nx/eslint");
+const internal_1 = require("@nx/eslint/internal");
+const js_1 = require("@nx/js");
+const default_base_1 = require("nx/src/utils/default-base");
+const internal_2 = require("@nx/js/internal");
+const angular_json_1 = require("nx/src/adapter/angular-json");
+const versions_1 = require("../../../utils/versions");
+const path_1 = require("path");
+function validateWorkspace(tree) {
+    const errors = [];
+    if (!tree.exists('package.json')) {
+        errors.push('The "package.json" file could not be found.');
+    }
+    if (!tree.exists('angular.json')) {
+        errors.push('The "angular.json" file could not be found.');
+    }
+    if (!errors.length) {
+        return;
+    }
+    throw new Error(`The workspace cannot be migrated because of the following issues:
+
+  - ${errors.join('\n  ')}`);
+}
+function createNxJson(tree, options, defaultProject) {
+    const targets = getWorkspaceCommonTargets(tree);
+    (0, devkit_1.writeJson)(tree, 'nx.json', {
+        defaultBase: options.defaultBase ?? (0, default_base_1.deduceDefaultBase)(),
+        namedInputs: {
+            sharedGlobals: [],
+            default: ['{projectRoot}/**/*', 'sharedGlobals'],
+            production: [
+                'default',
+                ...(targets.test
+                    ? [
+                        '!{projectRoot}/tsconfig.spec.json',
+                        '!{projectRoot}/**/*.spec.[jt]s',
+                        '!{projectRoot}/karma.conf.js',
+                    ]
+                    : []),
+                ...(targets.lint
+                    ? [
+                        '!{projectRoot}/.eslintrc.json',
+                        '!{projectRoot}/eslint.config.cjs',
+                    ]
+                    : []),
+            ].filter(Boolean),
+        },
+        targetDefaults: {
+            build: {
+                dependsOn: ['^build'],
+                inputs: ['production', '^production'],
+                cache: true,
+            },
+            test: targets.test
+                ? {
+                    inputs: ['default', '^production', '{workspaceRoot}/karma.conf.js'],
+                    cache: true,
+                }
+                : undefined,
+            lint: targets.lint
+                ? {
+                    inputs: [
+                        'default',
+                        '{workspaceRoot}/.eslintrc.json',
+                        '{workspaceRoot}/eslint.config.cjs',
+                    ],
+                    cache: true,
+                }
+                : undefined,
+            e2e: targets.e2e
+                ? {
+                    inputs: ['default', '^production'],
+                    cache: true,
+                }
+                : undefined,
+        },
+        defaultProject,
+    });
+}
+function getWorkspaceCommonTargets(tree) {
+    const targets = { e2e: false, lint: false, test: false };
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const [, project] of projects) {
+        if (!targets.e2e && project.targets?.e2e) {
+            targets.e2e = true;
+        }
+        if (!targets.lint && project.targets?.lint) {
+            targets.lint = true;
+        }
+        if (!targets.test && project.targets?.test) {
+            targets.test = true;
+        }
+        if (targets.e2e && targets.lint && targets.test) {
+            return targets;
+        }
+    }
+    return targets;
+}
+function updateWorkspaceConfigDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    delete nxJson.newProjectRoot;
+    if (nxJson.cli) {
+        delete nxJson.defaultCollection;
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function updateRootTsConfig(tree) {
+    const tsconfig = (0, devkit_1.readJson)(tree, (0, js_1.getRootTsConfigPathInTree)(tree));
+    tsconfig.compilerOptions.paths ??= {};
+    tsconfig.compilerOptions.rootDir = '.';
+    tsconfig.exclude = Array.from(new Set([...(tsconfig.exclude ?? []), 'node_modules', 'tmp']));
+    (0, devkit_1.writeJson)(tree, 'tsconfig.base.json', tsconfig);
+    if (tree.exists('tsconfig.json')) {
+        tree.delete('tsconfig.json');
+    }
+}
+function updatePackageJson(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (packageJson) => {
+        packageJson.scripts = packageJson.scripts ?? {};
+        Object.keys(packageJson.scripts).forEach((script) => {
+            packageJson.scripts[script] = packageJson.scripts[script]
+                .replace(/^ng /, 'nx ')
+                .replace(/ ng /, ' nx ');
+        });
+        packageJson.devDependencies = packageJson.devDependencies ?? {};
+        packageJson.dependencies = packageJson.dependencies ?? {};
+        if (!packageJson.devDependencies['@angular/cli']) {
+            packageJson.devDependencies['@angular/cli'] = versions_1.angularDevkitVersion;
+        }
+        if (!packageJson.devDependencies['@nx/workspace'] &&
+            !packageJson.devDependencies['@nrwl/workspace']) {
+            packageJson.devDependencies['@nx/workspace'] = versions_1.nxVersion;
+        }
+        if (!packageJson.devDependencies['nx']) {
+            packageJson.devDependencies['nx'] = versions_1.nxVersion;
+        }
+        if (!packageJson.devDependencies['prettier']) {
+            packageJson.devDependencies['prettier'] = internal_2.prettierVersion;
+        }
+        return packageJson;
+    });
+}
+async function updateRootEsLintConfig(tree, existingEsLintConfig, unitTestRunner) {
+    await (0, eslint_1.lintInitGenerator)(tree, {
+        addPlugin: false,
+    });
+    if (!existingEsLintConfig) {
+        // There was no eslint config in the root, so we set it up and use it as-is
+        (0, internal_1.setupRootEsLint)(tree, { unitTestRunner });
+        return;
+    }
+    existingEsLintConfig.ignorePatterns = ['**/*'];
+    if (!(existingEsLintConfig.plugins ?? []).includes('@nx')) {
+        existingEsLintConfig.plugins = Array.from(new Set([...(existingEsLintConfig.plugins ?? []), '@nx']));
+    }
+    existingEsLintConfig.overrides?.forEach((override) => {
+        if (!override.parserOptions?.project) {
+            return;
+        }
+        delete override.parserOptions.project;
+    });
+    // add the @nx/enforce-module-boundaries rule
+    existingEsLintConfig.overrides = [
+        ...(existingEsLintConfig.overrides ?? []),
+        {
+            files: ['*.ts', '*.tsx', '*.js', '*.jsx'],
+            rules: {
+                '@nx/enforce-module-boundaries': [
+                    'error',
+                    {
+                        enforceBuildableLibDependency: true,
+                        allow: [],
+                        depConstraints: [
+                            { sourceTag: '*', onlyDependOnLibsWithTags: ['*'] },
+                        ],
+                    },
+                ],
+            },
+        },
+    ];
+    (0, devkit_1.writeJson)(tree, '.eslintrc.json', existingEsLintConfig);
+}
+function cleanupEsLintPackages(tree) {
+    (0, devkit_1.updateJson)(tree, 'package.json', (json) => {
+        if (json.devDependencies?.['@angular-eslint/builder']) {
+            delete json.devDependencies['@angular-eslint/builder'];
+        }
+        if (json.dependencies?.['@angular-eslint/builder']) {
+            delete json.dependencies['@angular-eslint/builder'];
+        }
+        if (json.devDependencies?.['@angular-eslint/schematics']) {
+            delete json.devDependencies['@angular-eslint/schematics'];
+        }
+        if (json.dependencies?.['@angular-eslint/schematics']) {
+            delete json.dependencies['@angular-eslint/schematics'];
+        }
+        return json;
+    });
+}
+async function createWorkspaceFiles(tree) {
+    updateVsCodeRecommendedExtensions(tree);
+    await (0, js_1.initGenerator)(tree, { skipFormat: true });
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, '../files/root'), '.', {
+        tmpl: '',
+        dot: '.',
+        rootTsConfigPath: (0, js_1.getRootTsConfigPathInTree)(tree),
+    });
+}
+function createRootKarmaConfig(tree) {
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '../files/root-karma'), '.', {
+        tmpl: '',
+    });
+}
+function getWorkspaceRootFileTypesInfo(tree, migrators) {
+    const workspaceRootFileTypesInfo = {
+        eslint: false,
+        karma: false,
+    };
+    if (tree.exists('.eslintrc.json')) {
+        workspaceRootFileTypesInfo.eslint = true;
+    }
+    if (tree.exists('karma.conf.js')) {
+        workspaceRootFileTypesInfo.karma = true;
+    }
+    if (workspaceRootFileTypesInfo.eslint && workspaceRootFileTypesInfo.karma) {
+        return workspaceRootFileTypesInfo;
+    }
+    for (const migrator of migrators) {
+        const projectInfo = migrator.getWorkspaceRootFileTypesInfo();
+        workspaceRootFileTypesInfo.eslint =
+            workspaceRootFileTypesInfo.eslint || projectInfo.eslint;
+        workspaceRootFileTypesInfo.karma =
+            workspaceRootFileTypesInfo.karma || projectInfo.karma;
+        if (workspaceRootFileTypesInfo.eslint && workspaceRootFileTypesInfo.karma) {
+            return workspaceRootFileTypesInfo;
+        }
+    }
+    return workspaceRootFileTypesInfo;
+}
+function updateVsCodeRecommendedExtensions(tree) {
+    const recommendations = [
+        'nrwl.angular-console',
+        'angular.ng-template',
+        'dbaeumer.vscode-eslint',
+        'esbenp.prettier-vscode',
+    ];
+    if (tree.exists('.vscode/extensions.json')) {
+        (0, devkit_1.updateJson)(tree, '.vscode/extensions.json', (json) => {
+            json.recommendations = json.recommendations || [];
+            recommendations.forEach((extension) => {
+                if (!json.recommendations.includes(extension)) {
+                    json.recommendations.push(extension);
+                }
+            });
+            return json;
+        });
+    }
+    else {
+        (0, devkit_1.writeJson)(tree, '.vscode/extensions.json', {
+            recommendations,
+        });
+    }
+}
+function deleteAngularJson(tree) {
+    const projects = (0, angular_json_1.toNewFormat)((0, devkit_1.readJson)(tree, 'angular.json')).projects;
+    if (!Object.keys(projects).length) {
+        tree.delete('angular.json');
+    }
+}
+function deleteGitKeepFilesIfNotNeeded(tree) {
+    if (tree.children('apps').length > 1 && tree.exists('apps/.gitkeep')) {
+        tree.delete('apps/.gitkeep');
+    }
+    if (tree.children('libs').length > 1 && tree.exists('libs/.gitkeep')) {
+        tree.delete('libs/.gitkeep');
+    }
+}

package/dist/src/generators/ngrx-feature-store/lib/add-exports-barrel.d.ts

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

package/dist/src/generators/ngrx-feature-store/lib/add-exports-barrel.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExportsToBarrel = addExportsToBarrel;
+const devkit_1 = require("@nx/devkit");
+const internal_1 = require("@nx/js/internal");
+const js_1 = require("@nx/js");
+let tsModule;
+function addExportsToBarrel(tree, options) {
+    const indexFilePath = (0, devkit_1.joinPathFragments)(options.parentDirectory, '..', 'index.ts');
+    if (!tree.exists(indexFilePath)) {
+        return;
+    }
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const indexSourceText = tree.read(indexFilePath, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(indexFilePath, indexSourceText, tsModule.ScriptTarget.Latest, true);
+    // Public API for the feature interfaces, selectors, and facade
+    const { className, fileName } = (0, devkit_1.names)(options.name);
+    const fileNameWithSubdir = options.subdirectory
+        ? (0, devkit_1.joinPathFragments)(options.subdirectory, fileName)
+        : fileName;
+    const statePath = `./lib/${options.directory}/${fileNameWithSubdir}`;
+    sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, options.barrels
+        ? `import * as ${className}Actions from '${statePath}.actions';`
+        : `export * from '${statePath}.actions';`);
+    sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, options.barrels
+        ? `import * as ${className}Feature from '${statePath}.reducer';`
+        : `export * from '${statePath}.reducer';`);
+    sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, options.barrels
+        ? `import * as ${className}Selectors from '${statePath}.selectors';`
+        : `export * from '${statePath}.selectors';`);
+    if (options.barrels) {
+        sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, `export { ${className}Actions, ${className}Feature, ${className}Selectors };`);
+    }
+    sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, `export * from '${statePath}.models';`);
+    if (options.facade) {
+        sourceFile = (0, js_1.addGlobal)(tree, sourceFile, indexFilePath, `export * from '${statePath}.facade';`);
+    }
+}

package/dist/src/generators/ngrx-feature-store/lib/add-imports.d.ts

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

package/dist/src/generators/ngrx-feature-store/lib/add-imports.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImportsToModule = addImportsToModule;
+const devkit_1 = require("@nx/devkit");
+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");
+const js_1 = require("@nx/js");
+let tsModule;
+function addStoreForFeatureImport(tree, isParentStandalone, route, sourceFile, parentPath, provideStoreForFeature, storeForFeature) {
+    if (isParentStandalone) {
+        const parentContents = tree.read(parentPath, 'utf-8');
+        if (parentContents.includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideStoreForFeature);
+        }
+        else if (parentContents.includes('bootstrapApplication')) {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideStoreForFeature);
+        }
+        else {
+            (0, route_utils_1.addProviderToRoute)(tree, parentPath, route, provideStoreForFeature);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeForFeature);
+    }
+    return sourceFile;
+}
+function addEffectsForFeatureImport(tree, isParentStandalone, route, sourceFile, parentPath, provideEffectsForFeature, effectsForFeature) {
+    if (isParentStandalone) {
+        const parentContents = tree.read(parentPath, 'utf-8');
+        if (parentContents.includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideEffectsForFeature);
+        }
+        else if (parentContents.includes('bootstrapApplication')) {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideEffectsForFeature);
+        }
+        else {
+            (0, route_utils_1.addProviderToRoute)(tree, parentPath, route, provideEffectsForFeature);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, effectsForFeature);
+    }
+    return sourceFile;
+}
+function addImportsToModule(tree, options) {
+    if (!tsModule) {
+        tsModule = (0, internal_1.ensureTypescript)();
+    }
+    const parentPath = options.parent;
+    const sourceText = tree.read(parentPath, 'utf-8');
+    let sourceFile = tsModule.createSourceFile(parentPath, sourceText, tsModule.ScriptTarget.Latest, true);
+    const isParentStandalone = !sourceText.includes('@NgModule');
+    const addImport = (source, symbolName, fileName, isDefault = false) => {
+        return (0, js_1.insertImport)(tree, source, parentPath, symbolName, fileName, isDefault);
+    };
+    const dir = `./${(0, devkit_1.names)(options.directory).fileName}${options.subdirectory ? `/${options.subdirectory}` : ''}`;
+    const pathPrefix = `${dir}/${(0, devkit_1.names)(options.name).fileName}`;
+    const reducerPath = `${pathPrefix}.reducer`;
+    const effectsPath = `${pathPrefix}.effects`;
+    const facadePath = `${pathPrefix}.facade`;
+    const constantName = `${(0, devkit_1.names)(options.name).constantName}`;
+    const effectsName = `${(0, devkit_1.names)(options.name).className}Effects`;
+    const facadeName = `${(0, devkit_1.names)(options.name).className}Facade`;
+    const className = `${(0, devkit_1.names)(options.name).className}`;
+    const propertyName = `${(0, devkit_1.names)(options.name).propertyName}`;
+    const reducerImports = `* as from${className}`;
+    const storeForFeature = `StoreModule.forFeature(from${className}.${constantName}_FEATURE_KEY, from${className}.${propertyName}Reducer)`;
+    const effectsForFeature = `EffectsModule.forFeature([${effectsName}])`;
+    const provideEffectsForFeature = `provideEffects(${effectsName})`;
+    const provideStoreForFeature = `provideState(from${className}.${constantName}_FEATURE_KEY, from${className}.${propertyName}Reducer)`;
+    if (isParentStandalone) {
+        sourceFile = addImport(sourceFile, 'provideStore', '@ngrx/store');
+        if (!options.minimal) {
+            sourceFile = addImport(sourceFile, 'provideState', '@ngrx/store');
+        }
+        sourceFile = addImport(sourceFile, 'provideEffects', '@ngrx/effects');
+    }
+    else {
+        sourceFile = addImport(sourceFile, 'StoreModule', '@ngrx/store');
+        sourceFile = addImport(sourceFile, 'EffectsModule', '@ngrx/effects');
+    }
+    sourceFile = addImport(sourceFile, reducerImports, reducerPath, true);
+    sourceFile = addImport(sourceFile, effectsName, effectsPath);
+    if (options.facade) {
+        sourceFile = addImport(sourceFile, facadeName, facadePath);
+        if (isParentStandalone) {
+            if (tree.read(parentPath, 'utf-8').includes('ApplicationConfig')) {
+                (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, facadeName);
+            }
+            else {
+                (0, route_utils_1.addProviderToRoute)(tree, parentPath, options.route, facadeName);
+            }
+        }
+        else {
+            sourceFile = (0, ast_utils_1.addProviderToModule)(tree, sourceFile, parentPath, facadeName);
+        }
+    }
+    sourceFile = addStoreForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideStoreForFeature, storeForFeature);
+    sourceFile = addEffectsForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideEffectsForFeature, effectsForFeature);
+}

package/dist/src/generators/ngrx-feature-store/lib/add-ngrx-to-package-json.d.ts

@@ -0,0 +1,3 @@
+import type { GeneratorCallback, Tree } from '@nx/devkit';
+import { NormalizedNgRxFeatureStoreGeneratorOptions } from './normalize-options';
+export declare function addNgRxToPackageJson(tree: Tree, options: NormalizedNgRxFeatureStoreGeneratorOptions): GeneratorCallback;

package/dist/src/generators/ngrx-feature-store/lib/generate-files.d.ts

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

package/dist/src/generators/ngrx-feature-store/lib/index.d.ts

@@ -0,0 +1,6 @@
+export * from './add-imports';
+export * from './add-exports-barrel';
+export * from './add-ngrx-to-package-json';
+export * from './generate-files';
+export * from './normalize-options';
+export * from './validate-options';

package/dist/src/generators/ngrx-feature-store/lib/normalize-options.d.ts

@@ -0,0 +1,9 @@
+import type { Tree } from '@nx/devkit';
+import type { Schema } from '../schema';
+export type NormalizedNgRxFeatureStoreGeneratorOptions = Schema & {
+    parentDirectory: string;
+    subdirectory: string;
+    rxjsVersion: string;
+    rxjsMajorVersion: number;
+};
+export declare function normalizeOptions(tree: Tree, options: Schema): NormalizedNgRxFeatureStoreGeneratorOptions;

package/dist/src/generators/ngrx-feature-store/lib/normalize-options.js

@@ -0,0 +1,40 @@
+"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 path_1 = require("path");
+const semver_1 = require("semver");
+const versions_1 = require("../../../utils/versions");
+function normalizeOptions(tree, options) {
+    let rxjsVersion;
+    try {
+        rxjsVersion = (0, internal_1.checkAndCleanWithSemver)(tree, 'rxjs', (0, devkit_1.readJson)(tree, 'package.json').dependencies['rxjs']);
+    }
+    catch {
+        rxjsVersion = (0, internal_1.checkAndCleanWithSemver)(tree, 'rxjs', versions_1.rxjsVersion);
+    }
+    const rxjsMajorVersion = (0, semver_1.major)(rxjsVersion);
+    const { subdirectory, name } = determineSubdirectoryAndName(options.name);
+    return {
+        ...options,
+        name,
+        subdirectory,
+        parentDirectory: options.parent ? (0, path_1.dirname)(options.parent) : undefined,
+        route: options.route === '' ? `''` : (options.route ?? `''`),
+        directory: (0, devkit_1.names)(options.directory).fileName,
+        rxjsVersion,
+        rxjsMajorVersion,
+    };
+}
+function determineSubdirectoryAndName(name) {
+    if (name.includes('/')) {
+        const parts = name.split('/');
+        const storeName = parts.pop();
+        const subdirectory = (0, devkit_1.joinPathFragments)(...parts);
+        return { subdirectory, name: storeName };
+    }
+    else {
+        return { name };
+    }
+}

package/dist/src/generators/ngrx-feature-store/lib/validate-options.d.ts

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

package/dist/src/generators/ngrx-feature-store/ngrx-feature-store.d.ts

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

package/dist/src/generators/ngrx-feature-store/ngrx-feature-store.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngrxFeatureStoreGenerator = ngrxFeatureStoreGenerator;
+const devkit_1 = require("@nx/devkit");
+const assert_supported_angular_version_1 = require("../../utils/assert-supported-angular-version");
+const lib_1 = require("./lib");
+async function ngrxFeatureStoreGenerator(tree, schema) {
+    (0, assert_supported_angular_version_1.assertSupportedAngularVersion)(tree);
+    (0, lib_1.validateOptions)(tree, schema);
+    const options = (0, lib_1.normalizeOptions)(tree, schema);
+    if (!options.minimal) {
+        (0, lib_1.generateFilesFromTemplates)(tree, options);
+    }
+    if (!options.skipImport) {
+        (0, lib_1.addImportsToModule)(tree, options);
+        (0, lib_1.addExportsToBarrel)(tree, options);
+    }
+    let packageInstallationTask = () => { };
+    if (!options.skipPackageJson) {
+        packageInstallationTask = (0, lib_1.addNgRxToPackageJson)(tree, options);
+    }
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return packageInstallationTask;
+}
+exports.default = ngrxFeatureStoreGenerator;

package/dist/src/generators/ngrx-root-store/lib/add-imports.d.ts

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