@strictly/react-form 0.0.11 → 0.0.12

package/index.ts

@@ -3,7 +3,7 @@ export * from './core/mobx/field_adapter_builder'
 export * from './core/mobx/field_adapters_of_values'
 export * from './core/mobx/flattened_adapters_of_fields'
 export * from './core/mobx/form_fields_of_field_adapters'
-export * from './core/mobx/form_presenter'
+export * from './core/mobx/form_model'
 export * from './core/mobx/hooks'
 export * from './core/mobx/merge_field_adapters_with_two_way_converter'
 export * from './core/mobx/merge_field_adapters_with_validators'

package/mantine/hooks.tsx

@@ -431,4 +431,6 @@ class MantineFormImpl<
       this,
     ) as unknown as MantineFieldComponent<FormProps<ValueTypeOfField<F[K]>>, P, never>
   }
+
+  // TODO have an option to bind to a Text/(value: T) => JSX.Element for viewing form fields
 }

package/package.json

@@ -70,7 +70,7 @@
     "test:watch": "vitest"
   },
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "exports": {
     ".": {
       "import": {

package/.out/core/mobx/form_presenter.js

@@ -1,525 +0,0 @@
-var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
-    var useValue = arguments.length > 2;
-    for (var i = 0; i < initializers.length; i++) {
-        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-    }
-    return useValue ? value : void 0;
-};
-var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-    var _, done = false;
-    for (var i = decorators.length - 1; i >= 0; i--) {
-        var context = {};
-        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-        if (kind === "accessor") {
-            if (result === void 0) continue;
-            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-            if (_ = accept(result.get)) descriptor.get = _;
-            if (_ = accept(result.set)) descriptor.set = _;
-            if (_ = accept(result.init)) initializers.unshift(_);
-        }
-        else if (_ = accept(result)) {
-            if (kind === "field") initializers.unshift(_);
-            else descriptor[key] = _;
-        }
-    }
-    if (target) Object.defineProperty(target, contextIn.name, descriptor);
-    done = true;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-import { assertExists, assertExistsAndReturn, assertState, checkValidNumber, map, toArray, UnreachableError, } from '@strictly/base';
-import { flattenAccessorsOfType, flattenTypesOfType, flattenValuesOfType, flattenValueTo, jsonPathPop, mobxCopy, valuePathToTypePath, } from '@strictly/define';
-import { computed, observable, runInAction, } from 'mobx';
-import { UnreliableFieldConversionType, } from 'types/field_converters';
-export class FormPresenter {
-    constructor(type, adapters) {
-        Object.defineProperty(this, "type", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: type
-        });
-        Object.defineProperty(this, "adapters", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: adapters
-        });
-    }
-    maybeGetAdapterForValuePath(valuePath) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const typePath = valuePathToTypePath(this.type, valuePath, true);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return this.adapters[typePath];
-    }
-    getAdapterForValuePath(valuePath) {
-        return assertExistsAndReturn(this.maybeGetAdapterForValuePath(valuePath), 'expected adapter to be defined {}', valuePath);
-    }
-    typePath(valuePath) {
-        return valuePathToTypePath(this.type, valuePath, true);
-    }
-    setFieldValueAndValidate(model, valuePath, value) {
-        return this.internalSetFieldValue(model, valuePath, value, true);
-    }
-    setFieldValue(model, valuePath, value) {
-        return this.internalSetFieldValue(model, valuePath, value, false);
-    }
-    addListItem(model, valuePath, 
-    // TODO can this type be simplified?
-    elementValue = null, index) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const listValuePath = valuePath;
-        const accessor = model.accessors[valuePath];
-        const listTypePath = this.typePath(valuePath);
-        const definedIndex = index !== null && index !== void 0 ? index : accessor.value.length;
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const elementTypePath = `${listTypePath}.*`;
-        const elementAdapter = assertExistsAndReturn(this.adapters[elementTypePath], 'no adapter specified for list {} ({})', elementTypePath, valuePath);
-        // TODO validation on new elements
-        const element = elementValue != null
-            ? elementValue[0]
-            : elementAdapter.create(
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            elementTypePath, model.value);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const originalList = accessor.value;
-        const newList = [
-            ...originalList.slice(0, definedIndex),
-            element,
-            ...originalList.slice(definedIndex),
-        ];
-        // shuffle the overrides around to account for new indices
-        // to so this we need to sort the array indices in descending order
-        const targetPaths = Object.keys(model.fieldOverrides).filter(function (v) {
-            return v.startsWith(`${listValuePath}.`);
-        }).map(function (v) {
-            const parts = v.substring(listValuePath.length + 1).split('.');
-            const index = parseInt(parts[0]);
-            return [
-                index,
-                parts.slice(1),
-            ];
-        }).filter(function ([index]) {
-            return index >= definedIndex;
-        }).sort(function ([a], [b]) {
-            // descending
-            return b - a;
-        });
-        runInAction(function () {
-            targetPaths.forEach(function ([index, postfix,]) {
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const fromJsonPath = [
-                    listValuePath,
-                    `${index}`,
-                    ...postfix,
-                ].join('.');
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const toJsonPath = [
-                    listValuePath,
-                    `${index + 1}`,
-                    ...postfix,
-                ].join('.');
-                const fieldOverride = model.fieldOverrides[fromJsonPath];
-                delete model.fieldOverrides[fromJsonPath];
-                model.fieldOverrides[toJsonPath] = fieldOverride;
-                const error = model.errors[fromJsonPath];
-                delete model.errors[fromJsonPath];
-                model.errors[toJsonPath] = error;
-            });
-            accessor.set(newList);
-            // delete any value overrides so the new list isn't shadowed
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            delete model.fieldOverrides[listValuePath];
-        });
-    }
-    removeListItem(model, elementValuePath) {
-        const [listValuePath, elementIndexString,] = assertExistsAndReturn(jsonPathPop(elementValuePath), 'expected a path with two or more segments {}', elementValuePath);
-        const accessor = model.accessors[listValuePath];
-        const elementIndex = checkValidNumber(parseInt(elementIndexString), 'unexpected index {} ({})', elementIndexString, elementValuePath);
-        const newList = [...accessor.value];
-        assertState(elementIndex >= 0 && elementIndex < newList.length, 'invalid index from path {} ({})', elementIndex, elementValuePath);
-        newList.splice(elementIndex, 1);
-        // shuffle the overrides around to account for new indices
-        // to so this we need to sort the array indices in descending order
-        const targetPaths = Object.keys(model.fieldOverrides).filter(function (v) {
-            return v.startsWith(`${listValuePath}.`);
-        }).map(function (v) {
-            const parts = v.substring(listValuePath.length + 1).split('.');
-            const index = parseInt(parts[0]);
-            return [
-                index,
-                parts.slice(1),
-            ];
-        }).filter(function ([index]) {
-            return index > elementIndex;
-        }).sort(function ([a], [b]) {
-            // ascending
-            return a - b;
-        });
-        runInAction(function () {
-            targetPaths.forEach(function ([index, postfix,]) {
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const fromJsonPath = [
-                    listValuePath,
-                    `${index}`,
-                    ...postfix,
-                ].join('.');
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const toJsonPath = [
-                    listValuePath,
-                    `${index - 1}`,
-                    ...postfix,
-                ].join('.');
-                const fieldOverride = model.fieldOverrides[fromJsonPath];
-                delete model.fieldOverrides[fromJsonPath];
-                model.fieldOverrides[toJsonPath] = fieldOverride;
-                const error = model.errors[fromJsonPath];
-                delete model.errors[fromJsonPath];
-                model.errors[toJsonPath] = error;
-            });
-            accessor.set(newList);
-            // delete any value overrides so the new list isn't shadowed
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            delete model.fieldOverrides[listValuePath];
-        });
-    }
-    internalSetFieldValue(model, valuePath, value, displayValidation) {
-        const { revert } = this.getAdapterForValuePath(valuePath);
-        assertExists(revert, 'setting value not supported {}', valuePath);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-        const conversion = revert(value, valuePath, model.value);
-        const accessor = model.getAccessorForValuePath(valuePath);
-        return runInAction(() => {
-            model.fieldOverrides[valuePath] = [value];
-            switch (conversion.type) {
-                case UnreliableFieldConversionType.Failure:
-                    if (displayValidation) {
-                        model.errors[valuePath] = conversion.error;
-                    }
-                    if (conversion.value != null && accessor != null) {
-                        accessor.set(conversion.value[0]);
-                    }
-                    return false;
-                case UnreliableFieldConversionType.Success:
-                    delete model.errors[valuePath];
-                    accessor === null || accessor === void 0 ? void 0 : accessor.set(conversion.value);
-                    return true;
-                default:
-                    throw new UnreachableError(conversion);
-            }
-        });
-    }
-    clearFieldError(model, valuePath) {
-        const fieldOverride = model.fieldOverrides[valuePath];
-        if (fieldOverride != null) {
-            runInAction(function () {
-                delete model.errors[valuePath];
-            });
-        }
-    }
-    clearFieldValue(model, valuePath) {
-        const typePath = this.typePath(valuePath);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const adapter = this.adapters[typePath];
-        if (adapter == null) {
-            return;
-        }
-        const { convert, create, } = adapter;
-        const value = create(valuePath, model.value);
-        const { value: displayValue, } = convert(value, valuePath, model.value);
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const key = valuePath;
-        runInAction(function () {
-            model.fieldOverrides[key] = [displayValue];
-        });
-    }
-    clearAll(model, value) {
-        runInAction(() => {
-            model.errors = {};
-            // TODO this isn't correct, should reload from value
-            model.fieldOverrides = {};
-            model.value = mobxCopy(this.type, value);
-        });
-    }
-    isValuePathActive(model, valuePath) {
-        const values = flattenValuesOfType(this.type, model.value);
-        const keys = new Set(Object.keys(values));
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return keys.has(valuePath);
-    }
-    validateField(model, valuePath, ignoreDefaultValue = false) {
-        const { convert, revert, create, } = this.getAdapterForValuePath(valuePath);
-        const fieldOverride = model.fieldOverrides[valuePath];
-        const accessor = model.getAccessorForValuePath(valuePath);
-        const { value: storedValue, } = convert(accessor != null
-            ? accessor.value
-            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-            : create(valuePath, model.value), 
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        valuePath, model.value);
-        const value = fieldOverride != null
-            ? fieldOverride[0]
-            : storedValue;
-        const dirty = storedValue !== value;
-        assertExists(revert, 'changing field directly not supported {}', valuePath);
-        if (ignoreDefaultValue) {
-            const { value: defaultDisplayValue, } = convert(create(valuePath, model.value), valuePath, model.value);
-            if (defaultDisplayValue === value) {
-                return true;
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        const conversion = revert(value, valuePath, model.value);
-        return runInAction(function () {
-            switch (conversion.type) {
-                case UnreliableFieldConversionType.Failure:
-                    model.errors[valuePath] = conversion.error;
-                    if (conversion.value != null && accessor != null && dirty) {
-                        accessor.set(conversion.value[0]);
-                    }
-                    return false;
-                case UnreliableFieldConversionType.Success:
-                    delete model.errors[valuePath];
-                    if (accessor != null && dirty) {
-                        accessor.set(conversion.value);
-                    }
-                    return true;
-                default:
-                    throw new UnreachableError(conversion);
-            }
-        });
-    }
-    validateAll(model) {
-        // sort keys shortest to longest so parent changes don't overwrite child changes
-        const accessors = toArray(model.accessors).toSorted(function ([a], [b]) {
-            return a.length - b.length;
-        });
-        return runInAction(() => {
-            return accessors.reduce((success, [valuePath, accessor,]) => {
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const adapterPath = valuePath;
-                const adapter = this.maybeGetAdapterForValuePath(adapterPath);
-                if (adapter == null) {
-                    // no adapter == there should be nothing specified for this field
-                    return success;
-                }
-                const { convert, revert, } = adapter;
-                if (revert == null) {
-                    // no convert method means this field is immutable
-                    return success;
-                }
-                const fieldOverride = model.fieldOverrides[adapterPath];
-                const { value: storedValue, } = convert(accessor.value, valuePath, model.value);
-                const value = fieldOverride != null
-                    ? fieldOverride[0]
-                    : storedValue;
-                // TODO more nuanced comparison
-                const dirty = fieldOverride != null && fieldOverride[0] !== storedValue;
-                const conversion = revert(value, valuePath, model.value);
-                switch (conversion.type) {
-                    case UnreliableFieldConversionType.Failure:
-                        model.errors[adapterPath] = conversion.error;
-                        if (conversion.value != null && dirty) {
-                            accessor.set(conversion.value[0]);
-                        }
-                        return false;
-                    case UnreliableFieldConversionType.Success:
-                        if (dirty) {
-                            accessor.set(conversion.value);
-                        }
-                        delete model.errors[adapterPath];
-                        return success;
-                    default:
-                        throw new UnreachableError(conversion);
-                }
-            }, true);
-        });
-    }
-}
-let FormModel = (() => {
-    var _a, _FormModel_value_accessor_storage, _FormModel_fieldOverrides_accessor_storage, _FormModel_errors_accessor_storage;
-    var _b, _c, _d;
-    let _instanceExtraInitializers = [];
-    let _value_decorators;
-    let _value_initializers = [];
-    let _value_extraInitializers = [];
-    let _fieldOverrides_decorators;
-    let _fieldOverrides_initializers = [];
-    let _fieldOverrides_extraInitializers = [];
-    let _errors_decorators;
-    let _errors_initializers = [];
-    let _errors_extraInitializers = [];
-    let _get_fields_decorators;
-    let _get_knownFields_decorators;
-    let _get_accessors_decorators;
-    return _a = class FormModel {
-            get value() { return __classPrivateFieldGet(this, _FormModel_value_accessor_storage, "f"); }
-            set value(value) { __classPrivateFieldSet(this, _FormModel_value_accessor_storage, value, "f"); }
-            get fieldOverrides() { return __classPrivateFieldGet(this, _FormModel_fieldOverrides_accessor_storage, "f"); }
-            set fieldOverrides(value) { __classPrivateFieldSet(this, _FormModel_fieldOverrides_accessor_storage, value, "f"); }
-            get errors() { return __classPrivateFieldGet(this, _FormModel_errors_accessor_storage, "f"); }
-            set errors(value) { __classPrivateFieldSet(this, _FormModel_errors_accessor_storage, value, "f"); }
-            constructor(type, value, adapters) {
-                Object.defineProperty(this, "type", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: (__runInitializers(this, _instanceExtraInitializers), type)
-                });
-                Object.defineProperty(this, "adapters", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: adapters
-                });
-                _FormModel_value_accessor_storage.set(this, __runInitializers(this, _value_initializers, void 0));
-                _FormModel_fieldOverrides_accessor_storage.set(this, (__runInitializers(this, _value_extraInitializers), __runInitializers(this, _fieldOverrides_initializers, void 0)));
-                _FormModel_errors_accessor_storage.set(this, (__runInitializers(this, _fieldOverrides_extraInitializers), __runInitializers(this, _errors_initializers, {})));
-                Object.defineProperty(this, "flattenedTypeDefs", {
-                    enumerable: true,
-                    configurable: true,
-                    writable: true,
-                    value: __runInitializers(this, _errors_extraInitializers)
-                });
-                this.value = mobxCopy(type, value);
-                this.flattenedTypeDefs = flattenTypesOfType(type);
-                // pre-populate field overrides for consistent behavior when default information is overwritten
-                // then returned to
-                const conversions = flattenValueTo(type, this.value, () => { }, (_t, value, _setter, typePath, valuePath) => {
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    const adapter = this.adapters[typePath];
-                    if (adapter == null) {
-                        return;
-                    }
-                    const { convert, revert, } = adapter;
-                    if (revert == null) {
-                        // no need to store a temporary value if the value cannot be written back
-                        return;
-                    }
-                    return convert(value, valuePath, this.value);
-                });
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                this.fieldOverrides = map(conversions, function (_k, v) {
-                    return v && [v.value];
-                });
-            }
-            get fields() {
-                return new Proxy(this.knownFields, {
-                    get: (target, prop) => {
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any
-                        const field = target[prop];
-                        if (field != null) {
-                            return field;
-                        }
-                        if (typeof prop === 'string') {
-                            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                            return this.maybeSynthesizeFieldByValuePath(prop);
-                        }
-                    },
-                });
-            }
-            get knownFields() {
-                return flattenValueTo(this.type, this.value, () => { }, 
-                // TODO swap these to valuePath, typePath in flatten
-                (_t, _v, _setter, typePath, valuePath) => {
-                    return this.synthesizeFieldByPaths(
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    valuePath, 
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    typePath);
-                });
-            }
-            maybeSynthesizeFieldByValuePath(valuePath) {
-                let typePath;
-                try {
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    typePath = valuePathToTypePath(this.type, 
-                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                    valuePath, true);
-                }
-                catch (e) {
-                    // TODO make jsonValuePathToTypePath return null in the event of an invalid
-                    // value path instead of throwing an exception
-                    // assume that the path was invalid
-                    return;
-                }
-                return this.synthesizeFieldByPaths(valuePath, typePath);
-            }
-            synthesizeFieldByPaths(valuePath, typePath) {
-                const adapter = this.adapters[typePath];
-                if (adapter == null) {
-                    // invalid path, which can happen
-                    return;
-                }
-                const { convert, create, } = adapter;
-                const fieldOverride = this.fieldOverrides[valuePath];
-                const accessor = this.getAccessorForValuePath(valuePath);
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                const fieldTypeDef = this.flattenedTypeDefs[typePath];
-                const { value, required, readonly, } = convert(accessor != null
-                    ? accessor.value
-                    : fieldTypeDef != null
-                        ? mobxCopy(fieldTypeDef, 
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        create(valuePath, this.value))
-                        // fake values can't be copied
-                        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                        : create(valuePath, this.value), 
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                valuePath, this.value);
-                const error = this.errors[valuePath];
-                return {
-                    value: fieldOverride != null ? fieldOverride[0] : value,
-                    error,
-                    readonly,
-                    required,
-                };
-            }
-            getAccessorForValuePath(valuePath) {
-                // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-                return this.accessors[valuePath];
-            }
-            get accessors() {
-                return flattenAccessorsOfType(this.type, this.value, (value) => {
-                    this.value = mobxCopy(this.type, value);
-                });
-            }
-        },
-        _FormModel_value_accessor_storage = new WeakMap(),
-        _FormModel_fieldOverrides_accessor_storage = new WeakMap(),
-        _FormModel_errors_accessor_storage = new WeakMap(),
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _value_decorators = [(_b = observable).ref.bind(_b)];
-            _fieldOverrides_decorators = [(_c = observable).shallow.bind(_c)];
-            _errors_decorators = [(_d = observable).shallow.bind(_d)];
-            _get_fields_decorators = [computed];
-            _get_knownFields_decorators = [computed];
-            _get_accessors_decorators = [computed];
-            __esDecorate(_a, null, _value_decorators, { kind: "accessor", name: "value", static: false, private: false, access: { has: obj => "value" in obj, get: obj => obj.value, set: (obj, value) => { obj.value = value; } }, metadata: _metadata }, _value_initializers, _value_extraInitializers);
-            __esDecorate(_a, null, _fieldOverrides_decorators, { kind: "accessor", name: "fieldOverrides", static: false, private: false, access: { has: obj => "fieldOverrides" in obj, get: obj => obj.fieldOverrides, set: (obj, value) => { obj.fieldOverrides = value; } }, metadata: _metadata }, _fieldOverrides_initializers, _fieldOverrides_extraInitializers);
-            __esDecorate(_a, null, _errors_decorators, { kind: "accessor", name: "errors", static: false, private: false, access: { has: obj => "errors" in obj, get: obj => obj.errors, set: (obj, value) => { obj.errors = value; } }, metadata: _metadata }, _errors_initializers, _errors_extraInitializers);
-            __esDecorate(_a, null, _get_fields_decorators, { kind: "getter", name: "fields", static: false, private: false, access: { has: obj => "fields" in obj, get: obj => obj.fields }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _get_knownFields_decorators, { kind: "getter", name: "knownFields", static: false, private: false, access: { has: obj => "knownFields" in obj, get: obj => obj.knownFields }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _get_accessors_decorators, { kind: "getter", name: "accessors", static: false, private: false, access: { has: obj => "accessors" in obj, get: obj => obj.accessors }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
-})();
-export { FormModel };