remult 0.22.3 → 0.22.4

package/esm/angular/interfaces/index.d.ts

@@ -0,0 +1 @@
+export * from './src/public_api';

package/esm/angular/interfaces/index.js

@@ -0,0 +1 @@
+export * from './src/public_api';

package/esm/angular/interfaces/src/column-collection.d.ts

@@ -0,0 +1,70 @@
+import { FieldMetadata, FieldRef, EntityMetadata, ValueListItem, Remult, Repository, EntityOrderBy, EntityFilter } from "remult";
+import { DataControlInfo, DataControlSettings, ValueOrEntityExpression } from "./data-control-interfaces";
+import { FilterHelper } from "./filter-helper";
+export declare class FieldCollection<rowType = any> {
+    currentRow: () => any;
+    private allowUpdate;
+    filterHelper: FilterHelper<rowType>;
+    private showArea;
+    private _getRowColumn;
+    constructor(currentRow: () => any, allowUpdate: () => boolean, filterHelper: FilterHelper<rowType>, showArea: () => boolean, _getRowColumn: (row: rowType, col: FieldMetadata) => FieldRef<any, any>);
+    __showArea(): boolean;
+    __getColumn(map: DataControlSettings, record: any): any;
+    __visible(col: DataControlSettings, row: any): boolean;
+    allowClick(col: DataControlSettings<any, any>, row: any): boolean;
+    getRowColumn<T>(args: {
+        col: DataControlSettings<any>;
+        row: any;
+    }, what: (c: FieldRef<any, any>, row: any) => T): T;
+    __dataControlStyle(map: DataControlSettings): string;
+    private settingsByKey;
+    allowDesignMode: boolean;
+    add(...columns: DataControlInfo<rowType>[]): Promise<void>;
+    add(...columns: string[]): Promise<void>;
+    private doWhenWeHaveContext;
+    private remult;
+    setContext(remult: Remult): void;
+    buildDropDown(s: DataControlSettings): Promise<void>;
+    designMode: boolean;
+    colListChanged(): void;
+    _colListChangeListeners: (() => void)[];
+    onColListChange(action: (() => void)): void;
+    moveCol(col: DataControlSettings, move: number): void;
+    filterRows(col: DataControlSettings): void;
+    clearFilter(col: DataControlSettings): void;
+    _shouldShowFilterDialog(col: DataControlSettings): boolean;
+    deleteCol(col: DataControlSettings): void;
+    addCol(col: DataControlSettings, newCol: DataControlSettings): void;
+    _getEditable(col: DataControlSettings, row: rowType): boolean;
+    _click(col: DataControlSettings, row: any): void;
+    _getColDisplayValue(col: DataControlSettings, row: rowType): any;
+    _getColDataType(col: DataControlSettings): string;
+    _getColumnClass(col: DataControlSettings, row: any): any;
+    _getError(col: DataControlSettings, r: any): any;
+    autoGenerateColumnsBasedOnData(defs: EntityMetadata<any>): void;
+    __changeWidth(col: DataControlSettings, what: number): void;
+    _colValueChanged(col: DataControlSettings, row: any): false | undefined;
+    items: DataControlSettings[];
+    private gridColumns;
+    private nonGridColumns;
+    numOfColumnsInGrid: number;
+    private _lastColumnCount;
+    private _lastNumOfColumnsInGrid;
+    private augmented;
+    augment(augmenter: dataControlAugmenter, s: DataControlSettings): void;
+    private _initColumnsArrays;
+    getGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
+    getNonGridColumns(augmenter: dataControlAugmenter): DataControlSettings<any, any>[];
+}
+export declare function valueOrEntityExpressionToValue<T, entityType>(f: ValueOrEntityExpression<T, entityType>, e: entityType): T;
+/** returns an array of values that can be used in the value list property of a data control object */
+export declare function getEntityValueList<T>(repository: Repository<T>, args?: {
+    idField?: (e: EntityMetadata<T>) => FieldMetadata;
+    captionField?: (e: EntityMetadata<T>) => FieldMetadata;
+    orderBy?: EntityOrderBy<T>;
+    where?: EntityFilter<T>;
+}): Promise<ExtendedValueListItem[]>;
+export interface ExtendedValueListItem extends ValueListItem {
+    entity?: any;
+}
+export declare type dataControlAugmenter = (f: FieldMetadata, op: DataControlSettings) => void;

package/esm/angular/interfaces/src/column-collection.js

@@ -0,0 +1,341 @@
+import { getEntityRef } from "remult";
+import { decorateDataSettings, getFieldDefinition } from "./data-control-interfaces";
+import { getEntitySettings } from 'remult/src/remult3';
+export class FieldCollection {
+    currentRow;
+    allowUpdate;
+    filterHelper;
+    showArea;
+    _getRowColumn;
+    constructor(currentRow, allowUpdate, filterHelper, showArea, _getRowColumn) {
+        this.currentRow = currentRow;
+        this.allowUpdate = allowUpdate;
+        this.filterHelper = filterHelper;
+        this.showArea = showArea;
+        this._getRowColumn = _getRowColumn;
+    }
+    __showArea() {
+        return this.showArea();
+    }
+    __getColumn(map, record) {
+        if (!map.field)
+            return undefined;
+        let result;
+        if (record)
+            result = getEntityRef(record).fields.find(getFieldDefinition(map.field));
+        if (!result)
+            result = map.field;
+        return result;
+    }
+    __visible(col, row) {
+        if (col.visible === undefined)
+            return true;
+        return this.getRowColumn({ col, row }, (c, row) => col.visible(row, c));
+    }
+    allowClick(col, row) {
+        if (!col.click)
+            return false;
+        if (!this._getEditable(col, row))
+            return false;
+        if (col.allowClick === undefined) {
+            return true;
+        }
+        return this.getRowColumn({ col, row }, (c, row) => col.allowClick(row, c));
+    }
+    getRowColumn(args, what) {
+        let field;
+        let row = args.row;
+        if (this._getRowColumn && args.col.field && row) {
+            field = this._getRowColumn(row, getFieldDefinition(args.col.field));
+        }
+        if (!field)
+            field = args.col.field;
+        if (!row && field)
+            row = field.container;
+        return what(field, row);
+    }
+    __dataControlStyle(map) {
+        if (map.width && map.width.trim().length > 0) {
+            if ((+map.width).toString() == map.width)
+                return map.width + "px";
+            return map.width;
+        }
+        return undefined;
+    }
+    settingsByKey = {};
+    allowDesignMode;
+    async add(...columns) {
+        var promises = [];
+        for (let c of columns) {
+            if (!c)
+                continue;
+            let s;
+            let x = c;
+            let col = c;
+            let ecol = c;
+            if (!x.field && col.valueConverter || ecol.metadata) {
+                x = {
+                    field: c,
+                };
+            }
+            if (x.field) {
+                decorateDataSettings(x.field, x);
+            }
+            if (x.getValue) {
+                s = x;
+            }
+            {
+                promises.push(this.buildDropDown(x));
+            }
+            this.items.push(x);
+        }
+        await Promise.all(promises);
+        return Promise.resolve();
+    }
+    doWhenWeHaveContext = [];
+    remult;
+    setContext(remult) {
+        this.remult = remult;
+        for (const what of this.doWhenWeHaveContext) {
+            what(remult);
+        }
+    }
+    async buildDropDown(s) {
+        if (s.valueList) {
+            let orig = s.valueList;
+            let result = [];
+            s.valueList = result;
+            if (orig instanceof Array) {
+                for (let item of orig) {
+                    let type = typeof (item);
+                    if (type == "string" || type == "number")
+                        result.push({ id: item, caption: item });
+                    else {
+                        let x = item;
+                        if (x && x.id != undefined) {
+                            result.push(x);
+                        }
+                    }
+                }
+            }
+            else if (typeof orig === "function") {
+                let theFunc = orig;
+                let todo = async (remult) => {
+                    let x = await theFunc(remult);
+                    if (x === undefined)
+                        s.valueList = undefined;
+                    else
+                        result.push(...x);
+                    fixResult(result, s.field);
+                };
+                if (this.remult) {
+                    todo(this.remult);
+                }
+                else
+                    this.doWhenWeHaveContext.push(async (remult) => todo(remult));
+            }
+            else {
+                result.push(...(await orig));
+            }
+            fixResult(result, s.field);
+        }
+        return Promise.resolve();
+    }
+    designMode = false;
+    colListChanged() {
+        this._lastNumOfColumnsInGrid = -1;
+        this._colListChangeListeners.forEach(x => x());
+    }
+    ;
+    _colListChangeListeners = [];
+    onColListChange(action) {
+        this._colListChangeListeners.push(action);
+    }
+    moveCol(col, move) {
+        let currentIndex = this.items.indexOf(col);
+        let newIndex = currentIndex + move;
+        if (newIndex < 0 || newIndex >= this.items.length)
+            return;
+        this.items.splice(currentIndex, 1);
+        this.items.splice(newIndex, 0, col);
+        this.colListChanged();
+    }
+    filterRows(col) {
+        if (col.valueList)
+            col.useContainsFilter = false;
+        this.filterHelper.filterColumn(col.field, false, col.useContainsFilter);
+    }
+    clearFilter(col) {
+        this.filterHelper.filterColumn(col.field, true, false);
+    }
+    _shouldShowFilterDialog(col) {
+        return false;
+    }
+    deleteCol(col) {
+        this.items.splice(this.items.indexOf(col), 1);
+        this.colListChanged();
+    }
+    addCol(col, newCol) {
+        this.items.splice(this.items.indexOf(col) + 1, 0, newCol);
+        this.colListChanged();
+    }
+    _getEditable(col, row) {
+        if (!this.allowUpdate())
+            return false;
+        if (!col.field)
+            return false;
+        if (col.readonly !== undefined)
+            return !valueOrEntityExpressionToValue(col.readonly, row);
+        return true;
+    }
+    _click(col, row) {
+        this.getRowColumn({ col, row }, (c, r) => { col.click(r, c); });
+    }
+    _getColDisplayValue(col, row) {
+        let r;
+        if (col.getValue) {
+            r = this.getRowColumn({ row, col }, (c, r) => col.getValue(r, c));
+        }
+        else if (col.field) {
+            if (col.valueList) {
+                for (let x of col.valueList) {
+                    if (x.id == this.__getColumn(col, row).value)
+                        return x.caption;
+                }
+            }
+            r = this.__getColumn(col, row).displayValue;
+        }
+        return r;
+    }
+    _getColDataType(col) {
+        if (col.inputType)
+            return col.inputType;
+        return "text";
+    }
+    _getColumnClass(col, row) {
+        if (col.cssClass)
+            if (typeof col.cssClass === 'function') {
+                let anyFunc = col.cssClass;
+                return anyFunc(row);
+            }
+            else
+                return col.cssClass;
+        return '';
+    }
+    _getError(col, r) {
+        if (!col.field)
+            return undefined;
+        return this.__getColumn(col, r).error;
+    }
+    autoGenerateColumnsBasedOnData(defs) {
+        if (this.items.length == 0) {
+            if (defs) {
+                for (const c of defs.fields) {
+                    if (!(c.key == 'id' && c.valueType === String))
+                        this.add(c);
+                }
+            }
+        }
+    }
+    __changeWidth(col, what) {
+        let width = col.width;
+        if (!width)
+            width = '50';
+        width = ((+width) + what).toString();
+        col.width = width;
+    }
+    _colValueChanged(col, row) {
+        return this.getRowColumn({ col, row }, (c, row) => {
+            if (col.valueList) {
+                let item = col.valueList.find(x => x.id == c.inputValue);
+                if (item?.entity) {
+                    if (getEntitySettings(getFieldDefinition(col.field).valueType, false))
+                        c.value = item.entity;
+                }
+            }
+            if (!col.valueChange)
+                return false;
+            col.valueChange(row, c);
+        });
+    }
+    items = [];
+    gridColumns;
+    nonGridColumns;
+    numOfColumnsInGrid = 5;
+    _lastColumnCount;
+    _lastNumOfColumnsInGrid;
+    augmented = new Map();
+    augment(augmenter, s) {
+        if (this.augmented.get(s))
+            return;
+        augmenter(getFieldDefinition(s.field), s);
+        this.augmented.set(s, true);
+    }
+    _initColumnsArrays(augmenter) {
+        if (this._lastColumnCount != this.items.length || this._lastNumOfColumnsInGrid != this.numOfColumnsInGrid) {
+            this._lastNumOfColumnsInGrid = this.numOfColumnsInGrid;
+            this._lastColumnCount = this.items.length;
+            this.gridColumns = [];
+            this.nonGridColumns = [];
+            let i = 0;
+            for (let c of this.items) {
+                this.augment(augmenter, c);
+                if (i++ < this._lastNumOfColumnsInGrid)
+                    this.gridColumns.push(c);
+                else
+                    this.nonGridColumns.push(c);
+            }
+        }
+    }
+    getGridColumns(augmenter) {
+        this._initColumnsArrays(augmenter);
+        return this.gridColumns;
+    }
+    getNonGridColumns(augmenter) {
+        this._initColumnsArrays(augmenter);
+        return this.nonGridColumns;
+    }
+}
+export function valueOrEntityExpressionToValue(f, e) {
+    if (typeof f === 'function') {
+        let x = f;
+        return x(e);
+    }
+    return f;
+}
+function fixResult(result, inField) {
+    let field = getFieldDefinition(inField);
+    if (field?.valueType === Number) {
+        result.splice(0, result.length, ...result.map(x => ({ ...x, id: x.id?.toString() })));
+    }
+}
+/** returns an array of values that can be used in the value list property of a data control object */
+export async function getEntityValueList(repository, args) {
+    if (!args) {
+        args = {};
+    }
+    if (!args.idField) {
+        args.idField = x => x.idMetadata.field;
+    }
+    if (!args.captionField) {
+        let idCol = args.idField(repository.metadata);
+        for (const keyInItem of repository.metadata.fields) {
+            if (keyInItem != idCol) {
+                args.captionField = x => x.fields.find(keyInItem);
+                break;
+            }
+        }
+    }
+    let r = (await repository.find({
+        where: args.where,
+        orderBy: args.orderBy,
+        limit: 1000
+    })).map(x => {
+        return {
+            id: repository.getEntityRef(x).fields.find(args.idField(repository.metadata)).value,
+            caption: repository.getEntityRef(x).fields.find(args.captionField(repository.metadata)).value,
+            entity: x
+        };
+    });
+    return r;
+}

package/esm/angular/interfaces/src/data-area-settings.d.ts

@@ -0,0 +1,15 @@
+import { FieldsMetadata } from "remult";
+import { FieldCollection } from "./column-collection";
+import { DataControlInfo, DataControlSettings } from "./data-control-interfaces";
+export interface IDataAreaSettings<rowType = any> {
+    fields?: (rowType: FieldsMetadata<rowType>) => DataAreaFieldsSetting<rowType>[];
+    numberOfColumnAreas?: number;
+    labelWidth?: number;
+}
+export declare class DataAreaSettings<rowType = any> {
+    settings?: IDataAreaSettings<rowType> | undefined;
+    fields?: FieldCollection<rowType> | undefined;
+    lines: DataControlSettings[][];
+    constructor(settings?: IDataAreaSettings<rowType> | undefined, fields?: FieldCollection<rowType> | undefined, entity?: FieldsMetadata<rowType>);
+}
+export type DataAreaFieldsSetting<rowType = any> = DataControlInfo<rowType> | DataControlInfo<rowType>[];

package/esm/angular/interfaces/src/data-area-settings.js

@@ -0,0 +1,35 @@
+import { FieldCollection } from "./column-collection";
+export class DataAreaSettings {
+    settings;
+    fields;
+    lines = [];
+    constructor(settings, fields, entity) {
+        this.settings = settings;
+        this.fields = fields;
+        if (fields == undefined) {
+            fields = new FieldCollection(() => undefined, () => true, undefined, () => true, () => undefined);
+            fields.numOfColumnsInGrid = 0;
+            this.fields = fields;
+        }
+        if (settings && settings.fields) {
+            for (const colSettings of settings.fields(entity)) {
+                if (Array.isArray(colSettings)) {
+                    let x = fields.items.length;
+                    //@ts-ignore
+                    fields.add(...colSettings);
+                    let line = [];
+                    for (let index = x; index < fields.items.length; index++) {
+                        line.push(fields.items[index]);
+                    }
+                    this.lines.push(line);
+                }
+                else {
+                    fields.add(colSettings);
+                    let x = fields.items[fields.items.length - 1];
+                    x.width = '';
+                    this.lines.push([x]);
+                }
+            }
+        }
+    }
+}

package/esm/angular/interfaces/src/data-control-interfaces.d.ts

@@ -0,0 +1,36 @@
+import { FieldRef, FieldMetadata, ValueListItem, Remult } from "remult";
+export type DataControlInfo<rowType> = DataControlSettings<rowType> | FieldRef<any, any>;
+export interface DataControlSettings<entityType = any, valueType = any> {
+    field?: FieldMetadata | FieldRef<any, any>;
+    getValue?: (row: entityType, val: FieldRef<entityType, valueType>) => any;
+    readonly?: ValueOrEntityExpression<boolean, entityType>;
+    cssClass?: (string | ((row: entityType) => string));
+    caption?: string;
+    visible?: (row: entityType, val: FieldRef<entityType, valueType>) => boolean;
+    click?: (row: entityType, val: FieldRef<entityType, valueType>) => void;
+    valueChange?: (row: entityType, val: FieldRef<entityType, valueType>) => void;
+    allowClick?: (row: entityType, val: FieldRef<entityType, valueType>) => boolean;
+    clickIcon?: string;
+    valueList?: ValueListItem[] | string[] | any[] | Promise<ValueListItem[]> | ((remult: Remult) => Promise<ValueListItem[]>) | ((remult: any) => ValueListItem[]);
+    inputType?: string;
+    hideDataOnInput?: boolean;
+    useContainsFilter?: boolean;
+    width?: string;
+    customComponent?: {
+        component: any;
+        args?: any;
+    };
+}
+export interface CustomDataComponent<argsType = any> {
+    args: CustomComponentArgs<argsType>;
+}
+export declare type CustomComponentArgs<argsType = any> = {
+    fieldRef: FieldRef;
+    settings: DataControlSettings;
+    args?: argsType;
+};
+export declare const configDataControlField: unique symbol;
+export declare function getFieldDefinition(col: FieldMetadata | FieldRef<any, any>): any;
+export declare function decorateDataSettings(colInput: FieldMetadata | FieldRef<any, any>, x: DataControlSettings): void;
+export declare type ValueOrEntityExpression<valueType, entityType> = valueType | ((e: entityType) => valueType);
+export declare function DataControl<entityType = any, colType = any>(settings: DataControlSettings<entityType, colType>): (target: any, key?: any) => any;

package/esm/angular/interfaces/src/data-control-interfaces.js

@@ -0,0 +1,57 @@
+import { ValueListInfo } from "remult";
+export const configDataControlField = Symbol('configDataControlField');
+export function getFieldDefinition(col) {
+    if (!col)
+        return undefined;
+    let r = col;
+    let c = col;
+    if (c.metadata)
+        r = c.metadata;
+    return r;
+}
+export function decorateDataSettings(colInput, x) {
+    let col = getFieldDefinition(colInput);
+    if (col.target) {
+        let settingsOnColumnLevel = Reflect.getMetadata(configDataControlField, col.target, col.key);
+        if (settingsOnColumnLevel) {
+            for (const key in settingsOnColumnLevel) {
+                if (Object.prototype.hasOwnProperty.call(settingsOnColumnLevel, key)) {
+                    const element = settingsOnColumnLevel[key];
+                    if (x[key] === undefined)
+                        x[key] = element;
+                }
+            }
+        }
+    }
+    if (col.valueType) {
+        let settingsOnColumnLevel = Reflect.getMetadata(configDataControlField, col.valueType);
+        if (settingsOnColumnLevel) {
+            for (const key in settingsOnColumnLevel) {
+                if (Object.prototype.hasOwnProperty.call(settingsOnColumnLevel, key)) {
+                    const element = settingsOnColumnLevel[key];
+                    if (x[key] === undefined)
+                        x[key] = element;
+                }
+            }
+        }
+    }
+    if (x.valueList === undefined && col && col.valueConverter instanceof ValueListInfo)
+        x.valueList = col.valueConverter.getValues();
+    if (!x.caption && col.caption)
+        x.caption = col.caption;
+    if (!x.inputType && col.inputType)
+        x.inputType = col.inputType;
+    if (x.readonly == undefined) {
+        if (col.dbReadOnly)
+            x.readonly = true;
+        if (typeof col.options?.allowApiUpdate === 'boolean')
+            x.readonly = !col.options.allowApiUpdate;
+    }
+}
+export function DataControl(settings) {
+    return (target, key) => {
+        Reflect.defineMetadata(configDataControlField, settings, target, key);
+        if (key === undefined)
+            return target;
+    };
+}

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

@@ -0,0 +1,13 @@
+import { EntityFilter, FindOptions, Repository } from "remult/src/remult3";
+export declare class DataList<T> implements Iterable<T> {
+    private repository;
+    [Symbol.iterator](): Iterator<T>;
+    items: T[];
+    constructor(repository: Repository<T>);
+    removeItem(item: T): void;
+    private map;
+    lastGetId: number;
+    count(where?: EntityFilter<T>): any;
+    get(options?: FindOptions<T>): any;
+    add(): T;
+}

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

@@ -0,0 +1,42 @@
+export class DataList {
+    repository;
+    [Symbol.iterator]() {
+        return this.items[Symbol.iterator]();
+    }
+    items = [];
+    constructor(repository) {
+        this.repository = repository;
+        repository.addEventListener({
+            deleted: entity => {
+                this.removeItem(entity);
+            }
+        });
+    }
+    removeItem(item) {
+        let i = this.items.indexOf(item);
+        if (i >= 0)
+            this.items.splice(i, 1);
+    }
+    map(item) {
+        return item;
+    }
+    lastGetId = 0;
+    count(where) {
+        return this.repository.count(where);
+    }
+    get(options) {
+        let getId = ++this.lastGetId;
+        return this.repository.find(options).then(r => {
+            let x = r;
+            let result = r.map((x) => this.map(x));
+            if (getId == this.lastGetId)
+                this.items = result;
+            return result;
+        });
+    }
+    add() {
+        let x = this.map(this.repository.create());
+        this.items.push(x);
+        return x;
+    }
+}

package/esm/angular/interfaces/src/filter-helper.d.ts

@@ -0,0 +1,13 @@
+import { FieldRef, FindOptions, Repository } from "remult";
+import { FieldMetadata } from "remult";
+export declare class FilterHelper<rowType> {
+    private reloadData;
+    private repository;
+    filterRow: rowType;
+    filterColumns: FieldMetadata[];
+    forceEqual: FieldMetadata[];
+    constructor(reloadData: () => void, repository: Repository<rowType>);
+    isFiltered(columnInput: FieldMetadata | FieldRef<any, any>): boolean;
+    filterColumn(columnInput: FieldMetadata | FieldRef<any, any>, clearFilter: boolean, useContainsFilter: boolean): void;
+    addToFindOptions(opt: FindOptions<rowType>): void;
+}