@barcidev/ngx-autogen 0.1.18 → 0.1.19

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@barcidev/ngx-autogen",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "A collection of Angular schematics for essential functionalities.",
   "main": "dist/index.js",
   "scripts": {
     "build": "tsc -p tsconfig.json",
+    "release": "npm run build && npm publish --access public",
     "test": "npm run build && jasmine src/**/*_spec.js",
     "prepublishOnly": "npm run build"
   },

package/src/transloco/files/component/__name@dasherize__.i18n.ts.template

@@ -1,4 +1,5 @@
-import { TranslationScopeConfig } from '@i18n/transloco.model';
+import { TranslationScopeConfig } from '@barcidev/typed-transloco';
+import { AppLanguageCode } from '@i18n/app.i18n.ts';
 
 const esCO = {
   title: 'Titulo'
@@ -9,7 +10,7 @@ const enUS = {
 
 const scope = '<%= name %>' as const;
 
-export const <%= name %>I18n: TranslationScopeConfig<typeof esCO, typeof scope> = {
+export const <%= name %>I18n: TranslationScopeConfig<AppLanguageCode, typeof esCO, typeof scope> = {
   scope,
   translations: {
     'en-US': enUS,

package/src/transloco/index.d.ts

@@ -1,6 +1,3 @@
 import { Rule } from "@angular-devkit/schematics";
 import { TranslocoSchemaOptions } from "./scheme";
-/**
- * Schematic principal para configurar Transloco en un componente específico
- */
-export declare function transloco(options: TranslocoSchemaOptions): Rule;
+export declare function ngAdd(options: TranslocoSchemaOptions): Rule;

package/src/transloco/index.js

@@ -9,22 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transloco = transloco;
+exports.ngAdd = ngAdd;
 const schematics_1 = require("@angular-devkit/schematics");
-const tasks_1 = require("@angular-devkit/schematics/tasks");
-const dependencies_1 = require("@schematics/angular/utility/dependencies");
-const rules_1 = require("@schematics/angular/utility/standalone/rules");
+const utility_1 = require("@schematics/angular/utility");
 const workspace_1 = require("@schematics/angular/utility/workspace");
-const path_1 = require("path");
-const file_actions_1 = require("../common/file-actions");
-const pluralize_1 = require("../common/pluralize");
-/**
- * Schematic principal para configurar Transloco en un componente específico
- */
-function transloco(options) {
+const jsonc_parser_1 = require("jsonc-parser");
+function ngAdd(options) {
     return (tree, _context) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        // --- 1. CONFIGURACIÓN INICIAL Y WORKSPACE ---
         const workspace = yield (0, workspace_1.getWorkspace)(tree);
         if (!options.project) {
             options.project =
@@ -33,134 +24,131 @@ function transloco(options) {
         }
         const project = workspace.projects.get(options.project);
         if (!project) {
-            throw new schematics_1.SchematicsException(`El proyecto "${options.project}" no existe.`);
+            _context.logger.error(`❌ El proyecto "${options.project}" no existe en el workspace.`);
+            return;
         }
-        // --- 2. DETERMINACIÓN DE RUTAS Y DETECCIÓN DE COMPONENTE ---
-        // Resolvemos el path relativo (src/app/...) basado en el directorio de ejecución
-        const fullPath = process.cwd();
-        const srcIndex = fullPath.lastIndexOf("src");
-        const relativePath = srcIndex !== -1
-            ? fullPath.substring(srcIndex)
-            : (0, path_1.join)((0, path_1.normalize)("src"), "app");
-        options.path = (0, path_1.normalize)(relativePath);
-        const directory = tree.getDir(options.path);
-        // Buscamos el archivo .ts principal del directorio
-        const componentFile = directory.subfiles.find((f) => f.endsWith(".component.ts")) ||
-            directory.subfiles.find((f) => f.endsWith(".ts"));
-        if (!componentFile && !options.name) {
-            throw new schematics_1.SchematicsException("❌ No se encontró un archivo .ts en este directorio y no se proveyó un --name.");
-        }
-        // Normalizamos el nombre (ej. mi-componente.component -> mi-componente)
-        options.name = componentFile
-            ? componentFile.replace(".component.ts", "").replace(".ts", "")
-            : options.name;
-        const rules = [];
-        // --- 3. CONFIGURACIÓN GLOBAL (IDEMPOTENTE) ---
-        const appConfigPath = "src/app/app.config.ts";
-        const appConfigContent = ((_a = tree.read(appConfigPath)) === null || _a === void 0 ? void 0 : _a.toString()) || "";
-        if (!appConfigContent.includes("provideTransloco")) {
-            _context.logger.info("📦 Transloco no detectado. Configurando globalmente...");
-            // Dependencias y tarea de instalación
-            rules.push((host) => {
-                (0, dependencies_1.addPackageJsonDependency)(host, {
-                    type: dependencies_1.NodeDependencyType.Default,
-                    name: "@jsverse/transloco",
-                    version: "^7.0.0",
-                });
-                _context.addTask(new tasks_1.NodePackageInstallTask());
-                return host;
-            });
-            // Provider global en app.config.ts
-            rules.push((0, rules_1.addRootProvider)(options.project, ({ code, external }) => code `
-          ${external("provideTransloco", "@jsverse/transloco")}({
-            config: {
-              availableLangs: ['en', 'es'],
-              defaultLang: 'en',
-              prodMode: !${external("isDevMode", "@angular/core")}(),
-              reRenderOnLangChange: true
-            },
-            loader: ${external("TranslocoHttpLoader", "@i18n/transloco-loader")}
-          })
-        `));
-        }
-        // --- 4. GENERACIÓN DE ARCHIVOS I18N DEL COMPONENTE ---
-        rules.push((0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)("./files/component"), [
-            (0, schematics_1.applyTemplates)(Object.assign(Object.assign(Object.assign({}, schematics_1.strings), options), { pluralize: (word) => options.lang === "es" ? (0, pluralize_1.pluralizeEs)(word) : (0, pluralize_1.pluralizeEn)(word) })),
-            (0, schematics_1.move)(options.path),
-        ])));
-        // --- 5. REGISTRO DEL SCOPE EN EL COMPONENTE ---
-        if (componentFile) {
-            const componentPath = (0, path_1.join)(options.path, componentFile);
-            const i18nConstantName = `${schematics_1.strings.camelize(options.name)}I18n`;
-            rules.push((0, file_actions_1.addProviderToStandaloneComponent)(componentPath, `provideTranslocoScopeWrapper(${i18nConstantName})`, [
-                {
-                    symbol: `provideTranslocoScopeWrapper`,
-                    path: `@i18n/transloco-wrapper`,
-                },
-                {
-                    symbol: i18nConstantName,
-                    path: `./${schematics_1.strings.dasherize(options.name)}.i18n`,
-                },
-            ]));
-        }
-        // --- 6. SINCRONIZACIÓN DE ARCHIVOS COMUNES Y TSCONFIG ---
-        rules.push((0, file_actions_1.mergeFilesSmart)("./files/i18n", "src/app/i18n", options, tree));
-        // Ejecutar actualización de tsconfig
-        updateTsConfig(tree);
-        return (0, schematics_1.chain)(rules);
+        const projectRoot = project.sourceRoot || "src";
+        return (0, schematics_1.chain)([
+            (0, schematics_1.externalSchematic)("@barcidev/typed-transloco", "ng-add", {}),
+            setupGlobalConfig(options.project, projectRoot),
+            createI18nFiles(projectRoot),
+            updateTsConfigRule(projectRoot),
+        ]);
     });
 }
-/**
- * Actualiza los paths en tsconfig para soportar el alias @i18n.
- * Detecta la baseUrl existente para calcular la ruta relativa correcta.
- */
-function updateTsConfig(tree) {
-    const tsConfigPath = tree.exists("/tsconfig.json")
-        ? "/tsconfig.json"
-        : "/tsconfig.app.json";
-    const buffer = tree.read(tsConfigPath);
-    if (!buffer)
-        return;
-    // Limpieza de comentarios para evitar errores en JSON.parse
-    const content = buffer
-        .toString()
-        .replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
-    try {
-        const tsconfig = JSON.parse(content);
-        // Asegurar que exista compilerOptions
-        tsconfig.compilerOptions = tsconfig.compilerOptions || {};
-        // 1. Detectar o establecer baseUrl
-        // Si no existe, la inicializamos en "./"
-        const baseUrl = tsconfig.compilerOptions.baseUrl || "./";
-        if (!tsconfig.compilerOptions.baseUrl) {
-            tsconfig.compilerOptions.baseUrl = baseUrl;
-        }
-        // 2. Calcular el path del alias basado en la baseUrl
-        // Si baseUrl es "./", el path debe ser "src/app/i18n/*"
-        // Si baseUrl es "src", el path debe ser "app/i18n/*"
-        let i18nPath = "src/app/i18n/*";
+// --- 1. CONFIGURACIÓN DEL PROVIDER ---
+function setupGlobalConfig(project, root) {
+    return (tree) => {
+        const appConfigPath = `${root}/app/app.config.ts`;
+        if (!tree.exists(appConfigPath))
+            return tree;
+        const content = tree.read(appConfigPath).toString();
+        if (content.includes("provideTransloco"))
+            return tree;
+        return (0, utility_1.addRootProvider)(project, ({ code, external }) => code `
+      ${external("provideTransloco", "@jsverse/transloco")}({
+        config: {
+          availableLangs: ['en-US', 'es-CO'],
+          defaultLang: 'en-US',
+          prodMode: !${external("isDevMode", "@angular/core")}(),
+          reRenderOnLangChange: true
+        },
+        loader: ${external("TranslocoHttpLoader", "@barcidev/typed-transloco")}
+      })
+    `);
+    };
+}
+// --- 2. CREACIÓN DE ARCHIVOS (MODO STANDALONE) ---
+function createI18nFiles(root) {
+    return (tree) => {
+        const i18nPath = `${root}/app/i18n`;
+        const files = [
+            {
+                path: `${i18nPath}/app-typed-transloco.directive.ts`,
+                content: `import { Directive } from '@angular/core';
+import { TypedTranslocoDirective, TypedViewContext } from '@barcidev/typed-transloco';
+import { AppI18nType } from './app.i18n';
+
+@Directive({
+  selector: '[typedTransloco]',
+  standalone: true,
+})
+export class AppTypedTranslocoDirective<
+  T extends keyof AppI18nType = keyof AppI18nType,
+> extends TypedTranslocoDirective<T> {
+  static override ngTemplateContextGuard<T extends keyof AppI18nType>(
+    dir: TypedTranslocoDirective<T>,
+    ctx: any,
+  ): ctx is TypedViewContext<T extends keyof AppI18nType ? AppI18nType[T] : AppI18nType> {
+    return true;
+  }
+}`,
+            },
+            {
+                path: `${i18nPath}/app-typed-transloco.pipe.ts`,
+                content: `import { Pipe } from '@angular/core';
+import { TypedTranslocoPipe } from '@barcidev/typed-transloco';
+import { AppI18nType } from './app.i18n';
+
+@Pipe({
+  name: 'typedTransloco',
+  standalone: true,
+  pure: false,
+})
+export class AppTypedTranslocoPipe extends TypedTranslocoPipe<AppI18nType> {}`,
+            },
+            {
+                path: `${i18nPath}/app.i18n.ts`,
+                content: `export const appI18n = {};
+export type AppI18nType = typeof appI18n;
+export type AppLanguageCode = 'en-US' | 'es-CO';`,
+            },
+        ];
+        files.forEach((f) => {
+            if (!tree.exists(f.path)) {
+                tree.create(f.path, f.content);
+            }
+            else {
+                tree.overwrite(f.path, f.content);
+            }
+        });
+    };
+}
+// --- 3. ACTUALIZACIÓN SEGURA DE TSCONFIG ---
+function updateTsConfigRule(root) {
+    return (tree, context) => {
+        var _a, _b;
+        const tsConfigPath = tree.exists("/tsconfig.app.json")
+            ? "/tsconfig.app.json"
+            : "/tsconfig.json";
+        const buffer = tree.read(tsConfigPath);
+        if (!buffer)
+            return;
+        const content = buffer.toString();
+        const tsconfig = (0, jsonc_parser_1.parse)(content);
+        const baseUrl = ((_a = tsconfig.compilerOptions) === null || _a === void 0 ? void 0 : _a.baseUrl) || "./";
+        let i18nPath = `${root}/app/i18n/*`;
+        // Lógica de normalización de path
         if (baseUrl !== "./" && baseUrl !== ".") {
-            // Normalizamos la baseUrl eliminando barras iniciales/finales (ej. "src/" -> "src")
             const normalizedBase = baseUrl.replace(/^\.\/|\/$/g, "");
-            // Si la baseUrl ya incluye 'src', la recortamos del path del alias
             if (i18nPath.startsWith(normalizedBase)) {
                 i18nPath = i18nPath.replace(normalizedBase, "").replace(/^\//, "");
             }
         }
-        // 3. Configurar los paths
-        tsconfig.compilerOptions.paths = tsconfig.compilerOptions.paths || {};
         const alias = "@i18n/*";
-        const pathValue = [i18nPath];
-        // Solo actualizamos si el alias no existe o el valor ha cambiado
-        if (!tsconfig.compilerOptions.paths[alias] ||
-            tsconfig.compilerOptions.paths[alias][0] !== i18nPath) {
-            tsconfig.compilerOptions.paths[alias] = pathValue;
-            tree.overwrite(tsConfigPath, JSON.stringify(tsconfig, null, 2));
-            console.log(`✅ TsConfig actualizado: @i18n -> ${i18nPath} (baseUrl: ${baseUrl})`);
+        const modificationOptions = {
+            formattingOptions: { insertSpaces: true, tabSize: 2 },
+        };
+        // Usamos jsonc-parser para modificar manteniendo comentarios
+        let edits = (0, jsonc_parser_1.modify)(content, ["compilerOptions", "paths", alias], [i18nPath], modificationOptions);
+        // Si no existe baseUrl, la añadimos para asegurar consistencia
+        if (!((_b = tsconfig.compilerOptions) === null || _b === void 0 ? void 0 : _b.baseUrl)) {
+            const baseUrlEdits = (0, jsonc_parser_1.modify)(content, ["compilerOptions", "baseUrl"], "./", modificationOptions);
+            edits = [...edits, ...baseUrlEdits];
         }
-    }
-    catch (e) {
-        console.warn(`⚠️ No se pudo procesar ${tsConfigPath}. Revisa que sea un JSON válido.`);
-    }
+        const updatedContent = (0, jsonc_parser_1.applyEdits)(content, edits);
+        tree.overwrite(tsConfigPath, updatedContent);
+        context.logger.info(`✅ Alias @i18n configurado en ${tsConfigPath}`);
+    };
 }
 //# sourceMappingURL=index.js.map

package/src/transloco/files/i18n/global.i18n.ts.template

@@ -1,19 +0,0 @@
-import { TranslationScopeConfig } from "./transloco.model";
-
-const esCO = {};
-
-const enUS: typeof esCO = {};
-
-const scope = "global" as const;
-
-export const globalI18n: TranslationScopeConfig<typeof esCO, typeof scope> = {
-  scope,
-  translations: {
-    "en-US": enUS,
-    "es-CO": esCO,
-  },
-};
-
-export const appI18n = {
-  [scope]: globalI18n.translations["es-CO"],
-};

package/src/transloco/files/i18n/transloco-loader.ts.template

@@ -1,10 +0,0 @@
-import { HttpClient } from "@angular/common/http";
-import { inject, Injectable } from "@angular/core";
-import { Translation, TranslocoLoader } from "@jsverse/transloco";
-
-@Injectable({ providedIn: "root" })
-export class TranslocoHttpLoader implements TranslocoLoader {
-  private _http = inject(HttpClient);
-
-  getTranslation = (): Promise<Translation> => Promise.resolve({});
-}

package/src/transloco/files/i18n/transloco-wrapper.ts.template

@@ -1,12 +0,0 @@
-import { provideTranslocoScope } from '@jsverse/transloco';
-
-import { TranslationScopeConfig } from './transloco.model';
-
-export const provideTranslocoScopeWrapper = (config: TranslationScopeConfig) =>
-  provideTranslocoScope({
-    alias: config.alias,
-    loader: Object.fromEntries(
-      Object.entries(config.translations).map(([lang, translation]) => [lang, () => Promise.resolve(translation)])
-    ),
-    scope: config.scope
-  });

package/src/transloco/files/i18n/transloco.model.ts.template

@@ -1,34 +0,0 @@
-import { Translation } from "@jsverse/transloco";
-
-import { appI18n } from "./global.i18n";
-
-export type AppI18nType = typeof appI18n;
-
-export type AppLanguageCode = "en-US" | "es-CO";
-
-export type ConfigTranslation<T> = Record<AppLanguageCode, T>;
-
-export type TranslationKeys = PathKeys<AppI18nType> | (string & {});
-export type TranslationPagesKeys<K extends keyof AppI18nType> =
-  | PathKeys<AppI18nType[K]>
-  | (string & {});
-
-export interface TranslationScopeConfig<T = Translation, U = string> {
-  alias?: string;
-  scope: U;
-  translations: ConfigTranslation<T>;
-}
-
-type PathKeys<T> = T extends object
-  ? {
-      [K in keyof T]: K extends number | string
-        ?
-            | `${K}`
-            | (PathKeys<T[K]> extends infer P
-                ? P extends number | string
-                  ? `${K}.${P}`
-                  : never
-                : never)
-        : never;
-    }[keyof T]
-  : never;