@mediusinc/mng-commons-data-api 5.2.0-rc.0 → 5.2.0-rc.2

package/esm2022/index.mjs

@@ -1,7 +1,9 @@
 // helpers
 export * from './lib/helpers/get-all-params';
 // models
+export * from './lib/models/api-version.model';
 export * from './lib/models/request-params.model';
+export * from './lib/models/schema.model';
 // types
 export * from './lib/types/extract-get-all-params.type';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLGNBQWMsOEJBQThCLENBQUM7QUFFN0MsU0FBUztBQUNULGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsUUFBUTtBQUNSLGNBQWMseUNBQXlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBoZWxwZXJzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9oZWxwZXJzL2dldC1hbGwtcGFyYW1zJztcblxuLy8gbW9kZWxzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvcmVxdWVzdC1wYXJhbXMubW9kZWwnO1xuXG4vLyB0eXBlc1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdHlwZXMvZXh0cmFjdC1nZXQtYWxsLXBhcmFtcy50eXBlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLGNBQWMsOEJBQThCLENBQUM7QUFFN0MsU0FBUztBQUNULGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDJCQUEyQixDQUFDO0FBRTFDLFFBQVE7QUFDUixjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gaGVscGVyc1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaGVscGVycy9nZXQtYWxsLXBhcmFtcyc7XG5cbi8vIG1vZGVsc1xuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzL2FwaS12ZXJzaW9uLm1vZGVsJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscy9yZXF1ZXN0LXBhcmFtcy5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9tb2RlbHMvc2NoZW1hLm1vZGVsJztcblxuLy8gdHlwZXNcbmV4cG9ydCAqIGZyb20gJy4vbGliL3R5cGVzL2V4dHJhY3QtZ2V0LWFsbC1wYXJhbXMudHlwZSc7XG4iXX0=

package/esm2022/lib/models/api-version.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLXZlcnNpb24ubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbGliL21vZGVscy9hcGktdmVyc2lvbi5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBBcGlWZXJzaW9uIHtcbiAgICBhcHBOYW1lPzogc3RyaW5nO1xuICAgIGRlc2NyaXB0aW9uPzogc3RyaW5nO1xuICAgIHZlcnNpb24/OiBzdHJpbmc7XG4gICAgaW5mb0VtYWlsPzogc3RyaW5nO1xuICAgIGluZm9Vcmw/OiBzdHJpbmc7XG4gICAgbGljZW5zZUluZm8/OiBzdHJpbmc7XG4gICAgbGljZW5zZVVybD86IHN0cmluZztcbn1cbiJdfQ==

package/esm2022/lib/models/schema.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9tb2RlbHMvc2NoZW1hLm1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIFNjaGVtYU1vZGVsPE1vZGVsID0gYW55PiB7XG4gICAgbmFtZTogc3RyaW5nO1xuICAgIHByb3BlcnRpZXM6IFJlY29yZDxrZXlvZiBNb2RlbCwgU2NoZW1hUHJvcGVydHk+O1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNjaGVtYUVudW08RW51bVR5cGU+IHtcbiAgICBuYW1lOiBzdHJpbmc7XG4gICAgdmFsdWVzOiBFbnVtVHlwZVtdO1xuICAgIGNvbnN0YW50czogc3RyaW5nW107XG4gICAgdHlwZTogc3RyaW5nO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIFNjaGVtYVByb3BlcnR5IHtcbiAgICB0eXBlOiBzdHJpbmc7XG4gICAgb2JqZWN0VHlwZT86IHN0cmluZztcbiAgICBpc1JlYWRPbmx5PzogYm9vbGVhbjtcbiAgICByZXF1aXJlZD86IGJvb2xlYW47XG4gICAgaXNOdWxsYWJsZT86IGJvb2xlYW47XG4gICAgbWluTGVuZ3RoPzogbnVtYmVyO1xuICAgIG1heExlbmd0aD86IG51bWJlcjtcbiAgICBtaW5pbXVtPzogbnVtYmVyO1xuICAgIG1heGltdW0/OiBudW1iZXI7XG4gICAgZXhjbHVzaXZlTWluaW11bT86IGJvb2xlYW47XG4gICAgZXhjbHVzaXZlTWF4aW11bT86IGJvb2xlYW47XG4gICAgaXNJbnRlZ2VyPzogYm9vbGVhbjtcbiAgICBwYXR0ZXJuPzogc3RyaW5nO1xuICAgIG1heEl0ZW1zPzogbnVtYmVyO1xuICAgIG1pbkl0ZW1zPzogbnVtYmVyO1xuICAgIGVudW1Nb2RlbD86IGFueTtcbiAgICBlbnVtTmFtZT86IHN0cmluZztcbiAgICBpc0VtYWlsPzogYm9vbGVhbjtcbiAgICBpc1Bhc3N3b3JkPzogYm9vbGVhbjtcbn1cbiJdfQ==

package/esm2022/tableview/index.mjs

@@ -1,2 +1,6 @@
 export * from './tableview-get-all-params-create';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90YWJsZXZpZXcvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUNBQW1DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RhYmxldmlldy1nZXQtYWxsLXBhcmFtcy1jcmVhdGUnO1xuIl19
+// schema
+export * from './schema/columns-from-schema';
+export * from './schema/enum-from-schema';
+export * from './schema/fields-from-schema';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90YWJsZXZpZXcvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsU0FBUztBQUNULGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YWJsZXZpZXctZ2V0LWFsbC1wYXJhbXMtY3JlYXRlJztcblxuLy8gc2NoZW1hXG5leHBvcnQgKiBmcm9tICcuL3NjaGVtYS9jb2x1bW5zLWZyb20tc2NoZW1hJztcbmV4cG9ydCAqIGZyb20gJy4vc2NoZW1hL2VudW0tZnJvbS1zY2hlbWEnO1xuZXhwb3J0ICogZnJvbSAnLi9zY2hlbWEvZmllbGRzLWZyb20tc2NoZW1hJztcbiJdfQ==

package/esm2022/tableview/schema/columns-from-schema.mjs

@@ -0,0 +1,173 @@
+import { enumModelFromSchema } from './enum-from-schema';
+import { fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
+const defaultGetter = value => {
+    if (typeof value === 'object') {
+        const valueObj = value;
+        return (valueObj['title'] ??
+            valueObj['name'] ??
+            valueObj['naziv'] ??
+            valueObj['code'] ??
+            valueObj['sifra'] ??
+            valueObj['id'] ??
+            valueObj['uuid'] ??
+            valueObj[Object.keys(valueObj)[0]]);
+    }
+    else {
+        return value;
+    }
+};
+/**
+ * <em>Experimental:</em> Builder for adding columns to table.
+ *
+ * @experimental
+ */
+export class SchemaColumnsBuilder {
+    constructor(descriptor, schema, opts) {
+        this.descriptor = descriptor;
+        this.schema = schema;
+        this.opts = opts;
+    }
+    mergeColumnsOpts(property, opts) {
+        return {
+            ...this.opts,
+            columnType: this.opts?.columnTypes?.[property],
+            getter: opts?.getters?.[property] ?? this.opts?.getters?.[property],
+            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property],
+            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    mergeColumnOpts(property, opts) {
+        return {
+            ...this.opts,
+            columnType: this.opts?.columnTypes?.[property],
+            getter: this.opts?.getters?.[property],
+            enumModel: this.opts?.enumModels?.[property],
+            enumSchema: this.opts?.enumSchemas?.[property],
+            ...opts
+        };
+    }
+    /**
+     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the column for.
+     * @param {ColumnFromSchemaOptsType<SchModel[Property], SchModel, any, Model>} opts - Additional options.
+     *
+     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.
+     */
+    add(property, opts) {
+        return addColumnFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeColumnOpts(property, opts));
+    }
+    /**
+     * <em>Experimental:</em> Adds all columns from the non-array schema properties via {addColumnFromSchema}.
+     *
+     * @experimental
+     *
+     * @param {ColumnsFromSchemaOptsType<SchModel>} opts - Additional options.
+     *
+     * @return {this} - The current instance of the builder.
+     */
+    withAddAll(opts) {
+        this.addColumns(undefined, opts);
+        return this;
+    }
+    withAdd(propOrOpts, ...properties) {
+        if (typeof propOrOpts === 'object') {
+            this.addColumns(properties.length === 0 ? undefined : properties, propOrOpts);
+        }
+        else {
+            this.addColumns([propOrOpts, ...properties]);
+        }
+        return this;
+    }
+    /**
+     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema} where property schema is manually provided.
+     *
+     * @experimental
+     *
+     * @param {Property} property - The property to add the column for.
+     * @param {SchemaProperty} schemaProperty - Manually provided schema property.
+     * @param {ColumnFromSchemaOptsType} opts - Additional options.
+     *
+     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.
+     */
+    addFromSchema(property, schemaProperty, opts) {
+        return addColumnFromSchema(this.descriptor, property, schemaProperty, this.mergeColumnOpts(property, opts));
+    }
+    addColumns(properties, opts) {
+        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);
+        if (addProperties) {
+            addProperties.forEach(property => {
+                addColumnFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeColumnsOpts(property, opts));
+            });
+        }
+    }
+}
+/**
+ * <em>Experimental:</em> Creates builder for adding columns to descriptor based on provided model schema.
+ *
+ * @experimental
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - Descriptor to add columns to.
+ * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.
+ * @param {ColumnsFromSchemaOptsType<SchModel>} [opts] - Additional options.
+ *
+ * @return {SchemaColumnsBuilder<Model, SchModel>} - The column schema builder instance.
+ */
+export function columnsFromSchema(descriptor, schema, opts) {
+    return new SchemaColumnsBuilder(descriptor, schema, opts);
+}
+/**
+ * <em>Experimental:</em> Adds a column to table descriptor based on the given schema property and options.
+ *
+ * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - The table view descriptor or table descriptor to add the column to.
+ * @param {Property} property - The property key of the model to create the column for.
+ * @param {SchemaProperty} propertySchema - The schema property for the property.
+ * @param {ColumnFromSchemaOptsType<Model[Property], Model, any, Model>} [opts] - The options for the column.
+ *
+ * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} - The added column descriptor.
+ */
+export function addColumnFromSchema(descriptor, property, propertySchema, opts) {
+    const propertyType = opts?.columnType ?? propertySchema?.type;
+    const column = descriptor.addColumn(property);
+    // Handle different property types
+    switch (propertyType) {
+        case 'number':
+            if (opts?.currency) {
+                column.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));
+            }
+            else {
+                column.asNumber();
+            }
+            break;
+        case 'boolean':
+            column.asBoolean(undefined, undefined, true);
+            break;
+        case 'date':
+            column.asDate(opts?.dateFormat ?? 'dd.MM.YYYY');
+            break;
+        case 'enum':
+            // eslint-disable-next-line no-case-declarations
+            const enumModel = opts?.enumSchema ? enumModelFromSchema(opts.enumSchema) : opts?.enumModel;
+            if (enumModel) {
+                column.asEnumUnsafe(enumModel);
+            }
+            break;
+        case 'date-time':
+            column.asDate(opts?.dateTimeFormat ?? 'dd.MM.YYYY HH:mm');
+            break;
+        case 'currency':
+            column.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts?.currency) : undefined);
+            break;
+        case 'object':
+            column.withGetter(defaultGetter);
+            break;
+    }
+    // Add optional filter, sort and getters
+    if (opts?.getter)
+        column.withGetter(opts?.getter);
+    return column;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"columns-from-schema.js","sourceRoot":"","sources":["../../../../tableview/src/schema/columns-from-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import {SchemaEnum, SchemaModel, SchemaProperty} from '@mediusinc/mng-commons-data-api';\nimport {GetterFn} from '@mediusinc/mng-commons/core';\nimport {EnumDescriptor} from '@mediusinc/mng-commons/model';\nimport {ColumnDescriptor, TableDescriptorInst} from '@mediusinc/mng-commons/table/api';\nimport {TableviewDescriptorInst} from '@mediusinc/mng-commons/tableview/api';\n\nimport {enumModelFromSchema} from './enum-from-schema';\nimport {FromSchemaCurrencyOptsType, fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties} from './internal/common-from-schema';\n\ntype ColumnType = 'number' | 'currency' | 'boolean' | 'string' | 'text' | 'textarea' | 'date' | 'date-time' | 'enum' | 'object';\n\ntype ColumnsFromSchemaOptsType<Model = any> = {\n    columnTypes?: Partial<Record<keyof Model, ColumnType>>;\n    enumModels?: Partial<Record<keyof Model, EnumDescriptor<any>>>;\n    enumSchemas?: Partial<Record<keyof Model, SchemaEnum<any>>>;\n    getters?: {[K in keyof Model]?: GetterFn<Model[K], Model>};\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\ntype ColumnFromSchemaOptsType<Column = any, Model = any, Enum = any, CurrencyModel = Model> = {\n    columnType?: ColumnType;\n    getter?: GetterFn<Column, Model>;\n    enumModel?: EnumDescriptor<Enum>;\n    enumSchema?: SchemaEnum<Enum>;\n    currency?: FromSchemaCurrencyOptsType<CurrencyModel>;\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\nconst defaultGetter: GetterFn<unknown> = value => {\n    if (typeof value === 'object') {\n        const valueObj = value as object;\n        return (\n            valueObj['title' as keyof object] ??\n            valueObj['name' as keyof object] ??\n            valueObj['naziv' as keyof object] ??\n            valueObj['code' as keyof object] ??\n            valueObj['sifra' as keyof object] ??\n            valueObj['id' as keyof object] ??\n            valueObj['uuid' as keyof object] ??\n            valueObj[Object.keys(valueObj)[0] as keyof object]\n        );\n    } else {\n        return value;\n    }\n};\n\n/**\n * <em>Experimental:</em> Builder for adding columns to table.\n *\n * @experimental\n */\nexport class SchemaColumnsBuilder<Model, SchModel = Model> {\n    constructor(\n        private readonly descriptor: TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>,\n        private readonly schema: SchemaModel<SchModel>,\n        private opts?: ColumnsFromSchemaOptsType<SchModel>\n    ) {}\n\n    private mergeColumnsOpts(property: keyof Model, opts?: ColumnsFromSchemaOptsType) {\n        return <ColumnFromSchemaOptsType>{\n            ...this.opts,\n            columnType: this.opts?.columnTypes?.[property],\n            getter: opts?.getters?.[property] ?? this.opts?.getters?.[property],\n            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property],\n            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property],\n            ...opts\n        };\n    }\n\n    private mergeColumnOpts(property: keyof Model, opts?: ColumnFromSchemaOptsType) {\n        return <ColumnFromSchemaOptsType>{\n            ...this.opts,\n            columnType: this.opts?.columnTypes?.[property],\n            getter: this.opts?.getters?.[property],\n            enumModel: this.opts?.enumModels?.[property],\n            enumSchema: this.opts?.enumSchemas?.[property],\n            ...opts\n        };\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the column for.\n     * @param {ColumnFromSchemaOptsType<SchModel[Property], SchModel, any, Model>} opts - Additional options.\n     *\n     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.\n     */\n    public add<Property extends Extract<keyof Model, keyof SchModel>>(\n        property: Property,\n        opts?: ColumnFromSchemaOptsType<SchModel[Property], SchModel, any, Model>\n    ): ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]> {\n        return addColumnFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeColumnOpts(property, opts)) as unknown as ColumnDescriptor<\n            NonNullable<Model[Property]>,\n            Model,\n            Model[Property]\n        >;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds all columns from the non-array schema properties via {addColumnFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {ColumnsFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAddAll(opts?: ColumnsFromSchemaOptsType<SchModel>): this {\n        this.addColumns(undefined, opts);\n        return this;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds columns for properties via {addColumnFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {ColumnsFromSchemaOptsType<SchModel>} opts - Additional options.\n     * @param {...Property[]} properties - Properties to add columns for. If non provided, all non-array properties from schema will be added.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAdd<Property extends Extract<keyof Model, keyof SchModel>>(opts: ColumnsFromSchemaOptsType<SchModel>, ...properties: Property[]): this;\n    /**\n     * <em>Experimental:</em> Adds columns for properties via {addColumnFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {...Property[]} properties - Properties to add columns for. If non provided, all non-array properties from schema will be added.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAdd<Property extends Extract<keyof Model, keyof SchModel>>(...properties: Property[]): this;\n    public withAdd<Property extends Extract<keyof Model, keyof SchModel>>(propOrOpts: ColumnsFromSchemaOptsType<SchModel> | Property, ...properties: Property[]): this {\n        if (typeof propOrOpts === 'object') {\n            this.addColumns(properties.length === 0 ? undefined : properties, propOrOpts);\n        } else {\n            this.addColumns([propOrOpts, ...properties]);\n        }\n        return this;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single column via {addColumnFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the column for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     * @param {ColumnFromSchemaOptsType} opts - Additional options.\n     *\n     * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} The added column descriptor.\n     */\n    public addFromSchema<Property extends keyof Model>(\n        property: Property,\n        schemaProperty: SchemaProperty,\n        opts?: ColumnFromSchemaOptsType<Model[Property], Model>\n    ): ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]> {\n        return addColumnFromSchema(this.descriptor, property, schemaProperty, this.mergeColumnOpts(property, opts));\n    }\n\n    private addColumns<Property extends Extract<keyof Model, keyof SchModel>>(properties?: Property[], opts?: ColumnsFromSchemaOptsType<SchModel>) {\n        const addProperties = properties ?? fromSchemaFilterNonArrayProperties<SchModel>(this.schema.properties);\n\n        if (addProperties) {\n            addProperties.forEach(property => {\n                addColumnFromSchema(\n                    this.descriptor,\n                    property as unknown as keyof Model,\n                    this.schema.properties[property],\n                    this.mergeColumnsOpts(property as unknown as keyof Model, opts)\n                );\n            });\n        }\n    }\n}\n\n/**\n * <em>Experimental:</em> Creates builder for adding columns to descriptor based on provided model schema.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - Descriptor to add columns to.\n * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.\n * @param {ColumnsFromSchemaOptsType<SchModel>} [opts] - Additional options.\n *\n * @return {SchemaColumnsBuilder<Model, SchModel>} - The column schema builder instance.\n */\nexport function columnsFromSchema<Model, SchModel = Model>(\n    descriptor: TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>,\n    schema: SchemaModel<SchModel>,\n    opts?: ColumnsFromSchemaOptsType<SchModel>\n): SchemaColumnsBuilder<Model, SchModel> {\n    return new SchemaColumnsBuilder<Model, SchModel>(descriptor, schema, opts);\n}\n\n/**\n * <em>Experimental:</em> Adds a column to table descriptor based on the given schema property and options.\n *\n * @param {TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>} descriptor - The table view descriptor or table descriptor to add the column to.\n * @param {Property} property - The property key of the model to create the column for.\n * @param {SchemaProperty} propertySchema - The schema property for the property.\n * @param {ColumnFromSchemaOptsType<Model[Property], Model, any, Model>} [opts] - The options for the column.\n *\n * @return {ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>} - The added column descriptor.\n */\nexport function addColumnFromSchema<Property extends keyof Model, Model>(\n    descriptor: TableviewDescriptorInst<Model, any, any, any> | TableDescriptorInst<Model, any, any>,\n    property: Property,\n    propertySchema: SchemaProperty,\n    opts?: ColumnFromSchemaOptsType<Model[Property], Model, any, Model>\n): ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]> {\n    const propertyType = opts?.columnType ?? propertySchema?.type;\n\n    const column = descriptor.addColumn(property);\n\n    // Handle different property types\n    switch (propertyType) {\n        case 'number':\n            if (opts?.currency) {\n                column.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));\n            } else {\n                column.asNumber();\n            }\n            break;\n        case 'boolean':\n            column.asBoolean(undefined, undefined, true);\n            break;\n        case 'date':\n            column.asDate(opts?.dateFormat ?? 'dd.MM.YYYY');\n            break;\n        case 'enum':\n            // eslint-disable-next-line no-case-declarations\n            const enumModel = opts?.enumSchema ? enumModelFromSchema(opts.enumSchema) : opts?.enumModel;\n            if (enumModel) {\n                column.asEnumUnsafe(enumModel);\n            }\n            break;\n        case 'date-time':\n            column.asDate(opts?.dateTimeFormat ?? 'dd.MM.YYYY HH:mm');\n            break;\n        case 'currency':\n            column.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts?.currency) : undefined);\n            break;\n        case 'object':\n            column.withGetter(defaultGetter);\n            break;\n    }\n\n    // Add optional filter, sort and getters\n    if (opts?.getter) column.withGetter(opts?.getter);\n\n    return column;\n}\n"]}

package/esm2022/tableview/schema/enum-from-schema.mjs

@@ -0,0 +1,23 @@
+import { enumModelGeneric } from '@mediusinc/mng-commons/model';
+/**
+ * <em>Experimental:</em> Emulates an enum model object from enum schema.
+ *
+ * @experimental
+ *
+ * @param {SchemaEnum<Enum>} enumSchema - The schema of the enum.
+ *
+ * @returns {EnumDescriptor<Enum>} - The generated enum model descriptor.
+ */
+export function enumModelFromSchema(enumSchema) {
+    const enumObj = {};
+    enumSchema.values
+        .map((v, idx) => ({ value: v, constant: enumSchema.constants[idx] }))
+        .forEach(({ value, constant }) => {
+        const valueAsStrOrInt = value;
+        enumObj[constant] = valueAsStrOrInt;
+        if (typeof valueAsStrOrInt === 'number' && enumObj[valueAsStrOrInt] == null)
+            enumObj[valueAsStrOrInt] = constant;
+    });
+    return enumModelGeneric(enumObj, enumSchema.name.replace(/\d+$/, ''));
+}
+//# sourceMappingURL=data:application/json;base64,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