@cedarjs/forms 0.0.4

package/dist/coercion.js

@@ -0,0 +1,178 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var coercion_exports = {};
+__export(coercion_exports, {
+  setCoercion: () => setCoercion
+});
+module.exports = __toCommonJS(coercion_exports);
+const isValueEmpty = (val) => val === "";
+const SET_VALUE_AS_FUNCTIONS = {
+  // valueAsBoolean is commented out as r-h-f does not currently support
+  // setValueAs functionality for checkboxes.  May investigate future
+  // integration
+  /*  valueAsBoolean: {
+    // r-h-f returns a boolean if a checkBox type, but also handle string case in case valueAsBoolean is used
+    base: (val: boolean | string): boolean => !!val,
+    emptyAsNull: (val: boolean | string): boolean | null => (val ? true : null),
+    emptyAsUndefined: (val: boolean | string): boolean | undefined =>
+      val ? true : undefined,
+  },*/
+  valueAsDate: {
+    emptyAsNull: (val) => isValueEmpty(val) ? null : new Date(val),
+    emptyAsUndefined: (val) => isValueEmpty(val) ? void 0 : new Date(val),
+    emptyAsString: (val) => isValueEmpty(val) ? "" : new Date(val),
+    emptyAsZero: (val) => isValueEmpty(val) ? 0 : new Date(val)
+  },
+  valueAsJSON: {
+    emptyAsNull: (val) => {
+      if (isValueEmpty(val)) {
+        return null;
+      }
+      try {
+        return JSON.parse(val);
+      } catch {
+        return NaN;
+      }
+    },
+    emptyAsString: (val) => {
+      if (isValueEmpty(val)) {
+        return "";
+      }
+      try {
+        return JSON.parse(val);
+      } catch {
+        return NaN;
+      }
+    },
+    emptyAsUndefined: (val) => {
+      if (isValueEmpty(val)) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(val);
+      } catch {
+        return NaN;
+      }
+    },
+    emptyAsZero: (val) => {
+      if (isValueEmpty(val)) {
+        return 0;
+      }
+      try {
+        return JSON.parse(val);
+      } catch {
+        return NaN;
+      }
+    }
+  },
+  valueAsNumber: {
+    emptyAsNull: (val) => isValueEmpty(val) ? null : +val,
+    emptyAsUndefined: (val) => isValueEmpty(val) ? void 0 : +val,
+    emptyAsNaN: (val) => isValueEmpty(val) ? NaN : +val,
+    emptyAsString: (val) => isValueEmpty(val) ? "" : +val,
+    emptyAsZero: (val) => isValueEmpty(val) ? 0 : +val
+  },
+  valueAsString: {
+    emptyAsNull: (val) => isValueEmpty(val) ? null : val,
+    emptyAsUndefined: (val) => isValueEmpty(val) ? void 0 : val,
+    emptyAsString: (val) => isValueEmpty(val) ? "" : val,
+    emptyAsZero: (val) => isValueEmpty(val) ? 0 : val
+  }
+};
+const getSetValueAsFn = (type, emptyAs, required, isId) => {
+  const typeObj = SET_VALUE_AS_FUNCTIONS[type];
+  if (typeObj === void 0) {
+    throw Error(`Type ${type} is unsupported.`);
+  }
+  let fn;
+  switch (emptyAs) {
+    case null:
+      fn = typeObj["emptyAsNull"];
+      break;
+    case "undefined":
+      fn = typeObj["emptyAsUndefined"];
+      break;
+    case 0:
+      fn = typeObj["emptyAsZero"];
+      break;
+    case "":
+      fn = typeObj["emptyAsString"];
+      break;
+    case void 0:
+    default:
+      if (required || isId) {
+        fn = typeObj.emptyAsNull;
+      } else {
+        switch (type) {
+          case "valueAsNumber":
+            fn = typeObj.emptyAsNaN;
+            break;
+          case "valueAsDate":
+          case "valueAsJSON":
+            fn = typeObj.emptyAsNull;
+            break;
+          case "valueAsString":
+            fn = typeObj.emptyAsString;
+            break;
+        }
+      }
+      break;
+  }
+  if (fn === void 0) {
+    console.error(`emptyAs prop of ${emptyAs} is unsupported for this type.`);
+  }
+  return fn;
+};
+const JSONValidation = (val) => typeof val === "number" ? !isNaN(val) : true;
+const setCoercion = (validation, { type, name, emptyAs }) => {
+  if (validation.setValueAs) {
+    return;
+  }
+  let valueAs;
+  if (validation.valueAsBoolean || type === "checkbox") {
+    return;
+  } else if (validation.valueAsJSON) {
+    validation.validate = JSONValidation;
+    delete validation.valueAsJSON;
+    valueAs = "valueAsJSON";
+  } else if (type === "date" || type === "datetime-local" || validation.valueAsDate) {
+    valueAs = "valueAsDate";
+  } else if (type === "number" || validation.valueAsNumber) {
+    valueAs = "valueAsNumber";
+    if (validation.valueAsNumber && emptyAs !== void 0) {
+      delete validation.valueAsNumber;
+    }
+  } else {
+    valueAs = "valueAsString";
+  }
+  validation.setValueAs = getSetValueAsFn(
+    valueAs,
+    // type
+    emptyAs,
+    // emptyAs
+    validation.required !== void 0 && validation.required !== false,
+    // required
+    (name || "").endsWith("Id")
+    // isId
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setCoercion
+});

package/dist/index.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @module @cedarjs/forms
+ *
+ * Redwood's form library.
+ * Mostly simple wrappers around `react-hook-form` that make it even easier to use.
+ *
+ * @remarks
+ *
+ * @cedarjs/forms slightly extends `react-hook-form`'s `valueAs` props because it's important for us to coerce values
+ * to the correct type for GraphQL.
+ * The properties that are exclusive to Redwood are:
+ * - `valueAsBoolean`
+ * - `valueAsJSON`
+ * - `emptyAs`
+ *
+ * @see {@link https://react-hook-form.com/}
+ *
+ * @remarks
+ *
+ * We make all of `react-hook-form`'s exports available as well.
+ *
+ * @privateRemarks
+ *
+ * The two main hooks in this library are:
+ * - `useErrorStyles`
+ * - `useRegister`
+ *
+ * `useErrorStyles` implements the error-specific styling via `useEffect`.
+ *
+ * `useRegister` hooks fields up to `react-hook-form` while providing some sensible defaults
+ * based on the field's type.
+
+ * @privateRemarks
+ *
+ * We use `React.ComponentPropsWithRef` and `React.ComponentPropsWithoutRef` instead of `React.FC`
+ * because the community seems to be shifting away from `React.FC`.
+ *
+ * @see {@link https://fettblog.eu/typescript-react-why-i-dont-use-react-fc/}
+ * @see {@link https://github.com/facebook/create-react-app/pull/8177}
+ * @see {@link https://react-typescript-cheatsheet.netlify.app/docs/basic/getting-started/function_components/}
+ *
+ * @privateRemarks
+ *
+ * As for interfaces vs types, we're going with TypesScript's recommendation to use interfaces until types are needed.
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#differences-between-type-aliases-and-interfaces}
+ */
+export * from 'react-hook-form';
+export { CheckboxField } from './CheckboxField';
+export type { EmptyAsValue, RedwoodRegisterOptions } from './coercion';
+export { FieldError } from './FieldError';
+export { Form, FormProps } from './Form';
+export { default as FormError } from './FormError';
+export type { ServerError, RWGqlError, ServerParseError } from './FormError';
+export { InputField, ButtonField, ColorField, DateField, DatetimeLocalField, EmailField, FileField, HiddenField, ImageField, MonthField, NumberField, PasswordField, RadioField, RangeField, ResetField, SearchField, SubmitField, TelField, TextField, TimeField, UrlField, WeekField, } from './InputComponents';
+export type { InputFieldProps } from './InputComponents';
+export { Label } from './Label';
+export { SelectField } from './SelectField';
+export { ServerErrorsContext } from './ServerErrorsContext';
+export { Submit } from './Submit';
+export { TextAreaField } from './TextAreaField';
+export { useErrorStyles } from './useErrorStyles';
+export { useRegister } from './useRegister';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,cAAc,iBAAiB,CAAA;AAE/B,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,YAAY,EAAE,YAAY,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AACtE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AACzC,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AACxC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,aAAa,CAAA;AAClD,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAC5E,OAAO,EACL,UAAU,EACV,WAAW,EACX,UAAU,EACV,SAAS,EACT,kBAAkB,EAClB,UAAU,EACV,SAAS,EACT,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,aAAa,EACb,UAAU,EACV,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACX,QAAQ,EACR,SAAS,EACT,SAAS,EACT,QAAQ,EACR,SAAS,GACV,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAC/B,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACjC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC/C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA"}

package/dist/index.js

@@ -0,0 +1,118 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  ButtonField: () => import_InputComponents.ButtonField,
+  CheckboxField: () => import_CheckboxField.CheckboxField,
+  ColorField: () => import_InputComponents.ColorField,
+  DateField: () => import_InputComponents.DateField,
+  DatetimeLocalField: () => import_InputComponents.DatetimeLocalField,
+  EmailField: () => import_InputComponents.EmailField,
+  FieldError: () => import_FieldError.FieldError,
+  FileField: () => import_InputComponents.FileField,
+  Form: () => import_Form.Form,
+  FormError: () => import_FormError.default,
+  FormProps: () => import_Form.FormProps,
+  HiddenField: () => import_InputComponents.HiddenField,
+  ImageField: () => import_InputComponents.ImageField,
+  InputField: () => import_InputComponents.InputField,
+  Label: () => import_Label.Label,
+  MonthField: () => import_InputComponents.MonthField,
+  NumberField: () => import_InputComponents.NumberField,
+  PasswordField: () => import_InputComponents.PasswordField,
+  RadioField: () => import_InputComponents.RadioField,
+  RangeField: () => import_InputComponents.RangeField,
+  ResetField: () => import_InputComponents.ResetField,
+  SearchField: () => import_InputComponents.SearchField,
+  SelectField: () => import_SelectField.SelectField,
+  ServerErrorsContext: () => import_ServerErrorsContext.ServerErrorsContext,
+  Submit: () => import_Submit.Submit,
+  SubmitField: () => import_InputComponents.SubmitField,
+  TelField: () => import_InputComponents.TelField,
+  TextAreaField: () => import_TextAreaField.TextAreaField,
+  TextField: () => import_InputComponents.TextField,
+  TimeField: () => import_InputComponents.TimeField,
+  UrlField: () => import_InputComponents.UrlField,
+  WeekField: () => import_InputComponents.WeekField,
+  useErrorStyles: () => import_useErrorStyles.useErrorStyles,
+  useRegister: () => import_useRegister.useRegister
+});
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, require("react-hook-form"), module.exports);
+var import_CheckboxField = require("./CheckboxField");
+var import_FieldError = require("./FieldError");
+var import_Form = require("./Form");
+var import_FormError = __toESM(require("./FormError"));
+var import_InputComponents = require("./InputComponents");
+var import_Label = require("./Label");
+var import_SelectField = require("./SelectField");
+var import_ServerErrorsContext = require("./ServerErrorsContext");
+var import_Submit = require("./Submit");
+var import_TextAreaField = require("./TextAreaField");
+var import_useErrorStyles = require("./useErrorStyles");
+var import_useRegister = require("./useRegister");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ButtonField,
+  CheckboxField,
+  ColorField,
+  DateField,
+  DatetimeLocalField,
+  EmailField,
+  FieldError,
+  FileField,
+  Form,
+  FormError,
+  FormProps,
+  HiddenField,
+  ImageField,
+  InputField,
+  Label,
+  MonthField,
+  NumberField,
+  PasswordField,
+  RadioField,
+  RangeField,
+  ResetField,
+  SearchField,
+  SelectField,
+  ServerErrorsContext,
+  Submit,
+  SubmitField,
+  TelField,
+  TextAreaField,
+  TextField,
+  TimeField,
+  UrlField,
+  WeekField,
+  useErrorStyles,
+  useRegister,
+  ...require("react-hook-form")
+});

package/dist/useErrorStyles.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import type { FieldProps } from './FieldProps';
+export type UseErrorStylesProps = Pick<FieldProps, 'name' | 'errorClassName' | 'errorStyle' | 'className' | 'style'>;
+/**
+ * Adds styling to a field when an error is present.
+ *
+ * @remarks
+ *
+ * Mostly just a `useEffect` hook.
+ *
+ * `className` and `style` get swapped with `errorClassName` and `errorStyle` respectively
+ * when an error's present (on the server or otherwise).
+ */
+export declare const useErrorStyles: ({ name, errorClassName, errorStyle, className, style, }: UseErrorStylesProps) => {
+    className: string | undefined;
+    style: React.CSSProperties | undefined;
+};
+//# sourceMappingURL=useErrorStyles.d.ts.map

package/dist/useErrorStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useErrorStyles.d.ts","sourceRoot":"","sources":["../src/useErrorStyles.ts"],"names":[],"mappings":"AAAA,OAAO,KAAqB,MAAM,OAAO,CAAA;AAIzC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,MAAM,MAAM,mBAAmB,GAAG,IAAI,CACpC,UAAU,EACV,MAAM,GAAG,gBAAgB,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CACjE,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,4DAMxB,mBAAmB;;;CA2BrB,CAAA"}

package/dist/useErrorStyles.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useErrorStyles_exports = {};
+__export(useErrorStyles_exports, {
+  useErrorStyles: () => useErrorStyles
+});
+module.exports = __toCommonJS(useErrorStyles_exports);
+var import_react = __toESM(require("react"));
+var import_react_hook_form = require("react-hook-form");
+var import_ServerErrorsContext = require("./ServerErrorsContext");
+const useErrorStyles = ({
+  name,
+  errorClassName,
+  errorStyle,
+  className,
+  style
+}) => {
+  const {
+    formState: { errors },
+    setError
+  } = (0, import_react_hook_form.useFormContext)();
+  const serverError = (0, import_react.useContext)(import_ServerErrorsContext.ServerErrorsContext)[name];
+  import_react.default.useEffect(() => {
+    if (serverError) {
+      setError(name, { type: "server", message: serverError });
+    }
+  }, [serverError, name, setError]);
+  const validationError = name ? (0, import_react_hook_form.get)(errors, name) : void 0;
+  if (validationError) {
+    if (errorClassName) {
+      className = errorClassName;
+    }
+    if (errorStyle) {
+      style = errorStyle;
+    }
+  }
+  return { className, style };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useErrorStyles
+});

package/dist/useRegister.d.ts

@@ -0,0 +1,32 @@
+import type React from 'react';
+import type { EmptyAsValue } from './coercion';
+import type { FieldProps } from './FieldProps';
+export type UseRegisterProps<Element extends HTMLTextAreaElement | HTMLSelectElement | HTMLInputElement = HTMLInputElement> = Pick<FieldProps<Element>, 'name' | 'validation' | 'type' | 'onBlur' | 'onChange'>;
+/**
+ * useRegister
+ *
+ * Register the field into `react-hook-form` with defaults.
+ *
+ * @remarks
+ *
+ * A field's `validation` prop is `react-hook-form`'s `RegisterOptions`
+ * (with Redwood's extended `valueAs` props).
+ *
+ * @see {@link https://react-hook-form.com/api/useform/register}
+ */
+export declare const useRegister: <T, Element extends HTMLTextAreaElement | HTMLSelectElement | HTMLInputElement = HTMLInputElement>(props: UseRegisterProps<Element> & {
+    element?: string;
+}, ref?: React.ForwardedRef<T>, emptyAs?: EmptyAsValue) => {
+    ref: (element: T) => void;
+    onBlur: React.FocusEventHandler<Element>;
+    onChange: React.ChangeEventHandler<Element>;
+    name: string;
+    min?: string | number;
+    max?: string | number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    required?: boolean;
+    disabled?: boolean;
+};
+//# sourceMappingURL=useRegister.d.ts.map

package/dist/useRegister.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRegister.d.ts","sourceRoot":"","sources":["../src/useRegister.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAE9C,MAAM,MAAM,gBAAgB,CAC1B,OAAO,SACH,mBAAmB,GACnB,iBAAiB,GACjB,gBAAgB,GAAG,gBAAgB,IACrC,IAAI,CACN,UAAU,CAAC,OAAO,CAAC,EACnB,MAAM,GAAG,YAAY,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CACvD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,GACtB,CAAC,EACD,OAAO,SACH,mBAAmB,GACnB,iBAAiB,GACjB,gBAAgB,4BAEb,gBAAgB,CAAC,OAAO,CAAC,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,QACjD,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC,YACjB,YAAY;mBAmCL,CAAC;;;;;;;;;;;CAYnB,CAAA"}

package/dist/useRegister.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var useRegister_exports = {};
+__export(useRegister_exports, {
+  useRegister: () => useRegister
+});
+module.exports = __toCommonJS(useRegister_exports);
+var import_react_hook_form = require("react-hook-form");
+var import_coercion = require("./coercion");
+const useRegister = (props, ref, emptyAs) => {
+  const { register } = (0, import_react_hook_form.useFormContext)();
+  const { name } = props;
+  if (!name) {
+    throw Error("`name` prop must be provided");
+  }
+  const validation = props.validation || { required: false };
+  (0, import_coercion.setCoercion)(validation, {
+    type: props.type,
+    name,
+    emptyAs
+  });
+  const {
+    ref: _ref,
+    onBlur: handleBlur,
+    onChange: handleChange,
+    ...rest
+  } = register(name, validation);
+  const onBlur = (event) => {
+    handleBlur(event);
+    props.onBlur?.(event);
+  };
+  const onChange = (event) => {
+    handleChange(event);
+    props.onChange?.(event);
+  };
+  return {
+    ...rest,
+    ref: (element) => {
+      _ref(element);
+      if (typeof ref === "function") {
+        ref(element);
+      } else if (ref) {
+        ref.current = element;
+      }
+    },
+    onBlur,
+    onChange
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useRegister
+});

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@cedarjs/forms",
+  "version": "0.0.4",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cedarjs/cedar.git",
+    "directory": "packages/forms"
+  },
+  "license": "MIT",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsx ./build.mts && yarn build:types",
+    "build:pack": "yarn pack -o cedar-forms.tgz",
+    "build:types": "tsc --build --verbose ./tsconfig.build.json",
+    "build:watch": "nodemon --watch src --ext \"js,jsx,ts,tsx\" --ignore dist --exec \"yarn build\"",
+    "check:attw": "yarn rw-fwtools-attw",
+    "check:package": "concurrently npm:check:attw yarn:publint",
+    "prepublishOnly": "NODE_ENV=production yarn build",
+    "test": "vitest run",
+    "test:watch": "vitest watch"
+  },
+  "dependencies": {
+    "graphql": "16.9.0",
+    "pascalcase": "1.0.0",
+    "react-hook-form": "7.54.2"
+  },
+  "devDependencies": {
+    "@cedarjs/framework-tools": "0.0.4",
+    "@testing-library/dom": "9.3.4",
+    "@testing-library/jest-dom": "6.5.0",
+    "@testing-library/react": "14.3.1",
+    "@testing-library/user-event": "14.5.2",
+    "@types/pascalcase": "1.0.3",
+    "@types/react": "^18.2.55",
+    "@types/react-dom": "^18.2.19",
+    "concurrently": "8.2.2",
+    "nodemon": "3.1.9",
+    "publint": "0.3.11",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "tsx": "4.19.3",
+    "typescript": "5.6.2",
+    "vitest": "2.1.9"
+  },
+  "peerDependencies": {
+    "react": "18.3.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5b4f77f985bd86ee31ee7338312627accf0cb85b"
+}