@caribeng/ui 22.2.0 → 22.5.0

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.card = void 0;
+const rules_1 = require("./rules");
+const TEXT_ONLY = 'cb-card solo admite título y subtítulo de texto (inputs header y subtitle).';
+/**
+ * `<p-card header="Resumen" subheader="Octubre"><ng-template #footer>…</ng-template></p-card>`
+ * → `<cb-card header="Resumen" subtitle="Octubre"><div cb-card-footer>…</div></cb-card>`
+ */
+exports.card = {
+    name: 'card',
+    entry: '@caribeng/ui/card',
+    symbol: 'CbCard',
+    modules: {
+        'primeng/card': { CardModule: 'CbCard', Card: 'CbCard' },
+    },
+    elements: [
+        {
+            tag: 'p-card',
+            to: 'cb-card',
+            rules: {
+                subheader: (0, rules_1.rename)('subtitle'),
+                styleClass: (0, rules_1.styleClass)(),
+            },
+            child: (0, rules_1.slotChild)('cb-card', 'cb-card-footer', {
+                header: 'cb-card no tiene zona de cabecera (p. ej. una imagen); ponla al principio del contenido.',
+                title: TEXT_ONLY,
+                subtitle: TEXT_ONLY,
+            }),
+            same: ['header'],
+        },
+    ],
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkbox = void 0;
+const rules_1 = require("./rules");
+/**
+ * `<p-checkbox [(ngModel)]="acepto" [binary]="true" inputId="acepto" />`
+ * → `<cb-checkbox [(ngModel)]="acepto" inputId="acepto" />`
+ *
+ * cb-checkbox decide el modo por el valor del modelo: booleano si no es un
+ * array, lista si lo es (como `binary` / `value` en PrimeNG).
+ */
+const rules = {
+    binary: (0, rules_1.drop)(),
+    size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    styleClass: (0, rules_1.styleClass)(),
+    ariaLabelledBy: (0, rules_1.unsupported)('usa ariaLabel o el input label de cb-checkbox.'),
+    readonly: (0, rules_1.unsupported)('usa disabled o deshabilita el control de formulario.'),
+    tabindex: (0, rules_1.unsupported)('el tabindex no se reenvía al control interno.'),
+    autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+    trueValue: (0, rules_1.unsupported)('cb-checkbox usa true/false en modo binario; convierte el valor en el modelo.'),
+    falseValue: (0, rules_1.unsupported)('cb-checkbox usa true/false en modo binario; convierte el valor en el modelo.'),
+    checkboxIcon: (0, rules_1.unsupported)('cb-checkbox usa su propio icono.'),
+    inputStyle: (0, rules_1.unsupported)('personaliza el control con los tokens CSS de cb-checkbox.'),
+    inputClass: (0, rules_1.unsupported)('personaliza el control con los tokens CSS de cb-checkbox.'),
+    variant: (0, rules_1.unsupported)('cb-checkbox no tiene variante "filled".'),
+    '(onChange)': (0, rules_1.event)('changed', (0, rules_1.adaptEvent)('checked')),
+    ...rules_1.FOCUS_EVENTS,
+};
+exports.checkbox = {
+    name: 'checkbox',
+    entry: '@caribeng/ui/checkbox',
+    symbol: 'CbCheckbox',
+    modules: {
+        'primeng/checkbox': { CheckboxModule: 'CbCheckbox', Checkbox: 'CbCheckbox' },
+    },
+    // Selectores alternativos que acepta PrimeNG.
+    elements: ['p-checkbox', 'p-checkBox', 'p-check-box'].map((tag) => ({
+        tag,
+        to: 'cb-checkbox',
+        rules,
+        child: (child) => (child.name === 'ng-template' ? { todo: 'cb-checkbox usa su propio icono; la plantilla no se mostrará.' } : null),
+        same: ['value', 'inputId', 'ariaLabel', 'indeterminate', 'disabled', 'required', 'invalid', 'label'],
+    })),
+};

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

@@ -0,0 +1,221 @@
+"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.confirmpopup = exports.confirmdialog = void 0;
+const ts = __importStar(require("typescript"));
+const rules_1 = require("./rules");
+const service_calls_1 = require("./service-calls");
+/** Severidades que admite el botón de aceptar de CaribeNG (`CbConfirmSeverity`). */
+const ACCEPT_SEVERITIES = new Set(['primary', 'danger', 'success', 'warning']);
+/** `acceptButtonStyleClass: 'p-button-danger'` (PrimeNG ≤ 17) → severidad. */
+const STYLE_CLASS_SEVERITY = /\bp-button-(danger|success|warning|warn)\b/;
+/** Opciones de `Confirmation` que se copian tal cual a `CbConfirmation`. */
+const SAME_FIELDS = new Set(['message', 'header', 'accept', 'reject', 'target', 'key', 'acceptLabel', 'rejectLabel']);
+/** Severidad PrimeNG → CaribeNG (`warn` → `warning`); `null` si no tiene equivalente. */
+function acceptSeverity(value) {
+    const mapped = value === 'warn' ? 'warning' : value;
+    return ACCEPT_SEVERITIES.has(mapped) ? mapped : null;
+}
+/**
+ * `{ message, acceptButtonProps: { severity: 'danger', label: 'Sí' }, icon: 'pi pi-x' }`
+ * → `{ message, acceptSeverity: 'danger', acceptLabel: 'Sí' }`. Devuelve el
+ * texto nuevo (o `null` si no cambia) y deja los avisos en `todos`.
+ */
+function rewriteConfirmation(sf, confirmation, todos) {
+    const properties = [];
+    const dropped = [];
+    let severity;
+    const has = (name) => confirmation.properties.some((p) => (0, service_calls_1.propertyName)(p) === name);
+    let changed = false;
+    for (const property of confirmation.properties) {
+        const name = (0, service_calls_1.propertyName)(property);
+        const text = property.getText(sf);
+        if (!name || SAME_FIELDS.has(name) || !ts.isPropertyAssignment(property)) {
+            properties.push(text);
+            continue;
+        }
+        changed = true;
+        const value = property.initializer;
+        if ((name === 'acceptButtonProps' || name === 'rejectButtonProps') && ts.isObjectLiteralExpression(value)) {
+            const prefix = name === 'acceptButtonProps' ? 'accept' : 'reject';
+            for (const prop of value.properties) {
+                const propName = (0, service_calls_1.propertyName)(prop);
+                const init = ts.isPropertyAssignment(prop) ? prop.initializer : undefined;
+                if (propName === 'label' && init && !has(`${prefix}Label`)) {
+                    properties.push(`${prefix}Label: ${init.getText(sf)}`);
+                }
+                else if (prefix === 'accept' && propName === 'severity' && init && ts.isStringLiteralLike(init) && acceptSeverity(init.text)) {
+                    severity = acceptSeverity(init.text);
+                }
+                else {
+                    dropped.push(`${name}.${prop.getText(sf)}`);
+                }
+            }
+            continue;
+        }
+        if (name === 'acceptButtonStyleClass' && ts.isStringLiteralLike(value) && STYLE_CLASS_SEVERITY.test(value.text)) {
+            severity = acceptSeverity(STYLE_CLASS_SEVERITY.exec(value.text)[1]);
+            continue;
+        }
+        dropped.push(text);
+    }
+    if (severity)
+        properties.push(`acceptSeverity: '${severity}'`);
+    if (dropped.length)
+        todos.push(`${dropped.join(', ')} — CbConfirmationService no tiene estas opciones (iconos, visibilidad de botones, estilos…).`);
+    return changed ? (0, service_calls_1.rebuildObject)(sf, confirmation, properties) : null;
+}
+/**
+ * `ConfirmationService.confirm({...})` → `CbConfirmationService.confirm({...})`:
+ * mismas opciones salvo los botones (`acceptButtonProps.severity` →
+ * `acceptSeverity`) y las de iconos/estilo, que se marcan.
+ */
+const rewriteConfirmationService = (sf, { locals }, edits) => {
+    const local = locals.get('ConfirmationService');
+    if (!local)
+        return;
+    (0, service_calls_1.forEachServiceCall)(sf, local, (method, access, call) => {
+        const todos = [];
+        if (method === 'confirm' && call) {
+            const [confirmation] = call.arguments;
+            if (confirmation && ts.isObjectLiteralExpression(confirmation)) {
+                const rewritten = rewriteConfirmation(sf, confirmation, todos);
+                if (rewritten !== null)
+                    edits.push({ start: confirmation.getStart(sf), end: confirmation.getEnd(), text: rewritten });
+            }
+            else if (confirmation) {
+                todos.push('confirmación no literal: CbConfirmationService usa acceptSeverity en vez de acceptButtonProps y no tiene iconos.');
+            }
+        }
+        else if (method === 'requireConfirmation$' || method === 'accept' || method === 'onAccept') {
+            todos.push(`CbConfirmationService no expone ${method}; pasa accept/reject en confirm() o lee su señal request().`);
+        }
+        if (todos.length)
+            edits.push((0, service_calls_1.todoBefore)(sf, call ?? access, todos));
+    });
+};
+/** El host de PrimeNG atiende siempre al servicio: en CaribeNG hay que pedirlo con `service`. */
+function asServiceHost(el) {
+    if (!el.attrs.includes('service'))
+        el.attrs.push('service');
+}
+/** Se elimina sin aviso salvo que se desactive (`[closeOnEscape]="false"`), que no tiene equivalente. */
+const dropUnlessFalse = (why) => (binding, el) => {
+    if ((0, rules_1.staticBoolean)(binding) !== true)
+        el.todos.push(`${binding.source} — ${why}`);
+};
+const NO_ICONS = 'las confirmaciones de CaribeNG no tienen iconos.';
+const NO_STYLE = 'personaliza la confirmación con los tokens CSS de CaribeNG.';
+const NO_TEMPLATE = 'las confirmaciones de CaribeNG no admiten plantillas; el contenido no se mostrará.';
+/**
+ * `<p-confirmdialog />` + `ConfirmationService` → `<cb-confirm-dialog service />` + `CbConfirmationService`.
+ */
+exports.confirmdialog = {
+    name: 'confirmdialog',
+    entry: '@caribeng/ui/confirmdialog',
+    symbol: 'CbConfirmDialog',
+    modules: {
+        'primeng/confirmdialog': { ConfirmDialogModule: 'CbConfirmDialog', ConfirmDialog: 'CbConfirmDialog' },
+        'primeng/api': { ConfirmationService: { name: 'CbConfirmationService', entry: '@caribeng/ui' } },
+    },
+    rootServices: ['CbConfirmationService'],
+    rewriteSource: rewriteConfirmationService,
+    elements: ['p-confirmdialog', 'p-confirmDialog', 'p-confirm-dialog'].map((tag) => ({
+        tag,
+        to: 'cb-confirm-dialog',
+        finalize: asServiceHost,
+        rules: {
+            styleClass: (0, rules_1.styleClass)(),
+            closeOnEscape: dropUnlessFalse('cb-confirm-dialog siempre se cancela con Escape.'),
+            // Comportamiento que cb-confirm-dialog resuelve solo (modal, foco atrapado en "cancelar", clic en la máscara cancela).
+            dismissableMask: (0, rules_1.drop)(),
+            blockScroll: (0, rules_1.drop)(),
+            closable: (0, rules_1.drop)(),
+            modal: (0, rules_1.drop)(),
+            draggable: (0, rules_1.drop)(),
+            focusTrap: (0, rules_1.drop)(),
+            defaultFocus: (0, rules_1.drop)(),
+            appendTo: (0, rules_1.drop)(),
+            autoZIndex: (0, rules_1.drop)(),
+            baseZIndex: (0, rules_1.drop)(),
+            transitionOptions: (0, rules_1.drop)(),
+            icon: (0, rules_1.unsupported)(NO_ICONS),
+            acceptIcon: (0, rules_1.unsupported)(NO_ICONS),
+            rejectIcon: (0, rules_1.unsupported)(NO_ICONS),
+            acceptVisible: (0, rules_1.unsupported)('cb-confirm-dialog muestra siempre los dos botones.'),
+            rejectVisible: (0, rules_1.unsupported)('cb-confirm-dialog muestra siempre los dos botones.'),
+            acceptButtonStyleClass: (0, rules_1.unsupported)('usa acceptSeverity.'),
+            rejectButtonStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+            closeAriaLabel: (0, rules_1.drop)(),
+            acceptAriaLabel: (0, rules_1.unsupported)('el botón usa acceptLabel como nombre accesible.'),
+            rejectAriaLabel: (0, rules_1.unsupported)('el botón usa rejectLabel como nombre accesible.'),
+            style: (0, rules_1.unsupported)(NO_STYLE),
+            maskStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+            breakpoints: (0, rules_1.unsupported)(NO_STYLE),
+            position: (0, rules_1.unsupported)('cb-confirm-dialog aparece centrado.'),
+            rtl: (0, rules_1.unsupported)('cb-confirm-dialog sigue la dirección del documento (dir="rtl").'),
+            '(onHide)': (0, rules_1.unsupported)('usa accept/reject en confirm() o los eventos (accepted)/(rejected).'),
+        },
+        child: (child) => (child.name === 'ng-template' ? { todo: NO_TEMPLATE } : null),
+        same: ['header', 'message', 'acceptLabel', 'rejectLabel', 'key', 'visible'],
+    })),
+};
+/** `<p-confirmpopup />` → `<cb-confirm-popup service />` (las confirmaciones con `target`). */
+exports.confirmpopup = {
+    name: 'confirmpopup',
+    entry: '@caribeng/ui/confirmpopup',
+    symbol: 'CbConfirmPopup',
+    modules: {
+        'primeng/confirmpopup': { ConfirmPopupModule: 'CbConfirmPopup', ConfirmPopup: 'CbConfirmPopup' },
+    },
+    elements: ['p-confirmpopup', 'p-confirmPopup', 'p-confirm-popup'].map((tag) => ({
+        tag,
+        to: 'cb-confirm-popup',
+        finalize: asServiceHost,
+        rules: {
+            styleClass: (0, rules_1.styleClass)(),
+            defaultFocus: (0, rules_1.drop)(),
+            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)(),
+            style: (0, rules_1.unsupported)(NO_STYLE),
+        },
+        child: (child) => (child.name === 'ng-template' ? { todo: NO_TEMPLATE } : null),
+        same: ['key', 'visible'],
+    })),
+};

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

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.datepicker = void 0;
+const rules_1 = require("./rules");
+const BEHAVIOUR = 'cb-datepicker gestiona este comportamiento por su cuenta.';
+const NO_STYLE = 'personaliza cb-datepicker con los tokens CSS de CaribeNG.';
+/**
+ * `<p-datepicker [(ngModel)]="fecha" dateFormat="dd/mm/yy" [showIcon]="true" />`
+ * → `<cb-datepicker [(ngModel)]="fecha" dateFormat="dd/mm/yy" editable />`
+ *
+ * `dateFormat` usa la misma sintaxis en las dos librerías. Con Angular Forms el
+ * valor es igual: una fecha, o `[inicio, fin]` con `selectionMode="range"`.
+ */
+const rules = {
+    selectionMode: (binding, el) => {
+        if (binding.kind === 'static' && binding.value === 'multiple') {
+            el.todos.push(`${binding.source} — cb-datepicker no admite varias fechas sueltas; usa un rango o varios campos.`);
+            return;
+        }
+        el.attrs.push(binding.source);
+    },
+    numberOfMonths: (0, rules_1.numeric)(),
+    firstDayOfWeek: (0, rules_1.numeric)(),
+    stepMinute: (0, rules_1.numeric)(),
+    size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    styleClass: (0, rules_1.styleClass)(),
+    // PrimeNG deja escribir la fecha salvo con readonlyInput; cb-datepicker solo con editable (ver finalize).
+    readonlyInput: (0, rules_1.drop)(),
+    // cb-datepicker siempre muestra su icono y abre el calendario como overlay del CDK.
+    showIcon: (0, rules_1.drop)(),
+    iconDisplay: (0, rules_1.drop)(),
+    icon: (0, rules_1.drop)(),
+    appendTo: (0, rules_1.drop)(),
+    autoZIndex: (0, rules_1.drop)(),
+    baseZIndex: (0, rules_1.drop)(),
+    showOnFocus: (0, rules_1.drop)(),
+    showOtherMonths: (0, rules_1.drop)(),
+    selectOtherMonths: (0, rules_1.drop)(),
+    hideOnDateTimeSelect: (0, rules_1.drop)(),
+    keepInvalid: (0, rules_1.drop)(),
+    touchUI: (0, rules_1.drop)(),
+    focusTrap: (0, rules_1.drop)(),
+    showTransitionOptions: (0, rules_1.drop)(),
+    hideTransitionOptions: (0, rules_1.drop)(),
+    motionOptions: (0, rules_1.drop)(),
+    inline: (0, rules_1.unsupported)('cb-datepicker siempre se abre como desplegable.'),
+    timeOnly: (0, rules_1.unsupported)('cb-datepicker no tiene modo solo hora.'),
+    showSeconds: (0, rules_1.unsupported)('cb-datepicker muestra horas y minutos.'),
+    stepHour: (0, rules_1.unsupported)('cb-datepicker avanza las horas de una en una.'),
+    stepSecond: (0, rules_1.unsupported)('cb-datepicker muestra horas y minutos.'),
+    showButtonBar: (0, rules_1.unsupported)('usa presets (p. ej. [presets]="[\'today\']") para atajos de fecha.'),
+    showClear: (0, rules_1.unsupported)('borra la fecha desde el formulario.'),
+    showWeek: (0, rules_1.unsupported)('cb-datepicker no muestra el número de semana.'),
+    startWeekFromFirstDayOfYear: (0, rules_1.unsupported)('cb-datepicker no muestra el número de semana.'),
+    disabledDates: (0, rules_1.unsupported)('usa minDate/maxDate o valida la fecha en el formulario.'),
+    disabledDays: (0, rules_1.unsupported)('usa minDate/maxDate o valida la fecha en el formulario.'),
+    dataType: (0, rules_1.unsupported)('cb-datepicker siempre entrega objetos Date.'),
+    defaultDate: (0, rules_1.unsupported)('cb-datepicker abre en el mes de la fecha elegida o en el actual.'),
+    maxDateCount: (0, rules_1.unsupported)('cb-datepicker no admite varias fechas sueltas.'),
+    multipleSeparator: (0, rules_1.unsupported)('cb-datepicker no admite varias fechas sueltas.'),
+    rangeSeparator: (0, rules_1.unsupported)(BEHAVIOUR),
+    shortYearCutoff: (0, rules_1.unsupported)(BEHAVIOUR),
+    timeSeparator: (0, rules_1.unsupported)(BEHAVIOUR),
+    responsiveOptions: (0, rules_1.unsupported)(BEHAVIOUR),
+    panelStyle: (0, rules_1.unsupported)(NO_STYLE),
+    panelStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+    inputStyle: (0, rules_1.unsupported)(NO_STYLE),
+    inputStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+    todayButtonStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+    clearButtonStyleClass: (0, rules_1.unsupported)(NO_STYLE),
+    ariaLabel: (0, rules_1.unsupported)('usa el input label de cb-datepicker.'),
+    ariaLabelledBy: (0, rules_1.unsupported)('usa el input label de cb-datepicker.'),
+    iconAriaLabel: (0, rules_1.unsupported)('el botón del calendario usa el texto de provideCaribeNG().'),
+    tabindex: (0, rules_1.unsupported)('el tabindex no se reenvía al campo interno.'),
+    autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+    variant: (0, rules_1.unsupported)('cb-datepicker no tiene variante "filled".'),
+    fluid: (0, rules_1.unsupported)('cb-datepicker ya ocupa todo el ancho de su contenedor.'),
+    // PrimeNG emite la fecha elegida, igual que el valueChange de cb-datepicker.
+    '(onSelect)': (0, rules_1.event)('valueChange'),
+    '(onClose)': (0, rules_1.unsupported)('cb-datepicker no emite el cierre del calendario.'),
+    '(onClear)': (0, rules_1.unsupported)('escucha (valueChange) y comprueba el valor null.'),
+    '(onInput)': (0, rules_1.unsupported)('escucha (valueChange) o los cambios del control de formulario.'),
+    '(onTodayClick)': (0, rules_1.unsupported)('cb-datepicker no tiene barra de botones.'),
+    '(onClearClick)': (0, rules_1.unsupported)('cb-datepicker no tiene barra de botones.'),
+    '(onMonthChange)': (0, rules_1.unsupported)('cb-datepicker no emite el cambio de mes.'),
+    '(onYearChange)': (0, rules_1.unsupported)('cb-datepicker no emite el cambio de año.'),
+    '(onClickOutside)': (0, rules_1.unsupported)('cb-datepicker no emite el clic fuera.'),
+    '(onShow)': (0, rules_1.unsupported)('cb-datepicker no emite la apertura del calendario.'),
+    ...rules_1.FOCUS_EVENTS,
+};
+/** En PrimeNG el campo admite escribir la fecha salvo con `readonlyInput`; en cb-datepicker hay que pedirlo con `editable`. */
+function finalize(el) {
+    const readonly = el.find('readonlyInput');
+    if (!readonly) {
+        el.attrs.push('editable');
+    }
+    else if ((0, rules_1.staticBoolean)(readonly) === null) {
+        el.attrs.push(`[editable]="!(${readonly.value})"`);
+    }
+    else if ((0, rules_1.staticBoolean)(readonly) === false) {
+        el.attrs.push('editable');
+    }
+}
+exports.datepicker = {
+    name: 'datepicker',
+    entry: '@caribeng/ui/datepicker',
+    symbol: 'CbDatepicker',
+    modules: {
+        'primeng/datepicker': { DatePickerModule: 'CbDatepicker', DatePicker: 'CbDatepicker' },
+        // Nombre anterior a PrimeNG 18.
+        'primeng/calendar': { CalendarModule: 'CbDatepicker', Calendar: 'CbDatepicker' },
+    },
+    elements: ['p-datepicker', 'p-datePicker', 'p-date-picker', 'p-calendar'].map((tag) => ({
+        tag,
+        to: 'cb-datepicker',
+        rules,
+        finalize,
+        child: (child) => (child.name === 'ng-template' ? { todo: 'cb-datepicker no admite plantillas personalizadas; el contenido no se mostrará.' } : null),
+        same: ['dateFormat', 'hourFormat', 'showTime', 'minDate', 'maxDate', 'view', 'placeholder', 'inputId', 'disabled', 'required', 'invalid'],
+    })),
+};

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dialog = void 0;
+const rules_1 = require("./rules");
+/** `{ width: '25rem' }` · `{ 'width': "50vw" }`. */
+const WIDTH_OBJECT = /^\s*\{\s*(['"]?)width\1\s*:\s*(['"])([^'"]+)\2\s*,?\s*\}\s*$/;
+/** `width: 25rem` · `width: 25rem;`. */
+const WIDTH_STYLE = /^\s*width\s*:\s*([^;]+?)\s*;?\s*$/;
+/** `[style]="{ width: '25rem' }"` → `width="25rem"` (cb-dialog no aplica el style del host al panel). */
+const style = (binding, el) => {
+    const width = binding.kind === 'property' ? WIDTH_OBJECT.exec(binding.value)?.[3] : binding.kind === 'static' ? WIDTH_STYLE.exec(binding.value)?.[1] : undefined;
+    if (width)
+        el.attrs.push((0, rules_1.renderAttr)('static', 'width', width));
+    else
+        el.todos.push(`${binding.source} — cb-dialog solo admite el ancho (input width).`);
+};
+/**
+ * `<p-dialog header="Editar" [(visible)]="abierto" [modal]="true" [style]="{ width: '25rem' }">`
+ * → `<cb-dialog header="Editar" [(visible)]="abierto" width="25rem">`
+ */
+const rules = {
+    modal: (binding, el) => {
+        if ((0, rules_1.staticBoolean)(binding) !== true)
+            el.todos.push(`${binding.source} — cb-dialog siempre es modal; sin máscara usa <cb-drawer> o <cb-popover>.`);
+    },
+    style,
+    styleClass: (0, rules_1.styleClass)(),
+    // Comportamiento que cb-dialog resuelve solo (overlay del CDK, foco atrapado, scroll bloqueado).
+    appendTo: (0, rules_1.drop)(),
+    autoZIndex: (0, rules_1.drop)(),
+    baseZIndex: (0, rules_1.drop)(),
+    blockScroll: (0, rules_1.drop)(),
+    focusOnShow: (0, rules_1.drop)(),
+    focusTrap: (0, rules_1.drop)(),
+    keepInViewport: (0, rules_1.drop)(),
+    minX: (0, rules_1.drop)(),
+    minY: (0, rules_1.drop)(),
+    transitionOptions: (0, rules_1.drop)(),
+    motionOptions: (0, rules_1.drop)(),
+    maskMotionOptions: (0, rules_1.drop)(),
+    draggable: (0, rules_1.drop)(),
+    resizable: (0, rules_1.unsupported)('cb-dialog no se puede redimensionar.'),
+    maximizable: (0, rules_1.unsupported)('cb-dialog no se puede maximizar.'),
+    position: (0, rules_1.unsupported)('cb-dialog siempre aparece centrado; para un panel lateral usa <cb-drawer>.'),
+    breakpoints: (0, rules_1.unsupported)('ajusta el ancho con width (admite min(), clamp(), %).'),
+    contentStyle: (0, rules_1.unsupported)('aplica estilos al contenido proyectado.'),
+    contentStyleClass: (0, rules_1.unsupported)('aplica clases al contenido proyectado.'),
+    maskStyle: (0, rules_1.unsupported)('personaliza la máscara con los tokens CSS de cb-dialog.'),
+    maskStyleClass: (0, rules_1.unsupported)('personaliza la máscara con los tokens CSS de cb-dialog.'),
+    showHeader: (0, rules_1.unsupported)('cb-dialog muestra la cabecera si hay header o closable.'),
+    closeIcon: (0, rules_1.unsupported)('cb-dialog usa su propio icono de cierre.'),
+    closeAriaLabel: (0, rules_1.unsupported)('el botón de cierre usa el texto de provideCaribeNG().'),
+    closeTabindex: (0, rules_1.unsupported)('el botón de cierre ya es accesible por teclado.'),
+    closeButtonProps: (0, rules_1.unsupported)('cb-dialog usa su propio botón de cierre.'),
+    maximizeButtonProps: (0, rules_1.unsupported)('cb-dialog no se puede maximizar.'),
+    minimizeIcon: (0, rules_1.unsupported)('cb-dialog no se puede maximizar.'),
+    maximizeIcon: (0, rules_1.unsupported)('cb-dialog no se puede maximizar.'),
+    rtl: (0, rules_1.unsupported)('cb-dialog sigue la dirección del documento (dir="rtl").'),
+    role: (0, rules_1.unsupported)('cb-dialog usa role="dialog".'),
+    '(onResizeInit)': (0, rules_1.unsupported)('cb-dialog no se puede redimensionar.'),
+    '(onResizeEnd)': (0, rules_1.unsupported)('cb-dialog no se puede redimensionar.'),
+    '(onDragEnd)': (0, rules_1.unsupported)('cb-dialog no se puede arrastrar.'),
+    '(onMaximize)': (0, rules_1.unsupported)('cb-dialog no se puede maximizar.'),
+};
+const HEADER = 'cb-dialog solo admite una cabecera de texto (input header).';
+/** El pie pasa a un `<div cb-dialog-footer>` y `#content` se desenvuelve; el resto de plantillas no tiene equivalente. */
+const child = (0, rules_1.slotChild)('cb-dialog', 'cb-dialog-footer', { header: HEADER });
+exports.dialog = {
+    name: 'dialog',
+    entry: '@caribeng/ui/dialog',
+    symbol: 'CbDialog',
+    modules: {
+        'primeng/dialog': { DialogModule: 'CbDialog', Dialog: 'CbDialog' },
+    },
+    elements: [
+        {
+            tag: 'p-dialog',
+            to: 'cb-dialog',
+            rules,
+            child,
+            same: ['visible', 'header', 'closable', 'dismissableMask', 'closeOnEscape', 'ariaLabel', 'onShow', 'onHide', 'visibleChange'],
+        },
+    ],
+};

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCE_REWRITERS = exports.ROOT_SERVICES = exports.DIRECTIVES_BY_ATTR = exports.MAPPING_BY_TAG = exports.ELEMENTS_BY_ATTR = exports.ELEMENTS_BY_TAG = exports.ATTR_SYMBOLS = exports.TAG_SYMBOLS = exports.SYMBOLS = exports.MAPPINGS = void 0;
+const button_1 = require("./button");
+const card_1 = require("./card");
+const checkbox_1 = require("./checkbox");
+const confirm_1 = require("./confirm");
+const datepicker_1 = require("./datepicker");
+const dialog_1 = require("./dialog");
+const inputnumber_1 = require("./inputnumber");
+const inputtext_1 = require("./inputtext");
+const menu_1 = require("./menu");
+const multiselect_1 = require("./multiselect");
+const radiobutton_1 = require("./radiobutton");
+const select_1 = require("./select");
+const tabs_1 = require("./tabs");
+const table_1 = require("./table");
+const tag_1 = require("./tag");
+const textarea_1 = require("./textarea");
+const toast_1 = require("./toast");
+const toggleswitch_1 = require("./toggleswitch");
+const tooltip_1 = require("./tooltip");
+/** Componentes que el migrador sabe traducir. Para añadir uno, crea su archivo y regístralo aquí. */
+exports.MAPPINGS = [
+    button_1.button,
+    inputtext_1.inputtext,
+    textarea_1.textarea,
+    inputnumber_1.inputnumber,
+    select_1.select,
+    multiselect_1.multiselect,
+    checkbox_1.checkbox,
+    radiobutton_1.radiobutton,
+    toggleswitch_1.toggleswitch,
+    datepicker_1.datepicker,
+    dialog_1.dialog,
+    confirm_1.confirmdialog,
+    confirm_1.confirmpopup,
+    menu_1.menu,
+    menu_1.menubar,
+    menu_1.tieredmenu,
+    menu_1.panelmenu,
+    menu_1.breadcrumb,
+    menu_1.tabmenu,
+    menu_1.splitbutton,
+    menu_1.contextmenu,
+    table_1.table,
+    tabs_1.tabs,
+    tabs_1.accordion,
+    tag_1.tag,
+    toast_1.toast,
+    card_1.card,
+    tooltip_1.tooltip,
+];
+/** Módulo PrimeNG → (símbolo PrimeNG → símbolo CaribeNG). */
+exports.SYMBOLS = (() => {
+    const index = new Map();
+    for (const mapping of exports.MAPPINGS) {
+        for (const [module, symbols] of Object.entries(mapping.modules)) {
+            const target = index.get(module) ?? new Map();
+            for (const [from, to] of Object.entries(symbols))
+                target.set(from, typeof to === 'string' ? { name: to, entry: mapping.entry } : to);
+            index.set(module, target);
+        }
+    }
+    return index;
+})();
+/** Tag CaribeNG → símbolo que hay que importar en el componente que lo usa. */
+exports.TAG_SYMBOLS = new Map([
+    ['cb-icon', { name: 'CbIcon', entry: '@caribeng/ui/icon' }],
+    ...exports.MAPPINGS.flatMap((mapping) => mapping.elements.map((element) => [element.to, { name: element.symbol ?? mapping.symbol, entry: mapping.entry }])),
+    ...exports.MAPPINGS.flatMap((mapping) => Object.entries(mapping.tags ?? {}).map(([tag, name]) => [tag, { name, entry: mapping.entry }])),
+]);
+/** Atributo de directiva CaribeNG (`cbTooltip`) → símbolo que hay que importar. */
+exports.ATTR_SYMBOLS = new Map([
+    ...exports.MAPPINGS.flatMap((mapping) => (mapping.directives ?? []).map((directive) => [directive.to, { name: mapping.symbol, entry: mapping.entry }])),
+    ...exports.MAPPINGS.flatMap((mapping) => Object.entries(mapping.attrs ?? {}).map(([attr, name]) => [attr, { name, entry: mapping.entry }])),
+]);
+/** Selectores por tag (`p-button`) y por directiva de atributo (`pButton`). */
+exports.ELEMENTS_BY_TAG = new Map(exports.MAPPINGS.flatMap((mapping) => mapping.elements.filter((element) => element.tag).map((element) => [element.tag, element])));
+exports.ELEMENTS_BY_ATTR = new Map(exports.MAPPINGS.flatMap((mapping) => mapping.elements.filter((element) => element.attr).map((element) => [element.attr, element])));
+/** Tag PrimeNG → su mapeo completo (para saber qué módulo PrimeNG conservar si no se convierte). */
+exports.MAPPING_BY_TAG = new Map(exports.MAPPINGS.flatMap((mapping) => mapping.elements.filter((element) => element.tag).map((element) => [element.tag, mapping])));
+/** Directivas que se traducen sin cambiar el elemento (`pTooltip`). */
+exports.DIRECTIVES_BY_ATTR = new Map(exports.MAPPINGS.flatMap((mapping) => (mapping.directives ?? []).map((directive) => [directive.attr, directive])));
+/** Servicios `providedIn: 'root'` que no deben quedar en `providers`. */
+exports.ROOT_SERVICES = new Set(exports.MAPPINGS.flatMap((mapping) => mapping.rootServices ?? []));
+/** Reescrituras de uso de servicios (`MessageService.add`…). */
+exports.SOURCE_REWRITERS = exports.MAPPINGS.flatMap((mapping) => (mapping.rewriteSource ? [mapping.rewriteSource] : []));

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inputnumber = void 0;
+const rules_1 = require("./rules");
+const NOT_FORWARDED = 'cb-input-number no reenvía este atributo al <input> interno.';
+/**
+ * `<p-inputnumber [(ngModel)]="precio" mode="currency" currency="EUR" min="0" [showButtons]="true" />`
+ * → `<cb-input-number [(ngModel)]="precio" mode="currency" currency="EUR" [min]="0" [showButtons]="true" />`
+ */
+const rules = {
+    min: (0, rules_1.numeric)(),
+    max: (0, rules_1.numeric)(),
+    step: (0, rules_1.numeric)(),
+    minFractionDigits: (0, rules_1.numeric)(),
+    maxFractionDigits: (0, rules_1.numeric)(),
+    size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    styleClass: (0, rules_1.styleClass)(),
+    buttonLayout: (binding, el) => {
+        if (!(binding.kind === 'static' && binding.value === 'stacked'))
+            el.todos.push(`${binding.source} — cb-input-number solo tiene un diseño de botones.`);
+    },
+    localeMatcher: (0, rules_1.drop)(),
+    format: (0, rules_1.unsupported)('cb-input-number siempre formatea el número.'),
+    currencyDisplay: (0, rules_1.unsupported)('cb-input-number muestra el símbolo de la moneda.'),
+    allowEmpty: (0, rules_1.unsupported)('cb-input-number admite vacío (null) por defecto.'),
+    showClear: (0, rules_1.unsupported)('cb-input-number no tiene botón para limpiar.'),
+    ariaLabel: (0, rules_1.unsupported)('usa el input label de cb-input-number.'),
+    ariaLabelledBy: (0, rules_1.unsupported)('usa el input label de cb-input-number.'),
+    ariaDescribedBy: (0, rules_1.unsupported)('usa los inputs hint/error de cb-input-number.'),
+    ariaRequired: (0, rules_1.unsupported)('usa required.'),
+    title: (0, rules_1.unsupported)(NOT_FORWARDED),
+    autocomplete: (0, rules_1.unsupported)(NOT_FORWARDED),
+    tabindex: (0, rules_1.unsupported)(NOT_FORWARDED),
+    autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+    inputStyle: (0, rules_1.unsupported)('personaliza el campo con los tokens CSS de CaribeNG.'),
+    inputStyleClass: (0, rules_1.unsupported)('personaliza el campo con los tokens CSS de CaribeNG.'),
+    incrementButtonClass: (0, rules_1.unsupported)('cb-input-number usa sus propios botones.'),
+    decrementButtonClass: (0, rules_1.unsupported)('cb-input-number usa sus propios botones.'),
+    incrementButtonIcon: (0, rules_1.unsupported)('cb-input-number usa sus propios botones.'),
+    decrementButtonIcon: (0, rules_1.unsupported)('cb-input-number usa sus propios botones.'),
+    variant: (0, rules_1.unsupported)('cb-input-number no tiene variante "filled".'),
+    fluid: (0, rules_1.unsupported)('cb-input-number ya ocupa todo el ancho de su contenedor.'),
+    '(onInput)': (0, rules_1.unsupported)('escucha (valueChange) o los cambios del control de formulario.'),
+    '(onClear)': (0, rules_1.unsupported)('cb-input-number no tiene botón para limpiar.'),
+    '(onKeyDown)': (0, rules_1.event)('keydown'),
+    ...rules_1.FOCUS_EVENTS,
+};
+exports.inputnumber = {
+    name: 'inputnumber',
+    entry: '@caribeng/ui/input-number',
+    symbol: 'CbInputNumber',
+    modules: {
+        'primeng/inputnumber': { InputNumberModule: 'CbInputNumber', InputNumber: 'CbInputNumber' },
+    },
+    elements: ['p-inputnumber', 'p-inputNumber', 'p-input-number'].map((tag) => ({
+        tag,
+        to: 'cb-input-number',
+        rules,
+        child: (child) => (child.name === 'ng-template' ? { todo: 'cb-input-number usa sus propios iconos; la plantilla no se mostrará.' } : null),
+        same: ['placeholder', 'inputId', 'readonly', 'disabled', 'required', 'invalid', 'showButtons', 'mode', 'currency', 'locale', 'useGrouping', 'prefix', 'suffix'],
+    })),
+};