@mediusinc/mng-commons-data-api 5.2.0 → 5.3.0-rc.1

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

@@ -1,5 +1,5 @@
 import { enumModelFromSchema } from './enum-from-schema';
-import { fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
+import { fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
 const defaultGetter = value => {
     if (typeof value === 'object') {
         const valueObj = value;
@@ -135,12 +135,11 @@ export function addColumnFromSchema(descriptor, property, propertySchema, opts)
     // Handle different property types
     switch (propertyType) {
         case 'number':
-            if (opts?.currency) {
-                column.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));
-            }
-            else {
-                column.asNumber();
-            }
+            column.asNumber({
+                minFractionDigits: opts?.numberMinFractionDigits,
+                maxFractionDigits: opts?.numberMaxFractionDigits,
+                minIntegerDigits: opts?.numberMinIntegerDigits
+            });
             break;
         case 'boolean':
             column.asBoolean(undefined, undefined, true);
@@ -159,7 +158,14 @@ export function addColumnFromSchema(descriptor, property, propertySchema, opts)
             column.asDate(opts?.dateTimeFormat ?? 'dd.MM.YYYY HH:mm');
             break;
         case 'currency':
-            column.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts?.currency) : undefined);
+            column.asCurrency({
+                currency: opts?.currency,
+                currencyDisplay: opts?.currencyDisplay,
+                currencyProperty: opts?.currencyProperty,
+                minFractionDigits: opts?.numberMinFractionDigits,
+                maxFractionDigits: opts?.numberMaxFractionDigits,
+                minIntegerDigits: opts?.numberMinIntegerDigits
+            });
             break;
         case 'object':
             column.withGetter(defaultGetter);
@@ -170,4 +176,4 @@ export function addColumnFromSchema(descriptor, property, propertySchema, opts)
         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"]}
+//# 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 {fromSchemaFilterNonArrayProperties} from './internal/common-from-schema';\n\ntype ColumnType = 'number' | 'currency' | 'boolean' | 'string' | 'text' | 'textarea' | 'date' | 'date-time' | 'enum' | 'object';\n\ntype ColumnFromSchemaCommonOptsType<Model> = {\n    currencyProperty?: keyof Model;\n    currency?: string;\n    currencyDisplay?: 'symbol' | 'code' | 'name';\n    dateFormat?: string;\n    dateTimeFormat?: string;\n    numberMinIntegerDigits?: number;\n    numberMinFractionDigits?: number;\n    numberMaxFractionDigits?: number;\n};\n\ntype ColumnsFromSchemaOptsType<Model = any> = ColumnFromSchemaCommonOptsType<Model> & {\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};\n\ntype ColumnFromSchemaOptsType<Column = any, Model = any, Enum = any> = ColumnFromSchemaCommonOptsType<Model> & {\n    columnType?: ColumnType;\n    getter?: GetterFn<Column, Model>;\n    enumModel?: EnumDescriptor<Enum>;\n    enumSchema?: SchemaEnum<Enum>;\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: any, opts?: ColumnsFromSchemaOptsType) {\n        return <ColumnFromSchemaOptsType>{\n            ...this.opts,\n            columnType: this.opts?.columnTypes?.[property as keyof object],\n            getter: opts?.getters?.[property] ?? this.opts?.getters?.[property as keyof object],\n            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property as keyof object],\n            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property as keyof object],\n            ...opts\n        };\n    }\n\n    private mergeColumnOpts(property: any, opts?: ColumnFromSchemaOptsType) {\n        return <ColumnFromSchemaOptsType>{\n            ...this.opts,\n            columnType: this.opts?.columnTypes?.[property as keyof object],\n            getter: this.opts?.getters?.[property as keyof object],\n            enumModel: this.opts?.enumModels?.[property as keyof object],\n            enumSchema: this.opts?.enumSchemas?.[property as keyof object],\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>\n    ): ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]> {\n        return addColumnFromSchema(\n            this.descriptor,\n            property,\n            this.schema.properties[property],\n            this.mergeColumnOpts(property, opts) as ColumnFromSchemaOptsType<Model[Property], Model, any> | undefined\n        ) as unknown as ColumnDescriptor<NonNullable<Model[Property]>, Model, Model[Property]>;\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(\n            this.descriptor,\n            property,\n            schemaProperty,\n            this.mergeColumnOpts(property, opts) as ColumnFromSchemaOptsType<Model[Property], Model, any> | undefined\n        );\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 any,\n                    this.schema.properties[property],\n                    this.mergeColumnsOpts(property as unknown as keyof Model, opts) as ColumnFromSchemaOptsType<Model[Property], Model, any> | undefined\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>\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            column.asNumber({\n                minFractionDigits: opts?.numberMinFractionDigits,\n                maxFractionDigits: opts?.numberMaxFractionDigits,\n                minIntegerDigits: opts?.numberMinIntegerDigits\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({\n                currency: opts?.currency,\n                currencyDisplay: opts?.currencyDisplay,\n                currencyProperty: opts?.currencyProperty,\n                minFractionDigits: opts?.numberMinFractionDigits,\n                maxFractionDigits: opts?.numberMaxFractionDigits,\n                minIntegerDigits: opts?.numberMinIntegerDigits\n            });\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/fields-from-schema.mjs

@@ -2,7 +2,7 @@ import { CommonsInternalError, fromAngularDateFormatToPrime } from '@mediusinc/m
 import { EnumDescriptor } from '@mediusinc/mng-commons/model';
 import { FieldInputDescriptor, TableviewDescriptorInst } from '@mediusinc/mng-commons/tableview/api';
 import { enumModelFromSchema } from './enum-from-schema';
-import { fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
+import { fromSchemaFilterNonArrayProperties } from './internal/common-from-schema';
 /**
  * <em>Experimental:</em> Builder for adding fields to editor.
  *
@@ -342,7 +342,7 @@ export class SchemaFieldsBuilder {
  *
  * @experimental
  *
- * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add fields to.
+ * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>} descriptor - Descriptor to add fields to.
  * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.
  * @param {FieldsFromSchemaOptsType<SchModel>} [opts] - Additional options.
  *
@@ -365,7 +365,7 @@ export function fieldsFromSchema(descriptor, schema, opts) {
  */
 export function addFieldInputFromSchema(descriptor, property, propertySchema, opts) {
     const propertyType = opts?.fieldType ?? propertySchema.type;
-    const field = new FieldInputDescriptor(descriptor instanceof TableviewDescriptorInst ? descriptor.detailsEditor : descriptor, property);
+    const field = new FieldInputDescriptor(property);
     if (descriptor instanceof TableviewDescriptorInst) {
         descriptor.detailsEditor.addFieldDescriptor(field);
         descriptor.editEditor.addFieldDescriptor(field);
@@ -377,15 +377,14 @@ export function addFieldInputFromSchema(descriptor, property, propertySchema, op
     // Handle different property types
     switch (propertyType) {
         case 'number':
-            if (opts?.currency) {
-                field.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));
-            }
-            else {
-                field.asNumber();
-            }
+            field.asNumber();
             break;
         case 'currency':
-            field.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts.currency) : undefined);
+            field.asCurrency({
+                currency: opts?.currency,
+                currencyDisplay: opts?.currencyDisplay,
+                currencyProperty: opts?.currencyProperty
+            });
             break;
         case 'boolean':
             field.asSwitch();
@@ -421,8 +420,18 @@ export function addFieldInputFromSchema(descriptor, property, propertySchema, op
     if (propertyType === 'number' || propertyType === 'currency') {
         field.withNumberValidation({
             min: propertySchema.exclusiveMinimum && propertySchema.minimum != undefined ? propertySchema.minimum + (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.minimum,
-            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum
+            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum,
+            step: opts?.numberStep
         });
+        if (opts?.numberUseGrouping) {
+            field.withNumberGrouping();
+        }
+        if (opts?.numberMinFractionDigits != null || opts?.numberMaxFractionDigits != null) {
+            field.withNumberFractions({
+                minFractionDigits: opts?.numberMinFractionDigits,
+                maxFractionDigits: opts?.numberMaxFractionDigits
+            });
+        }
     }
     if (propertyType === 'string' || propertyType === 'textarea' || propertyType === 'text') {
         field.withTextValidation({
@@ -430,6 +439,9 @@ export function addFieldInputFromSchema(descriptor, property, propertySchema, op
             maxLength: propertySchema.maxLength,
             pattern: propertySchema.pattern ? new RegExp(propertySchema.pattern.slice(1, -1)) : undefined
         });
+        if (propertyType === 'textarea' && opts?.textareaRows != null) {
+            field.withTextareaRows(opts.textareaRows);
+        }
         if (propertyType !== 'textarea' && propertySchema.isEmail) {
             field.withTextValidationEmail();
         }
@@ -442,7 +454,7 @@ export function addFieldInputFromSchema(descriptor, property, propertySchema, op
  *
  * @experimental
  *
- * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add field to.
+ * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>} descriptor - Descriptor to add field to.
  * @param {keyof Model} property - The property of the model.
  * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} enumOpt - The enum schema or enum model descriptor.
  * @param {SchemaProperty} propertySchema - The property's schema for the field.
@@ -467,4 +479,4 @@ export function setFieldBasicOptionsFromSchema(field, propertySchema) {
     if (propertySchema.isReadOnly)
         field.withDisabled();
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields-from-schema.js","sourceRoot":"","sources":["../../../../tableview/src/schema/fields-from-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import {SchemaEnum, SchemaModel, SchemaProperty} from '@mediusinc/mng-commons-data-api';\nimport {ArrayItemType, CommonsInternalError, KeyofAndOfType, fromAngularDateFormatToPrime} from '@mediusinc/mng-commons/core';\nimport {EnumDescriptor, TypeDescriptor} from '@mediusinc/mng-commons/model';\nimport {ITableDataProvider, TableDescriptorInst} from '@mediusinc/mng-commons/table/api';\nimport {\n    AFieldDescriptor,\n    EditorDescriptorInst,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldLookupProviderType,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    TableviewDescriptorInst\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {enumModelFromSchema} from './enum-from-schema';\nimport {FromSchemaCurrencyOptsType, fromSchemaCurrencyOptsToCurrency, fromSchemaFilterNonArrayProperties} from './internal/common-from-schema';\n\ntype FieldInputType = 'number' | 'currency' | 'boolean' | 'string' | 'text' | 'textarea' | 'date' | 'date-time' | 'enum' | 'hidden';\n\ntype FieldsFromSchemaOptsType<Model = any> = {\n    fieldTypes?: Partial<Record<keyof Model, FieldInputType>>;\n    enumModels?: Partial<Record<keyof Model, EnumDescriptor<any>>>;\n    enumSchemas?: Partial<Record<keyof Model, SchemaEnum<any>>>;\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\ntype FieldInputFromSchemaOptsType<Model = any, Enum = any> = {\n    fieldType?: FieldInputType;\n    enumSchema?: SchemaEnum<Enum>;\n    enumModel?: EnumDescriptor<Enum>;\n    currency?: FromSchemaCurrencyOptsType<Model>;\n    dateFormat?: string;\n    dateTimeFormat?: string;\n};\n\n/**\n * <em>Experimental:</em> Builder for adding fields to editor.\n *\n * @experimental\n */\nexport class SchemaFieldsBuilder<Model, Parent = unknown, SchModel = Model> {\n    constructor(\n        private readonly descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n        private readonly schema: SchemaModel<SchModel>,\n        private opts?: FieldsFromSchemaOptsType<SchModel>\n    ) {}\n\n    private mergeFieldsInputOpts(property: keyof Model, opts?: FieldsFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: opts?.fieldTypes?.[property] ?? this.opts?.fieldTypes?.[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 mergeFieldInputOpts(property: keyof Model, opts?: FieldInputFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: this.opts?.fieldTypes?.[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 input field via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {FieldInputFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public add<Property extends Extract<keyof Model, keyof SchModel>>(\n        property: Property,\n        opts?: FieldInputFromSchemaOptsType<SchModel>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(this.descriptor, property, this.schema.properties[property], this.mergeFieldInputOpts(property, opts));\n    }\n\n    /**\n     * <em>Experimental:</em> Adds all input fields for the non-array properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAddAll(opts?: FieldsFromSchemaOptsType<SchModel>): this {\n        this.addFields(undefined, opts);\n        return this;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds input fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     * @param {...Property[]} properties - Properties to add fields 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<PropertyKey extends Extract<keyof Model, keyof SchModel>>(opts: FieldsFromSchemaOptsType<SchModel>, ...properties: PropertyKey[]): this;\n    /**\n     * <em>Experimental:</em> Adds fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {...Property[]} properties - Properties to add fields 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<PropertyKey extends Extract<keyof Model, keyof SchModel>>(...properties: PropertyKey[]): this;\n    public withAdd<PropertyKey extends Extract<keyof Model, keyof SchModel>>(propOrOpts: FieldsFromSchemaOptsType<SchModel> | PropertyKey, ...properties: PropertyKey[]): this {\n        if (typeof propOrOpts === 'object') {\n            this.addFields(properties.length === 0 ? undefined : properties, propOrOpts);\n        } else {\n            this.addFields(propOrOpts === undefined ? properties : [propOrOpts, ...properties]);\n        }\n        return this;\n    }\n\n    private addFields<Property extends Extract<keyof Model, keyof SchModel>>(properties?: Property[], opts?: FieldsFromSchemaOptsType<SchModel>) {\n        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);\n\n        addProperties.forEach(property => {\n            addFieldInputFromSchema(\n                this.descriptor,\n                property as unknown as keyof Model,\n                this.schema.properties[property],\n                this.mergeFieldsInputOpts(property as unknown as keyof Model, opts)\n            );\n        });\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     * @param {FieldInputFromSchemaOptsType<Model>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public addFromSchema<Property extends keyof Model>(\n        property: Property,\n        schemaProperty: SchemaProperty,\n        opts?: FieldInputFromSchemaOptsType<Model>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(this.descriptor, property, schemaProperty, this.mergeFieldInputOpts(property, opts));\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnum<Property extends Extract<keyof Model, keyof SchModel>, Enum>(\n        property: Property,\n        enumOpt?: SchemaEnum<Enum> | EnumDescriptor<Enum>\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema<Model, Parent, Enum>(this.descriptor, property, enumOpt, this.schema.properties[property]);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnumFromSchema<Property extends keyof Model, Enum>(\n        property: Property,\n        enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum> | undefined,\n        schemaProperty: SchemaProperty\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema(this.descriptor, property, enumOpt, schemaProperty);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     *\n     * @return The created lookup field.\n     */\n    public addLookup<Property extends Extract<keyof Model, keyof SchModel>, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(property: Property) {\n        const field = this.descriptor.addFieldLookup<Property, LookupModel>(property);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupFromSchema<Property extends keyof Model, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookup(property);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValuePropertyFromSchema<\n        Property extends keyof Model,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty, schemaProperty: SchemaProperty) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProvider<Property extends Extract<keyof Model, keyof SchModel>, Service, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProviderFromSchema<Property extends keyof Model, Service, LookupModel = NonNullable<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValuePropertyFromSchema<\n        Property extends keyof Model,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty,\n        schemaProperty: SchemaProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a one-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditor<Property extends Extract<keyof Model, keyof SchModel>, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an one-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditorFromSchema<Property extends keyof Model, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>,\n        schemaProperty: SchemaProperty\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditor<Property extends Extract<keyof Model, keyof SchModel>, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditorFromSchema<Property extends keyof Model, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>,\n        schemaProperty: SchemaProperty\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n}\n\n/**\n * <em>Experimental:</em> Creates builder for adding fields to descriptor based on provided model schema.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add fields to.\n * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.\n * @param {FieldsFromSchemaOptsType<SchModel>} [opts] - Additional options.\n *\n * @return {SchemaFieldsBuilder<Model, Parent, SchModel>} - The SchemaFieldsBuilder object containing the extracted fields.\n */\nexport function fieldsFromSchema<Model, Parent = unknown, SchModel = Model>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    schema: SchemaModel<SchModel>,\n    opts?: FieldsFromSchemaOptsType<SchModel>\n): SchemaFieldsBuilder<Model, Parent, SchModel> {\n    return new SchemaFieldsBuilder<Model, Parent, SchModel>(descriptor, schema, opts);\n}\n\n/**\n * <em>Experimental:</em> Adds a field input to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst | EditorDescriptorInst} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n * @param {FieldInputFromSchemaOptsType<Model>} [opts] - Additional options.\n *\n * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} - The generated field input descriptor.\n */\nexport function addFieldInputFromSchema<Property extends keyof Model, Model, Parent = unknown>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    property: Property,\n    propertySchema: SchemaProperty,\n    opts?: FieldInputFromSchemaOptsType<Model>\n): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n    const propertyType = opts?.fieldType ?? propertySchema.type;\n\n    const field = new FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>(\n        descriptor instanceof TableviewDescriptorInst ? descriptor.detailsEditor : descriptor,\n        property as string\n    );\n    if (descriptor instanceof TableviewDescriptorInst) {\n        descriptor.detailsEditor.addFieldDescriptor(field);\n        descriptor.editEditor.addFieldDescriptor(field);\n        descriptor.addEditor.addFieldDescriptor(field);\n    } else {\n        descriptor.addFieldDescriptor(field);\n    }\n\n    // Handle different property types\n    switch (propertyType as FieldInputType) {\n        case 'number':\n            if (opts?.currency) {\n                field.asCurrency(fromSchemaCurrencyOptsToCurrency(opts.currency));\n            } else {\n                field.asNumber();\n            }\n            break;\n        case 'currency':\n            field.asCurrency(opts?.currency ? fromSchemaCurrencyOptsToCurrency(opts.currency) : undefined);\n            break;\n        case 'boolean':\n            field.asSwitch();\n            break;\n        case 'text':\n        case 'string':\n            field.asText();\n            break;\n        case 'textarea':\n            field.asTextarea();\n            break;\n        case 'date':\n            field.asDatePicker({format: opts?.dateFormat ? fromAngularDateFormatToPrime(opts.dateFormat) : undefined});\n            break;\n        case 'date-time':\n            field.asDatePicker({showTime: true, format: opts?.dateTimeFormat ? fromAngularDateFormatToPrime(opts.dateTimeFormat) : undefined});\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                field.asRadioFromEnum(enumModel);\n            } else {\n                field.asText();\n            }\n            break;\n        case 'hidden':\n            field.asHidden();\n            break;\n    }\n\n    // Handle different property validations\n    if (propertyType === 'number' || propertyType === 'currency') {\n        field.withNumberValidation({\n            min: propertySchema.exclusiveMinimum && propertySchema.minimum != undefined ? propertySchema.minimum + (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.minimum,\n            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum\n        });\n    }\n\n    if (propertyType === 'string' || propertyType === 'textarea' || propertyType === 'text') {\n        field.withTextValidation({\n            minLength: propertySchema.minLength,\n            maxLength: propertySchema.maxLength,\n            pattern: propertySchema.pattern ? new RegExp(propertySchema.pattern.slice(1, -1)) : undefined\n        });\n\n        if (propertyType !== 'textarea' && propertySchema.isEmail) {\n            field.withTextValidationEmail();\n        }\n    }\n\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Adds a field enum lookup to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} enumOpt - The enum schema or enum model descriptor.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n *\n * @returns {FieldLookupEnum<Enum>} - The field with enumeration values.\n */\nexport function addFieldEnumLookupFromSchema<Model, Parent = unknown, Enum = any>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model>,\n    property: keyof Model,\n    enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum>,\n    propertySchema: SchemaProperty\n) {\n    const enumDescriptor = enumOpt instanceof EnumDescriptor ? enumOpt : enumModelFromSchema(enumOpt);\n    const field = descriptor.addFieldLookupEnumUnsafe<Enum>(property as string, enumDescriptor);\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Sets basic options for a field based on a given property schema.\n *\n * @param {AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>} field - The field to set options for.\n * @param {SchemaProperty} propertySchema - The property schema to base the options on.\n */\nexport function setFieldBasicOptionsFromSchema<FieldModel = any, EditorModel = any, FieldValue = FieldModel, ParentEditorModel = undefined>(\n    field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>,\n    propertySchema: SchemaProperty\n): void {\n    if (propertySchema.required) field.withRequired();\n    if (propertySchema.isReadOnly) field.withDisabled();\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fields-from-schema.js","sourceRoot":"","sources":["../../../../tableview/src/schema/fields-from-schema.ts"],"names":[],"mappings":"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","sourcesContent":["import {SchemaEnum, SchemaModel, SchemaProperty} from '@mediusinc/mng-commons-data-api';\nimport {ArrayItemType, CommonsInternalError, KeyofAndOfType, fromAngularDateFormatToPrime} from '@mediusinc/mng-commons/core';\nimport {EnumDescriptor, TypeDescriptor} from '@mediusinc/mng-commons/model';\nimport {ITableDataProvider, TableDescriptorInst} from '@mediusinc/mng-commons/table/api';\nimport {\n    AFieldDescriptor,\n    EditorDescriptorInst,\n    FieldInputDescriptor,\n    FieldLookupDescriptor,\n    FieldLookupEnumDescriptor,\n    FieldLookupProviderType,\n    FieldManyEditorDescriptor,\n    FieldManyToManyEditorDescriptor,\n    TableviewDescriptorInst\n} from '@mediusinc/mng-commons/tableview/api';\n\nimport {enumModelFromSchema} from './enum-from-schema';\nimport {fromSchemaFilterNonArrayProperties} from './internal/common-from-schema';\n\ntype FieldInputType = 'number' | 'currency' | 'boolean' | 'string' | 'text' | 'textarea' | 'date' | 'date-time' | 'enum' | 'hidden';\n\ntype FromSchemaCommonOptsType<Model> = {\n    dateFormat?: string;\n    dateTimeFormat?: string;\n    textareaRows?: number;\n    numberUseGrouping?: boolean;\n    numberStep?: number;\n    numberMinFractionDigits?: number;\n    numberMaxFractionDigits?: number;\n    currency?: string;\n    currencyProperty?: keyof Model;\n    currencyDisplay?: 'symbol' | 'code' | 'name';\n};\n\ntype FieldsFromSchemaOptsType<Model = any> = FromSchemaCommonOptsType<Model> & {\n    fieldTypes?: Partial<Record<keyof Model, FieldInputType>>;\n    enumModels?: Partial<Record<keyof Model, EnumDescriptor<any>>>;\n    enumSchemas?: Partial<Record<keyof Model, SchemaEnum<any>>>;\n};\n\ntype FieldInputFromSchemaOptsType<Model = any, Enum = any> = FromSchemaCommonOptsType<Model> & {\n    fieldType?: FieldInputType;\n    enumSchema?: SchemaEnum<Enum>;\n    enumModel?: EnumDescriptor<Enum>;\n};\n\n/**\n * <em>Experimental:</em> Builder for adding fields to editor.\n *\n * @experimental\n */\nexport class SchemaFieldsBuilder<Model, Parent = unknown, SchModel = Model> {\n    constructor(\n        private readonly descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>,\n        private readonly schema: SchemaModel<SchModel>,\n        private opts?: FieldsFromSchemaOptsType<SchModel>\n    ) {}\n\n    private mergeFieldsInputOpts(property: any, opts?: FieldsFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: opts?.fieldTypes?.[property] ?? this.opts?.fieldTypes?.[property as keyof object],\n            enumModel: opts?.enumModels?.[property] ?? this.opts?.enumModels?.[property as keyof object],\n            enumSchema: opts?.enumSchemas?.[property] ?? this.opts?.enumSchemas?.[property as keyof object],\n            ...opts\n        };\n    }\n\n    private mergeFieldInputOpts(property: any, opts?: FieldInputFromSchemaOptsType) {\n        return <FieldInputFromSchemaOptsType>{\n            ...this.opts,\n            fieldType: this.opts?.fieldTypes?.[property as keyof object],\n            enumModel: this.opts?.enumModels?.[property as keyof object],\n            enumSchema: this.opts?.enumSchemas?.[property as keyof object],\n            ...opts\n        };\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {FieldInputFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public add<Property extends Extract<keyof Model, keyof SchModel>>(\n        property: Property,\n        opts?: FieldInputFromSchemaOptsType<SchModel>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(\n            this.descriptor,\n            property,\n            this.schema.properties[property],\n            this.mergeFieldInputOpts(property, opts) as FieldInputFromSchemaOptsType<Model, any> | undefined\n        );\n    }\n\n    /**\n     * <em>Experimental:</em> Adds all input fields for the non-array properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     *\n     * @return {this} - The current instance of the builder.\n     */\n    public withAddAll(opts?: FieldsFromSchemaOptsType<SchModel>): this {\n        this.addFields(undefined, opts);\n        return this;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds input fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {FieldsFromSchemaOptsType<SchModel>} opts - Additional options.\n     * @param {...Property[]} properties - Properties to add fields 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<PropertyKey extends Extract<keyof Model, keyof SchModel>>(opts: FieldsFromSchemaOptsType<SchModel>, ...properties: PropertyKey[]): this;\n    /**\n     * <em>Experimental:</em> Adds fields for properties via {addFieldInputFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {...Property[]} properties - Properties to add fields 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<PropertyKey extends Extract<keyof Model, keyof SchModel>>(...properties: PropertyKey[]): this;\n    public withAdd<PropertyKey extends Extract<keyof Model, keyof SchModel>>(propOrOpts: FieldsFromSchemaOptsType<SchModel> | PropertyKey, ...properties: PropertyKey[]): this {\n        if (typeof propOrOpts === 'object') {\n            this.addFields(properties.length === 0 ? undefined : properties, propOrOpts);\n        } else {\n            this.addFields(propOrOpts === undefined ? properties : [propOrOpts, ...properties]);\n        }\n        return this;\n    }\n\n    private addFields<Property extends Extract<keyof Model, keyof SchModel>>(properties?: Property[], opts?: FieldsFromSchemaOptsType<SchModel>) {\n        const addProperties = properties ?? fromSchemaFilterNonArrayProperties(this.schema.properties);\n\n        addProperties.forEach(property => {\n            addFieldInputFromSchema(\n                this.descriptor,\n                property as unknown as keyof Model,\n                this.schema.properties[property],\n                this.mergeFieldsInputOpts(property, opts) as FieldInputFromSchemaOptsType<Model, any> | undefined\n            );\n        });\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a single input field via {addFieldInputFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     * @param {FieldInputFromSchemaOptsType<Model>} opts - Additional options.\n     *\n     * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} The added field descriptor.\n     */\n    public addFromSchema<Property extends keyof Model>(\n        property: Property,\n        schemaProperty: SchemaProperty,\n        opts?: FieldInputFromSchemaOptsType<Model>\n    ): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n        return addFieldInputFromSchema(this.descriptor, property, schemaProperty, this.mergeFieldInputOpts(property, opts) as FieldInputFromSchemaOptsType<Model, any> | undefined);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema}.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnum<Property extends Extract<keyof Model, keyof SchModel>, Enum>(\n        property: Property,\n        enumOpt?: SchemaEnum<Enum> | EnumDescriptor<Enum>\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema<Model, Parent, Enum>(this.descriptor, property, enumOpt, this.schema.properties[property]);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an enum lookup field via {addFieldEnumLookupFromSchema} where property schema is manually provided.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to add the enum lookup field for.\n     * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} [enumOpt] - The enum schema or the enum model descriptor. If non provided, builder opts will be checked.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @returns {FieldLookupEnumDescriptor<Enum, Model, Parent>} - The added field descriptor.\n     *\n     * @throws {CommonsInternalError} - If no enum metadata is found for the property either from parameter or from builder's opts.\n     */\n    public addEnumFromSchema<Property extends keyof Model, Enum>(\n        property: Property,\n        enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum> | undefined,\n        schemaProperty: SchemaProperty\n    ): FieldLookupEnumDescriptor<Enum, Model, Parent> {\n        if (!enumOpt) {\n            enumOpt = this.opts?.enumModels?.[property] ?? this.opts?.enumSchemas?.[property];\n        }\n        if (!enumOpt) {\n            throw new CommonsInternalError(`Enum lookup field for property ${property as string} cannot be added because enum metadata was not provided.`);\n        }\n        return addFieldEnumLookupFromSchema(this.descriptor, property, enumOpt, schemaProperty);\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     *\n     * @return The created lookup field.\n     */\n    public addLookup<Property extends Extract<keyof Model, keyof SchModel>, LookupModel = NonNullable<Model[Property]>>(property: Property) {\n        const field = this.descriptor.addFieldLookup<Property, LookupModel>(property);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookup} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupFromSchema<Property extends keyof Model>(property: Property, schemaProperty: SchemaProperty) {\n        const field = this.descriptor.addFieldLookup(property);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>\n    >(property: Property, type: TypeDescriptor<LookupModel>, lookupOptionsValueProperty: LookupValueProperty) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithOptionsValuePropertyFromSchema<Property extends keyof Model, LookupModel, LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>>(\n        property: Property,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookupWithOptionsValueProperty(property, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProvider<Property extends Extract<keyof Model, keyof SchModel>, Service, LookupModel = NonNullable<Model[Property]>>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProvider} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    public addLookupWithProviderFromSchema<Property extends keyof Model, Service, LookupModel = NonNullable<Model[Property]>>(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        schemaProperty: SchemaProperty\n    ) {\n        const field = this.descriptor.addFieldLookupWithProvider(property, provider);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValueProperty<\n        Property extends Extract<keyof Model, keyof SchModel>,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue, Parent> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue, Parent>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a lookup field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldLookupWithProviderAndOptionsValueProperty} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the lookup field for.\n     * @param {FieldLookupProviderType<LookupModel, Service>} provider - Lookup provider.\n     * @param {TypeDescriptor<LookupModel>} type - Type of lookup model.\n     * @param {LookupValueProperty} lookupOptionsValueProperty - Value property from lookup model.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created lookup field.\n     */\n    addLookupWithProviderAndOptionsValuePropertyFromSchema<\n        Property extends keyof Model,\n        Service,\n        LookupModel,\n        LookupValueProperty extends KeyofAndOfType<LookupModel, Model[Property]>,\n        FieldValue = Model[Property]\n    >(\n        property: Property,\n        provider: FieldLookupProviderType<LookupModel, Service>,\n        type: TypeDescriptor<LookupModel>,\n        lookupOptionsValueProperty: LookupValueProperty,\n        schemaProperty: SchemaProperty\n    ): FieldLookupDescriptor<LookupModel, Model, Service, FieldValue, Parent> {\n        const field = this.descriptor.addFieldLookupWithProviderAndOptionsValueProperty(property, provider, type, lookupOptionsValueProperty);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field as FieldLookupDescriptor<LookupModel, Model, Service, FieldValue, Parent>;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a one-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditor<Property extends Extract<keyof Model, keyof SchModel>, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue, Parent> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds an one-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableviewDescriptorInst<FieldModel, any, any, Model>} tableviewDescriptor - Tableview descriptor.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created one-to-many editor field.\n     */\n    addManyEditorFromSchema<Property extends keyof Model, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        tableviewDescriptor: TableviewDescriptorInst<FieldModel, any, any, Model>,\n        schemaProperty: SchemaProperty\n    ): FieldManyEditorDescriptor<FieldModel, Model, FieldValue, Parent> {\n        const field = this.descriptor.addFieldManyEditor<Property, FieldModel, FieldValue>(property, tableviewDescriptor);\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditor<Property extends Extract<keyof Model, keyof SchModel>, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue, Parent> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, this.schema.properties[property]);\n        return field;\n    }\n\n    /**\n     * <em>Experimental:</em> Adds a many-to-many editor field where property schema is manually provided.\n     * {EditorDescriptorInt.addFieldManyToManyEditor} is used to create field and ${setFieldBasicOptionsFromSchema} to add basic field's options from schema.\n     *\n     * @experimental\n     *\n     * @param {Property} property - The property to create the many editor field for.\n     * @param {TableDescriptorInst<FieldModel>} mainTableDescriptor - Main table descriptor.\n     * @param {TableDescriptorInst<FieldModel>} lookupTableDescriptor - Lookup table descriptor.\n     * @param {ITableDataProvider<FieldModel, ServiceType>} lookupDataProvider - Lookup data provider.\n     * @param {SchemaProperty} schemaProperty - Manually provided schema property.\n     *\n     * @return The created many-to-many editor field.\n     */\n    addManyToManyEditorFromSchema<Property extends keyof Model, ServiceType, FieldModel = ArrayItemType<Model[Property]>, FieldValue = Model[Property]>(\n        property: Property,\n        mainTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupTableDescriptor: TableDescriptorInst<FieldModel>,\n        lookupDataProvider: ITableDataProvider<FieldModel, ServiceType>,\n        schemaProperty: SchemaProperty\n    ): FieldManyToManyEditorDescriptor<FieldModel, Model, ServiceType, FieldValue, Parent> {\n        const field = this.descriptor.addFieldManyToManyEditor<Property, ServiceType, FieldModel, FieldValue>(\n            property,\n            mainTableDescriptor,\n            lookupTableDescriptor,\n            lookupDataProvider\n        );\n        setFieldBasicOptionsFromSchema(field, schemaProperty);\n        return field;\n    }\n}\n\n/**\n * <em>Experimental:</em> Creates builder for adding fields to descriptor based on provided model schema.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>} descriptor - Descriptor to add fields to.\n * @param {SchemaModel<SchModel>} schema - The schema with metadata about properties for fields.\n * @param {FieldsFromSchemaOptsType<SchModel>} [opts] - Additional options.\n *\n * @return {SchemaFieldsBuilder<Model, Parent, SchModel>} - The SchemaFieldsBuilder object containing the extracted fields.\n */\nexport function fieldsFromSchema<Model, Parent = unknown, SchModel = Model>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>,\n    schema: SchemaModel<SchModel>,\n    opts?: FieldsFromSchemaOptsType<SchModel>\n): SchemaFieldsBuilder<Model, Parent, SchModel> {\n    return new SchemaFieldsBuilder<Model, Parent, SchModel>(descriptor, schema, opts);\n}\n\n/**\n * <em>Experimental:</em> Adds a field input to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst | EditorDescriptorInst} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n * @param {FieldInputFromSchemaOptsType<Model>} [opts] - Additional options.\n *\n * @return {FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>} - The generated field input descriptor.\n */\nexport function addFieldInputFromSchema<Property extends keyof Model, Model, Parent = unknown>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>,\n    property: Property,\n    propertySchema: SchemaProperty,\n    opts?: FieldInputFromSchemaOptsType<Model>\n): FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent> {\n    const propertyType = opts?.fieldType ?? propertySchema.type;\n\n    const field = new FieldInputDescriptor<Model, NonNullable<Model[Property]>, Model[Property], Parent>(property as string);\n    if (descriptor instanceof TableviewDescriptorInst) {\n        descriptor.detailsEditor.addFieldDescriptor(field);\n        descriptor.editEditor.addFieldDescriptor(field);\n        descriptor.addEditor.addFieldDescriptor(field);\n    } else {\n        descriptor.addFieldDescriptor(field);\n    }\n\n    // Handle different property types\n    switch (propertyType as FieldInputType) {\n        case 'number':\n            field.asNumber();\n            break;\n        case 'currency':\n            field.asCurrency({\n                currency: opts?.currency,\n                currencyDisplay: opts?.currencyDisplay,\n                currencyProperty: opts?.currencyProperty\n            });\n            break;\n        case 'boolean':\n            field.asSwitch();\n            break;\n        case 'text':\n        case 'string':\n            field.asText();\n            break;\n        case 'textarea':\n            field.asTextarea();\n            break;\n        case 'date':\n            field.asDatePicker({format: opts?.dateFormat ? fromAngularDateFormatToPrime(opts.dateFormat) : undefined});\n            break;\n        case 'date-time':\n            field.asDatePicker({showTime: true, format: opts?.dateTimeFormat ? fromAngularDateFormatToPrime(opts.dateTimeFormat) : undefined});\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                field.asRadioFromEnum(enumModel);\n            } else {\n                field.asText();\n            }\n            break;\n        case 'hidden':\n            field.asHidden();\n            break;\n    }\n\n    // Handle different property validations\n    if (propertyType === 'number' || propertyType === 'currency') {\n        field.withNumberValidation({\n            min: propertySchema.exclusiveMinimum && propertySchema.minimum != undefined ? propertySchema.minimum + (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.minimum,\n            max: propertySchema.exclusiveMaximum && propertySchema.maximum != undefined ? propertySchema.maximum - (propertySchema.isInteger ? 1 : 0.0001) : propertySchema.maximum,\n            step: opts?.numberStep\n        });\n        if (opts?.numberUseGrouping) {\n            field.withNumberGrouping();\n        }\n        if (opts?.numberMinFractionDigits != null || opts?.numberMaxFractionDigits != null) {\n            field.withNumberFractions({\n                minFractionDigits: opts?.numberMinFractionDigits,\n                maxFractionDigits: opts?.numberMaxFractionDigits\n            });\n        }\n    }\n\n    if (propertyType === 'string' || propertyType === 'textarea' || propertyType === 'text') {\n        field.withTextValidation({\n            minLength: propertySchema.minLength,\n            maxLength: propertySchema.maxLength,\n            pattern: propertySchema.pattern ? new RegExp(propertySchema.pattern.slice(1, -1)) : undefined\n        });\n\n        if (propertyType === 'textarea' && opts?.textareaRows != null) {\n            field.withTextareaRows(opts.textareaRows);\n        }\n        if (propertyType !== 'textarea' && propertySchema.isEmail) {\n            field.withTextValidationEmail();\n        }\n    }\n\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Adds a field enum lookup to editor descriptor based on the given schema property and options.\n *\n * @experimental\n *\n * @param {TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>} descriptor - Descriptor to add field to.\n * @param {keyof Model} property - The property of the model.\n * @param {SchemaEnum<Enum> | EnumDescriptor<Enum>} enumOpt - The enum schema or enum model descriptor.\n * @param {SchemaProperty} propertySchema - The property's schema for the field.\n *\n * @returns {FieldLookupEnum<Enum>} - The field with enumeration values.\n */\nexport function addFieldEnumLookupFromSchema<Model, Parent = unknown, Enum = any>(\n    descriptor: TableviewDescriptorInst<Model, any, any, Parent> | EditorDescriptorInst<Model, Parent>,\n    property: keyof Model,\n    enumOpt: SchemaEnum<Enum> | EnumDescriptor<Enum>,\n    propertySchema: SchemaProperty\n) {\n    const enumDescriptor = enumOpt instanceof EnumDescriptor ? enumOpt : enumModelFromSchema(enumOpt);\n    const field = descriptor.addFieldLookupEnumUnsafe<Enum>(property as string, enumDescriptor);\n    setFieldBasicOptionsFromSchema(field, propertySchema);\n    return field;\n}\n\n/**\n * <em>Experimental:</em> Sets basic options for a field based on a given property schema.\n *\n * @param {AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>} field - The field to set options for.\n * @param {SchemaProperty} propertySchema - The property schema to base the options on.\n */\nexport function setFieldBasicOptionsFromSchema<FieldModel = any, EditorModel = any, FieldValue = FieldModel, ParentEditorModel = undefined>(\n    field: AFieldDescriptor<FieldModel, EditorModel, FieldValue, ParentEditorModel>,\n    propertySchema: SchemaProperty\n): void {\n    if (propertySchema.required) field.withRequired();\n    if (propertySchema.isReadOnly) field.withDisabled();\n}\n"]}

package/esm2022/tableview/schema/internal/common-from-schema.mjs

@@ -1,14 +1,7 @@
-export function fromSchemaCurrencyOptsToCurrency(opts) {
-    return {
-        currency: typeof opts === 'string' ? opts : opts.currency,
-        currencyDisplay: typeof opts === 'object' ? opts.currencyDisplay : undefined,
-        currencyProperty: typeof opts === 'object' ? opts.currencyProperty : undefined
-    };
-}
 export function fromSchemaFilterNonArrayProperties(propertySchemas) {
     return Object.keys(propertySchemas).filter(key => {
         const propertySchema = propertySchemas[key];
         return ['number', 'string', 'boolean', 'date', 'date-time', 'enum', 'object'].includes(propertySchema.type);
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tbW9uLWZyb20tc2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vdGFibGV2aWV3L3NyYy9zY2hlbWEvaW50ZXJuYWwvY29tbW9uLWZyb20tc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sVUFBVSxrQ0FBa0MsQ0FBUSxlQUF5QztJQUMvRixPQUFRLE1BQU0sQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFxQixDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsRUFBRTtRQUNsRSxNQUFNLGNBQWMsR0FBRyxlQUFlLENBQUMsR0FBRyxDQUFDLENBQUM7UUFDNUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxRQUFRLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxFQUFFLFFBQVEsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDaEgsQ0FBQyxDQUFDLENBQUM7QUFDUCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGZ1bmN0aW9uIGZyb21TY2hlbWFGaWx0ZXJOb25BcnJheVByb3BlcnRpZXM8TW9kZWw+KHByb3BlcnR5U2NoZW1hczogUmVjb3JkPGtleW9mIE1vZGVsLCBhbnk+KTogKGtleW9mIE1vZGVsKVtdIHtcbiAgICByZXR1cm4gKE9iamVjdC5rZXlzKHByb3BlcnR5U2NoZW1hcykgYXMgKGtleW9mIE1vZGVsKVtdKS5maWx0ZXIoa2V5ID0+IHtcbiAgICAgICAgY29uc3QgcHJvcGVydHlTY2hlbWEgPSBwcm9wZXJ0eVNjaGVtYXNba2V5XTtcbiAgICAgICAgcmV0dXJuIFsnbnVtYmVyJywgJ3N0cmluZycsICdib29sZWFuJywgJ2RhdGUnLCAnZGF0ZS10aW1lJywgJ2VudW0nLCAnb2JqZWN0J10uaW5jbHVkZXMocHJvcGVydHlTY2hlbWEudHlwZSk7XG4gICAgfSk7XG59XG4iXX0=