@mimi-ng/cli 0.4.0 → 0.5.0

package/dist/templates/theme/provider.ts

@@ -101,6 +101,10 @@ const COMPONENT_PREFIX: Record<keyof MimiComponentTokens, string> = {
   date: 'date',
   fileUpload: 'upload',
   colorPicker: 'color-picker',
+  tree: 'tree',
+  sortable: 'sortable',
+  command: 'command',
+  dataTable: 'table',
 };
 
 /** Nombres de la 0.1.0 que siguen funcionando hasta la 1.0 (spec 12): ruta → qué usar. */

package/dist/templates/theme/types.ts

@@ -555,6 +555,86 @@ export interface MimiColorPickerTokens {
   swatchGap?: string;
 }
 
+/**
+ * Tree. Fondo, hover y el nodo elegido van en el CSS (`--mimi-tree-bg`, `-hover`, `-selected`,
+ * `-selected-fg`).
+ */
+export interface MimiTreeTokens {
+  /** Relleno del contenedor (6px). */
+  padding?: string;
+  /** Alto de cada nodo (32px). */
+  rowHeight?: string;
+  /** Radio del nodo (el global `radius-sm`). */
+  rowRadius?: string;
+  /** Sangría por nivel (18px). */
+  indent?: string;
+  /** Tamaño de texto (13.5px). */
+  fontSize?: string;
+}
+
+/**
+ * Sortable List. Fondo, el hover del asa y los colores del hueco van en el CSS
+ * (`--mimi-sortable-bg`, `-handle-hover`, `-drop`, `-drop-bg`).
+ */
+export interface MimiSortableTokens {
+  /** Alto mínimo de cada elemento (56px). */
+  itemHeight?: string;
+  /** Separación entre elementos (8px). */
+  gap?: string;
+  /** Radio del elemento y del hueco (el global `radius`). */
+  radius?: string;
+  /** Giro y escala del elemento levantado (`rotate(-1.5deg) scale(1.03)`). */
+  lift?: string;
+  /** Curva del reacomodo (`cubic-bezier(.2, .8, .2, 1)`). */
+  easing?: string;
+}
+
+/**
+ * Command. El fondo del comando activo va en el CSS (`--mimi-command-active`).
+ */
+export interface MimiCommandTokens {
+  /** Ancho del panel en el diálogo (560px). */
+  width?: string;
+  /** Distancia del panel al borde superior en el diálogo (36px). */
+  top?: string;
+  /** Alto de la fila del buscador (52px). */
+  inputHeight?: string;
+  /** Tamaño del texto del buscador (15px). */
+  inputFontSize?: string;
+  /** Alto máximo de la lista (332px). */
+  listHeight?: string;
+  /** Alto de cada comando (40px). */
+  itemHeight?: string;
+  /** Radio del comando (el global `radius-sm`). */
+  itemRadius?: string;
+  /** Caja del ícono del comando (26px). */
+  iconSize?: string;
+}
+
+/**
+ * Data Table. Los fondos (tabla, encabezado, hover, elegida, detalle) y la sombra de la columna
+ * fija van en el CSS (`--mimi-table-bg`, `-head-bg`, `-row-hover`, `-row-selected`,
+ * `-expanded-bg`, `-sticky-shadow`).
+ */
+export interface MimiTableTokens {
+  /** Alto de fila en la densidad compacta (42px). */
+  rowHeight?: string;
+  /** Alto de fila en la densidad cómoda (60px). */
+  rowHeightComfortable?: string;
+  /** Alto del encabezado, compacta (38px). */
+  headHeight?: string;
+  /** Alto del encabezado, cómoda (44px). */
+  headHeightComfortable?: string;
+  /** Texto de las celdas, compacta (13px). */
+  fontSize?: string;
+  /** Texto de las celdas, cómoda (14px). */
+  fontSizeComfortable?: string;
+  /** Relleno horizontal de la celda (10px). */
+  cellPx?: string;
+  /** Alto mínimo de la barra (56px). */
+  toolbarHeight?: string;
+}
+
 /**
  * Tokens por componente (spec 13). Solo los que no dependen del modo: los colores de los
  * componentes (`--mimi-<prefijo>-bg`, `-fg`, `-border`…) se cambian en el CSS (spec 6.2).
@@ -594,6 +674,10 @@ export interface MimiComponentTokens {
   date?: MimiDateTokens;
   fileUpload?: MimiFileUploadTokens;
   colorPicker?: MimiColorPickerTokens;
+  tree?: MimiTreeTokens;
+  sortable?: MimiSortableTokens;
+  command?: MimiCommandTokens;
+  dataTable?: MimiTableTokens;
 }
 
 export interface MimiThemePreset {

package/dist/ui/index.js

@@ -8,6 +8,7 @@ const css_1 = require("../init/css");
 const items_1 = require("../init/items");
 const paths_1 = require("../init/paths");
 const registry_1 = require("../registry");
+const pages_1 = require("../utils/pages");
 const project_1 = require("../utils/project");
 const tailwind_1 = require("../utils/tailwind");
 const write_files_1 = require("../utils/write-files");
@@ -40,13 +41,14 @@ function ui(options) {
                 implicit: plan.implicit,
                 componentsDir: plan.componentsDir,
                 blocksDir: plan.blocksDir,
+                pages: plan.pages,
                 overwrite: options.overwrite ?? false,
                 version: registry_1.registry.version,
                 report,
             }),
             updateMimiConfig(plan, report),
             updateGlobalCss(plan),
-            addBlocksSource(plan),
+            addFolderSources(plan),
             ...Object.entries(plan.newPackages).map(([name, version]) => (0, utility_1.addDependency)(name, version, {
                 type: utility_1.DependencyType.Default,
                 existing: utility_1.ExistingBehavior.Skip,
@@ -112,12 +114,17 @@ function inspect(tree, options) {
     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');
     const blocksDir = (0, paths_1.normalizePath)(config.aliases?.blocks ?? (0, project_1.defaultBlocksDir)(componentsDir));
+    const pagesDir = (0, paths_1.normalizePath)(config.aliases?.pages ?? (0, project_1.defaultPagesDir)(componentsDir));
+    const { pages, legacyPages } = planPages(tree, config, items, options.name, blocksDir, pagesDir);
     const outdated = outdatedPeers(tree, items, installed, newPackages);
     const updatable = PEERS_WITH_MINIMUM.filter((name) => installed[name] || newPackages[name]);
     const missingExclusion = mimiExclusion(tree, config, installed);
     return {
         componentsDir,
         blocksDir,
+        pagesDir,
+        pages,
+        legacyPages,
         config,
         items,
         implicit,
@@ -127,6 +134,134 @@ function inspect(tree, options) {
         missingExclusion,
     };
 }
+// ── Páginas (B.11) ────────────────────────────────────────────────────────────────────
+/**
+ * Dónde va cada Block de tipo `page` de esta ejecución. Todo se comprueba antes de escribir: si
+ * algo no cuadra (un `--name` inválido, una carpeta que ya existe y no es esa página, dos páginas
+ * en la misma carpeta), falla sin cambiar nada.
+ *
+ * - Ya generada (`mimi.json → blocks.<ítem>.path`): se actualiza ahí, con su nombre (B.11-f).
+ * - Instalada con la 0.4.0 (`<aliases.blocks>/<ítem>/<ítem>.ts`, sin `path`): se queda donde está
+ *   y se actualiza como antes (B.11-g).
+ * - Nueva: `<aliases.pages>/<nombre>/`, con `--name` o el nombre por defecto (B.11-c).
+ */
+function planPages(tree, config, items, name, blocksDir, pagesDir) {
+    const pageItems = items.filter((item) => (0, registry_1.isPageBlock)(item));
+    if (name !== undefined) {
+        if (!pages_1.PAGE_NAME.test(name)) {
+            throw new schematics_1.SchematicsException(`--name ${JSON.stringify(name)} no sirve como nombre de página: usa minúsculas, números y ` +
+                'guiones, empezando con una letra (por ejemplo, --name admin-login). No se cambió nada.');
+        }
+        if (pageItems.length !== 1) {
+            const pageNames = exports.AVAILABLE.filter((item) => (0, registry_1.isPageBlock)(item)).join(', ');
+            throw new schematics_1.SchematicsException((pageItems.length === 0
+                ? '--name es el nombre de la página que se genera, y no pediste ningún Block de tipo página'
+                : `--name sirve para una sola página, y pediste ${pageItems.join(', ')}: agrégalas por separado`) +
+                ` (son páginas: ${pageNames}). No se cambió nada.`);
+        }
+        if ((0, pages_1.isBlockLikeName)(pageItems[0], name)) {
+            throw new schematics_1.SchematicsException(`--name ${name} lleva el nombre del Block (${pageItems[0]}): elige el de tu página, por ` +
+                `ejemplo --name ${(0, pages_1.defaultPageName)(pageItems[0])} o --name admin-` +
+                `${(0, pages_1.defaultPageName)(pageItems[0])}. No se cambió nada.`);
+        }
+    }
+    const prefix = projectPrefix(tree, pagesDir);
+    const pages = {};
+    const legacyPages = [];
+    const taken = new Map();
+    for (const item of pageItems) {
+        const entry = config.blocks?.[item];
+        let target;
+        if (entry?.path) {
+            const dir = (0, paths_1.normalizePath)(entry.path);
+            const trackedName = entry.name && pages_1.PAGE_NAME.test(entry.name) ? entry.name : basename(dir);
+            if (name !== undefined && name !== trackedName) {
+                throw new schematics_1.SchematicsException(`${item} ya es tu página ${trackedName} (${dir}/): Mimi la sigue por su nombre del ` +
+                    `registro, así que está en un solo sitio. Para actualizarla, ejecuta ng g mimi ${item} ` +
+                    'sin --name. Si quieres otra copia con otro nombre, renombra o mueve la tuya y cambia ' +
+                    `"path" y "name" de blocks.${item} en mimi.json. No se cambió nada.`);
+            }
+            target = { item, dir, name: trackedName, prefix };
+        }
+        else if (tree.exists(`${blocksDir}/${item}/${item}.ts`)) {
+            if (name !== undefined) {
+                throw new schematics_1.SchematicsException(`${item} está instalado como en la 0.4.0, en ${blocksDir}/${item}/, y se sigue ` +
+                    'actualizando ahí. Para generarlo como página, guarda tus cambios (por ejemplo, en git), ' +
+                    `borra esa carpeta y vuelve a ejecutar el comando. No se cambió nada.`);
+            }
+            legacyPages.push(item);
+            continue;
+        }
+        else {
+            const pageName = name ?? (0, pages_1.defaultPageName)(item);
+            const dir = `${pagesDir}/${pageName}`;
+            if (hasContent(tree, dir)) {
+                const owner = Object.entries(config.blocks ?? {}).find(([, other]) => other?.path && (0, paths_1.normalizePath)(other.path) === dir)?.[0];
+                throw new schematics_1.SchematicsException(`La carpeta ${dir}/ ya existe${owner ? ` (es tu página de ${owner})` : ''}, así que ` +
+                    `${item} no se generó ahí: Mimi no sobrescribe tus archivos. Elige otro nombre con ` +
+                    `--name, por ejemplo: ng g mimi ${item} --name ${pageName}-2. No se cambió nada.`);
+            }
+            target = { item, dir, name: pageName, prefix };
+        }
+        const other = taken.get(target.dir);
+        if (other) {
+            throw new schematics_1.SchematicsException(`${other} y ${item} irían a la misma carpeta (${target.dir}/). Agrégalos por separado, ` +
+                `uno de ellos con --name (por ejemplo: ng g mimi ${item} --name ${target.name}-2). ` +
+                'No se cambió nada.');
+        }
+        taken.set(target.dir, item);
+        pages[item] = target;
+    }
+    return { pages, legacyPages };
+}
+const basename = (path) => path.slice(path.lastIndexOf('/') + 1);
+/** ¿La carpeta existe y tiene algo dentro? (Un árbol de schematics no tiene carpetas vacías.) */
+function hasContent(tree, dir) {
+    const entry = tree.getDir(dir);
+    return entry.subfiles.length + entry.subdirs.length > 0;
+}
+/**
+ * Prefijo de los selectores (`app`, de angular.json → projects → prefix): el del proyecto que
+ * contiene la carpeta de páginas o, si no, el de la única aplicación. Si no se sabe, `app`.
+ */
+function projectPrefix(tree, dir) {
+    let workspace = null;
+    try {
+        workspace = (0, project_1.readJson)(tree, 'angular.json');
+    }
+    catch {
+        return 'app';
+    }
+    const projects = Object.values(workspace?.projects ?? {});
+    const sourceOf = (project) => (0, paths_1.normalizePath)(project.sourceRoot ?? `${project.root ?? ''}/src`);
+    const inside = projects
+        .filter((project) => `${dir}/`.startsWith(`${sourceOf(project)}/`))
+        .sort((a, b) => sourceOf(b).length - sourceOf(a).length);
+    const apps = projects.filter((project) => project.projectType === 'application');
+    const project = inside[0] ?? (apps.length === 1 ? apps[0] : undefined);
+    return typeof project?.prefix === 'string' && /^[a-z][a-z0-9-]*$|^$/.test(project.prefix)
+        ? project.prefix
+        : 'app';
+}
+/**
+ * Cómo importa `app.routes.ts` el archivo de rutas de una página: relativo a la carpeta del
+ * `app.routes.ts` que está por encima de la página (`src/app/pages/login` →
+ * `./pages/login/login.routes`). Se busca subiendo desde la carpeta de arriba de la página (nunca
+ * la suya: una página `app` tiene su propio `app.routes.ts`); si no hay ninguno, la carpeta `app/`
+ * más cercana por encima. Si tampoco, la ruta del workspace (y `appDir` null: hay que ajustarla).
+ */
+function routesImportOf(tree, page) {
+    const routes = `${page.dir}/${page.name}.routes`;
+    const ancestors = [];
+    const parts = page.dir.split('/');
+    for (let length = parts.length - 1; length > 0; length--) {
+        ancestors.push(parts.slice(0, length).join('/'));
+    }
+    const appDir = ancestors.find((dir) => tree.exists(`${dir}/app.routes.ts`)) ??
+        ancestors.find((dir) => basename(dir) === 'app') ??
+        null;
+    return appDir ? { path: (0, paths_1.relativePath)(appDir, routes), appDir } : { path: routes, appDir: null };
+}
 /**
  * Sin `@source not` hacia `.mimi/`, Tailwind escanea las copias originales (van en git) y genera
  * sus clases aunque el usuario ya las haya cambiado en sus componentes. Proyectos de la 0.3.0 o
@@ -290,21 +425,36 @@ function updateMimiConfig(plan, report) {
         const components = { ...plan.config.components };
         const blocks = { ...plan.config.blocks };
         for (const item of plan.items) {
-            const { type, files } = registry_1.registry.items[item];
+            const { type } = registry_1.registry.items[item];
             if (type !== 'component' && type !== 'block')
                 continue;
             if (blocked.has(item))
                 continue;
-            if (files.some((file) => skipped.has(file)))
+            if ((0, write_files_1.itemFiles)(item, plan.pages).some((file) => skipped.has(file)))
                 continue;
-            (type === 'block' ? blocks : components)[item] = { version: registry_1.registry.version };
+            if (type === 'component') {
+                components[item] = { version: registry_1.registry.version };
+                continue;
+            }
+            // Una página guarda dónde está y con qué nombre se generó (B.11-f).
+            const page = plan.pages[item];
+            blocks[item] = page
+                ? { version: registry_1.registry.version, path: page.dir, name: page.name }
+                : { version: registry_1.registry.version };
         }
         const next = { ...plan.config, components };
         if (Object.keys(blocks).length > 0) {
             next.blocks = blocks;
-            // Proyectos de la 0.3.0 o anteriores: la carpeta queda escrita la primera vez (B.1-a).
-            if (!plan.config.aliases?.blocks) {
-                next.aliases = { ...plan.config.aliases, blocks: plan.blocksDir };
+            // Proyectos anteriores: la carpeta queda escrita la primera vez que se copia un Block
+            // (B.1-a) o se genera una página (B.11-b).
+            const entries = Object.values(blocks);
+            const aliases = { ...plan.config.aliases };
+            if (!aliases.blocks && entries.some((entry) => !entry.path))
+                aliases.blocks = plan.blocksDir;
+            if (!aliases.pages && entries.some((entry) => entry.path))
+                aliases.pages = plan.pagesDir;
+            if (JSON.stringify(aliases) !== JSON.stringify(plan.config.aliases ?? {})) {
+                next.aliases = aliases;
             }
         }
         const text = `${JSON.stringify(next, null, 2)}\n`;
@@ -345,22 +495,40 @@ function updateGlobalCss(plan) {
     };
 }
 /**
- * G1: con `@import "tailwindcss" source(none)`, Tailwind no escanea la carpeta de los Blocks y
- * la pantalla queda sin sus estilos. Si se copia un Block, se agrega su `@source` (una vez).
+ * G1: con `@import "tailwindcss" source(none)`, Tailwind no escanea la carpeta de los Blocks ni
+ * la de las páginas (B.11-i), y la pantalla queda sin sus estilos. Si se copia un Block o se
+ * genera una página, se agrega el `@source` de su carpeta (una vez).
  */
-function addBlocksSource(plan) {
+function addFolderSources(plan) {
     return (tree, context) => {
-        if (!plan.items.some((item) => registry_1.registry.items[item].type === 'block'))
+        const dirs = [];
+        if (plan.items.some((item) => registry_1.registry.items[item].type === 'block' && !plan.pages[item])) {
+            dirs.push(plan.blocksDir);
+        }
+        for (const page of Object.values(plan.pages)) {
+            const dir = `${page.dir}/`.startsWith(`${plan.pagesDir}/`) ? plan.pagesDir : page.dir;
+            if (!dirs.includes(dir))
+                dirs.push(dir);
+        }
+        if (dirs.length === 0)
             return;
         const cssPath = plan.config.tailwind?.css;
         if (!cssPath || !tree.exists(cssPath))
             return;
-        const result = (0, tailwind_1.withBlocksSource)(tree.readText(cssPath), cssPath, plan.componentsDir, plan.blocksDir);
-        if (!result)
+        let css = tree.readText(cssPath);
+        const lines = [];
+        for (const dir of dirs) {
+            const result = (0, tailwind_1.withFolderSource)(css, cssPath, [plan.componentsDir, plan.blocksDir, plan.pagesDir], dir);
+            if (!result)
+                continue;
+            css = result.css;
+            lines.push(result.line);
+        }
+        if (lines.length === 0)
             return;
-        tree.overwrite(cssPath, result.css);
+        tree.overwrite(cssPath, css);
         context.logger.info(`Agregado a ${cssPath} (tu @import de Tailwind usa source(none), así que Tailwind solo ` +
-            `escanea las carpetas que indicas):\n  ${result.line}`);
+            `escanea las carpetas que indicas):\n${lines.map((line) => `  ${line}`).join('\n')}`);
     };
 }
 // ── Mensaje final ─────────────────────────────────────────────────────────────────────
@@ -384,18 +552,12 @@ function blocksUsingUpdated(plan, report, itemOf) {
     }
     return messages;
 }
-/**
- * Cómo se importa un Block desde `app.routes.ts` (en `src/app/`): `src/app/blocks` →
- * `./blocks/login-01`. Si la carpeta no está dentro de `app/`, la ruta del workspace.
- */
-function routesImport(blocksDir, item) {
-    const at = `/${blocksDir}`.lastIndexOf('/app/');
-    return at >= 0 ? `./${`/${blocksDir}`.slice(at + 5)}/${item}` : `${blocksDir}/${item}`;
-}
+/** `pricing-01` → `Pricing01`: la clase de un Block copiado tal cual. */
+const blockClassName = (item) => item.replace(/(^|-)([a-z0-9])/g, (_, _dash, c) => c.toUpperCase());
 function summary(plan, report) {
-    return (_tree, context) => {
+    return (tree, context) => {
         const log = context.logger;
-        const path = (file) => (0, write_files_1.targetPathOf)(file, plan.componentsDir, plan.blocksDir);
+        const path = (file) => (0, write_files_1.targetPathOf)(file, plan.componentsDir, plan.blocksDir, plan.pages);
         if (report.created.length > 0) {
             log.info('Agregado:');
             for (const file of report.created)
@@ -406,16 +568,23 @@ function summary(plan, report) {
             for (const file of report.overwritten)
                 log.info(`  ~ ${path(file)}`);
             // Un Block es una pantalla del usuario: --overwrite la reemplaza entera (B.1, trampas).
-            const screens = [
-                ...new Set(report.overwritten.filter(write_files_1.isBlockFile).map((file) => file.split('/')[1])),
-            ];
-            for (const block of screens) {
-                log.warn(`--overwrite reemplazó tu pantalla ${block} (${plan.blocksDir}/${block}/) por la de ` +
+            const screens = new Map();
+            for (const file of report.overwritten) {
+                if ((0, pages_1.isPageFile)(file)) {
+                    const item = (0, pages_1.pageItemOf)(file);
+                    screens.set(item, `${plan.pages[item].dir}/`);
+                }
+                else if ((0, write_files_1.isBlockFile)(file)) {
+                    const item = file.split('/')[1];
+                    screens.set(item, `${plan.blocksDir}/${item}/`);
+                }
+            }
+            for (const [block, dir] of screens) {
+                log.warn(`--overwrite reemplazó tu pantalla ${block} (${dir}) por la de ` +
                     `Mimi ${registry_1.registry.version}. Si tenías cambios, recupéralos de git.`);
             }
         }
-        const itemOf = (file) => [...plan.items, ...plan.implicit].find((item) => registry_1.registry.items[item].files.includes(file)) ??
-            file;
+        const itemOf = (file) => [...plan.items, ...plan.implicit].find((item) => (0, write_files_1.itemFiles)(item, plan.pages).includes(file)) ?? file;
         for (const message of (0, write_files_1.updatedMessages)(report, itemOf, registry_1.registry.version))
             log.info(message);
         for (const message of blocksUsingUpdated(plan, report, itemOf))
@@ -423,19 +592,42 @@ function summary(plan, report) {
         for (const file of report.skipped) {
             log.warn(`Omitido: ${path(file)} ya existe con otro contenido (usa --overwrite para reemplazarlo).`);
         }
-        for (const message of (0, write_files_1.blockedMessages)(report, plan.componentsDir, registry_1.registry.version, plan.blocksDir)) {
+        for (const message of (0, write_files_1.blockedMessages)(report, plan.componentsDir, registry_1.registry.version, plan.blocksDir, plan.pages)) {
             log.warn(message);
         }
-        // Un Block nuevo es una página: se enruta (B.1, «API pública»).
+        // Una página nueva se enruta con la línea exacta (B.11-e); la CLI no edita app.routes.ts.
+        // Una sección nueva va dentro de una página.
         const created = new Set(report.created);
         for (const item of plan.items) {
-            const { type, files } = registry_1.registry.items[item];
-            if (type !== 'block' || !files.some((file) => created.has(file)))
+            if (registry_1.registry.items[item].type !== 'block' || plan.legacyPages.includes(item))
+                continue;
+            const page = plan.pages[item];
+            if (page) {
+                if (!created.has((0, pages_1.routesKey)(item)))
+                    continue;
+                const { path: routes, appDir } = routesImportOf(tree, page);
+                const routesFile = appDir ? `${appDir}/app.routes.ts` : null;
+                log.info(`${item} es ahora tu página ${page.name} (${page.dir}/, clase ` +
+                    `${(0, pages_1.pageClassName)(page.name)}). Para abrirla en /${page.name}, agrega esta línea a ` +
+                    (routesFile && tree.exists(routesFile)
+                        ? `las rutas de ${routesFile}:`
+                        : 'tus rutas (la ruta del import es relativa a tu app.routes.ts):'));
+                log.info(`  ${(0, pages_1.routeLine)(page, routes)}`);
                 continue;
-            const className = item.replace(/(^|-)([a-z0-9])/g, (_, _dash, c) => c.toUpperCase());
-            log.info(`${item} es una pantalla: agrégala a tus rutas, por ejemplo ` +
-                `{ path: '${item.split('-')[0]}', component: ${className} } ` +
-                `(import { ${className} } from '${routesImport(plan.blocksDir, item)}').`);
+            }
+            if (!registry_1.registry.items[item].files.some((file) => created.has(file)))
+                continue;
+            log.info(`${item} es una sección (una parte de una página): ponla en una de tus páginas con ` +
+                `<mimi-${item} />, importando ${blockClassName(item)} de ${plan.blocksDir}/${item}.`);
+        }
+        // Pantallas de la 0.4.0: siguen donde estaban (B.11-g). Una bloqueada ya tiene su aviso.
+        const blockedItems = new Set(report.blocked.map((b) => b.item));
+        for (const item of plan.legacyPages.filter((legacy) => !blockedItems.has(legacy))) {
+            log.info(`${item} sigue en ${plan.blocksDir}/${item}/, donde lo instalaste con la 0.4.0, y se ` +
+                `actualiza ahí. Los Blocks de pantalla se generan ahora como páginas ` +
+                `(${plan.pagesDir}/${(0, pages_1.defaultPageName)(item)}/, ${(0, pages_1.pageClassName)((0, pages_1.defaultPageName)(item))}): ` +
+                'para pasarlo, guarda tus cambios, borra esa carpeta y vuelve a ejecutar ' +
+                `ng g mimi ${item}.`);
         }
         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.');

package/dist/ui/schema.json

@@ -51,6 +51,10 @@
             "value": "combobox",
             "label": "combobox"
           },
+          {
+            "value": "command",
+            "label": "command"
+          },
           {
             "value": "confirm",
             "label": "confirm"
@@ -59,6 +63,10 @@
             "value": "context-menu",
             "label": "context-menu"
           },
+          {
+            "value": "data-table",
+            "label": "data-table"
+          },
           {
             "value": "date-picker",
             "label": "date-picker"
@@ -131,6 +139,10 @@
             "value": "slider",
             "label": "slider"
           },
+          {
+            "value": "sortable-list",
+            "label": "sortable-list"
+          },
           {
             "value": "switch",
             "label": "switch"
@@ -163,29 +175,37 @@
             "value": "tooltip",
             "label": "tooltip"
           },
+          {
+            "value": "tree",
+            "label": "tree"
+          },
           {
             "value": "login-01",
-            "label": "login-01 (Block)"
+            "label": "login-01 (Block, página)"
           },
           {
             "value": "login-02",
-            "label": "login-02 (Block)"
+            "label": "login-02 (Block, página)"
           },
           {
             "value": "otp-01",
-            "label": "otp-01 (Block)"
+            "label": "otp-01 (Block, página)"
           },
           {
             "value": "pricing-01",
-            "label": "pricing-01 (Block)"
+            "label": "pricing-01 (Block, sección)"
           },
           {
             "value": "settings-01",
-            "label": "settings-01 (Block)"
+            "label": "settings-01 (Block, página)"
           },
           {
             "value": "signup-01",
-            "label": "signup-01 (Block)"
+            "label": "signup-01 (Block, página)"
+          },
+          {
+            "value": "table-01",
+            "label": "table-01 (Block, página)"
           }
         ]
       }
@@ -194,6 +214,10 @@
       "type": "boolean",
       "default": false,
       "description": "Reemplaza los archivos que ya existan con otro contenido."
+    },
+    "name": {
+      "type": "string",
+      "description": "Nombre de la página que genera un Block de tipo página (por defecto, el del Block sin el número: login-01 → login). En kebab-case: --name admin-login."
     }
   }
 }