@barcidev/ngx-autogen 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barcidev/ngx-autogen",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "A collection of Angular schematics for essential functionalities.",
   "main": "dist/index.js",
   "scripts": {
@@ -50,7 +50,7 @@
   "dependencies": {
     "@angular-devkit/core": "^21.2.0",
     "@angular-devkit/schematics": "^21.2.0",
-    "@barcidev/typed-transloco": "^0.0.10",
+    "@barcidev/typed-transloco": "^0.0.9",
     "@schematics/angular": "^21.2.0",
     "typescript": "~5.9.2"
   },

package/src/transloco/index.js

@@ -24,30 +24,28 @@ const pluralize_1 = require("../common/pluralize");
 function transloco(options) {
     return (tree) => __awaiter(this, void 0, void 0, function* () {
         const workspace = yield (0, workspace_1.getWorkspace)(tree);
-        const { project, projectName } = getProjectConfiguration(workspace, options);
+        // 1. Obtención correcta del ROOT del proyecto
+        const projectName = options.project ||
+            workspace.extensions.defaultProject ||
+            Array.from(workspace.projects.keys())[0];
+        const project = workspace.projects.get(projectName);
+        if (!project)
+            throw new schematics_1.SchematicsException(`El proyecto "${projectName}" no existe.`);
+        // Usamos project.sourceRoot para ir a 'src' (o lo que esté configurado)
+        const projectSourceRoot = project.sourceRoot || "src";
+        // 2. Contexto del componente
         const { path, componentFile, componentName } = resolveComponentContext(tree, options);
-        // Actualizamos las opciones con los valores calculados para las siguientes reglas
-        const finalOptions = Object.assign(Object.assign({}, options), { project: projectName, path, name: componentName });
+        const finalOptions = Object.assign(Object.assign({}, options), { project: projectName, path, name: componentName, projectRoot: projectSourceRoot });
+        // 3. RETORNO DE CADENA LIMPIA
+        // El secreto es que todas las reglas sean secuenciales y no disparen procesos paralelos
         return (0, schematics_1.chain)([
-            setupGlobalConfig(),
+            setupGlobalConfig(projectName),
             generateI18nFiles(finalOptions),
-            updateAppI18nType(project.root || "src", `${schematics_1.strings.camelize(componentName)}I18n`, `${path}/${schematics_1.strings.dasherize(componentName)}.i18n`),
+            updateAppI18nTypeRule(finalOptions), // Pasamos las opciones con el root
             registerProviderInComponent(finalOptions, componentFile),
         ]);
     });
 }
-/**
- * --- FUNCIONES HELPER (PURAS O DE CONFIGURACIÓN) ---
- */
-function getProjectConfiguration(workspace, options) {
-    const projectName = options.project ||
-        workspace.extensions.defaultProject ||
-        Array.from(workspace.projects.keys())[0];
-    const project = workspace.projects.get(projectName);
-    if (!project)
-        throw new schematics_1.SchematicsException(`El proyecto "${projectName}" no existe.`);
-    return { project, projectName };
-}
 function resolveComponentContext(tree, options) {
     const fullPath = process.cwd();
     const srcIndex = fullPath.lastIndexOf("src");
@@ -66,25 +64,26 @@ function resolveComponentContext(tree, options) {
     return { path, componentFile, componentName };
 }
 /**
- * --- REGLAS (RULES) ---
+ * Ajuste en setupGlobalConfig para recibir el proyecto
  */
-function setupGlobalConfig() {
+function setupGlobalConfig(projectName) {
     return (tree, context) => {
         var _a;
-        const appConfigPath = "src/app/app.config.ts";
+        const appConfigPath = "src/app/app.config.ts"; // Opcional: podrías usar el root aquí también
         const content = ((_a = tree.read(appConfigPath)) === null || _a === void 0 ? void 0 : _a.toString()) || "";
         if (content.includes("provideTransloco"))
             return tree;
-        context.logger.info("📦 Configurando dependencias globales de Transloco...");
+        // Solo añadimos dependencias si no existen
         (0, dependencies_1.addPackageJsonDependency)(tree, {
             type: dependencies_1.NodeDependencyType.Default,
             name: "@jsverse/transloco",
-            version: "^7.0.0",
+            version: "^8.0.0",
         });
         context.addTask(new tasks_1.NodePackageInstallTask());
-        return (0, schematics_1.chain)([
-            (0, schematics_1.externalSchematic)("@barcidev/typed-transloco", "ng-add", {}),
-        ]);
+        // Devolvemos el schematic externo como parte de la cadena
+        return (0, schematics_1.externalSchematic)("@barcidev/typed-transloco", "ng-add", {
+            project: projectName,
+        });
     };
 }
 function generateI18nFiles(options) {
@@ -93,40 +92,44 @@ function generateI18nFiles(options) {
         (0, schematics_1.move)(options.path),
     ]));
 }
-function updateAppI18nType(root, name, importPath) {
+/** * Ajuste en updateAppI18nType para usar el root detectado
+ */
+function updateAppI18nTypeRule(options) {
     return (tree, context) => {
-        const path = `${root}/app/i18n/app.i18n.ts`;
+        // IMPORTANTE: Construimos la ruta usando el root detectado dinámicamente
+        const path = `${options.projectRoot}/app/i18n/app.i18n.ts`;
         const buffer = tree.read(path);
         if (!buffer) {
-            context.logger.warn(`⚠️ No se encontró el archivo ${path}`);
+            context.logger.warn(`⚠️ No se encontró el archivo ${path}. Asegúrate de que ng-add se ejecutó primero.`);
             return tree;
         }
         let content = buffer.toString();
+        const name = `${schematics_1.strings.camelize(options.name)}I18n`;
+        const importPath = `${options.path}/${schematics_1.strings.dasherize(options.name)}.i18n`;
+        // Lógica de importación
         const importStatement = `import { ${name} } from '${importPath}';\n`;
-        // 1. AGREGAR EL IMPORT (si no existe ya)
         if (!content.includes(importPath)) {
             content = importStatement + content;
         }
-        // 2. ACTUALIZAR EL OBJETO appI18n
-        const options = {
+        // Lógica de JSONC-Parser para evitar Overlapping
+        const modificationOptions = {
             formattingOptions: { insertSpaces: true, tabSize: 2 },
         };
-        // Buscamos el bloque del objeto appI18n
         const regex = /const\s+appI18n\s*=\s*(\{[\s\S]*?\});/;
         const match = content.match(regex);
         if (match) {
             const oldObjectStr = match[1];
-            /**
-             * Usamos jsonc-parser sobre el fragmento del objeto.
-             * Nota: Pasamos la variableName como referencia (string sin comillas en el valor final)
-             * Para que TS lo reconozca como la variable importada y no como un string,
-             * hacemos un pequeño truco de reemplazo después de modificar.
-             */
-            const edits = (0, jsonc_parser_1.modify)(oldObjectStr, [name], [name + ".translations[en-US]"], options);
+            // El valor que quieres inyectar: name.translations['en-US']
+            const valueToInject = `${name}.translations['en-US']`;
+            // TRUCO: Usamos un placeholder para que jsonc-parser no ponga comillas de string
+            const placeholder = `__REF__${name}`;
+            const edits = (0, jsonc_parser_1.modify)(oldObjectStr, [schematics_1.strings.camelize(options.name)], placeholder, modificationOptions);
             let newObjectStr = (0, jsonc_parser_1.applyEdits)(oldObjectStr, edits);
+            // Reemplazamos el placeholder por la referencia real de TS
+            newObjectStr = newObjectStr.replace(`"${placeholder}"`, valueToInject);
             const newContent = content.replace(oldObjectStr, newObjectStr);
             tree.overwrite(path, newContent);
-            context.logger.info(`✅ Importado ${name}"`);
+            context.logger.info(`✅ Registro de tipos actualizado en app.i18n.ts`);
         }
         return tree;
     };