@esfaenza/es-table 11.2.22-beta6 → 11.2.23

package/lib/components/es-table/es_table.component.d.ts

@@ -0,0 +1,632 @@
+import { QueryList, ChangeDetectorRef, EventEmitter, OnChanges, SimpleChanges, ElementRef, TemplateRef } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { UtilityService, ExportService, MessageService, DateService } from '@esfaenza/extensions';
+import { LocalizationService } from '@esfaenza/localizations';
+import { PreferencesService } from '@esfaenza/preferences';
+import { ContextMenuComponent } from '@esfaenza/ngx-contextmenu';
+import { AppSearch, AppOrdering, EsTableColumnsDefinition, CornerMenuOption, ReportResult, EsTableOperationDefinition, EsTableColumn, GroupPager, GroupRouteFragment, ThElement } from '../../domain';
+import { EsTd } from '../es-td/es_td.component';
+import { EsTdDirective } from '../../directives/es_td.directive';
+import { EsThDirective } from '../../directives/es_th.directive';
+import { ItemsSelection } from '../../domain/externals/classes/appsearch/ItemsSelection';
+import { Group } from "../../domain/externals/classes/appsearch/Group";
+import { EsTableDefaultable } from '../../domain/configuration/EsTableDefaultable';
+import { ExportHandler, ColumnMetadataHandler, DynamicModeHandler, HierarchyModeHandler, ItemsHandler, ReportModeHandler, RowGroupingHandler, SelectionHandler, UtilitiesHandler } from '../../core/handlers';
+/** Componente che permette di rappresentare una griglia di valori */
+export declare class EsTableComponent implements ControlValueAccessor, OnChanges {
+    ngControl: NgControl;
+    private prefService;
+    private deafults;
+    locale: string;
+    lc: LocalizationService;
+    cdr: ChangeDetectorRef;
+    private utilities_H;
+    private utiExts;
+    private expExts;
+    private dateExts;
+    private msgExts;
+    export_H: ExportHandler;
+    columnMetadata_H: ColumnMetadataHandler;
+    dynamicMode_H: DynamicModeHandler;
+    hierarchyMode_H: HierarchyModeHandler;
+    items_H: ItemsHandler;
+    reportMode_H: ReportModeHandler;
+    rowGrouping_H: RowGroupingHandler;
+    selection_H: SelectionHandler;
+    /** @ignore */
+    constructor(ngControl: NgControl, prefService: PreferencesService, deafults: EsTableDefaultable, locale: string, lc: LocalizationService, cdr: ChangeDetectorRef, utilities_H: UtilitiesHandler, utiExts: UtilityService, expExts: ExportService, dateExts: DateService, msgExts: MessageService);
+    /** View finale su cui bindarsi lato Frontend, il tipo può essere IAppSearch<any> (per la **viewMode**), any[] (per l'**arrayMode**) e ReportDefinition per la **reportMode** */
+    View: any;
+    /** Modello da cui l'es-table mostra i pulsanti di paginazione in basso a destra */
+    arrayPulsanti: any;
+    /** Indica se l'es-table deve mostrare il check globale nell'header per fare il "seleziona tutto" */
+    globalCheck: boolean;
+    /** Tiene da conto l'ultimo elemento selezionato in modo da poter effettuare il SHIFT+CLICK */
+    private lastSelected;
+    /** Conteggio interno per il numero di elementi selezionati */
+    selectedObjects: number;
+    /** Indica se è possibile effettuare una selezione massiva */
+    canSelectAll: boolean;
+    /** Indica se il componente sta gestendo un IAppSearch<any> */
+    viewMode: boolean;
+    /** Indica se il componente sta gestendo un any[] */
+    arrayMode: boolean;
+    /** Indica se il componente sta gestendo un ReportDefinition */
+    reportMode: boolean;
+    /**
+     * Contenitore degli elementi da listare lato interfaccia dopo tutte le elaborazioni del caso,
+     * generalmente non sono altro che tutti gli oggetti da presentare con in più l'hash calcolato per identificare 1 oggetto con la propria riga
+     */
+    boundSource: any[];
+    /** Stessa cosa della **boundSource**, utilizzata come appoggio temporaneo interno */
+    TMPBoundSource: any[];
+    /** "Fetta" di oggetti utilizzata nell'endless scroll, ogni elemento di questo array è un blocchetto di 100 elementi */
+    boundSubSources: any[];
+    /** Questa funge da indicatore per gli slice inseriti, la lunghezza dovrebbe essere corrispondente a **boundSubSources** */
+    addedSlices: number[];
+    /** Variabile che identifica il valore del "seleziona Tutto" nella paginazione */
+    defaultAllPageOverride: number;
+    /** Indica se utilizzare il sistema di Endless Scroll */
+    UseEndlessscroll: boolean;
+    /** Valori dell'eventuale report in visualizzazione */
+    ReportValues: ReportResult;
+    /** Serve per tenere in memoria il conteggio precedente e recuperarlo in caso diventi -2 (verificare con Ale perché la logica del -2) */
+    previousCount: number;
+    /** Indica se utilizzare il sistema di autoupdate, cioè un trigger time-izzato in alto a destra della tabella che ripete le ricerche ogni X **seconds** */
+    autoUpdate: boolean;
+    /** Numero di secondi da fare trascorrere fra una ricerca e l'altra */
+    seconds: string;
+    /** Riferimento all'Interval che viene generato se **autoUpdate** è impostata a true in modo da poterlo ripulire */
+    updateTimer: any;
+    /** Impostata a true ogni volta che viene avviata una ricerca, e a false ogni volta che un nuovo valore viene ricevuto */
+    researchInProgress: boolean;
+    /** Modello rappresentante un singolo td della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
+    RowTDs: {
+        [context: string]: EsTd[];
+    };
+    /** Modello di appoggio temporaneo per i **RowTDs** */
+    TMPRowTDs: {
+        [context: string]: EsTd[];
+    };
+    /** Modello rappresentante un singolo th della tabella, generato in base alle configurazioni e agli oggetti ricevuti */
+    RowTHs: ThElement[];
+    /** Modello di appoggio temporaneo per i **RowTHs** */
+    TMPRowTHs: ThElement[];
+    /** Modello di appoggio temporaneo per i **RowThGroups** */
+    TMPRowThGroups: {
+        Span: number;
+        Template: TemplateRef<any>;
+    }[][];
+    /** Modello rappresentante un singolo header group della tabella. Questa lista è già ordinata e pronta per essere utilizzata in ngFor */
+    RowThGroups: {
+        Span: number;
+        Template: TemplateRef<any>;
+    }[][];
+    /** Cache per i routerLink generati nelle tabelle dinamiche */
+    DynamicTableRouterLinkCache: {};
+    /**
+     * Lista dei contesti. Un contesto non è altro che un hash particolare calcolato su un oggetto che identifica univocamente tale oggetto.
+     *
+     * Ognuno di questi contesti rappresenterà a sua volta, univocamente, una riga all'interno della tabella
+     */
+    RowContexts: any[];
+    /** Direttive di ordinamento delle colonne (non ordinamento dei dati ma delle colonne in se) */
+    OrderDirectives: string[];
+    /** Codice dell'ultimo oggetto solezionato */
+    lastSelectedItemID: any;
+    /**
+     * Indica se oltre alle colonne dinamiche specifiche di un tipo di oggetto ci sono anche colonne dinamiche aggiunte dall'utente
+     *
+     * Es. una colonna in cui mostrare sempre un iconcina
+     */
+    UserDefinedDynamicCols: boolean;
+    /** Indica che questo è il primo Bind della tabella, viene settato a false non appena il primo bind viene terminato con successo */
+    FirstBind: boolean;
+    /** Lista di colonne che si possono visualizzare/ordinare fra di loro */
+    ColumnsList: EsTableColumn[];
+    /** Variabile d'appoggio usata dalla dialog di selezione/nascondimento, per evitare di danneggiare **ColumnsList** in caso di modifiche poi annullate */
+    TMPColumnsList: EsTableColumn[];
+    /** Valore del check globale di visibilità valido per tutte le colonne in **ColumnsList** */
+    globalColVisCheck: boolean;
+    /** Query per recuperare tutte le nuove direttive  assegnati a direttiva (Per la modalità dinamica dell'es-table) */
+    EsTdsDirective: QueryList<EsTdDirective>;
+    /** Query per recuperare tutti gli es-td assegnati a direttiva (Per la modalità dinamica dell'es-table) */
+    EsThsDirective: QueryList<EsThDirective>;
+    /** @deprecated Query per recuperare tutti gli es-th */
+    private EsThs;
+    /** @deprecated Query per recuperare tutti gli es-td */
+    private EsTds;
+    /** @deprecated Query per recuperare le informazioni del body (punto della tabella dove vengono mostrate le righe) */
+    bodyRef: any;
+    /** @deprecated Query per recuperare le informazioni dell'header (punto della tabella dove vengono mostrate le intestazioni delle righe) */
+    headerRef: any;
+    /** Query per recuperare le informazioni sul raggruppamento degli header */
+    headerGroupRef: any;
+    /** Query per recuperare le informazioni sul raggruppamento di secondo livello degli header */
+    secondaryHeaderGroupRef: any;
+    /** Opzioni extra che devono apparire nel Menù contestuale in alto a destra, richiamato dai 3 pallini verticali */
+    CornerMenuOptions: CornerMenuOption[];
+    /** Indica se dev'essere possibile effettuare il resize delle colonne */
+    ColumnsResizable: boolean;
+    /** Indica se dev'essere disponibile il sistema di aggiornamento automatico */
+    AutoUpdate: boolean;
+    /** Indica se la tabella (configurata con **UseCustomCells**) deve mettersi in ascolto per i click sulle celle desiderate
+     *
+     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+     */
+    UseCustomCellActions: boolean;
+    /**
+     * Indica le celle desiderate su cui intercettare i click. Attiva solo quando **UseCustomCellActions** è true.
+     * Ogni cella dev'essere separata dalla successiva dal carattere del Simoleon:
+     *
+     * Es, "MiaCella1§MiaCella2"
+     *
+     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+     */
+    CustomCellActionsOn: string;
+    /**
+     * Serve per decidere di lanciare o meno il **event.stopPropagation()** al termine della gestione dell'evento
+     *
+     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+     */
+    CellActionPropagates: boolean;
+    /**
+     * Decide se utilizzare o meno le CustomCells. Impostandolo a **true** l'es-table diventa in grado di gestire nativamente:
+     *
+     * 1) Ordinamento e visibilità delle colonne
+     *
+     * 2) Ordinamento dei dati
+     *
+     * 3) Modalità Gerarchica
+     *
+     * ecc...
+     */
+    UseCustomCells: boolean;
+    /** Permette di impostare l'altezza massima della tabella. Se null la dimensione si adatta al numero di elementi attualmente in visualizzazione */
+    MaxHeight: number;
+    /** Classi da applicare al contenitore della tabella */
+    ContainerClass: any;
+    /** Permette o meno l'export in formato XLSX */
+    XLSXExport: boolean;
+    /** Permette o meno l'export in formato CSV */
+    CSVExport: boolean;
+    /** Permette di visualizzare o meno l'opzione di paginazione "Tutti" */
+    AllSearch: any;
+    /** Diminuisce gli spazi fra una cella e l'altra, e internamente il padding del font in modo da presentare molti più dati in un'unica pagina */
+    HighCellDensity: boolean;
+    /** Abilita o meno la possibilità di selezionare oggetti */
+    Selection: boolean;
+    /** Mostra o meno un messaggio di Loading al primo caricamento della tabella */
+    ShowLoadingOnBootstrap: boolean;
+    /** Se impostato a **true** aggiunge una colonna con pulsante di eliminazione per effettuare l'elimina dell'oggetto relativo */
+    Removal: boolean;
+    /**
+     * Condizione che nasconde l'icona di eliminazione inserita impostando **Removal** a true qualora la condizione non venisse rispettata
+     *
+     * Come condizione si considera un semplice campo su cui effettuare un controllo booleano, come ad esempio "canremove"
+     */
+    RemovalCondition: string;
+    /** Indica se abilitare la possibilità di esportare la vista dati attuale */
+    Export: boolean;
+    /** Indica se permettere la selezione multipla Windows-like cliccando un oggetto e facendo poi Shift + click su un oggetto successivo */
+    ShiftClick: boolean;
+    /** Indica il testo che va a sostituire "Oggetti Visualizzati" in caso si stia facendo qualcosa di custom */
+    CountLabel: string;
+    /** Indica se nascondere o mostrare il componente di paginazione */
+    HidePaging: boolean;
+    /** Indica se nascondere o mostrare il conteggio degli elementi trovati */
+    HidePagingCount: boolean;
+    /** Indica se nascondere o mostrare i pulsanti di paginazione */
+    HidePagingButtons: boolean;
+    /** Riferimento al ContextMenu (ngx-contextmenu) associato al click destro di uno o più elementi selezionati nella tabella */
+    ContextMenu: ContextMenuComponent;
+    /** Nome dell'esportazione generata da questa tabella */
+    ExportFileName: string;
+    /** Classe (HTML) di default della tabella */
+    TableClass: any;
+    /**
+     * Funzione da utilizzare in esportazione. Nel formato "Report" avrà un unico parametro "Formato" e nessun valore di ritorno.
+     *
+     * Nel formato "View" ha come parametro una callback con i dati completi da esportare (dato che di default la ricerca è paginata)
+     */
+    ExportFunction: any;
+    /** Indica la presenza di raggruppamenti a livello di header */
+    HasHeaderGroup: boolean;
+    /** Indica la presenza di raggruppamenti a livello del raggruppamento precedentemente esistente, chiaramente è insensata senza **HasHeaderGroup** */
+    HasSecondaryHeaderGroup: boolean;
+    /** Utilizzato per dividere la sorgente in modalità EndlessScroll */
+    SliceSize: number;
+    /** Decide se utilizzare la modalità di EndlessScroll */
+    EndlessScroll: boolean;
+    /** Qualora **EndlessScroll** fosse true, indica se utilizzare questa modalità solo quando si cerca per "Tutti" o in generale */
+    EndlessScrollOnlyForAll: boolean;
+    /** Indica se nascondere gli Header della tabella */
+    HeaderHidden: boolean;
+    /** Indica se nascondere il Body della tabella */
+    BodyHidden: boolean;
+    /**
+     * Indica se la selezione è temporaneamente disabilitata. Rispetto all'Input **Selection** che visivamente gestisce se ci sono o no gli input di selezione,
+     * questo Input gestisce se questi input sono abilitati o meno
+     */
+    SelectionDisabled: boolean;
+    /**
+     * Indica se forzare il sistema di selezione a gestire un elemento per volta.
+     * Selezionare un'altra riga con una già selezionata applicherà la selezione alla nuova riga, rimuovendola dall'attuale
+     */
+    SingleSelection: boolean;
+    /** Callback che dato un oggetto resituisce l'eventuale classe da applicare alla riga collegata all'oggetto */
+    RowClassAssigner: any;
+    /** Permette di ordinare i dati in maniera discendente o ascendente */
+    OrderByColumn: boolean;
+    /** Permette di avere più direttive di ordinamento dei dati */
+    MultipleOrderingDirectives: boolean;
+    /** Permette di nascondere le colonne in base alle selezioni effettuate dal Menù contestuale in alto a destra */
+    HiddenColumns: boolean;
+    /** Permette di riordinare le colonne in base alle impostazioni effettuate dal Menù contestuale in alto a destra */
+    ColumnsOrdering: boolean;
+    /** Eventuale supporto alle ricerche applicate alla modalità Array */
+    SearchView: AppSearch<any>;
+    /** Abilita o disabilita il sistema che permette di selezionare tutti gli elementi nella vista */
+    SelectAll: boolean;
+    /** Simula la paginazione anche per le tabelle che funzionano in modalità Array */
+    UseArrayModePaging: boolean;
+    /** Definizione di colonne dinamche per la modalità, appunto, dinamica */
+    DynamicRowColumnsDefinition: EsTableColumnsDefinition[];
+    /** Indica operazioni dinamiche generiche che possono essere effettuate per riga. Appaiono come colonne extra sul lato sinistro della tabella */
+    DynamicOperations: EsTableOperationDefinition[];
+    /** Indica se visualizzare i dati in maniera gerarchica */
+    Hierarchy: boolean;
+    /** Nome della proprietà che contiene l'ID del padre. Da utilizzare se **Hierarchy** è impostato */
+    ParentKey: string;
+    /** Nome della proprietà che contiene l'ID dell'oggetto attuale. Da utilizzare se **Hierarchy** è impostato */
+    OwnKey: string;
+    /** Indica se partire con un albero espanso. Da utilizzare se **Hierarchy** è impostato */
+    StartsExpanded: boolean;
+    /** Indica se effettuare il salvataggio delle preferenze di ricerca */
+    SavePreferences: boolean;
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    PagingStyle: 'both' | 'top' | 'bottom';
+    /** Indica dove visualizzare le informazioni di paginazione, se sopra, sotto o in entrambi */
+    RowGroupingPagingStyle: 'left' | 'right';
+    /**
+     * Sorgente dati secondaria
+     *
+     * @deprecated Utilizzato solo per un caso particolare del Metering
+     */
+    SecondarySource: boolean;
+    /**
+     * Sorgente dati secondaria
+     *
+     * @deprecated Utilizzato solo per un caso particolare del Metering
+     */
+    TertiarySource: boolean;
+    /** Indica se utilizzare la cache di selezione che permette di mantenere gli stati di selezione dei vari oggetti navigando da una pagina all'altra */
+    UseSelectionCache: any;
+    /** Permette di decidere se, in modalità raggruppamento, mostrare o meno il valore delle colonne di gruppo negli oggetti finali. Di default sono nascosti */
+    ShowItemGroupsColumns: any;
+    /** Evento che viene richiamato al cambio di oridnamento di una colonna */
+    onOrderChanged: EventEmitter<AppOrdering>;
+    /**
+     * Evento che viene richiamato quando l'es-table ritiene sia necessario ri-effettuare la ricerca.
+     * Il booleano dell'evento indica se viene suggerito di resettare la pagina o meno.
+     *
+     * Solo in caso venga utilizzata la modalità a raggruppamenti di righe può succedere che l'es-table passi un intero AppSearch come parametro di ricerca,
+     * in quel caso l'applicazione ricevente dovrà onorare la richiesta spedendo al backand l'oggetto di ricerca AS-IS
+     *
+     * il tipo dell'Emitter invece di essere [boolean | AppSearch<any>] è stato impostato a "any" per evitare problemi di retrocompatibilità
+     */
+    onSearchRequest: EventEmitter<any>;
+    /** Evento che parte ad ogni modifica di "checkaggio" in forma di comodo array. Espone l'oggetto con lo stato di check attuale */
+    onSelectionChanged: EventEmitter<ItemsSelection<any>>;
+    /** Evento richiamato all'eliminazione di un oggetto */
+    onRemoval: EventEmitter<any>;
+    /** Evento richiamato all'annullamento di un'eliminazione */
+    onAbortRemoval: EventEmitter<any>;
+    /** Evento richiamato al click su una cella quando **UseCustomCellActions** è attivo
+     *
+     * @deprecated Utilizzare l'Input **Template** delle es-td e assegnare un template con tutti i binding che si vuole ai click
+     */
+    onCellClick: EventEmitter<{
+        column: string;
+        model: any;
+    }>;
+    /** Evento richiamato quando si clicca su un opzione definita nelle **CornerMenuOptions** */
+    onCornerAction: EventEmitter<{
+        id: string;
+        estable: any;
+    }>;
+    /** Evento richiamato quando si clicca su un opzione definita nelle **DynamicOperations** */
+    onDynamicOperation: EventEmitter<{
+        id: string;
+        item: any;
+    }>;
+    /** Dati esportati da ngx-csv */
+    data: any[];
+    /** Header dei dati esportati da ngx-csv */
+    headers: any[];
+    /** Elemento HTML da cliccare per l'esportazione */
+    exportDownloader: ElementRef;
+    /** Placeholder di menù contestuale per quando non ci sono opzioni nel placeholder "Vero"  */
+    tableEmptyMenu: ContextMenuComponent;
+    /** Subscription sull'apertura del context menu da ripulire al destroy della classe */
+    private ctxMenuSubscription;
+    /** Pagina in visualizzazione (durante la paginazione in modalità Array) */
+    arraymodePage: number;
+    /** Numero di pagine (durante la paginazione in modalità Array) */
+    arraymodePages: number;
+    /** Oggetti per ogni pagina (durante la paginazione in modalità Array) */
+    ArraymodeItemsPerPage: any;
+    /** Oggetto di selezione per la modalità Array, che deve comportarsi come la controparte in modalità View */
+    arraymodeSelection: ItemsSelection<any>;
+    /** Colonne da visualizzare in modalità array */
+    arrayColumns: string[];
+    /** Ordine delle colonne da visualizzare in modalità array */
+    arrayColumnOrdering: string[];
+    /** Ordinamenti ASC-DESC sulle colonne in modalità array */
+    arrayOrders: AppOrdering[];
+    /**
+     * Variabile che serve a gestire il momento in cui l'es-table aggiorna la paginazione (pulsanti ecc).
+     * Essendo operazioni comunque costose le effettuo solo su binding esterni, non su rewrite generati internamente
+     */
+    private internalWriteCall;
+    /**
+     * Cache che conterrà tutte le ricerche effettuate su gruppi diversi dal primo e su elementi contenuti nei gruppi.
+     * In caso di cambi di ordinamento delle colonne diverse dalla prima tutte le chiamate fatte dal secondo livello in poi devono essere rieseguite secondo la seguente logica:
+     *
+     *
+     * **Cambio ordinamento sul primo gruppo**: reload completo, non mi occupo di ripulire gli elementi bindati in alcun modo
+     *
+     * **Cambio ordinamento sulla colonna relativa all'N-esimo gruppo**: reload completo del contenuto dei gruppi precedenti, ripulendo precedentemente
+     * tutti gli elementi con **_grouplevel** = N
+     *
+     * **Cambio ordinamento su una colonna non raggruppata**: reload completo per tutti i gruppi finali aperti, devo precedentemente ripulire tutti gli elementi con **_item** = true
+     *
+     * Altri eventi non dovrebbero rappresentare problemi:
+     * - Selezione: non cambia nulla
+     * - Paginazione: cambia a livello root quindi viene ricaricato tutto comunque, stesso vale per le paginazioni interne
+     */
+    groupSearchRequestsCache: {
+        path: string;
+        route: GroupRouteFragment[];
+        view: AppSearch<any>;
+        group_column: string;
+    }[];
+    /** Variabile d'appoggio per capire se c'è bisogno di ri-effettuare una ricerca o meno */
+    private ResearchNeeded;
+    /** Colonne visibili della vista attuale. Valorizzato di default al numero massimo di colonne supportate dalla tabella per le casistiche in assenza di custom cells */
+    Columns: {
+        Visibile: number;
+        VisibleUnpinned: number;
+        Global: number;
+    };
+    /** In caso di Row Grouping qui viene salvata la vista principale dei gruppi base */
+    MainGroupView: AppSearch<any>;
+    /** Conteggio base degli oggetti. In modalità normale viene resettato ad ogni nuova View inserita, in modalità RowGrouping viene resettato solo ad una nuova View di livello "0" */
+    BaseItemsCount: any;
+    /** Indica se ci sono delle colonne pinnate e visibili. Serve per poter settare tutte le colonne prima che arrivino dati a pinned*/
+    HasPinnedColumns: boolean;
+    /** Larghezza calcolata del container delle colonne pinnate */
+    PinnedContainerWidth: number;
+    /** Indica se nonostante siamo in modalità array sono stati individuati dei gruppi. In tal caso es-table si comporta da pseudo backend ed effettua le aggregazioni e raggruppamenti completamente lato client */
+    ArrayGrouping: boolean;
+    /** Indica che l'es-table è basata sulle direttive (nuova modalità) */
+    DirectivesBased: boolean;
+    /** Opzioni di paginazione */
+    PagerOptions: {
+        PagerCount: number;
+        ShowCount: boolean;
+        ShowPaging: boolean;
+        UsesView: boolean;
+        ShowButtons: boolean;
+        ShowPagingOptions: boolean;
+        View: any;
+        Ready: boolean;
+        Searches: 'items' | 'groups';
+    };
+    /** @ignore */
+    ngOnInit(): void;
+    /** @ignore */
+    ngAfterViewInit(): void;
+    /** @ignore */
+    ngOnDestroy(): void;
+    /** @ignore */
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    /** @ignore */
+    registerOnChange(fn: any): void;
+    /** @ignore */
+    registerOnTouched(fn: any): void;
+    /** @ignore */
+    changed(): void;
+    /** @ignore */
+    propagateChange: (_: any) => void;
+    /** @ignore */
+    writeValue(obj: any): void;
+    /** Funzione di trackby per il body che dovrebbe evitare il 90% delle change detection */
+    bodyTrackBy: (index: number, item: any) => any;
+    /**
+     * Successivamente al bind del nuovo input questa funzione si occupa di finalizzare tutti i parametri di funzionamento dell'es-table
+     * in base a Input - Modello, e qualsiasi altra cosa possa servire
+     */
+    private finalizeContext;
+    /** Genera le informzioni di paginazione per la vista globale dell'es-table */
+    private setupPagingInformations;
+    /**
+     * Metodo che gestisce l'endless scroll e in base a quanto la tabella è stata scrollata aggiunge degli elementi extra a **TMPBoundSource**
+     *
+     * @param {any} e Evento di scroll del browser
+     */
+    onScroll(e: any): void;
+    /**
+     * Metodo lanciato dopo che la sorgente dati è stata correttamente bindata, si occupa di ricalcolare tutto ciò che serve
+     * all'es-table per renderizzare i valori da mostrare
+     */
+    private postBoundSourceCalculation;
+    /** Per poter distinguere le chiamate a questo metodo: Dopo il setTimeout se uso gli EsTd/EsTh vecchi, senza il setTimeout se uso le nuove direttive */
+    private internalPostBoundSource;
+    /**
+     * Effettua il binding degli oggetti pervenuti da questa chiamata con gli oggetti effettivamente da graficare
+     *
+     * @param {any} view View da cui sono arrivati gli oggetti. Può essere o un array se sono in **arrayMode** o una AppSearch<T> se sono in **viewMode**
+     */
+    private bindDisplayToLoadedItemsOrGroups;
+    /** Metodo richiamato solo quando **TMPRowTDs** e **TMPRowTHs** sono completamente generati ed aggiustati. Serve per collegarli alle variabili usate lato binding HTML */
+    private MoveTemporaryVariablesToRealOnes;
+    /**
+     * Permette di selezionare o deselezionare in maniera arbitraria degli oggetti
+     *
+     * @param {any[]} items Oggetti da selezionare o deselezionare
+     * @param {boolean} select **true** per selezionarli, **false** per non toccarli
+     */
+    setSelectionStatus(items: any[], select: boolean): void;
+    /**
+     * Metodo che gestisce il cambio di Ordinamento di una colonna
+     *
+     * @param {string} id ID della colonna il cui oridnamento è cambiato
+     * @param {'DESC' | 'ASC'} order Nuovo ordine selezionato per la colonna
+     */
+    thOrderChanged(id: string, order?: 'DESC' | 'ASC'): void;
+    /**
+     * Metodo da chiamare ogni volta che si vuole dare evidenza all'esterno del bisogno di rieffettuare la ricerca
+     *
+     * @param {boolean} resetsPage Indica al listener che deve resettare il numero di pagina
+     * @param {AppSearch<any>} viewOverride Override della view da emettere per questa ricerca
+     */
+    emitSearchRequest(resetsPage: boolean, viewOverride?: AppSearch<any>): void;
+    /**
+     * Partendo dagli **EsTds** bindati genera, all'interno del dizionario **TMPRowTDs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TD "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 2 scan EsThs, 1 scan EsTds
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     * @param {EsTd[] | EsTdDirective[]} tds Celle della tabella
+     */
+    private evaluateRowTds;
+    /**
+     * Partendo dagli **EsThs** bindati genera, all'interno del dizionario **TMPRowTHs** tutti i contesti dei vari oggetti.
+     *
+     * Vengono esclusi i TH "Interni" in quanto vengono generati dagli originali quindi includerli vorrebbe dire rieffettuare le operazioni due volte
+     *
+     * Costo: 1 scan EsThs
+     *
+     * @param {EsTh[] | EsThDirective[]} ths Colonne della tabella
+     */
+    private evaluateRowThs;
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indietro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    addToPageGroup(page: number, pager: GroupPager): void;
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     * @param {any} pager Elemento di separazione su cui è effettuata la ricerca
+     */
+    goToPageGroup(page: number, pager: GroupPager): void;
+    /**
+     * Gestisce i click sulla tabella solo per le righe a gruppo.
+     * O rimuove gli elementi attualmente presenti o carica il contenuto del gruppo
+     *
+     * @param {any} group Gruppo bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleGroupClick(group: Group): boolean;
+    /**
+     * Gestisce la selezione globale degli oggetti, sia per pagina che a livello di **SelectAll**
+     *
+     * @param {boolean} forcedVal Valore forzato di check da assegnare agli oggetti
+     */
+    globalCheckChanged(forcedVal?: boolean): void;
+    /**
+     * Gestisce i click sulla tabella, gestendo eventualmente anche gli Shift + Click per selezionare un range di oggetti
+     *
+     * @param {any} event Evento nativo HTML del click
+     * @param {any} item Oggetto bindato su cui si è effettuato il click
+     *
+     * @returns {boolean} **true** se l'operaizone è andata a buon fine, **false** altrimenti
+     */
+    handleClick(event: any, item: any): boolean;
+    /**
+     * Sposta la ricerca di una pagina in avanti (o indeitro)
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    addToPage(page: number): void;
+    /**
+     * Sposta la ricerca alla pagina specificata
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    goToPage(page: number): void;
+    /**
+     * Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest**
+     * per comunicare al componente che utilizza questa tabella che i dati sono da aggiornare
+     */
+    onItemsPerPageChanged(newIpp: any): void;
+    /** Evento richiamato sul cambio della paginazione. Verrà richiamato l'evento **emitSearchRequest** con la vista del separatore */
+    onGroupItemsPerPageChanged(pager: GroupPager, newIpp: number): void;
+    /** Metodo che gestisce la modifica del tempo specificato per l'aggiornamento automatico */
+    autoUpdateChanged(): void;
+    /**
+     * Metodo chiamato dal click su una delle colonne generate dall'Input **DynamicOperations**
+     *
+     * @param {any} item L'oggetto su cui va effettuata l'operazione
+     * @param {string} opid Codice identificativo dell'operazione da effettuarsi
+     */
+    dynamicOperation(item: any, opid: string): void;
+    /**
+     * Ottiene il contenuto dell'EsTd da utilizzare per la colonna specificata
+     *
+     * @param {string} column Colonna per cui cercare la cella
+     *
+     * @returns {TemplateRef<any>} Template da usare per la colonna
+     */
+    findEsTd(column: string): TemplateRef<any>;
+    /**
+     * Equivalente del metodo **addToPage** riadattato per la modalità array
+     *
+     * @param {number} page Numero di pagine da aggiungere (o sottrarre, se negativo) alla pagina attuale
+     */
+    arrayAddToPage(page: number): void;
+    /**
+     * Equivalente del metodo **goToPage** riadattato per la modalità array
+     *
+     * @param {number} page Pagina a cui navigare
+     */
+    arrayGoToPage(page: number): void;
+    /**
+     * Gestore dei click sulle celle per le quali era impostata una azione custom da **CustomCellActionsOn**
+     *
+     * @param {string} name Nome della cella su cui si è fatto click
+     * @param {any} model Modello relativo alla cella cliccata
+     *
+     * @returns {boolean} **true** se il click è stato fatto su una cella cliccabile, **false** altrimenti
+     */
+    cellClicked(name: string, model: any): boolean;
+    /**
+     * Gestione dei click sulle opzioni del menù contestuale in alto a destra generato dall'Input **CornerMenuOptions**
+     *
+     * @param {string} cornerid Codice dell'operazione selezionata
+     */
+    cornerActionClicked(cornerid: string): void;
+    /**
+     * Impostazione modalità dell'EsTable
+     *
+     * @param {'array' | 'view' | 'report'} mode Modalità da impostare
+     **/
+    private setMode;
+    /**
+     * Helper per effettuare chiamate interne di allineamento alla funzione **writeValue**,
+     * impostando prima **internalWriteCall** in modo da non effettuare operazioni inutili
+     */
+    internalWriteValue(): void;
+    /**
+     * Metodo eventualmente richiamabile anche dal componente esterno che permette di forzare un refresh della tabella
+     */
+    forceRefresh(): void;
+}

package/lib/{es_th.component.d.ts → components/es-th/es_th.component.d.ts}

@@ -25,6 +25,8 @@ export declare class EsTh {
     Display: string;
     /** Indica se le dimnsioni di questa colonna sono modificabili o meno */
     Resizable: boolean;
+    /** Indica se questo header è pinnato. In caso lo fosse presenta il tastino per effettuare lo spinning */
+    Pinned: boolean;
     /**
      * Indica se sta venendo eseguita una operazione di ricerca o meno, serve per evitare l'esecuzione di eventuale codice che potrebbe dare fastidio
      * come ad esempio l'escuzione di un ordinamento durante il caricamento di dati nuovi
@@ -40,6 +42,8 @@ export declare class EsTh {
     Template?: any;
     /** Evento emesso al cambio di ordinamento effettuato su questa colonna */
     onOrderChange: EventEmitter<'DESC' | 'ASC' | null>;
+    /** Evento emesso all'unpinning della colonna */
+    onUnpinning: EventEmitter<string>;
     /** Proiezione del contenuto di questa colonna */
     content: ElementRef;
     /** Classi da applicare alla colonna */
@@ -64,6 +68,8 @@ export declare class EsTh {
     get Visible(): boolean;
     /** @ignore */
     ngAfterViewInit(): void;
+    /** Emette l'evento di unpinning */
+    unpin(): void;
     /** Gestisce la modifica dell'ordinamento qualora venisse cliccato su questa colonna */
     setupNextOrderAndNotify(): void;
     /**