@xosue-utils/inputs 0.1.0

package/lib/slider-entry/slider-entry.component.d.ts

@@ -0,0 +1,69 @@
+import { OnInit, OnDestroy, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class SliderEntryComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private platformId;
+    trackRef: ElementRef<HTMLDivElement>;
+    label: string;
+    description: string;
+    opcional: boolean;
+    min: number;
+    max: number;
+    decimal: boolean;
+    step: number | null;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    value: number;
+    isDisabled: boolean;
+    isDragging: boolean;
+    private documentMouseMoveHandler;
+    private documentMouseUpHandler;
+    private documentTouchMoveHandler;
+    private documentTouchEndHandler;
+    /**
+     * Normaliza un valor según el modo decimal.
+     * - Si decimal es true: redondea a 2 decimales (o formatea enteros con .00)
+     * - Si decimal es false: convierte a entero
+     * @param value - Valor a normalizar
+     * @returns Valor normalizado
+     */
+    private normalizeValue;
+    private onChange;
+    private onTouched;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (val: number) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSliderInput(event: Event): void;
+    onSliderChange(): void;
+    onInputChange(event: Event): void;
+    onKeydown(event: KeyboardEvent): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onThumbMouseDown(event: MouseEvent): void;
+    onThumbTouchStart(event: TouchEvent): void;
+    onTrackClick(event: MouseEvent): void;
+    onTrackTouchStart(event: TouchEvent): void;
+    private handleDocumentMouseMove;
+    private handleDocumentMouseUp;
+    private handleDocumentTouchMove;
+    private handleDocumentTouchEnd;
+    private touchToMouseEvent;
+    private updateValueFromEvent;
+    private updateRangeInput;
+    /**
+     * Retorna el step según el modo decimal o el step personalizado.
+     * - Si step es null: 0.01 (decimal) o 1 (entero) según el modo
+     * - Si step está definido: usa ese valor
+     */
+    get calculatedStep(): number;
+    get fillStyle(): {
+        [key: string]: string;
+    };
+    get thumbPosition(): number;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SliderEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SliderEntryComponent, "slider-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "decimal": { "alias": "decimal"; "required": false; }; "step": { "alias": "step"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/switch-entry/switch-entry.component.d.ts

@@ -0,0 +1,66 @@
+import { OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+type SwitchLabels = [string, string];
+type SwitchEntryModelValue = boolean | string | null;
+export declare class SwitchEntryComponent implements ControlValueAccessor, OnChanges, OnDestroy {
+    private cdr;
+    private hostRef;
+    private platformId;
+    label: string;
+    description: string;
+    opcional: boolean;
+    /**
+     * Si se brinda:
+     * - `values[0]` = equivalente a false/off (izquierda)
+     * - `values[1]` = equivalente a true/on (derecha)
+     *
+     * En ese caso el valor que emite el control es string (uno de esos 2).
+     * Si NO se brinda, el control funciona como boolean (true/false).
+     */
+    values: SwitchLabels | null | undefined;
+    get hostDisabledClass(): boolean;
+    set disabled(v: boolean);
+    /** Estado interno (solo para UI). */
+    private boolValue;
+    /** Último valor del modelo (boolean o string según modo). */
+    private modelValue;
+    isDisabled: boolean;
+    private dragging;
+    private pointerId;
+    private startX;
+    private startLeft;
+    private currentLeft;
+    private moved;
+    private onChange;
+    private onTouched;
+    writeValue(v: SwitchEntryModelValue): void;
+    registerOnChange(fn: (v: SwitchEntryModelValue) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    get ariaChecked(): 'true' | 'false';
+    get isOn(): boolean;
+    get isDragging(): boolean;
+    get displayText(): string;
+    onTrackClick(e: MouseEvent): void;
+    onPointerDown(e: PointerEvent): void;
+    onPointerMove(e: PointerEvent): void;
+    onPointerUp(e: PointerEvent): void;
+    onPointerCancel(e: PointerEvent): void;
+    private toggleByClick;
+    private setValue;
+    private getTrackEl;
+    private getMaxLeft;
+    private getThumbLeftForValue;
+    get thumbLeftPx(): number;
+    /** Porcentaje (0–100%) usado para el relleno/gradiente del track. */
+    get trackFillWidth(): string;
+    private resetThumbToValue;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private boolToModel;
+    private modelToBool;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SwitchEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SwitchEntryComponent, "switch-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "values": { "alias": "values"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/tags-entry/tags-entry.component.d.ts

@@ -0,0 +1,35 @@
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class TagsEntryComponent implements ControlValueAccessor {
+    private cdr;
+    private elementRef;
+    label: string;
+    description: string;
+    opcional: boolean;
+    placeholder: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    tagInputRef: ElementRef<HTMLInputElement>;
+    tags: string[] | null;
+    inputValue: string;
+    isDisabled: boolean;
+    isFocus: boolean;
+    private onChange;
+    private onTouched;
+    writeValue(value: string[] | null): void;
+    registerOnChange(fn: (tags: string[] | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    private emitChange;
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    addTag(tag: string): void;
+    removeTag(index: number): void;
+    clearAll(): void;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TagsEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TagsEntryComponent, "tags-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/text-area-entry/text-area-entry.component.d.ts

@@ -0,0 +1,27 @@
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class TextAreaEntryComponent implements ControlValueAccessor {
+    private cdr;
+    private elementRef;
+    label: string;
+    description: string;
+    opcional: boolean;
+    placeholder: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    isFocus: boolean;
+    value: string;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(): void;
+    onBlur(): void;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextAreaEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextAreaEntryComponent, "text-area-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/text-entry/text-entry.component.d.ts

@@ -0,0 +1,38 @@
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class TextEntryComponent implements ControlValueAccessor, OnInit {
+    private cdr;
+    private elementRef;
+    label: string;
+    description: string;
+    opcional: boolean;
+    placeholder: string;
+    prefix: string | null;
+    suffix: string | null;
+    concatPrefix: boolean;
+    concatSuffix: boolean;
+    /** Texto de ayuda mostrado al pulsar el botón de información. */
+    fieldHelp: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    isFocus: boolean;
+    rawValue: string | null;
+    outputValue: string | null;
+    ngOnInit(): void;
+    private onChange;
+    onTouched: () => void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private buildOutputValue;
+    private emitValue;
+    onInput(event: Event): void;
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextEntryComponent, "text-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "concatPrefix": { "alias": "concatPrefix"; "required": false; }; "concatSuffix": { "alias": "concatSuffix"; "required": false; }; "fieldHelp": { "alias": "fieldHelp"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/time-picker/services/time-picker-modal/time-picker-modal.service.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from "@angular/core";
+export interface TimePickerModalViewModel {
+    selectedValue: string | null;
+    selectedHour: number | null;
+    selectedMinute: number | null;
+    selectedDateExtended: string;
+    HOURS: readonly number[];
+    MINUTES: readonly number[];
+}
+export interface TimePickerModalHandlers {
+    toggleShowPicker: (e: Event) => void;
+    onSelectHour: (h: number, e: Event) => void;
+    onSelectMinute: (m: number, e: Event) => void;
+    onCancel: () => void;
+    onClear: () => void;
+    onAccept: () => void;
+}
+export interface TimePickerModalSession {
+    view: TimePickerModalViewModel;
+    handlers: TimePickerModalHandlers;
+}
+export declare class TimePickerModalService {
+    private readonly state;
+    readonly state$: import("rxjs").Observable<TimePickerModalSession>;
+    open(session: TimePickerModalSession): void;
+    patchView(patch: Partial<TimePickerModalViewModel>): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TimePickerModalService>;
+}

package/lib/time-picker/time-picker.component.d.ts

@@ -0,0 +1,70 @@
+import { EventEmitter, OnInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class TimePickerComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private timePickerModal;
+    private inputOverlayCoordinator;
+    private readonly overlayToken;
+    private static readonly modalRootSelector;
+    private get hostElement();
+    label: string;
+    opcional: boolean;
+    description: string;
+    placeholder: string;
+    format: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    selectionChange: EventEmitter<string>;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    selectedValue: string | null;
+    private previousSelectedValue;
+    selectedHour: number | null;
+    selectedMinute: number | null;
+    isDisabled: boolean;
+    isFocus: boolean;
+    showPicker: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private setFromDate;
+    /**
+     * @param notifyModel si es `true`, notifica al `FormControl` (acción de usuario).
+     * En `writeValue` del CVA debe ser `false`: el modelo ya viene del formulario.
+     */
+    private clearSelection;
+    private updateSelectedValue;
+    onSelectHour(hour: number): void;
+    onSelectMinute(minute: number): void;
+    scrollToCurrentHours(): void;
+    scrollToCurrentMinutes(): void;
+    toggleShowPicker(e: Event): void;
+    private applyCancelState;
+    onCancel(): void;
+    onClear(): void;
+    onAccept(): void;
+    private buildModalView;
+    private syncModalView;
+    private openModalPortal;
+    private closeModalPortal;
+    private onOverlayDismissedByCoordinator;
+    private closePicker;
+    private buildHandlers;
+    focus(): void;
+    defocus(): void;
+    /**
+     * Simula un click en el input interno (si existe) para enfocarlo.
+     * @param event Evento del mouse (opcional).
+     */
+    manualClick(event?: MouseEvent): void;
+    get selectedDateExtended(): string;
+    readonly HOURS: number[];
+    readonly MINUTES: number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TimePickerComponent, "time-picker", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "format": { "alias": "format"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, never, true, never>;
+}

package/lib/url-entry/url-entry.component.d.ts

@@ -0,0 +1,29 @@
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class UrlEntryComponent implements ControlValueAccessor {
+    private cdr;
+    private elementRef;
+    label: string;
+    description: string;
+    opcional: boolean;
+    placeholder: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    isFocus: boolean;
+    textValue: string;
+    error: boolean;
+    private onChange;
+    private onTouched;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    private isValidHttpsUrl;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UrlEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UrlEntryComponent, "url-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@xosue-utils/inputs",
+  "version": "0.1.0",
+  "description": "Angular standalone form inputs (text, select, date, media, rich-text, …) shared across Caludy / Orquesta / Mayoristas.",
+  "license": "UNLICENSED",
+  "private": false,
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/YOUR_ORG/xosue-utils.git"
+  },
+  "keywords": [
+    "angular",
+    "inputs",
+    "forms",
+    "xosue-utils"
+  ],
+  "peerDependencies": {
+    "@angular/common": "^19.0.0",
+    "@angular/core": "^19.0.0",
+    "@angular/forms": "^19.0.0",
+    "@angular/platform-browser": "^19.0.0",
+    "@angular/router": "^19.0.0",
+    "@lexical/history": "^0.42.0",
+    "@lexical/html": "^0.42.0",
+    "@lexical/link": "^0.42.0",
+    "@lexical/list": "^0.42.0",
+    "@lexical/rich-text": "^0.42.0",
+    "@lexical/selection": "^0.42.0",
+    "@lexical/table": "^0.42.0",
+    "@lexical/utils": "^0.42.0",
+    "@lucide/angular": "^0.500.0 || ^1.0.0",
+    "lexical": "^0.42.0",
+    "luxon": "^3.0.0",
+    "rxjs": "^7.8.0",
+    "sortablejs": "^1.15.0"
+  },
+  "dependencies": {
+    "tslib": "^2.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "fesm2022/xosue-utils-inputs.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/xosue-utils-inputs.mjs"
+    }
+  }
+}

package/public-api.d.ts

@@ -0,0 +1,8 @@
+export * from './config/inputs-config';
+export * from './lib/index';
+export { LucideIconComponent } from './vendor/lucide-icon/lucide-icon.component';
+export { FieldHelpTooltipComponent } from './vendor/field-help-tooltip/field-help-tooltip.component';
+export { ContextMenuService, type ContextMenuOption, type ContextMenuInfo, } from './vendor/context-menu-service/context-menu.service';
+export { ContextMenuServiceComponent } from './vendor/context-menu-service/context-menu-service.component';
+export { DragScrollDirective } from './vendor/drag-scroll.directive';
+export { FileSizePipe } from './vendor/file-size.pipe';

package/vendor/context-menu-service/context-menu-service.component.d.ts

@@ -0,0 +1,37 @@
+import { ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ContextMenuOption, ContextMenuRequest, ContextMenuService } from './context-menu.service';
+import * as i0 from "@angular/core";
+export declare class ContextMenuServiceComponent implements OnInit, OnDestroy {
+    private contextMenuService;
+    private platformId;
+    private static readonly VIEWPORT_EDGE_INSET;
+    private static readonly ANCHOR_OFFSET;
+    private readonly cdr;
+    panelRef?: ElementRef<HTMLElement>;
+    active: ContextMenuRequest | null;
+    position: {
+        x: number;
+        y: number;
+    };
+    panelVisible: boolean;
+    private anchor;
+    /** Timestamp hasta el cual ignoramos cierres (evita que el gesto de apertura cierre el menú). */
+    private ignoreOutsideUntil;
+    private sub?;
+    private closeSub?;
+    private readonly scrollListener;
+    private readonly outsidePointerListener;
+    private readonly outsideContextMenuListener;
+    constructor(contextMenuService: ContextMenuService, platformId: object);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onWindowResize(): void;
+    onEscape(event: KeyboardEvent): void;
+    selectOption(option: ContextMenuOption): void;
+    private handleOutsideEvent;
+    private dismissCurrent;
+    private clearMenu;
+    private applyClampedPosition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuServiceComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ContextMenuServiceComponent, "context-menu-service", never, {}, {}, never, never, true, never>;
+}

package/vendor/context-menu-service/context-menu.service.d.ts

@@ -0,0 +1,63 @@
+import * as i0 from "@angular/core";
+export interface ContextMenuOption<T = unknown> {
+    icon: string;
+    name: string;
+    value: T;
+    /** Estilo destructivo (rojo). */
+    danger?: boolean;
+    /** Separador visual antes de esta opción. */
+    separatorBefore?: boolean;
+    disabled?: boolean;
+}
+export interface ContextMenuInfo {
+    icon: string;
+    title: string;
+    info: string;
+}
+export type ContextMenuKind = 'menu' | 'info';
+interface ContextMenuRequestBase {
+    id: number;
+    x: number;
+    y: number;
+}
+export interface ContextMenuMenuRequest extends ContextMenuRequestBase {
+    kind: 'menu';
+    title?: string;
+    options: ContextMenuOption[];
+    resolve: (value: ContextMenuOption | null) => void;
+}
+export interface ContextMenuInfoRequest extends ContextMenuRequestBase {
+    kind: 'info';
+    info: ContextMenuInfo;
+    resolve: () => void;
+}
+export type ContextMenuRequest = ContextMenuMenuRequest | ContextMenuInfoRequest;
+export type ContextMenuOpenEvent = MouseEvent | {
+    clientX: number;
+    clientY: number;
+};
+export interface ContextMenuOpenOptions {
+    title?: string;
+    /** Si true (default), evita el menú nativo del navegador cuando el evento es MouseEvent. */
+    preventDefault?: boolean;
+}
+export declare class ContextMenuService {
+    private platformId;
+    private readonly requestSubject;
+    readonly request$: import("rxjs").Observable<ContextMenuRequest>;
+    private readonly closeSubject;
+    readonly close$: import("rxjs").Observable<void>;
+    private idCounter;
+    private readonly isBrowser;
+    constructor(platformId: object);
+    /** Menú contextual en el punto del clic. Solo uno activo a la vez. */
+    openMenu(event: ContextMenuOpenEvent, options: ContextMenuOption[], menuOptions?: ContextMenuOpenOptions): Promise<ContextMenuOption | null>;
+    /** Globo informativo en el punto del clic. */
+    openInfo(event: ContextMenuOpenEvent, info: ContextMenuInfo): Promise<void>;
+    /** Cierra el menú contextual activo desde código. */
+    close(): void;
+    private pointFromEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ContextMenuService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ContextMenuService>;
+}
+export {};

package/vendor/drag-scroll.directive.d.ts

@@ -0,0 +1,10 @@
+import { AfterViewInit, ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DragScrollDirective implements AfterViewInit {
+    private el;
+    direction?: 'horizontal' | 'vertical';
+    constructor(el: ElementRef<HTMLElement>);
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragScrollDirective, "[dragScroll]", never, { "direction": { "alias": "dragScroll"; "required": false; }; }, {}, never, never, true, never>;
+}

package/vendor/field-help-tooltip/field-help-tooltip.component.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+export declare class FieldHelpTooltipComponent {
+    private readonly contextMenuService;
+    text: string;
+    title: string;
+    showHelp(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldHelpTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldHelpTooltipComponent, "field-help-tooltip", never, { "text": { "alias": "text"; "required": true; }; "title": { "alias": "title"; "required": false; }; }, {}, never, never, true, never>;
+}

package/vendor/file-size.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FileSizePipe implements PipeTransform {
+    transform(bytes: number | null | undefined, decimals?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "fileSize", true>;
+}

package/vendor/lucide-icon/lucide-icon.component.d.ts

@@ -0,0 +1,26 @@
+import * as i0 from "@angular/core";
+/**
+ * Icono Lucide.
+ *
+ * HTML:
+ *   <lucide-icon name="star"></lucide-icon>
+ *   <lucide-icon name="heart" filled></lucide-icon>  // relleno + trazo
+ *
+ * SASS — variables CSS (heredan del padre):
+ *   --lucide-stroke: var(--primary)
+ *   --lucide-fill: var(--accent)
+ *   --lucide-stroke-width: 2
+ */
+export declare class LucideIconComponent {
+    readonly name: import("@angular/core").InputSignal<string>;
+    readonly size: import("@angular/core").InputSignal<string | number>;
+    readonly spin: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    /** Activa relleno (--lucide-fill); el trazo se conserva. */
+    readonly filled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly dimStyle: import("@angular/core").Signal<{
+        width: string;
+        height: string;
+    }>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LucideIconComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LucideIconComponent, "lucide-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "spin": { "alias": "spin"; "required": false; "isSignal": true; }; "filled": { "alias": "filled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}