@neural-ui/core 1.2.1 → 1.3.1

package/types/neural-ui-core-toggle-button-group.d.ts

@@ -0,0 +1,63 @@
+import * as _angular_core from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { NeuButtonSize } from '@neural-ui/core/button';
+
+interface NeuToggleOption<T = unknown> {
+    /** Texto visible del botón / Visible button text */
+    label: string;
+    /** Valor asociado a esta opción / Value associated with this option */
+    value: T;
+    /** Nombre de icono Lucide (opcional) / Lucide icon name (optional) */
+    icon?: string;
+    /** Deshabilita solo esta opción / Disables this option only */
+    disabled?: boolean;
+}
+/**
+ * NeuralUI ToggleButtonGroup Component
+ *
+ * Grupo de botones de selección (single o múltiple). / Selection button group (single or multiple).
+ * Selector segmentado para selección única o múltiple. / Segmented selector for single or multiple selection.
+ *
+ * Uso (single):
+ *   <neu-toggle-button-group [options]="opts" [formControl]="valueCtrl" />
+ *
+ * Uso (múltiple):
+ *   <neu-toggle-button-group [options]="opts" [multiple]="true" [formControl]="valuesCtrl" />
+ */
+declare class NeuToggleButtonGroupComponent<T = unknown> implements ControlValueAccessor {
+    /** Lista de opciones del grupo / Group option list */
+    options: _angular_core.InputSignal<NeuToggleOption<T>[]>;
+    /**
+     * Permite seleccionar múltiples opciones.
+     * - false (por defecto): valor es `T | null`
+     * - true: valor es `T[]`
+     */
+    multiple: _angular_core.InputSignal<boolean>;
+    /** Tamaño visual / Visual size */
+    size: _angular_core.InputSignal<NeuButtonSize>;
+    /** Deshabilita todo el grupo / Disables the entire group */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** Emite el nuevo valor al cambiar (útil sin formControl) / Emits the new value on change (useful without formControl) */
+    neuChange: _angular_core.OutputEmitterRef<T | T[] | null>;
+    readonly _value: _angular_core.WritableSignal<T | T[] | null>;
+    readonly _isDisabled: _angular_core.WritableSignal<boolean>;
+    readonly groupClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-toggle-group': boolean;
+        'neu-toggle-group--disabled': boolean;
+    }>;
+    isSelected(value: T): boolean;
+    toggle(opt: NeuToggleOption<T>): void;
+    onBlur(): void;
+    private _onChange;
+    private _onTouched;
+    writeValue(val: T | T[] | null): void;
+    registerOnChange(fn: (v: unknown) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuToggleButtonGroupComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuToggleButtonGroupComponent<any>, "neu-toggle-button-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "neuChange": "neuChange"; }, never, never, true, never>;
+}
+
+export { NeuToggleButtonGroupComponent };
+export type { NeuToggleOption };

package/types/neural-ui-core-toolbar.d.ts

@@ -0,0 +1,36 @@
+import * as _angular_core from '@angular/core';
+
+type NeuToolbarSize = 'sm' | 'md' | 'lg';
+/**
+ * NeuralUI Toolbar Component
+ *
+ * Barra horizontal con tres zonas de contenido: start (izquierda), center (centro) y end (derecha).
+ *
+ * Uso:
+ *   <neu-toolbar>
+ *     <span neu-toolbar-start>Logo</span>
+ *     <span neu-toolbar-center>Título</span>
+ *     <span neu-toolbar-end><neu-button>Acción</neu-button></span>
+ *   </neu-toolbar>
+ */
+declare class NeuToolbarComponent {
+    /** Tamaño de la toolbar / Toolbar size */
+    readonly size: _angular_core.InputSignal<NeuToolbarSize>;
+    /** Añade sombra en la parte inferior / Adds shadow at the bottom */
+    readonly shadow: _angular_core.InputSignal<boolean>;
+    /** Añade separador inferior / Adds bottom separator */
+    readonly bordered: _angular_core.InputSignal<boolean>;
+    /** Color de fondo personalizado vía CSS (pasa a la variable local) / Custom background color via CSS */
+    readonly surface: _angular_core.InputSignal<"primary" | "surface" | "none">;
+    readonly hostClasses: _angular_core.Signal<{
+        [x: string]: boolean;
+        'neu-toolbar': boolean;
+        'neu-toolbar--shadow': boolean;
+        'neu-toolbar--bordered': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuToolbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuToolbarComponent, "neu-toolbar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "shadow": { "alias": "shadow"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "surface": { "alias": "surface"; "required": false; "isSignal": true; }; }, {}, never, ["[neu-toolbar-start]", "[neu-toolbar-center]", "[neu-toolbar-end]", "*"], true, never>;
+}
+
+export { NeuToolbarComponent };
+export type { NeuToolbarSize };

package/types/neural-ui-core-tooltip.d.ts

@@ -0,0 +1,48 @@
+import * as _angular_core from '@angular/core';
+import { OnDestroy } from '@angular/core';
+
+/** @internal — componente flotante del tooltip, renderizado vía CDK Portal / floating tooltip component, rendered via CDK Portal */
+declare class NeuTooltipOverlayComponent {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly tooltipId: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTooltipOverlayComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuTooltipOverlayComponent, "neu-tooltip-overlay", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "tooltipId": { "alias": "tooltipId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type NeuTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * NeuralUI Tooltip Directive
+ *
+ * Muestra un globo informativo al hacer hover/focus sobre el elemento host.
+ * Usa CDK Overlay para posicionamiento robusto.
+ *
+ * Uso:
+ *   <button [neuTooltip]="'Guardar cambios'">Guardar</button>
+ *   <button [neuTooltip]="'Eliminar'" neuTooltipPosition="bottom">Eliminar</button>
+ */
+declare class NeuTooltipDirective implements OnDestroy {
+    readonly neuTooltip: _angular_core.InputSignal<string>;
+    readonly neuTooltipPosition: _angular_core.InputSignal<NeuTooltipPosition>;
+    readonly neuTooltipDisabled: _angular_core.InputSignal<boolean>;
+    private readonly _overlay;
+    private readonly _elementRef;
+    private readonly _injector;
+    readonly _tooltipId: string;
+    /** Elementos HTML nativamente focusables que no necesitan tabindex extra / Natively focusable HTML elements that don't need extra tabindex */
+    private readonly _NATIVE_FOCUSABLE;
+    protected readonly _needsTabindex: () => boolean;
+    private _overlayRef;
+    private _tooltipRef;
+    private _hideTimeout;
+    show(): void;
+    hide(): void;
+    private _createOverlay;
+    private _getPositions;
+    private _detach;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuTooltipDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NeuTooltipDirective, "[neuTooltip]", never, { "neuTooltip": { "alias": "neuTooltip"; "required": true; "isSignal": true; }; "neuTooltipPosition": { "alias": "neuTooltipPosition"; "required": false; "isSignal": true; }; "neuTooltipDisabled": { "alias": "neuTooltipDisabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NeuTooltipDirective, NeuTooltipOverlayComponent };
+export type { NeuTooltipPosition };

package/types/neural-ui-core-url-state.d.ts

@@ -0,0 +1,58 @@
+import * as i0 from '@angular/core';
+import { Signal, Injector } from '@angular/core';
+import { Params, Router } from '@angular/router';
+
+/**
+ * NeuUrlStateService — El Sistema Nervioso de NeuralUI
+ *
+ * Sincroniza el estado de la UI con los QueryParams de la URL.
+ * Completamente reactivo via Angular Signals.
+ *
+ * Uso:
+ *   const urlState = inject(NeuUrlStateService);
+ *   const page = urlState.getParam('page');  // Signal<string | null>
+ *   urlState.setParam('menu', 'open');        // Actualiza ?menu=open
+ *   urlState.patchParams({ page: '2', q: 'filter' }); // Actualiza múltiples
+ */
+declare class NeuUrlStateService {
+    private readonly injector;
+    private readonly router;
+    /**
+     * Signal con el mapa completo de queryParams actual.
+     * Se actualiza automáticamente en cada NavigationEnd.
+     */
+    readonly params: Signal<Params>;
+    constructor(injector: Injector, router: Router);
+    /**
+     * Devuelve un Signal reactivo con el valor del parámetro indicado.
+     * Memorizar el resultado: no llamar en bucle pues crea un computed nuevo c/vez.
+     *
+     * @example
+     *   readonly menuOpen = computed(() => this.urlState.getParam('menu')() === 'open');
+     */
+    getParam(key: string): Signal<string | null>;
+    /**
+     * Establece un único queryParam en la URL.
+     *
+     * @param key       Nombre del parámetro
+     * @param value     Valor. Pasar `null` para eliminarlo de la URL.
+     * @param replaceUrl Si true (default) usa replaceState — no ensucia el historial.
+     *                   Pasar false para acciones que el usuario debe poder deshacer con Atrás.
+     */
+    setParam(key: string, value: string | null, replaceUrl?: boolean): void;
+    /**
+     * Actualiza múltiples queryParams en una sola navegación.
+     *
+     * @example
+     *   urlState.patchParams({ page: '1', q: 'Angular' });
+     */
+    patchParams(params: Record<string, string | null>, replaceUrl?: boolean): void;
+    /**
+     * Elimina todos los queryParams de la URL de una vez.
+     */
+    clearParams(replaceUrl?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NeuUrlStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NeuUrlStateService>;
+}
+
+export { NeuUrlStateService };

package/types/neural-ui-core-virtual-list.d.ts

@@ -0,0 +1,60 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, TemplateRef } from '@angular/core';
+
+/**
+ * NeuralUI VirtualList
+ *
+ * Wrapper sobre CDK VirtualScrollViewport para listas de miles de ítems.
+ * Proyecta contenido mediante `ng-template` con let-item.
+ *
+ * Uso:
+ *   <neu-virtual-list [items]="bigArray" [itemSize]="40">
+ *     <ng-template neuVirtualItem let-item>
+ *       <div class="my-row">{{ item.name }}</div>
+ *     </ng-template>
+ *   </neu-virtual-list>
+ */
+declare class NeuVirtualListComponent<T = unknown> implements AfterViewInit {
+    /** Referencia al viewport CDK — para forzar remeasure tras render / CDK viewport ref — to force remeasure after render */
+    private readonly _viewport?;
+    constructor();
+    ngAfterViewInit(): void;
+    /** Array de ítems / Item array */
+    readonly items: _angular_core.InputSignal<T[]>;
+    /** Altura de cada fila en px / Row height in px */
+    readonly itemSize: _angular_core.InputSignal<number>;
+    /** Número de filas visibles / Visible row count (sets container height) */
+    readonly visibleRows: _angular_core.InputSignal<number>;
+    /** Texto cuando la lista está vacía / Empty state text */
+    readonly emptyLabel: _angular_core.InputSignal<string>;
+    /** Función de tracking / Tracking function */
+    readonly trackBy: _angular_core.InputSignal<(index: number, item: T) => unknown>;
+    /** Emitido al hacer click en un ítem / Emitted on item click */
+    readonly itemClick: _angular_core.OutputEmitterRef<{
+        item: T;
+        index: number;
+    }>;
+    itemTemplate: TemplateRef<{
+        $implicit: T;
+        index: number;
+    }> | null;
+    readonly _containerHeight: _angular_core.Signal<string>;
+    readonly _isEmpty: _angular_core.Signal<boolean>;
+    _trackBy: (index: number, item: T) => unknown;
+    protected _itemTemplateOrDefault(fallback: TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>): TemplateRef<{
+        $implicit: T;
+        index: number;
+    }>;
+    protected _itemContext(item: T, index: number): {
+        $implicit: T;
+        index: number;
+    };
+    protected _defaultItemLabel(item: T): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NeuVirtualListComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NeuVirtualListComponent<any>, "neu-virtual-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "itemSize": { "alias": "itemSize"; "required": false; "isSignal": true; }; "visibleRows": { "alias": "visibleRows"; "required": false; "isSignal": true; }; "emptyLabel": { "alias": "emptyLabel"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; }, { "itemClick": "itemClick"; }, ["itemTemplate"], never, true, never>;
+}
+
+export { NeuVirtualListComponent };