@mimi-ng/cli 0.1.1 → 0.2.0

package/dist/ui/index.js

@@ -4,6 +4,8 @@ exports.AVAILABLE = void 0;
 exports.ui = ui;
 const schematics_1 = require("@angular-devkit/schematics");
 const utility_1 = require("@schematics/angular/utility");
+const css_1 = require("../init/css");
+const items_1 = require("../init/items");
 const paths_1 = require("../init/paths");
 const registry_1 = require("../registry");
 const project_1 = require("../utils/project");
@@ -17,8 +19,10 @@ exports.AVAILABLE = Object.entries(registry_1.registry.items)
  * `ng g mimi button input form-field`: copia los componentes y sus dependencias del registro a la
  * carpeta de mimi.json. Sin nombres, pregunta (x-prompt de selección múltiple).
  *
- * Requiere init (mimi.json). Archivos existentes: igual → nada; distinto → se omite con aviso;
- * --overwrite → se reemplaza. Guarda la copia original en .mimi/base/ y la versión de cada
+ * Requiere init (mimi.json). Revisa también el tema y lo que copia init, y lo actualiza si el
+ * usuario no lo modificó. Todo o nada por componente (ver writeTemplates): si el usuario modificó
+ * un archivo de una versión anterior, ese componente y los que dependen de él no se tocan, con
+ * un aviso; --overwrite reemplaza. Guarda la copia original en .mimi/base/ y la versión de cada
  * componente en mimi.json. Instala las dependencias que falten con el gestor del proyecto.
  */
 function ui(options) {
@@ -27,13 +31,15 @@ function ui(options) {
         const report = (0, write_files_1.emptyReport)();
         return (0, schematics_1.chain)([
             (0, write_files_1.writeTemplates)({
-                files: plan.items.flatMap((item) => registry_1.registry.items[item].files),
+                items: [...plan.items, ...plan.implicit],
+                implicit: plan.implicit,
                 componentsDir: plan.componentsDir,
                 overwrite: options.overwrite ?? false,
                 version: registry_1.registry.version,
                 report,
             }),
             updateMimiConfig(plan, report),
+            updateGlobalCss(plan),
             ...Object.entries(plan.newPackages).map(([name, version]) => (0, utility_1.addDependency)(name, version, {
                 type: utility_1.DependencyType.Default,
                 existing: utility_1.ExistingBehavior.Skip,
@@ -82,11 +88,37 @@ function inspect(tree, options) {
         for (const [name, version] of Object.entries(registry_1.registry.items[item].peerDependencies ?? {})) {
             if (installed[name])
                 continue;
-            newPackages[name] = name.startsWith('@angular/') && angularRange ? angularRange : version;
+            newPackages[name] =
+                name === '@angular/aria'
+                    ? ariaVersion(tree, installed, version)
+                    : name.startsWith('@angular/') && angularRange
+                        ? angularRange
+                        : version;
         }
     }
+    // aria necesita el cdk (bidi, a11y, platform). Un ítem que solo importa aria (Tabs) no declara
+    // el cdk como peer; sin otro ítem que lo traiga, va con la misma versión que aria.
+    if (newPackages['@angular/aria'] && !installed['@angular/cdk'] && !newPackages['@angular/cdk']) {
+        newPackages['@angular/cdk'] = newPackages['@angular/aria'];
+    }
+    const implicit = [...new Set(items_1.INIT_ITEMS.flatMap((item) => (0, registry_1.resolveItems)(item)))].filter((item) => !items.includes(item));
     const componentsDir = (0, paths_1.normalizePath)(config.aliases?.components ?? 'src/app/components/ui');
-    return { componentsDir, config, items, newPackages };
+    return { componentsDir, config, items, implicit, newPackages };
+}
+/**
+ * @angular/aria pide como peer la versión exacta de @angular/cdk (22.1.7 → cdk 22.1.7). Si el cdk
+ * está instalado, aria va en esa versión (de `node_modules`, que el árbol del schematic lee del
+ * disco); si está declarado pero sin instalar, con su mismo rango; si no hay cdk, con el rango de
+ * `@angular/core`, igual que el cdk que se agrega junto con él (lo declare otro ítem o no).
+ */
+function ariaVersion(tree, installed, fallback) {
+    const cdk = tree.read('node_modules/@angular/cdk/package.json');
+    if (cdk) {
+        const { version } = JSON.parse(cdk.toString('utf-8'));
+        if (version)
+            return version;
+    }
+    return installed['@angular/cdk'] ?? installed['@angular/core'] ?? fallback;
 }
 /** El componente más parecido (distancia de edición ≤ 2, o que empiece igual). */
 function closest(name) {
@@ -115,15 +147,19 @@ function editDistance(a, b) {
 // ── mimi.json ─────────────────────────────────────────────────────────────────────────
 /**
  * Registra la versión de cada componente cuyos archivos quedaron iguales a la plantilla. Si
- * alguno se omitió por estar modificado, se conserva lo que había.
+ * alguno se omitió por estar modificado, o el componente no se escribió (bloqueado), se conserva
+ * lo que había (y uno que no se agregó no aparece).
  */
 function updateMimiConfig(plan, report) {
     return (tree) => {
         const skipped = new Set(report.skipped);
+        const blocked = new Set(report.blocked.map((b) => b.item));
         const components = { ...plan.config.components };
         for (const item of plan.items) {
             if (registry_1.registry.items[item].type !== 'component')
                 continue;
+            if (blocked.has(item))
+                continue;
             if (registry_1.registry.items[item].files.some((file) => skipped.has(file)))
                 continue;
             components[item] = { version: registry_1.registry.version };
@@ -134,6 +170,38 @@ function updateMimiConfig(plan, report) {
             tree.overwrite('mimi.json', text);
     };
 }
+// ── CSS global ────────────────────────────────────────────────────────────────────────
+/**
+ * Agrega los `cssImports` de los ítems (p. ej. `@angular/cdk/overlay-prebuilt.css`, que pide la
+ * guía del CDK) al CSS global de mimi.json, una sola vez. Van después del `@import` del tema (o
+ * del de Tailwind): los `@import` tienen que ir antes que cualquier otra regla, y así quedan
+ * junto a los de Mimi. Si no se encuentra el archivo, se explica cómo agregarlos a mano.
+ */
+function updateGlobalCss(plan) {
+    return (tree, context) => {
+        const imports = [
+            ...new Set(plan.items.flatMap((item) => registry_1.registry.items[item].cssImports ?? [])),
+        ];
+        if (imports.length === 0)
+            return;
+        const cssPath = plan.config.tailwind?.css;
+        const css = cssPath && tree.exists(cssPath) ? tree.readText(cssPath) : null;
+        const missing = imports.filter((path) => !css || !(0, css_1.hasDirective)(css, '@import', path));
+        if (missing.length === 0)
+            return;
+        const lines = missing.map((path) => `@import "${path}";`);
+        const updated = css === null ? null : (0, css_1.insertAfterTheme)(css, lines);
+        if (!cssPath || updated === null) {
+            context.logger.warn(`No se encontró el CSS global${cssPath ? ` (${cssPath})` : ''} con el @import de ` +
+                `Tailwind. Agrega a mano, después del tema de Mimi:\n${lines.map((l) => `  ${l}`).join('\n')}`);
+            return;
+        }
+        tree.overwrite(cssPath, updated);
+        context.logger.info(`Agregado a ${cssPath}:`);
+        for (const line of lines)
+            context.logger.info(`  ${line}`);
+    };
+}
 // ── Mensaje final ─────────────────────────────────────────────────────────────────────
 function summary(plan, report) {
     return (_tree, context) => {
@@ -149,13 +217,17 @@ function summary(plan, report) {
             for (const file of report.overwritten)
                 log.info(`  ~ ${path(file)}`);
         }
-        const itemOf = (file) => plan.items.find((item) => registry_1.registry.items[item].files.includes(file)) ?? file;
+        const itemOf = (file) => [...plan.items, ...plan.implicit].find((item) => registry_1.registry.items[item].files.includes(file)) ??
+            file;
         for (const message of (0, write_files_1.updatedMessages)(report, itemOf, registry_1.registry.version))
             log.info(message);
         for (const file of report.skipped) {
             log.warn(`Omitido: ${path(file)} ya existe con otro contenido (usa --overwrite para reemplazarlo).`);
         }
-        if (!(0, write_files_1.hasFileChanges)(report) && report.skipped.length === 0) {
+        for (const message of (0, write_files_1.blockedMessages)(report, plan.componentsDir, registry_1.registry.version)) {
+            log.warn(message);
+        }
+        if (!(0, write_files_1.hasFileChanges)(report) && report.skipped.length === 0 && report.blocked.length === 0) {
             log.info('Nada que hacer: los archivos ya están al día.');
         }
         const packages = Object.entries(plan.newPackages);

package/dist/ui/schema.json

@@ -39,6 +39,22 @@
             "value": "checkbox",
             "label": "checkbox"
           },
+          {
+            "value": "confirm",
+            "label": "confirm"
+          },
+          {
+            "value": "context-menu",
+            "label": "context-menu"
+          },
+          {
+            "value": "dialog",
+            "label": "dialog"
+          },
+          {
+            "value": "dropdown-menu",
+            "label": "dropdown-menu"
+          },
           {
             "value": "form-field",
             "label": "form-field"
@@ -47,6 +63,18 @@
             "value": "input",
             "label": "input"
           },
+          {
+            "value": "pagination",
+            "label": "pagination"
+          },
+          {
+            "value": "popover",
+            "label": "popover"
+          },
+          {
+            "value": "select",
+            "label": "select"
+          },
           {
             "value": "separator",
             "label": "separator"
@@ -59,9 +87,25 @@
             "value": "switch",
             "label": "switch"
           },
+          {
+            "value": "tabs",
+            "label": "tabs"
+          },
           {
             "value": "textarea",
             "label": "textarea"
+          },
+          {
+            "value": "toast",
+            "label": "toast"
+          },
+          {
+            "value": "toolbar",
+            "label": "toolbar"
+          },
+          {
+            "value": "tooltip",
+            "label": "tooltip"
           }
         ]
       }

package/dist/utils/write-files.js

@@ -4,9 +4,11 @@ exports.hasFileChanges = exports.emptyReport = exports.MANIFEST = exports.BASE_D
 exports.projectPathOf = projectPathOf;
 exports.basePathOf = basePathOf;
 exports.writeTemplates = writeTemplates;
+exports.blockedMessages = blockedMessages;
 exports.compareVersions = compareVersions;
 exports.updatedMessages = updatedMessages;
 const schematics_1 = require("@angular-devkit/schematics");
+const registry_1 = require("../registry");
 /** Carpeta de las copias originales, en la raíz del workspace. Debe quedar en git. */
 exports.BASE_DIR = '.mimi/base';
 /** Versión de Mimi con la que se escribió la base de cada archivo. */
@@ -17,6 +19,7 @@ const emptyReport = () => ({
     updated: [],
     unchanged: [],
     skipped: [],
+    blocked: [],
 });
 exports.emptyReport = emptyReport;
 /** ¿El reporte tiene cambios en archivos del proyecto? */
@@ -47,26 +50,97 @@ function readManifest(tree) {
     }
 }
 /**
- * Copia archivos de las plantillas del paquete (`dist/templates`, rutas relativas a esa
- * carpeta) a `componentsDir`, revisando el árbol antes de escribir. Si el archivo ya existe:
+ * Copia los archivos de los ítems del registro desde las plantillas del paquete
+ * (`dist/templates`) a `componentsDir`. **Todo o nada por ítem:** primero revisa cada archivo
+ * (ver `FileState`) y después decide por ítem:
  *
- * - igual a la plantilla → al día;
- * - igual a su base en `.mimi/base/` → el usuario no lo tocó. Si la base es de esta versión,
- *   la diferencia con la plantilla es solo de formato (la CLI de Angular pasa el Prettier del
- *   proyecto por lo que escriben los schematics): al día. Si es de una versión anterior, se
- *   actualiza;
- * - distinto de su base, o sin base → modificado por el usuario: se omite (o se reemplaza con
- *   `overwrite`).
+ * - si el usuario modificó alguno de sus archivos de una versión anterior, no se escribe
+ *   ninguno (ni los nuevos ni los que no tocó): mezclar versiones rompe la compilación;
+ * - lo mismo si depende (por `registryDependencies`, en cualquier nivel) de un ítem que quedó
+ *   así, esté instalado o no;
+ * - si no, se crean los que faltan y se actualizan los que el usuario no tocó. Los modificados
+ *   sobre esta versión se conservan (`skipped`).
  *
- * Nunca deja que mergeWith encuentre un archivo existente ("merge conflicted"). Guarda la base
- * y su versión en `.mimi/manifest.json` siempre que el archivo quede igual a la plantilla; si se
- * omitió por estar modificado, su base no cambia.
+ * Con `overwrite`, todo se reemplaza y nada se bloquea. Los ítems `implicit` (el tema y lo que
+ * copia init, que `ng g mimi` revisa aunque no se pidan) solo se escriben si hay que
+ * actualizarlos: un cambio del usuario sobre la versión actual se respeta en silencio, también
+ * con `overwrite`, y no bloquean a otros ítems.
+ *
+ * Nunca deja que mergeWith encuentre un archivo existente ("merge conflicted"). Guarda la base y
+ * su versión en `.mimi/manifest.json` siempre que el archivo quede igual a la plantilla; los de un
+ * ítem bloqueado o conservado no cambian su base.
  */
 function writeTemplates(options) {
-    const files = new Set(options.files);
-    return (tree) => {
+    const items = [...new Set(options.items)];
+    const implicit = new Set(options.implicit ?? []);
+    const files = new Set(items.flatMap((item) => registry_1.registry.items[item].files));
+    const contents = new Map();
+    // 1. Lee las plantillas (sin escribir nada: forEach devuelve null).
+    const read = (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('../templates'), [
+        (0, schematics_1.filter)((path) => files.has(path.replace(/^\//, ''))),
+        (0, schematics_1.forEach)((entry) => {
+            contents.set(entry.path.replace(/^\//, ''), entry.content.toString('utf8'));
+            return null;
+        }),
+    ]));
+    // 2. Decide por ítem y escribe.
+    const write = (tree) => {
         const manifest = readManifest(tree);
         let manifestChanged = false;
+        const targetOf = (file) => `${options.componentsDir}/${projectPathOf(file)}`;
+        const stateOf = (file) => {
+            const target = targetOf(file);
+            if (!tree.exists(target))
+                return { state: 'new', from: null };
+            const current = tree.readText(target);
+            if (current === contents.get(file))
+                return { state: 'same', from: null };
+            const from = manifest.files[projectPathOf(file)] ?? null;
+            const base = basePathOf(file);
+            if (tree.exists(base)) {
+                if (tree.readText(base) === current) {
+                    return { state: from === options.version ? 'formatted' : 'old', from };
+                }
+                if (from !== null && from !== options.version)
+                    return { state: 'modifiedOld', from };
+            }
+            return { state: 'modified', from };
+        };
+        const states = new Map(items.map((item) => [
+            item,
+            registry_1.registry.items[item].files
+                .filter((file) => contents.has(file))
+                .map((file) => ({ file, ...stateOf(file) })),
+        ]));
+        // Bloqueados por un cambio propio y, después, por una dependencia bloqueada.
+        const blocked = new Map();
+        if (!options.overwrite) {
+            for (const item of items) {
+                const modified = states.get(item).filter((s) => s.state === 'modifiedOld');
+                if (modified.length > 0) {
+                    blocked.set(item, {
+                        item,
+                        files: modified.map((s) => s.file),
+                        installed: true,
+                    });
+                }
+            }
+            for (const item of items) {
+                if (blocked.has(item))
+                    continue;
+                const dependency = (0, registry_1.resolveItems)(item)
+                    .filter((dep) => dep !== item)
+                    .find((dep) => blocked.has(dep) && blocked.get(dep).files.length > 0);
+                if (dependency) {
+                    blocked.set(item, {
+                        item,
+                        files: [],
+                        dependency,
+                        installed: states.get(item).some((s) => s.state !== 'new'),
+                    });
+                }
+            }
+        }
         const writeBase = (file, content) => {
             const base = basePathOf(file);
             if (!tree.exists(base))
@@ -79,60 +153,83 @@ function writeTemplates(options) {
                 manifestChanged = true;
             }
         };
-        const copy = (0, schematics_1.mergeWith)((0, schematics_1.apply)((0, schematics_1.url)('../templates'), [
-            (0, schematics_1.filter)((path) => files.has(path.replace(/^\//, ''))),
-            (0, schematics_1.forEach)((entry) => {
-                const file = entry.path.replace(/^\//, '');
-                const target = `${options.componentsDir}/${projectPathOf(file)}`;
-                const base = basePathOf(file);
-                const content = entry.content.toString('utf8');
-                if (!tree.exists(target)) {
-                    tree.create(target, content);
-                    options.report.created.push(file);
-                    writeBase(file, content);
-                    return null;
-                }
-                const current = tree.readText(target);
-                if (current === content) {
-                    options.report.unchanged.push(file);
-                    writeBase(file, content);
-                }
-                else if (tree.exists(base) && tree.readText(base) === current) {
-                    const from = manifest.files[projectPathOf(file)] ?? null;
-                    if (from === options.version) {
-                        // Mismo contenido que escribió Mimi, solo con otro formato.
+        for (const item of items) {
+            if (blocked.has(item)) {
+                options.report.blocked.push(blocked.get(item));
+                continue;
+            }
+            for (const { file, state, from } of states.get(item)) {
+                const content = contents.get(file);
+                const target = targetOf(file);
+                switch (state) {
+                    case 'new':
+                        tree.create(target, content);
+                        options.report.created.push(file);
+                        writeBase(file, content);
+                        break;
+                    case 'same':
+                        options.report.unchanged.push(file);
+                        writeBase(file, content);
+                        break;
+                    case 'formatted':
                         options.report.unchanged.push(file);
-                    }
-                    else {
+                        break;
+                    case 'old':
                         tree.overwrite(target, content);
                         options.report.updated.push({ file, from });
                         writeBase(file, content);
-                    }
-                }
-                else if (options.overwrite) {
-                    tree.overwrite(target, content);
-                    options.report.overwritten.push(file);
-                    writeBase(file, content);
-                }
-                else {
-                    options.report.skipped.push(file);
+                        break;
+                    case 'modifiedOld':
+                    case 'modified':
+                        // Un cambio sobre la versión actual de un ítem implícito se respeta siempre.
+                        if (options.overwrite && !(implicit.has(item) && state === 'modified')) {
+                            tree.overwrite(target, content);
+                            options.report.overwritten.push(file);
+                            writeBase(file, content);
+                        }
+                        else if (!implicit.has(item)) {
+                            options.report.skipped.push(file);
+                        }
+                        break;
                 }
-                // Todo se escribe arriba, en el árbol del proyecto: nada llega a mergeWith.
-                return null;
-            }),
-        ]));
-        const saveManifest = (t) => {
-            if (!manifestChanged)
-                return;
+            }
+        }
+        if (manifestChanged) {
             const sorted = Object.fromEntries(Object.entries(manifest.files).sort());
             const text = `${JSON.stringify({ files: sorted }, null, 2)}\n`;
-            if (t.exists(exports.MANIFEST))
-                t.overwrite(exports.MANIFEST, text);
+            if (tree.exists(exports.MANIFEST))
+                tree.overwrite(exports.MANIFEST, text);
             else
-                t.create(exports.MANIFEST, text);
-        };
-        return (0, schematics_1.chain)([copy, saveManifest]);
+                tree.create(exports.MANIFEST, text);
+        }
     };
+    return (0, schematics_1.chain)([read, write]);
+}
+/**
+ * Los avisos de los ítems que no se escribieron (`report.blocked`): qué no se actualizó, por qué
+ * y qué hacer. Nunca dicen «actualizado».
+ */
+function blockedMessages(report, componentsDir, version) {
+    const path = (file) => `${componentsDir}/${projectPathOf(file)}`;
+    return report.blocked.map(({ item, files, dependency, installed }) => {
+        if (dependency) {
+            const needs = `necesita ${dependency} ${version}, que no se actualizó (ver el aviso de ${dependency}).`;
+            return installed
+                ? `${item} no se actualizó a ${version}: ${needs}`
+                : `${item} no se agregó: ${needs}`;
+        }
+        const isTheme = registry_1.registry.items[item]?.type === 'theme';
+        const label = isTheme ? 'El tema' : item;
+        const dir = projectPathOf(files[0]).split('/').slice(0, -1).join('/');
+        return (`${label} no se actualizó a ${version} porque modificaste ${files.map(path).join(', ')}. ` +
+            'No se cambió ninguno de sus archivos, para no mezclar versiones.' +
+            (isTheme
+                ? ` Los componentes de la ${version} usan tokens nuevos del tema: sin ellos, algunos estilos no se generan.`
+                : '') +
+            ' Para actualizarlo: guarda tus cambios (por ejemplo, en git), vuelve a ejecutar el ' +
+            'comando con --overwrite y aplícalos de nuevo. La versión de Mimi que modificaste está en ' +
+            `${exports.BASE_DIR}/${dir}/, para comparar.`);
+    });
 }
 /** Compara versiones `x.y.z` numéricamente (`0.10.0` > `0.9.0`). `null` es la más vieja. */
 function compareVersions(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimi-ng/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Angular + Tailwind CSS 4 UI components that a CLI copies into your project, so you own the code. Schematics for ng add and ng generate.",
   "keywords": [
     "angular",