@mediusinc/mng-commons 3.6.0-rc.3 → 3.7.0-rc.0

package/lib/descriptors/filter/filter-lookup.descriptor.d.ts

@@ -0,0 +1,69 @@
+import { ILookupDataProvider, LookupDataProviderLookupFnType } from '../../data-providers';
+import { EnumValue } from '../../models';
+import { ClassType, EnumConstantType, EnumType, ServiceClassType } from '../../types';
+import { ILookupDescriptor } from '../interfaces';
+import { FilterLookupTypeEnum, FilterMatchModeEnum } from '../types';
+import { FilterDescriptor } from './filter.descriptor';
+export type FilterLookupDescriptorConstructorOptsType<FilterModel, Service> = FilterLookupDescriptorCreateOptsProviderType<FilterModel, Service> & {
+    type?: ClassType<FilterModel>;
+    optionsValueProperty?: string | null;
+};
+export type FilterLookupDescriptorCreateOptsProviderType<FilterModel, Service> = {
+    serviceType?: ServiceClassType<Service>;
+    dataProvider?: ILookupDataProvider<FilterModel, Service>;
+};
+export type FilterLookupAutocompleteOptsType = {
+    openOnFocus?: boolean;
+    inlineSearch?: boolean;
+    autoClear?: boolean;
+};
+export declare class FilterLookupDescriptor<FilterModel, Service = any> extends FilterDescriptor<FilterModel> implements ILookupDescriptor<FilterModel> {
+    protected readonly _dataProvider: ILookupDataProvider<FilterModel, Service>;
+    protected readonly _optionsValueProperty?: string | null;
+    protected _lookupType?: FilterLookupTypeEnum;
+    protected _optionsLabelProperty?: string;
+    protected _optionsLabelTranslate: boolean;
+    protected _multiselect: boolean;
+    protected _dropdownClassName: string;
+    protected _autocompleteOpenOnFocus?: boolean;
+    protected _autocompleteInlineSearch?: boolean;
+    protected _autocompleteAutoClear?: boolean;
+    constructor(property: string, cfg?: FilterLookupDescriptorConstructorOptsType<FilterModel, Service>);
+    get lookupType(): FilterLookupTypeEnum | undefined;
+    get dataProvider(): ILookupDataProvider<FilterModel, Service>;
+    get optionsLabelProperty(): string | undefined;
+    get optionsLabelTranslate(): boolean;
+    get optionsValueProperty(): string | undefined;
+    get multiselect(): boolean;
+    get autocompleteOpenOnFocus(): boolean | undefined;
+    get autocompleteAutoClear(): boolean | undefined;
+    get autocompleteInlineSearch(): boolean | undefined;
+    get dropdownClassName(): string;
+    withOptionsLabelProperty(property: keyof FilterModel, translate?: boolean): this;
+    withOptionsLabelPropertyUnsafe(property: string, translate?: boolean): this;
+    /**
+     * Method will set `optionsValueProperty`, because track properties are not supported here as filters need final value to work correctly.
+     * Use `optionsValueProperty` instead.
+     */
+    withOptionsTrackProperty(): this;
+    withOptionsTrackPropertyUnsafe(): this;
+    withLookup(lookup?: LookupDataProviderLookupFnType<FilterModel, Service>): this;
+    withMultiselect(multiselect?: boolean): this;
+    withDropdownClassName(dropdownClassName: string): this;
+    withDefaultFilter(filterValue: FilterModel | FilterModel[], filterValueTo?: FilterModel, filterMatchMode?: FilterMatchModeEnum): this;
+    asAutocomplete(opts?: FilterLookupAutocompleteOptsType): this;
+    copy(): FilterLookupDescriptor<FilterModel>;
+    protected copyFieldsTo(filter: FilterLookupDescriptor<FilterModel>): void;
+}
+export declare class FilterLookupEnumDescriptor extends FilterLookupDescriptor<EnumValue> {
+    private readonly _enumType;
+    private readonly _optionEnumValues;
+    private readonly _nameAsValue;
+    constructor(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
+    get enumType(): EnumType<EnumConstantType>;
+    asAutocomplete(opts?: FilterLookupAutocompleteOptsType): this;
+    withMultiselectEnum(multiselect?: boolean): FilterLookupEnumDescriptor;
+    withDefaultFilter(): this;
+    withDefaultFilterEnum(filterValue: EnumConstantType | EnumConstantType[], filterValueTo?: EnumConstantType, filterMatchMode?: FilterMatchModeEnum): this;
+    copy(): FilterLookupEnumDescriptor;
+}

package/lib/descriptors/filter/filter.descriptor.d.ts

@@ -1,19 +1,12 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { MediusQueryParam } from '../../api/models';
-import { ILookupDataProvider } from '../../data-providers';
-import { EnumValue } from '../../models';
-import { ClassType, EnumConstantType, EnumType } from '../../types';
-import { ILookupDescriptor } from '../interfaces';
-import { FilterLookupTypeEnum, FilterMatchModeEnum, FilterTypeEnum } from '../types';
-export declare class FilterDescriptor<T> {
+import { FilterMatchModeEnum, FilterTypeEnum } from '../types';
+export declare class FilterDescriptor<FilterModel> {
     protected readonly _property: string;
     protected _filterType: FilterTypeEnum;
     protected _filterProperty?: string;
     protected _hasDefaultValue: boolean;
     protected _defaultFilterMatchMode?: FilterMatchModeEnum;
-    protected _defaultValue?: T | T[];
-    protected _defaultValueTo?: T;
+    protected _defaultValue?: FilterModel | FilterModel[];
+    protected _defaultValueTo?: FilterModel;
     protected _matchModes: string[] | null;
     protected _numberMinFractionDigits?: number;
     protected _numberMaxFractionDigits?: number;
@@ -31,8 +24,8 @@ export declare class FilterDescriptor<T> {
     constructor(property: string);
     get filterType(): FilterTypeEnum;
     get hasDefaultValue(): boolean;
-    get defaultValue(): T | T[] | undefined;
-    get defaultValueTo(): T | undefined;
+    get defaultValue(): FilterModel | FilterModel[] | undefined;
+    get defaultValueTo(): FilterModel | undefined;
     get defaultFilterMatchMode(): FilterMatchModeEnum | undefined;
     get filterProperty(): string | undefined;
     get matchModes(): string[] | null;
@@ -56,7 +49,7 @@ export declare class FilterDescriptor<T> {
      * @param filterProperty
      */
     withFilterProperty(filterProperty: string): this;
-    withDefaultFilter(filterValue: T, filterValueTo?: T, filterMatchMode?: FilterMatchModeEnum): this;
+    withDefaultFilter(filterValue: FilterModel, filterValueTo?: FilterModel, filterMatchMode?: FilterMatchModeEnum): this;
     withNumberFractions(min?: number, max?: number): this;
     withNumberGrouping(useGrouping?: boolean): this;
     withDateFormat(format?: string, showTime?: boolean): this;
@@ -66,57 +59,6 @@ export declare class FilterDescriptor<T> {
     withColumnClassName(className: string): this;
     withColumnWidth(width?: number, minWidth?: number): this;
     withMatchModes(matchModes: Array<FilterMatchModeEnum>): this;
-    copy(): FilterDescriptor<T>;
-    protected copyFieldsTo(descriptor: FilterDescriptor<T>): void;
-}
-export declare class FilterLookupDescriptor<T> extends FilterDescriptor<T> implements ILookupDescriptor<T> {
-    protected readonly _modelType: ClassType<T> | null;
-    protected _lookupType?: FilterLookupTypeEnum;
-    protected _dataProvider?: ILookupDataProvider<T, any>;
-    protected _itemsLabelProperty?: string;
-    protected _itemsLabelTranslate: boolean;
-    protected _itemsValueProperty?: string;
-    protected _multiselect: boolean;
-    protected _dropdownClassName: string;
-    protected _autocompleteOpenOnFocus: boolean;
-    protected _autocompleteInlineSearch: boolean;
-    constructor(property: string, modelType: ClassType<T> | null);
-    get lookupType(): FilterLookupTypeEnum | undefined;
-    get dataProvider(): ILookupDataProvider<T, any> | undefined;
-    get itemsLabelProperty(): string | undefined;
-    get itemsLabelTranslate(): boolean;
-    get itemsValueProperty(): string | undefined;
-    get multiselect(): boolean;
-    get autocompleteOpenOnFocus(): boolean;
-    get autocompleteInlineSearch(): boolean;
-    get dropdownClassName(): string;
-    get modelType(): ClassType<T> | null;
-    withItemsLabelProperty(itemsLabelProperty: string, translate?: boolean): this;
-    withItemsValueProperty(itemsValueProperty: string): this;
-    /**
-     * Method will set `itemsValueProperty`, because dataKeys are not supported here as filters need final value to work correctly.
-     * Use `withItemsValueProperty` instead.
-     * @param itemsValueProperty Item's value property.
-     */
-    withDataKeyProperty(itemsValueProperty: string): this;
-    withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this;
-    withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
-    withMultiselect(multiselect?: boolean): this;
-    withDropdownClassName(dropdownClassName: string): this;
-    withDefaultFilter(filterValue: T | T[], filterValueTo?: T, filterMatchMode?: FilterMatchModeEnum): this;
-    asAutocomplete(openOnFocus?: boolean, inlineSearch?: boolean): this;
-    copy(): FilterLookupDescriptor<T>;
-    protected copyFieldsTo(filter: FilterLookupDescriptor<T>): void;
-}
-export declare class FilterLookupEnumDescriptor extends FilterLookupDescriptor<EnumValue<string | number>> {
-    private readonly _enumType;
-    private readonly _optionEnumValues;
-    private readonly _nameAsValue;
-    constructor(property: string, enumType: EnumType, options?: Array<EnumConstantType>, nameAsValue?: boolean, optionsTitlePath?: string | null);
-    get enumType(): EnumType;
-    asAutocomplete(openOnFocus?: boolean): this;
-    withMultiselectEnum(multiselect?: boolean): FilterLookupEnumDescriptor;
-    withDefaultFilter(): this;
-    withDefaultFilterEnum(filterValue: EnumConstantType | EnumConstantType[], filterValueTo?: EnumConstantType, filterMatchMode?: FilterMatchModeEnum): this;
-    copy(): FilterLookupEnumDescriptor;
+    copy(): FilterDescriptor<FilterModel>;
+    protected copyFieldsTo(descriptor: FilterDescriptor<FilterModel>): void;
 }

package/lib/descriptors/filter/index.d.ts

@@ -1 +1,2 @@
 export * from './filter.descriptor';
+export * from './filter-lookup.descriptor';

package/lib/descriptors/interfaces/lookup-descriptor.interface.d.ts

@@ -1,17 +1,12 @@
-import { Type } from '@angular/core';
-import { Observable } from 'rxjs';
-import { MediusQueryParam } from '../../api/models';
-import { ILookupDataProvider } from '../../data-providers';
-import { ClassType } from '../../types';
-export interface ILookupDescriptor<T> {
-    modelType: ClassType<T> | null;
-    itemsLabelProperty?: string;
-    itemsValueProperty?: string;
-    dataKeyProperty?: string;
-    dataProvider?: ILookupDataProvider<T, any>;
-    withItemsLabelProperty(itemsLabelProperty: string): this;
-    withItemsValueProperty(itemsLabelProperty: string): this;
-    withDataKeyProperty(dataKeyProperty: string): this;
-    withLookup<S>(lookup: (queryParam?: MediusQueryParam, service?: S, search?: string) => Observable<Array<T>>, serviceType?: Type<S>): this;
-    withLookupDataProvider(dataProvider: ILookupDataProvider<T, any>): this;
+import { ILookupDataProvider, LookupDataProviderLookupFnType } from '../../data-providers';
+export interface ILookupDescriptor<Model, Service = any> {
+    optionsLabelProperty?: string;
+    optionsValueProperty?: string;
+    optionsTrackProperty?: string;
+    dataProvider: ILookupDataProvider<Model, Service>;
+    withOptionsLabelProperty(property: keyof Model): this;
+    withOptionsLabelPropertyUnsafe(property: string): this;
+    withOptionsTrackProperty(property: keyof Model): this;
+    withOptionsTrackPropertyUnsafe(property: string): this;
+    withLookup(lookup: LookupDataProviderLookupFnType<Model, Service>): this;
 }

package/lib/descriptors/model/model.descriptor.d.ts

@@ -0,0 +1,22 @@
+import { ClassOptType, ClassType } from '../../types';
+export declare class ModelDescriptor<Model, ModelClass = ClassOptType<Model>> {
+    private readonly _type;
+    private readonly _typeName?;
+    private _i18nBaseKey;
+    private _idProperty?;
+    private _titleProperty?;
+    protected constructor(type: ModelClass, idProperty?: string, titleProperty?: string, i18nBaseKey?: string | ClassType<any>);
+    static create<Model>(idProperty?: keyof Model, titleProperty?: keyof Model, i18nBaseKey?: string | ClassType<unknown>): ModelDescriptor<Model, undefined>;
+    static fromClass<Model>(type: ClassType<Model>, idProperty?: keyof Model, titleProperty?: keyof Model, i18nBaseKey?: string | ClassType<unknown>): ModelDescriptor<Model, ClassType<Model>>;
+    get type(): ModelClass;
+    get typeName(): string | undefined;
+    get i18nBaseKey(): string;
+    get idProperty(): string | undefined;
+    get titleProperty(): string | undefined;
+    withIdProperty(property: keyof Model): this;
+    withIdPropertyUnsafe(property: string): this;
+    withTitleProperty(property: keyof Model): this;
+    withTitlePropertyUnsafe(property: string): this;
+    withI18nBase(base: ClassType<any> | string): this;
+    copy(): ModelDescriptor<Model, ModelClass>;
+}

package/lib/descriptors/table/column.descriptor.d.ts

@@ -1,16 +1,33 @@
 import { Type } from '@angular/core';
+import { ILookupDataProvider } from '../../data-providers';
 import { IColumnValueComponent } from '../../models';
-import { ClassType, EnumConstantType, EnumType } from '../../types';
+import { EnumConstantType, EnumType, GetterFn } from '../../types';
 import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor } from '../filter';
 import { ColumnDisplayTypeEnum, ColumnTypeEnum } from '../types';
-import { TableDescriptor, TableDynamicDescriptor } from './table.descriptor';
-export declare class ColumnDescriptor<T, TT> {
-    protected readonly _table: TableDescriptor<TT>;
+import { ITableDescriptorInternal } from './internal/table.model';
+export type ColumnCurrencyOptsType<Property = string> = {
+    currencyProperty?: Property;
+    currency?: string;
+    currencyDisplay?: 'symbol' | 'code' | 'name';
+} & ColumnNumberGroupingOptsType & ColumnNumberFractionOptsType & ColumnLocaleOptsType;
+export type ColumnNumberOptsType = ColumnNumberGroupingOptsType & ColumnNumberFractionOptsType & ColumnLocaleOptsType;
+export type ColumnNumberGroupingOptsType = {
+    groupSeparator?: boolean;
+};
+export type ColumnNumberFractionOptsType = {
+    minIntegerDigits?: number;
+    minFractionDigits?: number;
+    maxFractionDigits?: number;
+};
+export type ColumnLocaleOptsType = {
+    locale?: string;
+};
+export declare class ColumnDescriptor<ColumnModel, TableModel, ColumnValue = ColumnModel, Property = string> {
+    protected readonly _table: ITableDescriptorInternal<TableModel>;
     protected readonly _property: string;
     private _columnType;
     private _columnDisplayType;
     protected _title?: string;
-    private _jsonPath?;
     private _isSortEnabled;
     private _sortProperty?;
     private _filterDescriptor?;
@@ -35,48 +52,43 @@ export declare class ColumnDescriptor<T, TT> {
     private _booleanAsIcon;
     private _booleanYes?;
     private _booleanNo?;
-    private _objectModelType?;
-    private _objectTitleProperty?;
     private _currencyCode?;
-    private _currencyFromProperty?;
+    private _currencyProperty?;
     private _currencyDisplay?;
     private _customComponentType?;
     private _hasCopyToClipboard;
     private _isLocalized;
     private _localizationExistsProperty?;
-    constructor(table: TableDescriptor<TT>, property: string);
+    constructor(table: ITableDescriptorInternal<TableModel>, property: Property);
     get columnType(): ColumnTypeEnum;
     get columnDisplayType(): ColumnDisplayTypeEnum;
     get title(): string | undefined;
-    get jsonPath(): string | undefined;
     get isSortEnabled(): boolean;
     get sortProperty(): string | undefined;
-    get filterDescriptor(): FilterDescriptor<unknown> | undefined;
+    get filterDescriptor(): FilterDescriptor<any> | undefined;
     get displayFormat(): string | undefined;
-    get table(): TableDescriptor<TT>;
+    get table(): ITableDescriptorInternal<TableModel>;
     get property(): string;
     get headerClassName(): string;
     get className(): string;
-    get classNameMapFn(): ((className?: string | undefined, item?: TT | undefined) => string) | undefined;
+    get classNameMapFn(): ((className?: string | undefined, item?: TableModel | undefined) => string) | undefined;
     get width(): number | null;
     get minWidth(): number | null;
     get maxWidth(): number | null;
-    get enumType(): EnumType | undefined;
+    get enumType(): EnumType<EnumConstantType> | undefined;
     get enumTitlePath(): string | null | undefined;
     get enumNameAsValue(): boolean;
     get booleanAsIcon(): boolean;
     get booleanYes(): string | undefined;
     get booleanNo(): string | undefined;
-    get objectModelType(): ClassType<unknown> | undefined;
-    get objectTitleProperty(): string | undefined;
-    get customComponentType(): Type<IColumnValueComponent<TT>> | undefined;
+    get customComponentType(): Type<IColumnValueComponent<TableModel>> | undefined;
     get locale(): string | undefined;
     get currencyCode(): string | undefined;
     get currencyDisplay(): "symbol" | "name" | "code" | undefined;
-    get currencyFromProperty(): string | undefined;
+    get currencyProperty(): string | undefined;
     get hasCopyToClipboard(): boolean;
     get template(): string | undefined;
-    get getter(): ((item: TT, value?: T | null | undefined) => unknown) | undefined;
+    get getter(): GetterFn<ColumnValue, TableModel> | undefined;
     get isMultiline(): boolean;
     get hasValueAsTooltip(): boolean;
     get isReorderable(): boolean;
@@ -85,44 +97,44 @@ export declare class ColumnDescriptor<T, TT> {
     get isLocalized(): boolean;
     get localizationExistsProperty(): string | undefined;
     /**
-     * converts column to given type with additional arguments
+     * Converts column to given type with additional arguments
      * @param type column type enum
+     * @param displayType column display type
      * @param args any additional arguments for column (optional)
      */
     asType(type: ColumnTypeEnum, displayType?: ColumnDisplayTypeEnum, ...args: any[]): this;
-    asNumber(displayFormat?: string, locale?: string): this;
-    asCurrency(currencyCode?: string, currencyFromProperty?: string, currencyDisplay?: 'symbol' | 'code' | 'name', displayFormat?: string, locale?: string): this;
+    asNumber(opts?: ColumnNumberOptsType): this;
+    asCurrency(opts?: ColumnCurrencyOptsType<keyof ColumnModel>): this;
+    asCurrencyUnsafe(opts?: ColumnCurrencyOptsType): this;
     asDate(displayFormat?: string): this;
     asBoolean(yes?: string, no?: string, asIcon?: boolean): this;
     asEnum(enumType: EnumType, nameAsValue?: boolean, titlePath?: string | null): this;
-    asCustomComponent(customComponentType: Type<IColumnValueComponent<TT>>): this;
+    asCustomComponent(customComponentType: Type<IColumnValueComponent<TableModel>>): this;
     asHtml(): this;
-    withClassName(className?: string, headerClassName?: string, classNameMapFn?: (className?: string, item?: TT) => string): this;
+    withClassName(className?: string, headerClassName?: string, classNameMapFn?: (className?: string, item?: TableModel) => string): this;
     withWidth(width?: number, minWidth?: number, maxWidth?: number): this;
-    withObjectProperty<MT>(modelType: ClassType<MT>, titleProperty?: string): this;
     withTitle(title: string): this;
-    withJsonPath(path: string): this;
     withFilter(forceSimple?: boolean): FilterDescriptor<any>;
-    withFilterLookup(): FilterLookupDescriptor<unknown>;
+    withFilterLookup<FLT = ColumnModel, S = undefined>(provider?: ILookupDataProvider<FLT, S>, optionsValueProperty?: keyof FLT | null): FilterLookupDescriptor<FLT, S>;
+    withFilterLookupUnsafe<FLT = ColumnModel, S = undefined>(provider?: ILookupDataProvider<FLT, S>, optionsValueProperty?: string | null): FilterLookupDescriptor<FLT, S>;
     withFilterLookupEnum(options?: Array<EnumConstantType>): FilterLookupEnumDescriptor;
     withSort(isEnabled?: boolean, sortProperty?: string): this;
     withDefaultSort(asc?: boolean): this;
     withCopyToClipboard(hasCopyToCliboard?: boolean): this;
     withTemplate(template: string): this;
-    withGetter(getter?: (item: TT, value?: T | null) => unknown): this;
+    withGetter(getter?: GetterFn<ColumnValue, TableModel>): this;
     withMultiline(isMultiline?: boolean): this;
     withValueAsTooltip(valueAsTooltip?: boolean): this;
     withReorderable(isReorderable?: boolean): this;
     withToggleable(isToggleable?: boolean, isVisible?: boolean): this;
     localized(existsProperty?: string): this;
-    copy(): ColumnDescriptor<T, TT>;
-    protected copyFieldsTo(obj: ColumnDescriptor<T, TT>): void;
+    copy(): ColumnDescriptor<ColumnModel, TableModel, ColumnValue>;
+    protected copyFieldsTo(obj: ColumnDescriptor<ColumnModel, TableModel, ColumnValue>): void;
 }
 export declare class ColumnDynamicDescriptor extends ColumnDescriptor<any, any> {
-    protected _table: TableDynamicDescriptor;
     protected _title: string | undefined;
     private _visibility;
-    constructor(table: TableDynamicDescriptor, property: string);
+    constructor(table: ITableDescriptorInternal<any>, property: string);
     get visibility(): boolean;
     /**
      * sets column's title and returns this column
@@ -144,5 +156,5 @@ export declare class ColumnDynamicDescriptor extends ColumnDescriptor<any, any>
      * creates deep copy of column dynamic descriptor
      */
     copy(): ColumnDynamicDescriptor;
-    toColumnDescriptor(tableDescriptor: TableDescriptor<any>): ColumnDescriptor<any, any>;
+    toColumnDescriptor(tableDescriptor: ITableDescriptorInternal<any>): ColumnDescriptor<any, any>;
 }

package/lib/descriptors/table/internal/table-columns.model.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDescriptor } from '../../table';
+export interface IColumnsManageInterface<TableModel> {
+    getColumn(property: keyof TableModel): ColumnDescriptor<any, TableModel> | null;
+    getColumnUnsafe(property: string): ColumnDescriptor<any, TableModel> | null;
+    removeColumn(property: keyof TableModel): void;
+    removeColumnUnsafe(property: string): void;
+    addColumnDescriptor<ColumnModel>(column: ColumnDescriptor<ColumnModel, TableModel>): this;
+    addColumn<PropertyKey extends keyof TableModel>(property: PropertyKey): ColumnDescriptor<TableModel[PropertyKey], TableModel>;
+    addColumnUnsafe<ColumnModel = any>(property: string): ColumnDescriptor<ColumnModel, TableModel>;
+    addColumns(...properties: (keyof TableModel)[]): this;
+}

package/lib/descriptors/table/internal/table.model.d.ts

@@ -0,0 +1,9 @@
+import { ModelDescriptor } from '../../model';
+/**
+ * This one is internal only to prevent circular dependencies between editor and fields.
+ */
+export interface ITableDescriptorInternal<TableModel> {
+    model: ModelDescriptor<TableModel>;
+    withDefaultSort(property: keyof TableModel, asc?: boolean): this;
+    withDefaultSortUnsafe(property: string, asc: boolean): this;
+}