remix-validated-form 1.1.1-beta.0 → 2.0.1-beta.0

package/.turbo/turbo-build.log

@@ -0,0 +1,9 @@
+$ npm run build:browser && npm run build:main
+
+> remix-validated-form@2.0.0 build:browser
+> tsc --module ESNext --outDir ./browser
+
+
+> remix-validated-form@2.0.0 build:main
+> tsc --module CommonJS --outDir ./build
+

package/browser/ValidatedForm.d.ts

@@ -2,10 +2,32 @@ import { Form as RemixForm, useFetcher } from "@remix-run/react";
 import React, { ComponentProps } from "react";
 import { Validator } from "./validation/types";
 export declare type FormProps<DataType> = {
+    /**
+     * A `Validator` object that describes how to validate the form.
+     */
     validator: Validator<DataType>;
+    /**
+     * A submit callback that gets called when the form is submitted
+     * after all validations have been run.
+     */
     onSubmit?: (data: DataType, event: React.FormEvent<HTMLFormElement>) => void;
+    /**
+     * Allows you to provide a `fetcher` from remix's `useFetcher` hook.
+     * The form will use the fetcher for loading states, action data, etc
+     * instead of the default form action.
+     */
     fetcher?: ReturnType<typeof useFetcher>;
+    /**
+     * Accepts an object of default values for the form
+     * that will automatically be propagated to the form fields via `useField`.
+     */
     defaultValues?: Partial<DataType>;
+    /**
+     * A ref to the form element.
+     */
     formRef?: React.RefObject<HTMLFormElement>;
 } & Omit<ComponentProps<typeof RemixForm>, "onSubmit">;
+/**
+ * The primary form component of `remix-validated-form`.
+ */
 export declare function ValidatedForm<DataType>({ validator, onSubmit, children, fetcher, action, defaultValues, formRef: formRefProp, ...rest }: FormProps<DataType>): JSX.Element;

package/browser/ValidatedForm.js

@@ -23,7 +23,10 @@ const useIsSubmitting = (action, fetcher) => {
         : pendingFormSubmit &&
             pendingFormSubmit.action === (action !== null && action !== void 0 ? action : actionForCurrentPage);
 };
-const getDataFromForm = (el) => Object.fromEntries(new FormData(el));
+const getDataFromForm = (el) => new FormData(el);
+/**
+ * The primary form component of `remix-validated-form`.
+ */
 export function ValidatedForm({ validator, onSubmit, children, fetcher, action, defaultValues, formRef: formRefProp, ...rest }) {
     var _a;
     const [fieldErrors, setFieldErrors] = useFieldErrors(fetcher);

package/browser/hooks.d.ts

@@ -1,8 +1,33 @@
-export declare const useField: (name: string) => {
-    error: string;
+export declare type FieldProps = {
+    /**
+     * The validation error message if there is one.
+     */
+    error?: string;
+    /**
+     * Clears the error message.
+     */
     clearError: () => void;
+    /**
+     * Validates the field.
+     */
     validate: () => void;
-    defaultValue: any;
+    /**
+     * The default value of the field, if there is one.
+     */
+    defaultValue?: any;
 };
+/**
+ * Provides the data and helpers necessary to set up a field.
+ */
+export declare const useField: (name: string) => FieldProps;
+/**
+ * Provides access to the entire form context.
+ * This is not usually necessary, but can be useful for advanced use cases.
+ */
 export declare const useFormContext: () => import("./internal/formContext").FormContextValue;
+/**
+ * Returns whether or not the parent form is currently being submitted.
+ * This is different from remix's `useTransition().submission` in that it
+ * is aware of what form it's in and when _that_ form is being submitted.
+ */
 export declare const useIsSubmitting: () => boolean;

package/browser/hooks.js

@@ -2,6 +2,9 @@ import get from "lodash/get";
 import toPath from "lodash/toPath";
 import { useContext, useMemo } from "react";
 import { FormContext } from "./internal/formContext";
+/**
+ * Provides the data and helpers necessary to set up a field.
+ */
 export const useField = (name) => {
     const { fieldErrors, clearError, validateField, defaultValues } = useContext(FormContext);
     const field = useMemo(() => ({
@@ -16,6 +19,14 @@ export const useField = (name) => {
     }), [clearError, defaultValues, fieldErrors, name, validateField]);
     return field;
 };
-// test commit
+/**
+ * Provides access to the entire form context.
+ * This is not usually necessary, but can be useful for advanced use cases.
+ */
 export const useFormContext = () => useContext(FormContext);
+/**
+ * Returns whether or not the parent form is currently being submitted.
+ * This is different from remix's `useTransition().submission` in that it
+ * is aware of what form it's in and when _that_ form is being submitted.
+ */
 export const useIsSubmitting = () => useFormContext().isSubmitting;

package/browser/index.d.ts

@@ -4,3 +4,5 @@ export * from "./ValidatedForm";
 export * from "./validation/types";
 export * from "./validation/withYup";
 export * from "./validation/withZod";
+export * from "./validation/createValidator";
+export type { FormContextValue } from "./internal/formContext";

package/browser/index.js

@@ -4,3 +4,4 @@ export * from "./ValidatedForm";
 export * from "./validation/types";
 export * from "./validation/withYup";
 export * from "./validation/withZod";
+export * from "./validation/createValidator";

package/browser/{flatten.d.ts → internal/flatten.d.ts}

@@ -1,5 +1,4 @@
-import { GenericObject } from ".";
-/** Unflatten a previously flatten object */
-export declare function unflatten(params: GenericObject): {};
+import { GenericObject } from "..";
+export declare const objectFromPathEntries: (entries: [string, any][]) => {};
 /** Flatten an object so there are no nested objects or arrays */
 export declare function flatten(obj: GenericObject, preserveEmpty?: boolean): GenericObject;

package/browser/{flatten.js → internal/flatten.js}

@@ -1,18 +1,12 @@
-// `flatten` and `unflatten` are taken from https://github.com/richie5um/FlattenJS. Decided to implement them here instead of using that package because this is a core functionality of the library and this will add more flexibility in case we need to change the implementation.
+// `flatten` is taken from https://github.com/richie5um/FlattenJS. Decided to implement them here instead of using that package because this is a core functionality of the library and this will add more flexibility in case we need to change the implementation.
 import assign from "lodash/assign";
 import isArray from "lodash/isArray";
 import isObject from "lodash/isObject";
 import keys from "lodash/keys";
 import mapKeys from "lodash/mapKeys";
-import reduce from "lodash/reduce";
 import set from "lodash/set";
 import transform from "lodash/transform";
-/** Unflatten a previously flatten object */
-export function unflatten(params) {
-    return reduce(params, function (result, value, key) {
-        return set(result, key, value);
-    }, {});
-}
+export const objectFromPathEntries = (entries) => entries.reduce((acc, [key, value]) => set(acc, key, value), {});
 /** Flatten an object so there are no nested objects or arrays */
 export function flatten(obj, preserveEmpty = false) {
     return transform(obj, function (result, value, key) {

package/browser/internal/formContext.d.ts

@@ -1,11 +1,29 @@
 /// <reference types="react" />
 import { FieldErrors } from "../validation/types";
 export declare type FormContextValue = {
+    /**
+     * All the errors in all the fields in the form.
+     */
     fieldErrors: FieldErrors;
+    /**
+     * Clear the errors of the specified fields.
+     */
     clearError: (...names: string[]) => void;
+    /**
+     * Validate the specified field.
+     */
     validateField: (fieldName: string) => void;
+    /**
+     * The `action` prop of the form.
+     */
     action?: string;
+    /**
+     * Whether or not the form is submitting.
+     */
     isSubmitting: boolean;
+    /**
+     * The default values of the form.
+     */
     defaultValues?: {
         [fieldName: string]: any;
     };

package/browser/server.d.ts

@@ -1,2 +1,7 @@
 import { FieldErrors } from "./validation/types";
+/**
+ * Takes the errors from a `Validator` and returns a `Response`.
+ * The `ValidatedForm` on the frontend will automatically display the errors
+ * if this is returned from the action.
+ */
 export declare const validationError: (errors: FieldErrors) => Response;

package/browser/server.js

@@ -1,2 +1,7 @@
 import { json } from "@remix-run/server-runtime";
+/**
+ * Takes the errors from a `Validator` and returns a `Response`.
+ * The `ValidatedForm` on the frontend will automatically display the errors
+ * if this is returned from the action.
+ */
 export const validationError = (errors) => json({ fieldErrors: errors }, { status: 422 });

package/browser/test-data/testFormData.d.ts

@@ -0,0 +1,15 @@
+export declare class TestFormData implements FormData {
+    private _params;
+    constructor(body?: string);
+    append(name: string, value: string | Blob, fileName?: string): void;
+    delete(name: string): void;
+    get(name: string): FormDataEntryValue | null;
+    getAll(name: string): FormDataEntryValue[];
+    has(name: string): boolean;
+    set(name: string, value: string | Blob, fileName?: string): void;
+    forEach(callbackfn: (value: FormDataEntryValue, key: string, parent: FormData) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, FormDataEntryValue]>;
+    keys(): IterableIterator<string>;
+    values(): IterableIterator<FormDataEntryValue>;
+    [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+}

package/browser/test-data/testFormData.js

@@ -0,0 +1,46 @@
+// Copied from remix to use in tests
+// https://github.com/remix-run/remix/blob/a69a631cb5add72d5fb24211ab2a0be367b6f2fd/packages/remix-node/form-data.ts
+export class TestFormData {
+    constructor(body) {
+        this._params = new URLSearchParams(body);
+    }
+    append(name, value, fileName) {
+        if (typeof value !== "string") {
+            throw new Error("formData.append can only accept a string");
+        }
+        this._params.append(name, value);
+    }
+    delete(name) {
+        this._params.delete(name);
+    }
+    get(name) {
+        return this._params.get(name);
+    }
+    getAll(name) {
+        return this._params.getAll(name);
+    }
+    has(name) {
+        return this._params.has(name);
+    }
+    set(name, value, fileName) {
+        if (typeof value !== "string") {
+            throw new Error("formData.set can only accept a string");
+        }
+        this._params.set(name, value);
+    }
+    forEach(callbackfn, thisArg) {
+        this._params.forEach(callbackfn, thisArg);
+    }
+    entries() {
+        return this._params.entries();
+    }
+    keys() {
+        return this._params.keys();
+    }
+    values() {
+        return this._params.values();
+    }
+    *[Symbol.iterator]() {
+        yield* this._params;
+    }
+}

package/browser/validation/createValidator.d.ts

@@ -1,3 +1,7 @@
 import { Validator } from "..";
-/** Handles data manipulation such us flattening the data to send to the validator */
+/**
+ * Used to create a validator for a form.
+ * It provides built-in handling for unflattening nested objects and
+ * extracting the values from FormData.
+ */
 export declare function createValidator<T>(validator: Validator<T>): Validator<T>;

package/browser/validation/createValidator.js

@@ -1,8 +1,19 @@
-import { unflatten } from "../flatten";
-/** Handles data manipulation such us flattening the data to send to the validator */
+import { objectFromPathEntries } from "../internal/flatten";
+const preprocessFormData = (data) => {
+    // A slightly janky way of determining if the data is a FormData object
+    // since node doesn't really have FormData
+    if ("entries" in data && typeof data.entries === "function")
+        return objectFromPathEntries([...data.entries()]);
+    return objectFromPathEntries(Object.entries(data));
+};
+/**
+ * Used to create a validator for a form.
+ * It provides built-in handling for unflattening nested objects and
+ * extracting the values from FormData.
+ */
 export function createValidator(validator) {
     return {
-        validate: (value) => validator.validate(unflatten(value)),
-        validateField: (data, field) => validator.validateField(unflatten(data), field),
+        validate: (value) => validator.validate(preprocessFormData(value)),
+        validateField: (data, field) => validator.validateField(preprocessFormData(data), field),
     };
 }

package/browser/validation/types.d.ts

@@ -2,6 +2,9 @@ export declare type FieldErrors = Record<string, string>;
 export declare type GenericObject = {
     [key: string]: any;
 };
+/**
+ * The result when validating a form.
+ */
 export declare type ValidationResult<DataType> = {
     data: DataType;
     error: undefined;
@@ -9,9 +12,15 @@ export declare type ValidationResult<DataType> = {
     error: FieldErrors;
     data: undefined;
 };
+/**
+ * The result when validating an individual field in a form.
+ */
 export declare type ValidateFieldResult = {
     error?: string;
 };
+/**
+ * A `Validator` can be passed to the `validator` prop of a `ValidatedForm`.
+ */
 export declare type Validator<DataType> = {
     validate: (unvalidatedData: GenericObject) => ValidationResult<DataType>;
     validateField: (unvalidatedData: GenericObject, field: string) => ValidateFieldResult;

package/browser/validation/validation.test.js

@@ -1,6 +1,7 @@
 import * as yup from "yup";
 import { z } from "zod";
 import { withYup } from "..";
+import { TestFormData } from "../test-data/testFormData";
 import { withZod } from "./withZod";
 const validationTestCases = [
     {
@@ -80,6 +81,70 @@ describe("Validation", () => {
                     },
                 });
             });
+            it("should unflatten data when validating", () => {
+                const data = {
+                    firstName: "John",
+                    lastName: "Doe",
+                    age: 30,
+                    "address.streetAddress": "123 Main St",
+                    "address.city": "Anytown",
+                    "address.country": "USA",
+                    "pets[0].animal": "dog",
+                    "pets[0].name": "Fido",
+                };
+                expect(validator.validate(data)).toEqual({
+                    data: {
+                        firstName: "John",
+                        lastName: "Doe",
+                        age: 30,
+                        address: {
+                            streetAddress: "123 Main St",
+                            city: "Anytown",
+                            country: "USA",
+                        },
+                        pets: [{ animal: "dog", name: "Fido" }],
+                    },
+                    error: undefined,
+                });
+            });
+            it("should accept FormData directly and return errors", () => {
+                const formData = new TestFormData();
+                formData.set("firstName", "John");
+                formData.set("lastName", "Doe");
+                formData.set("address.streetAddress", "123 Main St");
+                formData.set("address.country", "USA");
+                formData.set("pets[0].animal", "dog");
+                expect(validator.validate(formData)).toEqual({
+                    data: undefined,
+                    error: {
+                        "address.city": anyString,
+                        "pets[0].name": anyString,
+                    },
+                });
+            });
+            it("should accept FormData directly and return valid data", () => {
+                const formData = new TestFormData();
+                formData.set("firstName", "John");
+                formData.set("lastName", "Doe");
+                formData.set("address.streetAddress", "123 Main St");
+                formData.set("address.country", "USA");
+                formData.set("address.city", "Anytown");
+                formData.set("pets[0].animal", "dog");
+                formData.set("pets[0].name", "Fido");
+                expect(validator.validate(formData)).toEqual({
+                    data: {
+                        firstName: "John",
+                        lastName: "Doe",
+                        address: {
+                            streetAddress: "123 Main St",
+                            country: "USA",
+                            city: "Anytown",
+                        },
+                        pets: [{ animal: "dog", name: "Fido" }],
+                    },
+                    error: undefined,
+                });
+            });
         });
         describe("validateField", () => {
             it("should not return an error if field is valid", () => {

package/browser/validation/withYup.d.ts

@@ -1,3 +1,6 @@
 import type { AnyObjectSchema, InferType } from "yup";
 import { Validator } from "./types";
+/**
+ * Create a `Validator` using a `yup` schema.
+ */
 export declare const withYup: <Schema extends AnyObjectSchema>(validationSchema: Schema) => Validator<InferType<Schema>>;

package/browser/validation/withYup.js

@@ -8,6 +8,9 @@ const validationErrorToFieldErrors = (error) => {
     });
     return fieldErrors;
 };
+/**
+ * Create a `Validator` using a `yup` schema.
+ */
 export const withYup = (validationSchema) => {
     return createValidator({
         validate: (data) => {

package/browser/validation/withZod.d.ts

@@ -1,3 +1,6 @@
 import type { z } from "zod";
 import { Validator } from "..";
+/**
+ * Create a validator using a `zod` schema.
+ */
 export declare function withZod<T>(zodSchema: z.Schema<T>): Validator<T>;

package/browser/validation/withZod.js

@@ -17,6 +17,9 @@ function pathToString(array) {
         return string + (isNaN(Number(item)) ? prefix + item : "[" + item + "]");
     }, "");
 }
+/**
+ * Create a validator using a `zod` schema.
+ */
 export function withZod(zodSchema) {
     return createValidator({
         validate: (value) => {

package/build/ValidatedForm.d.ts

@@ -2,10 +2,32 @@ import { Form as RemixForm, useFetcher } from "@remix-run/react";
 import React, { ComponentProps } from "react";
 import { Validator } from "./validation/types";
 export declare type FormProps<DataType> = {
+    /**
+     * A `Validator` object that describes how to validate the form.
+     */
     validator: Validator<DataType>;
+    /**
+     * A submit callback that gets called when the form is submitted
+     * after all validations have been run.
+     */
     onSubmit?: (data: DataType, event: React.FormEvent<HTMLFormElement>) => void;
+    /**
+     * Allows you to provide a `fetcher` from remix's `useFetcher` hook.
+     * The form will use the fetcher for loading states, action data, etc
+     * instead of the default form action.
+     */
     fetcher?: ReturnType<typeof useFetcher>;
+    /**
+     * Accepts an object of default values for the form
+     * that will automatically be propagated to the form fields via `useField`.
+     */
     defaultValues?: Partial<DataType>;
+    /**
+     * A ref to the form element.
+     */
     formRef?: React.RefObject<HTMLFormElement>;
 } & Omit<ComponentProps<typeof RemixForm>, "onSubmit">;
+/**
+ * The primary form component of `remix-validated-form`.
+ */
 export declare function ValidatedForm<DataType>({ validator, onSubmit, children, fetcher, action, defaultValues, formRef: formRefProp, ...rest }: FormProps<DataType>): JSX.Element;

package/build/ValidatedForm.js

@@ -29,7 +29,10 @@ const useIsSubmitting = (action, fetcher) => {
         : pendingFormSubmit &&
             pendingFormSubmit.action === (action !== null && action !== void 0 ? action : actionForCurrentPage);
 };
-const getDataFromForm = (el) => Object.fromEntries(new FormData(el));
+const getDataFromForm = (el) => new FormData(el);
+/**
+ * The primary form component of `remix-validated-form`.
+ */
 function ValidatedForm({ validator, onSubmit, children, fetcher, action, defaultValues, formRef: formRefProp, ...rest }) {
     var _a;
     const [fieldErrors, setFieldErrors] = useFieldErrors(fetcher);

package/build/hooks.d.ts

@@ -1,8 +1,33 @@
-export declare const useField: (name: string) => {
-    error: string;
+export declare type FieldProps = {
+    /**
+     * The validation error message if there is one.
+     */
+    error?: string;
+    /**
+     * Clears the error message.
+     */
     clearError: () => void;
+    /**
+     * Validates the field.
+     */
     validate: () => void;
-    defaultValue: any;
+    /**
+     * The default value of the field, if there is one.
+     */
+    defaultValue?: any;
 };
+/**
+ * Provides the data and helpers necessary to set up a field.
+ */
+export declare const useField: (name: string) => FieldProps;
+/**
+ * Provides access to the entire form context.
+ * This is not usually necessary, but can be useful for advanced use cases.
+ */
 export declare const useFormContext: () => import("./internal/formContext").FormContextValue;
+/**
+ * Returns whether or not the parent form is currently being submitted.
+ * This is different from remix's `useTransition().submission` in that it
+ * is aware of what form it's in and when _that_ form is being submitted.
+ */
 export declare const useIsSubmitting: () => boolean;

package/build/hooks.js

@@ -8,6 +8,9 @@ const get_1 = __importDefault(require("lodash/get"));
 const toPath_1 = __importDefault(require("lodash/toPath"));
 const react_1 = require("react");
 const formContext_1 = require("./internal/formContext");
+/**
+ * Provides the data and helpers necessary to set up a field.
+ */
 const useField = (name) => {
     const { fieldErrors, clearError, validateField, defaultValues } = (0, react_1.useContext)(formContext_1.FormContext);
     const field = (0, react_1.useMemo)(() => ({
@@ -23,8 +26,16 @@ const useField = (name) => {
     return field;
 };
 exports.useField = useField;
-// test commit
+/**
+ * Provides access to the entire form context.
+ * This is not usually necessary, but can be useful for advanced use cases.
+ */
 const useFormContext = () => (0, react_1.useContext)(formContext_1.FormContext);
 exports.useFormContext = useFormContext;
+/**
+ * Returns whether or not the parent form is currently being submitted.
+ * This is different from remix's `useTransition().submission` in that it
+ * is aware of what form it's in and when _that_ form is being submitted.
+ */
 const useIsSubmitting = () => (0, exports.useFormContext)().isSubmitting;
 exports.useIsSubmitting = useIsSubmitting;

package/build/index.d.ts

@@ -4,3 +4,5 @@ export * from "./ValidatedForm";
 export * from "./validation/types";
 export * from "./validation/withYup";
 export * from "./validation/withZod";
+export * from "./validation/createValidator";
+export type { FormContextValue } from "./internal/formContext";

package/build/index.js

@@ -16,3 +16,4 @@ __exportStar(require("./ValidatedForm"), exports);
 __exportStar(require("./validation/types"), exports);
 __exportStar(require("./validation/withYup"), exports);
 __exportStar(require("./validation/withZod"), exports);
+__exportStar(require("./validation/createValidator"), exports);

package/build/{flatten.d.ts → internal/flatten.d.ts}

@@ -1,5 +1,4 @@
-import { GenericObject } from ".";
-/** Unflatten a previously flatten object */
-export declare function unflatten(params: GenericObject): {};
+import { GenericObject } from "..";
+export declare const objectFromPathEntries: (entries: [string, any][]) => {};
 /** Flatten an object so there are no nested objects or arrays */
 export declare function flatten(obj: GenericObject, preserveEmpty?: boolean): GenericObject;

package/build/{flatten.js → internal/flatten.js}

@@ -3,23 +3,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flatten = exports.unflatten = void 0;
-// `flatten` and `unflatten` are taken from https://github.com/richie5um/FlattenJS. Decided to implement them here instead of using that package because this is a core functionality of the library and this will add more flexibility in case we need to change the implementation.
+exports.flatten = exports.objectFromPathEntries = void 0;
+// `flatten` is taken from https://github.com/richie5um/FlattenJS. Decided to implement them here instead of using that package because this is a core functionality of the library and this will add more flexibility in case we need to change the implementation.
 const assign_1 = __importDefault(require("lodash/assign"));
 const isArray_1 = __importDefault(require("lodash/isArray"));
 const isObject_1 = __importDefault(require("lodash/isObject"));
 const keys_1 = __importDefault(require("lodash/keys"));
 const mapKeys_1 = __importDefault(require("lodash/mapKeys"));
-const reduce_1 = __importDefault(require("lodash/reduce"));
 const set_1 = __importDefault(require("lodash/set"));
 const transform_1 = __importDefault(require("lodash/transform"));
-/** Unflatten a previously flatten object */
-function unflatten(params) {
-    return (0, reduce_1.default)(params, function (result, value, key) {
-        return (0, set_1.default)(result, key, value);
-    }, {});
-}
-exports.unflatten = unflatten;
+const objectFromPathEntries = (entries) => entries.reduce((acc, [key, value]) => (0, set_1.default)(acc, key, value), {});
+exports.objectFromPathEntries = objectFromPathEntries;
 /** Flatten an object so there are no nested objects or arrays */
 function flatten(obj, preserveEmpty = false) {
     return (0, transform_1.default)(obj, function (result, value, key) {