@sumaris-net/ngx-components 2.2.1-rc16 → 2.2.1-rc19

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sumaris-net/ngx-components",
   "description": "SUMARiS Angular components",
-  "version": "2.2.1-rc16",
+  "version": "2.2.1-rc19",
   "author": "contact@e-is.pro",
   "license": "AGPL-3.0",
   "readmeFilename": "README.md",

package/public_api.d.ts

@@ -162,7 +162,9 @@ export * from './src/app/core/form/properties/properties.module';
 export * from './src/app/core/form/text-popover/text-form.component';
 export * from './src/app/core/form/text-popover/text-popover.component';
 export * from './src/app/core/form/text-popover/text-popover.module';
+export * from './src/app/core/table/table.model';
 export * from './src/app/core/table/table.class';
+export * from './src/app/core/table/async-table.class';
 export * from './src/app/core/table/table.utils';
 export * from './src/app/core/table/table.module';
 export * from './src/app/core/table/memory-table.class';

package/src/app/core/table/async-table.class.d.ts

@@ -0,0 +1,366 @@
+import { AfterViewInit, EventEmitter, Injector, OnDestroy, OnInit } from '@angular/core';
+import { MatPaginator } from '@angular/material/paginator';
+import { MatSort, MatSortable, SortDirection } from '@angular/material/sort';
+import { MatTable } from '@angular/material/table';
+import { BehaviorSubject, Observable, Subject, Subscription } from 'rxjs';
+import { SelectionModel } from '@angular/cdk/collections';
+import { IEntity } from '../services/model/entity.model';
+import { AlertController, ModalController, ToastController } from '@ionic/angular';
+import { ActivatedRoute, Router } from '@angular/router';
+import { ColumnItem } from './table-select-columns.component';
+import { Location } from '@angular/common';
+import { IAppForm } from '../form/form.utils';
+import { LocalSettingsService } from '../services/local-settings.service';
+import { TranslateService } from '@ngx-translate/core';
+import { MatAutocompleteConfigHolder, MatAutocompleteFieldAddOptions, MatAutocompleteFieldConfig } from '../../shared/material/autocomplete/material.autocomplete.config';
+import { CompletableEvent } from '../../shared/events';
+import { WaitForOptions } from '../../shared/observables';
+import { ShowToastOptions } from '../../shared/toast/toasts';
+import { CdkColumnDef } from '@angular/cdk/table';
+import { LoadResult } from '../../shared/services/entity-service.class';
+import { FormErrorTranslator, FormErrorTranslatorOptions, IFormControlPathTranslator } from '../../shared/validator/form-error-adapter.class';
+import { SaveActionType } from './table.model';
+import { AsyncTableElement } from '@e-is/ngx-material-table/src/app/ngx-material-table/async/async-table-element';
+import { EntitiesAsyncTableDataSource } from './entities-async-table-datasource.class';
+import * as i0 from "@angular/core";
+export declare abstract class AppAsyncTable<T extends IEntity<T, ID>, F = any, ID = number> implements OnInit, OnDestroy, AfterViewInit, IAppForm, IFormControlPathTranslator {
+    protected columns: string[];
+    protected _dataSource?: EntitiesAsyncTableDataSource<T, F, ID>;
+    private _filter?;
+    private _initialized;
+    private _subscription;
+    private _dataSourceLoadingSubscription;
+    private _cellValueChangesDefs;
+    protected _enabled: boolean;
+    protected _autocompleteConfigHolder: MatAutocompleteConfigHolder;
+    protected allowRowDetail: boolean;
+    protected route: ActivatedRoute;
+    protected router: Router;
+    protected location: Location;
+    protected settings: LocalSettingsService;
+    protected translate: TranslateService;
+    protected modalCtrl: ModalController;
+    protected alertCtrl: AlertController;
+    protected toastController: ToastController;
+    protected previouslyEditedRowId: number;
+    protected formErrorAdapter: FormErrorTranslator;
+    protected readonly destroySubject: Subject<void>;
+    excludesColumns: string[];
+    displayedColumns: string[];
+    totalRowCount: number | null;
+    visibleRowCount: number;
+    errorTranslatorOptions: FormErrorTranslatorOptions;
+    readonly readySubject: BehaviorSubject<boolean>;
+    readonly loadingSubject: BehaviorSubject<boolean>;
+    readonly savingSubject: BehaviorSubject<boolean>;
+    readonly touchedSubject: BehaviorSubject<boolean>;
+    readonly dirtySubject: BehaviorSubject<boolean>;
+    readonly errorSubject: BehaviorSubject<string>;
+    get error(): string;
+    set error(error: string);
+    selection: SelectionModel<AsyncTableElement<T>>;
+    autocompleteFields: {
+        [key: string]: MatAutocompleteFieldConfig;
+    };
+    readonly mobile: boolean;
+    settingsId: string;
+    debug: boolean;
+    i18nColumnPrefix: string;
+    i18nColumnSuffix: string;
+    autoLoad: boolean;
+    readOnly: boolean;
+    inlineEdition: boolean;
+    focusFirstColumn: boolean;
+    confirmBeforeDelete: boolean;
+    confirmBeforeCancel: boolean;
+    undoableDeletion: boolean;
+    saveBeforeDelete: boolean;
+    keepEditedRowOnSave: boolean;
+    saveBeforeSort: boolean;
+    saveBeforeFilter: boolean;
+    propagateRowError: boolean;
+    defaultSortBy: string;
+    defaultSortDirection: SortDirection;
+    defaultPageSize: number;
+    defaultPageSizeOptions: number[];
+    focusColumn: string;
+    get firstUserColumn(): string;
+    get lastUserColumn(): string;
+    set dataSource(value: EntitiesAsyncTableDataSource<T, F, ID>);
+    get dataSource(): EntitiesAsyncTableDataSource<T, F, ID>;
+    set filter(value: F);
+    get filter(): F;
+    get empty(): boolean;
+    onRefresh: EventEmitter<any>;
+    onOpenRow: EventEmitter<AsyncTableElement<T>>;
+    onNewRow: EventEmitter<any>;
+    onStartEditingRow: EventEmitter<AsyncTableElement<T>>;
+    onConfirmEditCreateRow: EventEmitter<AsyncTableElement<T>>;
+    onCancelOrDeleteRow: EventEmitter<AsyncTableElement<T>>;
+    onBeforeDeleteRows: EventEmitter<import("../../shared/events").PromiseEvent<boolean, {
+        rows: AsyncTableElement<T>[];
+    }>>;
+    onBeforeCancelRows: EventEmitter<import("../../shared/events").PromiseEvent<boolean, {
+        rows: AsyncTableElement<T>[];
+    }>>;
+    onBeforeSave: EventEmitter<import("../../shared/events").PromiseEvent<{
+        confirmed: boolean;
+        save: boolean;
+    }, {
+        action: SaveActionType;
+        valid: boolean;
+    }>>;
+    onAfterDeletedRows: EventEmitter<AsyncTableElement<T>[]>;
+    onSort: EventEmitter<any>;
+    onDirty: EventEmitter<boolean>;
+    onError: EventEmitter<string>;
+    get dirty(): boolean;
+    get valid(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get touched(): boolean;
+    get untouched(): boolean;
+    disable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    enable(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    get enabled(): boolean;
+    set disabled(value: boolean);
+    get disabled(): boolean;
+    markAsDirty(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsPristine(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAsUntouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): Promise<void>;
+    /**
+     * @deprecated prefer to use markAllAsTouched()
+     * @param opts
+     */
+    markAsTouched(opts?: {
+        onlySelf?: boolean;
+        emitEvent?: boolean;
+    }): void;
+    markAllAsTouched(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsSaving(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsSaved(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsLoading(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsLoaded(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    markAsReady(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    get loading(): boolean;
+    get loaded(): boolean;
+    enableSort(): void;
+    disableSort(): void;
+    set pageSize(value: number);
+    get pageSize(): number;
+    get pageOffset(): number;
+    get sortActive(): string;
+    get sortDirection(): 'asc' | 'desc';
+    private _paginator;
+    set paginator(value: MatPaginator);
+    get paginator(): MatPaginator;
+    get destroyed(): boolean;
+    table: MatTable<T>;
+    childPaginator: MatPaginator;
+    sort: MatSort;
+    protected constructor(injector: Injector, columns: string[], _dataSource?: EntitiesAsyncTableDataSource<T, F, ID>, _filter?: F);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    updateView(res: LoadResult<T> | undefined, opts?: {
+        emitEvent?: boolean;
+    }): Promise<void>;
+    setDatasource(datasource: EntitiesAsyncTableDataSource<T, F, ID>): void;
+    resetDataSource(): void;
+    addColumnDef(column: CdkColumnDef): void;
+    removeColumnDef(column: CdkColumnDef): void;
+    setFilter(filter: F, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    confirmAndAdd(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    confirmAndBackward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    confirmAndForward(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    /**
+     * Confirm the creation of the given row, or if not specified the currently edited row
+     *
+     * @param event
+     * @param row
+     */
+    confirmEditCreate(event?: Event, row?: AsyncTableElement<T>): Promise<boolean>;
+    cancelOrDelete(event: Event, row: AsyncTableElement<T>, opts?: {
+        interactive?: boolean;
+        keepEditing?: boolean;
+    }): Promise<void>;
+    addRow(event?: Event, insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+    }): Promise<boolean>;
+    save(opts?: {
+        keepEditing?: boolean;
+    }): Promise<boolean>;
+    cancel(event?: Event, opts?: {
+        interactive?: boolean;
+    }): Promise<void>;
+    duplicateRow(event?: Event, row?: AsyncTableElement<T>, opts?: {
+        skipProperties?: string[];
+    }): Promise<boolean>;
+    /** Whether the number of selected elements matches the total number of rows. */
+    isAllSelected(): boolean;
+    /** Selects all rows if they are not all selected; otherwise clear selection. */
+    masterToggle(): Promise<void>;
+    deleteSelection(event: Event): Promise<number>;
+    /**
+     *
+     * @param event
+     * @param row
+     * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+     *  And to force deletion even if table is busy
+     */
+    deleteRow(event: Event | null, row: AsyncTableElement<T>, opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    /**
+     *
+     * @param event
+     * @param rows
+     * @param opts Use interactive=false to avoid user interaction (e.g. user confirmation)
+     *    And to force deletion even if table is busy
+     */
+    deleteRows(event: Event | null, rows: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<number>;
+    selectRowById(id: number): Promise<boolean>;
+    /**
+     * Try to select row by data. Will use dataEquals() (that call EntityUtils.equals()) to find same row's data
+     * @param data
+     */
+    selectRowByData(data: T): Promise<boolean>;
+    clickRow(event: Event | undefined, row: AsyncTableElement<T>): Promise<boolean>;
+    moveRow(id: number, direction: number): Promise<void>;
+    ready(opts?: WaitForOptions): Promise<void>;
+    waitIdle(opts?: WaitForOptions): Promise<void>;
+    openSelectColumnsModal(event?: Event): Promise<any>;
+    trackByFn(index: number, row: AsyncTableElement<T>): number;
+    doRefresh(event?: CompletableEvent): void;
+    getCurrentColumns(): ColumnItem[];
+    escapeEditingRow(event?: Event, row?: AsyncTableElement<T>): Promise<void>;
+    translateControlPath(path: string): string;
+    protected editRow(event: Event | undefined, row: AsyncTableElement<T>, opts?: {
+        focusColumn?: string;
+    }): Promise<boolean>;
+    /**
+     * Try to select row, by row.id, or by data. WIll use EntityUtils.equals()
+     * @param id
+     * @param data
+     * @protected
+     */
+    protected selectRowByIdOrData(id: number, data?: T): Promise<boolean>;
+    /**
+     * return the selected row if unique in selection
+     */
+    protected get singleSelectedRow(): AsyncTableElement<T>;
+    protected canDeleteRows(rows: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    protected canCancelRows(rows?: AsyncTableElement<T>[], opts?: {
+        interactive?: boolean;
+    }): Promise<boolean>;
+    protected saveBeforeAction(saveAction: SaveActionType): Promise<boolean>;
+    /**
+     * Open a row detail view. By default, will to open row detail page.
+     * Can be overridden by subclasses, BUT prefer to subscribe on onOpenRow
+     * @param id
+     * @param row
+     * @protected
+     */
+    protected openRow(id: ID, row: AsyncTableElement<T>): Promise<boolean>;
+    protected openNewRowDetail(event?: any): Promise<boolean>;
+    protected getRequiredColumns(): string[];
+    protected getUserColumns(): string[];
+    protected getSortedColumn(): MatSortable;
+    protected getPageSize(): number;
+    protected getDisplayColumns(): string[];
+    /**
+     * Recompute display columns
+     *
+     * @protected
+     */
+    protected updateColumns(): void;
+    protected registerSubscription(sub: Subscription): void;
+    protected unregisterSubscription(sub: Subscription): void;
+    protected registerAutocompleteField<E = any, EF = any>(fieldName: string, options?: MatAutocompleteFieldAddOptions<E, EF>): MatAutocompleteFieldConfig<E, EF>;
+    protected getI18nColumnName(columnName: string): string;
+    protected generateTableId(): string;
+    protected addRowToTable(insertAt?: number, opts?: {
+        focusColumn?: string;
+        editing?: boolean;
+        emitEvent?: boolean;
+    }): Promise<AsyncTableElement<T> | undefined>;
+    protected registerCellValueChanges(name: string, formPath?: string, emitInitialValue?: boolean): Observable<any>;
+    protected setShowColumn(columnName: string, show: boolean, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected getShowColumn(columnName: string): boolean;
+    protected startsWithUpperCase(input: string, search: string): boolean;
+    protected markForCheck(): void;
+    protected askDeleteConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean>;
+    protected askCancelConfirmation(event?: Event, rows?: AsyncTableElement<T>[]): Promise<boolean>;
+    protected askRestoreConfirmation(event?: Event): Promise<boolean>;
+    protected showToast(opts: ShowToastOptions): Promise<import("@ionic/core").OverlayEventDetail<any>>;
+    protected resetError(opts?: {
+        emitEvent?: boolean;
+    }): void;
+    protected getRowError(row?: AsyncTableElement<T>, opts?: FormErrorTranslatorOptions): string;
+    protected setError(value: string, opts?: {
+        emitEvent?: boolean;
+    }): void;
+    /**
+     * Compare data equality (default by id)
+     * Can be overridden to add additional properties to compare
+     *
+     * @param d1
+     * @param d2
+     * @protected
+     */
+    protected equals(d1: T, d2: T): boolean;
+    protected markRowAsDirty(row?: AsyncTableElement<T>, opts?: {
+        onlySelf?: boolean;
+        emitEVent?: boolean;
+    }): void;
+    private listenSortAndPaginationEvents;
+    private editRowById;
+    private setLoading;
+    private deleteNewRow;
+    private deleteExistingRow;
+    private cancelExistingRow;
+    private checkIfRowPristine;
+    private checkIfPristine;
+    private applyFilter;
+    private listenDatasourceLoading;
+    private startCellValueChanges;
+    private stopCellValueChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppAsyncTable<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppAsyncTable<any, any, any>, never, never, { "settingsId": "settingsId"; "debug": "debug"; "i18nColumnPrefix": "i18nColumnPrefix"; "i18nColumnSuffix": "i18nColumnSuffix"; "autoLoad": "autoLoad"; "readOnly": "readOnly"; "inlineEdition": "inlineEdition"; "focusFirstColumn": "focusFirstColumn"; "confirmBeforeDelete": "confirmBeforeDelete"; "confirmBeforeCancel": "confirmBeforeCancel"; "undoableDeletion": "undoableDeletion"; "saveBeforeDelete": "saveBeforeDelete"; "keepEditedRowOnSave": "keepEditedRowOnSave"; "saveBeforeSort": "saveBeforeSort"; "saveBeforeFilter": "saveBeforeFilter"; "propagateRowError": "propagateRowError"; "defaultSortBy": "defaultSortBy"; "defaultSortDirection": "defaultSortDirection"; "defaultPageSize": "defaultPageSize"; "defaultPageSizeOptions": "defaultPageSizeOptions"; "focusColumn": "focusColumn"; "dataSource": "dataSource"; "filter": "filter"; "disabled": "disabled"; "paginator": "paginator"; }, { "onRefresh": "onRefresh"; "onOpenRow": "onOpenRow"; "onNewRow": "onNewRow"; "onStartEditingRow": "onStartEditingRow"; "onConfirmEditCreateRow": "onConfirmEditCreateRow"; "onCancelOrDeleteRow": "onCancelOrDeleteRow"; "onBeforeDeleteRows": "onBeforeDeleteRows"; "onBeforeCancelRows": "onBeforeCancelRows"; "onBeforeSave": "onBeforeSave"; "onAfterDeletedRows": "onAfterDeletedRows"; "onSort": "onSort"; "onDirty": "onDirty"; "onError": "onError"; }, never, never, false>;
+}

package/src/app/core/table/entities-async-table-datasource.class.d.ts

@@ -0,0 +1,81 @@
+import { TableDataSourceConfig, ValidatorService } from '@e-is/ngx-material-table';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { Entity, IEntity } from '../services/model/entity.model';
+import { OnDestroy } from '@angular/core';
+import { SortDirection } from '@angular/material/sort';
+import { CollectionViewer } from '@angular/cdk/collections';
+import { EntitiesServiceWatchOptions, FetchMoreFn, IEntitiesService, LoadResult } from '../../shared/services/entity-service.class';
+import { AsyncTableElement } from '@e-is/ngx-material-table/src/app/ngx-material-table/async/async-table-element';
+import { AsyncTableDataSource } from '@e-is/ngx-material-table/public_async_api';
+import * as i0 from "@angular/core";
+export interface EntitiesAsyncTableDataSourceConfig<T extends Entity<T, ID>, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions, SO = any> extends TableDataSourceConfig {
+    onRowCreated?: (row: AsyncTableElement<T>) => Promise<void> | void;
+    saveOnlyDirtyRows?: boolean;
+    readOnly?: boolean;
+    /**
+     * @deprecated
+     */
+    dataServiceOptions?: WO & SO;
+    watchAllOptions?: WO;
+    saveAllOptions?: SO;
+    [key: string]: any;
+}
+export declare class EntitiesAsyncTableDataSource<T extends IEntity<T, ID>, F = any, ID = number, WO extends EntitiesServiceWatchOptions = EntitiesServiceWatchOptions, SO = any, V extends ValidatorService = ValidatorService, C extends EntitiesAsyncTableDataSourceConfig<T, ID, WO, SO> = EntitiesAsyncTableDataSourceConfig<T, ID, WO, SO>, R extends AsyncTableElement<T> = AsyncTableElement<T>> extends AsyncTableDataSource<T, V, C, R> implements OnDestroy {
+    readonly dataService: IEntitiesService<T, F, WO>;
+    private readonly _entityName;
+    protected _debug: boolean;
+    protected _creating: boolean;
+    protected _saving: boolean;
+    protected _fetchMoreFn: FetchMoreFn<LoadResult<T>>;
+    protected _stopWatchSubject: Subject<void>;
+    loadingSubject: BehaviorSubject<boolean>;
+    get watchAllOptions(): WO;
+    set watchAllOptions(value: WO);
+    get saveAllOptions(): SO;
+    set saveAllOptions(value: SO);
+    get loaded(): boolean;
+    get loading(): boolean;
+    /**
+     * Creates a new TableDataSource instance, that can be used as datasource of `@angular/cdk` data-table.
+     *
+     * @param dataService A service to load and save data
+     * @param dataType Type of data contained by the Table. If not specified, then `data` with at least one element must be specified.
+     * @param environment
+     * @param validatorService Service that create instances of the FormGroup used to validate row fields.
+     * @param config Additional configuration for table.
+     */
+    constructor(dataType: new () => T, dataService: IEntitiesService<T, F, WO>, validatorService?: V, options?: C);
+    ngOnDestroy(): void;
+    watchAll(offset: number, size: number, sortBy?: string, sortDirection?: SortDirection, filter?: Partial<F>): Observable<LoadResult<T>>;
+    protected updateDatasourceFromRows(rows: R[]): void;
+    save(): Promise<boolean>;
+    updateDatasource(data: T[], opts?: {
+        emitEvent: boolean;
+    }): void;
+    connect(collectionViewer: CollectionViewer): Observable<R[] | ReadonlyArray<R>>;
+    disconnect(collectionViewer?: CollectionViewer): void;
+    waitIdle(debounceTimeMs?: number): Promise<any>;
+    confirmCreate(row: R): Promise<boolean>;
+    confirmEdit(row: R): Promise<boolean>;
+    startEdit(row: R): Promise<boolean>;
+    handleError(error: any, message: string): Observable<LoadResult<T>>;
+    handleServiceError(error: any): void;
+    delete(id: number): Promise<boolean>;
+    deleteAll(rows: R[]): Promise<any>;
+    getRow(id: number): R;
+    getRows(): R[];
+    getEditingRows(): R[];
+    getSingleEditingRow(): R;
+    hasSomeEditingRow(): boolean;
+    createNew(insertAt?: number, opts?: {
+        editing: boolean;
+    }): Promise<R | undefined>;
+    getData(): T[];
+    fetchMore(opts?: {
+        emitEvent: boolean;
+    }): Promise<boolean>;
+    markAsLoading(): void;
+    markAsLoaded(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EntitiesAsyncTableDataSource<any, any, any, any, any, any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<EntitiesAsyncTableDataSource<any, any, any, any, any, any, any, any>, never, never, {}, {}, never, never, false>;
+}

package/src/app/core/table/table.class.d.ts

@@ -21,29 +21,8 @@ import { ShowToastOptions } from '../../shared/toast/toasts';
 import { CdkColumnDef } from '@angular/cdk/table';
 import { LoadResult } from '../../shared/services/entity-service.class';
 import { FormErrorTranslator, FormErrorTranslatorOptions, IFormControlPathTranslator } from '../../shared/validator/form-error-adapter.class';
+import { SaveActionType } from './table.model';
 import * as i0 from "@angular/core";
-export declare const SETTINGS_DISPLAY_COLUMNS = "displayColumns";
-export declare const SETTINGS_SORTED_COLUMN = "sortedColumn";
-export declare const SETTINGS_FILTER = "filter";
-export declare const SETTINGS_PAGE_SIZE = "pageSize";
-export declare const DEFAULT_PAGE_SIZE = 20;
-export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
-export declare const RESERVED_START_COLUMNS: string[];
-export declare const RESERVED_END_COLUMNS: string[];
-export declare const DEFAULT_REQUIRED_COLUMNS: string[];
-export declare class CellValueChangeListener {
-    subject: Subject<any>;
-    subscription: Subscription;
-    formPath: string;
-    emitInitialValue: boolean;
-}
-export interface IModalDetailOptions<T = any> {
-    isNew: boolean;
-    data: T;
-    disabled: boolean;
-    onDelete?: (event: Event, data: T) => Promise<boolean>;
-}
-export declare type SaveActionType = 'delete' | 'sort' | 'filter';
 export declare abstract class AppTable<T extends IEntity<T, ID>, F = any, ID = number> implements OnInit, OnDestroy, AfterViewInit, IAppForm, IFormControlPathTranslator {
     protected columns: string[];
     protected _dataSource?: EntitiesTableDataSource<T, F, ID>;

package/src/app/core/table/table.model.d.ts

@@ -0,0 +1,23 @@
+import { Subject, Subscription } from 'rxjs';
+export declare const SETTINGS_DISPLAY_COLUMNS = "displayColumns";
+export declare const SETTINGS_SORTED_COLUMN = "sortedColumn";
+export declare const SETTINGS_FILTER = "filter";
+export declare const SETTINGS_PAGE_SIZE = "pageSize";
+export declare const DEFAULT_PAGE_SIZE = 20;
+export declare const DEFAULT_PAGE_SIZE_OPTIONS: number[];
+export declare const RESERVED_START_COLUMNS: string[];
+export declare const RESERVED_END_COLUMNS: string[];
+export declare const DEFAULT_REQUIRED_COLUMNS: string[];
+export declare class CellValueChangeListener {
+    subject: Subject<any>;
+    subscription: Subscription;
+    formPath: string;
+    emitInitialValue: boolean;
+}
+export interface IModalDetailOptions<T = any> {
+    isNew: boolean;
+    data: T;
+    disabled: boolean;
+    onDelete?: (event: Event, data: T) => Promise<boolean>;
+}
+export declare type SaveActionType = 'delete' | 'sort' | 'filter';

package/plugins/clovelced-plugin-audiomanagement/README.md

@@ -1,66 +0,0 @@
-# cordova-plugin-audiomanagement
-A plugin to manage audio mode and volume
-
-## Installation
-`cordova plugin add clovelced-plugin-audiomanagement`
-
-## Supported Platforms
-
-- Android
-
-## AUDIO MODE
-- Define the audio mode
-```javascript
-AudioManagement.setAudioMode(audioMode, onSuccess, onError);
-
-// Example
-AudioManagement.setAudioMode(AudioManagement.AudioMode.NORMAL, function(){}, function(){});
-```
-
-- Get the current audio mode
-```javascript
-AudioManagement.getAudioMode(onSuccess, onError);
-
-AudioManagement.getAudioMode(function(result){
-  console.log('Mode' + result.audioMode);     // will show '2'
-  console.log('Label' + result.label);        // will show 'Normal'
-}, onError);
-```
-
-### The audio mode
-- `AudioManagement.AudioMode.SILENT` = 0
-- `AudioManagement.AudioMode.VIBRATE` = 1
-- `AudioManagement.AudioMode.NORMAL` = 2
-
-## VOLUME
-- Set the volume
-```javascript
-AudioManagement.setVolume(type, volume, onSuccess, onError);
-
-// Example
-AudioManagement.setVolume(AudioManagement.VolumeType.RING, 10, function(){}, function(){});
-```
-
-- Get the volume of a stream
-```javascript
-AudioManagement.getVolume(type, onSuccess, onError);
-
-AudioManagement.getVolume(AudioManagement.VolumeType.RING, function(result){  
-  console.log('Volume' + result.volume);        // will show '12'
-}, onError);
-```
-
-- Get the max volume of a stream
-```javascript
-AudioManagement.getMaxVolume(type, onSuccess, onError);
-
-AudioManagement.getMaxVolume(AudioManagement.VolumeType.RING, function(result){  
-  console.log('Max volume' + result.maxVolume);        // will show '15'
-}, onError);
-```
-
-### The volume type
-- `AudioManagement.VolumeType.RING` = 0
-- `AudioManagement.VolumeType.MUSIC` = 1
-- `AudioManagement.VolumeType.NOTIFICATION` = 2
-- `AudioManagement.VolumeType.SYSTEM` = 3