@caribeng/ui 22.2.0 → 22.5.0

package/schematics/migrate-from-primeng/mappings/inputtext.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputtext = void 0;
+const rules_1 = require("./rules");
+/** Tipos que admite `cb-input` (`CbInputType`). */
+const INPUT_TYPES = new Set(['text', 'email', 'password', 'search', 'tel', 'url', 'number']);
+const NOT_FORWARDED = 'el atributo nativo no se reenvía al <input> interno de cb-input.';
+/**
+ * `<input pInputText id="email" type="email" [(ngModel)]="email" />`
+ * → `<cb-input inputId="email" type="email" [(ngModel)]="email" />`
+ */
+const rules = {
+    pSize: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    // En un <input> nativo `size` es el ancho en caracteres; en cb-input es sm|md|lg.
+    size: (0, rules_1.unsupported)('en cb-input `size` es sm|md|lg; el ancho en caracteres no se reenvía.'),
+    // El id debe llegar al <input> interno para que <label for> siga funcionando.
+    id: (0, rules_1.rename)('inputId'),
+    type: (binding, el) => {
+        if (binding.kind === 'static' && !INPUT_TYPES.has(binding.value)) {
+            el.todos.push(`${binding.source} — cb-input no admite este tipo; usa el componente específico (cb-datepicker, cb-colorpicker…).`);
+            return;
+        }
+        (0, rules_1.rename)('type')(binding, el);
+    },
+    variant: (0, rules_1.unsupported)('cb-input no tiene variante "filled".'),
+    fluid: (0, rules_1.unsupported)('cb-input ya ocupa todo el ancho de su contenedor.'),
+    'aria-label': (0, rules_1.unsupported)('usa el input label de cb-input; el aria-label del host no llega al <input> interno.'),
+    'aria-describedby': (0, rules_1.unsupported)('usa los inputs hint/error de cb-input.'),
+    maxlength: (0, rules_1.unsupported)(NOT_FORWARDED),
+    minlength: (0, rules_1.unsupported)(NOT_FORWARDED),
+    pattern: (0, rules_1.unsupported)(NOT_FORWARDED),
+    autocomplete: (0, rules_1.unsupported)(NOT_FORWARDED),
+    min: (0, rules_1.unsupported)(NOT_FORWARDED),
+    max: (0, rules_1.unsupported)(NOT_FORWARDED),
+    step: (0, rules_1.unsupported)(NOT_FORWARDED),
+    autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+    spellcheck: (0, rules_1.unsupported)(NOT_FORWARDED),
+    // focus/blur no burbujean desde el <input> interno; focusin/focusout sí.
+    '(focus)': (0, rules_1.event)('focusin'),
+    '(blur)': (0, rules_1.event)('focusout'),
+};
+exports.inputtext = {
+    name: 'inputtext',
+    entry: '@caribeng/ui/input',
+    symbol: 'CbInput',
+    modules: {
+        'primeng/inputtext': { InputTextModule: 'CbInput', InputText: 'CbInput' },
+    },
+    elements: [
+        {
+            attr: 'pInputText',
+            on: ['input'],
+            otherTags: 'para <textarea> usa <cb-textarea>.',
+            to: 'cb-input',
+            selfClosing: true,
+            rules,
+            same: ['value', 'placeholder', 'invalid', 'disabled', 'readonly', 'required', 'inputmode'],
+        },
+    ],
+};

package/schematics/migrate-from-primeng/mappings/menu.js

@@ -0,0 +1,468 @@
+"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.contextmenu = exports.splitbutton = exports.tabmenu = exports.breadcrumb = exports.panelmenu = exports.tieredmenu = exports.menubar = exports.menu = void 0;
+const ts = __importStar(require("typescript"));
+const icons_1 = require("../icons");
+const todo_1 = require("../todo");
+const rules_1 = require("./rules");
+const service_calls_1 = require("./service-calls");
+/** Tipo de item de cada menú CaribeNG, según el tag PrimeNG que recibe el array en `[model]`. */
+const ITEM_TYPES = new Map();
+const itemType = (tags, name, entry) => tags.forEach((tag) => ITEM_TYPES.set(tag, { name, entry }));
+itemType(['p-menu', 'p-splitbutton', 'p-splitButton', 'p-split-button'], 'CbMenuItem', '@caribeng/ui/menu');
+itemType(['p-menubar'], 'CbMenubarItem', '@caribeng/ui/menubar');
+itemType(['p-tieredmenu', 'p-tieredMenu', 'p-tiered-menu'], 'CbTieredMenuItem', '@caribeng/ui/tieredmenu');
+itemType(['p-panelmenu', 'p-panelMenu', 'p-panel-menu'], 'CbPanelMenuItem', '@caribeng/ui/panelmenu');
+itemType(['p-breadcrumb'], 'CbBreadcrumbItem', '@caribeng/ui/breadcrumb');
+itemType(['p-tabmenu', 'p-tabMenu'], 'CbTabMenuItem', '@caribeng/ui/tabmenu');
+/** Tipos de item que admiten `separator` (y en los que `label` es obligatorio también en los separadores). */
+const WITH_SEPARATORS = new Set(['CbMenuItem', 'CbTieredMenuItem', 'CbContextMenuItem']);
+/** Para un `MenuItem` cuyo menú no se conoce (p. ej. lo devuelve un servicio): el tipo más completo. */
+const FALLBACK = { name: 'CbMenubarItem', entry: '@caribeng/ui/menubar' };
+/** Campos de `MenuItem` sin equivalente en los items de CaribeNG. */
+const DROPPED_FIELDS = new Set([
+    'expanded',
+    'styleClass',
+    'style',
+    'badge',
+    'badgeStyleClass',
+    'tooltip',
+    'tooltipPosition',
+    'tooltipOptions',
+    'id',
+    'title',
+    'automationId',
+    'tabindex',
+    'iconClass',
+    'iconStyle',
+    'escape',
+    'data',
+    'shortcut',
+    'queryParams',
+    'fragment',
+    'state',
+    'queryParamsHandling',
+    'preserveFragment',
+    'skipLocationChange',
+    'replaceUrl',
+    'routerLinkActiveOptions',
+]);
+/** `[model]="items"` / `[home]="inicio"` en las plantillas → nombre de la propiedad → tipo de item. */
+function propertyTypes(templates) {
+    const types = new Map();
+    for (const template of templates) {
+        for (const [, tag, attrs] of template.matchAll(/<(p-[A-Za-z-]+)\b([^>]*)>/g)) {
+            const type = ITEM_TYPES.get(tag);
+            if (!type)
+                continue;
+            for (const [, input, name] of attrs.matchAll(/\[(model|home)\]\s*=\s*"\s*(?:this\.)?([A-Za-z_$][\w$]*)(?:\(\))?\s*"/g)) {
+                types.set(name, input === 'home' ? ITEM_TYPES.get('p-breadcrumb') : type);
+            }
+        }
+    }
+    return types;
+}
+/** Nombre de la declaración (propiedad, variable, parámetro, método) que contiene `node`. */
+function declarationName(node) {
+    for (let current = node; current; current = current.parent) {
+        if ((ts.isPropertyDeclaration(current) || ts.isVariableDeclaration(current) || ts.isParameter(current) || ts.isGetAccessorDeclaration(current)) &&
+            ts.isIdentifier(current.name)) {
+            return current.name.text;
+        }
+    }
+    return undefined;
+}
+/** Rango para quitar las propiedades `removed` de un objeto literal sin dejar comas sueltas. */
+function removalEdits(sf, object, removed) {
+    const props = object.properties;
+    const lastKept = [...props.keys()].filter((i) => !removed.has(i)).pop() ?? -1;
+    const edits = [];
+    for (const i of removed) {
+        if (i < lastKept)
+            edits.push({ start: props[i].getStart(sf), end: props[i + 1].getStart(sf), text: '' });
+    }
+    // Las del final (detrás de la última que se queda) se quitan junto con la coma que las precede.
+    const tail = [...removed].filter((i) => i > lastKept);
+    if (tail.length) {
+        const start = lastKept >= 0 ? props[lastKept].getEnd() : props[Math.min(...tail)].getStart(sf);
+        edits.push({ start, end: props[Math.max(...tail)].getEnd(), text: '' });
+    }
+    return edits;
+}
+/**
+ * `{ label: 'Nuevo', icon: 'pi pi-plus', routerLink: '/nuevo', badge: '2', command: () => … }`
+ * → `{ label: 'Nuevo', icon: 'plus', url: '/nuevo', command: () => … }` (+ aviso por `badge`).
+ */
+function rewriteItem(sf, item, type, icons, edits) {
+    const todos = [];
+    const removed = new Set();
+    const hasUrl = item.properties.some((p) => (0, service_calls_1.propertyName)(p) === 'url');
+    const separator = item.properties.some((p) => (0, service_calls_1.propertyName)(p) === 'separator' && ts.isPropertyAssignment(p) && p.initializer.kind === ts.SyntaxKind.TrueKeyword);
+    if (separator && !WITH_SEPARATORS.has(type.name)) {
+        todos.push(`${type.name} no admite separadores; quita este item.`);
+    }
+    else if (separator && !item.properties.some((p) => (0, service_calls_1.propertyName)(p) === 'label')) {
+        // En CaribeNG label es obligatorio también en los separadores.
+        const first = item.properties[0];
+        edits.push({ start: first.getStart(sf), end: first.getStart(sf), text: "label: '', " });
+    }
+    item.properties.forEach((property, i) => {
+        const name = (0, service_calls_1.propertyName)(property);
+        if (!name || !ts.isPropertyAssignment(property))
+            return;
+        const value = property.initializer;
+        if (name === 'icon') {
+            const parsed = ts.isStringLiteralLike(value) ? (0, icons_1.parsePrimeIcon)(value.text) : null;
+            if (parsed?.name) {
+                edits.push({ start: value.getStart(sf), end: value.getEnd(), text: `'${parsed.name}'` });
+                icons.add(parsed.name);
+            }
+            else if (ts.isStringLiteralLike(value) && parsed) {
+                todos.push(`icon: pi-${parsed.prime} no tiene equivalente conocido; usa un nombre de @caribeng/ui/icon.`);
+            }
+            else if (!ts.isStringLiteralLike(value)) {
+                todos.push('icon recibe el nombre de un icono de CaribeNG ("plus"), no clases "pi pi-plus".');
+            }
+        }
+        else if (name === 'routerLink') {
+            const single = ts.isArrayLiteralExpression(value) && value.elements.length === 1 ? value.elements[0] : value;
+            if (!hasUrl && ts.isStringLiteralLike(single)) {
+                edits.push({ start: property.getStart(sf), end: property.getEnd(), text: `url: '${single.text}'` });
+            }
+            else {
+                removed.add(i);
+                todos.push(`${property.getText(sf)} — los menús de CaribeNG navegan con url (recarga la página); para el router usa command: () => this.router.navigate(…).`);
+            }
+        }
+        else if (DROPPED_FIELDS.has(name)) {
+            removed.add(i);
+            todos.push(`${property.getText(sf)} — los items de menú de CaribeNG no tienen este campo.`);
+        }
+    });
+    edits.push(...removalEdits(sf, item, removed));
+    if (todos.length) {
+        const start = item.getStart(sf);
+        edits.push({ start, end: start, text: todos.map((t) => `/* ${todo_1.TODO_MARK}: ${t} */ `).join('') });
+    }
+}
+/** Items de menú: objetos literales que son elementos de un array dentro de `node`. */
+function rewriteItems(sf, node, type, icons, edits) {
+    const visit = (current) => {
+        if (ts.isArrayLiteralExpression(current)) {
+            for (const element of current.elements)
+                if (ts.isObjectLiteralExpression(element))
+                    rewriteItem(sf, element, type, icons, edits);
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+}
+/**
+ * `MenuItem` (primeng/api) → el tipo de item del menú CaribeNG que lo recibe,
+ * deducido de la plantilla (`<p-menubar [model]="items">` → `CbMenubarItem`),
+ * y traducción de los arrays de items (`icon`, `routerLink`, campos sin equivalente).
+ */
+const rewriteMenuItems = (sf, context, edits) => {
+    const local = context.locals.get('MenuItem');
+    if (!local)
+        return;
+    context.consume('MenuItem');
+    const types = propertyTypes(context.templates);
+    // Propiedad con MenuItem → tipo de item que se le asignó.
+    const menuProperties = new Map();
+    let fallbackNoted = false;
+    const visitTypes = (node) => {
+        if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.text === local) {
+            const owner = declarationName(node);
+            const type = (owner && types.get(owner)) || FALLBACK;
+            if (owner)
+                menuProperties.set(owner, type);
+            context.addImport(type.name, type.entry);
+            const note = type === FALLBACK && !fallbackNoted
+                ? `/* ${todo_1.TODO_MARK}: no se encontró en la plantilla qué menú recibe este MenuItem; ${FALLBACK.name} sirve para menubar, pero usa el tipo del menú que lo reciba (CbMenuItem, CbTieredMenuItem…). */ `
+                : '';
+            if (note)
+                fallbackNoted = true;
+            edits.push({ start: node.typeName.getStart(sf), end: node.typeName.getEnd(), text: note + type.name });
+        }
+        ts.forEachChild(node, visitTypes);
+    };
+    visitTypes(sf);
+    // Arrays de items: el inicializador de las propiedades tipadas con MenuItem y las asignaciones `this.items = [...]`.
+    const visitValues = (node) => {
+        if ((ts.isPropertyDeclaration(node) || ts.isVariableDeclaration(node)) && ts.isIdentifier(node.name) && menuProperties.has(node.name.text) && node.initializer) {
+            rewriteItems(sf, node.initializer, menuProperties.get(node.name.text), context.icons, edits);
+            return;
+        }
+        if (ts.isBinaryExpression(node) &&
+            node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+            ts.isPropertyAccessExpression(node.left) &&
+            node.left.expression.kind === ts.SyntaxKind.ThisKeyword &&
+            menuProperties.has(node.left.name.text)) {
+            rewriteItems(sf, node.right, menuProperties.get(node.left.name.text), context.icons, edits);
+            return;
+        }
+        ts.forEachChild(node, visitValues);
+    };
+    visitValues(sf);
+};
+/** `[model]` → `[items]`. */
+const model = (binding, el) => el.attrs.push((0, rules_1.renderAttr)(binding.kind, 'items', binding.value));
+const OVERLAY = {
+    appendTo: (0, rules_1.drop)(),
+    autoZIndex: (0, rules_1.drop)(),
+    baseZIndex: (0, rules_1.drop)(),
+    showTransitionOptions: (0, rules_1.drop)(),
+    hideTransitionOptions: (0, rules_1.drop)(),
+    motionOptions: (0, rules_1.drop)(),
+    transitionOptions: (0, rules_1.drop)(),
+};
+const NO_TEMPLATES = (tag) => (child) => (child.name === 'ng-template' ? { todo: `${tag} no admite plantillas personalizadas; el contenido no se mostrará.` } : null);
+const COMMON = {
+    model,
+    styleClass: (0, rules_1.styleClass)(),
+    style: (0, rules_1.unsupported)('personaliza el menú con los tokens CSS de CaribeNG.'),
+    ariaLabelledBy: (0, rules_1.unsupported)('usa ariaLabel.'),
+    tabindex: (0, rules_1.unsupported)('el menú gestiona su propio orden de foco.'),
+    ...OVERLAY,
+};
+/** `<p-menu [model]="items" [popup]="true" #menu />` → `<cb-menu [items]="items" #menu />`. */
+exports.menu = {
+    name: 'menu',
+    entry: '@caribeng/ui/menu',
+    symbol: 'CbMenu',
+    modules: {
+        'primeng/menu': { MenuModule: 'CbMenu', Menu: 'CbMenu' },
+        'primeng/api': { MenuItemCommandEvent: { name: 'CbMenuCommandEvent', entry: '@caribeng/ui' } },
+    },
+    rewriteSource: rewriteMenuItems,
+    elements: [
+        {
+            tag: 'p-menu',
+            to: 'cb-menu',
+            rules: {
+                ...COMMON,
+                popup: (binding, el) => {
+                    if (binding.kind === 'static' ? binding.value === 'false' : binding.value.trim() !== 'true') {
+                        el.todos.push(`${binding.source} — cb-menu siempre es emergente: ábrelo con (click)="menu.toggle($event)".`);
+                    }
+                },
+                '(onHide)': (0, rules_1.event)('hidden'),
+                '(onShow)': (0, rules_1.unsupported)('cb-menu no emite la apertura.'),
+                '(onFocus)': (0, rules_1.unsupported)('cb-menu no emite el foco.'),
+                '(onBlur)': (0, rules_1.unsupported)('cb-menu no emite el foco.'),
+            },
+            finalize: (el) => {
+                if (!el.find('popup'))
+                    el.todos.push('p-menu sin [popup]="true" era un menú fijo; cb-menu es emergente (ábrelo con (click)="menu.toggle($event)") o usa cb-panelmenu.');
+            },
+            child: NO_TEMPLATES('cb-menu'),
+            same: ['ariaLabel'],
+        },
+    ],
+};
+exports.menubar = {
+    name: 'menubar',
+    entry: '@caribeng/ui/menubar',
+    symbol: 'CbMenubar',
+    modules: { 'primeng/menubar': { MenubarModule: 'CbMenubar', Menubar: 'CbMenubar' } },
+    elements: [
+        {
+            tag: 'p-menubar',
+            to: 'cb-menubar',
+            rules: {
+                ...COMMON,
+                autoDisplay: (0, rules_1.drop)(),
+                autoHide: (0, rules_1.drop)(),
+                autoHideDelay: (0, rules_1.drop)(),
+                breakpoint: (0, rules_1.unsupported)('cb-menubar se adapta solo a pantallas pequeñas.'),
+                '(onFocus)': (0, rules_1.unsupported)('cb-menubar no emite el foco.'),
+                '(onBlur)': (0, rules_1.unsupported)('cb-menubar no emite el foco.'),
+            },
+            child: (child) => child.name === 'ng-template' ? { todo: 'cb-menubar no tiene zonas #start/#end ni plantillas de item; pon el logo y las acciones fuera, junto al menú.' } : null,
+            same: ['ariaLabel'],
+        },
+    ],
+};
+exports.tieredmenu = {
+    name: 'tieredmenu',
+    entry: '@caribeng/ui/tieredmenu',
+    symbol: 'CbTieredMenu',
+    modules: { 'primeng/tieredmenu': { TieredMenuModule: 'CbTieredMenu', TieredMenu: 'CbTieredMenu' } },
+    elements: ['p-tieredmenu', 'p-tieredMenu', 'p-tiered-menu'].map((tag) => ({
+        tag,
+        to: 'cb-tieredmenu',
+        rules: {
+            ...COMMON,
+            popup: (0, rules_1.drop)(),
+            autoDisplay: (0, rules_1.drop)(),
+            breakpoint: (0, rules_1.unsupported)('cb-tieredmenu se adapta solo a pantallas pequeñas.'),
+            disabled: (0, rules_1.unsupported)('deshabilita los items con disabled.'),
+            '(onShow)': (0, rules_1.unsupported)('cb-tieredmenu no emite la apertura.'),
+            '(onHide)': (0, rules_1.unsupported)('cb-tieredmenu no emite el cierre.'),
+        },
+        finalize: (el) => {
+            el.todos.push('cb-tieredmenu muestra su propio botón de apertura (texto en triggerLabel); si lo abrías con otro botón, quítalo.');
+        },
+        child: NO_TEMPLATES('cb-tieredmenu'),
+        same: ['ariaLabel'],
+    })),
+};
+exports.panelmenu = {
+    name: 'panelmenu',
+    entry: '@caribeng/ui/panelmenu',
+    symbol: 'CbPanelMenu',
+    modules: { 'primeng/panelmenu': { PanelMenuModule: 'CbPanelMenu', PanelMenu: 'CbPanelMenu' } },
+    elements: ['p-panelmenu', 'p-panelMenu', 'p-panel-menu'].map((tag) => ({
+        tag,
+        to: 'cb-panelmenu',
+        rules: COMMON,
+        child: NO_TEMPLATES('cb-panelmenu'),
+        same: ['multiple'],
+    })),
+};
+/** `[home]` + `[model]` de PrimeNG → un solo `[items]` con el inicio delante. */
+function breadcrumbItems(el) {
+    const home = el.find('home');
+    const items = el.find('model');
+    if (!home) {
+        if (items)
+            el.attrs.unshift((0, rules_1.renderAttr)(items.kind, 'items', items.value));
+        return;
+    }
+    const list = items ? `[${home.value}, ...${items.value}]` : `[${home.value}]`;
+    el.attrs.unshift((0, rules_1.renderAttr)('property', 'items', list));
+}
+exports.breadcrumb = {
+    name: 'breadcrumb',
+    entry: '@caribeng/ui/breadcrumb',
+    symbol: 'CbBreadcrumb',
+    modules: { 'primeng/breadcrumb': { BreadcrumbModule: 'CbBreadcrumb', Breadcrumb: 'CbBreadcrumb' } },
+    elements: [
+        {
+            tag: 'p-breadcrumb',
+            to: 'cb-breadcrumb',
+            rules: {
+                ...COMMON,
+                // Se combinan en finalize.
+                model: (0, rules_1.drop)(),
+                home: (0, rules_1.drop)(),
+                homeAriaLabel: (0, rules_1.unsupported)('el inicio usa su label como nombre accesible.'),
+                '(onItemClick)': (0, rules_1.event)('itemClick', (0, rules_1.adaptEvent)('item')),
+            },
+            finalize: breadcrumbItems,
+            child: (child) => (child.name === 'ng-template' ? { todo: 'cb-breadcrumb no admite plantillas; el separador se cambia con el input separator (nombre de icono).' } : null),
+        },
+    ],
+};
+exports.tabmenu = {
+    name: 'tabmenu',
+    entry: '@caribeng/ui/tabmenu',
+    symbol: 'CbTabMenu',
+    modules: { 'primeng/tabmenu': { TabMenuModule: 'CbTabMenu', TabMenu: 'CbTabMenu' } },
+    elements: ['p-tabmenu', 'p-tabMenu'].map((tag) => ({
+        tag,
+        to: 'cb-tabmenu',
+        rules: {
+            ...COMMON,
+            activeItem: (0, rules_1.unsupported)('cb-tabmenu marca la pestaña activa con [(activeIndex)] (posición).'),
+            '(activeItemChange)': (0, rules_1.unsupported)('usa (activeIndexChange) o (itemSelect).'),
+            scrollable: (0, rules_1.drop)(),
+        },
+        child: NO_TEMPLATES('cb-tabmenu'),
+        same: ['activeIndex', 'ariaLabel'],
+    })),
+};
+/** `<p-splitbutton label="Guardar" icon="pi pi-check" [model]="mas" (onClick)="guardar()" />`. */
+exports.splitbutton = {
+    name: 'splitbutton',
+    entry: '@caribeng/ui/splitbutton',
+    symbol: 'CbSplitButton',
+    modules: { 'primeng/splitbutton': { SplitButtonModule: 'CbSplitButton', SplitButton: 'CbSplitButton' } },
+    elements: ['p-splitbutton', 'p-splitButton', 'p-split-button'].map((tag) => ({
+        tag,
+        to: 'cb-split-button',
+        rules: {
+            model,
+            icon: (0, rules_1.iconName)(),
+            severity: (0, rules_1.values)('severity', rules_1.SEVERITY_VALUES),
+            size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+            outlined: (0, rules_1.flagToValue)('variant', 'outlined', 'solid'),
+            text: (0, rules_1.flagToValue)('variant', 'text', 'solid'),
+            expandAriaLabel: (binding, el) => el.attrs.push((0, rules_1.renderAttr)(binding.kind, 'menuAriaLabel', binding.value)),
+            styleClass: (0, rules_1.styleClass)(),
+            raised: (0, rules_1.unsupported)('cb-split-button no tiene variante elevada.'),
+            rounded: (0, rules_1.unsupported)('cb-split-button no tiene variante redondeada.'),
+            plain: (0, rules_1.unsupported)('usa severity="secondary".'),
+            iconPos: (0, rules_1.unsupported)('cb-split-button muestra el icono delante del texto.'),
+            tooltip: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+            tooltipOptions: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+            menuStyle: (0, rules_1.unsupported)('personaliza el menú con los tokens CSS de CaribeNG.'),
+            menuStyleClass: (0, rules_1.unsupported)('personaliza el menú con los tokens CSS de CaribeNG.'),
+            dropdownIcon: (0, rules_1.unsupported)('cb-split-button usa su propio icono.'),
+            buttonProps: (0, rules_1.unsupported)('pasa cada propiedad como input de cb-split-button.'),
+            menuButtonProps: (0, rules_1.unsupported)('pasa cada propiedad como input de cb-split-button.'),
+            buttonDisabled: (0, rules_1.unsupported)('usa disabled (deshabilita los dos botones).'),
+            menuButtonDisabled: (0, rules_1.unsupported)('usa disabled o deshabilita los items.'),
+            autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+            tabindex: (0, rules_1.unsupported)('el tabindex no se reenvía a los botones internos.'),
+            dir: (0, rules_1.drop)(),
+            ...OVERLAY,
+            '(onClick)': (0, rules_1.event)('primaryClick'),
+            '(onDropdownClick)': (0, rules_1.unsupported)('cb-split-button no emite la apertura del menú.'),
+            '(onMenuShow)': (0, rules_1.unsupported)('cb-split-button no emite la apertura del menú.'),
+            '(onMenuHide)': (0, rules_1.unsupported)('cb-split-button no emite el cierre del menú.'),
+        },
+        child: NO_TEMPLATES('cb-split-button'),
+        same: ['label', 'disabled', 'loading'],
+    })),
+};
+/**
+ * PrimeNG ancla el menú contextual a otro elemento (`[target]`) o a toda la
+ * página (`[global]`); cb-contextmenu envuelve el área sobre la que se abre.
+ */
+exports.contextmenu = {
+    name: 'contextmenu',
+    entry: '@caribeng/ui/contextmenu',
+    symbol: 'CbContextMenu',
+    modules: {},
+    elements: ['p-contextmenu', 'p-contextMenu', 'p-context-menu'].map((tag) => ({
+        tag,
+        to: 'cb-contextmenu',
+        manual: 'envuelve el área con <cb-contextmenu [items]="…" (itemSelect)="…"> … </cb-contextmenu> (se abre con clic derecho sobre su contenido); importa CbContextMenu de @caribeng/ui/contextmenu.',
+        rules: {},
+    })),
+};

package/schematics/migrate-from-primeng/mappings/multiselect.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiselect = void 0;
+const rules_1 = require("./rules");
+const select_1 = require("./select");
+/**
+ * Mismas reglas que Select (opciones, filtro, overlay…) más las propias de la
+ * selección múltiple.
+ *
+ * `<p-multiselect [options]="ciudades" optionLabel="nombre" [(ngModel)]="elegidas" filterPlaceHolder="Buscar" />`
+ * → `<cb-multiselect [options]="ciudades" optionLabel="nombre" [(ngModel)]="elegidas" filterPlaceholder="Buscar" />`
+ */
+const rules = {
+    ...select_1.selectRules,
+    // En PrimeNG la H va en mayúscula.
+    filterPlaceHolder: (0, rules_1.rename)('filterPlaceholder'),
+    maxSelectedLabels: (0, rules_1.numeric)(),
+    showClear: (0, rules_1.unsupported)('cb-multiselect no tiene botón para limpiar; usa "seleccionar todo" o vacía el valor.'),
+    display: (0, rules_1.unsupported)('cb-multiselect muestra las opciones elegidas como texto.'),
+    selectionLimit: (0, rules_1.unsupported)('cb-multiselect no limita la cantidad de opciones; valídalo en el formulario.'),
+    selectedItemsLabel: (0, rules_1.unsupported)('cb-multiselect usa el texto de provideCaribeNG() al superar maxSelectedLabels.'),
+    showHeader: (0, rules_1.unsupported)('cb-multiselect muestra la cabecera con "seleccionar todo" y el filtro.'),
+    chipIcon: (0, rules_1.unsupported)('cb-multiselect no muestra chips.'),
+    displaySelectedLabel: (0, rules_1.unsupported)('cb-multiselect siempre muestra la selección.'),
+    selectAll: (0, rules_1.unsupported)('usa showToggleAll; el estado de "todo" se deduce del valor.'),
+    overlayVisible: (0, rules_1.unsupported)('cb-multiselect no admite abrir el panel desde un input.'),
+    filterValue: (0, rules_1.unsupported)('cb-multiselect no admite fijar el texto del filtro.'),
+    highlightOnSelect: (0, rules_1.unsupported)('cb-multiselect marca las opciones elegidas con su casilla.'),
+    autocomplete: (0, rules_1.unsupported)('cb-multiselect no reenvía autocomplete.'),
+    '(onPanelShow)': (0, rules_1.unsupported)('cb-multiselect no emite la apertura del panel.'),
+    '(onPanelHide)': (0, rules_1.unsupported)('cb-multiselect no emite el cierre del panel.'),
+    '(onRemove)': (0, rules_1.unsupported)('escucha (valueChange).'),
+    '(onSelectAllChange)': (0, rules_1.unsupported)('escucha (valueChange).'),
+};
+exports.multiselect = {
+    name: 'multiselect',
+    entry: '@caribeng/ui/multiselect',
+    symbol: 'CbMultiSelect',
+    modules: {
+        'primeng/multiselect': { MultiSelectModule: 'CbMultiSelect', MultiSelect: 'CbMultiSelect' },
+    },
+    elements: ['p-multiselect', 'p-multiSelect', 'p-multi-select'].map((tag) => ({
+        tag,
+        to: 'cb-multiselect',
+        rules,
+        child: select_1.selectChild,
+        same: [...select_1.selectSame.filter((name) => name !== 'showClear'), 'showToggleAll'],
+    })),
+};

package/schematics/migrate-from-primeng/mappings/radiobutton.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.radiobutton = void 0;
+/**
+ * PrimeNG enlaza el modelo en cada radio (`<p-radiobutton name="t" value="a" [(ngModel)]="talla">`);
+ * CaribeNG lo enlaza una vez en el grupo que los envuelve (`<cb-radio-group [(ngModel)]="talla">`).
+ * Los radios suelen ir cada uno en su propio contenedor con su <label>, así que
+ * agruparlos cambia el layout: se deja un aviso con la forma de hacerlo y
+ * RadioButtonModule sigue importado para que la plantilla compile.
+ */
+exports.radiobutton = {
+    name: 'radiobutton',
+    entry: '@caribeng/ui/radio',
+    symbol: 'CbRadioGroup',
+    modules: {},
+    elements: ['p-radiobutton', 'p-radioButton', 'p-radio-button'].map((tag) => ({
+        tag,
+        to: 'cb-radio-group',
+        manual: 'agrupa los radios en <cb-radio-group [(ngModel)]="…"> (el modelo va en el grupo) con un <cb-radio value="…" label="…" /> por opción; importa CbRadioGroup y CbRadio de @caribeng/ui/radio.',
+        rules: {},
+    })),
+};