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

package/src/generators/ngrx/files/__directory__/__fileName__.selectors.ts__tmpl__

@@ -0,0 +1,38 @@
+import { createFeatureSelector, createSelector } from '@ngrx/store';
+import { <%= constantName %>_FEATURE_KEY, <%= className %>State, <%= propertyName %>Adapter } from './<%= fileName %>.reducer';
+
+// Lookup the '<%= className %>' feature state managed by NgRx
+export const select<%= className %>State = createFeatureSelector<<%= className %>State>(<%= constantName %>_FEATURE_KEY);
+
+const { selectAll, selectEntities } = <%= propertyName %>Adapter.getSelectors();
+
+export const select<%= className %>Loaded = createSelector(
+  select<%= className %>State,
+  (state: <%= className %>State) => state.loaded
+);
+
+export const select<%= className %>Error = createSelector(
+  select<%= className %>State,
+  (state: <%= className %>State) => state.error
+);
+
+export const selectAll<%= className %> = createSelector(
+  select<%= className %>State,
+  (state: <%= className %>State) => selectAll(state)
+);
+
+export const select<%= className %>Entities = createSelector(
+  select<%= className %>State,
+  (state: <%= className %>State) => selectEntities(state)
+);
+
+export const selectSelectedId = createSelector(
+  select<%= className %>State,
+  (state: <%= className %>State) => state.selectedId
+);
+
+export const selectEntity = createSelector(
+  select<%= className %>Entities,
+  selectSelectedId,
+  (entities, selectedId) => (selectedId ? entities[selectedId] : undefined)
+);

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

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedNgRxGeneratorOptions } from './normalize-options';
+/**
+ * Add ngrx feature exports to the public barrel in the feature library
+ */
+export declare function addExportsToBarrel(tree: Tree, options: NormalizedNgRxGeneratorOptions): void;

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExportsToBarrel = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const js_1 = require("@nx/js");
+let tsModule;
+/**
+ * Add ngrx feature exports to the public barrel in the feature library
+ */
+function addExportsToBarrel(tree, options) {
+    // Don't update the public barrel for the root state, only for feature states
+    if (options.root) {
+        return;
+    }
+    const indexFilePath = (0, devkit_1.joinPathFragments)(options.parentDirectory, '..', 'index.ts');
+    if (!tree.exists(indexFilePath)) {
+        return;
+    }
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_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 statePath = `./lib/${options.directory}/${fileName}`;
+    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';`);
+    }
+}
+exports.addExportsToBarrel = addExportsToBarrel;

package/src/generators/ngrx/lib/add-imports-to-module.d.ts

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

package/src/generators/ngrx/lib/add-imports-to-module.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addImportsToModule = void 0;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+const ast_utils_1 = require("../../../utils/nx-devkit/ast-utils");
+const route_utils_1 = require("../../../utils/nx-devkit/route-utils");
+let tsModule;
+function addRootStoreImport(tree, isParentStandalone, route, sourceFile, parentPath, provideRootStore, storeForRoot) {
+    if (isParentStandalone) {
+        const parentContents = tree.read(parentPath, 'utf-8');
+        if (parentContents.includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideRootStore);
+        }
+        else if (parentContents.includes('bootstrapApplication')) {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideRootStore);
+        }
+        else {
+            (0, route_utils_1.addProviderToRoute)(tree, parentPath, route, provideRootStore);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeForRoot);
+    }
+    return sourceFile;
+}
+function addRootEffectsImport(tree, isParentStandalone, route, sourceFile, parentPath, provideRootEffects, effectsForEmptyRoot) {
+    if (isParentStandalone) {
+        const parentContents = tree.read(parentPath, 'utf-8');
+        if (parentContents.includes('ApplicationConfig')) {
+            (0, ast_utils_1.addProviderToAppConfig)(tree, parentPath, provideRootEffects);
+        }
+        else if (parentContents.includes('bootstrapApplication')) {
+            (0, ast_utils_1.addProviderToBootstrapApplication)(tree, parentPath, provideRootEffects);
+        }
+        else {
+            (0, route_utils_1.addProviderToRoute)(tree, parentPath, route, provideRootEffects);
+        }
+    }
+    else {
+        sourceFile = (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, effectsForEmptyRoot);
+    }
+    return sourceFile;
+}
+function addRouterStoreImport(tree, sourceFile, addImport, parentPath, storeRouterModule) {
+    sourceFile = addImport(sourceFile, 'StoreRouterConnectingModule', '@ngrx/router-store');
+    return (0, ast_utils_1.addImportToModule)(tree, sourceFile, parentPath, storeRouterModule);
+}
+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, ensure_typescript_1.ensureTypescript)();
+    }
+    const parentPath = options.module ?? 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}`;
+    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 storeMetaReducers = `metaReducers: []`;
+    const storeForRoot = `StoreModule.forRoot({}, {
+      ${storeMetaReducers},
+      runtimeChecks: {
+        strictActionImmutability: true,
+        strictStateImmutability: true
+      }
+    })`;
+    const effectsForRoot = `EffectsModule.forRoot([${effectsName}])`;
+    const effectsForEmptyRoot = `EffectsModule.forRoot([])`;
+    const storeForFeature = `StoreModule.forFeature(from${className}.${constantName}_FEATURE_KEY, from${className}.${propertyName}Reducer)`;
+    const effectsForFeature = `EffectsModule.forFeature([${effectsName}])`;
+    const storeRouterModule = 'StoreRouterConnectingModule.forRoot()';
+    const provideRootStore = `provideStore()`;
+    const provideRootEffects = `provideEffects()`;
+    const provideEffectsForFeature = `provideEffects(${effectsName})`;
+    const provideStoreForFeature = `provideState(from${className}.${constantName}_FEATURE_KEY, from${className}.${propertyName}Reducer)`;
+    if (isParentStandalone) {
+        sourceFile = addImport(sourceFile, 'provideStore', '@ngrx/store');
+        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');
+    }
+    // this is just a heuristic
+    const hasRouter = sourceText.indexOf('RouterModule') > -1;
+    if (options.minimal && options.root) {
+        sourceFile = addRootStoreImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideRootStore, storeForRoot);
+        sourceFile = addRootEffectsImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideRootEffects, effectsForEmptyRoot);
+        if (hasRouter && !isParentStandalone) {
+            sourceFile = addRouterStoreImport(tree, sourceFile, addImport, parentPath, storeRouterModule);
+        }
+    }
+    else {
+        const addCommonImports = () => {
+            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);
+                }
+            }
+            return sourceFile;
+        };
+        if (options.root) {
+            sourceFile = addCommonImports();
+            sourceFile = addRootStoreImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideRootStore, storeForRoot);
+            sourceFile = addRootEffectsImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideRootEffects, effectsForRoot);
+            if (hasRouter && !isParentStandalone) {
+                sourceFile = addRouterStoreImport(tree, sourceFile, addImport, parentPath, storeRouterModule);
+            }
+            sourceFile = addStoreForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideStoreForFeature, storeForFeature);
+            if (isParentStandalone) {
+                addEffectsForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideEffectsForFeature, effectsForFeature);
+            }
+        }
+        else {
+            sourceFile = addCommonImports();
+            sourceFile = addStoreForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideStoreForFeature, storeForFeature);
+            sourceFile = addEffectsForFeatureImport(tree, isParentStandalone, options.route, sourceFile, parentPath, provideEffectsForFeature, effectsForFeature);
+        }
+    }
+}
+exports.addImportsToModule = addImportsToModule;

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

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

package/src/generators/ngrx/lib/add-ngrx-to-package-json.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addNgRxToPackageJson = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const version_utils_1 = require("../../utils/version-utils");
+function addNgRxToPackageJson(tree, options) {
+    const jasmineMarblesVersion = (0, semver_1.gte)(options.rxjsVersion, '7.0.0')
+        ? '~0.9.1'
+        : '~0.8.3';
+    const ngrxVersion = (0, version_utils_1.versions)(tree).ngrxVersion;
+    process.env.npm_config_legacy_peer_deps ??= 'true';
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        '@ngrx/store': ngrxVersion,
+        '@ngrx/effects': ngrxVersion,
+        '@ngrx/entity': ngrxVersion,
+        '@ngrx/router-store': ngrxVersion,
+        '@ngrx/component-store': ngrxVersion,
+    }, {
+        '@ngrx/schematics': ngrxVersion,
+        '@ngrx/store-devtools': ngrxVersion,
+        'jasmine-marbles': jasmineMarblesVersion,
+    });
+}
+exports.addNgRxToPackageJson = addNgRxToPackageJson;

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

@@ -0,0 +1,6 @@
+import type { Tree } from '@nx/devkit';
+import { NormalizedNgRxGeneratorOptions } from './normalize-options';
+/**
+ * Generate 'feature' scaffolding: actions, reducer, effects, interfaces, selectors, facade
+ */
+export declare function generateNgrxFilesFromTemplates(tree: Tree, options: NormalizedNgRxGeneratorOptions): void;

package/src/generators/ngrx/lib/generate-files.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNgrxFilesFromTemplates = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+/**
+ * Generate 'feature' scaffolding: actions, reducer, effects, interfaces, selectors, facade
+ */
+function generateNgrxFilesFromTemplates(tree, options) {
+    const name = options.name;
+    const projectNames = (0, devkit_1.names)(name);
+    (0, devkit_1.generateFiles)(tree, (0, devkit_1.joinPathFragments)(__dirname, '..', 'files'), options.parentDirectory, {
+        ...options,
+        ...projectNames,
+        importFromOperators: (0, semver_1.lt)(options.rxjsVersion, '7.2.0'),
+        tmpl: '',
+    });
+    if (!options.facade) {
+        tree.delete((0, devkit_1.joinPathFragments)(options.parentDirectory, options.directory, `${projectNames.fileName}.facade.ts`));
+        tree.delete((0, devkit_1.joinPathFragments)(options.parentDirectory, options.directory, `${projectNames.fileName}.facade.spec.ts`));
+    }
+}
+exports.generateNgrxFilesFromTemplates = generateNgrxFilesFromTemplates;

package/src/generators/ngrx/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { addExportsToBarrel } from './add-exports-barrel';
+export { addImportsToModule } from './add-imports-to-module';
+export { addNgRxToPackageJson } from './add-ngrx-to-package-json';
+export { generateNgrxFilesFromTemplates } from './generate-files';
+export { normalizeOptions } from './normalize-options';
+export { validateOptions } from './validate-options';

package/src/generators/ngrx/lib/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = exports.normalizeOptions = exports.generateNgrxFilesFromTemplates = exports.addNgRxToPackageJson = exports.addImportsToModule = exports.addExportsToBarrel = void 0;
+var add_exports_barrel_1 = require("./add-exports-barrel");
+Object.defineProperty(exports, "addExportsToBarrel", { enumerable: true, get: function () { return add_exports_barrel_1.addExportsToBarrel; } });
+var add_imports_to_module_1 = require("./add-imports-to-module");
+Object.defineProperty(exports, "addImportsToModule", { enumerable: true, get: function () { return add_imports_to_module_1.addImportsToModule; } });
+var add_ngrx_to_package_json_1 = require("./add-ngrx-to-package-json");
+Object.defineProperty(exports, "addNgRxToPackageJson", { enumerable: true, get: function () { return add_ngrx_to_package_json_1.addNgRxToPackageJson; } });
+var generate_files_1 = require("./generate-files");
+Object.defineProperty(exports, "generateNgrxFilesFromTemplates", { enumerable: true, get: function () { return generate_files_1.generateNgrxFilesFromTemplates; } });
+var normalize_options_1 = require("./normalize-options");
+Object.defineProperty(exports, "normalizeOptions", { enumerable: true, get: function () { return normalize_options_1.normalizeOptions; } });
+var validate_options_1 = require("./validate-options");
+Object.defineProperty(exports, "validateOptions", { enumerable: true, get: function () { return validate_options_1.validateOptions; } });

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

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+import type { NgRxGeneratorOptions } from '../schema';
+export type NormalizedNgRxGeneratorOptions = NgRxGeneratorOptions & {
+    parentDirectory: string;
+    rxjsVersion: string;
+};
+export declare function normalizeOptions(tree: Tree, options: NgRxGeneratorOptions): NormalizedNgRxGeneratorOptions;

package/src/generators/ngrx/lib/normalize-options.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("@nx/devkit/src/utils/semver");
+const path_1 = require("path");
+const versions_1 = require("../../../utils/versions");
+function normalizeOptions(tree, options) {
+    let rxjsVersion;
+    try {
+        rxjsVersion = (0, semver_1.checkAndCleanWithSemver)('rxjs', (0, devkit_1.readJson)(tree, 'package.json').dependencies['rxjs']);
+    }
+    catch {
+        rxjsVersion = (0, semver_1.checkAndCleanWithSemver)('rxjs', versions_1.rxjsVersion);
+    }
+    return {
+        ...options,
+        parentDirectory: options.module
+            ? (0, path_1.dirname)(options.module)
+            : options.parent
+                ? (0, path_1.dirname)(options.parent)
+                : undefined,
+        route: options.route === '' ? `''` : options.route ?? `''`,
+        directory: (0, devkit_1.names)(options.directory).fileName,
+        rxjsVersion,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

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

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

package/src/generators/ngrx/lib/validate-options.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateOptions = void 0;
+function validateOptions(tree, options) {
+    if (!options.module && !options.parent) {
+        throw new Error('Please provide a value for "--parent"!');
+    }
+    if (options.module && !tree.exists(options.module)) {
+        throw new Error(`Module does not exist: ${options.module}.`);
+    }
+    if (options.parent && !tree.exists(options.parent)) {
+        throw new Error(`Parent does not exist: ${options.parent}.`);
+    }
+}
+exports.validateOptions = validateOptions;

package/src/generators/ngrx/ngrx.d.ts

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

package/src/generators/ngrx/ngrx.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ngrxGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const lib_1 = require("./lib");
+async function ngrxGenerator(tree, schema) {
+    (0, lib_1.validateOptions)(tree, schema);
+    const options = (0, lib_1.normalizeOptions)(tree, schema);
+    if (!options.minimal || !options.root) {
+        (0, lib_1.generateNgrxFilesFromTemplates)(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.ngrxGenerator = ngrxGenerator;
+exports.default = ngrxGenerator;

package/src/generators/ngrx/schema.d.ts

@@ -0,0 +1,14 @@
+export interface NgRxGeneratorOptions {
+  directory: string;
+  minimal: boolean;
+  module?: string;
+  parent?: string;
+  route?: string;
+  name: string;
+  barrels?: boolean;
+  facade?: boolean;
+  root?: boolean;
+  skipFormat?: boolean;
+  skipImport?: boolean;
+  skipPackageJson?: boolean;
+}

package/src/generators/ngrx/schema.json

@@ -0,0 +1,102 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNgrxGenerator",
+  "title": "Add NgRx support to an application or library.",
+  "description": "Adds NgRx support to an application or library.",
+  "x-deprecated": "This generator is deprecated and will be removed in a future version of Nx. Use the 'ngrx-root-store' and 'ngrx-feature-store' generators instead.",
+  "cli": "nx",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/angular:ngrx --root --parent=apps/my-app/src/app/app.module.ts --facade=false placeholder",
+      "description": "Add root ngrx configration to the `my-app` application"
+    },
+    {
+      "command": "nx g @nx/angular:ngrx --parent=libs/my-lib/src/lib/my-lib.module.ts --facade=true --root=false users",
+      "description": "Add a `users` state with a facade to the `my-lib` library. It will be tracked under the default `+state` folder in the lib"
+    },
+    {
+      "command": "nx g @nx/angular:ngrx --parent=apps/my-app/src/app/app.config.ts --root",
+      "description": "Add a root state configuration to `my-app` when `my-app` uses Standalone APIs"
+    },
+    {
+      "command": "nx g @nx/angular:ngrx --parent=libs/my-lib/src/lib.routes.ts users",
+      "description": "Add a `users` feature state to the Route definition of a library using Standalone APIs"
+    }
+  ],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Name of the NgRx feature state, such as `products` or `users`. Recommended to use the plural form of the name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the NgRx feature state? An example would be `users`.",
+      "x-priority": "important"
+    },
+    "module": {
+      "type": "string",
+      "description": "The path to the `NgModule` where the feature state will be registered. The host directory will create/use the new state directory.",
+      "x-deprecated": "This option will be removed in a future version of Nx. Please switch to using --parent instead."
+    },
+    "parent": {
+      "type": "string",
+      "description": "The path to the file where the state will be registered. For NgModule usage, this will be your `app.module.ts` for your root state, or your Feature Module for feature state. For Standalone API usage, this will be your `app.config.ts` file for your root state, or the Routes definition file for your feature state. The host directory will create/use the new state directory.",
+      "x-prompt": "What is the path to the module or Routes definition where this NgRx state should be registered?",
+      "x-priority": "important"
+    },
+    "route": {
+      "type": "string",
+      "description": "The route that the Standalone NgRx Providers should be added to.",
+      "default": "''"
+    },
+    "directory": {
+      "type": "string",
+      "default": "+state",
+      "description": "The name of the folder used to contain/group the generated NgRx files."
+    },
+    "root": {
+      "type": "boolean",
+      "default": false,
+      "description": "Setup root or feature state management with NgRx.",
+      "x-prompt": "Is this the root state of the application?",
+      "x-priority": "important"
+    },
+    "facade": {
+      "type": "boolean",
+      "default": false,
+      "description": "Create a Facade class for the the feature.",
+      "x-prompt": "Would you like to use a Facade with your NgRx state?"
+    },
+    "skipImport": {
+      "type": "boolean",
+      "default": false,
+      "description": "Generate NgRx feature files without registering the feature in the NgModule."
+    },
+    "minimal": {
+      "type": "boolean",
+      "default": true,
+      "description": "Only register the root state management setup or feature state."
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not update the `package.json` with NgRx dependencies.",
+      "x-priority": "internal"
+    },
+    "barrels": {
+      "type": "boolean",
+      "default": false,
+      "description": "Use barrels to re-export actions, state and selectors."
+    }
+  },
+  "additionalProperties": false,
+  "required": ["name"]
+}

package/src/generators/ngrx-feature-store/files/__directory__/__fileName__.actions.ts__tmpl__

@@ -0,0 +1,16 @@
+import { createAction, props } from '@ngrx/store';
+import { <%= className %>Entity } from './<%= relativeFileName %>.models';
+
+export const init<%= className %> = createAction(
+  '[<%= className %> Page] Init'
+);
+
+export const load<%= className %>Success = createAction(
+  '[<%= className %>/API] Load <%= className %> Success',
+  props<{ <%= propertyName %>: <%= className %>Entity[] }>()
+);
+
+export const load<%= className %>Failure = createAction(
+  '[<%= className %>/API] Load <%= className %> Failure',
+  props<{ error: any }>()
+);

package/src/generators/ngrx-feature-store/files/__directory__/__fileName__.effects.spec.ts__tmpl__

@@ -0,0 +1,37 @@
+import { TestBed } from '@angular/core/testing';
+import { provideMockActions } from '@ngrx/effects/testing';
+import { Action } from '@ngrx/store';
+import { provideMockStore } from '@ngrx/store/testing';
+import { hot } from 'jasmine-marbles';
+import { Observable } from 'rxjs';
+
+import * as <%= className %>Actions from './<%= relativeFileName %>.actions';
+import { <%= className %>Effects } from './<%= relativeFileName %>.effects';
+
+describe('<%= className %>Effects', () => {
+  let actions: Observable<Action>;
+  let effects: <%= className %>Effects;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [],
+      providers: [
+        <%= className %>Effects,
+        provideMockActions(() => actions),
+        provideMockStore()
+      ],
+    });
+
+    effects = TestBed.inject(<%= className %>Effects);
+  });
+
+  describe('init$', () => {
+    it('should work', () => {
+      actions = hot('-a-|', { a: <%= className %>Actions.init<%= className %>() });
+
+      const expected = hot('-a-|', { a: <%= className %>Actions.load<%= className %>Success({ <%= propertyName %>: [] }) });
+
+      expect(effects.init$).toBeObservable(expected);
+    });
+  });
+});