autoforma 1.0.55 → 1.0.56

package/README.md

@@ -1,157 +1,286 @@
-
-# AutoForm
-
-AutoForm is a dynamic form builder component for React applications, using **Mantine**. It generates forms dynamically based on a schema definition. This allows for faster form creation and less repetitive code when working with forms in your React applications.
-
-## Features
-
-- **Dynamic Form Rendering**: AutoForm renders fields based on the provided schema, making form generation easy.
-- **Field Types Support**: Supports various input types like `text`, `number`, `password`, `select`, `checkbox`, etc.
-- **Validation Support**: Integrates with form validation mechanisms.
-- **Custom Layout**: Supports custom layout rendering via the `container` and `fieldContainer` props.
-- **Read-Only Mode**: Option to set the form in read-only mode.
-- **Field Customization**: Easily customize field rendering for different input types.
-- **Conditional Rendering**: Hide fields or conditionally render based on certain conditions.
-
-## Installation
-
-To install `AutoForm`, you can use npm or yarn:
-
-```bash
-npm install @mantine/core react
-```
-
-## Usage
-
-### Example Usage
-
-```tsx
-import React from 'react';
-import AutoForm from './AutoForm';  // Path to your AutoForm component
-import { Button, Grid, Group } from '@mantine/core';
-
-const schema = [
-  { name: 'firstName', label: 'First Name', type: 'text' },
-  { name: 'age', label: 'Age', type: 'number' },
-  { name: 'subscribe', label: 'Subscribe?', type: 'checkbox' },
-  { name: 'role', label: 'Role', type: 'select', options: ['User', 'Admin'] },
-];
-
-const MyForm = () => {
-  const onSubmit = (values) => {
-    alert(JSON.stringify(values, null, 2));
-  };
-
-  return (
-    <AutoForm
-      schema={schema}
-      onSubmit={onSubmit}
-      container={(form, onSubmit, readOnly) => (
-        <>
-          <Grid>{form}</Grid>
-          {!readOnly && (
-            <Group justify="flex-end">
-              <Button onClick={onSubmit}>Submit</Button>
-            </Group>
-          )}
-        </>
-      )}
-    />
-  );
-};
-```
-
-### Props
-
-| Prop             | Type                                                                           | Description                                                                 |
-|------------------|--------------------------------------------------------------------------------|-----------------------------------------------------------------------------|
-| `schema`         | `FieldSchema[]`                                                                | List of field definitions to render. Each field specifies `name`, `type`, etc. |
-| `values`         | `Record<string, any>`                                                          | Initial values for the form fields. Optional.                              |
-| `onSubmit`       | `(values: Record<string, any>) => void`                                        | Callback triggered on form submission with current form values.            |
-| `container`      | `(form: ReactNode, onSubmit: () => void, readOnly?: true) => ReactNode`        | Custom render wrapper around the form and submit button.                   |
-| `fieldContainer` | `(field: ReactNode, fieldSchema: FieldSchema) => ReactNode`                    | Optional. Custom layout for each field (e.g., grid wrappers).              |
-| `customRender`   | `FieldRenderCustomRender`                                                      | Optional. Override how specific field types are rendered.                  |
-| `validate`       | `FormValidateInput<Record<string, any>>`                                       | Optional validation logic. Uses Mantine-compatible validation.             |
-| `readOnly`       | `true`                                                                         | Optional. When true, disables all inputs (read-only mode).                 |
-| `onFieldChange`  | `(name: string, value: any, values: Record<string, any>) => Record<string, any>` | Optional. Modify or transform values when a field changes.                 |
-
-### Custom Layout
-
-You can customize the layout of the entire form or specific fields by using the `container` and `fieldContainer` props.
-
-#### Example: Customizing the Form Layout
-
-```tsx
-const customLayout = (form, onSubmit, readOnly) => (
-  <>
-    <div className="form-container">{form}</div>
-    {!readOnly && <button onClick={onSubmit}>Submit</button>}
-  </>
-);
-```
-
-#### Example: Customizing Field Layout
-
-```tsx
-const customFieldLayout = (field, fieldSchema) => (
-  <div className="custom-field">{field}</div>
-);
-```
-
-### Validation
-
-AutoForm supports validation through the `validate` prop. You can pass a validation function that returns an object of validation errors.
-
-Example:
-
-```tsx
-const validateForm = (values) => {
-  const errors = {};
-  if (!values.firstName) errors.firstName = 'First name is required';
-  if (!values.age) errors.age = 'Age is required';
-  return errors;
-};
-
-<AutoForm
-  schema={schema}
-  validate={validateForm}
-  onSubmit={(values) => console.log(values)}
-  container={(form, onSubmit) => (
-    <>
-      <Grid>{form}</Grid>
-      <Button onClick={onSubmit}>Submit</Button>
-    </>
-  )}
-/>
-```
-
-### Hide Fields
-
-To hide a field from rendering, you can set the `hidden` property in the schema.
-
-Example:
-
-```tsx
-const schema = [
-  { name: 'firstName', label: 'First Name', type: 'text' },
-  { name: 'internalCode', label: 'Internal Code', type: 'text', hidden: true },
-];
-```
-
-This will ensure the "Internal Code" field is not rendered.
-
----
-
-## Contributing
-
-1. Fork the repository
-2. Create a new branch (`git checkout -b feature-branch`)
-3. Commit your changes (`git commit -am 'Add feature'`)
-4. Push to the branch (`git push origin feature-branch`)
-5. Create a new Pull Request
-
----
-
-## License
-
-Distributed under the MIT License. See `LICENSE` for more information.
+# 🚀 AutoForma
+
+**AutoForma** is a powerful and flexible **dynamic form builder** for React. It allows developers to build complex forms from simple schema definitions without writing repetitive boilerplate code. With AutoForma, you can focus on the logic and behavior of your forms — not the UI details.
+
+---
+
+## ✨ Features
+
+- ⚡ **Fast form building:** Generate forms instantly from JSON schema.
+- 🧩 **Rich field types:** Text, Select, Checkbox, Date, Time, Switch, Tags, Array, Object, and more.
+- 🎨 **Full UI control:** Customize how each field looks and behaves.
+- 🔄 **Dynamic behavior:** Show/hide fields, enable/disable them, or update their properties based on form values.
+- 🪄 **Custom renderers:** Replace any field’s renderer with your own component.
+- 🧠 **Validation support:** Built-in and custom validation supported out of the box.
+- 📐 **Multiple layouts:** Vertical, horizontal, or grid layouts.
+- 🧪 **Extendable:** Easily integrate with any backend and add your own field types.
+
+---
+
+## 📦 Installation
+
+Install AutoForma **and the exact peer dependencies** required for it to work properly:
+
+```bash
+npm install autoforma @mantine/core@^7.17.5 @mantine/hooks@^7.17.5 @mantine/form@^7.17.5 @mantine/dates@^7.17.5 @mantine/tiptap@^7.17.5 @tiptap/react@^3.6.6 react@^18.0.0 react-dom@^18.0.0
+```
+
+---
+
+## ⚙️ Requirements
+
+Before using `AutoForma`, make sure to wrap your application with `MantineProvider` and import Mantine's base styles:
+
+```tsx
+import { MantineProvider } from "@mantine/core";
+import "@mantine/core/styles.css";
+import "@mantine/dates/styles.css";
+import "@mantine/tiptap/styles.css";
+
+const Root = () => (
+  <MantineProvider>
+    <App />
+  </MantineProvider>
+);
+```
+
+> ✅ Without `MantineProvider`, the components might not render or style correctly.
+
+---
+
+## 🛠️ Usage
+
+Here's a complete example showing how to use **AutoForma** with a custom field type (`newText`):
+
+```tsx
+import { MantineProvider } from "@mantine/core";
+import "@mantine/core/styles.css";
+import "@mantine/dates/styles.css";
+import "@mantine/tiptap/styles.css";
+import ReactDOM from "react-dom/client";
+import AutoForm from "autoforma";
+import { FieldSchema } from "autoforma";
+
+interface DemoFormValues {
+  fullName: string;
+  email: string;
+  age: number;
+  subscribe: boolean;
+  birthDate: string | null;
+  appointment: string | null;
+  contacts: { type: string; value: string }[];
+  gender: string;
+  bio: string;
+}
+
+const schema: FieldSchema[] = [
+  {
+    name: "fullName",
+    label: "Full Name",
+    type: "newText",
+    placeholder: "Enter your full name",
+    required: true,
+  },
+  {
+    name: "age",
+    label: "Age",
+    type: "number",
+    placeholder: "Enter your age",
+  },
+  {
+    name: "gender",
+    label: "Gender",
+    type: "select",
+    placeholder: "Select your gender",
+    data: [
+      { label: "Male", value: "M" },
+      { label: "Female", value: "F" },
+      { label: "Prefer not to say", value: "N" },
+    ],
+  },
+  {
+    name: "subscribe",
+    label: "Subscribe to newsletter",
+    type: "checkbox",
+    description: "Receive updates by email",
+  },
+  {
+    name: "birthDate",
+    label: "Birth Date",
+    type: "date",
+    placeholder: "Pick your birth date",
+  },
+  {
+    name: "appointment",
+    label: "Appointment",
+    type: "datetime",
+    placeholder: "Select date and time",
+  },
+  {
+    name: "contacts",
+    label: "Contacts",
+    type: "array",
+    fields: [
+      {
+        name: "type",
+        label: "Contact Type",
+        type: "select",
+        data: [
+          { label: "Email", value: "email" },
+          { label: "Phone", value: "phone" },
+        ],
+      },
+      {
+        name: "value",
+        label: "Contact Value",
+        type: "text",
+      },
+    ],
+  },
+  {
+    name: "bio",
+    label: "Bio",
+    type: "text",
+    placeholder: "Tell us about yourself",
+  },
+];
+
+const App = () => {
+  return (
+    <AutoForm<DemoFormValues>
+      layout="grid"
+      schema={schema}
+      customFieldTypes={{
+        newText: (field, form) => (
+          <div>
+            <label htmlFor={field.name}>{field.label}</label>
+            <input {...form.getInputProps(field.name)} />
+          </div>
+        ),
+      }}
+      onSubmit={(values) => alert(JSON.stringify(values))}
+    />
+  );
+};
+
+ReactDOM.createRoot(document.getElementById("root")!).render(
+  <MantineProvider>
+    <App />
+  </MantineProvider>
+);
+```
+
+---
+
+## 🔧 Props / API Reference
+
+| Prop                    | Type                                         | Description                                               |
+| ----------------------- | -------------------------------------------- | --------------------------------------------------------- |
+| `schema`                | `FieldSchema[]`                              | The form schema definition.                               |
+| `values`                | `TValues`                                    | Initial form values.                                      |
+| `onSubmit`              | `(values: TValues) => void`                  | Callback triggered when the form is submitted.            |
+| `transformBeforeSubmit` | `(values: TValues) => TValues`               | Optional function to transform form values before submit. |
+| `transformAfterSubmit`  | `(values: TValues) => void \| Promise<void>` | Optional function called after form submission.           |
+| `validate`              | `FormValidateInput<TValues>`                 | Validation configuration.                                 |
+| `readOnly`              | `boolean`                                    | Makes the entire form read-only.                          |
+| `onFieldChange`         | `OnFieldChangeMap<TValues>`                  | Trigger callbacks when specific fields change.            |
+| `layout`                | `"vertical" \| "horizontal" \| "grid"`       | Form layout type.                                         |
+| `customFieldRenderers`  | `CustomRenderersMap<TValues>`                | Override default field renderers.                         |
+| `customFieldTypes`      | `CustomFieldTypes<TValues>`                  | Add new field types dynamically and render them.          |
+| `updateFieldSchema`     | `UpdateFieldSchemaMap<TValues>`              | Dynamically update field definitions based on values.     |
+| `submitButton`          | `boolean \| ReactNode`                       | Show or customize the submit button.                      |
+
+---
+
+## 🧩 Field Types
+
+AutoForma supports a variety of field types out-of-the-box:
+
+- `text`
+- `number`
+- `select`
+- `checkbox`
+- `date`
+- `datetime`
+- `time`
+- `object`
+- `array`
+- `switch`
+- `texteditor`
+- `tags`
+
+✅ **Plus any custom type** you add through `customFieldTypes`.
+
+---
+
+## ⚙️ Advanced Usage
+
+You can control the behavior of fields dynamically based on form values **and** extend the form with new field types:
+
+```tsx
+<AutoForm
+  schema={schema}
+  updateFieldSchema={{
+    gender: (field, values) => {
+      if (values.age && values.age < 18) {
+        return { ...field, data: [{ label: "Prefer not to say", value: "N" }] };
+      }
+      return field;
+    },
+    appointment: (field, values) => ({
+      ...field,
+      disabled: !values.birthDate,
+    }),
+  }}
+  customFieldTypes={{
+    newText: (field, form) => (
+      <div>
+        <label htmlFor={field.name}>{field.label}</label>
+        <input {...form.getInputProps(field.name)} />
+      </div>
+    ),
+  }}
+/>
+```
+
+✅ This gives you full power to:
+
+- Dynamically adjust schema behavior.
+- Inject custom field types without touching the library core.
+
+---
+
+## 🧪 Development
+
+If you want to contribute or run AutoForma locally:
+
+```bash
+git clone https://github.com/your-username/AutoForma.git
+cd AutoForma
+npm install
+npm run dev
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! 🎉  
+If you'd like to help improve AutoForma:
+
+1. Fork the repository
+2. Create a new feature branch
+3. Commit your changes
+4. Submit a pull request 🚀
+
+---
+
+## 📜 License
+
+This project is licensed under the **MIT License**.
+
+---
+
+## ⭐ Support
+
+If you find AutoForma helpful, please consider giving it a ⭐ on [GitHub](https://github.com/your-username/AutoForma) — it helps the project grow!

package/dist/components/AutoForm/AutoForm.d.ts

@@ -0,0 +1,17 @@
+import { AutoFormRef } from './AutoForm.types';
+export declare const AutoForm: import('react').ForwardRefExoticComponent<import('../../fields/renderer.types').CustomRenderersConfig<Record<string, any>> & {
+    schema: import('../..').FieldSchema<Record<string, any>>[];
+    values?: Partial<Record<string, any>> | undefined;
+    getInitialValues?: (() => Partial<Record<string, any>> | Promise<Partial<Record<string, any>>>) | undefined;
+    onSubmit: (values: Record<string, any>) => void | Promise<void>;
+    transformBeforeSubmit?: ((values: Record<string, any>) => Record<string, any> | Promise<Record<string, any>>) | undefined;
+    transformAfterSubmit?: ((values: Record<string, any>) => void | Promise<void>) | undefined;
+    validate?: import('@mantine/form').FormValidateInput<Record<string, any>> | undefined;
+    readOnly?: boolean;
+    onFieldChange?: import('./AutoForm.types').OnFieldChangeMap<Record<string, any>> | undefined;
+    layout?: "vertical" | "horizontal" | "grid";
+    updateFieldSchema?: import('./AutoForm.types').UpdateFieldSchemaMap<Record<string, any>> | undefined;
+    submitButton?: boolean | React.ReactNode;
+    loading?: boolean;
+} & import('react').RefAttributes<AutoFormRef<Record<string, any>>>>;
+export default AutoForm;

package/dist/components/AutoForm/AutoForm.types.d.ts

@@ -0,0 +1,35 @@
+import { CustomRenderersConfig } from '../../fields/renderer.types';
+import { FieldSchema } from '../../fields/types';
+import { FormValidateInput, UseFormReturnType } from '@mantine/form';
+export type AutoFormProps<TValues extends Record<string, any> = Record<string, any>> = CustomRenderersConfig<TValues> & {
+    schema: FieldSchema<TValues>[];
+    values?: Partial<TValues>;
+    getInitialValues?: () => Partial<TValues> | Promise<Partial<TValues>>;
+    onSubmit: (values: TValues) => void | Promise<void>;
+    transformBeforeSubmit?: (values: TValues) => TValues | Promise<TValues>;
+    transformAfterSubmit?: (values: TValues) => void | Promise<void>;
+    validate?: FormValidateInput<TValues>;
+    readOnly?: boolean;
+    onFieldChange?: OnFieldChangeMap<TValues>;
+    layout?: "vertical" | "horizontal" | "grid";
+    updateFieldSchema?: UpdateFieldSchemaMap<TValues>;
+    submitButton?: boolean | React.ReactNode;
+    loading?: boolean;
+};
+export type UpdateFieldSchemaMap<TValues extends Record<string, any> = Record<string, any>> = {
+    [K in keyof TValues]?: (schema: FieldSchema<TValues>, values: TValues) => FieldSchema<TValues>;
+};
+export type OnFieldChangeMap<TValues extends Record<string, any> = Record<string, any>> = {
+    [K in keyof TValues]?: (value: TValues[K], form: UseFormReturnType<TValues>) => void | Promise<void>;
+};
+export interface AutoFormRef<TValues extends Record<string, any> = Record<string, any>> {
+    submit: () => void;
+    reset: (values?: Partial<TValues>) => void;
+    validate: () => boolean;
+    getValues: () => TValues;
+    setValues: (values: Partial<TValues>) => void;
+    getFieldValue: (path: string) => any;
+    setFieldValue: (path: string, value: any) => void;
+    isValid: () => boolean;
+    isDirty: () => boolean;
+}

package/dist/fields/FieldRenderer/DefaultFieldRender.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from '../types';
+type DefaultFieldRenderProps<TValues extends Record<string, any>> = {
+    field: FieldSchema<TValues>;
+    form: UseFormReturnType<TValues>;
+    children: React.ReactNode;
+};
+export declare function DefaultFieldRender<TValues extends Record<string, any>>({ field, form, children, }: DefaultFieldRenderProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default DefaultFieldRender;

package/dist/fields/FieldRenderer/FieldLayoutWrapper.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+import { FieldSchema } from '../types';
+type FieldLayoutWrapperProps = {
+    field: FieldSchema;
+    layout: "vertical" | "horizontal" | "grid";
+    children: React.ReactNode;
+};
+export declare function FieldLayoutWrapper({ field, layout, children, }: FieldLayoutWrapperProps): import("react/jsx-runtime").JSX.Element;
+export default FieldLayoutWrapper;

package/dist/fields/FieldRenderer/FieldRenderer.d.ts

@@ -0,0 +1,3 @@
+import { FieldRendererProps } from './FieldRenderer.types';
+export declare function FieldRenderer<TValues extends Record<string, any> = Record<string, any>>(props: FieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default FieldRenderer;

package/dist/fields/FieldRenderer/FieldRenderer.types.d.ts

@@ -0,0 +1,7 @@
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from '../types';
+export interface FieldRendererProps<TValues extends Record<string, any> = Record<string, any>> {
+    field: FieldSchema<TValues>;
+    form: UseFormReturnType<TValues>;
+    layout?: "vertical" | "horizontal" | "grid";
+}

package/dist/fields/context/RenderersContext.d.ts

@@ -0,0 +1,7 @@
+import { CustomRenderersConfig } from '../renderer.types';
+export declare const RenderersContext: import('react').Context<CustomRenderersConfig<any> | null>;
+export declare const RenderersProvider: <TValues extends Record<string, any> = Record<string, any>>({ children, value, }: {
+    children: React.ReactNode;
+    value: CustomRenderersConfig<TValues>;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useRenderers: <TValues extends Record<string, any> = Record<string, any>>() => CustomRenderersConfig<TValues>;

package/dist/fields/handlers/BuiltInHandler.d.ts

@@ -0,0 +1,9 @@
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from '../types';
+import { RendererHandler } from './RendererHandler';
+export declare class BuiltInHandler<TValues extends Record<string, any>> extends RendererHandler<TValues> {
+    private layout;
+    constructor(layout: "vertical" | "horizontal" | "grid");
+    canHandle(): boolean;
+    render(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): import("react/jsx-runtime").JSX.Element;
+}

package/dist/fields/handlers/CustomTypeRendererResolver.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { RendererHandler } from './RendererHandler';
+import { FieldSchema } from '../types';
+import { UseFormReturnType } from '@mantine/form';
+export declare class CustomTypeRendererResolver<TValues extends Record<string, any>> extends RendererHandler<TValues> {
+    private customFieldTypes;
+    constructor(customFieldTypes: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>);
+    canHandle(field: FieldSchema<TValues>): boolean;
+    render(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): React.ReactNode;
+}

package/dist/fields/handlers/FieldNameHandler.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { RendererHandler } from './RendererHandler';
+import { FieldSchema } from '../types';
+import { UseFormReturnType } from '@mantine/form';
+export declare class FieldNameHandler<TValues extends Record<string, any>> extends RendererHandler<TValues> {
+    private fieldRenderers;
+    constructor(fieldRenderers: Record<string, (field: any, form: any) => React.ReactNode>);
+    canHandle(field: FieldSchema<TValues>): boolean;
+    render(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): React.ReactNode;
+}

package/dist/fields/handlers/FieldTypeHandler.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+import { RendererHandler } from './RendererHandler';
+import { FieldSchema } from '../types';
+import { UseFormReturnType } from '@mantine/form';
+export declare class FieldTypeHandler<TValues extends Record<string, any>> extends RendererHandler<TValues> {
+    private typeRenderers;
+    constructor(typeRenderers: Record<string, (field: any, form: any) => React.ReactNode>);
+    canHandle(field: FieldSchema<TValues>): boolean;
+    render(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): React.ReactNode;
+}

package/dist/fields/handlers/RendererHandler.d.ts

@@ -0,0 +1,10 @@
+import { FieldSchema } from '../types';
+import { UseFormReturnType } from '@mantine/form';
+import { default as React } from 'react';
+export declare abstract class RendererHandler<TValues extends Record<string, any>> {
+    private next?;
+    setNext(handler: RendererHandler<TValues>): RendererHandler<TValues>;
+    handle(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): React.ReactNode;
+    abstract canHandle(field: FieldSchema<TValues>): boolean;
+    abstract render(field: FieldSchema<TValues>, form: UseFormReturnType<TValues>): React.ReactNode;
+}

package/dist/fields/renderer.types.d.ts

@@ -0,0 +1,12 @@
+import { UseFormReturnType } from '@mantine/form';
+import { FieldSchema } from './types';
+export type FieldRendererResolverProps<TValues extends Record<string, any> = Record<string, any>> = CustomRenderersConfig<TValues> & {
+    field: FieldSchema<TValues>;
+    form: UseFormReturnType<TValues>;
+    layout?: "vertical" | "horizontal" | "grid";
+};
+export type CustomRenderersConfig<TValues extends Record<string, any> = Record<string, any>> = {
+    customFieldRenderers?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+    customTypeRenderers?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+    customFieldTypes?: Record<string, (field: FieldSchema<TValues>, form: UseFormReturnType<TValues>) => React.ReactNode>;
+};

package/dist/fields/renderers/ArrayFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type ArrayFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function ArrayFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form, layout }: ArrayFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default ArrayFieldRenderer;

package/dist/fields/renderers/CheckBoxFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type CheckBoxFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function CheckBoxFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: CheckBoxFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default CheckBoxFieldRenderer;

package/dist/fields/renderers/DateFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type DateFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function DateFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: DateFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default DateFieldRenderer;

package/dist/fields/renderers/DateTimeFieldRenderer.d.ts

@@ -0,0 +1,4 @@
+import { FieldRendererProps } from '../FieldRenderer/FieldRenderer.types';
+type DateTimeFieldRendererProps<TValues extends Record<string, any> = Record<string, any>> = FieldRendererProps<TValues>;
+export declare function DateTimeFieldRenderer<TValues extends Record<string, any> = Record<string, any>>({ field, form }: DateTimeFieldRendererProps<TValues>): import("react/jsx-runtime").JSX.Element;
+export default DateTimeFieldRenderer;