@caribeng/ui 22.2.0 → 22.4.0

package/schematics/migrate-from-primeng/typescript.js

@@ -0,0 +1,442 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_CONFIG = void 0;
+exports.rewriteImports = rewriteImports;
+exports.findComponents = findComponents;
+exports.replaceInlineTemplate = replaceInlineTemplate;
+exports.ensureComponentImports = ensureComponentImports;
+const ts = __importStar(require("typescript"));
+const mappings_1 = require("./mappings");
+const template_1 = require("./template");
+/** `providePrimeNG` (de `primeng/config`) → `provideCaribeNG` (de `@caribeng/ui`). */
+const CONFIG_SYMBOLS = new Map([['providePrimeNG', { name: 'provideCaribeNG', entry: '@caribeng/ui' }]]);
+/** Configuración que se escribe en lugar de la de PrimeNG (la misma que `ng add` por defecto). */
+exports.PROVIDER_CONFIG = "{ locale: 'es', theme: 'light', preset: 'emerald' }";
+/** Módulos que quedan sin uso tras la migración y se eliminan si nada los referencia. */
+const PRUNABLE_MODULES = /^(@primeuix\/|primeng\/config$)/;
+function parse(fileName, text) {
+    return ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true);
+}
+function newline(text) {
+    return text.includes('\r\n') ? '\r\n' : '\n';
+}
+/** Rango de una sentencia incluyendo su salto de línea final (para borrarla sin dejar una línea vacía). */
+function statementRange(sf, node) {
+    const text = sf.text;
+    let end = node.getEnd();
+    if (text.startsWith('\r\n', end))
+        end += 2;
+    else if (text[end] === '\n')
+        end += 1;
+    return { start: node.getStart(sf), end };
+}
+/** Nombres ya importados desde cada entry point de CaribeNG. */
+function caribeImports(sf) {
+    const imports = new Map();
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const module = statement.moduleSpecifier.text;
+        const bindings = statement.importClause?.namedBindings;
+        if (!module.startsWith('@caribeng/') || !bindings || !ts.isNamedImports(bindings))
+            continue;
+        const names = imports.get(module) ?? new Set();
+        bindings.elements.forEach((element) => names.add(element.name.text));
+        imports.set(module, names);
+    }
+    return imports;
+}
+/** El identificador es un nombre de propiedad/miembro, no una referencia al símbolo importado. */
+function isMemberName(node) {
+    const parent = node.parent;
+    return ((ts.isPropertyAccessExpression(parent) && parent.name === node) ||
+        (ts.isQualifiedName(parent) && parent.right === node) ||
+        ((ts.isPropertyAssignment(parent) ||
+            ts.isPropertyDeclaration(parent) ||
+            ts.isMethodDeclaration(parent) ||
+            ts.isPropertySignature(parent) ||
+            ts.isMethodSignature(parent) ||
+            ts.isGetAccessorDeclaration(parent) ||
+            ts.isSetAccessorDeclaration(parent) ||
+            ts.isEnumMember(parent)) &&
+            parent.name === node));
+}
+/**
+ * Cambia los imports de PrimeNG por los de CaribeNG (`ButtonModule` de
+ * `primeng/button` → `CbButton` de `@caribeng/ui/button`), renombra sus usos
+ * y sustituye `providePrimeNG(…)` por `provideCaribeNG(…)`. Los símbolos sin
+ * equivalente se quedan importados de PrimeNG (aparecen en el informe).
+ */
+function rewriteImports(fileName, text, templates = []) {
+    const sf = parse(fileName, text);
+    const edits = [];
+    const renames = new Map();
+    const existing = caribeImports(sf);
+    const eol = newline(text);
+    let providerLocal;
+    // Reescrituras que dependen del contexto (servicios, MenuItem): van primero porque
+    // pueden consumir símbolos de PrimeNG y pedir imports de CaribeNG.
+    const locals = new Map();
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier) || !statement.moduleSpecifier.text.startsWith('primeng/'))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings && ts.isNamedImports(bindings))
+            bindings.elements.forEach((e) => locals.set((e.propertyName ?? e.name).text, e.name.text));
+    }
+    const consumed = new Set();
+    const requested = new Map();
+    const icons = new Set();
+    for (const rewriteSource of mappings_1.SOURCE_REWRITERS) {
+        rewriteSource(sf, {
+            locals,
+            templates,
+            icons,
+            consume: (symbol) => consumed.add(symbol),
+            addImport: (name, entry) => {
+                if (existing.get(entry)?.has(name))
+                    return;
+                requested.set(entry, (requested.get(entry) ?? new Set()).add(name));
+            },
+        }, edits);
+    }
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const module = statement.moduleSpecifier.text;
+        const symbols = module === 'primeng/config' ? CONFIG_SYMBOLS : mappings_1.SYMBOLS.get(module);
+        const clause = statement.importClause;
+        const bindings = clause?.namedBindings;
+        if (!symbols || !clause || clause.name || !bindings || !ts.isNamedImports(bindings))
+            continue;
+        const quote = text[statement.moduleSpecifier.getStart(sf)];
+        const typePrefix = clause.isTypeOnly ? 'type ' : '';
+        const groups = new Map();
+        const kept = [];
+        let dropped = false;
+        for (const element of bindings.elements) {
+            const imported = (element.propertyName ?? element.name).text;
+            if (consumed.has(imported)) {
+                dropped = true;
+                continue;
+            }
+            const target = symbols.get(imported);
+            if (!target) {
+                kept.push(element.getText(sf));
+                continue;
+            }
+            const local = element.name.text;
+            if (module === 'primeng/config') {
+                providerLocal = local;
+                // Con provideCaribeNG() ya importado no hace falta importarlo otra vez.
+                if (existing.get(target.entry)?.has(target.name))
+                    continue;
+            }
+            else if (!element.propertyName && local !== target.name)
+                renames.set(local, target.name);
+            const specifier = `${element.isTypeOnly ? 'type ' : ''}${element.propertyName ? `${target.name} as ${local}` : target.name}`;
+            const names = existing.get(target.entry) ?? new Set();
+            const group = groups.get(target.entry) ?? [];
+            if ((element.propertyName || !names.has(target.name)) && !group.includes(specifier))
+                group.push(specifier);
+            // Con alias el nombre local es otro: `CbDialog` sigue sin estar importado.
+            if (!element.propertyName)
+                names.add(target.name);
+            existing.set(target.entry, names);
+            groups.set(target.entry, group);
+        }
+        if (!groups.size && !dropped)
+            continue;
+        const lines = [...groups]
+            .filter(([, names]) => names.length)
+            .map(([entry, names]) => `import ${typePrefix}{ ${names.join(', ')} } from ${quote}${entry}${quote};`);
+        if (kept.length)
+            lines.push(`import ${typePrefix}{ ${kept.join(', ')} } from ${quote}${module}${quote};`);
+        const range = lines.length ? { start: statement.getStart(sf), end: statement.getEnd() } : statementRange(sf, statement);
+        edits.push({ ...range, text: lines.join(eol) });
+    }
+    // Si `ng add @caribeng/ui` ya registró provideCaribeNG(), providePrimeNG() se elimina en vez de sustituirse.
+    const hasCaribeProvider = /\bprovideCaribeNG\s*\(/.test(text);
+    const visit = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (providerLocal && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === providerLocal) {
+            if (hasCaribeProvider && ts.isArrayLiteralExpression(node.parent)) {
+                const elements = node.parent.elements;
+                const i = elements.indexOf(node);
+                edits.push(i > 0 ? { start: elements[i - 1].getEnd(), end: node.getEnd(), text: '' } : { start: node.getStart(sf), end: elements[1]?.getStart(sf) ?? node.getEnd(), text: '' });
+                return;
+            }
+            edits.push({
+                start: node.getStart(sf),
+                end: node.getEnd(),
+                text: `provideCaribeNG(${exports.PROVIDER_CONFIG}) /* ${template_1.TODO_MARK}: elige locale, theme y preset; la configuración de PrimeNG (tema, ripple, zIndex…) no se traslada. */`,
+            });
+            return;
+        }
+        if (ts.isIdentifier(node) && !isMemberName(node)) {
+            const renamed = renames.get(node.text);
+            if (renamed) {
+                const shorthand = ts.isShorthandPropertyAssignment(node.parent) && node.parent.name === node;
+                edits.push({ start: node.getStart(sf), end: node.getEnd(), text: shorthand ? `${node.text}: ${renamed}` : renamed });
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    // Imports pedidos por las reescrituras (p. ej. CbMenubarItem): tras el último import;
+    // mergeCaribeImports los une con los que ya hubiera del mismo entry point.
+    if (requested.size) {
+        const imports = sf.statements.filter(ts.isImportDeclaration);
+        const position = imports.length ? imports[imports.length - 1].getEnd() : 0;
+        const lines = [...requested].map(([entry, names]) => `import { ${[...names].join(', ')} } from '${entry}';`);
+        edits.push({ start: position, end: position, text: imports.length ? eol + lines.join(eol) : lines.join(eol) + eol });
+    }
+    if (!edits.length)
+        return { text, changed: false, icons };
+    const rewritten = mergeCaribeImports(fileName, cleanDecoratorArrays(fileName, (0, template_1.applyEdits)(text, edits)));
+    return { text: pruneUnusedImports(fileName, rewritten), changed: true, icons };
+}
+/**
+ * Limpia los arrays de los decoradores tras renombrar:
+ * - `imports: [ButtonModule, Button]` quedaría `[CbButton, CbButton]`: se deja uno.
+ * - `providers: [MessageService]` quedaría `[CbToastService]`: se quita, porque
+ *   es `providedIn: 'root'` y una instancia local no compartiría los mensajes.
+ */
+function cleanDecoratorArrays(fileName, text) {
+    const sf = parse(fileName, text);
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isPropertyAssignment(node) && ts.isIdentifier(node.name) && ts.isArrayLiteralExpression(node.initializer)) {
+            const property = node.name.text;
+            const elements = node.initializer.elements;
+            if (['imports', 'exports', 'providers'].includes(property) && elements.length) {
+                const seen = new Set();
+                const kept = elements.filter((element) => {
+                    if (!ts.isIdentifier(element))
+                        return true;
+                    const drop = seen.has(element.text) || (property === 'providers' && mappings_1.ROOT_SERVICES.has(element.text));
+                    seen.add(element.text);
+                    return !drop;
+                });
+                if (kept.length !== elements.length) {
+                    const first = elements[0];
+                    const last = elements[elements.length - 1];
+                    const between = text.slice(first.getEnd(), elements[1]?.getStart(sf) ?? first.getEnd());
+                    // Array en varias líneas: se conserva el separador original (coma + salto + sangría).
+                    const separator = between.includes('\n') ? between : ', ';
+                    edits.push({ start: first.getStart(sf), end: last.getEnd(), text: kept.map((element) => element.getText(sf)).join(separator) });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return edits.length ? (0, template_1.applyEdits)(text, edits) : text;
+}
+/**
+ * Une los imports del mismo entry point de CaribeNG (`MessageService` de
+ * primeng/api y `ToastModule` de primeng/toast acaban ambos en @caribeng/ui/toast).
+ */
+function mergeCaribeImports(fileName, text) {
+    const sf = parse(fileName, text);
+    const first = new Map();
+    const extra = new Map();
+    const edits = [];
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const clause = statement.importClause;
+        const module = statement.moduleSpecifier.text;
+        if (!module.startsWith('@caribeng/') || !clause || clause.name || clause.isTypeOnly || !clause.namedBindings || !ts.isNamedImports(clause.namedBindings))
+            continue;
+        const target = first.get(module);
+        if (!target) {
+            first.set(module, statement);
+            continue;
+        }
+        const names = extra.get(target) ?? [];
+        names.push(...clause.namedBindings.elements.map((element) => element.getText(sf)));
+        extra.set(target, names);
+        edits.push({ ...statementRange(sf, statement), text: '' });
+    }
+    for (const [target, names] of extra) {
+        const elements = target.importClause.namedBindings.elements;
+        const present = new Set(elements.map((element) => element.getText(sf)));
+        const missing = [...new Set(names)].filter((name) => !present.has(name));
+        if (missing.length)
+            edits.push({ start: elements[elements.length - 1].getEnd(), end: elements[elements.length - 1].getEnd(), text: `, ${missing.join(', ')}` });
+    }
+    return edits.length ? (0, template_1.applyEdits)(text, edits) : text;
+}
+/** Quita los imports de `@primeuix/*` y `primeng/config` que ya nada usa (p. ej. el preset `Aura`). */
+function pruneUnusedImports(fileName, text) {
+    const sf = parse(fileName, text);
+    const used = new Set();
+    const collect = (node) => {
+        if (ts.isImportDeclaration(node))
+            return;
+        if (ts.isIdentifier(node) && !isMemberName(node))
+            used.add(node.text);
+        ts.forEachChild(node, collect);
+    };
+    collect(sf);
+    const edits = [];
+    for (const statement of sf.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        if (!PRUNABLE_MODULES.test(statement.moduleSpecifier.text) || !statement.importClause)
+            continue;
+        const clause = statement.importClause;
+        const locals = [clause.name?.text, ...(clause.namedBindings && ts.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements.map((e) => e.name.text) : [])];
+        if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings))
+            locals.push(clause.namedBindings.name.text);
+        if (locals.every((local) => !local || !used.has(local)))
+            edits.push({ ...statementRange(sf, statement), text: '' });
+    }
+    return edits.length ? (0, template_1.applyEdits)(text, edits) : text;
+}
+function componentDecorators(sf) {
+    const found = [];
+    const visit = (node) => {
+        if (ts.isDecorator(node) && ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === 'Component') {
+            const [config] = node.expression.arguments;
+            if (config && ts.isObjectLiteralExpression(config))
+                found.push(config);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+    return found;
+}
+function property(config, name) {
+    return config.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === name);
+}
+/** Componentes del archivo con su plantilla. */
+function findComponents(fileName, text) {
+    return componentDecorators(parse(fileName, text)).map((config, index) => {
+        const template = property(config, 'template')?.initializer;
+        const templateUrl = property(config, 'templateUrl')?.initializer;
+        const standalone = property(config, 'standalone')?.initializer;
+        return {
+            index,
+            inlineTemplate: template && ts.isStringLiteralLike(template) ? template.text : undefined,
+            templateUrl: templateUrl && ts.isStringLiteralLike(templateUrl) ? templateUrl.text : undefined,
+            declaredInModule: standalone?.kind === ts.SyntaxKind.FalseKeyword,
+        };
+    });
+}
+/** Sustituye la plantilla en línea del componente `index` (se escribe como template literal). */
+function replaceInlineTemplate(fileName, text, index, template) {
+    const literal = property(componentDecorators(parse(fileName, text))[index], 'template').initializer;
+    const escaped = template.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+    return (0, template_1.applyEdits)(text, [{ start: literal.getStart(), end: literal.getEnd(), text: `\`${escaped}\`` }]);
+}
+/**
+ * Añade al `imports` de cada componente los símbolos CaribeNG que usa su
+ * plantilla, y sus `import` de TypeScript. Devuelve también los que no se
+ * pudieron añadir (componentes de NgModule o con `imports` no literal).
+ */
+function ensureComponentImports(fileName, text, needed) {
+    const sf = parse(fileName, text);
+    const decorators = componentDecorators(sf);
+    const edits = [];
+    const manual = [];
+    const toImport = new Map();
+    const existing = caribeImports(sf);
+    const eol = newline(text);
+    for (const [index, symbols] of needed) {
+        const config = decorators[index];
+        if (!config || !symbols.length)
+            continue;
+        const standalone = property(config, 'standalone')?.initializer;
+        const imports = property(config, 'imports');
+        const names = symbols.map((s) => s.name);
+        if (standalone?.kind === ts.SyntaxKind.FalseKeyword || (imports && !ts.isArrayLiteralExpression(imports.initializer))) {
+            manual.push(...names);
+            continue;
+        }
+        const present = new Set(imports && ts.isArrayLiteralExpression(imports.initializer) ? imports.initializer.elements.map((e) => e.getText(sf)) : []);
+        const missing = symbols.filter((s) => !present.has(s.name));
+        if (missing.length) {
+            const list = missing.map((s) => s.name).join(', ');
+            if (imports && ts.isArrayLiteralExpression(imports.initializer)) {
+                const array = imports.initializer;
+                const last = array.elements[array.elements.length - 1];
+                if (last)
+                    edits.push({ start: last.getEnd(), end: last.getEnd(), text: `, ${list}` });
+                else
+                    edits.push({ start: array.getStart(sf) + 1, end: array.getEnd() - 1, text: list });
+            }
+            else {
+                const last = config.properties[config.properties.length - 1];
+                const indent = /[ \t]*$/.exec(text.slice(0, last.getStart(sf)))?.[0] ?? '  ';
+                edits.push({ start: last.getEnd(), end: last.getEnd(), text: `,${eol}${indent}imports: [${list}]` });
+            }
+        }
+        for (const symbol of symbols) {
+            if (existing.get(symbol.entry)?.has(symbol.name))
+                continue;
+            const set = toImport.get(symbol.entry) ?? new Set();
+            set.add(symbol.name);
+            toImport.set(symbol.entry, set);
+        }
+    }
+    if (toImport.size) {
+        const declarations = sf.statements.filter(ts.isImportDeclaration);
+        const lastImport = declarations[declarations.length - 1];
+        const newLines = [];
+        for (const [entry, names] of [...toImport].sort(([a], [b]) => a.localeCompare(b))) {
+            const current = declarations.find((d) => ts.isStringLiteral(d.moduleSpecifier) && d.moduleSpecifier.text === entry && !d.importClause?.isTypeOnly && d.importClause?.namedBindings && ts.isNamedImports(d.importClause.namedBindings));
+            const elements = current && current.importClause.namedBindings.elements;
+            if (elements?.length) {
+                const end = elements[elements.length - 1].getEnd();
+                edits.push({ start: end, end, text: `, ${[...names].join(', ')}` });
+            }
+            else {
+                newLines.push(`import { ${[...names].join(', ')} } from '${entry}';`);
+            }
+        }
+        if (newLines.length) {
+            const position = lastImport ? lastImport.getEnd() : 0;
+            const block = newLines.join(eol);
+            edits.push({ start: position, end: position, text: lastImport ? `${eol}${block}` : `${block}${eol}` });
+        }
+    }
+    if (!edits.length)
+        return { text, changed: false, manual };
+    return { text: (0, template_1.applyEdits)(text, edits), changed: true, manual };
+}

package/schematics/migrate-from-primeng/workspace.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIME_PACKAGES = void 0;
+exports.workspaceFiles = workspaceFiles;
+exports.readPackageJson = readPackageJson;
+exports.dependencyVersion = dependencyVersion;
+exports.majorOf = majorOf;
+exports.removePrimeDependencies = removePrimeDependencies;
+exports.removePrimeStyleEntries = removePrimeStyleEntries;
+exports.removePrimeStyleImports = removePrimeStyleImports;
+/** Carpetas que nunca se recorren (dependencias, salidas de build, cachés). */
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'tmp', 'out-tsc', 'coverage', '.git', '.angular', '.nx', '.cache', '.vscode', '.idea']);
+/** Archivos del workspace bajo `root`, sin entrar en {@link SKIP_DIRS}. */
+function workspaceFiles(tree, root = '/') {
+    const files = [];
+    const walk = (path) => {
+        const dir = tree.getDir(path);
+        for (const file of dir.subfiles)
+            files.push(`${dir.path === '/' ? '' : dir.path}/${file}`);
+        for (const sub of dir.subdirs)
+            if (!SKIP_DIRS.has(sub))
+                walk(`${dir.path === '/' ? '' : dir.path}/${sub}`);
+    };
+    walk(root);
+    return files;
+}
+/** Paquetes del ecosistema PrimeNG que se quitan al terminar (si ya nada los usa). */
+exports.PRIME_PACKAGES = ['primeng', 'primeicons', '@primeuix/themes', '@primeuix/styled', '@primeuix/styles', '@primeuix/utils', '@primeuix/motion', 'tailwindcss-primeui', 'primelocale'];
+const DEPENDENCY_FIELDS = ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies'];
+function readPackageJson(tree) {
+    const raw = tree.exists('/package.json') ? tree.readText('/package.json') : null;
+    return raw ? JSON.parse(raw) : null;
+}
+/** Versión declarada de un paquete, o `null`. */
+function dependencyVersion(pkg, name) {
+    for (const field of DEPENDENCY_FIELDS) {
+        const version = pkg[field]?.[name];
+        if (version)
+            return version;
+    }
+    return null;
+}
+/** Major de una versión de package.json (`^21.1.0` → 21). `null` si no es numérica (`latest`, `workspace:*`…). */
+function majorOf(version) {
+    const match = /(\d+)\./.exec(version) ?? /^\D*(\d+)$/.exec(version);
+    return match ? Number(match[1]) : null;
+}
+/** Quita los paquetes de PrimeNG de package.json. Devuelve los que quitó. */
+function removePrimeDependencies(tree) {
+    const raw = tree.readText('/package.json');
+    const pkg = JSON.parse(raw);
+    const removed = [];
+    for (const field of DEPENDENCY_FIELDS) {
+        const deps = pkg[field];
+        if (!deps)
+            continue;
+        for (const name of exports.PRIME_PACKAGES) {
+            if (name in deps) {
+                delete deps[name];
+                removed.push(name);
+            }
+        }
+    }
+    if (removed.length) {
+        const indent = /^\{\r?\n([ \t]+)/.exec(raw)?.[1] ?? '  ';
+        tree.overwrite('/package.json', JSON.stringify(pkg, null, indent) + '\n');
+    }
+    return removed;
+}
+/** Hoja de PrimeIcons o un tema CSS antiguo de PrimeNG (`primeng/resources/…`). */
+const PRIME_STYLESHEET = /primeicons|primeng\/resources/;
+/** Quita PrimeIcons y los temas CSS de PrimeNG de los `styles` de angular.json/project.json. */
+function removePrimeStyleEntries(tree, path, context) {
+    const raw = tree.readText(path);
+    let config;
+    try {
+        config = JSON.parse(raw);
+    }
+    catch {
+        context.logger.warn(`${path}: no es JSON válido; revisa a mano si incluye primeicons.css.`);
+        return false;
+    }
+    let changed = false;
+    const visit = (node) => {
+        if (Array.isArray(node))
+            return node.forEach(visit);
+        if (!node || typeof node !== 'object')
+            return;
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'styles' && Array.isArray(value)) {
+                const kept = value.filter((entry) => {
+                    const input = typeof entry === 'string' ? entry : entry?.input;
+                    return !(typeof input === 'string' && PRIME_STYLESHEET.test(input));
+                });
+                if (kept.length !== value.length) {
+                    node[key] = kept;
+                    changed = true;
+                }
+            }
+            else {
+                visit(value);
+            }
+        }
+    };
+    visit(config);
+    if (changed) {
+        const indent = /^\{\r?\n([ \t]+)/.exec(raw)?.[1] ?? '  ';
+        tree.overwrite(path, JSON.stringify(config, null, indent) + '\n');
+    }
+    return changed;
+}
+/** `@import 'primeicons/primeicons.css';` y similares. */
+const PRIME_STYLE_IMPORT = /^[ \t]*@(import|use|forward)\s+(url\()?\s*['"]?[^'"\n]*(primeicons|primeng\/resources)[^'"\n]*['"]?\s*\)?[^;\n]*;?[ \t]*\r?\n?/gm;
+/** Quita los `@import` de PrimeIcons de una hoja de estilos global. */
+function removePrimeStyleImports(text) {
+    return text.replace(PRIME_STYLE_IMPORT, '');
+}

package/schematics/ng-add/index.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CARIBENG_STYLES = void 0;
 exports.ngAdd = ngAdd;
 exports.providerConfig = providerConfig;
+exports.projectSourceRoot = projectSourceRoot;
+exports.addStyles = addStyles;
+exports.containsText = containsText;
 const schematics_1 = require("@angular-devkit/schematics");
 const utility_1 = require("@schematics/angular/utility");
 /** Hoja de estilos de CaribeNG (export `./styles.css` del paquete). */
@@ -97,7 +100,7 @@ function containsText(tree, root, text) {
     return found;
 }
 function logNextSteps(options) {
-    return (_tree, context) => {
+    return (tree, context) => {
         const es = options.locale !== 'en';
         const lines = es
             ? [
@@ -121,5 +124,17 @@ function logNextSteps(options) {
                 '',
             ];
         lines.forEach((line) => context.logger.info(line));
+        if (usesPrimeng(tree)) {
+            context.logger.warn(es
+                ? '⚠ Este proyecto usa PrimeNG. Para migrar sus componentes a CaribeNG ejecuta:\n    ng generate @caribeng/ui:migrate-from-primeng'
+                : '⚠ This project uses PrimeNG. To migrate its components to CaribeNG run:\n    ng generate @caribeng/ui:migrate-from-primeng');
+        }
     };
 }
+/** `primeng` aparece en las dependencias del package.json raíz. */
+function usesPrimeng(tree) {
+    if (!tree.exists('/package.json'))
+        return false;
+    const pkg = JSON.parse(tree.readText('/package.json'));
+    return Boolean(pkg['dependencies']?.['primeng'] ?? pkg['devDependencies']?.['primeng']);
+}

package/types/caribeng-ui-badge.d.ts

@@ -19,8 +19,10 @@ declare class CbBadge {
     readonly size: _angular_core.InputSignal<CbSize>;
     /** Muestra solo un punto (sin texto). */
     readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nombre accesible que sustituye al valor (p. ej. "3 mensajes sin leer"). Sin él, un `dot` es decorativo. */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbBadge, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbBadge, "cb-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbBadge, "cb-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "severity": { "alias": "severity"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 export { CbBadge };

package/types/caribeng-ui-breadcrumb.d.ts

@@ -1,5 +1,6 @@
 import * as _angular_core from '@angular/core';
 import * as _caribeng_ui from '@caribeng/ui';
+import { CbMenuCommandEvent } from '@caribeng/ui';
 
 interface CbBreadcrumbItem {
     label: string;
@@ -7,6 +8,10 @@ interface CbBreadcrumbItem {
     url?: string;
     /** Icono (nombre del set de @caribeng/ui/icon) antes del texto. */
     icon?: string;
+    /** Acción al elegir el item (además del evento de selección), como `command` en PrimeNG. */
+    command?: (event: CbMenuCommandEvent<CbBreadcrumbItem>) => void;
+    /** `false` oculta el item. */
+    visible?: boolean;
 }
 /**
  * Breadcrumb de CaribeNG: rastro de navegación jerárquica.
@@ -24,10 +29,13 @@ declare class CbBreadcrumb {
     /** Textos de interfaz en el idioma activo (`provideCaribeNG({ locale })`). */
     protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
     readonly items: _angular_core.InputSignal<readonly CbBreadcrumbItem[]>;
+    /** Items sin los de `visible: false`. */
+    protected readonly visibleItems: _angular_core.Signal<CbBreadcrumbItem[]>;
     /** Icono separador entre elementos. */
     readonly separator: _angular_core.InputSignal<string>;
     /** Se emite al hacer clic en un elemento con enlace. */
     readonly itemClick: _angular_core.OutputEmitterRef<CbBreadcrumbItem>;
+    protected select(item: CbBreadcrumbItem, event: MouseEvent): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbBreadcrumb, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbBreadcrumb, "cb-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, never, never, true, never>;
 }

package/types/caribeng-ui-chart.d.ts

@@ -213,8 +213,10 @@ declare class CbChart {
     readonly sparkline: _angular_core.InputSignalWithTransform<boolean, unknown>;
     /** Formato de los valores (ejes, tooltip y tabla). */
     readonly valueFormat: _angular_core.InputSignal<CbChartValueFormat | undefined>;
-    /** Locale BCP 47 para el formato (por defecto, el del navegador). */
+    /** Locale BCP 47 para el formato (por defecto, el del idioma activo de CaribeNG: `intlLocale`). */
     readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Locale efectivo: el input o, si no se indica, el del idioma activo. */
+    protected readonly intlLocale: _angular_core.Signal<string>;
     /** Valor mínimo del medidor (`gauge`). */
     readonly min: _angular_core.InputSignal<number>;
     /** Valor que representa el 100 % en `radialBar` y el máximo del medidor (`gauge`). */