@strictly/react-form 0.0.1

package/.eslintrc.cjs

@@ -0,0 +1,26 @@
+/* eslint-env node */
+/** @type {import('@types/eslint').Linter.Config} */
+module.exports = {
+  root: true,
+  extends: ['../../.eslintrc.cjs'],
+  parserOptions: {
+    project: [
+      'tsconfig.json',
+      'tsconfig.build.json',
+    ],
+    tsconfigRootDir: __dirname,
+    sourceType: 'module',
+    ecmaVersion: '2015',
+  },
+  rules: {
+    'import/no-extraneous-dependencies': [
+      'warn',
+      {
+        packageDir: [
+          '.',
+          '../..',
+        ],
+      },
+    ],
+  },
+}

package/.out/.storybook/main.d.ts

@@ -0,0 +1,3 @@
+import { type StorybookConfig } from '@storybook/react-vite';
+declare const config: StorybookConfig;
+export default config;

package/.out/.storybook/main.js

@@ -0,0 +1,32 @@
+import { dirname, join, } from 'path';
+/**
+ * This function is used to resolve the absolute path of a package.
+ * It is needed in projects that use Yarn PnP or are set up within a monorepo.
+ */
+function getAbsolutePath(value) {
+    return dirname(require.resolve(join(value, 'package.json')));
+}
+const config = {
+    stories: ['../**/*.stories.@(ts|tsx)'],
+    addons: [
+        getAbsolutePath('@storybook/addon-links'),
+        getAbsolutePath('@storybook/addon-essentials'),
+        getAbsolutePath('@chromatic-com/storybook'),
+        getAbsolutePath('@storybook/addon-interactions'),
+    ],
+    core: {
+        builder: {
+            name: getAbsolutePath('@storybook/builder-vite'),
+            options: {
+                viteConfigPath: './.storybook/vite.config.mts',
+            },
+        },
+    },
+    framework: {
+        // NOTE: the documentation says this should be @storybook/react-vite, which fails completely
+        // https://storybook.js.org/docs/get-started/frameworks/react-vite
+        name: getAbsolutePath('@storybook/react'),
+        options: {},
+    },
+};
+export default config;

package/.out/.storybook/preview.d.ts

@@ -0,0 +1,4 @@
+import '@mantine/core/styles.css';
+import { type Preview } from '@storybook/react';
+declare const preview: Preview;
+export default preview;

package/.out/.storybook/preview.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import '@mantine/core/styles.css';
+import { MantineProvider } from '@mantine/core';
+import { StrictMode } from 'react';
+const preview = {
+    parameters: {
+        controls: {
+            matchers: {
+                color: /(background|color)$/i,
+                date: /Date$/i,
+            },
+        },
+    },
+    decorators: [
+        function (Story) {
+            return (_jsx(MantineProvider, { children: _jsx(StrictMode, { children: _jsx(Story, {}) }) }));
+        },
+    ],
+};
+export default preview;

package/.out/.vitest/install_deterministic_random.d.ts

@@ -0,0 +1,2 @@
+declare const originalMathRandom: () => number;
+declare const LIMIT = 100;

package/.out/.vitest/install_deterministic_random.js

@@ -0,0 +1,15 @@
+"use strict";
+// sadly Mantine uses randomness to generate certain fields (e.g. label mappings), we
+// override Math.random to ensure these seeds remain the same between runs
+const originalMathRandom = Math.random;
+const LIMIT = 100;
+beforeEach(function () {
+    let count = 0;
+    Math.random = function () {
+        count++;
+        return (count % LIMIT) / LIMIT;
+    };
+});
+afterEach(function () {
+    Math.random = originalMathRandom;
+});

package/.out/.vitest/install_storybook_preview.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/.vitest/install_storybook_preview.js

@@ -0,0 +1,7 @@
+// adapted from https://storybook.js.org/docs/api/portable-stories/portable-stories-jest
+import { setProjectAnnotations } from '@storybook/react';
+// eslint-disable-next-line no-relative-import-paths/no-relative-import-paths
+import * as previewAnnotations from '../.storybook/preview';
+const annotations = setProjectAnnotations([previewAnnotations]);
+// Run Storybook's beforeAll hook
+beforeAll(annotations.beforeAll);

package/.out/.vitest/match_media.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/.vitest/match_media.js

@@ -0,0 +1,5 @@
+import MatchMediaMock from 'vitest-matchmedia-mock';
+const matchMediaMock = new MatchMediaMock();
+beforeAll(function () {
+    matchMediaMock.clear();
+});

package/.out/.vitest/resize_observer.d.ts

@@ -0,0 +1 @@
+export {};

package/.out/.vitest/resize_observer.js

@@ -0,0 +1,4 @@
+import ResizeObserver from 'resize-observer-polyfill';
+beforeAll(function () {
+    window.ResizeObserver = window.ResizeObserver || ResizeObserver;
+});

package/.out/core/mobx/field_adapter.d.ts

@@ -0,0 +1,9 @@
+import { type FieldConverter, type FieldValueFactory, type SafeFieldConverter } from 'types/field_converters';
+export type FieldAdapter<From = any, To = any, E = any, ValuePath extends string = any, Context = any> = {
+    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly create: FieldValueFactory<From, ValuePath, Context>;
+    readonly revert?: FieldConverter<To, From, E, ValuePath, Context>;
+};
+export type FromTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer From> ? From : never;
+export type ToTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _F, infer To> ? To : never;
+export type ErrorTypeOfFieldAdapter<C extends FieldAdapter> = C extends FieldAdapter<infer _From, infer _To, infer E> ? NonNullable<E> : never;

package/.out/core/mobx/field_adapter.js

@@ -0,0 +1 @@
+export {};

package/.out/core/mobx/field_adapter_builder.d.ts

@@ -0,0 +1,22 @@
+import { type FieldConverter, type FieldValueFactory, type SafeFieldConverter, type TwoWayFieldConverter, type TwoWayFieldConverterWithValueFactory } from 'types/field_converters';
+import { type FieldValidator } from 'types/field_validator';
+declare class FieldAdapterBuilder<From, To, E, ValuePath extends string, Context> {
+    readonly convert: SafeFieldConverter<From, To, ValuePath, Context>;
+    readonly create: FieldValueFactory<From, ValuePath, Context>;
+    readonly revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined;
+    constructor(convert: SafeFieldConverter<From, To, ValuePath, Context>, create: FieldValueFactory<From, ValuePath, Context>, revert?: FieldConverter<To, From, E, ValuePath, Context> | undefined);
+    validateFrom<E2>(...validators: readonly FieldValidator<From, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
+    validateTo<E2>(...validators: readonly FieldValidator<To, E2, ValuePath, Context>[]): FieldAdapterBuilder<From, To, E | E2, ValuePath, Context>;
+    chain<To2, E2 = E>(converter: SafeFieldConverter<To, To2, ValuePath, Context>, reverter?: FieldConverter<To2, To, E2, ValuePath, Context>): FieldAdapterBuilder<From, To2, E | E2, ValuePath, Context>;
+    withReverter(reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+    withIdentity(isFrom: (from: To | From) => from is From): FieldAdapterBuilder<From, To | From, E, ValuePath, Context>;
+}
+export declare function adapter<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+export declare function adapter<From, To, E, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>, reverter: FieldConverter<To, From, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+export declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, valueFactory: FieldValueFactory<From, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+export declare function adapterFromTwoWayConverter<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverterWithValueFactory<From, To, E, ValuePath, Context>): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+export declare function adapterFromPrototype<From, To, ValuePath extends string, Context>(converter: SafeFieldConverter<From, To, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, never, ValuePath, Context>;
+export declare function adapterFromPrototype<From, To, E, ValuePath extends string, Context>(converter: TwoWayFieldConverter<From, To, E, ValuePath, Context>, prototype: From): FieldAdapterBuilder<From, To, E, ValuePath, Context>;
+export declare function identityAdapter<V, ValuePath extends string, Context>(prototype: V): FieldAdapterBuilder<V, V, never, ValuePath, Context>;
+export declare function listAdapter<E, K extends string, ValuePath extends string, Context>(): FieldAdapterBuilder<readonly E[], readonly K[], never, ValuePath, Context>;
+export {};

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

@@ -0,0 +1,56 @@
+import { chainFieldConverter, chainSafeFieldConverter, } from 'field_converters/chain_field_converter';
+import { identityConverter, safeIdentityConverter, } from 'field_converters/identity_converter';
+import { listConverter } from 'field_converters/list_converter';
+import { MaybeIdentityConverter } from 'field_converters/maybe_identity_converter';
+import { validatingConverter, } from 'field_converters/validating_converter';
+import { prototypingFieldValueFactory } from 'field_value_factories/prototyping_field_value_factory';
+class FieldAdapterBuilder {
+    convert;
+    create;
+    revert;
+    constructor(convert, create, revert) {
+        this.convert = convert;
+        this.create = create;
+        this.revert = revert;
+    }
+    validateFrom(...validators) {
+        return new FieldAdapterBuilder(this.convert, this.create, this.revert && chainFieldConverter(this.revert, validatingConverter(validators)));
+    }
+    validateTo(...validators) {
+        return new FieldAdapterBuilder(this.convert, this.create, this.revert && chainFieldConverter(validatingConverter(validators), this.revert));
+    }
+    chain(converter, reverter) {
+        return new FieldAdapterBuilder(chainSafeFieldConverter(this.convert, converter), this.create, this.revert && reverter && chainFieldConverter(reverter, this.revert));
+    }
+    withReverter(reverter) {
+        return new FieldAdapterBuilder(this.convert, this.create, reverter);
+    }
+    withIdentity(isFrom) {
+        const identityConverter = new MaybeIdentityConverter({
+            convert: this.convert,
+            // should never get called if null
+            revert: this.revert,
+        }, isFrom);
+        return new FieldAdapterBuilder(identityConverter.convert.bind(identityConverter), this.create, this.revert && identityConverter.revert.bind(identityConverter));
+    }
+}
+export function adapter(converter, valueFactory, reverter) {
+    return new FieldAdapterBuilder(converter, valueFactory, reverter);
+}
+export function adapterFromTwoWayConverter(converter, 
+// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+valueFactory = converter.create.bind(converter)) {
+    return new FieldAdapterBuilder(converter.convert.bind(converter), valueFactory, converter.revert.bind(converter));
+}
+export function adapterFromPrototype(converter, prototype) {
+    const factory = prototypingFieldValueFactory(prototype);
+    return typeof converter === 'function'
+        ? new FieldAdapterBuilder(converter, factory)
+        : new FieldAdapterBuilder(converter.convert.bind(converter), factory, converter.revert.bind(converter));
+}
+export function identityAdapter(prototype) {
+    return new FieldAdapterBuilder(safeIdentityConverter(), prototypingFieldValueFactory(prototype), identityConverter());
+}
+export function listAdapter() {
+    return new FieldAdapterBuilder(listConverter(), prototypingFieldValueFactory([]));
+}

package/.out/core/mobx/flattened_adapters_of_fields.d.ts

@@ -0,0 +1,9 @@
+import { type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
+import { type FieldAdapter } from 'core/mobx/field_adapter';
+import { type SimplifyDeep, type ValueOf } from 'type-fest';
+import { type Field } from 'types/field';
+export type FlattenedAdaptersOfFields<ValuePathsToTypePaths extends Readonly<Record<string, string>>, FlattenedTypeDefs extends Partial<Readonly<Record<ValueOf<ValuePathsToTypePaths>, Type>>>, FormFields extends Partial<Readonly<Record<keyof ValuePathsToTypePaths, Field>>>> = SimplifyDeep<{
+    readonly [K in keyof ValuePathsToTypePaths as FormFields[K] extends Field ? ValuePathsToTypePaths[K] : never]: AdapterOfField<NonNullable<FormFields[K]>, FlattenedTypeDefs[ValuePathsToTypePaths[K]], K>;
+}>;
+type AdapterOfField<F extends Field, T extends Type | undefined, ValuePath extends string | number | symbol> = ValuePath extends string ? F extends Field<infer V, infer E> ? undefined extends T ? FieldAdapter<V, V, E, ValuePath> : FieldAdapter<ValueTypeOf<ReadonlyTypeDefOf<NonNullable<T>>>, V, E, ValuePath> : never : never;
+export {};

package/.out/core/mobx/flattened_adapters_of_fields.js

@@ -0,0 +1 @@
+export {};

package/.out/core/mobx/flattened_list_type_defs_of.d.ts

@@ -0,0 +1,8 @@
+import { type FlattenedTypeDefsOf, type ListTypeDef, type Type } from '@strictly/define';
+import { type SimplifyDeep } from 'type-fest';
+export type ListJsonPathsOf<T extends Type> = keyof FlattenedListTypeDefsOf<T>;
+export type FlattenedListTypeDefsOf<T extends Type> = FlattenedListTypeDefsOfFlattened<SimplifyDeep<FlattenedTypeDefsOf<T, null>>>;
+type FlattenedListTypeDefsOfFlattened<T extends Readonly<Record<string, Type>>> = {
+    [K in keyof T as T[K]['definition'] extends ListTypeDef ? K : never]: T[K];
+};
+export {};

package/.out/core/mobx/flattened_list_type_defs_of.js

@@ -0,0 +1 @@
+export {};

package/.out/core/mobx/form_presenter.d.ts

@@ -0,0 +1,61 @@
+import { type ElementOfArray, type Maybe } from '@strictly/base';
+import { type Accessor, type FlattenedValueTypesOf, type MobxValueTypeOf, type ReadonlyTypeDefOf, type Type, type ValueTypeOf } from '@strictly/define';
+import { type ReadonlyDeep, type SimplifyDeep, type StringKeyOf, type ValueOf } from 'type-fest';
+import { type Field } from 'types/field';
+import { type ErrorTypeOfFieldAdapter, type FieldAdapter, type ToTypeOfFieldAdapter } from './field_adapter';
+import { type FlattenedListTypeDefsOf } from './flattened_list_type_defs_of';
+export type FlattenedConvertedFieldsOf<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    readonly [K in keyof ValuePathsToAdapters]: Field<ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>, ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>>;
+};
+export type FlattenedTypePathsToAdaptersOf<FlattenedValues extends Readonly<Record<string, any>>, Context> = {
+    readonly [K in keyof FlattenedValues]?: FieldAdapter<ReadonlyDeep<FlattenedValues[K]>, any, any, any, Context>;
+};
+type FieldOverride<V = any> = {
+    value: V;
+};
+type FlattenedFieldOverrides<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: FieldOverride<ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>>;
+};
+type FlattenedErrors<ValuePathsToAdapters extends Readonly<Record<string, FieldAdapter>>> = {
+    -readonly [K in keyof ValuePathsToAdapters]?: ErrorTypeOfFieldAdapter<ValuePathsToAdapters[K]>;
+};
+export type ValuePathsToAdaptersOf<TypePathsToAdapters extends Partial<Readonly<Record<string, FieldAdapter>>>, ValuePathsToTypePaths extends Readonly<Record<string, string>>> = keyof TypePathsToAdapters extends ValueOf<ValuePathsToTypePaths> ? {
+    readonly [K in keyof ValuePathsToTypePaths as unknown extends TypePathsToAdapters[ValuePathsToTypePaths[K]] ? never : K]: NonNullable<TypePathsToAdapters[ValuePathsToTypePaths[K]]>;
+} : never;
+export declare class FormPresenter<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    readonly typeDef: T;
+    private readonly adapters;
+    constructor(typeDef: T, adapters: TypePathsToAdapters);
+    private maybeGetAdapterForValuePath;
+    private getAdapterForValuePath;
+    typePath<K extends keyof ValueToTypePaths>(valuePath: K): ValueToTypePaths[K];
+    setFieldValueAndValidate<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    setFieldValue<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, value: ToTypeOfFieldAdapter<ValuePathsToAdapters[K]>): boolean;
+    addListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K, elementValue: Maybe<ElementOfArray<FlattenedValueTypesOf<T>[K]>>, index?: number): void;
+    removeListItem<K extends keyof FlattenedListTypeDefsOf<T>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, elementValuePath: `${K}.${number}`): void;
+    private internalSetFieldValue;
+    clearFieldError<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
+    clearFieldValue<K extends StringKeyOf<ValuePathsToAdapters>>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): void;
+    clearAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, value: ValueTypeOf<T>): void;
+    validateField<K extends keyof ValuePathsToAdapters>(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>, valuePath: K): boolean;
+    validateAll(model: FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>): boolean;
+    createModel(value: ValueTypeOf<ReadonlyTypeDefOf<T>>): FormModel<T, ValueToTypePaths, TypePathsToAdapters, ValuePathsToAdapters>;
+}
+export declare class FormModel<T extends Type, ValueToTypePaths extends Readonly<Record<string, string>>, TypePathsToAdapters extends FlattenedTypePathsToAdaptersOf<FlattenedValueTypesOf<T, '*'>, ValueTypeOf<ReadonlyTypeDefOf<T>>>, ValuePathsToAdapters extends ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths> = ValuePathsToAdaptersOf<TypePathsToAdapters, ValueToTypePaths>> {
+    private readonly typeDef;
+    private readonly adapters;
+    accessor value: MobxValueTypeOf<T>;
+    accessor fieldOverrides: FlattenedFieldOverrides<ValuePathsToAdapters>;
+    accessor errors: FlattenedErrors<ValuePathsToAdapters>;
+    private readonly flattenedTypeDefs;
+    constructor(typeDef: T, value: ValueTypeOf<ReadonlyTypeDefOf<T>>, adapters: TypePathsToAdapters);
+    get fields(): SimplifyDeep<FlattenedConvertedFieldsOf<ValuePathsToAdapters>>;
+    private get knownFields();
+    private maybeSynthesizeFieldByValuePath;
+    private synthesizeFieldByPaths;
+    getAccessorForValuePath(valuePath: keyof ValuePathsToAdapters): Accessor | undefined;
+    get accessors(): Readonly<Record<string, Accessor>>;
+    protected isDisabled(_valuePath: keyof ValuePathsToAdapters): boolean;
+    protected isRequired(_valuePath: keyof ValuePathsToAdapters): boolean;
+}
+export {};