@barcidev/ngx-autogen 0.1.66 → 0.1.67

package/{src/ngrx/store/files/entity/entity.model.ts.template → dist/lib/entity/entity.model.d.ts}

@@ -1,12 +1,10 @@
 import { HttpErrorResponse } from '@angular/common/http';
 import { FormControl } from '@angular/forms';
-
 export type FormGroupType<T> = {
-  [K in keyof T]: FormControl<T[K]>;
+    [K in keyof T]: FormControl<T[K]>;
 };
-
 export interface RequestConfig<T, U = unknown> {
-  onError?: (error?: HttpErrorResponse) => void;
-  onSuccess?: (response?: U) => void;
-  payload: T;
+    onError?: (error?: HttpErrorResponse) => void;
+    onSuccess?: (response?: U) => void;
+    payload: T;
 }

package/dist/lib/entity/entity.model.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=entity.model.js.map

package/dist/lib/entity/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity.model';
+export * from './with-entity-pagination';
+export * from './with-entity-status';

package/dist/lib/entity/index.js

@@ -0,0 +1,4 @@
+export * from './entity.model';
+export * from './with-entity-pagination';
+export * from './with-entity-status';
+//# sourceMappingURL=index.js.map

package/dist/lib/entity/with-entity-pagination.d.ts

@@ -0,0 +1,34 @@
+import { Signal } from '@angular/core';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+export interface PaginationState {
+    page: number;
+    pageSize: number;
+    totalCount: number;
+}
+interface PaginationComputedProps {
+    hasNext: boolean;
+    hasPrevious: boolean;
+    totalPages: number;
+}
+/**
+ * Resetea el estado de paginación al estado inicial.
+ * @returns {PaginationState} - El estado inicial de paginación.
+ */
+export declare function resetPaginationState(): PaginationState;
+/**
+ * Agrega funcionalidades de paginación a un Store.
+ * @param {[number]} initialPageSize - Tamaño inicial de página (opcional).
+ * @returns {SignalStoreFeature} - Características de la tienda con estado, computados y métodos de paginación.
+ */
+export declare function withPagination(initialPageSize?: number): SignalStoreFeature<EmptyFeatureResult, {
+    methods: {
+        nextPage: () => void;
+        previousPage: () => void;
+        setPage: (page: number) => void;
+        setPageSize: (pageSize: number) => void;
+        setTotalCount: (totalCount: number) => void;
+    };
+    props: Record<'paginationComputed', Signal<PaginationComputedProps>>;
+    state: Record<'pagination', PaginationState>;
+}>;
+export {};

package/dist/lib/entity/with-entity-pagination.js

@@ -0,0 +1,47 @@
+import { computed } from '@angular/core';
+import { patchState, signalStoreFeature, withComputed, withMethods, withState } from '@ngrx/signals';
+const initialPaginationState = {
+    page: 1,
+    pageSize: 10,
+    totalCount: 0
+};
+/**
+ * Resetea el estado de paginación al estado inicial.
+ * @returns {PaginationState} - El estado inicial de paginación.
+ */
+export function resetPaginationState() {
+    return initialPaginationState;
+}
+/**
+ * Agrega funcionalidades de paginación a un Store.
+ * @param {[number]} initialPageSize - Tamaño inicial de página (opcional).
+ * @returns {SignalStoreFeature} - Características de la tienda con estado, computados y métodos de paginación.
+ */
+export function withPagination(initialPageSize) {
+    return signalStoreFeature(withState({
+        pagination: initialPageSize ? { ...initialPaginationState, pageSize: initialPageSize } : initialPaginationState
+    }), withComputed(({ pagination: { page, pageSize, totalCount } }) => ({
+        paginationComputed: computed(() => ({
+            hasNext: page() < Math.ceil(totalCount() / pageSize()),
+            hasPrevious: page() > 1,
+            totalPages: Math.ceil(totalCount() / pageSize())
+        }))
+    })), withMethods((store) => ({
+        nextPage: () => {
+            if (store.pagination.page() < Math.ceil(store.pagination.totalCount() / store.pagination.pageSize())) {
+                patchState(store, (state) => ({ pagination: { ...state.pagination, page: store.pagination.page() + 1 } }));
+            }
+        },
+        previousPage: () => {
+            if (store.pagination.page() > 1) {
+                patchState(store, (state) => ({ pagination: { ...state.pagination, page: store.pagination.page() - 1 } }));
+            }
+        },
+        setPage: (page) => {
+            patchState(store, (state) => ({ pagination: { ...state.pagination, page } }));
+        },
+        setPageSize: (pageSize) => patchState(store, (state) => ({ pagination: { ...state.pagination, page: 1, pageSize } })), // Reset a pág 1 si cambia el tamaño
+        setTotalCount: (totalCount) => patchState(store, (state) => ({ pagination: { ...state.pagination, totalCount } }))
+    })));
+}
+//# sourceMappingURL=with-entity-pagination.js.map

package/dist/lib/entity/with-entity-status.d.ts

@@ -0,0 +1,41 @@
+import { Signal } from '@angular/core';
+import { EntityId } from '@ngrx/signals/entities';
+import { EmptyFeatureResult, SignalStoreFeature } from '@ngrx/signals';
+export interface EntityStatus {
+    _removeLoading: boolean;
+    _updateLoading: boolean;
+    addError: Error | null;
+    addLoading: boolean;
+    error: Error | null;
+    idSelected: EntityId | null;
+    idsRemoving: EntityId[];
+    idsUpdating: EntityId[];
+    loaded: boolean;
+    loading: boolean;
+    removeError: Error | null;
+    selectedError: Error | null;
+    selectedLoading: boolean;
+    updateError: Error | null;
+}
+interface EntityStatusComputedProps {
+    anyError: Error | null;
+    isAnyActionLoading: boolean;
+    removeLoading: boolean;
+    updateLoading: boolean;
+}
+type EntityStatusMethodProps = Record<string, (...args: unknown[]) => unknown>;
+/**
+ * Resetea el estado de la entidad al estado inicial.
+ * @returns {EntityStatus} - El estado inicial de la entidad.
+ */
+export declare function resetEntityStatus(): EntityStatus;
+/**
+ * Agrega funcionalidades comunes de estado y computados para manejar el estado de entidades.
+ * @returns {SignalStoreFeature} -Características de la tienda con estado y computados para el manejo de entidades.
+ */
+export declare function withEntityStatus(): SignalStoreFeature<EmptyFeatureResult, {
+    methods: EntityStatusMethodProps;
+    props: Record<'statusComputed', Signal<EntityStatusComputedProps>>;
+    state: Record<'status', EntityStatus>;
+}>;
+export {};

package/dist/lib/entity/with-entity-status.js

@@ -0,0 +1,40 @@
+import { computed } from '@angular/core';
+import { signalStoreFeature, withComputed, withState } from '@ngrx/signals';
+const initialState = {
+    _removeLoading: false,
+    _updateLoading: false,
+    addError: null,
+    addLoading: false,
+    error: null,
+    idSelected: null,
+    idsRemoving: [],
+    idsUpdating: [],
+    loaded: false,
+    loading: false,
+    removeError: null,
+    selectedError: null,
+    selectedLoading: false,
+    updateError: null
+};
+/**
+ * Resetea el estado de la entidad al estado inicial.
+ * @returns {EntityStatus} - El estado inicial de la entidad.
+ */
+export function resetEntityStatus() {
+    return initialState;
+}
+/**
+ * Agrega funcionalidades comunes de estado y computados para manejar el estado de entidades.
+ * @returns {SignalStoreFeature} -Características de la tienda con estado y computados para el manejo de entidades.
+ */
+export function withEntityStatus() {
+    return signalStoreFeature(withState({ status: initialState }), withComputed(({ status: { _removeLoading, _updateLoading, addError, error, idsRemoving, idsUpdating, removeError, selectedError, updateError } }) => ({
+        statusComputed: computed(() => ({
+            anyError: error() || addError() || removeError() || updateError() || selectedError(),
+            isAnyActionLoading: idsUpdating().length > 0 || idsRemoving().length > 0,
+            removeLoading: _removeLoading() || idsRemoving().length > 0,
+            updateLoading: _updateLoading() || idsUpdating().length > 0
+        }))
+    })));
+}
+//# sourceMappingURL=with-entity-status.js.map

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@barcidev/ngx-autogen",
-  "version": "0.1.66",
+  "version": "0.1.67",
   "description": "A collection of Angular schematics for essential functionalities.",
   "main": "dist/index.js",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsc -p tsconfig.lib.json",
     "release": "npm run build && npm publish --access public",
     "test": "npm run build && jasmine src/**/*_spec.js",
     "prepublishOnly": "npm run build"
@@ -15,6 +15,8 @@
     "src/**/*.d.ts",
     "src/**/schema.json",
     "src/collection.json",
+    "dist/lib/**/*.js",
+    "dist/lib/**/*.d.ts",
     "README.md",
     "LICENSE"
   ],
@@ -56,9 +58,37 @@
   },
   "devDependencies": {
     "@angular-devkit/schematics-cli": "^21.2.0",
+    "@angular/forms": "^21.2.11",
+    "@ngrx/signals": "^21.1.0",
     "@types/jasmine": "~5.1.0",
     "@types/node": "^20.17.19",
     "copyfiles": "^2.4.1",
     "jasmine": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=17.0.0",
+    "@angular/core": ">=17.0.0",
+    "@angular/forms": ">=17.0.0",
+    "@ngrx/signals": ">=17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@angular/common": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@angular/forms": {
+      "optional": true
+    },
+    "@ngrx/signals": {
+      "optional": true
+    }
+  },
+  "exports": {
+    "./entity": {
+      "types": "./dist/lib/entity/index.d.ts",
+      "default": "./dist/lib/entity/index.js"
+    }
   }
 }

package/src/angular/component/files/__name@dasherize__.component.spec.ts.template

@@ -1,6 +1,6 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { <%= classify(name) %>Component } from './<%= dasherize(name) %>.component';
-<% if (store === 'Yes') { %>import { <%= classify(name) %>Store } from './state';<% } %>
+<% if (store === 'Yes') { %>import { <%= classify(storeName) %>Store } from './state';<% } %>
 
 describe('<%= classify(name) %>Component', () => {
   let component: <%= classify(name) %>Component;
@@ -10,7 +10,7 @@ describe('<%= classify(name) %>Component', () => {
     await TestBed.configureTestingModule({
       imports: [<%= classify(name) %>Component],
       providers: [
-        <% if (store === 'Yes') { %><%= classify(name) %>Store,<% } %>
+        <% if (store === 'Yes') { %><%= classify(storeName) %>Store,<% } %>
       ]
     }).compileComponents();
 

package/src/angular/component/files/__name@dasherize__.component.ts.template

@@ -1,17 +1,17 @@
 import { Component, inject } from '@angular/core';
 <% if (store === 'Yes') { %>
-import { <%= classify(name) %>Store } from './state';
+import { <%= classify(storeName) %>Store<% if (!isProvideInRoot) { %>, provide<%= classify(storeName) %>Store<% } %> } from './state';
 import { JsonPipe } from '@angular/common';
 <% } %>
 
 @Component({
   imports: [<% if (store === 'Yes') { %>JsonPipe<% } %>],
-  providers: [],
+  providers: [<% if (store === 'Yes' && !isProvideInRoot) { %>...provide<%= classify(storeName) %>Store()<% } %>],
   selector: 'app-<%= dasherize(name) %>',
   styleUrls: ['./<%= dasherize(name) %>.component.css'],
   templateUrl: './<%= dasherize(name) %>.component.html',
 })
 export class <%= classify(name) %>Component {
-<% if (store === 'Yes') { %>  private _<%= camelize(name) %>Store = inject(<%= classify(name) %>Store);
-  data$ = this._<%= camelize(name) %>Store.entities();<% } %>
+<% if (store === 'Yes') { %>  private _<%= camelize(storeName) %>Store = inject(<%= classify(storeName) %>Store);
+  data$ = this._<%= camelize(storeName) %>Store.entities();<% } %>
 }

package/src/angular/component/index.js

@@ -14,12 +14,22 @@ const schematics_1 = require("@angular-devkit/schematics");
 const workspace_1 = require("@schematics/angular/utility/workspace");
 const path_1 = require("path");
 const pluralize_1 = require("../../common/pluralize");
+const prompts_1 = require("../../common/prompts");
 function component(options) {
     return (tree) => __awaiter(this, void 0, void 0, function* () {
         const workspace = yield (0, workspace_1.getWorkspace)(tree);
-        // 1. Preparar contexto y opciones enriquecidas
+        if (options.store === "Yes") {
+            if (!options.storeName) {
+                options.storeName = yield (0, prompts_1.askInput)("What is the name of the entity store to create?", options.name);
+            }
+            if (!options.pk) {
+                options.pk = yield (0, prompts_1.askInput)("What is the name of the default Primary Key (e.g., id, cod, uuid)?", "id");
+            }
+            if (options.isProvideInRoot === undefined) {
+                options.isProvideInRoot = yield (0, prompts_1.askConfirm)("Should the store and service be provided in root?", false);
+            }
+        }
         const context = resolveComponentContext(workspace, options);
-        // Aquí podrías agregar más reglas para otras funcionalidades, como NgRx
         return (0, schematics_1.chain)([
             generateComponentFiles(context),
             options.i18n === "Yes"
@@ -30,8 +40,10 @@ function component(options) {
                 : (0, schematics_1.noop)(),
             options.store === "Yes"
                 ? (0, schematics_1.schematic)("app-store", {
-                    name: context.options.name,
+                    name: options.storeName || context.options.name,
                     path: (0, path_1.join)(context.movePath, context.nameDash),
+                    pk: context.options.pk,
+                    isProvideInRoot: context.options.isProvideInRoot,
                 })
                 : (0, schematics_1.noop)(),
         ]);

package/src/angular/component/schema.json

@@ -22,6 +22,16 @@
       "x-prompt": "Do you want to create an i18n file for the component?",
       "enum": ["Yes", "No"]
     },
+    "pk": {
+      "type": "string",
+      "description": "The name of the default Primary Key (e.g., id, cod, uuid); default is 'id'.",
+      "default": "id"
+    },
+    "isProvideInRoot": {
+      "type": "boolean",
+      "description": "Whether the store and service should be provided in root.",
+      "default": false
+    },
     "path": {
       "type": "string",
       "description": "Destination path."

package/src/angular/component/types/types.d.ts

@@ -9,7 +9,10 @@ export interface ComponentSchemaOptions {
     name: string;
     project?: string;
     store: "Yes" | "No";
+    storeName?: string;
     i18n: "Yes" | "No";
+    pk?: string;
+    isProvideInRoot?: boolean;
     path?: string;
     lang?: "en" | "es";
 }

package/src/common/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function askInput(question: string, defaultValue?: string): Promise<string>;
+export declare function askConfirm(question: string, defaultValue?: boolean): Promise<boolean>;

package/src/common/prompts.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.askInput = askInput;
+exports.askConfirm = askConfirm;
+const readline = require("readline");
+function askInput(question, defaultValue) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const suffix = defaultValue ? ` (${defaultValue})` : "";
+    return new Promise((resolve) => {
+        rl.question(`${question}${suffix}: `, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultValue || "");
+        });
+    });
+}
+function askConfirm(question, defaultValue = false) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const hint = defaultValue ? "(Y/n)" : "(y/N)";
+    return new Promise((resolve) => {
+        rl.question(`${question} ${hint}: `, (answer) => {
+            rl.close();
+            const normalized = answer.trim().toLowerCase();
+            if (normalized === "")
+                return resolve(defaultValue);
+            resolve(normalized === "y" || normalized === "yes");
+        });
+    });
+}
+//# sourceMappingURL=prompts.js.map

package/src/ngrx/store/files/state/models/__name@dasherize__.model.ts.template

@@ -1,4 +1,4 @@
-import { FormGroupType } from '@shared-state/entity.model';
+import { FormGroupType } from '@barcidev/ngx-autogen/entity';
 
 export interface Add<%= classify(name) %> {
 }

package/src/ngrx/store/files/state/services/__name@dasherize__.service.ts.template

@@ -6,9 +6,7 @@ import {
   Update<%= classify(name) %>
 } from '<%= grouped ? "../models/" + dasherize(name) + ".model" : "./" + dasherize(name) + ".model" %>';
 
-@Injectable({
-  providedIn: 'root'
-})
+@Injectable(<%= isProvideInRoot ? "{ providedIn: 'root' }" : "" %>)
 export class <%= classify(name) %>Service {
 
   add<%= classify(name) %>$(payload: Add<%= classify(name) %>): Observable<number> {

package/src/ngrx/store/files/state/store/__name@dasherize__.store.ts.template

@@ -10,10 +10,9 @@ import {
 } from '@ngrx/signals/entities';
 import { rxMethod } from '@ngrx/signals/rxjs-interop';
 import { catchError, EMPTY, pipe, switchMap, tap } from 'rxjs';
+import { EntityId } from '@ngrx/signals/entities';
 
-import { RequestConfig } from '@shared-state/entity.model';
-import { withPagination } from '@shared-state/with-entity-pagination';
-import { withEntityStatus } from '@shared-state/with-entity-status';
+import { RequestConfig, withEntityStatus, withPagination } from '@barcidev/ngx-autogen/entity';
 import {
   Add<%= classify(name) %>,
   <%= classify(name) %>Dto,
@@ -27,12 +26,11 @@ const config = entityConfig({
 });
 
 export const <%= classify(name) %>Store = signalStore(
-  { providedIn: 'root' },
+  <%= isProvideInRoot ? "{ providedIn: 'root' }," : "" %>
   withEntities(config),
   withEntityStatus(),
   withPagination(),
   withComputed(({ entities, entityMap, status: { idSelected } }) => ({
-    <%= camelize(pluralize(name)) %>: computed(() => entities()),
     <%= camelize(name) %>Seleccionado: computed(() => {
       const <%= pk %> = idSelected();
       return <%= pk %> ? entityMap()[<%= pk %>] : null;
@@ -142,6 +140,18 @@ export const <%= classify(name) %>Store = signalStore(
         })
       )
     ),
+    select<%= classify(name) %>: rxMethod<EntityId | null>(
+      pipe(
+        tap((payload) => {
+          patchState(store, (state) => ({
+            status: {
+              ...state.status,
+              idSelected: payload
+            }
+          }));
+        })
+      )
+    ),
     update<%= classify(name) %>: rxMethod<RequestConfig<Update<%= classify(name) %>, boolean>>(
       pipe(
         tap(({ payload }) => {
@@ -198,4 +208,11 @@ export const <%= classify(name) %>Store = signalStore(
       store.load<%= classify(pluralize(name)) %>();
     },
   })
-);
+);
+
+export function provide<%= classify(name) %>Store() {
+  return <%= isProvideInRoot ?  [
+      <%= classify(name) %>Service,
+      <%= classify(name) %>Store,
+    ] : [ <%= classify(name) %>Store ]
+}

package/src/ngrx/store/index.js

@@ -16,12 +16,13 @@ const tasks_1 = require("@angular-devkit/schematics/tasks");
 const dependencies_1 = require("@schematics/angular/utility/dependencies");
 const workspace_1 = require("@schematics/angular/utility/workspace");
 const jsonc_parser_1 = require("jsonc-parser");
-const file_actions_1 = require("../../common/file-actions");
 const pluralize_1 = require("../../common/pluralize");
 const project_metadata_1 = require("../../common/project-metadata");
 const NGRX_SIGNALS = "@ngrx/signals";
+let _needsInstall = false;
 function signalStore(options) {
     return (tree) => __awaiter(this, void 0, void 0, function* () {
+        _needsInstall = false;
         const workspace = yield (0, workspace_1.getWorkspace)(tree);
         // 1. Preparar contexto y opciones enriquecidas
         const context = resolveStoreContext(workspace, options);
@@ -35,12 +36,14 @@ function signalStore(options) {
             ensureNgrxSignals(angularVersion),
             updateIndexFile(context),
             generateStoreFiles(context),
-            (0, file_actions_1.mergeFilesSmart)("./files/entity", "src/app/shared/state", context.options, tree),
             updateAngularJson(context.options),
             updateTsConfigRule(projectRoot),
-            (host, context) => {
-                context.addTask(new tasks_1.NodePackageInstallTask());
-                context.logger.info("🚀 Entorno preparado con éxito.");
+            (host, ctx) => {
+                if (_needsInstall) {
+                    ctx.addTask(new tasks_1.NodePackageInstallTask());
+                    ctx.logger.info("📦 Instalando dependencias...");
+                }
+                ctx.logger.info("🚀 Entorno preparado con éxito.");
                 return host;
             },
         ]);
@@ -85,20 +88,16 @@ function resolveStoreContext(workspace, options) {
  */
 function ensureNgrxSignals(version) {
     return (tree) => {
-        // 1. Intentamos obtener la dependencia si ya existe
         const existingDep = (0, dependencies_1.getPackageJsonDependency)(tree, NGRX_SIGNALS);
-        // 2. Si existe, simplemente retornamos el árbol sin hacer nada
-        if (existingDep) {
-            // Opcional: podrías loguear un mensaje aquí
+        if (existingDep)
             return tree;
-        }
-        // 3. Si no existe, la añadimos
         (0, dependencies_1.addPackageJsonDependency)(tree, {
             type: dependencies_1.NodeDependencyType.Default,
             name: NGRX_SIGNALS,
             version: `^${version}.0.0`,
             overwrite: false,
         });
+        _needsInstall = true;
         return tree;
     };
 }
@@ -147,7 +146,7 @@ function generateStoreFiles(ctx) {
 }
 function updateTsConfigRule(root) {
     return (tree, context) => {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         const tsConfigPath = tree.exists("/tsconfig.app.json")
             ? "/tsconfig.app.json"
             : "/tsconfig.json";
@@ -155,21 +154,28 @@ function updateTsConfigRule(root) {
         if (!buffer)
             return;
         let content = buffer.toString();
-        const modOptions = {
-            formattingOptions: { insertSpaces: true, tabSize: 2 },
-        };
-        // 1. Asegurar baseUrl
-        if (!((_a = (0, jsonc_parser_1.parse)(content).compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl)) {
-            content = (0, jsonc_parser_1.applyEdits)(content, (0, jsonc_parser_1.modify)(content, ["compilerOptions", "baseUrl"], "./", modOptions));
-        }
-        // 2. Calcular path relativo al baseUrl
-        const baseUrl = ((_b = (0, jsonc_parser_1.parse)(content).compilerOptions) === null || _b === void 0 ? void 0 : _b.baseUrl) || "./";
+        const parsed = (0, jsonc_parser_1.parse)(content);
+        // Calcular el path esperado del alias
+        const baseUrl = ((_a = parsed.compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl) || "./";
         let i18nPath = `${root}/app/shared/state/*`;
         const normalizedBase = baseUrl.replace(/^\.\/|\/$/g, "");
         if (normalizedBase && i18nPath.startsWith(normalizedBase)) {
             i18nPath = i18nPath.replace(normalizedBase, "").replace(/^\//, "");
         }
-        // 3. Aplicar alias
+        // Verificar si ya tiene baseUrl y el alias correcto
+        const existingPaths = (_c = (_b = parsed.compilerOptions) === null || _b === void 0 ? void 0 : _b.paths) === null || _c === void 0 ? void 0 : _c["@shared-state/*"];
+        const alreadyConfigured = ((_d = parsed.compilerOptions) === null || _d === void 0 ? void 0 : _d.baseUrl) &&
+            Array.isArray(existingPaths) &&
+            existingPaths.length === 1 &&
+            existingPaths[0] === i18nPath;
+        if (alreadyConfigured)
+            return;
+        const modOptions = {
+            formattingOptions: { insertSpaces: true, tabSize: 2 },
+        };
+        if (!((_e = parsed.compilerOptions) === null || _e === void 0 ? void 0 : _e.baseUrl)) {
+            content = (0, jsonc_parser_1.applyEdits)(content, (0, jsonc_parser_1.modify)(content, ["compilerOptions", "baseUrl"], "./", modOptions));
+        }
         const finalContent = (0, jsonc_parser_1.applyEdits)(content, (0, jsonc_parser_1.modify)(content, ["compilerOptions", "paths", "@shared-state/*"], [i18nPath], modOptions));
         tree.overwrite(tsConfigPath, finalContent);
         context.logger.info(`✅ Alias @shared-state configurado.`);
@@ -177,11 +183,15 @@ function updateTsConfigRule(root) {
 }
 function updateAngularJson(options) {
     return (tree) => {
+        var _a;
         const path = "/angular.json";
         const buffer = tree.read(path);
         if (!buffer)
             return;
         const workspace = JSON.parse(buffer.toString());
+        const existing = (_a = workspace.schematics) === null || _a === void 0 ? void 0 : _a["@barcidev/ngx-autogen:signal-state"];
+        if ((existing === null || existing === void 0 ? void 0 : existing.pk) === options.pk && (existing === null || existing === void 0 ? void 0 : existing.lang) === options.lang)
+            return;
         if (!workspace.schematics)
             workspace.schematics = {};
         workspace.schematics["@barcidev/ngx-autogen:signal-state"] = {

package/src/ngrx/store/schema.json

@@ -28,6 +28,19 @@
     "lang":{
       "type": "string",
       "description": "The default language for the application (en, es); default is 'en'."
+    },
+    "isProvideInRoot": {
+      "type": "boolean",
+      "description": "Whether the store and service should be provided in root.",
+      "default": false,
+      "x-prompt": {
+        "message": "Should the store and service be provided in root?",
+        "type": "list",
+        "items": [
+          { "value": true, "label": "Yes" },
+          { "value": false, "label": "No" }
+        ]
+      }
     }
   },
   "required": ["name"]

package/src/ngrx/store/types/types.d.ts

@@ -5,4 +5,5 @@ export interface StoreSchemaOptions {
     grouped: boolean;
     pk?: string;
     lang: "en" | "es";
+    isProvideInRoot: boolean;
 }

package/src/ngrx/store/files/entity/with-entity-pagination.ts.template

@@ -1,89 +0,0 @@
-import { computed, Signal } from '@angular/core';
-import {
-  EmptyFeatureResult,
-  patchState,
-  SignalStoreFeature,
-  signalStoreFeature,
-  withComputed,
-  withMethods,
-  withState
-} from '@ngrx/signals';
-
-export interface PaginationState {
-  page: number;
-  pageSize: number;
-  totalCount: number;
-}
-
-interface PaginationComputedProps {
-  hasNext: boolean;
-  hasPrevious: boolean;
-  totalPages: number;
-}
-
-const initialPaginationState: PaginationState = {
-  page: 1,
-  pageSize: 10,
-  totalCount: 0
-};
-
-/**
- * Resetea el estado de paginación al estado inicial.
- * @returns {PaginationState} - El estado inicial de paginación.
- */
-export function resetPaginationState(): PaginationState {
-  return initialPaginationState;
-}
-
-/**
- * Agrega funcionalidades de paginación a un Store.
- * @param {[number]} initialPageSize - Tamaño inicial de página (opcional).
- * @returns {SignalStoreFeature} - Características de la tienda con estado, computados y métodos de paginación.
- */
-export function withPagination(initialPageSize?: number): SignalStoreFeature<
-  EmptyFeatureResult,
-  {
-    methods: {
-      nextPage: () => void;
-      previousPage: () => void;
-      setPage: (page: number) => void;
-      setPageSize: (pageSize: number) => void;
-      setTotalCount: (totalCount: number) => void;
-    };
-    props: Record<'paginationComputed', Signal<PaginationComputedProps>>;
-    state: Record<'pagination', PaginationState>;
-  }
-> {
-  return signalStoreFeature(
-    withState({
-      pagination: initialPageSize ? { ...initialPaginationState, pageSize: initialPageSize } : initialPaginationState
-    }),
-
-    withComputed(({ pagination: { page, pageSize, totalCount } }) => ({
-      paginationComputed: computed(() => ({
-        hasNext: page() < Math.ceil(totalCount() / pageSize()),
-        hasPrevious: page() > 1,
-        totalPages: Math.ceil(totalCount() / pageSize())
-      }))
-    })),
-    withMethods((store) => ({
-      nextPage: () => {
-        if (store.pagination.page() < Math.ceil(store.pagination.totalCount() / store.pagination.pageSize())) {
-          patchState(store, (state) => ({ pagination: { ...state.pagination, page: store.pagination.page() + 1 } }));
-        }
-      },
-      previousPage: () => {
-        if (store.pagination.page() > 1) {
-          patchState(store, (state) => ({ pagination: { ...state.pagination, page: store.pagination.page() - 1 } }));
-        }
-      },
-      setPage: (page: number) => {
-        patchState(store, (state) => ({ pagination: { ...state.pagination, page } }));
-      },
-      setPageSize: (pageSize: number) =>
-        patchState(store, (state) => ({ pagination: { ...state.pagination, page: 1, pageSize } })), // Reset a pág 1 si cambia el tamaño
-      setTotalCount: (totalCount: number) =>
-        patchState(store, (state) => ({ pagination: { ...state.pagination, totalCount } }))
-    }))
-  );
-}

package/src/ngrx/store/files/entity/with-entity-status.ts.template

@@ -1,92 +0,0 @@
-import { computed, Signal } from '@angular/core';
-import { EmptyFeatureResult, SignalStoreFeature, signalStoreFeature, withComputed, withState } from '@ngrx/signals';
-
-export interface EntityStatus {
-  _removeLoading: boolean;
-  _updateLoading: boolean;
-  addError: Error | null;
-  addLoading: boolean;
-  error: Error | null;
-  idSelected: null | number | string;
-  idsRemoving: (number | string)[];
-  idsUpdating: (number | string)[];
-  loaded: boolean;
-  loading: boolean;
-  removeError: Error | null;
-  selectedError: Error | null;
-  selectedLoading: boolean;
-  updateError: Error | null;
-}
-
-interface EntityStatusComputedProps {
-  anyError: Error | null;
-  isAnyActionLoading: boolean;
-  removeLoading: boolean;
-  updateLoading: boolean;
-}
-
-type EntityStatusMethodProps = Record<string, (...args: unknown[]) => unknown>;
-
-const initialState: EntityStatus = {
-  _removeLoading: false,
-  _updateLoading: false,
-  addError: null,
-  addLoading: false,
-  error: null,
-  idSelected: null,
-  idsRemoving: [],
-  idsUpdating: [],
-  loaded: false,
-  loading: false,
-  removeError: null,
-  selectedError: null,
-  selectedLoading: false,
-  updateError: null
-};
-
-/**
- * Resetea el estado de la entidad al estado inicial.
- * @returns {EntityStatus} - El estado inicial de la entidad.
- */
-export function resetEntityStatus(): EntityStatus {
-  return initialState;
-}
-
-/**
- * Agrega funcionalidades comunes de estado y computados para manejar el estado de entidades.
- * @returns {SignalStoreFeature} -Características de la tienda con estado y computados para el manejo de entidades.
- */
-export function withEntityStatus(): SignalStoreFeature<
-  EmptyFeatureResult,
-  {
-    methods: EntityStatusMethodProps;
-    props: Record<'statusComputed', Signal<EntityStatusComputedProps>>;
-    state: Record<'status', EntityStatus>;
-  }
-> {
-  return signalStoreFeature(
-    withState({ status: initialState }),
-    withComputed(
-      ({
-        status: {
-          _removeLoading,
-          _updateLoading,
-          addError,
-          error,
-          idsRemoving,
-          idsUpdating,
-          removeError,
-          selectedError,
-          updateError
-        }
-      }) => ({
-        statusComputed: computed(() => ({
-          anyError: error() || addError() || removeError() || updateError() || selectedError(),
-          isAnyActionLoading: idsUpdating().length > 0 || idsRemoving().length > 0,
-          removeLoading: _removeLoading() || idsRemoving().length > 0,
-          updateLoading: _updateLoading() || idsUpdating().length > 0
-        }))
-      })
-    )
-  );
-}