wuic-framework-lib 0.0.1

package/lib/component/list-grid/list-grid.component.d.ts

@@ -0,0 +1,238 @@
+import { AfterViewInit, ChangeDetectorRef, OnInit } from '@angular/core';
+import { MetadataProviderService } from '../../service/metadata-provider.service';
+import { DataSourceComponent } from "../data-source/data-source.component";
+import { Table, TableRowCollapseEvent, TableRowExpandEvent } from 'primeng/table';
+import { MetadatiColonna } from '../../class/metadati_colonna';
+import { MetaInfo } from '../../class/metaInfo';
+import { DomSanitizer } from '@angular/platform-browser';
+import { Location } from '@angular/common';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ContextMenu } from 'primeng/contextmenu';
+import { Title } from "@angular/platform-browser";
+import { TranslationManagerService } from '../../service/translation-manager.service';
+import { BehaviorSubject } from 'rxjs';
+import { UserInfoService } from '../../service/user-info.service';
+import { MenuItem } from 'primeng/api';
+import * as i0 from "@angular/core";
+interface ListGridSavedState {
+    id: string;
+    name: string;
+    description: string;
+    isDefault: boolean;
+    createdAt: string;
+    filterInfo: any;
+    sortInfo: any[];
+    pageInfo: {
+        currentPage: number;
+        pageSize: number;
+    };
+    columnWidths: {
+        [field: string]: number;
+    };
+}
+interface ReportVariableInput {
+    name: string;
+    alias: string;
+    value: string;
+    type?: string;
+}
+export declare class ListGridComponent implements AfterViewInit, OnInit {
+    private metaSrv;
+    private sanitizer;
+    private route;
+    private router;
+    private location;
+    private titleService;
+    private trslSrv;
+    private cd;
+    userInfo: UserInfoService;
+    private static readonly GRID_VIEW_STATES_SETTINGS_KEY;
+    private static readonly GRID_COLUMN_LAYOUT_SETTINGS_KEY;
+    hardcodedRoute: string;
+    parentRecord: any;
+    parentMetaInfo: MetaInfo;
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    rowCustomSelect: (rowData: any, $event: any, dt: Table) => void;
+    table: Table;
+    columnCtxMenu: ContextMenu;
+    metadataColumnsDatasource: DataSourceComponent;
+    records: any[];
+    cols: any[];
+    metas: MetadatiColonna[];
+    metaInfo: MetaInfo;
+    routeName: string;
+    actionName: string;
+    totalRecords: number;
+    pageSize: number;
+    rowNumber: number;
+    orderColumn: string;
+    orderDir: 'asc' | 'desc';
+    loading: BehaviorSubject<boolean>;
+    pageIndex: number;
+    globalFilterFields: string[];
+    searchValue: string;
+    rowTemplate: any;
+    selectedItems: any[];
+    expandedRows: {};
+    aggregates: any[];
+    private syncFilterInfoQueryTimer;
+    private syncGridStateQueryTimer;
+    private suppressGridStateUrlPush;
+    private releaseGridStateUrlPushTimer;
+    private navigationTriggeredByPopstate;
+    private suppressNextPageOnlyQuerySync;
+    clientSideCrudToggleBusy: boolean;
+    private persistedColumnWidthsByRoute;
+    private persistedColumnLayoutByRoute;
+    private remoteColumnLayoutHydrationInFlight;
+    private persistedGridStatesByRoute;
+    private remoteGridStatesHydrationInFlight;
+    currentRouteSavedStates: ListGridSavedState[];
+    selectedSavedStateId: string;
+    private applyingSavedState;
+    readonly NEW_GRID_STATE_OPTION_ID = "__new__";
+    saveGridStateDialogVisible: boolean;
+    saveGridStateDialogSelectedId: string;
+    saveGridStateDialogNewName: string;
+    saveGridStateDialogSetAsDefault: boolean;
+    saveStateMenuItems: MenuItem[];
+    clearFiltersMenuItems: MenuItem[];
+    columnContextMenuItems: MenuItem[];
+    selectedColumnForContextMenu?: MetadatiColonna;
+    availableReports: {
+        path: string;
+        name: string;
+    }[];
+    reportMenuItems: MenuItem[];
+    tableActionMenuItems: MenuItem[];
+    reportVariableDialogVisible: boolean;
+    reportVariableDialogLoading: boolean;
+    selectedReportNameForVariables: string;
+    selectedReportVariables: ReportVariableInput[];
+    columnLayoutDialogVisible: boolean;
+    columnLayoutDraft: {
+        field: string;
+        header: string;
+        visible: boolean;
+    }[];
+    private pendingPreferredStateAutoApply;
+    width_defined: string;
+    MetadatiColonna: typeof MetadatiColonna;
+    constructor(metaSrv: MetadataProviderService, sanitizer: DomSanitizer, route: ActivatedRoute, router: Router, location: Location, titleService: Title, trslSrv: TranslationManagerService, cd: ChangeDetectorRef, userInfo: UserInfoService);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private subscribeToDS;
+    private getEffectiveGridRowTemplate;
+    private buildDefaultGridRowTemplateWithColumnTemplates;
+    private buildGridColumnTemplateSwitchCases;
+    private isAngularCellMarkupTemplate;
+    private normalizeGridCellTemplate;
+    private syncTableFilterUiFromDatasource;
+    parseData(data: any): any;
+    private rebuildTableActionMenuItems;
+    onColumnHeaderContextMenu(event: MouseEvent, col: any, menu: ContextMenu): void;
+    private ensureMetadataColumnsDatasourceRoute;
+    private ensureMetadataColumnsDatasourceSchema;
+    private fetchMetadataColumnRecord;
+    private openColumnMetadataEditor;
+    private hideColumnByMetadata;
+    private editColumnDisplayStrings;
+    parseColumns(columns: MetadatiColonna[]): any[];
+    onColumnResize(event: any): Promise<void>;
+    onColumnReorder(event: any): Promise<void>;
+    pageFilterChange(event: any): Promise<void>;
+    clearFilter(table: Table): Promise<void>;
+    resetGridState(table: Table): Promise<void>;
+    getTgtVal(tgt: any): any;
+    getAggregations(col: MetadatiColonna): any[];
+    exportXls(): Promise<void>;
+    refresh(): void;
+    canToggleClientSideCrud(): boolean;
+    isClientSideCrudActive(): boolean;
+    toggleClientSideCrud(): Promise<void>;
+    syncAndDisableClientSideCrud(): Promise<void>;
+    discardLocalAndDisableClientSideCrud(): Promise<void>;
+    addRecord(): void;
+    expandAll(): void;
+    collapseAll(): void;
+    onRowExpand(event: TableRowExpandEvent): void;
+    onRowCollapse(event: TableRowCollapseEvent): void;
+    toggleRow(item: any, event: Event, dt: Table): void;
+    rowSelect(item: any, event: any, dt: Table): void;
+    clearColumnFilter(col: MetadatiColonna, fetch: boolean): void;
+    hasActiveFilter(col: MetadatiColonna): boolean;
+    showActionColumn(): boolean;
+    private syncFilterInfoQueryString;
+    private syncGridStateQueryString;
+    private clearGridStateQueryString;
+    private scheduleSyncFilterInfoQueryString;
+    private scheduleSyncGridStateQueryString;
+    private syncPageInfoQueryString;
+    private syncSortInfoQueryString;
+    private pushGridStateUrl;
+    private areUrlsEquivalent;
+    private normalizedQueryParams;
+    private getRouteKey;
+    private getCurrentRouteColumnWidths;
+    private getCurrentRouteColumnLayout;
+    openColumnLayoutDialog(): void;
+    resetColumnLayoutDraftToMetadata(): void;
+    resetColumnLayoutDraftAndWidths(): Promise<void>;
+    moveColumnLayoutDraft(index: number, direction: -1 | 1): void;
+    saveColumnLayoutFromDialog(): Promise<void>;
+    private extractVisibleColumnOrderFromReorderEvent;
+    private applyPersistedColumnOrder;
+    private persistCurrentRouteColumnLayoutFromCols;
+    private loadPersistedColumnLayoutFromLocalStorage;
+    private hydratePersistedColumnLayoutFromServerIfNeeded;
+    private captureResizedColumnWidth;
+    private captureAllColumnWidthsFromTableDom;
+    private getFieldFromResizeEvent;
+    private getWidthFromResizeEvent;
+    private persistCurrentRouteColumnWidths;
+    resetCurrentRouteColumnWidths(): Promise<void>;
+    openSaveGridStateDialog(): void;
+    onSaveGridStateDialogSelectionChange(): void;
+    private updateSaveGridStateDialogSetAsDefault;
+    saveCurrentRouteGridState(): Promise<void>;
+    applySelectedGridState(stateId?: string): Promise<void>;
+    removeSelectedGridState(): Promise<void>;
+    onSelectedGridStateChange(stateId: string): Promise<void>;
+    onSavedStateDropdownChange(event: Event): Promise<void>;
+    setSelectedGridStateAsPreferred(): Promise<void>;
+    private normalizePersistedColumnWidthMap;
+    private normalizePersistedColumnLayoutMap;
+    private loadPersistedGridStatesFromLocalStorage;
+    private hydratePersistedGridStatesFromServerIfNeeded;
+    private refreshCurrentRouteSavedStates;
+    private tryAutoApplyPreferredStateForCurrentRoute;
+    private hasExplicitGridStateInQueryParams;
+    private persistGridStatesSettings;
+    private deepClone;
+    private syncSelectedSavedStateWithDatasourceCurrentState;
+    private getCurrentGridStateSignatureFromDatasource;
+    private getCurrentGridStateSignatureFromQueryOrDatasource;
+    private getSavedStateSignature;
+    private normalizeForCompare;
+    private getCurrentGridStateFromQueryParams;
+    private tryParseJson;
+    private normalizeFilterInfoForCompare;
+    private normalizeSortInfoForCompare;
+    private applySavedFilterInfoToDatasourceDescriptor;
+    private forceApplyPersistedColumnWidthsToTableDom;
+    private getLeadingStructuralColumnCount;
+    private debugColumnWidths;
+    private buildNewReportName;
+    private openReportDesigner;
+    private openReportViewer;
+    private buildReportParametersQueryString;
+    openReportFromMenu(reportName: string): Promise<void>;
+    cancelReportVariableDialog(): void;
+    applyReportVariablesAndOpenViewer(): void;
+    private loadReportList;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListGridComponent, "wuic-list-grid", never, { "hardcodedRoute": { "alias": "hardcodedRoute"; "required": false; }; "parentRecord": { "alias": "parentRecord"; "required": false; }; "parentMetaInfo": { "alias": "parentMetaInfo"; "required": false; }; "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; "rowCustomSelect": { "alias": "rowCustomSelect"; "required": false; }; }, {}, never, never, true, never>;
+}
+export {};

package/lib/component/map-list/map-list.component.d.ts

@@ -0,0 +1,137 @@
+import { ChangeDetectorRef, ElementRef, OnInit, QueryList } from '@angular/core';
+import { GoogleMap, MapInfoWindow, MapPolygon } from "@angular/google-maps";
+import { MarkerClusterer } from "@googlemaps/markerclusterer";
+import { MetaInfo } from '../../class/metaInfo';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { BehaviorSubject } from 'rxjs';
+import { Title } from '@angular/platform-browser';
+import { MapOptions, Point } from '../../class/mapOptions';
+import { MetadatiColonna } from '../../class/metadati_colonna';
+import { DynamicGenericTemplateComponent } from '../dynamic-generic-template/dynamic-generic-template.component';
+import { IBindable } from '../../class/IBindable';
+import { IDesigner } from '../../class/IDesigner';
+import { UserInfoService } from '../../service/user-info.service';
+import { TranslationManagerService } from '../../service/translation-manager.service';
+import { ActivatedRoute } from '@angular/router';
+import * as i0 from "@angular/core";
+export declare class MapListComponent implements OnInit, IBindable, IDesigner<MapOptions> {
+    private titleService;
+    private cd;
+    private route;
+    private userInfo;
+    private trslSrv;
+    map: GoogleMap;
+    info: MapInfoWindow;
+    markerElements: QueryList<any>;
+    mapHostRef?: ElementRef<HTMLElement>;
+    MAP_LIB: google.maps.MapsLibrary;
+    MARKER_LIB: google.maps.MarkerLibrary;
+    PLACE_LIB: google.maps.PlacesLibrary;
+    DRAWING_LIB: google.maps.DrawingLibrary;
+    hardcodedRoute: string;
+    parentRecord: any;
+    parentMetaInfo: MetaInfo;
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    metaInfo: MetaInfo;
+    archetypeOptions: MapOptions;
+    data: any[];
+    itemTemplateString: string;
+    itemTemplate: typeof DynamicGenericTemplateComponent;
+    center: Point;
+    markers: any[];
+    vertexArray: {
+        lat: number;
+        lng: number;
+    }[][];
+    circles: {
+        center: {
+            lat: number;
+            lng: number;
+        };
+        radius: number;
+    }[];
+    infoContent: string;
+    zoom: number;
+    parser: DOMParser;
+    dragging: boolean;
+    mc: MarkerClusterer;
+    loading: boolean;
+    bounds: google.maps.LatLngBounds;
+    currentMarker: any;
+    showConfigDialog: boolean;
+    fieldCandidates: MetadatiColonna[];
+    initCompleted: boolean;
+    private fetchInfoSubscription?;
+    private destroyed;
+    routeName: string;
+    mapHostHeightPx?: number;
+    private mapResizeObserver?;
+    private pendingMapResizeHandle?;
+    private pendingMapMeasureTimeouts;
+    private readonly mapHostMinHeight;
+    private readonly mapBottomPadding;
+    private readonly mapResizePassDelaysMs;
+    polygonEditMode: boolean;
+    private polygonSaveInProgress;
+    private editedPolygonKeys;
+    private readonly onWindowResize;
+    private readonly onWindowScroll;
+    constructor(titleService: Title, cd: ChangeDetectorRef, route: ActivatedRoute, userInfo: UserInfoService, trslSrv: TranslationManagerService);
+    get isAdmin(): boolean;
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    subscribeToDS(): Promise<void>;
+    boundsToPolyline(bounds: google.maps.LatLngBounds): string;
+    parseData(data: any): any;
+    getMarkerContent(record: any): any;
+    getCurrentPositionAsync(): Promise<GeolocationPosition | null>;
+    initMap(metaInfo: MetaInfo): Promise<void>;
+    openMapConfig(): void;
+    applyMapConfig(nextConfig?: any): Promise<void>;
+    saveMapMetadataPropsBag(): Promise<void>;
+    private syncArchetypeOptionsFromPropsBag;
+    private getMapPropsFromPropsBag;
+    private loadCurrentTableMetadataRecord;
+    private ensureMergedExtraProps;
+    private syncMapViewportFromMeta;
+    debounce(callback: any, waitTime: any): (...args: any[]) => void;
+    filterByBoundaries(): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    logCenter(): void;
+    hello($event: any): void;
+    addMarkerOnClick(event: any): void;
+    mapDragstart(markerElem: any, marker: any, $event: any): void;
+    mapDragend(markerElem: any, marker: any, $event: any): Promise<void>;
+    testMarker(): void;
+    setAllDraggable(): void;
+    hasPolygonField(): boolean;
+    showMarkerDragButton(): boolean;
+    showPolygonEditButton(): boolean;
+    togglePolygonEditing(): Promise<void>;
+    onPolygonShapeChanged(polygonElem: MapPolygon, record: any, polygonIndex: number): void;
+    openInfo(markerElem: any, marker: any): void;
+    renderMarkerInfo(selectedMarker: any): any;
+    private getRecordFieldValue;
+    private getPolygonMetadataColumn;
+    private setPolygonEditability;
+    private getVerticesFromMapPolygon;
+    private verticesToPolygonWkt;
+    private getPolygonEditKey;
+    private saveEditedPolygons;
+    private getPointMetadataColumn;
+    private updateMarkerRecordPositionInMemory;
+    private saveDraggedMarkerPosition;
+    private startMapResizeObserver;
+    private scheduleMapResizePasses;
+    private measureAndResizeMap;
+    private scheduleMapResize;
+    private updateMapHostHeight;
+    private getLayoutViewportBottom;
+    private clearPendingMapMeasureTimeouts;
+    private attachLayoutListeners;
+    private detachLayoutListeners;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MapListComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MapListComponent, "wuic-map-list", never, { "hardcodedRoute": { "alias": "hardcodedRoute"; "required": false; }; "parentRecord": { "alias": "parentRecord"; "required": false; }; "parentMetaInfo": { "alias": "parentMetaInfo"; "required": false; }; "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/meta-menu/meta-menu.component.d.ts

@@ -0,0 +1,97 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { MegaMenuItem, MenuItem } from 'primeng/api';
+import { Menubar } from 'primeng/menubar';
+import { MetadataProviderService } from '../../service/metadata-provider.service';
+import { Observable } from 'rxjs';
+import { AuthSessionService, AuthSessionState } from '../../service/auth-session.service';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { TranslationManagerService } from '../../service/translation-manager.service';
+import { UserInfoService } from '../../service/user-info.service';
+import { WorkflowRuntimeMenuService } from '../../service/workflow-runtime-menu.service';
+import * as i0 from "@angular/core";
+export declare class MetaMenuComponent implements OnInit, AfterViewInit, OnDestroy {
+    private metaSrv;
+    private authSession;
+    private trslSrv;
+    private userInfo;
+    private workflowRuntimeMenu;
+    items: MenuItem[];
+    private baseItems;
+    private runtimeItems;
+    private runtimeMenuExclusive;
+    private runtimeMenuSub?;
+    megaItems: MegaMenuItem[];
+    menu: Menubar;
+    menuMetadataDs: DataSourceComponent;
+    megaItems2: {
+        label: string;
+        icon: string;
+        items: {
+            label: string;
+            items: {
+                label: string;
+            }[];
+        }[][];
+    }[];
+    observer: MutationObserver;
+    targetNode: Element;
+    config: {
+        attributes: boolean;
+        childList: boolean;
+        subtree: boolean;
+    };
+    authState$: Observable<AuthSessionState>;
+    authReturnUrl: string;
+    loginUsername: string;
+    loginPassword: string;
+    metaMenuRoute: any;
+    contextItems: MenuItem[];
+    menuAdminMethods: Set<string>;
+    draggedMenuId: number | null;
+    moveDialogVisible: boolean;
+    pendingMove: {
+        sourceId: number;
+        targetId: number;
+        targetLabel?: string;
+    } | null;
+    dragInProgress: boolean;
+    constructor(metaSrv: MetadataProviderService, authSession: AuthSessionService, trslSrv: TranslationManagerService, userInfo: UserInfoService, workflowRuntimeMenu: WorkflowRuntimeMenuService);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onMenuItemClick(item: any, event?: Event): void;
+    onFocus($event: any): void;
+    ngOnInit(): Promise<void>;
+    onAuthReturnUrlChanged(): void;
+    loginWithGoogle(): void;
+    logout(): Promise<void>;
+    refreshAuthSession(): Promise<void>;
+    loginLegacy(): Promise<void>;
+    requiresAuthentication(state: AuthSessionState): boolean;
+    showAuthBar(state: AuthSessionState): boolean;
+    isAdminRole(auth?: any): boolean;
+    canOpenMenuContext(auth: AuthSessionState, item: any): boolean;
+    canDragMenu(auth: AuthSessionState, item: any): boolean;
+    onMenuContext(event: MouseEvent, item: any, auth: AuthSessionState, contextMenu: any): void;
+    onMenuDragStart(event: DragEvent, item: any, auth: AuthSessionState): void;
+    onMenuDragOver(event: DragEvent, item: any, auth: AuthSessionState): void;
+    onMenuDragEnd(): void;
+    onMenuDrop(event: DragEvent, item: any, auth: AuthSessionState): Promise<void>;
+    private loadMenuIfAllowed;
+    private applyMergedMenuItems;
+    private syncMenuAdminMethods;
+    hasMenuAdminMethod(methodName: string): boolean;
+    private buildContextItems;
+    private openMenuMetadata;
+    private getNodeContext;
+    private isDescendant;
+    cancelPendingMove(): void;
+    executePendingMove(action: 'before' | 'after' | 'inside'): Promise<void>;
+    private setDragState;
+    private addMenuEntry;
+    private removeMenuEntry;
+    private t;
+    private tf;
+    private ensureMenuObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetaMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetaMenuComponent, "wuic-meta-menu", never, {}, {}, never, never, true, never>;
+}

package/lib/component/metadata-editor/metadata-editor.component.d.ts

@@ -0,0 +1,125 @@
+import { AfterViewInit, OnDestroy, OnInit } from '@angular/core';
+import { MenuItem } from 'primeng/api';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import { MetaInfo } from '../../class/metaInfo';
+import { EditFormComponent } from '../edit-form/edit-form.component';
+import { TranslationManagerService } from '../../service/translation-manager.service';
+import { BehaviorSubject } from 'rxjs';
+import { MetadataProviderService } from '../../service/metadata-provider.service';
+import { Router } from '@angular/router';
+import { UserInfoService } from '../../service/user-info.service';
+import * as i0 from "@angular/core";
+export declare class MetadataEditorComponent implements AfterViewInit, OnInit, OnDestroy {
+    private trslSrv;
+    private metaSrv;
+    private router;
+    private userInfoSrv;
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    saveCallback: Function;
+    hideReports: boolean;
+    hideRelatedTableActions: boolean;
+    hideRelatedColumnActions: boolean;
+    datasourceTabelle: DataSourceComponent;
+    datasourceColonne: DataSourceComponent;
+    datasourceRelatedMetadataCustomActions: DataSourceComponent;
+    datasourceRelatedMetadataAuthTable: DataSourceComponent;
+    datasourceRelatedMetadataAuthColumn: DataSourceComponent;
+    datasourceRelatedMetadataTableStyles: DataSourceComponent;
+    datasourceRelatedMetadataColumnStyles: DataSourceComponent;
+    private datasourceRelatedMetadataCompat?;
+    get datasourceRelatedMetadata(): DataSourceComponent;
+    set datasourceRelatedMetadata(value: DataSourceComponent);
+    items: MenuItem[] | undefined;
+    metaInfo: MetaInfo;
+    ref: import("primeng/dynamicdialog").DynamicDialogRef<EditFormComponent>;
+    readonly metaCustomActionsRoute: any;
+    readonly metaAuthTableRoute: any;
+    readonly metaAuthColumnRoute: any;
+    readonly metaTableStyleRoute: any;
+    readonly metaColumnStyleRoute: any;
+    private fetchInfoSub?;
+    private translationsSub?;
+    private viewReady;
+    private extendedMenuRefreshSeq;
+    private reportMenuRefreshSeq;
+    private roleDescriptionById;
+    constructor(trslSrv: TranslationManagerService, metaSrv: MetadataProviderService, router: Router, userInfoSrv: UserInfoService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterViewInit(): void;
+    private unwrapMenuItem;
+    isDeletableMenuItem(item: any): boolean;
+    onMenuItemClick(event: Event, item: any): void;
+    onMenuItemDeleteClick(event: Event, item: any): Promise<void>;
+    private subscribeToDS;
+    private rebuildMenuItems;
+    private t;
+    private buildNewReportName;
+    private getCurrentRouteName;
+    private openReportDesigner;
+    private refreshReportMenuItems;
+    private refreshExtendedMetadataMenuItems;
+    private toMenuItems;
+    private getEditorStrategies;
+    private getRelatedMetadataDatasource;
+    private getEditorStrategyByKey;
+    private hydrateContextRecordFromSection;
+    private resolveEditorContext;
+    private deleteRelatedMetadataItem;
+    private notifyDeleteToSaveCallback;
+    private resolveFirstIdentityKey;
+    private normalizeRecordForDelete;
+    private deepUnwrapModelValue;
+    private appendRelatedMetadataSection;
+    private pickFirstDefined;
+    private formatTableAuthorizationLabel;
+    private formatAuthorizationPermissions;
+    private formatColumnAuthorizationLabel;
+    private formatColumnAuthorizationPermissions;
+    private formatTableStyleLabel;
+    private toTriStateFlag;
+    private toBool;
+    private normalizeKey;
+    private unwrapValue;
+    private getUserDescription;
+    private getRoleDescription;
+    private hydrateRoleDescriptionCache;
+    private hydrateRoleDescriptionsFromLookupRoutes;
+    private isRoleLookupField;
+    private extractLookupItems;
+    private pickLookupValue;
+    private pickLookupText;
+    private hasMeaningfulRoleText;
+    private selectRelevantColumnAuthorizations;
+    private selectRelevantTableAuthorizations;
+    private shouldShowAllAuthorizationsForMetadataEditor;
+    private getNestedTableAuthorizations;
+    private getNestedTableStyles;
+    private getNestedColumnStyles;
+    private getNestedColumnAuthorizations;
+    private getNestedRelationArray;
+    private computeAuthorizationScore;
+    private ensureDatasourceRoute;
+    private ensureDatasourceSchema;
+    private reloadMetadataEditorState;
+    private getEditorKeyFromRoute;
+    private openEditDialog;
+    private publishDatasourceState;
+    private resolveLocalEditorContext;
+    private openInsertRelatedMetadata;
+    private applyCurrentRouteColumnLookupFilter;
+    private openInsertColumnEditor;
+    private openInsertColumnActionMetadata;
+    private parseCreatedColumnId;
+    private getAddColumnEndpoint;
+    private syncMetadataFromSchema;
+    private getConnectionInfo;
+    private parseMaybeSerialized;
+    private getAsmxEndpoint;
+    private removeColumn;
+    private invalidateMetadataCaches;
+    openEditor(item: any): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MetadataEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MetadataEditorComponent, "wuic-metadata-editor", never, { "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; "saveCallback": { "alias": "saveCallback"; "required": false; }; "hideReports": { "alias": "hideReports"; "required": false; }; "hideRelatedTableActions": { "alias": "hideRelatedTableActions"; "required": false; }; "hideRelatedColumnActions": { "alias": "hideRelatedColumnActions"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/pager/pager.component.d.ts

@@ -0,0 +1,41 @@
+import { OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DataSourceComponent } from '../data-source/data-source.component';
+import * as i0 from "@angular/core";
+export declare class PagerComponent implements OnInit, OnChanges, OnDestroy {
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    pageSize: number;
+    currentPage: number;
+    totalRecords: number;
+    totalPages: number;
+    busy: boolean;
+    private datasourceSubscription?;
+    private fetchInfoSubscription?;
+    private boundDatasource?;
+    private syncingFromDatasource;
+    private preferredPagingApplied;
+    private applyingPreferredPaging;
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    prevPage(): Promise<void>;
+    nextPage(): Promise<void>;
+    firstPage(): Promise<void>;
+    lastPage(): Promise<void>;
+    applyPageSize(): Promise<void>;
+    applyCurrentPage(): Promise<void>;
+    private goToPage;
+    private applyExternalPagingInputs;
+    private bindToDatasource;
+    private subscribeToDatasource;
+    private applyPreferredPagingFromInputs;
+    private syncFromDatasource;
+    private recomputeTotals;
+    private applyPaging;
+    private setCurrentToFirstRow;
+    private getCurrentDatasource;
+    private normalizeInt;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PagerComponent, "wuic-pager", never, { "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/component/parametric-dialog/parametric-dialog.component.d.ts

@@ -0,0 +1,44 @@
+import { OnDestroy } from '@angular/core';
+import { DataSourceComponent } from './../data-source/data-source.component';
+import { ActivatedRoute, Router } from '@angular/router';
+import { DynamicDialogRef, DynamicDialogConfig } from 'primeng/dynamicdialog';
+import { BehaviorSubject } from 'rxjs';
+import { MetadatiColonna } from '../../class/metadati_colonna';
+import { MetaInfo } from '../../class/metaInfo';
+import { MetadatiCustomActionTabella } from '../../class/metadati_custom_actions_tabelle';
+import { WtoolboxService } from '../../service/wtoolbox.service';
+import * as i0 from "@angular/core";
+export declare class ParametricDialogComponent implements OnDestroy {
+    ref: DynamicDialogRef;
+    config: DynamicDialogConfig;
+    private route;
+    private router;
+    datasource: BehaviorSubject<DataSourceComponent>;
+    hardcodedDatasource: DataSourceComponent;
+    record: any;
+    metas: MetadatiColonna[];
+    metaInfo: MetaInfo;
+    routeName: BehaviorSubject<string>;
+    pristine: any;
+    formTemplate: any;
+    wtoolbox: typeof WtoolboxService;
+    private conditionsBootstrapped;
+    private fetchInfoSubscription?;
+    private recordValueSubscriptions;
+    private disableCallbacksRunning;
+    private disableCallbacksPending;
+    constructor(ref: DynamicDialogRef, config: DynamicDialogConfig, route: ActivatedRoute, router: Router);
+    ngOnInit(): void;
+    private bootstrapConditionalActions;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    parseData(data: any): any;
+    parseColumns(columns: MetadatiColonna[]): MetadatiColonna[];
+    fieldByTab(metas: MetadatiColonna[], tab: any): MetadatiColonna[];
+    execute($event: any, item: MetadatiCustomActionTabella): void;
+    private clearRecordValueSubscriptions;
+    private setupRecordValueSubscriptions;
+    private recomputeActionDisabledState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParametricDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParametricDialogComponent, "wuic-parametric-dialog", never, { "datasource": { "alias": "datasource"; "required": false; }; "hardcodedDatasource": { "alias": "hardcodedDatasource"; "required": false; }; }, {}, never, never, true, never>;
+}