@antelopejs/interface-dms 0.0.1

package/dist/base/data-types/default-types.js

@@ -0,0 +1,842 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultDataTypes = void 0;
+const interface_core_1 = require("@antelopejs/interface-core");
+const metadata_1 = require("@antelopejs/interface-data-api/metadata");
+const interface_file_storage_1 = require("@antelopejs/interface-file-storage");
+const zod_1 = require("zod");
+const value_parser_1 = require("../../utils/value-parser");
+const type_check_1 = require("../../utils/type-check");
+const attachments_1 = require("../../attachments");
+const form_schema_1 = require("../form-schema");
+const meta_1 = require("../table-view/meta");
+const types_1 = require("../types");
+const core_1 = require("./core");
+const compare_types_1 = require("./compare-types");
+var DefaultDataTypes;
+(function (DefaultDataTypes) {
+    let NumberType = class NumberType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.GreaterThan,
+                compare_types_1.DefaultDataCompareTypes.GreaterThanOrEqualTo,
+                compare_types_1.DefaultDataCompareTypes.LessThan,
+                compare_types_1.DefaultDataCompareTypes.LessThanOrEqualTo,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputNumber({
+                min: this.options.min,
+                max: this.options.max,
+                step: this.options.step,
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            let schema = zod_1.z.number();
+            if (this.options.min !== undefined) {
+                schema = schema.min(this.options.min);
+            }
+            if (this.options.max !== undefined) {
+                schema = schema.max(this.options.max);
+            }
+            return schema;
+        }
+    };
+    NumberType = __decorate([
+        (0, core_1.RegisterDataType)("number"),
+        __metadata("design:paramtypes", [Object])
+    ], NumberType);
+    DefaultDataTypes.NumberType = NumberType;
+    let StringType = class StringType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.Contains,
+                compare_types_1.DefaultDataCompareTypes.NotContains,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Contains, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            if (this.options.textarea) {
+                return form_schema_1.FormComponents.InputTextarea({
+                    placeholder: this.options.placeholder,
+                    maxLength: this.options.maxLength,
+                    rows: this.options.rows,
+                });
+            }
+            return form_schema_1.FormComponents.InputText({
+                placeholder: this.options.placeholder,
+                maxLength: this.options.maxLength,
+                minLength: this.options.minLength,
+            });
+        }
+        getValidation() {
+            let schema = zod_1.z.string();
+            if (this.options.minLength !== undefined) {
+                schema = schema.min(this.options.minLength);
+            }
+            if (this.options.maxLength !== undefined) {
+                schema = schema.max(this.options.maxLength);
+            }
+            return schema;
+        }
+    };
+    StringType = __decorate([
+        (0, core_1.RegisterDataType)("string"),
+        __metadata("design:paramtypes", [Object])
+    ], StringType);
+    DefaultDataTypes.StringType = StringType;
+    let DateType = class DateType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.LessThan,
+                compare_types_1.DefaultDataCompareTypes.GreaterThan,
+                compare_types_1.DefaultDataCompareTypes.IsBetween,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.DatePicker({
+                range: this.options.range,
+                multiple: this.options.multiple,
+                minDate: this.options.minDate,
+                maxDate: this.options.maxDate,
+            });
+        }
+        filter(context, proxy, key, value, mode, row) {
+            if (mode === "is" || mode === "is_not") {
+                return this.sameDayFilter(proxy, value, mode === "is_not");
+            }
+            if (mode === "is_between") {
+                return this.dayRangeFilter(proxy, value);
+            }
+            return super.filter(context, proxy, key, value, mode, row);
+        }
+        startOfUtcDay(date) {
+            const result = new Date(date);
+            result.setUTCHours(0, 0, 0, 0);
+            return result;
+        }
+        nextUtcDay(date) {
+            const result = this.startOfUtcDay(date);
+            result.setUTCDate(result.getUTCDate() + 1);
+            return result;
+        }
+        sameDayFilter(proxy, value, negate) {
+            const parsed = (0, value_parser_1.parseValue)(value);
+            if (!(parsed instanceof Date)) {
+                throw new Error(`Date filter expects a date value. Got: ${typeof parsed}`);
+            }
+            const dayStart = this.startOfUtcDay(parsed);
+            const dayEnd = this.nextUtcDay(parsed);
+            const dbVal = proxy;
+            const matchesDay = dbVal.ge(dayStart).and(dbVal.lt(dayEnd));
+            return negate ? matchesDay.not() : matchesDay;
+        }
+        dayRangeFilter(proxy, value) {
+            const [rawStart, rawEnd] = value
+                .split(",")
+                .map((v) => (0, value_parser_1.parseValue)(v.trim()));
+            if (!(rawStart instanceof Date) || !(rawEnd instanceof Date)) {
+                throw new Error(`Date is_between filter expects two date values. Got: ${value}`);
+            }
+            const rangeStart = this.startOfUtcDay(rawStart);
+            const rangeEnd = this.nextUtcDay(rawEnd);
+            const dbVal = proxy;
+            return dbVal.ge(rangeStart).and(dbVal.lt(rangeEnd));
+        }
+        filterComponents() {
+            const datepicker = form_schema_1.FormComponents.DatePicker({
+                range: this.options.range,
+                multiple: this.options.multiple,
+                minDate: this.options.minDate,
+                maxDate: this.options.maxDate,
+            });
+            return {
+                default: datepicker,
+                is_between: form_schema_1.FormComponents.DatePickerRange({
+                    minDate: this.options.minDate,
+                    maxDate: this.options.maxDate,
+                }),
+            };
+        }
+        getValidation() {
+            let singleDateSchema = zod_1.z
+                .union([
+                zod_1.z
+                    .string()
+                    .regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?)?$/),
+                zod_1.z.date(),
+            ])
+                .transform((val) => {
+                return (0, type_check_1.isString)(val) ? new Date(val) : val;
+            });
+            if (this.options.minDate) {
+                const minDate = new Date(this.options.minDate);
+                singleDateSchema = singleDateSchema.refine((date) => date >= minDate, {
+                    message: `Date must be after ${minDate.toISOString()}`,
+                });
+            }
+            if (this.options.maxDate) {
+                const maxDate = new Date(this.options.maxDate);
+                singleDateSchema = singleDateSchema.refine((date) => date <= maxDate, {
+                    message: `Date must be before ${maxDate.toISOString()}`,
+                });
+            }
+            if (this.options.range || this.options.multiple) {
+                return zod_1.z.array(singleDateSchema);
+            }
+            return singleDateSchema;
+        }
+    };
+    DateType = __decorate([
+        (0, core_1.RegisterDataType)("date"),
+        __metadata("design:paramtypes", [Object])
+    ], DateType);
+    DefaultDataTypes.DateType = DateType;
+    let BooleanType = class BooleanType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputSwitch();
+        }
+        filterComponents() {
+            const selectOptions = form_schema_1.FormComponents.InputSelect({
+                items: [
+                    { value: "true", label: "$dms.table.filter.boolean.checked" },
+                    { value: "false", label: "$dms.table.filter.boolean.unchecked" },
+                ],
+            });
+            return {
+                default: selectOptions,
+                is: selectOptions,
+                is_not: selectOptions,
+            };
+        }
+        getValidation() {
+            return zod_1.z.boolean();
+        }
+    };
+    BooleanType = __decorate([
+        (0, core_1.RegisterDataType)("boolean"),
+        __metadata("design:paramtypes", [Object])
+    ], BooleanType);
+    DefaultDataTypes.BooleanType = BooleanType;
+    let SelectType = class SelectType extends core_1.DataType {
+        options;
+        constructor(options = { items: [] }) {
+            super([
+                options.multiple
+                    ? compare_types_1.DefaultDataCompareTypes.Include
+                    : compare_types_1.DefaultDataCompareTypes.Is,
+                options.multiple
+                    ? compare_types_1.DefaultDataCompareTypes.Exclude
+                    : compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], options.multiple
+                ? compare_types_1.DefaultDataCompareTypes.Include
+                : compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputSelect(this.options);
+        }
+        getValidation() {
+            const validValues = this.options.items.map((item) => String(item.value));
+            if (this.options.multiple) {
+                return zod_1.z.array(zod_1.z.enum(validValues));
+            }
+            return zod_1.z.enum(validValues);
+        }
+    };
+    SelectType = __decorate([
+        (0, core_1.RegisterDataType)("select"),
+        __metadata("design:paramtypes", [Object])
+    ], SelectType);
+    DefaultDataTypes.SelectType = SelectType;
+    let PriceType = class PriceType extends NumberType {
+        constructor(options = {}) {
+            super({
+                min: options.min ?? 0,
+                step: options.step ?? 0.01,
+                ...options,
+            });
+        }
+    };
+    PriceType = __decorate([
+        (0, core_1.RegisterDataType)("price"),
+        __metadata("design:paramtypes", [Object])
+    ], PriceType);
+    DefaultDataTypes.PriceType = PriceType;
+    let PercentageType = class PercentageType extends NumberType {
+        constructor(options = {}) {
+            super({
+                min: options.min ?? 0,
+                max: options.max ?? 1,
+                step: options.step ?? 0.01,
+                ...options,
+            });
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputPercentage({
+                min: (this.options.min ?? 0) * 100,
+                max: (this.options.max ?? 1) * 100,
+                step: this.options.step,
+                placeholder: this.options.placeholder,
+            });
+        }
+    };
+    PercentageType = __decorate([
+        (0, core_1.RegisterDataType)("percentage"),
+        __metadata("design:paramtypes", [Object])
+    ], PercentageType);
+    DefaultDataTypes.PercentageType = PercentageType;
+    let EmailType = class EmailType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.Contains,
+                compare_types_1.DefaultDataCompareTypes.NotContains,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Contains, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputEmail({
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            return zod_1.z.string().email();
+        }
+    };
+    EmailType = __decorate([
+        (0, core_1.RegisterDataType)("email"),
+        __metadata("design:paramtypes", [Object])
+    ], EmailType);
+    DefaultDataTypes.EmailType = EmailType;
+    let ColorType = class ColorType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputColor({
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            return zod_1.z.string().regex(/^#[0-9a-fA-F]{6}$/);
+        }
+    };
+    ColorType = __decorate([
+        (0, core_1.RegisterDataType)("color"),
+        __metadata("design:paramtypes", [Object])
+    ], ColorType);
+    DefaultDataTypes.ColorType = ColorType;
+    let PasswordType = class PasswordType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([], undefined, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputPassword({
+                placeholder: this.options.placeholder,
+                minLength: this.options.minLength,
+                confirmPassword: this.options.confirmPassword,
+                confirmPlaceholder: this.options.confirmPlaceholder,
+            });
+        }
+        getValidation() {
+            let schema = zod_1.z.string();
+            if (this.options.minLength !== undefined) {
+                schema = schema.min(this.options.minLength);
+            }
+            return schema;
+        }
+    };
+    PasswordType = __decorate([
+        (0, core_1.RegisterDataType)("password"),
+        __metadata("design:paramtypes", [Object])
+    ], PasswordType);
+    DefaultDataTypes.PasswordType = PasswordType;
+    let UrlType = class UrlType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputText({
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            return zod_1.z.string().url();
+        }
+    };
+    UrlType = __decorate([
+        (0, core_1.RegisterDataType)("url"),
+        __metadata("design:paramtypes", [Object])
+    ], UrlType);
+    DefaultDataTypes.UrlType = UrlType;
+    let PhoneType = class PhoneType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.Contains,
+                compare_types_1.DefaultDataCompareTypes.NotContains,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Contains, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputPhone({
+                placeholder: this.options.placeholder,
+                requiredPrefix: this.options.requiredPrefix,
+            });
+        }
+        getValidation() {
+            if (this.options.requiredPrefix) {
+                return zod_1.z.string().regex(/^\+[1-9]\d{1,14}$/);
+            }
+            return zod_1.z.string();
+        }
+    };
+    PhoneType = __decorate([
+        (0, core_1.RegisterDataType)("phone"),
+        __metadata("design:paramtypes", [Object])
+    ], PhoneType);
+    DefaultDataTypes.PhoneType = PhoneType;
+    let TreeType = class TreeType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([compare_types_1.DefaultDataCompareTypes.Include, compare_types_1.DefaultDataCompareTypes.Exclude], compare_types_1.DefaultDataCompareTypes.Include, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputTree({
+                items: this.options.items || [],
+                fetchUrl: this.options.fetchUrl,
+                multiple: this.options.multiple,
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            if (this.options.multiple) {
+                return zod_1.z.array(zod_1.z.string());
+            }
+            return zod_1.z.string();
+        }
+    };
+    TreeType = __decorate([
+        (0, core_1.RegisterDataType)("tree"),
+        __metadata("design:paramtypes", [Object])
+    ], TreeType);
+    DefaultDataTypes.TreeType = TreeType;
+    let RelationType = class RelationType extends core_1.DataType {
+        options;
+        constructor(options) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            const tableViewMeta = (0, interface_core_1.GetMetadata)(this.options.dataApiController, meta_1.TableViewMeta);
+            const { config } = tableViewMeta;
+            const { endpoints } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
+            const location = `${config.location}/${endpoints.select.endpoint || "select"}`;
+            const addOptions = this.buildAddOptions(tableViewMeta, endpoints);
+            return form_schema_1.FormComponents.InputRelation({
+                placeholder: this.options.placeholder,
+                multiple: this.options.multiple,
+                deselectable: this.options.deselectable,
+                searchUrl: location,
+                keyMapping: this.options.keyMapping,
+                addForm: addOptions?.addForm,
+                addPermissionId: addOptions?.addPermissionId,
+            });
+        }
+        buildAddOptions(tableViewMeta, endpoints) {
+            if (!endpoints.new)
+                return undefined;
+            const newFields = tableViewMeta.getFormFields("new");
+            if (newFields.length === 0)
+                return undefined;
+            const submitUrl = `${tableViewMeta.config.location}/new`;
+            const addForm = (0, form_schema_1.Form)({
+                fields: newFields,
+                submitUrl,
+                submitUrlMethod: types_1.HttpMethod.post,
+            }).serializeSync();
+            return {
+                addForm,
+                addPermissionId: tableViewMeta.componentBuilder?.getAction("add")?.permissionId,
+            };
+        }
+        getValidation() {
+            return this.options.multiple ? zod_1.z.array(zod_1.z.string()) : zod_1.z.string();
+        }
+        decorateField(target, key, descriptor) {
+            if (this.options.filterOnly) {
+                return;
+            }
+            const meta = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
+            (0, compare_types_1.absolutizeJoinedSchemas)(meta);
+            const { tableName, pluck } = meta;
+            (0, metadata_1.Foreign)(tableName, this.options.index, this.options.multiple, Array.from(pluck.select?.keys() || []), meta.schemaName, meta)(target, key, descriptor ?? {});
+        }
+    };
+    RelationType = __decorate([
+        (0, core_1.RegisterDataType)("relation"),
+        __metadata("design:paramtypes", [Object])
+    ], RelationType);
+    DefaultDataTypes.RelationType = RelationType;
+    let CascaderRelationType = class CascaderRelationType extends core_1.DataType {
+        options;
+        constructor(options) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            const { config } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, meta_1.TableViewMeta);
+            const { endpoints } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
+            return form_schema_1.FormComponents.InputCascader({
+                placeholder: this.options.placeholder,
+                multiple: this.options.multiple,
+                deselectable: this.options.deselectable,
+                searchUrl: `${config.location}/${endpoints.select.endpoint || "select"}`,
+                keyMapping: this.options.keyMapping,
+                maxDepth: this.options.maxDepth,
+                leafOnly: this.options.leafOnly,
+                fallback: this.options.fallback,
+            });
+        }
+        getValidation() {
+            return this.options.multiple ? zod_1.z.array(zod_1.z.string()) : zod_1.z.string();
+        }
+        decorateField(target, key, descriptor) {
+            if (this.options.filterOnly) {
+                return;
+            }
+            const meta = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
+            (0, compare_types_1.absolutizeJoinedSchemas)(meta);
+            const { tableName, pluck } = meta;
+            (0, metadata_1.Foreign)(tableName, this.options.index, this.options.multiple, Array.from(pluck.select?.keys() || []), meta.schemaName, meta)(target, key, descriptor ?? {});
+        }
+    };
+    CascaderRelationType = __decorate([
+        (0, core_1.RegisterDataType)("cascader_relation"),
+        __metadata("design:paramtypes", [Object])
+    ], CascaderRelationType);
+    DefaultDataTypes.CascaderRelationType = CascaderRelationType;
+    let AddressType = class AddressType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([compare_types_1.DefaultDataCompareTypes.IsEmpty, compare_types_1.DefaultDataCompareTypes.IsNotEmpty], compare_types_1.DefaultDataCompareTypes.IsEmpty, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            const baseConfig = {
+                placeholder: this.options.placeholder,
+                autocomplete: this.options.autocomplete,
+            };
+            if (!this.options.dataApiController) {
+                return form_schema_1.FormComponents.InputAddress(baseConfig);
+            }
+            const { config } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, meta_1.TableViewMeta);
+            const { endpoints } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
+            const location = `${config.location}/${endpoints.select.endpoint || "select"}`;
+            return form_schema_1.FormComponents.InputAddress({
+                ...baseConfig,
+                searchUrl: location,
+                keyMapping: this.options.keyMapping,
+            });
+        }
+        getValidation() {
+            return zod_1.z.object({
+                streetName: zod_1.z.string().min(1),
+                houseNumber: zod_1.z.string().optional(),
+                boxNumber: zod_1.z.string().optional(),
+                addressLine2: zod_1.z.string().optional(),
+                postalCode: zod_1.z.string().min(1),
+                city: zod_1.z.string().min(1),
+                countrySubdivision: zod_1.z.string().optional(),
+                countryCode: zod_1.z.string().length(2),
+            });
+        }
+    };
+    AddressType = __decorate([
+        (0, core_1.RegisterDataType)("address"),
+        __metadata("design:paramtypes", [Object])
+    ], AddressType);
+    DefaultDataTypes.AddressType = AddressType;
+    let PermissionsType = class PermissionsType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([compare_types_1.DefaultDataCompareTypes.Include, compare_types_1.DefaultDataCompareTypes.Exclude], compare_types_1.DefaultDataCompareTypes.Include, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.PermissionsTree({
+                fetchUrl: this.options.fetchUrl,
+            });
+        }
+        getValidation() {
+            return zod_1.z.array(zod_1.z.string());
+        }
+    };
+    PermissionsType = __decorate([
+        (0, core_1.RegisterDataType)("permissions"),
+        __metadata("design:paramtypes", [Object])
+    ], PermissionsType);
+    DefaultDataTypes.PermissionsType = PermissionsType;
+    let RichTextType = class RichTextType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([], undefined, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.RichText({
+                placeholder: this.options.placeholder,
+            });
+        }
+        getValidation() {
+            return zod_1.z.string();
+        }
+    };
+    RichTextType = __decorate([
+        (0, core_1.RegisterDataType)("rich_text"),
+        __metadata("design:paramtypes", [Object])
+    ], RichTextType);
+    DefaultDataTypes.RichTextType = RichTextType;
+    let StringTimeType = class StringTimeType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([
+                compare_types_1.DefaultDataCompareTypes.Is,
+                compare_types_1.DefaultDataCompareTypes.IsNot,
+                compare_types_1.DefaultDataCompareTypes.GreaterThan,
+                compare_types_1.DefaultDataCompareTypes.GreaterThanOrEqualTo,
+                compare_types_1.DefaultDataCompareTypes.LessThan,
+                compare_types_1.DefaultDataCompareTypes.LessThanOrEqualTo,
+                compare_types_1.DefaultDataCompareTypes.IsEmpty,
+                compare_types_1.DefaultDataCompareTypes.IsNotEmpty,
+            ], compare_types_1.DefaultDataCompareTypes.Is, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.InputTime({
+                placeholder: this.options.placeholder,
+                min: this.options.min,
+                max: this.options.max,
+            });
+        }
+        getValidation() {
+            let schema = zod_1.z.number();
+            if (this.options.min !== undefined) {
+                schema = schema.min(this.options.min);
+            }
+            if (this.options.max !== undefined) {
+                schema = schema.max(this.options.max);
+            }
+            return schema;
+        }
+    };
+    StringTimeType = __decorate([
+        (0, core_1.RegisterDataType)("string_time"),
+        __metadata("design:paramtypes", [Object])
+    ], StringTimeType);
+    DefaultDataTypes.StringTimeType = StringTimeType;
+    function matchMimetype(actual, pattern) {
+        if (pattern === actual)
+            return true;
+        if (pattern.endsWith("/*")) {
+            const prefix = pattern.slice(0, -1);
+            return actual.startsWith(prefix);
+        }
+        return false;
+    }
+    const MISSING_FILE_ERROR_PATTERN = /not\s?found|nosuchkey/i;
+    function isMissingFileError(error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return MISSING_FILE_ERROR_PATTERN.test(message);
+    }
+    function createFileValidationSchema(constraints, storage, attachmentField) {
+        return zod_1.z.string().refine(async (resourceKey) => {
+            if (!constraints && !attachmentField)
+                return true;
+            if (!resourceKey)
+                return true;
+            const getMetadata = attachmentField
+                ? attachments_1.GetAttachmentValidationMetadata
+                : interface_file_storage_1.GetFileMetadata;
+            const metadata = await getMetadata(resourceKey, storage).catch((error) => {
+                if (isMissingFileError(error))
+                    return null;
+                throw error;
+            });
+            if (metadata === null) {
+                return attachmentField !== undefined;
+            }
+            if (!metadata) {
+                return false;
+            }
+            if (constraints?.maxSize && metadata.size > constraints.maxSize) {
+                return false;
+            }
+            if (constraints?.allowedMimetypes?.length) {
+                const isAllowed = constraints.allowedMimetypes.some((pattern) => matchMimetype(metadata.mimetype, pattern));
+                if (!isAllowed)
+                    return false;
+            }
+            return true;
+        }, { message: "File does not meet constraints" });
+    }
+    let FileType = class FileType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([], undefined, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.File({
+                multiple: this.options.multiple,
+                constraints: this.options.constraints,
+                path: this.options.path,
+                storage: this.options.storage,
+                attachmentField: this.options.attachmentField,
+                visibility: this.options.visibility,
+            });
+        }
+        getValidation() {
+            const fileSchema = zod_1.z.lazy(() => createFileValidationSchema(this.options.constraints, this.options.storage, this.options.attachmentField));
+            if (this.options.multiple) {
+                return zod_1.z.array(fileSchema);
+            }
+            return fileSchema;
+        }
+    };
+    FileType = __decorate([
+        (0, core_1.RegisterDataType)("file"),
+        __metadata("design:paramtypes", [Object])
+    ], FileType);
+    DefaultDataTypes.FileType = FileType;
+    const DEFAULT_IMAGE_MIMETYPES = ["image/*"];
+    function resolveImageConstraints(constraints) {
+        return {
+            ...constraints,
+            allowedMimetypes: constraints?.allowedMimetypes?.length
+                ? constraints.allowedMimetypes
+                : DEFAULT_IMAGE_MIMETYPES,
+        };
+    }
+    function createImageValueSchema(constraints, storage, attachmentField) {
+        return zod_1.z.object({
+            key: createFileValidationSchema(constraints, storage, attachmentField),
+            alt: zod_1.z.string().optional(),
+            principal: zod_1.z.boolean().optional(),
+        });
+    }
+    function hasAtMostOnePrincipal(images) {
+        return images.filter((image) => image.principal).length <= 1;
+    }
+    let ImageType = class ImageType extends core_1.DataType {
+        options;
+        constructor(options = {}) {
+            super([], undefined, options);
+            this.options = options;
+        }
+        defaultInputComponent() {
+            return form_schema_1.FormComponents.Image({
+                multiple: this.options.multiple,
+                max: this.options.max,
+                constraints: resolveImageConstraints(this.options.constraints),
+                path: this.options.path,
+                storage: this.options.storage,
+                resize: this.options.resize,
+                attachmentField: this.options.attachmentField,
+                visibility: this.options.visibility,
+            });
+        }
+        getValidation() {
+            const imageSchema = zod_1.z.lazy(() => createImageValueSchema(resolveImageConstraints(this.options.constraints), this.options.storage, this.options.attachmentField));
+            if (!this.options.multiple) {
+                return imageSchema;
+            }
+            const arraySchema = this.options.max !== undefined
+                ? zod_1.z.array(imageSchema).max(this.options.max)
+                : zod_1.z.array(imageSchema);
+            return arraySchema.refine(hasAtMostOnePrincipal, {
+                message: "Only one image can be marked as principal",
+            });
+        }
+    };
+    ImageType = __decorate([
+        (0, core_1.RegisterDataType)("image"),
+        __metadata("design:paramtypes", [Object])
+    ], ImageType);
+    DefaultDataTypes.ImageType = ImageType;
+})(DefaultDataTypes || (exports.DefaultDataTypes = DefaultDataTypes = {}));
+//# sourceMappingURL=default-types.js.map