@caribeng/ui 22.1.1 → 22.4.0

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

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accordion = exports.tabs = void 0;
+const rules_1 = require("./rules");
+/** Hijos que cuentan (sin el espacio en blanco entre etiquetas). */
+function significant(node) {
+    return node.children.filter((child) => child.kind !== 'text' || child.inner.trim() !== '');
+}
+/** `value="0"` / `[value]="0"` → `0`. */
+function valueOf(node) {
+    return node.bindings.find((b) => b.name === 'value' && (b.kind === 'static' || b.kind === 'property'))?.value.trim();
+}
+/** Texto de una cabecera, o `null` si tiene marcado (iconos, badges, bloques). */
+function headerText(node) {
+    const text = node.inner.trim().replace(/\s+/g, ' ');
+    return /[<@]/.test(text) ? null : text;
+}
+/** El primer elemento hijo con uno de estos tags. */
+function childNamed(node, names) {
+    return node.children.find((child) => child.kind === 'element' && names.includes(child.name));
+}
+const NO_ACTIVE = 'cb-tabs no expone la pestaña activa (empieza en la primera).';
+/** Atributos de `p-tabs` / `p-tabView`. */
+function tabsRules(firstValue) {
+    return {
+        value: (binding, el) => {
+            if (!(binding.kind === 'static' && binding.value.trim() === firstValue))
+                el.todos.push(`${binding.source} — ${NO_ACTIVE}`);
+        },
+        activeIndex: (binding, el) => {
+            if (!(binding.kind !== 'event' && binding.value.trim() === '0'))
+                el.todos.push(`${binding.source} — ${NO_ACTIVE}`);
+        },
+        '(valueChange)': (0, rules_1.unsupported)(NO_ACTIVE),
+        '(activeIndexChange)': (0, rules_1.unsupported)(NO_ACTIVE),
+        '(onChange)': (0, rules_1.unsupported)(NO_ACTIVE),
+        '(onClose)': (0, rules_1.unsupported)('las pestañas de cb-tabs no se cierran.'),
+        styleClass: (0, rules_1.styleClass)(),
+        style: (0, rules_1.unsupported)('personaliza las pestañas con los tokens CSS de CaribeNG.'),
+        scrollable: (0, rules_1.drop)(),
+        lazy: (0, rules_1.drop)(),
+        selectOnFocus: (0, rules_1.drop)(),
+        showNavigators: (0, rules_1.drop)(),
+        tabindex: (0, rules_1.drop)(),
+    };
+}
+/** `[disabled]` de la pestaña (p-tab) pasa al cb-tab. */
+function tabPanel(label, disabled) {
+    return {
+        to: 'cb-tab',
+        rules: { value: (0, rules_1.drop)() },
+        finalize: (el) => {
+            el.attrs.unshift((0, rules_1.renderAttr)('static', 'label', label));
+            if (disabled)
+                el.attrs.push(disabled.source);
+        },
+    };
+}
+/**
+ * ```html
+ * <p-tabs value="0">
+ *   <p-tablist><p-tab value="0">Resumen</p-tab><p-tab value="1">Detalle</p-tab></p-tablist>
+ *   <p-tabpanels><p-tabpanel value="0">A</p-tabpanel><p-tabpanel value="1">B</p-tabpanel></p-tabpanels>
+ * </p-tabs>
+ * ```
+ * → `<cb-tabs><cb-tab label="Resumen">A</cb-tab><cb-tab label="Detalle">B</cb-tab></cb-tabs>`
+ */
+function restructureTabs(node, r) {
+    const parts = significant(node);
+    const list = parts.find((p) => p.name === 'p-tablist');
+    const panelsWrapper = parts.find((p) => p.name === 'p-tabpanels');
+    if (!list || !panelsWrapper || parts.length !== 2)
+        return 'p-tabs sin la estructura p-tablist + p-tabpanels; migra a <cb-tabs> con un <cb-tab label="…"> por panel.';
+    const tabs = significant(list);
+    const panels = significant(panelsWrapper);
+    if ([...tabs, ...panels].some((n) => n.kind !== 'element' || !['p-tab', 'p-tabpanel'].includes(n.name))) {
+        return 'las pestañas se generan con @for/@if o tienen elementos extra; migra a <cb-tabs> con un <cb-tab label="…"> por panel.';
+    }
+    const headers = new Map(tabs.map((tab) => [valueOf(tab), tab]));
+    if (headers.has(undefined) || headers.size !== tabs.length || panels.length !== tabs.length) {
+        return 'las pestañas y los paneles no se pueden emparejar por value; migra a <cb-tabs> con un <cb-tab label="…"> por panel.';
+    }
+    const pairs = [];
+    for (const panel of panels) {
+        const tab = headers.get(valueOf(panel));
+        if (!tab)
+            return `el p-tabpanel con value ${valueOf(panel)} no tiene p-tab; migra a <cb-tabs> a mano.`;
+        const label = headerText(tab);
+        if (label === null)
+            return 'una cabecera tiene marcado (icono, badge…) y cb-tab solo admite texto en label; migra a <cb-tabs> a mano.';
+        pairs.push([panel, label, tab.bindings.find((b) => b.name === 'disabled')]);
+    }
+    r.convert(node, { to: 'cb-tabs', rules: tabsRules(valueOf(tabs[0])) });
+    r.remove(list);
+    r.unwrap(panelsWrapper);
+    for (const [panel, label, disabled] of pairs)
+        r.convert(panel, tabPanel(label, disabled));
+    return null;
+}
+const TAB_PANEL_V17 = {
+    header: (0, rules_1.rename)('label'),
+    closable: (0, rules_1.unsupported)('las pestañas de cb-tabs no se cierran.'),
+    leftIcon: (0, rules_1.unsupported)('cb-tab solo admite texto en label.'),
+    rightIcon: (0, rules_1.unsupported)('cb-tab solo admite texto en label.'),
+    tooltip: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+    tooltipPosition: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+    tooltipStyleClass: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+    headerStyle: (0, rules_1.unsupported)('personaliza las pestañas con los tokens CSS de CaribeNG.'),
+    headerStyleClass: (0, rules_1.unsupported)('personaliza las pestañas con los tokens CSS de CaribeNG.'),
+    cache: (0, rules_1.drop)(),
+    selected: (0, rules_1.unsupported)(NO_ACTIVE),
+};
+exports.tabs = {
+    name: 'tabs',
+    entry: '@caribeng/ui/tabs',
+    symbol: 'CbTabs',
+    tags: { 'cb-tab': 'CbTab' },
+    modules: {
+        'primeng/tabs': { TabsModule: 'CbTabs', Tabs: 'CbTabs', TabList: 'CbTabs', TabPanels: 'CbTabs', Tab: 'CbTab', TabPanel: 'CbTab' },
+        // PrimeNG < 18.
+        'primeng/tabview': { TabViewModule: 'CbTabs', TabView: 'CbTabs', TabPanel: 'CbTab' },
+    },
+    elements: [
+        { tag: 'p-tabs', to: 'cb-tabs', rules: {}, restructure: restructureTabs },
+        ...['p-tabView', 'p-tabview'].map((tag) => ({ tag, to: 'cb-tabs', rules: tabsRules() })),
+        {
+            tag: 'p-tabPanel',
+            to: 'cb-tab',
+            symbol: 'CbTab',
+            rules: TAB_PANEL_V17,
+            child: (child) => (child.name === 'ng-template' ? { todo: 'cb-tab solo admite texto en label; la cabecera personalizada no se mostrará.' } : null),
+            same: ['disabled'],
+        },
+    ],
+};
+const NO_OPEN = 'cb-accordion empieza con los paneles cerrados y no expone cuál está abierto.';
+/**
+ * ```html
+ * <p-accordion-panel value="0">
+ *   <p-accordion-header>Envío</p-accordion-header>
+ *   <p-accordion-content>…</p-accordion-content>
+ * </p-accordion-panel>
+ * ```
+ * → `<cb-accordion-panel header="Envío">…</cb-accordion-panel>`
+ */
+function restructurePanel(node, r) {
+    const header = childNamed(node, ['p-accordion-header', 'p-accordionheader']);
+    const content = childNamed(node, ['p-accordion-content', 'p-accordioncontent']);
+    if (!header || !content)
+        return 'panel sin p-accordion-header y p-accordion-content; migra a <cb-accordion-panel header="…"> a mano.';
+    const text = headerText(header);
+    if (text === null)
+        return 'la cabecera tiene marcado (icono, badge…) y cb-accordion-panel solo admite texto en header; migra a mano.';
+    r.convert(node, {
+        to: 'cb-accordion-panel',
+        rules: { value: (0, rules_1.drop)() },
+        finalize: (el) => el.attrs.unshift((0, rules_1.renderAttr)('static', 'header', text)),
+    });
+    r.remove(header);
+    r.unwrap(content);
+    return null;
+}
+exports.accordion = {
+    name: 'accordion',
+    entry: '@caribeng/ui/accordion',
+    symbol: 'CbAccordion',
+    modules: {
+        'primeng/accordion': {
+            AccordionModule: 'CbAccordion',
+            Accordion: 'CbAccordion',
+            AccordionPanel: 'CbAccordionPanel',
+            AccordionHeader: 'CbAccordionPanel',
+            AccordionContent: 'CbAccordionPanel',
+            // PrimeNG < 18.
+            AccordionTab: 'CbAccordionPanel',
+        },
+    },
+    elements: [
+        {
+            tag: 'p-accordion',
+            to: 'cb-accordion',
+            rules: {
+                value: (0, rules_1.unsupported)(NO_OPEN),
+                activeIndex: (0, rules_1.unsupported)(NO_OPEN),
+                '(valueChange)': (0, rules_1.unsupported)(NO_OPEN),
+                '(activeIndexChange)': (0, rules_1.unsupported)(NO_OPEN),
+                '(onOpen)': (0, rules_1.unsupported)(NO_OPEN),
+                '(onClose)': (0, rules_1.unsupported)(NO_OPEN),
+                expandIcon: (0, rules_1.unsupported)('cb-accordion usa su propio icono.'),
+                collapseIcon: (0, rules_1.unsupported)('cb-accordion usa su propio icono.'),
+                styleClass: (0, rules_1.styleClass)(),
+                style: (0, rules_1.unsupported)('personaliza el acordeón con los tokens CSS de CaribeNG.'),
+                selectOnFocus: (0, rules_1.drop)(),
+                transitionOptions: (0, rules_1.drop)(),
+                motionOptions: (0, rules_1.drop)(),
+            },
+            same: ['multiple'],
+        },
+        ...['p-accordion-panel', 'p-accordionpanel'].map((tag) => ({
+            tag,
+            to: 'cb-accordion-panel',
+            symbol: 'CbAccordionPanel',
+            rules: {},
+            restructure: restructurePanel,
+        })),
+        {
+            tag: 'p-accordionTab',
+            to: 'cb-accordion-panel',
+            symbol: 'CbAccordionPanel',
+            rules: {
+                selected: (0, rules_1.unsupported)(NO_OPEN),
+                '(selectedChange)': (0, rules_1.unsupported)(NO_OPEN),
+                headerStyle: (0, rules_1.unsupported)('personaliza el acordeón con los tokens CSS de CaribeNG.'),
+                headerStyleClass: (0, rules_1.unsupported)('personaliza el acordeón con los tokens CSS de CaribeNG.'),
+                contentStyle: (0, rules_1.unsupported)('personaliza el acordeón con los tokens CSS de CaribeNG.'),
+                contentStyleClass: (0, rules_1.unsupported)('personaliza el acordeón con los tokens CSS de CaribeNG.'),
+                cache: (0, rules_1.drop)(),
+                transitionOptions: (0, rules_1.drop)(),
+                iconPos: (0, rules_1.unsupported)('cb-accordion-panel coloca su icono a la derecha.'),
+            },
+            child: (child) => (child.name === 'ng-template' ? { todo: 'cb-accordion-panel solo admite texto en header; la cabecera personalizada no se mostrará.' } : null),
+            same: ['header', 'disabled'],
+        },
+    ],
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tag = void 0;
+const rules_1 = require("./rules");
+/**
+ * `<p-tag value="Nuevo" severity="warn" icon="pi pi-star" [rounded]="true" />`
+ * → `<cb-tag value="Nuevo" severity="warning" icon="star" [rounded]="true" />`
+ */
+exports.tag = {
+    name: 'tag',
+    entry: '@caribeng/ui/tag',
+    symbol: 'CbTag',
+    modules: {
+        'primeng/tag': { TagModule: 'CbTag', Tag: 'CbTag' },
+    },
+    elements: [
+        {
+            tag: 'p-tag',
+            to: 'cb-tag',
+            rules: {
+                severity: (0, rules_1.values)('severity', rules_1.SEVERITY_VALUES),
+                icon: (0, rules_1.iconName)(),
+                styleClass: (0, rules_1.styleClass)(),
+            },
+            child: (child) => (child.name === 'ng-template' ? { todo: 'cb-tag no admite plantilla de icono; usa el input icon.' } : null),
+            same: ['value', 'rounded'],
+        },
+    ],
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textarea = void 0;
+const rules_1 = require("./rules");
+const NOT_FORWARDED = 'el atributo nativo no se reenvía al <textarea> interno de cb-textarea.';
+/**
+ * `<textarea pTextarea id="nota" rows="5" [autoResize]="true" [(ngModel)]="nota"></textarea>`
+ * → `<cb-textarea inputId="nota" [rows]="5" [autoResize]="true" [(ngModel)]="nota" />`
+ */
+exports.textarea = {
+    name: 'textarea',
+    entry: '@caribeng/ui/textarea',
+    symbol: 'CbTextarea',
+    modules: {
+        'primeng/textarea': { TextareaModule: 'CbTextarea', Textarea: 'CbTextarea' },
+        // Nombre anterior a PrimeNG 18.
+        'primeng/inputtextarea': { InputTextareaModule: 'CbTextarea', InputTextarea: 'CbTextarea' },
+    },
+    elements: ['pTextarea', 'pInputTextarea'].map((attr) => ({
+        attr,
+        on: ['textarea'],
+        to: 'cb-textarea',
+        selfClosing: true,
+        rules: {
+            // El id debe llegar al <textarea> interno para que <label for> siga funcionando.
+            id: (0, rules_1.rename)('inputId'),
+            pSize: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+            rows: (0, rules_1.numeric)(),
+            maxlength: (0, rules_1.numeric)(),
+            variant: (0, rules_1.unsupported)('cb-textarea no tiene variante "filled".'),
+            fluid: (0, rules_1.unsupported)('cb-textarea ya ocupa todo el ancho de su contenedor.'),
+            cols: (0, rules_1.unsupported)('cb-textarea ocupa el ancho de su contenedor; ajusta el ancho con CSS.'),
+            minlength: (0, rules_1.unsupported)(NOT_FORWARDED),
+            autocomplete: (0, rules_1.unsupported)(NOT_FORWARDED),
+            spellcheck: (0, rules_1.unsupported)(NOT_FORWARDED),
+            autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+            'aria-label': (0, rules_1.unsupported)('usa el input label de cb-textarea; el aria-label del host no llega al <textarea> interno.'),
+            '(onResize)': (0, rules_1.unsupported)('cb-textarea no emite el cambio de tamaño.'),
+            '(focus)': (0, rules_1.event)('focusin'),
+            '(blur)': (0, rules_1.event)('focusout'),
+        },
+        same: ['autoResize', 'placeholder', 'readonly', 'required', 'disabled', 'invalid', 'value'],
+    })),
+};

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

@@ -0,0 +1,173 @@
+"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.toast = void 0;
+const ts = __importStar(require("typescript"));
+const rules_1 = require("./rules");
+const service_calls_1 = require("./service-calls");
+const POSITIONS = ['top-right', 'top-left', 'top-center', 'bottom-right', 'bottom-left', 'bottom-center'];
+/** Severidades de los mensajes de PrimeNG → CbSeverity. */
+const MESSAGE_SEVERITY = { warn: 'warning', error: 'danger' };
+/** Propiedades de un mensaje de PrimeNG sin equivalente en CbToastOptions. */
+const DROPPED_FIELDS = new Set(['key', 'icon', 'data', 'id', 'styleClass', 'contentStyleClass', 'closeIcon', 'text']);
+/**
+ * `{ severity: 'error', summary, sticky: true, key: 'x' }`
+ * → `{ severity: 'danger', summary, life: 0 }`. Devuelve el texto nuevo (o
+ * `null` si no cambia) y los avisos.
+ */
+function rewriteMessage(sf, message, todos) {
+    let changed = false;
+    const hasLife = message.properties.some((p) => (0, service_calls_1.propertyName)(p) === 'life');
+    const dropped = [];
+    const properties = [];
+    for (const property of message.properties) {
+        const name = (0, service_calls_1.propertyName)(property);
+        const text = property.getText(sf);
+        if (name && DROPPED_FIELDS.has(name)) {
+            dropped.push(text);
+            changed = true;
+            continue;
+        }
+        if (name === 'severity' && ts.isPropertyAssignment(property)) {
+            const value = property.initializer;
+            if (ts.isStringLiteralLike(value)) {
+                const mapped = MESSAGE_SEVERITY[value.text];
+                if (mapped) {
+                    const quote = sf.text[value.getStart(sf)];
+                    properties.push(`${property.name.getText(sf)}: ${quote}${mapped}${quote}`);
+                    changed = true;
+                    continue;
+                }
+            }
+            else {
+                todos.push(`severity con expresión: CaribeNG usa 'warning' y 'danger' en vez de 'warn' y 'error'.`);
+            }
+        }
+        if (name === 'sticky' && ts.isPropertyAssignment(property)) {
+            changed = true;
+            const value = property.initializer;
+            if (value.kind === ts.SyntaxKind.FalseKeyword)
+                continue;
+            if (hasLife) {
+                todos.push(`${text} — en CaribeNG un mensaje fijo es life: 0; revisa el life de este mensaje.`);
+                continue;
+            }
+            properties.push(value.kind === ts.SyntaxKind.TrueKeyword ? 'life: 0' : `life: (${value.getText(sf)}) ? 0 : 3000`);
+            continue;
+        }
+        properties.push(text);
+    }
+    if (dropped.length)
+        todos.push(`${dropped.join(', ')} — CbToastService no tiene estos campos.`);
+    if (!changed)
+        return null;
+    return (0, service_calls_1.rebuildObject)(sf, message, properties);
+}
+/**
+ * Llamadas a `MessageService` → `CbToastService`: traduce las severidades
+ * (`warn` → `warning`, `error` → `danger`), `sticky` → `life: 0`, y marca
+ * `key`, `addAll()` y los observables, que no tienen equivalente.
+ */
+const rewriteMessageService = (sf, { locals }, edits) => {
+    const local = locals.get('MessageService');
+    if (!local)
+        return;
+    (0, service_calls_1.forEachServiceCall)(sf, local, (method, access, call) => {
+        const todos = [];
+        if (method === 'add' && call) {
+            const [message] = call.arguments;
+            if (message && ts.isObjectLiteralExpression(message)) {
+                const rewritten = rewriteMessage(sf, message, todos);
+                if (rewritten !== null)
+                    edits.push({ start: message.getStart(sf), end: message.getEnd(), text: rewritten });
+            }
+            else if (message) {
+                todos.push(`mensaje no literal: CaribeNG usa severity 'warning'/'danger' (no 'warn'/'error') y life: 0 en vez de sticky.`);
+            }
+        }
+        else if (method === 'addAll') {
+            todos.push('CbToastService no tiene addAll(); llama a add() por cada mensaje.');
+        }
+        else if (method === 'clear' && call?.arguments.length) {
+            const args = call.arguments;
+            edits.push({ start: args[0].getStart(sf), end: args[args.length - 1].getEnd(), text: '' });
+            todos.push('cb-toast no tiene key: clear() cierra todos los mensajes.');
+        }
+        else if (method === 'messageObserver' || method === 'clearObserver') {
+            todos.push(`CbToastService no expone ${method}; usa su señal toasts().`);
+        }
+        if (todos.length)
+            edits.push((0, service_calls_1.todoBefore)(sf, call ?? access, todos));
+    });
+};
+/**
+ * `<p-toast position="bottom-center" />` → `<cb-toast position="bottom-center" />`
+ * y `MessageService` (primeng/api) → `CbToastService`.
+ */
+exports.toast = {
+    name: 'toast',
+    entry: '@caribeng/ui/toast',
+    symbol: 'CbToast',
+    modules: {
+        'primeng/toast': { ToastModule: 'CbToast', Toast: 'CbToast' },
+        'primeng/api': { MessageService: 'CbToastService' },
+    },
+    rootServices: ['CbToastService'],
+    rewriteSource: rewriteMessageService,
+    elements: [
+        {
+            tag: 'p-toast',
+            to: 'cb-toast',
+            rules: {
+                position: (0, rules_1.values)('position', Object.fromEntries(POSITIONS.map((p) => [p, p]))),
+                key: (0, rules_1.unsupported)('cb-toast muestra todos los mensajes de CbToastService; si tenías varios p-toast con key, deja uno.'),
+                life: (0, rules_1.unsupported)('indica life en cada mensaje (CbToastService.add).'),
+                preventOpenDuplicates: (0, rules_1.unsupported)('cb-toast no filtra mensajes duplicados.'),
+                preventDuplicates: (0, rules_1.unsupported)('cb-toast no filtra mensajes duplicados.'),
+                styleClass: (0, rules_1.styleClass)(),
+                autoZIndex: (0, rules_1.drop)(),
+                baseZIndex: (0, rules_1.drop)(),
+                showTransformOptions: (0, rules_1.drop)(),
+                hideTransformOptions: (0, rules_1.drop)(),
+                showTransitionOptions: (0, rules_1.drop)(),
+                hideTransitionOptions: (0, rules_1.drop)(),
+                motionOptions: (0, rules_1.drop)(),
+                breakpoints: (0, rules_1.drop)(),
+                '(onClose)': (0, rules_1.unsupported)('cb-toast no emite el cierre de los mensajes.'),
+            },
+            child: (child) => (child.name === 'ng-template' ? { todo: 'cb-toast no admite plantillas de mensaje; el contenido no se mostrará.' } : null),
+        },
+    ],
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleswitch = void 0;
+const rules_1 = require("./rules");
+/**
+ * `<p-toggleswitch [(ngModel)]="activo" inputId="activo" (onChange)="guardar($event.checked)" />`
+ * → `<cb-toggle [(ngModel)]="activo" inputId="activo" (changed)="guardar($event)" />`
+ */
+const rules = {
+    size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    styleClass: (0, rules_1.styleClass)(),
+    readonly: (0, rules_1.unsupported)('usa disabled o deshabilita el control de formulario.'),
+    trueValue: (0, rules_1.unsupported)('cb-toggle usa true/false; convierte el valor en el modelo.'),
+    falseValue: (0, rules_1.unsupported)('cb-toggle usa true/false; convierte el valor en el modelo.'),
+    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.'),
+    ariaLabelledBy: (0, rules_1.unsupported)('usa ariaLabel o el input label de cb-toggle.'),
+    '(onChange)': (0, rules_1.event)('changed', (0, rules_1.adaptEvent)('checked')),
+    ...rules_1.FOCUS_EVENTS,
+};
+exports.toggleswitch = {
+    name: 'toggleswitch',
+    entry: '@caribeng/ui/toggle',
+    symbol: 'CbToggle',
+    modules: {
+        'primeng/toggleswitch': { ToggleSwitchModule: 'CbToggle', ToggleSwitch: 'CbToggle' },
+        // Nombre anterior a PrimeNG 18.
+        'primeng/inputswitch': { InputSwitchModule: 'CbToggle', InputSwitch: 'CbToggle' },
+    },
+    elements: ['p-toggleswitch', 'p-toggleSwitch', 'p-toggle-switch', 'p-inputSwitch', 'p-inputswitch'].map((tag) => ({
+        tag,
+        to: 'cb-toggle',
+        rules,
+        child: (child) => (child.name === 'ng-template' ? { todo: 'cb-toggle no admite plantilla para el tirador.' } : null),
+        same: ['inputId', 'ariaLabel', 'disabled', 'invalid', 'label'],
+    })),
+};

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tooltip = void 0;
+const rules_1 = require("./rules");
+const NO_TIMING = 'cbTooltip usa sus propios tiempos de aparición.';
+/**
+ * `<span pTooltip="Ayuda" tooltipPosition="bottom">` → `<span cbTooltip="Ayuda" cbTooltipPosition="bottom">`.
+ * Funciona en cualquier elemento, también sobre componentes que se migran a la vez (`<p-button pTooltip>`).
+ */
+exports.tooltip = {
+    name: 'tooltip',
+    entry: '@caribeng/ui/tooltip',
+    symbol: 'CbTooltipDirective',
+    modules: {
+        'primeng/tooltip': { TooltipModule: 'CbTooltipDirective', Tooltip: 'CbTooltipDirective' },
+    },
+    elements: [],
+    directives: [
+        {
+            attr: 'pTooltip',
+            to: 'cbTooltip',
+            rules: {
+                tooltipPosition: (0, rules_1.values)('cbTooltipPosition', { top: 'top', bottom: 'bottom', left: 'left', right: 'right' }),
+                tooltipDisabled: (0, rules_1.rename)('cbTooltipDisabled'),
+                appendTo: (0, rules_1.drop)(),
+                tooltipZIndex: (0, rules_1.drop)(),
+                tooltipEvent: (0, rules_1.unsupported)('cbTooltip se muestra con hover y con foco.'),
+                positionStyle: (0, rules_1.unsupported)('cbTooltip se posiciona con el overlay del CDK.'),
+                positionTop: (0, rules_1.unsupported)('cbTooltip se posiciona con el overlay del CDK.'),
+                positionLeft: (0, rules_1.unsupported)('cbTooltip se posiciona con el overlay del CDK.'),
+                tooltipStyleClass: (0, rules_1.unsupported)('personaliza el tooltip con los tokens CSS de CaribeNG.'),
+                escape: (0, rules_1.unsupported)('cbTooltip muestra solo texto (siempre escapado).'),
+                showDelay: (0, rules_1.unsupported)(NO_TIMING),
+                hideDelay: (0, rules_1.unsupported)(NO_TIMING),
+                life: (0, rules_1.unsupported)(NO_TIMING),
+                autoHide: (0, rules_1.unsupported)(NO_TIMING),
+                fitContent: (0, rules_1.unsupported)('cbTooltip ajusta su ancho al texto.'),
+                hideOnEscape: (0, rules_1.drop)(),
+                showOnEllipsis: (0, rules_1.unsupported)('cbTooltip se muestra siempre que tenga texto.'),
+                tooltipOptions: (0, rules_1.unsupported)('pasa cada opción como input de cbTooltip.'),
+            },
+        },
+    ],
+};

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

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Tipos de los mapeos PrimeNG → CaribeNG.
+ *
+ * Cada componente se describe con datos (qué módulos/símbolos importa PrimeNG,
+ * qué selector usa y cómo se traduce cada input/output). El motor de
+ * plantillas (`../template.ts`) y el de TypeScript (`../typescript.ts`) solo
+ * aplican estos datos: añadir un componente no exige tocar los motores.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REPORT_PATH = void 0;
+exports.scanWorkspace = scanWorkspace;
+exports.renderReport = renderReport;
+const template_1 = require("./template");
+const workspace_1 = require("./workspace");
+/** Archivo del informe en la raíz del workspace. */
+exports.REPORT_PATH = '/caribeng-migration-report.md';
+const SCANNED = /\.(ts|mts|js|mjs|html|css|scss|sass|less|json)$/;
+const SKIPPED = new Set(['package.json', 'package-lock.json', 'npm-shrinkwrap.json', 'yarn.lock', 'pnpm-lock.yaml', 'bun.lock']);
+/** Referencias a paquetes del ecosistema PrimeNG. */
+const PRIME_PACKAGE = /primeng|primeicons|@primeuix|tailwindcss-primeui|primelocale/;
+/** Selectores PrimeNG en plantillas: `<p-table`, `pTooltip`, `pi pi-…`. */
+const PRIME_TEMPLATE = /<p-[a-z]|\sp[A-Z][A-Za-z]+(?=[\s=>/])|\bpi pi-/;
+/** Busca avisos y restos de PrimeNG en todo el workspace. */
+function scanWorkspace(tree) {
+    const todos = [];
+    const leftovers = [];
+    for (const path of (0, workspace_1.workspaceFiles)(tree)) {
+        const name = path.slice(path.lastIndexOf('/') + 1);
+        if (!SCANNED.test(path) || SKIPPED.has(name) || path === exports.REPORT_PATH)
+            continue;
+        const template = /\.(html|ts)$/.test(path);
+        tree
+            .readText(path)
+            .split(/\r?\n/)
+            .forEach((line, i) => {
+            const at = line.indexOf(template_1.TODO_MARK);
+            if (at >= 0) {
+                // Hasta el cierre del comentario: en TypeScript puede seguir código en la misma línea.
+                const message = line.slice(at + template_1.TODO_MARK.length + 1).replace(/\s*(-->|\*\/)[\s\S]*$/, '').trim();
+                todos.push({ path, line: i + 1, text: message });
+                return;
+            }
+            if (PRIME_PACKAGE.test(line) || (template && PRIME_TEMPLATE.test(line)))
+                leftovers.push({ path, line: i + 1, text: line.trim() });
+        });
+    }
+    return { todos, leftovers };
+}
+/** Informe en Markdown con lo migrado y lo que queda por revisar. */
+function renderReport({ scan, changedFiles, manual, removedPackages }) {
+    const lines = ['# Migración de PrimeNG a CaribeNG', ''];
+    lines.push(`- Archivos modificados: **${changedFiles.length}**`);
+    lines.push(`- Avisos para revisar (\`${template_1.TODO_MARK}\`): **${scan.todos.length}**`);
+    lines.push(`- Referencias a PrimeNG sin migrar: **${scan.leftovers.length}**`);
+    lines.push(removedPackages.length
+        ? `- Paquetes eliminados de package.json: ${removedPackages.map((p) => `\`${p}\``).join(', ')}`
+        : '- PrimeNG sigue en package.json mientras queden referencias (las dos librerías pueden convivir).');
+    lines.push('');
+    const section = (title, intro, findings) => {
+        if (!findings.length)
+            return;
+        lines.push(`## ${title}`, '', intro);
+        let current = '';
+        for (const finding of findings) {
+            if (finding.path !== current) {
+                current = finding.path;
+                lines.push('', `### \`${finding.path.slice(1)}\``, '');
+            }
+            lines.push(`- Línea ${finding.line}: ${finding.text.replace(/\|/g, '\\|')}`);
+        }
+        lines.push('');
+    };
+    section('Avisos', `El migrador dejó un comentario \`${template_1.TODO_MARK}\` en cada punto que necesita una decisión. Bórralo cuando lo resuelvas.`, scan.todos);
+    section('Referencias a PrimeNG pendientes', 'Componentes, directivas o imports que esta versión del migrador aún no traduce. Migra estos usos a mano (consulta el catálogo de CaribeNG).', scan.leftovers);
+    if (manual.length) {
+        lines.push('## Imports que añadir a mano', '', ...manual.map((item) => `- ${item}`), '');
+    }
+    lines.push('## Siguientes pasos', '');
+    lines.push('1. Revisa los cambios con `git diff`.');
+    lines.push('2. Resuelve los avisos y las referencias pendientes de este informe.');
+    lines.push('3. Compila (`ng build`) y ejecuta los tests.');
+    if (!removedPackages.length)
+        lines.push('4. Cuando no queden referencias, vuelve a ejecutar el migrador o quita `primeng` y `primeicons` de package.json.');
+    lines.push('');
+    return lines.join('\n');
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });