@overmap-ai/forms 1.0.0

package/README.md

@@ -0,0 +1,12 @@
+# Overmap `FormRenderer` component
+
+Renders a form entry or renders a form that can be submitted.
+
+# Overmap `FormBuilder` component
+
+Allows a new form to be created or a new revision of an existing form to be made.
+
+## Dev notes
+
+To use unreleased versions of peer dependencies like @overmap-ai/blocks, follow
+[these instructions](https://github.com/facebook/react/issues/14257#issuecomment-595183610) for how to use `yarn link` with react.

package/dist/builder/DropDispatch.d.ts

@@ -0,0 +1,27 @@
+import { SerializedFieldSection } from "@overmap-ai/core";
+import { Reducer } from "react";
+export interface SmallFieldSection {
+    /** is dropping disabled in this section? */
+    disabled: boolean;
+    /** id's of field that may not be dropped on this section */
+    conditionFields: Set<string>;
+    /** the index of the section the condition is in */
+    conditionIndex?: number;
+    /** the index of the section */
+    index: number;
+    /** label of the section */
+    label: string | null;
+}
+export type DropState = Record<string, SmallFieldSection>;
+export type DropAction = {
+    type: "release";
+} | {
+    type: "hold";
+    fieldId: string;
+} | {
+    type: "update";
+    state: DropState;
+};
+export declare const reducer: Reducer<DropState, DropAction>;
+/** creates a `DropState` from a list of `SerializedFieldSection` objects */
+export declare const initializer: (fields: SerializedFieldSection[]) => DropState;

package/dist/builder/FieldActions.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="react" />
+import { DraggableProvidedDragHandleProps } from "@hello-pangea/dnd";
+import { FieldBuilderArgs } from "./FieldBuilder";
+interface FieldActionsProps {
+    remove: () => void;
+    dragHandleProps: DraggableProvidedDragHandleProps | null | undefined;
+    editProps: FieldBuilderArgs;
+    insertAfterProps: FieldBuilderArgs;
+}
+export declare const FieldActions: import("react").NamedExoticComponent<FieldActionsProps>;
+export {};

package/dist/builder/FieldBuilder.d.ts

@@ -0,0 +1,22 @@
+import { NestedFieldPath } from "./typings";
+import { FC, ReactNode } from "react";
+import { FieldTypeIdentifier, ISerializedField } from "@overmap-ai/core";
+import { Form } from '../typings';
+interface FieldOptionsFormProps {
+    defaultField?: ISerializedField;
+    fieldType: FieldTypeIdentifier;
+    /** fields that can be used as a condition */
+    conditionalSourceFields?: ISerializedField[];
+    handleCancel: () => void;
+    handleCreateField: (form: Form) => void;
+}
+interface FieldBuilderProps extends Pick<FieldOptionsFormProps, "conditionalSourceFields"> {
+    index: number;
+    parentPath: NestedFieldPath;
+    initial?: ISerializedField;
+    editing?: boolean;
+    children: ReactNode;
+}
+export type FieldBuilderArgs = Omit<FieldBuilderProps, "children">;
+export declare const FieldBuilder: FC<FieldBuilderProps>;
+export {};

package/dist/builder/FieldSectionWithActions.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { SerializedFieldSection } from "@overmap-ai/core";
+import { DropState } from "./DropDispatch";
+interface FieldSectionWithActionsProps {
+    field: SerializedFieldSection;
+    index: number;
+    dropState: DropState;
+}
+export declare const FieldSectionWithActions: import("react").NamedExoticComponent<FieldSectionWithActionsProps>;
+export {};

package/dist/builder/FieldWithActions.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { ISerializedField } from "@overmap-ai/core";
+interface FieldWithActionsProps {
+    field: ISerializedField;
+    index: number;
+    sectionIndex: number;
+    remove: () => void;
+}
+export declare const FieldWithActions: import("react").NamedExoticComponent<FieldWithActionsProps>;
+export {};

package/dist/builder/FieldsEditor.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const FieldsEditor: import("react").NamedExoticComponent<object>;

package/dist/builder/FormBuilder.d.ts

@@ -0,0 +1,15 @@
+import { FormBuilderSaveHandler } from "./typings";
+import { ReactNode } from "react";
+import { UserFormRevision } from "@overmap-ai/core";
+interface FormBuilderProps {
+    onCancel?: () => void;
+    onSave: FormBuilderSaveHandler;
+    /** A revision of an existing form to edit. To create a new form, pass `undefined`. */
+    revision?: UserFormRevision;
+    /** A heading for the `FormBuilder`
+     * @default "Create a new form" or "Edit form" if `revision` is passed
+     */
+    heading?: ReactNode;
+}
+export declare const FormBuilder: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<FormBuilderProps & import("react").RefAttributes<HTMLDivElement>>>;
+export {};

package/dist/builder/constants.d.ts

@@ -0,0 +1 @@
+export declare const formId = "form-builder";

package/dist/builder/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./FormBuilder";
+export * from "./typings";

package/dist/builder/typings.d.ts

@@ -0,0 +1,11 @@
+import { SerializedFieldSection, UserFormRevision } from "@overmap-ai/core";
+export type NewForm = Pick<UserFormRevision<SerializedFieldSection>, "description" | "title" | "fields">;
+export type FormBuilderSaveHandler = (form: NewForm | UserFormRevision) => void;
+/** The `FormBuilder` can either be used to edit an existing form or create a new one.
+ *
+ * The only difference between the two is that new forms do not have `id` attributes.
+ */
+export type FormikUserFormRevision = UserFormRevision<SerializedFieldSection> | NewForm;
+/** Using `lodash.get` and `lodash.set`, we can set and get attributes of nested objects using a string path. This is
+used to get and set attributes of the `fields` of a `SerializedFieldSection` object. */
+export type NestedFieldPath = "fields" | `fields.${number}.fields`;

package/dist/builder/utils.d.ts

@@ -0,0 +1,11 @@
+import { UserFormRevision, ISerializedField, SerializedFieldSection } from "@overmap-ai/core";
+import { ISerializedOnlyField } from '../fields';
+export declare const emptySection: (id?: string, fields?: ISerializedOnlyField[]) => SerializedFieldSection;
+export declare const wrapRootFieldsWithFieldSection: (revision?: UserFormRevision) => UserFormRevision<SerializedFieldSection> | undefined;
+export declare function reorder<T>(list: T[], source: number, destination: number): T[];
+export declare function replace<T>(list: T[], index: number, value: T): T[];
+export declare function insert<T>(list: T[] | undefined, index: number, value: T): T[];
+export declare function remove<T>(list: T[], index: number): T[];
+export declare const makeIdentifier: (existing: unknown, label: string) => string;
+export declare const findFieldByIdentifier: (fields: ISerializedField[], identifier?: string) => ISerializedField | null;
+export declare const makeConditionalSourceFields: (sections: SerializedFieldSection[], index: number) => (import("@overmap-ai/core").SerializedTextField | import("@overmap-ai/core").SerializedBooleanField | import("@overmap-ai/core").SerializedNumberField | import("@overmap-ai/core").SerializedDateField | import("@overmap-ai/core").SerializedStringField | import("@overmap-ai/core").SerializedSelectField | import("@overmap-ai/core").SerializedMultiStringField | import("@overmap-ai/core").SerializedMultiSelectField)[];

package/dist/fields/BaseField/BaseField.d.ts

@@ -0,0 +1,32 @@
+import { BaseSerializedField, BaseSerializedObject, FieldTypeIdentifier, FieldValue, ISerializedField } from "@overmap-ai/core";
+import { AnyField, GetInputProps, ISerializedOnlyField, InputFieldLevelValidator, InputFormLevelValidator } from '../typings';
+import { Form } from '../../typings';
+import { ReactNode } from "react";
+import { FieldSection } from '../FieldSection';
+import { FieldOptions } from "./typings";
+export declare abstract class BaseFormElement<TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> {
+    readonly type: TIdentifier;
+    protected readonly identifier: string;
+    readonly description: string | null;
+    protected constructor(options: BaseSerializedObject);
+    getId(): string;
+    abstract getInput(props: GetInputProps<this>): ReactNode;
+    static deserialize(_data: ISerializedField): AnyField | FieldSection;
+    protected _serialize(): BaseSerializedObject<TIdentifier>;
+}
+export declare abstract class BaseField<TValue extends FieldValue, TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> extends BaseFormElement<TIdentifier> {
+    static readonly fieldTypeName: string;
+    static readonly fieldTypeDescription: string;
+    readonly required: boolean;
+    private readonly formValidators;
+    private readonly fieldValidators;
+    readonly label: string;
+    protected constructor(options: FieldOptions<TValue>);
+    static getFieldCreationSchema(): AnyField[];
+    protected isBlank(value: TValue): boolean;
+    getError(value: TValue, allValues?: Form): string | undefined;
+    protected _serialize(): BaseSerializedField<TIdentifier>;
+    abstract serialize(): ISerializedOnlyField;
+    getFieldValidators(): InputFieldLevelValidator<TValue>[];
+    getFormValidators(): InputFormLevelValidator<TValue>[];
+}

package/dist/fields/BaseField/hooks.d.ts

@@ -0,0 +1,374 @@
+import { AnyField, ComponentProps } from '../typings';
+import { ValueOfField } from "../../typings.ts";
+import { FocusEventHandler } from "react";
+export declare const useFormikInput: <TField extends AnyField>(props: ComponentProps<TField>) => readonly [{
+    readonly helpText: string | null;
+    readonly severity: "danger" | undefined;
+    readonly inputId: string;
+    readonly labelId: string;
+    readonly label: string;
+    readonly fieldProps: import("formik").FieldInputProps<ValueOfField<TField>>;
+    readonly helpers: import("formik").FieldHelperProps<ValueOfField<TField>>;
+    readonly field: TField;
+}, {
+    readonly "aria-labelledby": string;
+    readonly accept?: string | undefined;
+    readonly acceptCharset?: string | undefined;
+    readonly action?: string | undefined;
+    readonly allowFullScreen?: boolean | undefined;
+    readonly allowTransparency?: boolean | undefined;
+    readonly alt?: string | undefined;
+    readonly as?: string | undefined;
+    readonly async?: boolean | undefined;
+    readonly autoComplete?: string | undefined;
+    readonly autoPlay?: boolean | undefined;
+    readonly capture?: boolean | "user" | "environment" | undefined;
+    readonly cellPadding?: string | number | undefined;
+    readonly cellSpacing?: string | number | undefined;
+    readonly charSet?: string | undefined;
+    readonly challenge?: string | undefined;
+    readonly checked?: boolean | undefined;
+    readonly cite?: string | undefined;
+    readonly classID?: string | undefined;
+    readonly cols?: number | undefined;
+    readonly colSpan?: number | undefined;
+    readonly controls?: boolean | undefined;
+    readonly coords?: string | undefined;
+    readonly crossOrigin?: "" | "anonymous" | "use-credentials" | undefined;
+    readonly data?: string | undefined;
+    readonly dateTime?: string | undefined;
+    readonly default?: boolean | undefined;
+    readonly defer?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly download?: any;
+    readonly encType?: string | undefined;
+    readonly form?: string | undefined;
+    readonly formAction?: string | undefined;
+    readonly formEncType?: string | undefined;
+    readonly formMethod?: string | undefined;
+    readonly formNoValidate?: boolean | undefined;
+    readonly formTarget?: string | undefined;
+    readonly frameBorder?: string | number | undefined;
+    readonly headers?: string | undefined;
+    readonly height?: string | number | undefined;
+    readonly high?: number | undefined;
+    readonly href?: string | undefined;
+    readonly hrefLang?: string | undefined;
+    readonly htmlFor?: string | undefined;
+    readonly httpEquiv?: string | undefined;
+    readonly integrity?: string | undefined;
+    readonly keyParams?: string | undefined;
+    readonly keyType?: string | undefined;
+    readonly kind?: string | undefined;
+    readonly label?: string | undefined;
+    readonly list?: string | undefined;
+    readonly loop?: boolean | undefined;
+    readonly low?: number | undefined;
+    readonly manifest?: string | undefined;
+    readonly marginHeight?: number | undefined;
+    readonly marginWidth?: number | undefined;
+    readonly max?: string | number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly media?: string | undefined;
+    readonly mediaGroup?: string | undefined;
+    readonly method?: string | undefined;
+    readonly min?: string | number | undefined;
+    readonly minLength?: number | undefined;
+    readonly multiple?: boolean | undefined;
+    readonly muted?: boolean | undefined;
+    readonly noValidate?: boolean | undefined;
+    readonly open?: boolean | undefined;
+    readonly optimum?: number | undefined;
+    readonly pattern?: string | undefined;
+    readonly placeholder?: string | undefined;
+    readonly playsInline?: boolean | undefined;
+    readonly poster?: string | undefined;
+    readonly preload?: string | undefined;
+    readonly readOnly?: boolean | undefined;
+    readonly required?: boolean | undefined;
+    readonly reversed?: boolean | undefined;
+    readonly rows?: number | undefined;
+    readonly rowSpan?: number | undefined;
+    readonly sandbox?: string | undefined;
+    readonly scope?: string | undefined;
+    readonly scoped?: boolean | undefined;
+    readonly scrolling?: string | undefined;
+    readonly seamless?: boolean | undefined;
+    readonly selected?: boolean | undefined;
+    readonly shape?: string | undefined;
+    readonly sizes?: string | undefined;
+    readonly span?: number | undefined;
+    readonly src?: string | undefined;
+    readonly srcDoc?: string | undefined;
+    readonly srcLang?: string | undefined;
+    readonly srcSet?: string | undefined;
+    readonly start?: number | undefined;
+    readonly step?: string | number | undefined;
+    readonly summary?: string | undefined;
+    readonly target?: string | undefined;
+    readonly useMap?: string | undefined;
+    readonly width?: string | number | undefined;
+    readonly wmode?: string | undefined;
+    readonly wrap?: string | undefined;
+    readonly defaultChecked?: boolean | undefined;
+    readonly suppressContentEditableWarning?: boolean | undefined;
+    readonly suppressHydrationWarning?: boolean | undefined;
+    readonly accessKey?: string | undefined;
+    readonly autoFocus?: boolean | undefined;
+    readonly className?: string | undefined;
+    readonly contentEditable?: (boolean | "true" | "false") | "inherit" | undefined;
+    readonly contextMenu?: string | undefined;
+    readonly draggable?: (boolean | "true" | "false") | undefined;
+    readonly hidden?: boolean | undefined;
+    readonly lang?: string | undefined;
+    readonly nonce?: string | undefined;
+    readonly slot?: string | undefined;
+    readonly spellCheck?: (boolean | "true" | "false") | undefined;
+    readonly style?: import("react").CSSProperties | undefined;
+    readonly tabIndex?: number | undefined;
+    readonly title?: string | undefined;
+    readonly translate?: "yes" | "no" | undefined;
+    readonly radioGroup?: string | undefined;
+    readonly role?: import("react").AriaRole | undefined;
+    readonly about?: string | undefined;
+    readonly content?: string | undefined;
+    readonly datatype?: string | undefined;
+    readonly inlist?: any;
+    readonly prefix?: string | undefined;
+    readonly property?: string | undefined;
+    readonly rel?: string | undefined;
+    readonly resource?: string | undefined;
+    readonly rev?: string | undefined;
+    readonly typeof?: string | undefined;
+    readonly vocab?: string | undefined;
+    readonly autoCapitalize?: string | undefined;
+    readonly autoCorrect?: string | undefined;
+    readonly autoSave?: string | undefined;
+    readonly itemProp?: string | undefined;
+    readonly itemScope?: boolean | undefined;
+    readonly itemType?: string | undefined;
+    readonly itemID?: string | undefined;
+    readonly itemRef?: string | undefined;
+    readonly results?: number | undefined;
+    readonly security?: string | undefined;
+    readonly unselectable?: "on" | "off" | undefined;
+    readonly inputMode?: "text" | "none" | "search" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    readonly is?: string | undefined;
+    readonly "aria-activedescendant"?: string | undefined;
+    readonly "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-autocomplete"?: "list" | "none" | "inline" | "both" | undefined;
+    readonly "aria-braillelabel"?: string | undefined;
+    readonly "aria-brailleroledescription"?: string | undefined;
+    readonly "aria-busy"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-checked"?: boolean | "true" | "false" | "mixed" | undefined;
+    readonly "aria-colcount"?: number | undefined;
+    readonly "aria-colindex"?: number | undefined;
+    readonly "aria-colindextext"?: string | undefined;
+    readonly "aria-colspan"?: number | undefined;
+    readonly "aria-controls"?: string | undefined;
+    readonly "aria-current"?: boolean | "date" | "step" | "true" | "false" | "page" | "location" | "time" | undefined;
+    readonly "aria-describedby"?: string | undefined;
+    readonly "aria-description"?: string | undefined;
+    readonly "aria-details"?: string | undefined;
+    readonly "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-dropeffect"?: "link" | "none" | "copy" | "execute" | "move" | "popup" | undefined;
+    readonly "aria-errormessage"?: string | undefined;
+    readonly "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-flowto"?: string | undefined;
+    readonly "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-haspopup"?: boolean | "true" | "false" | "dialog" | "grid" | "listbox" | "menu" | "tree" | undefined;
+    readonly "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-invalid"?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    readonly "aria-keyshortcuts"?: string | undefined;
+    readonly "aria-label"?: string | undefined;
+    readonly "aria-level"?: number | undefined;
+    readonly "aria-live"?: "off" | "assertive" | "polite" | undefined;
+    readonly "aria-modal"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-orientation"?: "horizontal" | "vertical" | undefined;
+    readonly "aria-owns"?: string | undefined;
+    readonly "aria-placeholder"?: string | undefined;
+    readonly "aria-posinset"?: number | undefined;
+    readonly "aria-pressed"?: boolean | "true" | "false" | "mixed" | undefined;
+    readonly "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-relevant"?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+    readonly "aria-required"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-roledescription"?: string | undefined;
+    readonly "aria-rowcount"?: number | undefined;
+    readonly "aria-rowindex"?: number | undefined;
+    readonly "aria-rowindextext"?: string | undefined;
+    readonly "aria-rowspan"?: number | undefined;
+    readonly "aria-selected"?: (boolean | "true" | "false") | undefined;
+    readonly "aria-setsize"?: number | undefined;
+    readonly "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined;
+    readonly "aria-valuemax"?: number | undefined;
+    readonly "aria-valuemin"?: number | undefined;
+    readonly "aria-valuenow"?: number | undefined;
+    readonly "aria-valuetext"?: string | undefined;
+    readonly children?: import("react").ReactNode;
+    readonly dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    readonly onCopy?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCopyCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCut?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCutCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onPaste?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onPasteCapture?: import("react").ClipboardEventHandler<HTMLElement> | undefined;
+    readonly onCompositionEnd?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionStart?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionUpdate?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLElement> | undefined;
+    readonly onFocus?: FocusEventHandler<HTMLElement> | undefined;
+    readonly onFocusCapture?: FocusEventHandler<HTMLElement> | undefined;
+    readonly onBlurCapture?: FocusEventHandler<HTMLElement> | undefined;
+    readonly onChangeCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onBeforeInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onBeforeInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onInput?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onInputCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onReset?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onResetCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onSubmit?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onSubmitCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onInvalid?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onInvalidCapture?: import("react").FormEventHandler<HTMLElement> | undefined;
+    readonly onLoad?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onError?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onErrorCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onKeyDown?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyPress?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyUp?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLElement> | undefined;
+    readonly onAbort?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onAbortCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayThrough?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onDurationChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onDurationChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEmptied?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEmptiedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEncrypted?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEncryptedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEnded?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onEndedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedData?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedDataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedMetadata?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadStart?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onLoadStartCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPause?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPauseCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlay?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlayCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlaying?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onPlayingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onProgress?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onProgressCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onRateChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onRateChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onResize?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onResizeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeeked?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeekedCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeeking?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSeekingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onStalled?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onStalledCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSuspend?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSuspendCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onTimeUpdate?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onVolumeChange?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onWaiting?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onWaitingCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onAuxClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onAuxClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onContextMenu?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onContextMenuCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onDoubleClick?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onDoubleClickCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onDrag?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnd?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEndCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnter?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragEnterCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragExit?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragExitCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragLeave?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragLeaveCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragOver?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragOverCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragStart?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDragStartCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDrop?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onDropCapture?: import("react").DragEventHandler<HTMLElement> | undefined;
+    readonly onMouseDown?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseDownCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseEnter?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseLeave?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseMove?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseMoveCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOut?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOutCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOver?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseOverCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseUp?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onMouseUpCapture?: import("react").MouseEventHandler<HTMLElement> | undefined;
+    readonly onSelect?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onSelectCapture?: import("react").ReactEventHandler<HTMLElement> | undefined;
+    readonly onTouchCancel?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchCancelCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchEnd?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchEndCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchMove?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchMoveCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchStart?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onTouchStartCapture?: import("react").TouchEventHandler<HTMLElement> | undefined;
+    readonly onPointerDown?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerDownCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerMove?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerMoveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerUp?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerUpCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerCancel?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerCancelCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerEnter?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerEnterCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerLeave?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOver?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOverCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOut?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onPointerOutCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onGotPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onLostPointerCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLElement> | undefined;
+    readonly onScroll?: import("react").UIEventHandler<HTMLElement> | undefined;
+    readonly onScrollCapture?: import("react").UIEventHandler<HTMLElement> | undefined;
+    readonly onWheel?: import("react").WheelEventHandler<HTMLElement> | undefined;
+    readonly onWheelCapture?: import("react").WheelEventHandler<HTMLElement> | undefined;
+    readonly onAnimationStart?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationEnd?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationIteration?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLElement> | undefined;
+    readonly onTransitionEnd?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    readonly onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLElement> | undefined;
+    readonly key?: import("react").Key | null | undefined;
+}];

package/dist/fields/BaseField/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./BaseField";
+export * from "./layouts";
+export * from "./hooks";
+export * from "./typings";

package/dist/fields/BaseField/layouts.d.ts

@@ -0,0 +1,19 @@
+import { Flex, Severity, ThemeOptions } from "@overmap-ai/blocks";
+import { ReactElement, ComponentProps, ReactNode } from "react";
+export type Color = ThemeOptions["accentColor"];
+interface InputWithLabelProps {
+    severity: Severity | undefined;
+    inputId: string;
+    labelId: string;
+    label: string;
+    children: ReactNode;
+    flexProps?: ComponentProps<typeof Flex>;
+}
+export declare const InputWithLabel: (props: InputWithLabelProps) => import("react/jsx-runtime").JSX.Element;
+interface InputWithLabelAndHelpTextProps {
+    severity: Severity | undefined;
+    helpText: string | null;
+    children: ReactElement<InputWithLabelProps>;
+}
+export declare const InputWithLabelAndHelpText: (props: InputWithLabelAndHelpTextProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/fields/BaseField/typings.d.ts

@@ -0,0 +1,7 @@
+import { BaseSerializedField } from "@overmap-ai/core";
+import { InputFieldLevelValidator, InputFormLevelValidator } from '..';
+export interface FieldOptions<TValue> extends BaseSerializedField {
+    fieldValidators?: InputFieldLevelValidator<TValue>[];
+    formValidators?: InputFormLevelValidator<TValue>[];
+}
+export type ChildFieldOptions<TValue> = Omit<FieldOptions<TValue>, "type">;

package/dist/fields/BooleanField/BooleanInput.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ComponentProps } from '../typings';
+import { BooleanField } from "./BooleanField";
+export declare const BooleanInput: import("react").NamedExoticComponent<ComponentProps<BooleanField>>;

package/dist/fields/BooleanField/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./BooleanField";
+export * from "./BooleanInput";

package/dist/fields/CustomField/CustomField.d.ts

@@ -0,0 +1,19 @@
+import { FieldTypeIdentifier, FieldValue } from "@overmap-ai/core";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { FC, ReactNode } from "react";
+import { GetInputProps, ISerializedOnlyField } from "../typings";
+export interface CustomFieldOptions<TValue> extends ChildFieldOptions<TValue> {
+}
+export declare class CustomField<TValue extends FieldValue, 
+/** The options passed to constructor */
+TFieldOptions extends CustomFieldOptions<TValue>, 
+/** The props passed to the custom component */
+TComponentProps extends GetInputProps<CustomField<TValue, TFieldOptions, TComponentProps>>, TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> extends BaseField<TValue, TIdentifier> {
+    static readonly fieldTypeName = "Custom";
+    static readonly fieldTypeDescription = "Allows re-rendering of field already in the form";
+    readonly Component: FC<TComponentProps>;
+    readonly options: TFieldOptions;
+    constructor(options: TFieldOptions, Component: FC<TComponentProps>);
+    serialize(): ISerializedOnlyField;
+    getInput(props: TComponentProps): ReactNode;
+}