@mediusinc/mng-commons 5.5.0 → 6.0.0-rc.3

package/fesm2022/mediusinc-mng-commons-table-api.mjs

@@ -1,12 +1,12 @@
 import { Subject } from 'rxjs';
 import { map } from 'rxjs/operators';
-import { DataProviderInst, toObservable, TypeRegistry, CommonsInternalError, flattenObjectKeys } from '@mediusinc/mng-commons/core';
+import { DataProviderInst, toObservable, CommonsInternalError, flattenObjectKeys } from '@mediusinc/mng-commons/core';
 import { FilterDescriptor, FilterLookupDescriptor, FilterLookupEnumDescriptor, FilterGenericDescriptor, FilterTypeEnum } from '@mediusinc/mng-commons/filter';
-import { enumModelGeneric, findClassTitleAttribute, model, TypeDescriptor, ModelDescriptor } from '@mediusinc/mng-commons/model';
+import { model, ModelDescriptor } from '@mediusinc/mng-commons/model';
 
 class TableDataProviderInst extends DataProviderInst {
-    constructor(type, serviceType) {
-        super(type, serviceType);
+    constructor(serviceType) {
+        super(serviceType);
         this._reloadTableSubject = new Subject();
         this._isLazy = true;
         this._getAll = () => ({ data: [] });
@@ -29,57 +29,49 @@ class TableDataProviderInst extends DataProviderInst {
         this._isLazy = false;
         return this;
     }
-    /**
-     * @deprecated Use ${reloadTable} instead.
-     */
-    getAllReload(params) {
-        this.reloadTable(params ? { params: params } : undefined);
-    }
     reloadTable(event) {
         this._reloadTableSubject.next(event ?? {});
     }
 }
 
-class TableDataProvider extends TableDataProviderInst {
-    constructor() {
-        super(undefined, undefined);
-    }
-    static create() {
-        return tableDataProvider();
-    }
-    static fromClass(type) {
-        return tableDataProviderFromClass(type);
-    }
-    static fromClassWithService(type, serviceType) {
-        return tableDataProviderFromClass(type, serviceType);
+/**
+ * Creates and returns an instance of `TableDataProviderInst` with the specified options for managing table data.
+ *
+ * @param {Object} [opts] - The options object to configure the data provider.
+ * @param {TypeDescriptor<Model> | ModelDescriptor<Model>} [opts.type] - The descriptor defining the type of model.
+ * @param {ServiceClassType<Service>} [opts.service] - The service class type associated with the data provider.
+ * @param {TypeDescriptor<CreateModel> | ModelDescriptor<CreateModel>} [opts.filtersType] - The descriptor defining the filters type.
+ * @param {TypeDescriptor<UpdateModel> | ModelDescriptor<UpdateModel>} [opts.sortsType] - The descriptor defining the sorts type.
+ * @return {TableDataProviderInst<Model, Service, Sorts, Filters, ServiceClass>} An instance of `TableDataProviderInst` configured according to the provided options.
+ */
+function tableDataProvider(opts) {
+    return new TableDataProviderInst(opts?.service);
+}
+
+const dateRegex = /\d{4}-[01]\d-[0-3]\d/;
+const dateTimeRegex = /\d{4}-[01]\d-[0-3]\dT([0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z?)|([0-2]\d:[0-5]\d:[0-5]\d\+[0-2]\d:[0-5]\d))/;
+/**
+ * converts column to number or date on value based
+ * @param column column to be transformed
+ * @param value value to check if applicable
+ */
+function columnToDateNumberOrBoolean(column, value) {
+    if (typeof value === 'boolean') {
+        return column.asBoolean();
     }
-    static fromService(serviceType) {
-        return tableDataProviderWithService(serviceType);
+    else if (!isNaN(value) && typeof value === 'number') {
+        return column.asNumber();
     }
-}
-function tableDataProvider(type, serviceTypeOrOpts, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-opts) {
-    if (serviceTypeOrOpts === undefined || typeof serviceTypeOrOpts === 'function') {
-        return new TableDataProviderInst(undefined, serviceTypeOrOpts);
+    else if (dateRegex.test(value)) {
+        if (dateTimeRegex.test(value)) {
+            return column.asDate('dd. MMM yyyy HH:mm');
+        }
+        return column.asDate('dd. MMM yyyy');
     }
     else {
-        return new TableDataProviderInst(undefined, undefined);
+        return column;
     }
 }
-function tableDataProviderWithService(serviceType, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-opts) {
-    return new TableDataProviderInst(undefined, serviceType);
-}
-function tableDataProviderFromClass(type, serviceType) {
-    return new TableDataProviderInst(type, serviceType);
-}
-function tableDataProviderFromModel(model, serviceTypeOrOpts, opts) {
-    return typeof serviceTypeOrOpts === 'function'
-        ? new TableDataProviderInst(model.type, serviceTypeOrOpts)
-        : new TableDataProviderInst(model.type, undefined);
-}
 
 var ColumnTypeEnum;
 (function (ColumnTypeEnum) {
@@ -102,108 +94,6 @@ var ColumnDisplayTypeEnum;
     ColumnDisplayTypeEnum["Html"] = "HTML";
 })(ColumnDisplayTypeEnum || (ColumnDisplayTypeEnum = {}));
 
-const dateRegex = /\d{4}-[01]\d-[0-3]\d/;
-const dateTimeRegex = /\d{4}-[01]\d-[0-3]\dT([0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z?)|([0-2]\d:[0-5]\d:[0-5]\d\+[0-2]\d:[0-5]\d))/;
-/**
- * converts column to number or date on value based
- * @param column column to be transformed
- * @param value value to check if applicable
- */
-function columnToDateNumberOrBoolean(column, value) {
-    if (typeof value === 'boolean') {
-        return column.asBoolean();
-    }
-    else if (!isNaN(value) && typeof value === 'number') {
-        return column.asNumber();
-    }
-    else if (dateRegex.test(value)) {
-        if (dateTimeRegex.test(value)) {
-            return column.asDate('dd. MMM yyyy HH:mm');
-        }
-        return column.asDate('dd. MMM yyyy');
-    }
-    else {
-        return column;
-    }
-}
-/**
- * converts string type to column type enum, default is string
- * @param attributeType
- */
-function getColumnTypeFromClassAttributeDefType(attributeType) {
-    const typeRegistry = TypeRegistry.get();
-    if (typeRegistry.findEnum(attributeType)) {
-        attributeType = 'enum';
-    }
-    else if (typeRegistry.findType(attributeType)) {
-        attributeType = 'class';
-    }
-    switch (attributeType.toLowerCase()) {
-        case 'number':
-        case 'currency':
-            return ColumnTypeEnum.Number;
-        case 'boolean':
-            return ColumnTypeEnum.Boolean;
-        case 'date':
-            return ColumnTypeEnum.Date;
-        case 'enum':
-            return ColumnTypeEnum.Enum;
-        case 'custom':
-            return ColumnTypeEnum.Custom;
-        case 'class':
-            return ColumnTypeEnum.String;
-        case 'string':
-        default:
-            return ColumnTypeEnum.String;
-    }
-}
-function getColumnDisplayTypeFromColumnType(columnType, attributeType) {
-    switch (columnType) {
-        case ColumnTypeEnum.Number:
-            return attributeType === 'currency' ? ColumnDisplayTypeEnum.Currency : ColumnDisplayTypeEnum.Number;
-        case ColumnTypeEnum.Boolean:
-            return ColumnDisplayTypeEnum.Boolean;
-        case ColumnTypeEnum.Date:
-            return ColumnDisplayTypeEnum.Date;
-        case ColumnTypeEnum.Enum:
-            return ColumnDisplayTypeEnum.Enum;
-        case ColumnTypeEnum.Custom:
-            return ColumnDisplayTypeEnum.Component;
-        case ColumnTypeEnum.String:
-        default:
-            return ColumnDisplayTypeEnum.String;
-    }
-}
-function expandClassAttributeDefWithTableDef(attributes) {
-    if (!attributes) {
-        throw new CommonsInternalError('Class attribute definition is null, problem with TypeRegistry::findAttributesDefinitionByClassType?', { name: 'TableviewUtilsError' });
-    }
-    const typeRegistry = TypeRegistry.get();
-    const tableClassAttributeDef = [];
-    for (const attribute of attributes) {
-        const enumType = typeRegistry.findEnum(attribute.type);
-        const columnType = enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type);
-        tableClassAttributeDef.push({
-            name: attribute.name,
-            baseName: attribute.baseName,
-            type: attribute.type,
-            subtype: attribute.subtype,
-            columnType: enumType ? ColumnTypeEnum.Enum : getColumnTypeFromClassAttributeDefType(attribute.type),
-            columnDisplayType: getColumnDisplayTypeFromColumnType(columnType, attribute.type),
-            enumType: typeRegistry.findEnum(attribute.type),
-            classType: typeRegistry.findType(attribute.type)
-        });
-    }
-    return tableClassAttributeDef;
-}
-/**
- * returns attributes from class type and extends to typed def with column and field enum type
- * @param type class type
- */
-function getTableClassAttributeDef(type) {
-    return expandClassAttributeDefWithTableDef(TypeRegistry.get().findAttributesDefinitionByClassType(type));
-}
-
 class ColumnDescriptor {
     constructor(property) {
         this._columnType = ColumnTypeEnum.String;
@@ -237,6 +127,9 @@ class ColumnDescriptor {
     get title() {
         return this._title;
     }
+    get titleUseModelBase() {
+        return this._titleUseModelBase;
+    }
     get displayFormat() {
         return this._displayFormat;
     }
@@ -476,9 +369,11 @@ class ColumnDescriptor {
      * Sets the title for the column. If title is undefined, then the title will be calculated based on table model (i18nBase) and column property.
      *
      * @param title - The title of the column.
+     * @param useModelBase - Whether to append title to model's i18n path.
      */
-    withTitle(title) {
+    withTitle(title, useModelBase) {
         this._title = title;
+        this._titleUseModelBase = useModelBase;
         return this;
     }
     /**
@@ -1787,7 +1682,7 @@ class TableDynamicDescriptorInst extends TableDescriptorInst {
      */
     withColumnTitle(property, title) {
         const column = this._columns.find(col => property === col.property) ?? this.addColumn(property);
-        column.withTitle(title, true);
+        column.withTitle(title);
         return this;
     }
     /**
@@ -1869,189 +1764,30 @@ class TableDynamicDescriptorInst extends TableDescriptorInst {
     }
 }
 
-/**
- * generates column based on attributes
- * @param desc Table descriptor
- * @param attribute attribute map
- * @param column if provided, replaced by new, otherwise new is created
- * @param args additional parameters
- */
-function upsertTableColumnFromAttributeDef(desc, attribute, column, ...args) {
-    if (column == null) {
-        column = desc.addColumnUnsafe(attribute.name);
-    }
-    if (attribute.columnType === ColumnTypeEnum.Enum && args.length === 0 && attribute.enumType) {
-        args = [enumModelGeneric(attribute.enumType)];
-    }
-    column = column.asType(attribute.columnType, attribute.columnDisplayType, ...args);
-    if (attribute.classType) {
-        const titleProperty = findClassTitleAttribute(attribute.classType) ?? undefined;
-        if (titleProperty) {
-            column.withGetter(value => value?.[titleProperty]);
-        }
-    }
-    else {
-        desc.addFilterFromColumnDescriptorUnsafe(column, false);
-        desc.withSortUnsafe(column.property);
-    }
-    return column;
-}
-/**
- * defines modified type of column
- * DO NOT USE with enum (use withCustomEnumType)
- * @param descriptor table descriptor
- * @param property column name
- * @param columnType modified type
- * @param args additional attributes
- * @param columnDisplayType
- */
-function modifyTableClassAttributeColumnType(descriptor, property, columnType, columnDisplayType, ...args) {
-    return modifyTableClassAttributeColumnTypeUnsafe(descriptor, property, columnType, columnDisplayType, ...args);
-}
-function modifyTableClassAttributeColumnTypeUnsafe(descriptor, property, columnType, columnDisplayType, ...args) {
-    if (!descriptor.model.type) {
-        throw new CommonsInternalError(`withColumnModifiedType cannot be executed for property ${property}: Model type is not defined.`);
-    }
-    const attributeDef = getTableClassAttributeDef(descriptor.model.type).find(attr => attr.name === property);
-    if (attributeDef != null) {
-        attributeDef.columnType = columnType ?? attributeDef.columnType;
-        attributeDef.columnDisplayType = columnDisplayType ?? attributeDef.columnDisplayType;
-        return upsertTableColumnFromAttributeDef(descriptor, attributeDef, descriptor.columns.find(col => col.property === attributeDef.name), ...args);
-    }
-    return null;
-}
-/**
- * defines custom enum type for column
- * @param descriptor table descriptor
- * @param property column name
- * @param enumDesc Enum descriptor.
- */
-function modifyTableClassAttributeColumnEnum(descriptor, property, enumDesc) {
-    return tableDescriptorModifyEnumColumnUnsafe(descriptor, property, enumDesc);
-}
-function tableDescriptorModifyEnumColumnUnsafe(descriptor, property, enumDesc) {
-    if (!descriptor.model.type) {
-        throw new CommonsInternalError(`withColumnModifiedEnum cannot be executed for property ${property}: Model type is not defined.`);
-    }
-    const attributeDef = getTableClassAttributeDef(descriptor.model.type).find(attr => attr.name === property);
-    if (attributeDef != null) {
-        attributeDef.columnType = ColumnTypeEnum.Enum;
-        upsertTableColumnFromAttributeDef(descriptor, attributeDef, descriptor.columns.find(col => col.property === property), enumDesc ?? enumModelGeneric(TypeRegistry.get().findEnum(attributeDef.type)));
-    }
-    return null;
-}
-/**
- * modifies column with class and lookup provider
- * @param descriptor table descriptor
- * @param property column name
- * @param lookupProvider lookupProvider for class
- * @param optionsLabelProperty
- * @param filterProperty
- */
-function modifyTableColumnFilterLookup(descriptor, property, lookupProvider, optionsLabelProperty, filterProperty) {
-    return modifyTableColumnFilterLookupUnsafe(descriptor, property, lookupProvider, optionsLabelProperty, filterProperty);
-}
-function modifyTableColumnFilterLookupUnsafe(descriptor, property, lookupProvider, optionsLabelProperty, filterProperty) {
-    const column = descriptor.columns.find(col => col.property === property);
-    if (column) {
-        const filter = descriptor.addFilterLookupUnsafe(column.property, lookupProvider, filterProperty);
-        if (optionsLabelProperty) {
-            filter.withOptionsLabelPropertyUnsafe(optionsLabelProperty);
-        }
-        return filter;
-    }
-    return null;
-}
-
-class TableDescriptor extends TableDescriptorInst {
-    constructor() {
-        super(model());
-    }
-    static create(idProperty, titleProperty, i18nBaseKey) {
-        return tableDescriptor({ id: idProperty, title: titleProperty, i18nBase: i18nBaseKey });
-    }
-    static fromClass(type, idProperty, titleProperty, i18nBaseKey) {
-        return tableDescriptorFromClass(type, { id: idProperty, title: titleProperty, i18nBase: i18nBaseKey });
-    }
-    static fromModel(model) {
-        return new TableDescriptorInst(model);
-    }
-    /**
-     * generates descriptor based on type attribute definition
-     * @param type class type
-     * @param idProperty
-     * @param titleProperty
-     */
-    static fromClassWithAutoAttrsDef(type, idProperty, titleProperty) {
-        return tableDescriptorFromClassAttrsDef(type, undefined, { id: idProperty, title: titleProperty });
-    }
-    /**
-     * generates descriptor base on given attribute definition
-     * @param type class type
-     * @param attributes attributes from which descriptor is generated
-     * @param idProperty
-     * @param titleProperty
-     */
-    static fromClassWithCustomAttrsDef(type, attributes, idProperty, titleProperty) {
-        return tableDescriptorFromClassAttrsDef(type, attributes, { id: idProperty, title: titleProperty });
-    }
-}
-function tableDescriptor(typeOrModelOrClassOrOpts, opts) {
-    if (typeOrModelOrClassOrOpts == null) {
+function tableDescriptor(modelOrOpts, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+opts) {
+    if (modelOrOpts == null) {
         return new TableDescriptorInst(model());
     }
-    else if (typeOrModelOrClassOrOpts instanceof TypeDescriptor) {
-        return new TableDescriptorInst(model(opts ?? {}));
-    }
-    else if (typeOrModelOrClassOrOpts instanceof ModelDescriptor) {
-        return new TableDescriptorInst(typeOrModelOrClassOrOpts);
+    else if (modelOrOpts instanceof ModelDescriptor) {
+        return new TableDescriptorInst(modelOrOpts);
     }
     else {
         // this could have autoGenerated if model descriptor is class
-        return new TableDescriptorInst(model(typeOrModelOrClassOrOpts));
-    }
-}
-function tableDescriptorFromClass(type, opts) {
-    return new TableDescriptorInst(model(type, opts));
-}
-/**
- * generates descriptor based on type attribute definition
- * @param type class type
- * @param attributes
- * @param opts
- */
-function tableDescriptorFromClassAttrsDef(type, attributes, opts) {
-    const descriptor = new TableDescriptorInst(model(type, opts), true);
-    (attributes ?? getTableClassAttributeDef(type))
-        .filter(attr => !attr.type.includes('Set') && !attr.type.includes('Array'))
-        .forEach(attr => upsertTableColumnFromAttributeDef(descriptor, attr));
-    return descriptor;
-}
-class TableDynamicDescriptor extends TableDynamicDescriptorInst {
-    constructor() {
-        super(ModelDescriptor.create());
-    }
-    static create(idProperty, titleProperty, i18nBaseKey) {
-        return tableDynamicDescriptor({
-            id: idProperty,
-            title: titleProperty,
-            i18nBase: i18nBaseKey
-        });
-    }
-    static fromModel(model) {
-        return tableDynamicDescriptor(model);
+        return new TableDescriptorInst(model(modelOrOpts));
     }
 }
 function tableDynamicDescriptor(modelOrOpts) {
     return modelOrOpts instanceof ModelDescriptor
         ? new TableDynamicDescriptorInst(modelOrOpts)
-        : new TableDynamicDescriptorInst(new ModelDescriptor(undefined, modelOrOpts?.id, modelOrOpts?.title, modelOrOpts?.i18nBase));
+        : new TableDynamicDescriptorInst(new ModelDescriptor(modelOrOpts?.id, modelOrOpts?.title, modelOrOpts?.i18nBase));
 }
 
-function tableToDataProvider(descriptor, serviceType) {
+function tableDataProviderFromDescriptor(descriptor, serviceType) {
     return typeof serviceType !== 'undefined'
-        ? new TableDataProviderInst(undefined, serviceType)
-        : new TableDataProviderInst(undefined, undefined);
+        ? new TableDataProviderInst(serviceType)
+        : new TableDataProviderInst(undefined);
 }
 
 // data providers
@@ -2060,5 +1796,5 @@ function tableToDataProvider(descriptor, serviceType) {
  * Generated bundle index. Do not edit.
  */
 
-export { ColumnDescriptor, ColumnDisplayTypeEnum, ColumnDynamicDescriptor, ColumnTypeEnum, SortDescriptor, TableDataProvider, TableDataProviderInst, TableDescriptor, TableDescriptorInst, TableDynamicColumnsModeEnum, TableDynamicDescriptor, TableDynamicDescriptorInst, TablePaginationModeEnum, TableSizeEnum, columnToDateNumberOrBoolean, expandClassAttributeDefWithTableDef, getColumnDisplayTypeFromColumnType, getColumnTypeFromClassAttributeDefType, getTableClassAttributeDef, modifyTableClassAttributeColumnEnum, modifyTableClassAttributeColumnType, modifyTableClassAttributeColumnTypeUnsafe, modifyTableColumnFilterLookup, modifyTableColumnFilterLookupUnsafe, tableDataProvider, tableDataProviderFromClass, tableDataProviderFromModel, tableDataProviderWithService, tableDescriptor, tableDescriptorFromClass, tableDescriptorFromClassAttrsDef, tableDescriptorModifyEnumColumnUnsafe, tableDynamicDescriptor, tableToDataProvider, upsertTableColumnFromAttributeDef };
+export { ColumnDescriptor, ColumnDisplayTypeEnum, ColumnDynamicDescriptor, ColumnTypeEnum, SortDescriptor, TableDataProviderInst, TableDescriptorInst, TableDynamicColumnsModeEnum, TableDynamicDescriptorInst, TablePaginationModeEnum, TableSizeEnum, columnToDateNumberOrBoolean, tableDataProvider, tableDataProviderFromDescriptor, tableDescriptor, tableDynamicDescriptor };
 //# sourceMappingURL=mediusinc-mng-commons-table-api.mjs.map