@igo2/common 16.3.0 → 17.0.0-next.10

package/entity/entity-table/entity-table.component.d.ts

@@ -0,0 +1,342 @@
+import { FocusMonitor } from '@angular/cdk/a11y';
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges, TrackByFunction } from '@angular/core';
+import { FormControlName, NgControl, NgForm, UntypedFormBuilder, UntypedFormGroup } from '@angular/forms';
+import { DateAdapter, ErrorStateMatcher } from '@angular/material/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatTableDataSource } from '@angular/material/table';
+import { BehaviorSubject } from 'rxjs';
+import { EntityTablePaginatorOptions } from '../entity-table-paginator/entity-table-paginator.interface';
+import { EntityRecord, EntityState, EntityStore, EntityTableColumn, EntityTableColumnRenderer, EntityTableScrollBehavior, EntityTableSelectionState, EntityTableTemplate } from '../shared';
+import * as i0 from "@angular/core";
+interface CellData {
+    [key: string]: {
+        value: any;
+        class: {
+            [key: string]: boolean;
+        };
+        isUrl: boolean;
+        isImg: boolean;
+    };
+}
+interface RowData {
+    record: EntityRecord<object, EntityState>;
+    cellData: CellData;
+}
+export declare class EntityTableComponent implements OnInit, OnChanges, OnDestroy {
+    private cdRef;
+    private formBuilder;
+    protected _focusMonitor: FocusMonitor;
+    protected _elementRef: ElementRef<HTMLElement>;
+    ngControl: NgControl;
+    protected _parentForm: NgForm;
+    protected _controlName: FormControlName;
+    protected _defaultErrorStateMatcher: ErrorStateMatcher;
+    private dateAdapter;
+    entitySortChange$: BehaviorSubject<boolean>;
+    formGroup: UntypedFormGroup;
+    filteredOptions: {};
+    /**
+     * Reference to the column renderer types
+     * @internal
+     */
+    entityTableColumnRenderer: typeof EntityTableColumnRenderer;
+    /**
+     * Reference to the selection's state
+     * @internal
+     */
+    entityTableSelectionState: typeof EntityTableSelectionState;
+    /**
+     * Observable of the selection,s state
+     * @internal
+     */
+    readonly selectionState$: BehaviorSubject<EntityTableSelectionState>;
+    /**
+     * Subscription to the store's selection
+     */
+    private selection$$;
+    /**
+     * Subscription to the dataSource
+     */
+    private dataSource$$;
+    /**
+     * The last record checked. Useful for selecting
+     * multiple records by holding the shift key and checking
+     * checkboxes.
+     */
+    private lastRecordCheckedKey;
+    /**
+     * Entity store
+     */
+    store: EntityStore<object>;
+    /**
+     * Table paginator
+     */
+    set paginator(value: MatPaginator);
+    get paginator(): MatPaginator;
+    private _paginator;
+    /**
+     * Table template
+     */
+    template: EntityTableTemplate;
+    /**
+     * Scroll behavior on selection
+     */
+    scrollBehavior: EntityTableScrollBehavior;
+    /**
+     * Whether nulls should be first when sorting
+     */
+    sortNullsFirst: boolean;
+    /**
+     * Show the table paginator or not. False by default.
+     */
+    withPaginator: boolean;
+    /**
+     * Paginator options
+     */
+    paginatorOptions: EntityTablePaginatorOptions;
+    /**
+     * Event emitted when an entity (row) is clicked
+     */
+    entityClick: EventEmitter<object>;
+    /**
+     * Event emitted when an entity (row) is selected
+     */
+    entitySelectChange: EventEmitter<{
+        added: object[];
+    }>;
+    /**
+     * Event emitted when the table sort is changed.
+     */
+    entitySortChange: EventEmitter<{
+        column: EntityTableColumn;
+        direction: string;
+    }>;
+    /**
+     * Table headers
+     * @internal
+     */
+    get headers(): string[];
+    /**
+     * Data source consumable by the underlying material table
+     * @internal
+     */
+    dataSource: MatTableDataSource<RowData, MatPaginator>;
+    /**
+     * Whether selection is supported
+     * @internal
+     */
+    get selection(): boolean;
+    /**
+     * Whether a selection checkbox should be displayed
+     * @internal
+     */
+    get selectionCheckbox(): boolean;
+    /**
+     * Whether selection many entities should eb supported
+     * @internal
+     */
+    get selectMany(): boolean;
+    /**
+     * Whether selection many entities should eb supported
+     * @internal
+     */
+    get fixedHeader(): boolean;
+    get tableHeight(): string;
+    constructor(cdRef: ChangeDetectorRef, formBuilder: UntypedFormBuilder, _focusMonitor: FocusMonitor, _elementRef: ElementRef<HTMLElement>, ngControl: NgControl, _parentForm: NgForm, _controlName: FormControlName, _defaultErrorStateMatcher: ErrorStateMatcher, dateAdapter: DateAdapter<Date>);
+    /**
+     * Track the selection state to properly display the selection checkboxes
+     * @internal
+     */
+    ngOnInit(): void;
+    /**
+     * @internal
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Process text or number value change (edition)
+     */
+    onValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process boolean value change (edition)
+     */
+    onBooleanValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process select value change (edition)
+     */
+    onSelectValueChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process autocomplete value change (edition)
+     */
+    onAutocompleteValueChange(column: EntityTableColumn, record: EntityRecord<any>, event: any): void;
+    /**
+     * Process date value change (edition)
+     */
+    onDateChange(column: string, record: EntityRecord<any>, event: any): void;
+    /**
+     * Enable edition mode for one row
+     * More than one row can be edited at the same time
+     */
+    private enableEdit;
+    private handleDatasource;
+    /**
+     * Unbind the store watcher
+     * @internal
+     */
+    ngOnDestroy(): void;
+    private unsubscribeStore;
+    /**
+     * Trackby function
+     * @param record Record
+     * @param index Record index
+     * @internal
+     */
+    getTrackByFunction(): TrackByFunction<RowData>;
+    /**
+     * Trigger a refresh of the table. This can be useful when
+     * the data source doesn't emit a new value but for some reason
+     * the records need an update.
+     * @internal
+     */
+    refresh(): void;
+    paginatorChange(event: MatPaginator): void;
+    /**
+     * On sort, sort the store
+     * @param event Sort event
+     * @internal
+     */
+    onSort(event: {
+        active: string;
+        direction: string;
+    }): void;
+    /**
+     * When an entity is clicked, emit an event
+     * @param record Record
+     * @internal
+     */
+    onRowClick(record: EntityRecord<object>): void;
+    /**
+     * When an entity is selected, select it in the store and emit an event. Even if
+     * "many" is set to true, this method always select a single, exclusive row. Selecting
+     * multiple rows should be achieved by using the checkboxes.
+     * @param record Record
+     * @internal
+     */
+    onRowSelect(record: EntityRecord<object>): void;
+    /**
+     * Select or unselect all rows at once. On select, emit an event.
+     * @param toggle Select or unselect
+     * @internal
+     */
+    onToggleRows(toggle: boolean): void;
+    /**
+     * When an entity is toggled, select or unselect it in the store. On select,
+     * emit an event.
+     * @param toggle Select or unselect
+     * @param record Record
+     * @internal
+     */
+    onToggleRow(toggle: boolean, record: EntityRecord<object>): void;
+    /**
+     * When an entity is toggled, select or unselect it in the store. On select,
+     * emit an event.
+     * @param toggle Select or unselect
+     * @param record Record
+     * @internal
+     */
+    onShiftToggleRow(toggle: boolean, record: EntityRecord<object>, event: MouseEvent): void;
+    /**
+     * Compute the selection state
+     * @returns Whether all, some or no rows are selected
+     * @internal
+     */
+    private computeSelectionState;
+    /**
+     * Whether a column is sortable
+     * @param column Column
+     * @returns True if a column is sortable
+     * @internal
+     */
+    columnIsSortable(column: EntityTableColumn): boolean;
+    /**
+     * Whether a row is should be selected based on the underlying entity state
+     * @param record Record
+     * @returns True if a row should be selected
+     * @internal
+     */
+    rowIsSelected(record: EntityRecord<object>): boolean;
+    isImg(value: any): boolean;
+    isUrl(value: any): boolean;
+    /**
+     * Method to access an entity's values
+     * @param record Record
+     * @param column Column
+     * @returns Any value
+     * @internal
+     */
+    getValue(record: EntityRecord<object>, column: EntityTableColumn): any;
+    /**
+     * Method to access an entity's validation values
+     * @param column Column
+     * @param validationType string
+     * @returns Any value (false if no validation or not the one concerned)
+     * @internal
+     */
+    getValidationAttributeValue(column: EntityTableColumn, validationType: string): any;
+    isEdition(record: any): boolean;
+    /**
+     * Return the type of renderer of a column
+     * @param column Column
+     * @returns Renderer type
+     * @internal
+     */
+    getColumnRenderer(column: EntityTableColumn): EntityTableColumnRenderer;
+    /**
+     * Return the table ngClass
+     * @returns ngClass
+     * @internal
+     */
+    getTableClass(): {
+        [key: string]: boolean;
+    };
+    /**
+     * Return a header ngClass
+     * @returns ngClass
+     * @internal
+     */
+    getHeaderClass(): {
+        [key: string]: boolean;
+    };
+    /**
+     * Return a row ngClass
+     * @param record Record
+     * @returns ngClass
+     * @internal
+     */
+    getRowClass(record: EntityRecord<object>): {
+        [key: string]: boolean;
+    };
+    /**
+     * Return a row ngClass
+     * @param record Record
+     * @param column Column
+     * @returns ngClass
+     * @internal
+     */
+    getCellClass(record: EntityRecord<object>, column: EntityTableColumn): {
+        [key: string]: boolean;
+    };
+    /**
+     * When a button is clicked
+     * @param func Function
+     * @param record Record
+     * @internal
+     */
+    onButtonClick(clickFunc: (entity: object, record?: EntityRecord<object>) => void, record: EntityRecord<object>): void;
+    /**
+     * Retrieve column name without his "properties" tag (useful for edition workspace properties)
+     */
+    getColumnKeyWithoutPropertiesTag(column: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTableComponent, [null, null, null, null, { optional: true; self: true; }, { optional: true; }, { optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityTableComponent, "igo-entity-table", never, { "store": { "alias": "store"; "required": false; }; "paginator": { "alias": "paginator"; "required": false; }; "template": { "alias": "template"; "required": false; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; }; "sortNullsFirst": { "alias": "sortNullsFirst"; "required": false; }; "withPaginator": { "alias": "withPaginator"; "required": false; }; "paginatorOptions": { "alias": "paginatorOptions"; "required": false; }; }, { "entityClick": "entityClick"; "entitySelectChange": "entitySelectChange"; "entitySortChange": "entitySortChange"; }, never, never, true, never>;
+}
+export {};

package/entity/entity-table/entity-table.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-table.component";
+/**
+ * @deprecated import the EntityTableComponent directly
+ */
+export declare class IgoEntityTableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityTableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityTableModule, never, [typeof i1.EntityTableComponent], [typeof i1.EntityTableComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityTableModule>;
+}

package/entity/entity-table/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity-table.module';
+export * from './entity-table.component';

package/entity/entity-table-paginator/entity-table-paginator.component.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter, OnChanges, OnDestroy } from '@angular/core';
+import { MatPaginator, PageEvent } from '@angular/material/paginator';
+import { LanguageService } from '@igo2/core/language';
+import { MediaService } from '@igo2/core/media';
+import { BehaviorSubject } from 'rxjs';
+import { EntityStore } from '../shared';
+import { EntityTablePaginatorOptions } from './entity-table-paginator.interface';
+import * as i0 from "@angular/core";
+export declare class EntityTablePaginatorComponent implements OnChanges, OnDestroy {
+    private languageService;
+    private mediaService;
+    disabled: boolean;
+    hidePageSize: boolean;
+    pageIndex: number;
+    pageSize: number;
+    pageSizeOptions: number[];
+    showFirstLastButtons: boolean;
+    private count$$;
+    private entitySortChange$$;
+    private paginationLabelTranslation$$;
+    entitySortChange$: BehaviorSubject<boolean>;
+    /**
+     * Entity store
+     */
+    store: EntityStore<object>;
+    /**
+     * Paginator options
+     */
+    paginatorOptions: EntityTablePaginatorOptions;
+    /**
+     * Event emitted when the paginator changes the page size or page index.
+     */
+    page: EventEmitter<PageEvent>;
+    length: number;
+    /**
+     * Paginator emitted.
+     */
+    paginatorChange: EventEmitter<MatPaginator>;
+    constructor(languageService: LanguageService, mediaService: MediaService);
+    paginator: MatPaginator;
+    ngOnChanges(): void;
+    initPaginatorOptions(): void;
+    translateLabels(): void;
+    rangeLabel: (page: number, pageSize: number, length: number) => string;
+    private unsubscribeAll;
+    ngOnDestroy(): void;
+    emitPaginator(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntityTablePaginatorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EntityTablePaginatorComponent, "igo-entity-table-paginator", never, { "entitySortChange$": { "alias": "entitySortChange$"; "required": false; }; "store": { "alias": "store"; "required": false; }; "paginatorOptions": { "alias": "paginatorOptions"; "required": false; }; }, { "page": "page"; "paginatorChange": "paginatorChange"; }, never, never, true, never>;
+}

package/entity/entity-table-paginator/entity-table-paginator.module.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-table-paginator.component";
+/**
+ * @deprecated import the EntityTablePaginatorComponent directly
+ */
+export declare class IgoEntityTablePaginatorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityTablePaginatorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityTablePaginatorModule, never, [typeof i1.EntityTablePaginatorComponent], [typeof i1.EntityTablePaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityTablePaginatorModule>;
+}

package/entity/entity-table-paginator/index.d.ts

@@ -0,0 +1,3 @@
+export * from './entity-table-paginator.module';
+export * from './entity-table-paginator.component';
+export * from './entity-table-paginator.interface';

package/entity/entity.module.d.ts

@@ -0,0 +1,16 @@
+import { EntitySelectorComponent } from './entity-selector';
+import { EntityTableComponent } from './entity-table';
+import { EntityTablePaginatorComponent } from './entity-table-paginator';
+import * as i0 from "@angular/core";
+import * as i1 from "./entity-selector/entity-selector.component";
+import * as i2 from "./entity-table/entity-table.component";
+import * as i3 from "./entity-table-paginator/entity-table-paginator.component";
+export declare const ENTITY_DIRECTIVES: readonly [typeof EntitySelectorComponent, typeof EntityTableComponent, typeof EntityTablePaginatorComponent];
+/**
+ * @deprecated import the components directly or ENTITY_DIRECTIVES for every components/directives
+ */
+export declare class IgoEntityModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IgoEntityModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<IgoEntityModule, never, [typeof i1.EntitySelectorComponent, typeof i2.EntityTableComponent, typeof i3.EntityTablePaginatorComponent], [typeof i1.EntitySelectorComponent, typeof i2.EntityTableComponent, typeof i3.EntityTablePaginatorComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<IgoEntityModule>;
+}

package/entity/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@igo2/common/entity" />
+export * from './public_api';

package/entity/public_api.d.ts

@@ -0,0 +1,5 @@
+export * from './shared';
+export * from './entity.module';
+export * from './entity-selector';
+export * from './entity-table';
+export * from './entity-table-paginator';

package/entity/shared/entity.interfaces.d.ts

@@ -0,0 +1,102 @@
+import { Observable } from 'rxjs';
+import { EntityTableColumnRenderer } from './entity.enums';
+export type EntityKey = string | number;
+export interface EntityState {
+    [key: string]: any;
+}
+export interface EntityRecord<E extends object, S extends EntityState = EntityState> {
+    entity: E;
+    state: S;
+    revision: number;
+    ref: string;
+    edition?: boolean;
+}
+export interface EntityStoreStrategyOptions {
+}
+export interface EntityStoreStrategyFuncOptions extends EntityStoreStrategyOptions {
+    filterClauseFunc: EntityFilterClause;
+}
+export interface EntityTransactionOptions {
+    getKey?: (entity: object) => EntityKey;
+}
+export type EntityFilterClause<E = object> = (entity: E) => boolean;
+export interface EntitySortClause<E = object> {
+    valueAccessor: (entity: E) => string | number;
+    direction: string;
+    nullsFirst?: boolean;
+}
+export interface EntityJoinClause {
+    source: Observable<any | void>;
+    reduce: (param1: object, param2: any) => object;
+}
+export interface EntityOperationState {
+    added: boolean;
+    canceled: boolean;
+}
+export interface EntityTableTemplate {
+    columns: EntityTableColumn[];
+    selection?: boolean;
+    selectionCheckbox?: boolean;
+    selectMany?: boolean;
+    sort?: boolean;
+    fixedHeader?: boolean;
+    tableHeight?: string;
+    valueAccessor?: (entity: object, property: string, record: EntityRecord<object>) => any;
+    headerClassFunc?: () => {
+        [key: string]: boolean;
+    };
+    rowClassFunc?: (entity: object, record: EntityRecord<object>) => {
+        [key: string]: boolean;
+    };
+    cellClassFunc?: (entity: object, column: EntityTableColumn, record: EntityRecord<object>) => {
+        [key: string]: boolean;
+    };
+}
+export interface EntityTableColumnValidation {
+    readonly?: boolean;
+    mandatory?: boolean;
+    maxlength?: number;
+    minlength?: number;
+    minValue?: number;
+    maxValue?: number;
+}
+export interface TableRelation {
+    table: string;
+}
+export interface EntityTableColumn {
+    validation?: EntityTableColumnValidation;
+    name: string;
+    title: string;
+    renderer?: EntityTableColumnRenderer;
+    valueAccessor?: (entity: object, record: EntityRecord<object>) => any;
+    visible?: boolean;
+    linkColumnForce?: string;
+    sort?: boolean;
+    type?: string;
+    multiple?: boolean;
+    domainValues?: Array<SelectOption>;
+    relation?: TableRelation;
+    tooltip?: string;
+    cellClassFunc?: (entity: object, record: EntityRecord<object>) => {
+        [key: string]: boolean;
+    };
+    step?: number;
+    icon?: string;
+    onBlur?: (event: Event) => void;
+    onChange?: (event: Event) => void;
+    onClick?: (event: Event) => void;
+    onFocus?: (event: Event) => void;
+}
+export interface SelectOption {
+    id: number;
+    value: string;
+    disabled?: boolean;
+}
+export interface EntityTableButton {
+    icon: string;
+    click: (entity: object, record: EntityRecord<object>) => void;
+    color?: 'primary' | 'accent' | 'warn';
+    disabled?: boolean;
+    style?: 'mat-mini-fab' | 'mat-icon-button';
+    editMode?: boolean;
+}