@antelopejs/interface-dms 0.9.1 → 0.10.1

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

@@ -15,12 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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 __importStar = (this && this.__importStar) || (function () {
     var ownKeys = function(o) {
         ownKeys = Object.getOwnPropertyNames || function (o) {
@@ -38,34 +32,29 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-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 = exports.BOOLEAN_DISPLAYS = exports.SELECT_DISPLAYS = 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/internal/value-parser");
-const type_check_1 = require("../../utils/internal/type-check");
-const attachments_1 = require("../../attachments");
-const form_schema_1 = require("../form-schema");
-// Import from the defining leaf, not the table-view barrel: the barrel pulls
-// in the assembled routes, whose composition runs at module evaluation — and
-// this module sits on the import path of the pieces being composed.
-// The cycle is what registers the default data types: they declare
-// themselves through decorators, and this barrel is the only value
-// path that evaluates them. Breaking it left the registry empty and
-// every column serialised without a type, silently. Safe because
-// neither side dereferences the other while it evaluates.
-// oxlint-disable-next-line import/no-cycle
-const meta_1 = require("../table-view/meta");
-const types_1 = require("../types");
-const core_1 = require("./core");
+require("@antelopejs/interface-core");
+require("@antelopejs/interface-data-api/metadata");
+require("@antelopejs/interface-file-storage");
+require("zod");
+require("../../utils/internal/value-parser");
+require("../../utils/internal/type-check");
+require("../../attachments");
+require("../form-schema");
+// oxlint-disable-next-line import/no-cycle -- Preserve the existing table metadata evaluation before built-in registration.
+require("../table-view/meta");
+require("../types");
+require("./core");
 const FieldTypes = __importStar(require("./field-types"));
-const compare_types_1 = require("./internal/compare-types");
-const compare_types_2 = require("./compare-types");
+require("./internal/compare-types");
+require("./compare-types");
+const defaultNumbers = __importStar(require("./default/numbers"));
+const defaultChoices = __importStar(require("./default/choices"));
+const defaultStrings = __importStar(require("./default/strings"));
+const defaultRelations = __importStar(require("./default/relations"));
+const defaultAddress = __importStar(require("./default/address"));
+const defaultFiles = __importStar(require("./default/files"));
 /** How a `SelectType` shows its options. */
 exports.SELECT_DISPLAYS = [
     "dropdown",
@@ -75,968 +64,27 @@ exports.SELECT_DISPLAYS = [
 ];
 /** How a `BooleanType` shows its value. */
 exports.BOOLEAN_DISPLAYS = ["switch", "checkbox", "card"];
-// Displays picking one value only: a select picking several shows cards.
-const SINGLE_PICK_DISPLAYS = new Set(["segmented", "radio"]);
-// The cards keep `columns` out of their options unless it is set, so a select
-// that does not set it serializes as before.
-function choiceCardsOptions({ items, multiple, columns, }) {
-    const options = { items, multiple };
-    if (columns !== undefined)
-        options.columns = columns;
-    return options;
-}
-// The input each display of a select renders.
-const SELECT_INPUTS = {
-    dropdown: ({ columns: _columns, ...options }) => form_schema_1.FormComponents.InputSelect(options),
-    cards: (options) => form_schema_1.FormComponents.InputChoiceCards(choiceCardsOptions(options)),
-    segmented: ({ items }) => form_schema_1.FormComponents.InputSegmentedSelect({ items }),
-    radio: ({ items }) => form_schema_1.FormComponents.InputRadioGroup({ items }),
-};
-// The input each display of a boolean renders.
-const BOOLEAN_INPUTS = {
-    switch: ({ label, description }) => form_schema_1.FormComponents.InputSwitch({ label, description }),
-    checkbox: ({ label, description }) => form_schema_1.FormComponents.InputCheckbox({ label, description }),
-    card: (options) => form_schema_1.FormComponents.InputBooleanCard(options),
-};
 var DefaultDataTypes;
 (function (DefaultDataTypes) {
-    let NumberType = class NumberType extends core_1.DataType {
-        options;
-        constructor(options = {}) {
-            super([
-                compare_types_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.GreaterThan,
-                compare_types_2.DefaultDataCompareTypes.GreaterThanOrEqualTo,
-                compare_types_2.DefaultDataCompareTypes.LessThan,
-                compare_types_2.DefaultDataCompareTypes.LessThanOrEqualTo,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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,
-                suffix: this.options.suffix,
-                width: this.options.width,
-            });
-        }
-        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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.Contains,
-                compare_types_2.DefaultDataCompareTypes.NotContains,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.DefaultDataCompareTypes.Contains, options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            if (this.options.copyable) {
-                return form_schema_1.FormComponents.InputCopyableText({
-                    placeholder: this.options.placeholder,
-                });
-            }
-            return this.editableInputComponent();
-        }
-        // A filter is typed in, even on a value the form only shows.
-        filterComponents() {
-            return { default: this.editableInputComponent() };
-        }
-        editableInputComponent() {
-            if (this.options.textarea) {
-                return form_schema_1.FormComponents.InputTextarea({
-                    placeholder: this.options.placeholder,
-                    maxLength: this.options.maxLength,
-                    rows: this.options.rows,
-                    showCount: this.options.showCount,
-                });
-            }
-            return form_schema_1.FormComponents.InputText({
-                placeholder: this.options.placeholder,
-                maxLength: this.options.maxLength,
-                minLength: this.options.minLength,
-                showCount: this.options.showCount,
-                width: this.options.width,
-            });
-        }
-        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;
-    /** Before or after an instant: `less_than` / `greater_than` on a date. */
-    const INSTANT_COMPARISONS = {
-        greater_than: (stored, instant) => stored.gt(instant),
-        less_than: (stored, instant) => stored.lt(instant),
-    };
-    /**
-     * Before or after a whole day, as `is` and `is_between` read a day:
-     * "greater than" starts at the next day, "less than" ends before it.
-     */
-    const DAY_COMPARISONS = {
-        greater_than: (stored, dayStart) => {
-            const nextDay = new Date(dayStart);
-            nextDay.setUTCDate(nextDay.getUTCDate() + 1);
-            return stored.ge(nextDay);
-        },
-        less_than: (stored, dayStart) => stored.lt(dayStart),
-    };
-    /** A calendar day as the date picker sends it, without a time. */
-    const CALENDAR_DAY = /^\d{4}-\d{2}-\d{2}$/;
-    let DateType = class DateType extends core_1.DataType {
-        options;
-        constructor(options = {}) {
-            super([
-                compare_types_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.LessThan,
-                compare_types_2.DefaultDataCompareTypes.GreaterThan,
-                compare_types_2.DefaultDataCompareTypes.IsBetween,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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,
-            });
-        }
-        // A published contract: the runtime calls this positionally and every
-        // implementing module declares the same shape, so an options object
-        // cannot be introduced from this side.
-        // oxlint-disable-next-line eslint/max-params
-        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 (0, compare_types_1.whenValueSet)(proxy, this.dayRangeFilter(proxy, value));
-            }
-            if (Object.hasOwn(INSTANT_COMPARISONS, mode)) {
-                return (0, compare_types_1.whenValueSet)(proxy, this.orderFilter(proxy, value, mode));
-            }
-            return super.filter(context, proxy, key, value, mode, row);
-        }
-        // A stored date is a date: comparing it with the instant's milliseconds,
-        // as the generic number comparison does, matches every row or none.
-        instant(value) {
-            const parsed = (0, value_parser_1.parseValue)(value);
-            if (!(parsed instanceof Date)) {
-                throw new Error(`Date filter expects a date value. Got: ${value}`);
-            }
-            return parsed;
-        }
-        // A picked day stands for the whole day; an instant (a `{{now-7d}}`
-        // token) is compared as it is.
-        orderFilter(stored, value, mode) {
-            const instant = this.instant(value);
-            if (CALENDAR_DAY.test(value.trim())) {
-                return DAY_COMPARISONS[mode](stored, this.startOfUtcDay(instant));
-            }
-            return INSTANT_COMPARISONS[mode](stored, instant);
-        }
-        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() {
-            if (this.options.range) {
-                // A range is `{ start, end }`, the date picker's shape; a pair of
-                // dates `[start, end]` is still read, and validates to the same
-                // object. Each date gets its own schema: one shared instance would
-                // serialize as a JSON Schema `$ref`, which the form rebuilds as
-                // "anything".
-                return zod_1.z
-                    .union([
-                    zod_1.z.tuple([this.singleDateValidation(), this.singleDateValidation()]),
-                    zod_1.z.object({
-                        start: this.singleDateValidation(),
-                        end: this.singleDateValidation(),
-                    }),
-                ])
-                    .transform((range) => Array.isArray(range) ? { start: range[0], end: range[1] } : range)
-                    .refine((range) => range.start <= range.end, {
-                    message: "The range must end on or after its start",
-                    path: ["end"],
-                });
-            }
-            if (this.options.multiple) {
-                return zod_1.z.array(this.singleDateValidation());
-            }
-            return this.singleDateValidation();
-        }
-        singleDateValidation() {
-            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()}`,
-                });
-            }
-            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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.DefaultDataCompareTypes.Is, options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            const { display = "switch", icon, label, description } = this.options;
-            return BOOLEAN_INPUTS[display]({ icon, label, description });
-        }
-        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_2.DefaultDataCompareTypes.Include
-                    : compare_types_2.DefaultDataCompareTypes.Is,
-                options.multiple
-                    ? compare_types_2.DefaultDataCompareTypes.Exclude
-                    : compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], options.multiple
-                ? compare_types_2.DefaultDataCompareTypes.Include
-                : compare_types_2.DefaultDataCompareTypes.Is, options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            const { display = "dropdown", ...options } = this.options;
-            const shown = options.multiple && SINGLE_PICK_DISPLAYS.has(display)
-                ? "cards"
-                : display;
-            return SELECT_INPUTS[shown](options);
-        }
-        // A filter picks from a dropdown, whatever the form shows.
-        filterComponents() {
-            const { display: _display, columns: _columns, ...options } = this.options;
-            return { default: form_schema_1.FormComponents.InputSelect(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,
-                width: this.options.width,
-            });
-        }
-    };
-    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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.Contains,
-                compare_types_2.DefaultDataCompareTypes.NotContains,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.DefaultDataCompareTypes.Is, options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            return form_schema_1.FormComponents.InputText({
-                placeholder: this.options.placeholder,
-                preview: this.options.preview,
-            });
-        }
-        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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.Contains,
-                compare_types_2.DefaultDataCompareTypes.NotContains,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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;
-    // A multiple relation stores an array of ids: `is` would compare the
-    // whole array, so it offers whether the array includes the picked id.
-    function relationCompareModes(multiple) {
-        return [
-            multiple ? compare_types_2.DefaultDataCompareTypes.Include : compare_types_2.DefaultDataCompareTypes.Is,
-            multiple
-                ? compare_types_2.DefaultDataCompareTypes.Exclude
-                : compare_types_2.DefaultDataCompareTypes.IsNot,
-            compare_types_2.DefaultDataCompareTypes.IsEmpty,
-            compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-        ];
-    }
-    function relationDefaultCompareMode(multiple) {
-        return multiple
-            ? compare_types_2.DefaultDataCompareTypes.Include
-            : compare_types_2.DefaultDataCompareTypes.Is;
-    }
-    let RelationType = class RelationType extends core_1.DataType {
-        options;
-        constructor(options) {
-            super(relationCompareModes(options.multiple), relationDefaultCompareMode(options.multiple), options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            return this.relationInput(true, this.options.multiple);
-        }
-        // A filter picks among the rows there are: it never adds one. A multiple
-        // relation is filtered on one id at a time (`include`).
-        filterComponents() {
-            return { default: this.relationInput(false, false) };
-        }
-        describedInputComponent() {
-            return this.relationInput(false, this.options.multiple);
-        }
-        // The picker, with the related table's "new" form when a row can be
-        // added through it: that form, nested relations included, is the bulk of
-        // the component, and only an editable field opens it.
-        relationInput(canAdd, multiple) {
-            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 = canAdd
-                ? this.buildAddOptions(tableViewMeta, endpoints)
-                : undefined;
-            return form_schema_1.FormComponents.InputRelation({
-                placeholder: this.options.placeholder,
-                multiple,
-                deselectable: this.options.deselectable,
-                searchUrl: location,
-                keyMapping: this.options.keyMapping,
-                filterBy: this.options.filterBy,
-                addForm: addOptions?.addForm,
-                addPermissionIds: addOptions?.addPermissionIds,
-                addFormTexts: this.options.addForm,
-            });
-        }
-        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,
-                kind: "create",
-            }).serializeSync();
-            return {
-                addForm,
-                addPermissionIds: tableViewMeta.actionPermissionIds("add"),
-            };
-        }
-        getValidation() {
-            return this.options.multiple ? zod_1.z.array(zod_1.z.string()) : zod_1.z.string();
-        }
-        // The search route drops a filter the related controller does not
-        // declare, so an unfilterable `field` would offer every row in silence.
-        assertFilterByFilterable(key) {
-            const field = this.options.filterBy?.field;
-            if (!field)
-                return;
-            const { filters } = (0, interface_core_1.GetMetadata)(this.options.dataApiController, metadata_1.DataAPIMeta);
-            if (filters[field])
-                return;
-            throw new Error(`Relation "${String(key)}": filterBy.field "${field}" is not filterable on ${this.options.dataApiController.name}; declare it filterable: true there.`);
-        }
-        decorateField(target, key, descriptor) {
-            this.assertFilterByFilterable(key);
-            // Filter-only relations never resolve the related row: skip the join so
-            // the raw scalar id stays in the `/list` output and the row id key is
-            // preserved. The funnel filter still works (relation picker +
-            // `@Filter` equality on the raw column). See {@link options.filterOnly}.
-            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;
-    /**
-     * Relation to a self-referencing table rendered as a cascader.
-     *
-     * The target controller exposes a flat list through its `select` endpoint
-     * (the `parent` field of `keyMapping` must be decorated with `@Select()`);
-     * the widget rebuilds the tree client-side and displays the full path
-     * (e.g. `Electronics / Audio / Headphones`) in table cells.
-     */
-    let CascaderRelationType = class CascaderRelationType extends core_1.DataType {
-        options;
-        constructor(options) {
-            super(relationCompareModes(options.multiple), relationDefaultCompareMode(options.multiple), options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            return this.cascaderInput(this.options.multiple);
-        }
-        // A multiple relation is filtered on one id at a time (`include`).
-        filterComponents() {
-            return { default: this.cascaderInput(false) };
-        }
-        cascaderInput(multiple) {
-            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,
-                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) {
-            // See RelationType.decorateField: a filter-only relation skips the join.
-            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_2.DefaultDataCompareTypes.IsEmpty, compare_types_2.DefaultDataCompareTypes.IsNotEmpty], compare_types_2.DefaultDataCompareTypes.IsEmpty, options);
-            this.options = options;
-        }
-        defaultInputComponent() {
-            const baseConfig = {
-                placeholder: this.options.placeholder,
-                autocomplete: this.options.autocomplete,
-                defaultCountry: this.options.defaultCountry,
-            };
-            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 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_2.DefaultDataCompareTypes.Is,
-                compare_types_2.DefaultDataCompareTypes.IsNot,
-                compare_types_2.DefaultDataCompareTypes.GreaterThan,
-                compare_types_2.DefaultDataCompareTypes.GreaterThanOrEqualTo,
-                compare_types_2.DefaultDataCompareTypes.LessThan,
-                compare_types_2.DefaultDataCompareTypes.LessThanOrEqualTo,
-                compare_types_2.DefaultDataCompareTypes.IsEmpty,
-                compare_types_2.DefaultDataCompareTypes.IsNotEmpty,
-            ], compare_types_2.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;
-    /**
-     * A missing referenced file is a validation failure (the submitted key does
-     * not point at a real upload); any other metadata error (storage outage,
-     * auth) keeps propagating so it surfaces as a server error, not as a bogus
-     * "invalid input" on the field.
-     */
-    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;
-            // An empty value is the absence of a file, not a reference to check;
-            // whether the field may be empty is the schema's business.
-            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;
-            });
-            // `undefined` comes from the attachment lookup: the key belongs to no
-            // prepared attachment, so it is an invalid reference. `null` means the
-            // object itself is gone, which an attachment-backed field survives:
-            // the attachment row proves provenance and the save replays the
-            // promotion of a staged key.
-            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;
-    // The field types of `field-types.ts`, under the namespace modules use.
+    DefaultDataTypes.NumberType = defaultNumbers.NumberType;
+    DefaultDataTypes.StringType = defaultNumbers.StringType;
+    DefaultDataTypes.DateType = defaultNumbers.DateType;
+    DefaultDataTypes.BooleanType = defaultChoices.BooleanType;
+    DefaultDataTypes.SelectType = defaultChoices.SelectType;
+    DefaultDataTypes.PriceType = defaultChoices.PriceType;
+    DefaultDataTypes.PercentageType = defaultChoices.PercentageType;
+    DefaultDataTypes.EmailType = defaultStrings.EmailType;
+    DefaultDataTypes.ColorType = defaultStrings.ColorType;
+    DefaultDataTypes.PasswordType = defaultStrings.PasswordType;
+    DefaultDataTypes.UrlType = defaultStrings.UrlType;
+    DefaultDataTypes.PhoneType = defaultStrings.PhoneType;
+    DefaultDataTypes.RelationType = defaultRelations.RelationType;
+    DefaultDataTypes.CascaderRelationType = defaultRelations.CascaderRelationType;
+    DefaultDataTypes.AddressType = defaultAddress.AddressType;
+    DefaultDataTypes.RichTextType = defaultFiles.RichTextType;
+    DefaultDataTypes.StringTimeType = defaultFiles.StringTimeType;
+    DefaultDataTypes.FileType = defaultFiles.FileType;
+    DefaultDataTypes.ImageType = defaultFiles.ImageType;
     DefaultDataTypes.ArrayType = FieldTypes.ArrayType;
     DefaultDataTypes.KeyValueType = FieldTypes.KeyValueType;
     DefaultDataTypes.SecretType = FieldTypes.SecretType;