@caribeng/ui 22.1.1 → 22.4.0

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FOCUS_EVENTS = exports.iconName = exports.SEVERITY_VALUES = exports.SIZE_VALUES = exports.styleClass = exports.adaptEvent = exports.numeric = exports.event = exports.flagToValue = exports.values = exports.unsupported = exports.drop = exports.rename = void 0;
+exports.renderAttr = renderAttr;
+exports.staticBoolean = staticBoolean;
+exports.escapeText = escapeText;
+exports.templateName = templateName;
+exports.slotChild = slotChild;
+const icons_1 = require("../icons");
+/** Escribe un atributo de plantilla con la sintaxis de su tipo. */
+function renderAttr(kind, name, value, bare = false) {
+    const key = kind === 'property' ? `[${name}]` : kind === 'twoWay' ? `[(${name})]` : kind === 'event' ? `(${name})` : name;
+    if (kind === 'static' && bare)
+        return key;
+    const quote = value.includes('"') ? "'" : '"';
+    return `${key}=${quote}${value}${quote}`;
+}
+/** Valor booleano de un atributo estático (`outlined`, `outlined="true"` → true). `null` si es una expresión. */
+function staticBoolean(binding) {
+    if (binding.kind === 'static')
+        return binding.value !== 'false';
+    const value = binding.value.trim();
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    return null;
+}
+/** Texto plano listo para usarse como contenido de una plantilla Angular. */
+function escapeText(text) {
+    return text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/\{/g, '&#123;')
+        .replace(/\}/g, '&#125;')
+        .replace(/@/g, '&#64;');
+}
+/** El input/output existe con otro nombre. */
+const rename = (to) => (binding, el) => el.attrs.push(renderAttr(binding.kind, to, binding.value, binding.bare));
+exports.rename = rename;
+/** Se elimina sin aviso: no tiene efecto en CaribeNG (p. ej. `appendTo`, que resuelve el overlay del CDK). */
+const drop = () => () => undefined;
+exports.drop = drop;
+/** Sin equivalente: se elimina y se deja un aviso con el atributo original para no perder información. */
+const unsupported = (why) => (binding, el) => el.todos.push(`${binding.source} — ${why}`);
+exports.unsupported = unsupported;
+/**
+ * El input existe pero sus valores cambian (`small` → `sm`). Los valores
+ * estáticos se traducen; las expresiones se conservan con un aviso.
+ */
+const values = (to, map) => (binding, el) => {
+    if (binding.kind === 'static') {
+        const mapped = map[binding.value];
+        if (mapped !== undefined) {
+            el.attrs.push(renderAttr('static', to, mapped));
+        }
+        else {
+            el.attrs.push(renderAttr('static', to, binding.value, binding.bare));
+            el.todos.push(`${binding.source} — valor sin equivalente conocido en ${el.tag}.`);
+        }
+        return;
+    }
+    el.attrs.push(renderAttr(binding.kind, to, binding.value));
+    const table = Object.entries(map)
+        .filter(([from, mapped]) => from !== mapped)
+        .map(([from, mapped]) => `'${from}' → '${mapped}'`)
+        .join(', ');
+    if (table)
+        el.todos.push(`${binding.source} — revisa los valores de la expresión: ${table}.`);
+};
+exports.values = values;
+/**
+ * Un booleano de PrimeNG (`outlined`, `text`) se convierte en un valor de un
+ * input de CaribeNG (`variant="outlined"`). Con una expresión se escribe un
+ * ternario con el valor por defecto.
+ */
+const flagToValue = (to, value, otherwise) => (binding, el) => {
+    if (el.attrs.some((attr) => attr.startsWith(`${to}=`) || attr.startsWith(`[${to}]=`))) {
+        el.todos.push(`${binding.source} — ya hay otro ${to}; revisa cuál aplica.`);
+        return;
+    }
+    const flag = staticBoolean(binding);
+    if (flag === true)
+        el.attrs.push(renderAttr('static', to, value));
+    else if (flag === null)
+        el.attrs.push(renderAttr('property', to, `(${binding.value}) ? '${value}' : '${otherwise}'`));
+};
+exports.flagToValue = flagToValue;
+/**
+ * Un output con otro nombre. `adapt` traduce la expresión cuando cambia el
+ * payload; si devuelve `null` se conserva el output con un aviso.
+ */
+const event = (to, adapt) => (binding, el) => {
+    if (!adapt) {
+        el.attrs.push(renderAttr('event', to, binding.value));
+        return;
+    }
+    const adapted = adapt(binding.value);
+    if (adapted !== null) {
+        el.attrs.push(renderAttr('event', to, adapted));
+    }
+    else {
+        el.attrs.push(renderAttr('event', to, binding.value));
+        el.todos.push(`${binding.source} — el evento ahora es (${to}) y su $event es distinto; revisa el manejador.`);
+    }
+};
+exports.event = event;
+/**
+ * Input numérico de CaribeNG (`input<number>` sin transform). Con
+ * strictTemplates un atributo estático (`rows="5"`) es un string y no compila:
+ * se escribe como binding (`[rows]="5"`).
+ */
+const numeric = (to) => (binding, el) => {
+    const name = to ?? binding.name;
+    if (binding.kind !== 'static') {
+        el.attrs.push(renderAttr(binding.kind, name, binding.value));
+    }
+    else if (/^-?\d+(\.\d+)?$/.test(binding.value.trim())) {
+        el.attrs.push(renderAttr('property', name, binding.value.trim()));
+    }
+    else {
+        el.attrs.push(renderAttr('static', name, binding.value, binding.bare));
+        el.todos.push(`${binding.source} — ${name} es numérico en ${el.tag}; usa [${name}]="…".`);
+    }
+};
+exports.numeric = numeric;
+/**
+ * Adaptador para `event()`: PrimeNG envuelve el valor en `$event.<campo>`
+ * (`{ value, originalEvent }`, `{ checked, originalEvent }`) y CaribeNG emite
+ * el valor directamente. `$event.value` → `$event`; cualquier otro uso de
+ * `$event` devuelve `null` (se deja un aviso).
+ */
+const adaptEvent = (field) => (expression) => {
+    const property = new RegExp(`\\$event\\.${field}\\b`, 'g');
+    const other = new RegExp(`\\$event\\b(?!\\.${field}\\b)`);
+    return other.test(expression) ? null : expression.replace(property, '$event');
+};
+exports.adaptEvent = adaptEvent;
+/** `styleClass` → `class` en el host (CaribeNG aplica las clases del host). */
+const styleClass = () => (0, exports.rename)('class');
+exports.styleClass = styleClass;
+/** Tamaños de PrimeNG (`small`/`large`) a los de CaribeNG (`sm`/`lg`). */
+exports.SIZE_VALUES = { small: 'sm', large: 'lg' };
+/** Severidades de PrimeNG a las de CaribeNG (solo cambia `warn`). */
+exports.SEVERITY_VALUES = {
+    primary: 'primary',
+    secondary: 'secondary',
+    success: 'success',
+    info: 'info',
+    warn: 'warning',
+    danger: 'danger',
+    help: 'help',
+    contrast: 'contrast',
+};
+/**
+ * `icon="pi pi-check"` → `icon="check"` en componentes CaribeNG cuyo input
+ * `icon` recibe el nombre del icono (Tag…).
+ */
+const iconName = (to = 'icon') => (binding, el) => {
+    const parsed = binding.kind === 'static' ? (0, icons_1.parsePrimeIcon)(binding.value) : null;
+    if (parsed?.name) {
+        el.attrs.push(renderAttr('static', to, parsed.name));
+        el.icons.add(parsed.name);
+    }
+    else if (binding.kind === 'static') {
+        el.todos.push(`${binding.source} — ${parsed ? `pi-${parsed.prime} no tiene equivalente conocido` : 'icono que no es de PrimeIcons'}; usa un nombre de @caribeng/ui/icon.`);
+    }
+    else {
+        el.attrs.push(renderAttr(binding.kind, to, binding.value));
+        el.todos.push(`${binding.source} — ${to} recibe el nombre de un icono de CaribeNG ("check"), no clases "pi pi-check".`);
+    }
+};
+exports.iconName = iconName;
+/** Nombre de la plantilla PrimeNG de un hijo (`#footer` o `pTemplate="footer"`). */
+function templateName(child) {
+    if (child.name !== 'ng-template')
+        return undefined;
+    return child.references[0] ?? child.bindings.find((b) => b.kind === 'static' && b.name === 'pTemplate')?.value;
+}
+/**
+ * Hijos de los componentes con pie y contenido proyectado (Dialog, Card):
+ * `#footer`/`<p-footer>` pasan al slot `[footerAttr]`, `#content` se desenvuelve
+ * y el resto de plantillas se marca con un aviso.
+ */
+function slotChild(tag, footerAttr, others) {
+    return (child) => {
+        if (child.name === 'p-footer')
+            return { tag: 'div', attrs: [footerAttr] };
+        if (child.name === 'p-header')
+            return { todo: others['header'] ?? `${tag} no tiene cabecera personalizada.` };
+        const name = templateName(child);
+        if (!name)
+            return null;
+        if (name === 'footer')
+            return { tag: 'div', attrs: [footerAttr] };
+        if (name === 'content')
+            return { tag: 'ng-container', attrs: [] };
+        return { todo: others[name] ?? `${tag} no tiene la plantilla "${name}"; pon el contenido directamente dentro de ${tag}.` };
+    };
+}
+/** Outputs de foco: los de PrimeNG pasan a los eventos nativos que burbujean hasta el host. */
+exports.FOCUS_EVENTS = {
+    '(onFocus)': (0, exports.event)('focusin'),
+    '(onBlur)': (0, exports.event)('focusout'),
+};

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.select = exports.selectChild = exports.selectSame = exports.selectRules = void 0;
+const rules_1 = require("./rules");
+const NO_TEMPLATES = 'cb-select no admite plantillas personalizadas; este contenido no se mostrará.';
+/**
+ * `<p-select [options]="ciudades" optionLabel="nombre" [(ngModel)]="ciudad" size="small" />`
+ * → `<cb-select [options]="ciudades" optionLabel="nombre" [(ngModel)]="ciudad" size="sm" />`
+ */
+exports.selectRules = {
+    size: (0, rules_1.values)('size', rules_1.SIZE_VALUES),
+    virtualScrollItemSize: (0, rules_1.numeric)(),
+    styleClass: (0, rules_1.styleClass)(),
+    emptyFilterMessage: (binding, el) => {
+        if (el.find('emptyMessage'))
+            el.todos.push(`${binding.source} — cb-select usa un solo mensaje (emptyMessage).`);
+        else
+            (0, rules_1.rename)('emptyMessage')(binding, el);
+    },
+    // cb-select abre su panel con el overlay del CDK: no hace falta.
+    appendTo: (0, rules_1.drop)(),
+    autoZIndex: (0, rules_1.drop)(),
+    baseZIndex: (0, rules_1.drop)(),
+    panelStyle: (0, rules_1.unsupported)('personaliza el panel con los tokens CSS de cb-select.'),
+    panelStyleClass: (0, rules_1.unsupported)('personaliza el panel con los tokens CSS de cb-select.'),
+    editable: (0, rules_1.unsupported)('cb-select no es editable; usa <cb-autocomplete>.'),
+    filterBy: (0, rules_1.unsupported)('cb-select filtra por optionLabel.'),
+    filterFields: (0, rules_1.unsupported)('cb-select filtra por optionLabel.'),
+    filterMatchMode: (0, rules_1.unsupported)('cb-select filtra por "contiene".'),
+    filterLocale: (0, rules_1.unsupported)('cb-select usa el idioma de provideCaribeNG().'),
+    resetFilterOnHide: (0, rules_1.unsupported)('cb-select limpia el filtro al cerrar.'),
+    dataKey: (0, rules_1.unsupported)('cb-select compara los valores con ===.'),
+    lazy: (0, rules_1.unsupported)('cb-select no tiene carga diferida; carga las opciones antes.'),
+    loading: (0, rules_1.unsupported)('cb-select no tiene estado de carga.'),
+    loadingIcon: (0, rules_1.unsupported)('cb-select no tiene estado de carga.'),
+    dropdownIcon: (0, rules_1.unsupported)('cb-select usa su propio icono.'),
+    checkmark: (0, rules_1.unsupported)('cb-select marca la opción elegida por defecto.'),
+    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.'),
+    tooltipPositionStyle: (0, rules_1.unsupported)('usa la directiva cbTooltip de @caribeng/ui/tooltip.'),
+    overlayOptions: (0, rules_1.unsupported)('cb-select gestiona su overlay.'),
+    virtualScrollOptions: (0, rules_1.unsupported)('usa virtualScroll y virtualScrollItemSize.'),
+    autofocus: (0, rules_1.unsupported)('usa la directiva cbAutoFocus de @caribeng/ui/autofocus.'),
+    autofocusFilter: (0, rules_1.unsupported)('el filtro recibe el foco al abrir.'),
+    tabindex: (0, rules_1.unsupported)('el tabindex no se reenvía al control interno.'),
+    readonly: (0, rules_1.unsupported)('usa disabled o deshabilita el control de formulario.'),
+    focusOnHover: (0, rules_1.drop)(),
+    selectOnFocus: (0, rules_1.unsupported)('cb-select solo selecciona al confirmar.'),
+    autoOptionFocus: (0, rules_1.drop)(),
+    variant: (0, rules_1.unsupported)('cb-select no tiene variante "filled".'),
+    fluid: (0, rules_1.unsupported)('cb-select ya ocupa todo el ancho de su contenedor.'),
+    ariaFilterLabel: (0, rules_1.unsupported)('el filtro usa filterPlaceholder como nombre accesible.'),
+    '(onChange)': (0, rules_1.event)('valueChange', (0, rules_1.adaptEvent)('value')),
+    ...rules_1.FOCUS_EVENTS,
+    '(onShow)': (0, rules_1.unsupported)('cb-select no emite la apertura del panel.'),
+    '(onHide)': (0, rules_1.unsupported)('cb-select no emite el cierre del panel.'),
+    '(onClear)': (0, rules_1.unsupported)('escucha (valueChange) y comprueba el valor null.'),
+    '(onFilter)': (0, rules_1.unsupported)('cb-select no emite el texto del filtro.'),
+    '(onClick)': (0, rules_1.unsupported)('usa (click) en el host.'),
+    '(onLazyLoad)': (0, rules_1.unsupported)('cb-select no tiene carga diferida.'),
+};
+exports.selectSame = [
+    'options',
+    'optionLabel',
+    'optionValue',
+    'optionDisabled',
+    'group',
+    'optionGroupLabel',
+    'optionGroupChildren',
+    'placeholder',
+    'filter',
+    'filterPlaceholder',
+    'emptyMessage',
+    'showClear',
+    'scrollHeight',
+    'virtualScroll',
+    'invalid',
+    'disabled',
+    'inputId',
+    'ariaLabel',
+    'ariaLabelledBy',
+];
+/** Las plantillas de PrimeNG (`#item`, `#selectedItem`…) no tienen equivalente. */
+const selectChild = (element) => (element.name === 'ng-template' ? { todo: NO_TEMPLATES } : null);
+exports.selectChild = selectChild;
+exports.select = {
+    name: 'select',
+    entry: '@caribeng/ui/select',
+    symbol: 'CbSelect',
+    modules: {
+        'primeng/select': { SelectModule: 'CbSelect', Select: 'CbSelect' },
+        // Nombre anterior a PrimeNG 18.
+        'primeng/dropdown': { DropdownModule: 'CbSelect', Dropdown: 'CbSelect' },
+    },
+    elements: ['p-select', 'p-dropdown'].map((tag) => ({ tag, to: 'cb-select', rules: exports.selectRules, child: exports.selectChild, same: exports.selectSame })),
+};

package/schematics/migrate-from-primeng/mappings/service-calls.js

@@ -0,0 +1,100 @@
+"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.forEachServiceCall = forEachServiceCall;
+exports.propertyName = propertyName;
+exports.rebuildObject = rebuildObject;
+exports.todoBefore = todoBefore;
+const ts = __importStar(require("typescript"));
+const todo_1 = require("../todo");
+/** El tipo es una referencia a `local` (`ms: MessageService`). */
+function isTypeOf(type, local) {
+    return !!type && ts.isTypeReferenceNode(type) && ts.isIdentifier(type.typeName) && type.typeName.text === local;
+}
+/** `inject(MessageService)`. */
+function isInjectOf(expression, local) {
+    return (!!expression &&
+        ts.isCallExpression(expression) &&
+        ts.isIdentifier(expression.expression) &&
+        expression.expression.text === 'inject' &&
+        expression.arguments.some((arg) => ts.isIdentifier(arg) && arg.text === local));
+}
+/**
+ * Recorre los usos de un servicio PrimeNG en el archivo: propiedades,
+ * parámetros y variables tipadas con él o creadas con `inject(Servicio)`, y
+ * llama a `visit` por cada acceso `this.ms.metodo` / `ms.metodo`.
+ */
+function forEachServiceCall(sf, local, visit) {
+    const receivers = new Set();
+    const collect = (node) => {
+        if ((ts.isPropertyDeclaration(node) || ts.isParameter(node) || ts.isVariableDeclaration(node)) && ts.isIdentifier(node.name)) {
+            if (isTypeOf(node.type, local) || isInjectOf(node.initializer, local))
+                receivers.add(node.name.text);
+        }
+        ts.forEachChild(node, collect);
+    };
+    collect(sf);
+    if (!receivers.size)
+        return;
+    const isReceiver = (expression) => (ts.isIdentifier(expression) && receivers.has(expression.text)) ||
+        (ts.isPropertyAccessExpression(expression) && expression.expression.kind === ts.SyntaxKind.ThisKeyword && receivers.has(expression.name.text));
+    const walk = (node) => {
+        if (ts.isPropertyAccessExpression(node) && isReceiver(node.expression)) {
+            const call = ts.isCallExpression(node.parent) && node.parent.expression === node ? node.parent : undefined;
+            visit(node.name.text, node, call);
+        }
+        ts.forEachChild(node, walk);
+    };
+    walk(sf);
+}
+/** Nombre de una propiedad de un objeto literal (`severity`, `'severity'`). */
+function propertyName(property) {
+    return property.name && (ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) ? property.name.text : undefined;
+}
+/** Reescribe un objeto literal con estas propiedades, conservando si estaba en una línea o en varias. */
+function rebuildObject(sf, object, properties) {
+    if (!object.getText(sf).includes('\n'))
+        return properties.length ? `{ ${properties.join(', ')} }` : '{}';
+    const first = object.properties[0];
+    const indent = /[ \t]*$/.exec(sf.text.slice(0, first.getStart(sf)))?.[0] ?? '  ';
+    const closing = /[ \t]*$/.exec(sf.text.slice(0, object.getEnd() - 1))?.[0] ?? '';
+    const eol = sf.text.includes('\r\n') ? '\r\n' : '\n';
+    return `{${eol}${properties.map((p) => indent + p).join(`,${eol}`)},${eol}${closing}}`;
+}
+/** Comentarios `TODO(caribeng)` justo antes de `node`. */
+function todoBefore(sf, node, messages) {
+    const start = node.getStart(sf);
+    return { start, end: start, text: messages.map((m) => `/* ${todo_1.TODO_MARK}: ${m} */ `).join('') };
+}