mtrl-addons 0.2.4 → 0.2.5

package/dist/components/form/config.d.ts

@@ -0,0 +1,49 @@
+import type { FormConfig, FormState, FormData } from "./types";
+import { FORM_DEFAULTS } from "./constants";
+export { FORM_DEFAULTS };
+/**
+ * Creates the base configuration with defaults applied
+ */
+export declare const createBaseConfig: (config?: FormConfig) => FormConfig;
+/**
+ * Creates the initial form state
+ */
+export declare const createInitialState: (config: FormConfig) => FormState;
+/**
+ * Gets the element configuration for withElement
+ */
+export declare const getElementConfig: (config: FormConfig) => {
+    tag: string;
+    className: string;
+    attributes: {
+        "data-component": string;
+    };
+};
+/**
+ * Extracts field name from a prefixed name (e.g., 'info.username' -> 'username')
+ */
+export declare const extractFieldName: (prefixedName: string) => string;
+/**
+ * Gets the full field path including prefix
+ */
+export declare const getFieldPath: (name: string, prefix?: string) => string;
+/**
+ * Checks if a name is a field name (starts with info. or data.)
+ */
+export declare const isFieldName: (name: string) => boolean;
+/**
+ * Checks if a name is a file field name
+ */
+export declare const isFileName: (name: string) => boolean;
+/**
+ * Deep comparison of two values for change detection
+ */
+export declare const isValueEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Checks if form data has been modified from initial state
+ */
+export declare const hasDataChanged: (initial: FormData, current: FormData) => boolean;
+/**
+ * Gets only the modified fields between initial and current data
+ */
+export declare const getModifiedFields: (initial: FormData, current: FormData) => FormData;

package/dist/components/form/constants.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Data state constants
+ * Tracks whether form data has been modified from initial state
+ */
+export declare const DATA_STATE: {
+    /** Data matches initial state - no changes made */
+    readonly PRISTINE: "pristine";
+    /** Data has been modified from initial state */
+    readonly DIRTY: "dirty";
+};
+/**
+ * Form event constants
+ */
+export declare const FORM_EVENTS: {
+    /** Fired when any field value changes */
+    readonly CHANGE: "change";
+    /** Fired when form is submitted */
+    readonly SUBMIT: "submit";
+    /** Fired when data state changes (pristine <-> dirty) */
+    readonly STATE_CHANGE: "state:change";
+    /** Fired when data is set on the form */
+    readonly DATA_SET: "data:set";
+    /** Fired when data is retrieved from the form */
+    readonly DATA_GET: "data:get";
+    /** Fired when a specific field changes */
+    readonly FIELD_CHANGE: "field:change";
+    /** Fired when validation fails */
+    readonly VALIDATION_ERROR: "validation:error";
+    /** Fired when submit succeeds */
+    readonly SUBMIT_SUCCESS: "submit:success";
+    /** Fired when submit fails */
+    readonly SUBMIT_ERROR: "submit:error";
+    /** Fired when form is reset to initial state */
+    readonly RESET: "reset";
+};
+/**
+ * Form CSS class modifiers
+ */
+export declare const FORM_CLASSES: {
+    /** Applied when data has been modified */
+    readonly MODIFIED: "modified";
+    /** Applied when form is submitting */
+    readonly SUBMITTING: "submitting";
+    /** Applied when form is disabled */
+    readonly DISABLED: "disabled";
+};
+/**
+ * Default form configuration
+ */
+export declare const FORM_DEFAULTS: {
+    readonly prefix: "mtrl";
+    readonly componentName: "form";
+    readonly tag: "div";
+    readonly formTag: "form";
+    readonly method: "POST";
+    readonly autocomplete: "off";
+    readonly useChanges: true;
+    readonly controls: readonly ["submit", "cancel"];
+};
+/**
+ * Field name prefixes used for extraction
+ */
+export declare const FIELD_PREFIXES: {
+    readonly INFO: "info.";
+    readonly FILE: "file.";
+    readonly DATA: "data.";
+};

package/dist/components/form/features/api.d.ts

@@ -0,0 +1,52 @@
+/**
+ * API feature for Form component
+ * Provides a clean, unified public API for the form
+ * Also wires up control button click handlers (submit/cancel)
+ */
+import type { FormConfig, BaseFormComponent, FormComponent, FormData, DataState, FormState, FormField, FormFieldRegistry, FormValidationResult, FormSubmitOptions, FieldValue } from "../types";
+/**
+ * Extended component interface before API is applied
+ */
+interface EnhancedFormComponent extends BaseFormComponent {
+    form: HTMLFormElement;
+    ui: Record<string, unknown>;
+    fields: FormFieldRegistry;
+    files: FormFieldRegistry;
+    state: FormState;
+    controls: Map<string, FormField>;
+    getData: () => FormData;
+    setData: (data: FormData, silent?: boolean) => void;
+    getFieldValue: (name: string) => FieldValue;
+    setFieldValue: (name: string, value: FieldValue, silent?: boolean) => void;
+    isModified: () => boolean;
+    getModifiedData: () => FormData;
+    snapshot: () => void;
+    reset: () => void;
+    clear: () => void;
+    getField: (name: string) => FormField | undefined;
+    getFieldNames: () => string[];
+    hasField: (name: string) => boolean;
+    getDataState: () => DataState;
+    enableControls: () => void;
+    disableControls: () => void;
+    enableFields: () => void;
+    disableFields: () => void;
+    validate: () => FormValidationResult;
+    submit: (options?: FormSubmitOptions) => Promise<unknown>;
+    setValidationRules: (rules: import("../types").FormValidationRule[]) => void;
+    clearErrors: () => void;
+    setFieldError: (field: string, error: string) => void;
+    getFieldError: (field: string) => string | undefined;
+    on?: (event: string, handler: Function) => void;
+    off?: (event: string, handler: Function) => void;
+    emit?: (event: string, data?: unknown) => void;
+    lifecycle?: {
+        destroy: () => void;
+    };
+}
+/**
+ * withAPI feature
+ * Creates a clean public API for the form component
+ */
+export declare const withAPI: (config: FormConfig) => (component: EnhancedFormComponent) => FormComponent;
+export default withAPI;

package/dist/components/form/features/controller.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Controller feature for Form component
+ * Manages control buttons (submit/cancel) based on data state (pristine/dirty)
+ */
+import type { FormConfig, BaseFormComponent, FormState, FormFieldRegistry, FormField } from "../types";
+/**
+ * withController feature
+ * Adds control button handling based on data state (pristine/dirty)
+ */
+export declare const withController: (config: FormConfig) => <T extends BaseFormComponent & {
+    fields: FormFieldRegistry;
+    state: FormState;
+    emit?: (event: string, data?: unknown) => void;
+    on?: (event: string, handler: Function) => void;
+}>(component: T) => T & {
+    controls: Map<string, FormField>;
+    getDataState: () => string;
+    enableControls: () => void;
+    disableControls: () => void;
+    enableFields: () => void;
+    disableFields: () => void;
+};
+export default withController;

package/dist/components/form/features/data.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Data feature for Form component
+ * Handles form data operations: get/set data, change tracking, snapshots
+ */
+import type { FormConfig, BaseFormComponent, FormData, FormState, FieldValue, FormFieldRegistry } from "../types";
+/**
+ * Gets a nested value from an object using dot notation
+ */
+declare const getNestedValue: (obj: Record<string, unknown>, path: string) => unknown;
+/**
+ * Sets a nested value in an object using dot notation
+ */
+declare const setNestedValue: (obj: Record<string, unknown>, path: string, value: unknown) => void;
+/**
+ * Converts flat field data to nested object structure
+ * e.g., { 'user.name': 'John' } -> { user: { name: 'John' } }
+ */
+declare const flatToNested: (data: FormData) => Record<string, unknown>;
+/**
+ * withData feature
+ * Adds data management capabilities to the form
+ */
+export declare const withData: (config: FormConfig) => <T extends BaseFormComponent & {
+    fields: FormFieldRegistry;
+    emit?: (event: string, data?: unknown) => void;
+}>(component: T) => T & {
+    state: FormState;
+    getData: () => FormData;
+    setData: (data: FormData, silent?: boolean) => void;
+    getFieldValue: (name: string) => FieldValue;
+    setFieldValue: (name: string, value: FieldValue, silent?: boolean) => void;
+    isModified: () => boolean;
+    getModifiedData: () => FormData;
+    snapshot: () => void;
+    reset: () => void;
+    clear: () => void;
+};
+export { flatToNested, getNestedValue, setNestedValue };
+export default withData;

package/dist/components/form/features/fields.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Fields feature for Form component
+ * Extracts fields from layout and manages the field registry
+ */
+import type { FormConfig, BaseFormComponent, FormField, FormFieldRegistry, FieldValue } from "../types";
+/**
+ * Gets the value from a field component
+ * All mtrl components now have unified getValue() API:
+ * - Textfield: returns string
+ * - Select: returns string or string[]
+ * - Chips: returns string[]
+ * - Switch/Checkbox: returns boolean (updated in mtrl core)
+ */
+export declare const getFieldValue: (field: FormField) => FieldValue;
+/**
+ * Sets the value on a field component
+ * All mtrl components now have unified setValue() API:
+ * - Textfield: accepts string
+ * - Select: accepts string or string[]
+ * - Chips: accepts string[]
+ * - Switch/Checkbox: accepts boolean or string ("true"/"false") (updated in mtrl core)
+ *
+ * For silent updates (no change events), we set directly on the input element
+ */
+export declare const setFieldValue: (field: FormField, value: FieldValue, silent?: boolean) => void;
+/**
+ * Updates the tracked value for a field
+ * Called when setData is used with silent=true to keep deduplication in sync
+ */
+export declare const updateTrackedFieldValue: (name: string, value: FieldValue) => void;
+/**
+ * Updates all tracked field values from a fields registry
+ * Called after silent setData to sync deduplication state
+ */
+export declare const syncTrackedFieldValues: (fields: FormFieldRegistry) => void;
+/**
+ * withFields feature
+ * Adds field extraction and registry management to the form
+ */
+export declare const withFields: (config: FormConfig) => <T extends BaseFormComponent>(component: T) => T & {
+    fields: FormFieldRegistry;
+    files: FormFieldRegistry;
+    getField: (name: string) => FormField | undefined;
+    getFieldNames: () => string[];
+    hasField: (name: string) => boolean;
+};
+export default withFields;

package/dist/components/form/features/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Form component features
+ * Each feature adds specific capabilities to the form component
+ */
+export { withLayout } from "./layout";
+export { withFields, getFieldValue, setFieldValue, updateTrackedFieldValue, syncTrackedFieldValues, } from "./fields";
+export { withData, flatToNested, getNestedValue, setNestedValue } from "./data";
+export { withController } from "./controller";
+export { withSubmit, validateData, performRequest } from "./submit";
+export { withAPI } from "./api";

package/dist/components/form/features/layout.d.ts

@@ -0,0 +1,11 @@
+import type { FormConfig, BaseFormComponent } from "../types";
+/**
+ * withLayout feature
+ * Adds form element creation and layout processing
+ */
+export declare const withLayout: (config: FormConfig) => <T extends BaseFormComponent>(component: T) => T & {
+    form: HTMLFormElement;
+    ui: Record<string, unknown>;
+    layoutResult: unknown;
+};
+export default withLayout;

package/dist/components/form/features/submit.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Submit feature for Form component
+ * Handles form validation and submission
+ */
+import type { FormConfig, BaseFormComponent, FormData, FormState, FormFieldRegistry, FormValidationRule, FormValidationResult, FormSubmitOptions } from "../types";
+/**
+ * Validates form data against validation rules
+ */
+declare const validateData: (data: FormData, rules: FormValidationRule[]) => FormValidationResult;
+/**
+ * Performs the actual HTTP request
+ */
+declare const performRequest: (url: string, data: FormData, options: FormSubmitOptions) => Promise<unknown>;
+/**
+ * withSubmit feature
+ * Adds validation and submission capabilities to the form
+ */
+export declare const withSubmit: (config: FormConfig) => <T extends BaseFormComponent & {
+    fields: FormFieldRegistry;
+    state: FormState;
+    getData: () => FormData;
+    getModifiedData: () => FormData;
+    disableControls: () => void;
+    snapshot: () => void;
+    emit?: (event: string, data?: unknown) => void;
+}>(component: T) => T & {
+    validate: () => FormValidationResult;
+    submit: (options?: FormSubmitOptions) => Promise<unknown>;
+    setValidationRules: (rules: FormValidationRule[]) => void;
+    clearErrors: () => void;
+    setFieldError: (field: string, error: string) => void;
+    getFieldError: (field: string) => string | undefined;
+};
+export { validateData, performRequest };
+export default withSubmit;

package/dist/components/form/form.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Form Component - Functional form builder with mtrl composition
+ *
+ * A form component that uses the mtrl-addons layout system to build
+ * forms from schema definitions, with built-in data management,
+ * validation, and submission handling.
+ */
+import type { FormConfig, FormComponent } from './types';
+/**
+ * Creates a new Form component using functional composition
+ *
+ * @param {FormConfig} config - Form configuration options
+ * @returns {FormComponent} A fully configured form component
+ *
+ * @example
+ * ```typescript
+ * import { createForm } from 'mtrl-addons'
+ * import { createTextfield, createSwitch, createChips } from 'mtrl'
+ *
+ * const form = createForm({
+ *   class: 'account-form',
+ *   action: '/api/users/',
+ *   layout: [
+ *     ['section', { class: 'user-section' },
+ *       ['div', { class: 'section-title', text: 'User' }],
+ *       [createTextfield, 'info.username', { label: 'Username' }],
+ *       [createChips, 'info.role', {
+ *         label: 'Role',
+ *         chips: [
+ *           { text: 'registered', value: 'registered' },
+ *           { text: 'admin', value: 'admin' },
+ *           { text: 'premium', value: 'premium' }
+ *         ]
+ *       }],
+ *       [createSwitch, 'info.enabled', { label: 'Enabled' }]
+ *     ]
+ *   ],
+ *   on: {
+ *     change: (data) => console.log('Form changed:', data),
+ *     submit: (data) => console.log('Form submitted:', data)
+ *   }
+ * })
+ *
+ * // Append to DOM
+ * document.body.appendChild(form.element)
+ *
+ * // Set data
+ * form.setData({
+ *   username: 'john_doe',
+ *   role: 'admin',
+ *   enabled: true
+ * })
+ *
+ * // Get data
+ * const data = form.getData()
+ *
+ * // Check if modified
+ * if (form.isModified()) {
+ *   await form.submit()
+ * }
+ * ```
+ */
+export declare const createForm: (config?: FormConfig) => FormComponent;
+export default createForm;

package/dist/components/form/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Form Component
+ * A functional form builder using mtrl composition pattern
+ */
+export { createForm, default } from "./form";
+export { DATA_STATE, FORM_EVENTS, FORM_CLASSES, FORM_DEFAULTS, FIELD_PREFIXES, } from "./constants";
+export type { DataState, FormEvent, FieldValue, FormData, FormField, FormFieldRegistry, LayoutSchema, LayoutSchemaItem, FormSectionConfig, FormValidationRule, FormValidationResult, FormSubmitOptions, FormEventHandlers, FormConfig, FormState, FormAPI, FormComponent, BaseFormComponent, SubmitHandler, CancelHandler, } from "./types";
+export { createBaseConfig, createInitialState, getElementConfig, extractFieldName, getFieldPath, isFieldName, isFileName, isValueEqual, hasDataChanged, getModifiedFields, } from "./config";
+export { withLayout, withFields, withData, withController, withSubmit, withAPI, getFieldValue, setFieldValue, flatToNested, getNestedValue, setNestedValue, validateData, performRequest, } from "./features";

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

@@ -0,0 +1,260 @@
+import type { DATA_STATE, FORM_EVENTS } from "./constants";
+/**
+ * Data state type (pristine or dirty)
+ */
+export type DataState = (typeof DATA_STATE)[keyof typeof DATA_STATE];
+/**
+ * Form event type
+ */
+export type FormEvent = (typeof FORM_EVENTS)[keyof typeof FORM_EVENTS];
+/**
+ * Field value types supported by the form
+ */
+export type FieldValue = string | number | boolean | string[] | null | undefined;
+/**
+ * Form data object - key-value pairs of field names and values
+ */
+export type FormData = Record<string, FieldValue>;
+/**
+ * Form field interface - represents a form field component
+ */
+export interface FormField {
+    /** The field's DOM element */
+    element: HTMLElement;
+    /** Get the field's current value */
+    getValue?: () => FieldValue;
+    /** Set the field's value */
+    setValue?: (value: FieldValue) => void;
+    /** Enable the field */
+    enable?: () => void;
+    /** Disable the field */
+    disable?: () => void;
+    /** Check if field is disabled */
+    isDisabled?: () => boolean;
+    /** Add event listener */
+    on?: (event: string, handler: Function) => void;
+    /** Remove event listener */
+    off?: (event: string, handler: Function) => void;
+    /** Destroy the field */
+    destroy?: () => void;
+}
+/**
+ * Form field registry - maps field names to field components
+ */
+export type FormFieldRegistry = Map<string, FormField>;
+/**
+ * Layout schema item - can be a component factory, string, or nested array
+ */
+export type LayoutSchemaItem = Function | string | Record<string, unknown> | LayoutSchema;
+/**
+ * Layout schema - array-based layout definition
+ */
+export type LayoutSchema = LayoutSchemaItem[];
+/**
+ * Form section configuration
+ */
+export interface FormSectionConfig {
+    /** Section title */
+    title?: string;
+    /** Section CSS class */
+    class?: string;
+    /** Section layout schema */
+    layout?: LayoutSchema;
+}
+/**
+ * Form validation rule
+ */
+export interface FormValidationRule {
+    /** Field name to validate */
+    field: string;
+    /** Validation function - returns true if valid, string error message if invalid */
+    validate: (value: FieldValue, data: FormData) => boolean | string;
+    /** Error message if validation returns false */
+    message?: string;
+}
+/**
+ * Form validation result
+ */
+export interface FormValidationResult {
+    /** Whether the form is valid */
+    valid: boolean;
+    /** Validation errors by field name */
+    errors: Record<string, string>;
+}
+/**
+ * Form submit options
+ */
+export interface FormSubmitOptions {
+    /** HTTP method */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Whether to validate before submit */
+    validate?: boolean;
+    /** Custom submit handler - if provided, replaces default fetch */
+    handler?: (data: FormData, form: FormComponent) => Promise<unknown>;
+}
+/**
+ * Form event handlers configuration
+ */
+export interface FormEventHandlers {
+    /** Called when any field value changes */
+    change?: (data: FormData, fieldName: string) => void;
+    /** Called when form is submitted */
+    submit?: (data: FormData) => void;
+    /** Called when form submit succeeds */
+    "submit:success"?: (response: unknown) => void;
+    /** Called when form submit fails */
+    "submit:error"?: (error: Error) => void;
+    /** Called when data state changes (pristine <-> dirty) */
+    "state:change"?: (event: {
+        modified: boolean;
+        state: DataState;
+    }) => void;
+    /** Called when form data is set */
+    "data:set"?: (data: FormData) => void;
+    /** Called when form is reset */
+    reset?: () => void;
+}
+/**
+ * Submit button handler - called when submit button is clicked
+ * Return a promise that resolves with the result or rejects with an error
+ */
+export type SubmitHandler = (data: FormData, form: FormComponent) => Promise<unknown>;
+/**
+ * Cancel button handler - called when cancel button is clicked
+ */
+export type CancelHandler = (form: FormComponent) => void;
+/**
+ * Form configuration
+ */
+export interface FormConfig {
+    /** Component prefix for class names */
+    prefix?: string;
+    /** Component name */
+    componentName?: string;
+    /** Additional CSS class for the form container */
+    class?: string;
+    /** Form action URL for submission */
+    action?: string;
+    /** HTTP method for form submission */
+    method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    /** Form autocomplete attribute */
+    autocomplete?: "on" | "off";
+    /** Layout schema defining form structure */
+    layout?: LayoutSchema;
+    /** System info fields (excluded from form data) */
+    sysinfo?: string[];
+    /** Whether to track changes and auto-enable/disable controls */
+    useChanges?: boolean;
+    /** Control button names (default: ['submit', 'cancel']) */
+    controls?: string[] | null;
+    /** Handler called when submit button is clicked */
+    onSubmit?: SubmitHandler;
+    /** Handler called when cancel button is clicked */
+    onCancel?: CancelHandler;
+    /** Initial form data */
+    data?: FormData;
+    /** Validation rules */
+    validation?: FormValidationRule[];
+    /** Event handlers */
+    on?: FormEventHandlers;
+    /** Container element to append form to */
+    container?: HTMLElement;
+}
+/**
+ * Form state
+ */
+export interface FormState {
+    /** Whether form has been modified from initial data */
+    modified: boolean;
+    /** Whether form is currently submitting */
+    submitting: boolean;
+    /** Whether form is disabled */
+    disabled: boolean;
+    /** Initial data snapshot for change detection */
+    initialData: FormData;
+    /** Current form data */
+    currentData: FormData;
+    /** Validation errors */
+    errors: Record<string, string>;
+}
+/**
+ * Form component public API
+ */
+export interface FormAPI {
+    /** Get all form data */
+    getData: () => FormData;
+    /** Set form data */
+    setData: (data: FormData, silent?: boolean) => FormComponent;
+    /** Get a specific field value */
+    getFieldValue: (name: string) => FieldValue;
+    /** Set a specific field value */
+    setFieldValue: (name: string, value: FieldValue, silent?: boolean) => FormComponent;
+    /** Get a field component by name */
+    getField: (name: string) => FormField | undefined;
+    /** Get all field names */
+    getFieldNames: () => string[];
+    /** Check if form has been modified */
+    isModified: () => boolean;
+    /** Get current data state (pristine or dirty) */
+    getDataState: () => DataState;
+    /** Validate the form */
+    validate: () => FormValidationResult;
+    /** Submit the form */
+    submit: (options?: FormSubmitOptions) => Promise<unknown>;
+    /** Reset form to initial data */
+    reset: () => FormComponent;
+    /** Clear all form fields */
+    clear: () => FormComponent;
+    /** Enable all form fields */
+    enable: () => FormComponent;
+    /** Disable all form fields */
+    disable: () => FormComponent;
+    /** Enable control buttons */
+    enableControls: () => FormComponent;
+    /** Disable control buttons */
+    disableControls: () => FormComponent;
+}
+/**
+ * Form component interface
+ */
+export interface FormComponent extends FormAPI {
+    /** The form container element */
+    element: HTMLElement;
+    /** The form element */
+    form: HTMLFormElement;
+    /** Layout result with named components */
+    ui: Record<string, unknown>;
+    /** Field registry */
+    fields: FormFieldRegistry;
+    /** Current form state */
+    state: FormState;
+    /** Add event listener */
+    on: (event: string, handler: Function) => FormComponent;
+    /** Remove event listener */
+    off: (event: string, handler: Function) => FormComponent;
+    /** Emit an event */
+    emit: (event: string, data?: unknown) => void;
+    /** Destroy the form and clean up */
+    destroy: () => void;
+}
+/**
+ * Internal component structure before API is applied
+ */
+export interface BaseFormComponent {
+    element: HTMLElement;
+    form?: HTMLFormElement;
+    ui?: Record<string, unknown>;
+    fields?: FormFieldRegistry;
+    state?: FormState;
+    config?: FormConfig;
+    componentName?: string;
+    getClass?: (name: string) => string;
+    on?: (event: string, handler: Function) => void;
+    off?: (event: string, handler: Function) => void;
+    emit?: (event: string, data?: unknown) => void;
+    lifecycle?: {
+        destroy: () => void;
+    };
+}

package/dist/components/index.d.ts

@@ -5,3 +5,6 @@
  */
 export { createVList } from "./vlist";
 export type { VListConfig, VListComponent } from "./vlist/types";
+export { createForm } from "./form";
+export type { FormConfig, FormComponent, FormField, FormData, DataState, FormState, FormValidationRule, FormValidationResult, FormSubmitOptions, FormEventHandlers, FieldValue, SubmitHandler, CancelHandler, } from "./form/types";
+export { DATA_STATE, FORM_EVENTS, FORM_CLASSES, FORM_DEFAULTS, } from "./form/constants";