@strictly/react-form 0.0.10 → 0.0.11

package/.out/core/mobx/field_adapter_builder.js

@@ -5,13 +5,25 @@ import { TrimmingStringConverter } from 'field_converters/trimming_string_conver
 import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 class FieldAdapterBuilder {
-    convert;
-    create;
-    revert;
     constructor(convert, create, revert) {
-        this.convert = convert;
-        this.create = create;
-        this.revert = revert;
+        Object.defineProperty(this, "convert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: convert
+        });
+        Object.defineProperty(this, "create", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: create
+        });
+        Object.defineProperty(this, "revert", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: revert
+        });
     }
     chain(converter, reverter) {
         return new FieldAdapterBuilder(chainAnnotatedFieldConverter(this.convert, converter), this.create, this.revert && reverter && chainUnreliableFieldConverter(reverter, this.revert));

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

@@ -1,13 +1,66 @@
+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 {
-    type;
-    adapters;
     constructor(type, adapters) {
-        this.type = type;
-        this.adapters = 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
@@ -34,7 +87,7 @@ export class FormPresenter {
         const listValuePath = valuePath;
         const accessor = model.accessors[valuePath];
         const listTypePath = this.typePath(valuePath);
-        const definedIndex = index ?? accessor.value.length;
+        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);
@@ -165,7 +218,7 @@ export class FormPresenter {
                     return false;
                 case UnreliableFieldConversionType.Success:
                     delete model.errors[valuePath];
-                    accessor?.set(conversion.value);
+                    accessor === null || accessor === void 0 ? void 0 : accessor.set(conversion.value);
                     return true;
                 default:
                     throw new UnreachableError(conversion);
@@ -299,124 +352,174 @@ export class FormPresenter {
         });
     }
 }
-export class FormModel {
-    type;
-    adapters;
-    @observable.ref
-    accessor value;
-    @observable.shallow
-    accessor fieldOverrides;
-    @observable.shallow
-    accessor errors = {};
-    flattenedTypeDefs;
-    constructor(type, value, adapters) {
-        this.type = type;
-        this.adapters = adapters;
-        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;
+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];
+                });
             }
-            const { convert, revert, } = adapter;
-            if (revert == null) {
-                // no need to store a temporary value if the value cannot be written back
-                return;
+            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);
+                        }
+                    },
+                });
             }
-            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];
-        });
-    }
-    @computed
-    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') {
+            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
-                    return this.maybeSynthesizeFieldByValuePath(prop);
+                    typePath = valuePathToTypePath(this.type, 
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    valuePath, true);
                 }
-            },
-        });
-    }
-    @computed
-    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, 
+                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
-                create(valuePath, this.value))
-                // fake values can't be copied
+                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
-                : 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];
-    }
-    @computed
-    // should only be referenced internally, so loosely typed
-    get accessors() {
-        return flattenAccessorsOfType(this.type, this.value, (value) => {
-            this.value = mobxCopy(this.type, value);
-        });
-    }
-}
+                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 };

package/.out/core/mobx/hooks.js

@@ -17,7 +17,7 @@ export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit,
     ]);
     const onFieldSubmit = useCallback(function (valuePath) {
         if (presenter.validateField(model, valuePath)) {
-            onValidFieldSubmit?.(model, valuePath);
+            onValidFieldSubmit === null || onValidFieldSubmit === void 0 ? void 0 : onValidFieldSubmit(model, valuePath);
         }
         return false;
     }, [
@@ -40,7 +40,7 @@ export function useDefaultMobxFormHooks(presenter, value, { onValidFieldSubmit,
     ]);
     const onFormSubmit = useCallback(function () {
         if (presenter.validateAll(model)) {
-            onValidFormSubmit?.(model, model.value);
+            onValidFormSubmit === null || onValidFormSubmit === void 0 ? void 0 : onValidFormSubmit(model, model.value);
         }
     }, [
         presenter,

package/.out/core/mobx/merge_field_adapters_with_validators.js

@@ -35,11 +35,7 @@ export function mergeAdaptersWithValidators(adapters, validators) {
                 readonly: readonly1 || readonly2,
             };
         }
-        acc[key] = {
-            ...adapter,
-            convert,
-            revert: adapter.revert && revert,
-        };
+        acc[key] = Object.assign(Object.assign({}, adapter), { convert, revert: adapter.revert && revert });
         return acc;
     }, {});
 }

package/.out/core/mobx/specs/fixtures.js

@@ -3,9 +3,10 @@ export function createMockedAdapter(_original) {
     return mock();
 }
 export function resetMockAdapter({ convert, revert, create, }, mockedAdapter) {
+    var _a;
     mockReset(mockedAdapter);
     if (revert) {
-        mockedAdapter.revert?.mockImplementation(revert);
+        (_a = mockedAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockImplementation(revert);
     }
     mockedAdapter.convert.mockImplementation(convert);
     mockedAdapter.create.mockImplementation(create);

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

@@ -335,7 +335,8 @@ describe('all', function () {
                         const newValue = -1;
                         const errorCode = 65;
                         beforeEach(function () {
-                            integerToStringAdapter.revert?.mockReturnValueOnce({
+                            var _a;
+                            (_a = integerToStringAdapter.revert) === null || _a === void 0 ? void 0 : _a.mockReturnValueOnce({
                                 type: UnreliableFieldConversionType.Failure,
                                 error: errorCode,
                                 value: [newValue],
@@ -548,7 +549,8 @@ describe('all', function () {
                             '7',
                         ],
                     ])('it reports the value of field %s as %s', function (path, fieldValue) {
-                        expect(model.fields[path]?.value).toBe(fieldValue);
+                        var _a;
+                        expect((_a = model.fields[path]) === null || _a === void 0 ? void 0 : _a.value).toBe(fieldValue);
                     });
                     it.each([
                         [
@@ -568,7 +570,8 @@ describe('all', function () {
                             2,
                         ],
                     ])('it reports the error of field %s', function (path, error) {
-                        expect(model.fields[path]?.error).toBe(error);
+                        var _a;
+                        expect((_a = model.fields[path]) === null || _a === void 0 ? void 0 : _a.error).toBe(error);
                     });
                 });
                 describe('add defined value', function () {

package/.out/core/mobx/specs/sub_form_field_adapters.tests.js

@@ -43,12 +43,13 @@ describe('subFormFieldAdapters', () => {
             expect(returnedValue).toEqual(mockedReturnedValue);
         });
         it('calls revert with the correct paths and values', () => {
+            var _a, _b;
             const mockedReturnedValue = {
                 type: UnreliableFieldConversionType.Success,
                 value: 'ok',
             };
             mockedFieldAdapter1.revert.mockReturnValue(mockedReturnedValue);
-            const returnedValue = adapters['$.a'].revert?.(true, '$.a', { a: 'y' });
+            const returnedValue = (_b = (_a = adapters['$.a']).revert) === null || _b === void 0 ? void 0 : _b.call(_a, true, '$.a', { a: 'y' });
             expect(fieldAdapter1.revert).toHaveBeenCalledWith(true, '$', 'y');
             expect(returnedValue).toEqual(mockedReturnedValue);
         });

package/.out/field_converters/integer_to_string_converter.js

@@ -1,10 +1,18 @@
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class IntegerToStringConverter {
-    isNanError;
-    base;
     constructor(isNanError, base = 10) {
-        this.isNanError = isNanError;
-        this.base = base;
+        Object.defineProperty(this, "isNanError", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: isNanError
+        });
+        Object.defineProperty(this, "base", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: base
+        });
     }
     convert(from) {
         const value = Math.floor(from).toString();

package/.out/field_converters/maybe_identity_converter.js

@@ -1,9 +1,17 @@
 export class MaybeIdentityConverter {
-    converter;
-    isFrom;
     constructor(converter, isFrom) {
-        this.converter = converter;
-        this.isFrom = isFrom;
+        Object.defineProperty(this, "converter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: converter
+        });
+        Object.defineProperty(this, "isFrom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: isFrom
+        });
     }
     convert(from, valuePath, context) {
         return this.converter.convert(from, valuePath, context);

package/.out/field_converters/nullable_to_boolean_converter.js

@@ -1,14 +1,31 @@
 import { copy, } from '@strictly/define';
 import { UnreliableFieldConversionType, } from 'types/field_converters';
 export class NullableToBooleanConverter {
-    typeDef;
-    prototype;
-    nullType;
-    defaultValue;
     constructor(typeDef, prototype, nullType, defaultToNull = true) {
-        this.typeDef = typeDef;
-        this.prototype = prototype;
-        this.nullType = nullType;
+        Object.defineProperty(this, "typeDef", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: typeDef
+        });
+        Object.defineProperty(this, "prototype", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: prototype
+        });
+        Object.defineProperty(this, "nullType", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: nullType
+        });
+        Object.defineProperty(this, "defaultValue", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.defaultValue = defaultToNull ? this.nullType : prototype;
     }
     convert(from) {