remult 0.22.3 → 0.22.4

package/esm/angular/interfaces/src/filter-helper.js

@@ -0,0 +1,59 @@
+import { getEntityRef } from "remult";
+import { getEntitySettings } from 'remult/src/remult3';
+import { getFieldDefinition } from "./data-control-interfaces";
+export class FilterHelper {
+    reloadData;
+    repository;
+    filterRow;
+    filterColumns = [];
+    forceEqual = [];
+    constructor(reloadData, repository) {
+        this.reloadData = reloadData;
+        this.repository = repository;
+    }
+    isFiltered(columnInput) {
+        return this.filterColumns.indexOf(getFieldDefinition(columnInput)) >= 0;
+    }
+    filterColumn(columnInput, clearFilter, useContainsFilter) {
+        let column = getFieldDefinition(columnInput);
+        if (!column)
+            return;
+        if (clearFilter) {
+            this.filterColumns.splice(this.filterColumns.indexOf(column, 1), 1);
+            this.forceEqual.splice(this.forceEqual.indexOf(column, 1), 1);
+        }
+        else if (this.filterColumns.indexOf(column) < 0) {
+            this.filterColumns.push(column);
+            if (useContainsFilter === false)
+                this.forceEqual.push(column);
+        }
+        this.reloadData();
+    }
+    addToFindOptions(opt) {
+        this.filterColumns.forEach(c => {
+            //@ts-ignore
+            let val = this.filterRow[c.key];
+            let f = val;
+            if (c.valueType != Number &&
+                c.valueType != Date &&
+                c.valueType != Boolean &&
+                getEntitySettings(c.valueType, false) == undefined &&
+                !this.forceEqual.find(x => c.key == x.key))
+                f = { $contains: getEntityRef(this.filterRow).fields[c.key].inputValue };
+            else if (c.valueType == Date) {
+                if (val) {
+                    let v = val;
+                    v = new Date(v.getFullYear(), v.getMonth(), v.getDate());
+                    f = { $gte: v, $lt: (new Date(v.getFullYear(), v.getMonth(), v.getDate() + 1)) };
+                }
+            }
+            let w = { [c.key]: f };
+            if (opt.where) {
+                let x = opt.where;
+                opt.where = { $and: [x, w] };
+            }
+            else
+                opt.where = w;
+        });
+    }
+}

package/esm/angular/interfaces/src/grid-settings.d.ts

@@ -0,0 +1,145 @@
+import { FieldMetadata, Sort, FieldsMetadata, EntityOrderBy, EntityFilter, FindOptions, Repository } from "remult";
+import { FieldCollection } from "./column-collection";
+import { DataAreaSettings, IDataAreaSettings } from "./data-area-settings";
+import { DataControlInfo, DataControlSettings } from "./data-control-interfaces";
+import { FilterHelper } from "./filter-helper";
+export declare class GridSettings<rowType> {
+    private repository;
+    settings?: IDataSettings<rowType> | undefined;
+    undoChanges(r: rowType): void;
+    constructor(repository: Repository<rowType>, settings?: IDataSettings<rowType> | undefined);
+    currList: DataControlSettings[];
+    origList: DataControlSettings[];
+    origNumOfColumns: number;
+    showSelectColumn: boolean;
+    initOrigList(): void;
+    userChooseColumns(): void;
+    resetColumns(): void;
+    deleteCol(c: DataControlSettings): void;
+    addNewRow(): void;
+    noam: string;
+    addArea(settings: IDataAreaSettings<rowType>): DataAreaSettings<rowType>;
+    currentRow: rowType;
+    setCurrentRow(row: rowType): void;
+    nextRow(): void;
+    previousRowAllowed(): boolean;
+    previousRow(): void;
+    deleteCurentRow(): void;
+    currentRowAsRestListItemRow(): undefined;
+    getRowHelper(item: rowType): any;
+    cancelCurrentRowChanges(): void;
+    deleteCurrentRowAllowed(): undefined;
+    currentRowChanged(): undefined;
+    saveCurrentRow(): void;
+    allowUpdate: boolean;
+    allowInsert: boolean;
+    allowDelete: boolean;
+    showDataArea: boolean;
+    _buttons: RowButton<any>[];
+    rowClass?: (row: any) => string;
+    onSavingRow?: (row: any) => Promise<any> | any;
+    onValidate?: (row: rowType) => Promise<any> | any;
+    onEnterRow: (row: rowType) => void;
+    onNewRow: (row: rowType) => void;
+    _doSavingRow(s: rowType): any;
+    caption: string;
+    filterHelper: FilterHelper<rowType>;
+    columns: FieldCollection<rowType>;
+    page: number;
+    nextPage(): Promise<any>;
+    previousPage(): Promise<any> | undefined;
+    firstPage(): Promise<any>;
+    selectedRows: rowType[];
+    selectedChanged(row: rowType): void;
+    lastSelectedRowWithShift: rowType;
+    clickOnselectCheckboxFor(row: rowType, shift: boolean): void;
+    isSelected(row: rowType): boolean;
+    selectAllIntermitent(): boolean;
+    selectAllChecked(): boolean;
+    private _selectedAll;
+    selectAllChanged(e: {
+        checked: boolean;
+    }): void;
+    rowsPerPage: number;
+    rowsPerPageOptions: number[];
+    get(options: FindOptions<rowType>): Promise<any>;
+    _currentOrderBy: Sort;
+    sort(column: FieldMetadata): void;
+    sortedAscending(column: FieldMetadata): boolean;
+    sortedDescending(column: FieldMetadata): boolean;
+    totalRows: number;
+    reloadData(): Promise<any>;
+    private restList;
+    _internalBuildFindOptions(): Promise<FindOptions<rowType>>;
+    getFilterWithSelectedRows(): Promise<FindOptions<rowType>>;
+    get items(): rowType[];
+}
+export interface IDataSettings<rowType> {
+    rowsLoaded?: (items: rowType[]) => void;
+    allowUpdate?: boolean;
+    allowInsert?: boolean;
+    allowDelete?: boolean;
+    allowCrud?: boolean;
+    showDataArea?: boolean;
+    showPagination?: boolean;
+    allowSelection?: boolean;
+    confirmDelete?: (r: rowType) => Promise<boolean>;
+    columnSettings?: (row: FieldsMetadata<rowType>) => DataControlInfo<rowType>[];
+    areas?: {
+        [areaKey: string]: DataControlInfo<rowType>[];
+    };
+    rowCssClass?: (row: rowType) => string;
+    rowButtons?: RowButton<rowType>[];
+    gridButtons?: GridButton[];
+    /** filters the data
+  * @example
+  * await taskRepo.find({where: { completed:false }})
+  * @see For more usage examples see [EntityFilter](https://remult.dev/docs/entityFilter.html)
+  */
+    where?: EntityFilter<rowType> | (() => EntityFilter<rowType> | Promise<EntityFilter<rowType>>);
+    /** Determines the order in which the result will be sorted in
+     * @see See [EntityOrderBy](https://remult-ts.github.io/guide/ref__entityorderby) for more examples on how to sort
+     */
+    orderBy?: EntityOrderBy<rowType>;
+    /** Determines the number of rows returned by the request, on the browser the default is 25 rows
+     * @example
+     * this.products = await this.remult.repo(Products).gridSettings({
+     *  rowsInPage:10,
+     *  page:2
+    * })
+    */
+    rowsInPage?: number;
+    /** Determines the page number that will be used to extract the data
+     * @example
+     * this.products = await this.remult.repo(Products).gridSettings({
+     *  rowsInPage:10,
+     *  page:2
+     * })
+    */
+    page?: number;
+    __customFindData?: any;
+    knowTotalRows?: boolean;
+    saving?: (r: rowType) => void;
+    validation?: (r: rowType) => void;
+    enterRow?: (r: rowType) => void;
+    newRow?: (r: rowType) => void;
+    numOfColumnsInGrid?: number;
+    caption?: string;
+}
+export interface RowButton<rowType> {
+    name?: string;
+    visible?: (r: rowType) => boolean;
+    click?: (r: rowType) => void;
+    showInLine?: boolean;
+    textInMenu?: (string | ((row: rowType) => string));
+    icon?: string;
+    cssClass?: (string | ((row: rowType) => string));
+}
+export interface GridButton {
+    name?: string;
+    visible?: () => boolean;
+    click?: () => void;
+    textInMenu?: () => string;
+    icon?: string;
+    cssClass?: (string | (() => string));
+}

package/esm/angular/interfaces/src/grid-settings.js

@@ -0,0 +1,387 @@
+import { Sort, getEntityRef, Filter } from "remult";
+import { FieldCollection } from "./column-collection";
+import { DataAreaSettings } from "./data-area-settings";
+import { DataList } from "./dataList";
+import { FilterHelper } from "./filter-helper";
+export class GridSettings {
+    repository;
+    settings;
+    undoChanges(r) {
+        let helper = this.getRowHelper(r);
+        helper.undoChanges();
+        if (helper.isNew())
+            this.restList.removeItem(r);
+    }
+    constructor(repository, settings) {
+        this.repository = repository;
+        this.settings = settings;
+        if (!settings)
+            this.settings = settings = {};
+        this.restList = new DataList(repository);
+        if (repository) {
+            this.filterHelper.filterRow = repository.create();
+            repository.addEventListener({
+                validating: async (entity) => {
+                    if (this.onValidate)
+                        await this.onValidate(entity);
+                    if (this.onSavingRow)
+                        await this.onSavingRow(entity);
+                }
+            });
+        }
+        this.columns = new FieldCollection(() => this.currentRow, () => this.allowUpdate, this.filterHelper, () => this.currentRow ? true : false, (a, b) => this.repository.getEntityRef(a).fields.find(b));
+        if (settings) {
+            if (settings.columnSettings) {
+                let x = settings.columnSettings(repository.metadata.fields);
+                this.columns.add(...x);
+            }
+            if (settings.allowCrud !== undefined) {
+                if (settings.allowUpdate === undefined)
+                    settings.allowUpdate = settings.allowCrud;
+                if (settings.allowDelete === undefined)
+                    settings.allowDelete = settings.allowCrud;
+                if (settings.allowInsert === undefined)
+                    settings.allowInsert = settings.allowCrud;
+            }
+            if (settings.allowUpdate)
+                this.allowUpdate = true;
+            if (settings.allowDelete)
+                this.allowDelete = true;
+            if (settings.allowInsert)
+                this.allowInsert = true;
+            if (settings.showDataArea)
+                this.showDataArea = settings.showDataArea;
+            if (settings.showPagination === undefined)
+                settings.showPagination = true;
+            if (settings.numOfColumnsInGrid != undefined)
+                this.columns.numOfColumnsInGrid = settings.numOfColumnsInGrid;
+            if (settings.rowButtons)
+                this._buttons = settings.rowButtons;
+            if (settings.rowCssClass)
+                this.rowClass = settings.rowCssClass;
+            if (settings.saving)
+                this.onSavingRow = settings.saving;
+            if (settings.enterRow)
+                this.onEnterRow = settings.enterRow;
+            if (settings.newRow)
+                this.onNewRow = settings.newRow;
+            if (settings.validation)
+                this.onValidate = settings.validation;
+            if (settings.caption)
+                this.caption = settings.caption;
+            if (!this.caption && repository) {
+                this.caption = repository.metadata.caption;
+            }
+            if (settings.page)
+                this.page = settings.page;
+            if (settings.rowsInPage)
+                this.rowsPerPage = settings.rowsInPage;
+            else
+                this.rowsPerPage = 25;
+            if (this.rowsPerPageOptions.indexOf(this.rowsPerPage) < 0) {
+                this.rowsPerPageOptions.push(this.rowsPerPage);
+                this.rowsPerPageOptions.sort((a, b) => +a - +b);
+            }
+            if (settings.orderBy)
+                this._currentOrderBy = Sort.translateOrderByToSort(this.repository.metadata, this.settings.orderBy);
+        }
+    }
+    currList;
+    origList;
+    origNumOfColumns;
+    showSelectColumn = false;
+    initOrigList() {
+        if (!this.origList) {
+            this.origList = [];
+            this.origNumOfColumns = this.columns.numOfColumnsInGrid;
+            this.origList.push(...this.columns.items);
+        }
+    }
+    userChooseColumns() {
+        this.initOrigList();
+        if (!this.currList) {
+            this.resetColumns();
+        }
+        this.showSelectColumn = !this.showSelectColumn;
+    }
+    resetColumns() {
+        this.currList = [];
+        this.columns.items = this.currList;
+        this.columns.numOfColumnsInGrid = this.origNumOfColumns;
+        for (let i = 0; i < this.origList.length; i++) {
+            // if (i < this.columns.numOfColumnsInGrid)
+            this.currList.push(this.origList[i]);
+        }
+    }
+    deleteCol(c) {
+        this.columns.deleteCol(c);
+        this.columns.numOfColumnsInGrid--;
+    }
+    addNewRow() {
+        let r = this.restList.add();
+        if (this.onNewRow)
+            this.onNewRow(r);
+        this.setCurrentRow(r);
+    }
+    noam;
+    addArea(settings) {
+        let col = new FieldCollection(() => this.currentRow, () => this.allowUpdate, this.filterHelper, () => this.currentRow ? true : false, (a, b) => this.repository.getEntityRef(a).fields.find(b));
+        col.numOfColumnsInGrid = 0;
+        return new DataAreaSettings(settings, col, this.repository.metadata.fields);
+    }
+    currentRow;
+    setCurrentRow(row) {
+        if (this.currentRow != row) {
+            this.currentRow = row;
+            if (this.onEnterRow && row) {
+                this.onEnterRow(row);
+            }
+        }
+    }
+    nextRow() {
+        if (!this.currentRow && this.items.length > 0)
+            this.setCurrentRow(this.items[0]);
+        if (this.currentRow) {
+            let currentRowPosition = this.items.indexOf(this.currentRow);
+            if (currentRowPosition < this.items.length - 1)
+                this.setCurrentRow(this.items[currentRowPosition + 1]);
+            else
+                this.nextPage().then(() => {
+                    if (this.items.length > 0)
+                        this.setCurrentRow(this.items[0]);
+                });
+        }
+    }
+    previousRowAllowed() {
+        return this.currentRow && this.items.indexOf(this.currentRow) > 0 || this.page > 1;
+    }
+    previousRow() {
+        if (!this.previousRowAllowed())
+            return;
+        let currentRowPosition = this.items.indexOf(this.currentRow);
+        if (currentRowPosition > 0)
+            this.setCurrentRow(this.items[currentRowPosition - 1]);
+        else {
+            if (this.page > 1)
+                this.previousPage().then(() => {
+                    if (this.items.length > 0)
+                        this.setCurrentRow(this.items[this.items.length - 1]);
+                });
+        }
+    }
+    deleteCurentRow() {
+        if (!this.deleteCurrentRowAllowed)
+            return;
+        this.currentRowAsRestListItemRow().delete();
+    }
+    currentRowAsRestListItemRow() {
+        if (!this.currentRow)
+            return undefined;
+        this.getRowHelper(this.currentRow);
+    }
+    getRowHelper(item) {
+        return this.repository.getEntityRef(item);
+    }
+    cancelCurrentRowChanges() {
+        if (this.currentRowAsRestListItemRow() && this.currentRowAsRestListItemRow())
+            this.currentRowAsRestListItemRow().undoChanges();
+    }
+    deleteCurrentRowAllowed() {
+        return this.currentRowAsRestListItemRow() && this.currentRowAsRestListItemRow().delete && this.allowDelete && !this.currentRowAsRestListItemRow().isNew();
+    }
+    currentRowChanged() {
+        return this.currentRowAsRestListItemRow() && this.currentRowAsRestListItemRow().wasChanged();
+    }
+    saveCurrentRow() {
+        if (this.currentRowAsRestListItemRow() && this.currentRowAsRestListItemRow().save)
+            this.currentRowAsRestListItemRow().save();
+    }
+    allowUpdate = false;
+    allowInsert = false;
+    allowDelete = false;
+    showDataArea = false;
+    _buttons = [];
+    rowClass;
+    onSavingRow;
+    onValidate;
+    onEnterRow;
+    onNewRow;
+    _doSavingRow(s) {
+        return getEntityRef(s).save();
+    }
+    caption;
+    filterHelper = new FilterHelper(() => {
+        this.page = 1;
+        this.reloadData();
+    }, this.repository);
+    columns;
+    page = 1;
+    nextPage() {
+        this.page++;
+        return this.reloadData();
+    }
+    previousPage() {
+        if (this.page <= 1)
+            return;
+        this.page--;
+        return this.reloadData();
+    }
+    firstPage() {
+        this.page = 1;
+        return this.reloadData();
+    }
+    selectedRows = [];
+    selectedChanged(row) {
+        if (this.isSelected(row)) {
+            this.selectedRows.splice(this.selectedRows.indexOf(row), 1);
+            this._selectedAll = false;
+        }
+        else {
+            this.selectedRows.push(row);
+            this._selectedAll = this.selectedRows.length == this.totalRows;
+        }
+    }
+    lastSelectedRowWithShift;
+    clickOnselectCheckboxFor(row, shift) {
+        if (shift) {
+            if (!this.lastSelectedRowWithShift) {
+                this.lastSelectedRowWithShift = row;
+            }
+            else {
+                let found = false;
+                for (const rule of this.items) {
+                    if (found) {
+                        if (rule == row || rule == this.lastSelectedRowWithShift) {
+                            this.lastSelectedRowWithShift = undefined;
+                            return;
+                        }
+                        else
+                            this.selectedChanged(rule);
+                    }
+                    else
+                        found = rule == row || rule == this.lastSelectedRowWithShift;
+                }
+            }
+        }
+        this.lastSelectedRowWithShift = row;
+    }
+    isSelected(row) {
+        return this.selectedRows.indexOf(row) >= 0;
+    }
+    selectAllIntermitent() {
+        return this.selectedRows.length > 0 && (this.selectedRows.length != this.items.length || !this._selectedAll);
+    }
+    selectAllChecked() {
+        return this.selectedRows.length > 0 && this.selectedRows.length == this.items.length && this._selectedAll;
+    }
+    _selectedAll = false;
+    selectAllChanged(e) {
+        this.selectedRows.splice(0);
+        if (e.checked) {
+            this.selectedRows.push(...this.items);
+            this._selectedAll = true;
+        }
+        else
+            this._selectedAll = false;
+    }
+    rowsPerPage;
+    rowsPerPageOptions = [10, 25, 50, 100];
+    get(options) {
+        if (options.where)
+            this.settings.where = () => options.where;
+        if (options.orderBy)
+            this._currentOrderBy = Sort.translateOrderByToSort(this.repository.metadata, options.orderBy);
+        this.page = 1;
+        return this.reloadData();
+    }
+    _currentOrderBy;
+    sort(column) {
+        let done = false;
+        if (this._currentOrderBy && this._currentOrderBy.Segments.length > 0) {
+            if (this._currentOrderBy.Segments[0].field.key == column.key) {
+                this._currentOrderBy.Segments[0].isDescending = !this._currentOrderBy.Segments[0].isDescending;
+                done = true;
+            }
+        }
+        if (!done)
+            this._currentOrderBy = new Sort({ field: column });
+        this.reloadData();
+    }
+    sortedAscending(column) {
+        if (!this._currentOrderBy)
+            return false;
+        if (!column)
+            return false;
+        return this._currentOrderBy.Segments.length > 0 &&
+            this._currentOrderBy.Segments[0].field.key == column.key &&
+            !this._currentOrderBy.Segments[0].isDescending;
+    }
+    sortedDescending(column) {
+        if (!this._currentOrderBy)
+            return false;
+        if (!column)
+            return false;
+        return this._currentOrderBy.Segments.length > 0 &&
+            this._currentOrderBy.Segments[0].field.key == column.key &&
+            !!this._currentOrderBy.Segments[0].isDescending;
+    }
+    totalRows;
+    async reloadData() {
+        let opt = await this._internalBuildFindOptions();
+        this.columns.autoGenerateColumnsBasedOnData(this.repository.metadata);
+        let result = this.restList.get(opt).then((rows) => {
+            this.selectedRows = this.selectedRows.map(s => {
+                let id = getEntityRef(s).getId();
+                let r = rows.find(r => getEntityRef(r).getId() == id);
+                if (r !== undefined)
+                    return r;
+                return s;
+            });
+            if (this.restList.items.length == 0) {
+                this.setCurrentRow(undefined);
+            }
+            else {
+                this.setCurrentRow(this.restList.items[0]);
+            }
+            if (this.settings?.rowsLoaded) {
+                this.settings?.rowsLoaded(this.restList.items);
+            }
+            return this.restList;
+        });
+        if (this.settings && this.settings.knowTotalRows) {
+            this.restList.count(opt.where).then(x => {
+                this.totalRows = x;
+            });
+        }
+        return result;
+    }
+    ;
+    restList;
+    async _internalBuildFindOptions() {
+        let opt = {};
+        if (this.settings.where) {
+            opt.where = await Filter.resolve(this.settings.where);
+        }
+        if (this.settings.orderBy)
+            opt.orderBy = this.settings.orderBy;
+        if (this._currentOrderBy)
+            opt.orderBy = this._currentOrderBy.toEntityOrderBy();
+        opt.limit = this.rowsPerPage;
+        if (this.page > 1)
+            opt.page = this.page;
+        this.filterHelper.addToFindOptions(opt);
+        return opt;
+    }
+    async getFilterWithSelectedRows() {
+        let r = await this._internalBuildFindOptions();
+        if (this.selectedRows.length > 0 && !this._selectedAll) {
+            r.where = { $and: [r.where, this.repository.metadata.idMetadata.createIdInFilter(this.selectedRows)] };
+        }
+        return r;
+    }
+    get items() {
+        if (this.restList)
+            return this.restList.items;
+        return undefined;
+    }
+}

package/esm/angular/interfaces/src/public_api.d.ts

@@ -0,0 +1,4 @@
+export * from './data-control-interfaces';
+export * from './data-area-settings';
+export * from './grid-settings';
+export * from './column-collection';

package/esm/angular/interfaces/src/public_api.js

@@ -0,0 +1,4 @@
+export * from './data-control-interfaces';
+export * from './data-area-settings';
+export * from './grid-settings';
+export * from './column-collection';

package/esm/angular/src/angular/RemultAngularPluginsService.d.ts

@@ -0,0 +1,4 @@
+import { dataControlAugmenter } from '../../interfaces';
+export declare class RemultAngularPluginsService {
+    dataControlAugmenter: dataControlAugmenter;
+}

package/esm/angular/src/angular/RemultAngularPluginsService.js

@@ -0,0 +1,3 @@
+export class RemultAngularPluginsService {
+    dataControlAugmenter = () => { };
+}

package/esm/angular/src/angular/data-control/data-control2.component.d.ts

@@ -0,0 +1,49 @@
+import { ComponentFactoryResolver, ViewContainerRef } from '@angular/core';
+import { FloatLabelType } from '@angular/material/form-field';
+import { ValueListItem, FieldMetadata, FieldRef } from 'remult';
+import { DataControlSettings, FieldCollection } from '../../../interfaces';
+import { RemultAngularPluginsService } from '../RemultAngularPluginsService';
+export declare class DataControl2Component {
+    private plugin;
+    private componentFactoryResolver;
+    map: DataControlSettings;
+    set field(value: FieldMetadata | FieldRef<any, any>);
+    constructor(plugin: RemultAngularPluginsService, componentFactoryResolver: ComponentFactoryResolver);
+    theId: ViewContainerRef;
+    done: boolean;
+    initCustomComponent(): void;
+    record: any;
+    notReadonly: boolean;
+    settings: FieldCollection;
+    showDescription(): any;
+    getDropDown(): ValueListItem[];
+    showClick(): boolean;
+    click(): void;
+    getClickIcon(): string;
+    dataControlStyle(): string;
+    dummy: {
+        inputValue: string;
+    };
+    _getColumn(): any;
+    _getEditable(): boolean;
+    ngOnChanges(): void;
+    isSelect(): boolean;
+    showTextBox(): boolean;
+    showCheckbox(): boolean;
+    getError(): any;
+    getStyle(): {
+        display: string;
+        width?: undefined;
+    } | {
+        width: string;
+        display?: undefined;
+    } | {
+        display?: undefined;
+        width?: undefined;
+    };
+    getFloatLabel(): FloatLabelType;
+    ngErrorStateMatches: {
+        parent: DataControl2Component;
+        isErrorState(): boolean;
+    };
+}