@mimi-ng/cli 0.1.1 → 0.3.0

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,98 @@ 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, también un archivo igual a su base de la
+ * misma versión (`formatted`; M.11). 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 +154,92 @@ 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);
-                    }
-                    else {
+                        writeBase(file, content);
+                        break;
+                    case 'formatted':
+                        // Con --overwrite se reemplaza siempre, también con la misma versión (M.11): sin él,
+                        // un archivo distinto de la plantilla con la misma versión no se podía reponer.
+                        if (options.overwrite && !implicit.has(item)) {
+                            tree.overwrite(target, content);
+                            options.report.overwritten.push(file);
+                            writeBase(file, content);
+                        }
+                        else {
+                            options.report.unchanged.push(file);
+                        }
+                        break;
+                    case 'old':
                         tree.overwrite(target, content);
                         options.report.updated.push({ file, from });
                         writeBase(file, content);
-                    }
+                        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;
                 }
-                else if (options.overwrite) {
-                    tree.overwrite(target, content);
-                    options.report.overwritten.push(file);
-                    writeBase(file, content);
-                }
-                else {
-                    options.report.skipped.push(file);
-                }
-                // 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.3.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",