@overmap-ai/forms 1.0.15 → 1.0.17-blank-value-updates.1

package/dist/forms/fields/MultiStringField/MultiStringField.d.ts

@@ -0,0 +1,40 @@
+import { ReactNode } from 'react';
+import { RiListCheck } from 'react-icons/ri';
+import { ISerializedField, SerializedMultiStringField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { GetInputProps, InputFieldLevelValidator } from '../typings';
+type MultiStringFieldOptions = ChildFieldOptions<string[]> & {
+    minimum_length?: number;
+    maximum_length?: number;
+    placeholder?: string;
+};
+export declare const emptyMultiStringField: {
+    type: string;
+    minimum_length: number;
+    maximum_length: null;
+    label: string;
+    description: string;
+    required: boolean;
+};
+/**
+ * A field that lets the user input multiple strings. Each string must be unique. Useful for things like:
+ * - Specifying the options of a SelectField (used in `SelectField.getFieldCreationSchema`
+ * - Listing serial numbers and similar
+ */
+export declare class MultiStringField extends BaseField<string[], "multi-string"> {
+    static readonly fieldTypeName = "Multi-string";
+    static readonly fieldTypeDescription = "Allows the user to provide multiple unique strings.";
+    readonly minLength: number;
+    readonly maxLength: number;
+    readonly onlyValidateAfterTouched = false;
+    readonly placeholder: string;
+    static Icon: typeof RiListCheck;
+    constructor(options: MultiStringFieldOptions);
+    getInput(props: GetInputProps<this>): ReactNode;
+    serialize(): SerializedMultiStringField;
+    protected isBlank(value: string[] | undefined): boolean;
+    isEqual(value1: string[] | undefined, value2: string[] | undefined): boolean;
+    getFieldValidators(): InputFieldLevelValidator<string[]>[];
+    static deserialize(data: ISerializedField): MultiStringField;
+}
+export {};

package/dist/forms/fields/MultiStringField/MultiStringInput.d.ts

@@ -0,0 +1,7 @@
+import { ComponentProps } from '../typings';
+import { MultiStringField } from './MultiStringField';
+/**
+ * Allows the user to create an array of unique strings and customize the order.
+ * User to generate options for the Select field.
+ */
+export declare const MultiStringInput: import('react').MemoExoticComponent<(props: ComponentProps<MultiStringField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/MultiStringField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './MultiStringField';
+export * from './MultiStringInput';

package/dist/forms/fields/NumberField/NumberField.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { RiHashtag } from 'react-icons/ri';
+import { ISerializedField, SerializedNumberField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { BooleanField } from '../BooleanField';
+import { GetInputProps, InputFieldLevelValidator, InputValidator } from '../typings';
+export declare const emptyNumberField: {
+    type: string;
+    minimum: number;
+    maximum: number;
+    integers: boolean;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export interface NumberFieldOptions extends ChildFieldOptions<number> {
+    maximum?: number;
+    minimum?: number;
+    integers?: boolean;
+    placeholder?: string;
+}
+export declare class NumberField extends BaseField<number, "number"> {
+    static readonly fieldTypeName = "Number";
+    static readonly fieldTypeDescription = "Allows specifying a number within a given range.";
+    readonly minimum: number | undefined;
+    readonly maximum: number | undefined;
+    readonly integers: boolean;
+    readonly placeholder: string;
+    static Icon: typeof RiHashtag;
+    constructor(options: NumberFieldOptions);
+    static _validateMin: (path: string) => InputValidator<number>;
+    static _validateMax: (path: string) => InputValidator<number>;
+    static getFieldCreationSchema(parentPath?: string): ({
+        field: NumberField;
+        showDirectly: boolean;
+    } | {
+        field: BooleanField;
+        showDirectly: boolean;
+    })[];
+    getFieldValidators(): InputFieldLevelValidator<number>[];
+    serialize(): SerializedNumberField;
+    static deserialize(data: ISerializedField): NumberField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/NumberField/NumberInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { NumberField } from './NumberField';
+export declare const NumberInput: import('react').MemoExoticComponent<(props: ComponentProps<NumberField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/NumberField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './NumberField';
+export * from './NumberInput';

package/dist/forms/fields/QrField/QrField.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { RiQrCodeLine } from 'react-icons/ri';
+import { ISerializedField, SerializedQrField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { ComponentProps } from '../typings';
+export declare const emptyQrField: {
+    type: string;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class QrField extends BaseField<string, "qr"> {
+    static readonly fieldTypeName = "QR";
+    static readonly fieldTypeDescription = "Used for scanning/reading QR codes.";
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof RiQrCodeLine;
+    constructor(options: ChildFieldOptions<string>);
+    serialize(): SerializedQrField;
+    static deserialize(data: ISerializedField): QrField;
+    getInput(props: ComponentProps<QrField>): ReactNode;
+}

package/dist/forms/fields/QrField/QrInput.d.ts

@@ -0,0 +1,8 @@
+import { ComponentProps } from '../typings';
+import { QrField } from './QrField';
+export declare const QrInput: import('react').MemoExoticComponent<(props: ComponentProps<QrField>) => import("react/jsx-runtime").JSX.Element>;
+interface QrScannerProps {
+    onQrScan: (data: string) => void;
+}
+export declare const QrScanner: import('react').MemoExoticComponent<(props: QrScannerProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/forms/fields/QrField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QrField';
+export * from './QrInput';

package/dist/{fields → forms/fields}/SelectField/BaseSelectField.d.ts

@@ -1,6 +1,6 @@
-import { FieldValue, SelectFieldOption } from "@overmap-ai/core";
-import { BaseField, ChildFieldOptions } from "../BaseField";
-import { MultiStringField } from "../MultiStringField";
+import { FieldValue, SelectFieldOption } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { MultiStringField } from '../MultiStringField';
 /**
  * The options passed to the constructor of SelectField.
  */
@@ -10,18 +10,25 @@ export interface BaseSelectFieldOptions<TValue, TIdentifier extends "select" | "
      * where the `label` is the text to display to the user and the `value` is the value handled by Formik.*/
     options: string[] | SelectFieldOption[];
     type: TIdentifier;
+    placeholder?: string;
 }
 export declare abstract class BaseSelectField<TValue extends FieldValue, TIdentifier extends "select" | "multi-select"> extends BaseField<TValue, TIdentifier> {
     readonly options: SelectFieldOption[];
     readonly onlyValidateAfterTouched = false;
+    readonly placeholder: string;
     protected constructor(options: BaseSelectFieldOptions<TValue, TIdentifier>);
     protected _serialize(): {
         options: SelectFieldOption[];
+        placeholder: string;
         label: string;
         required: boolean;
-        description?: string | null | undefined;
+        image?: File | Promise<File>;
+        description?: string | null;
         identifier: string;
         type: TIdentifier;
     };
-    static getFieldCreationSchema(): MultiStringField[];
+    static getFieldCreationSchema(parentPath?: string): {
+        field: MultiStringField;
+        showDirectly: boolean;
+    }[];
 }

package/dist/{fields → forms/fields}/SelectField/MultiSelectField.d.ts

@@ -1,19 +1,26 @@
-import { ISerializedField, SelectFieldOptionValue, SerializedMultiSelectField } from "@overmap-ai/core";
-import { ReactNode } from "react";
-import { GetInputProps } from "../typings";
-import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
-import { CheckboxIcon } from "@radix-ui/react-icons";
+import { ReactNode } from 'react';
+import { RiCheckboxLine } from 'react-icons/ri';
+import { ISerializedField, SelectFieldOptionValue, SerializedMultiSelectField } from '../../typings';
+import { GetInputProps } from '../typings';
+import { BaseSelectField, BaseSelectFieldOptions } from './BaseSelectField';
 /**
  * The options passed to the constructor of MultiSelectField.
  */
 export type MultiSelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue[], "multi-select">, "type">;
+export declare const emptyMultiSelectField: {
+    type: string;
+    options: never[];
+    label: string;
+    description: string;
+    required: boolean;
+};
 export declare class MultiSelectField extends BaseSelectField<SelectFieldOptionValue[], "multi-select"> {
     static readonly fieldTypeName = "Multi-select";
     static readonly fieldTypeDescription = "Allows the user to select a multiple options from a list of options.";
-    static Icon: typeof CheckboxIcon;
+    static Icon: typeof RiCheckboxLine;
     constructor(options: MultiSelectFieldOptions);
-    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | string[]): string[];
-    protected isBlank(value: SelectFieldOptionValue[]): boolean;
+    protected isBlank(value: SelectFieldOptionValue[] | undefined): boolean;
+    isEqual(value1: SelectFieldOptionValue[] | undefined, value2: SelectFieldOptionValue[] | undefined): boolean;
     serialize(): SerializedMultiSelectField;
     static deserialize(data: ISerializedField): MultiSelectField;
     getInput(props: GetInputProps<this>): ReactNode;

package/dist/forms/fields/SelectField/MultiSelectInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { MultiSelectField } from './MultiSelectField';
+export declare const MultiSelectInput: import('react').MemoExoticComponent<(props: ComponentProps<MultiSelectField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/{fields → forms/fields}/SelectField/SelectField.d.ts

@@ -1,18 +1,24 @@
-import { ISerializedField, SelectFieldOptionValue, SerializedSelectField } from "@overmap-ai/core";
-import { ReactNode } from "react";
-import { GetInputProps } from "../typings";
-import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
-import { DropdownMenuIcon } from "@radix-ui/react-icons";
+import { ReactNode } from 'react';
+import { RiMenuFoldLine } from 'react-icons/ri';
+import { ISerializedField, SelectFieldOptionValue, SerializedSelectField } from '../../typings';
+import { GetInputProps } from '../typings';
+import { BaseSelectField, BaseSelectFieldOptions } from './BaseSelectField';
 /**
  * The options passed to the constructor of SelectField.
  */
 export type SelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue, "select">, "type">;
+export declare const emptySelectField: {
+    type: string;
+    options: never[];
+    label: string;
+    description: string;
+    required: boolean;
+};
 export declare class SelectField extends BaseSelectField<SelectFieldOptionValue, "select"> {
     static readonly fieldTypeName = "Dropdown";
     static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
-    static Icon: typeof DropdownMenuIcon;
+    static Icon: typeof RiMenuFoldLine;
     constructor(options: SelectFieldOptions);
-    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | string): SelectFieldOptionValue;
     serialize(): SerializedSelectField;
     static deserialize(data: ISerializedField): SelectField;
     getInput(props: GetInputProps<this>): ReactNode;

package/dist/forms/fields/SelectField/SelectInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { SelectField } from './SelectField';
+export declare const SelectInput: import('react').MemoExoticComponent<(props: ComponentProps<SelectField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/SelectField/index.d.ts

@@ -0,0 +1,4 @@
+export * from './MultiSelectField';
+export * from './MultiSelectInput';
+export * from './SelectField';
+export * from './SelectInput';

package/dist/forms/fields/StringOrTextFields/StringField/StringField.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { RiInputField } from 'react-icons/ri';
+import { ISerializedField, SerializedStringField, StringInputType } from '../../../typings';
+import { GetInputProps } from '../../typings';
+import { StringOrTextField, StringOrTextFieldOptions } from '../StringOrTextField';
+export interface StringFieldOptions extends Omit<StringOrTextFieldOptions, "type"> {
+    inputType?: StringInputType;
+}
+export declare const emptyStringField: {
+    type: string;
+    maximum_length: number;
+    input_type: string;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class StringField extends StringOrTextField<"string"> {
+    static readonly fieldTypeName = "Short Text";
+    static readonly fieldTypeDescription = "Short text fields can hold up to 500 characters on a single line.";
+    readonly inputType: StringInputType;
+    static Icon: typeof RiInputField;
+    constructor(options: StringFieldOptions);
+    serialize(): SerializedStringField;
+    static deserialize(data: ISerializedField): StringField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/StringOrTextFields/StringField/StringInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../../typings';
+import { StringField } from './StringField';
+export declare const StringInput: import('react').MemoExoticComponent<(props: ComponentProps<StringField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/StringOrTextFields/StringField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './StringField';
+export * from './StringInput';

package/dist/{fields → forms/fields}/StringOrTextFields/StringOrTextField.d.ts

@@ -1,10 +1,11 @@
-import { NumberField, NumberFieldValue } from "../NumberField";
-import { BaseField, FieldOptions } from "../BaseField";
-import { SerializedStringField } from "@overmap-ai/core";
+import { SerializedStringField } from '../../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { NumberField } from '../NumberField';
 import { InputFieldLevelValidator, InputValidator } from '../typings';
 export interface StringOrTextFieldOptions extends FieldOptions<string> {
-    minLength?: NumberFieldValue;
-    maxLength?: NumberFieldValue;
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
 }
 export type SerializedStringOrTextField<TIdentifier extends "string" | "text"> = Omit<SerializedStringField, "type"> & {
     type: TIdentifier;
@@ -12,18 +13,22 @@ export type SerializedStringOrTextField<TIdentifier extends "string" | "text"> =
 export declare abstract class StringOrTextField<TIdentifier extends "string" | "text"> extends BaseField<string, TIdentifier> {
     readonly minLength?: number;
     readonly maxLength: number;
+    readonly placeholder: string;
     protected constructor(options: StringOrTextFieldOptions);
     /**
-     * This function validates that the value given for "minimum length" (when creating a new field) is less than or
+     * This function returns a function that validates that the value given for "minimum length" (when creating a new field) is less than or
      * equal to the value given for "maximum length".
      */
-    static _validateMin: InputValidator<NumberFieldValue>;
+    static _validateMin: (path: string) => InputValidator<number>;
     /**
-     * This function validates that the value given for "maximum length" (when creating a new field) is greater than or
+     * This function returns a function that validates that the value given for "maximum length" (when creating a new field) is greater than or
      * equal to the value given for "minimum length".
      */
-    static _validateMax: InputValidator<NumberFieldValue>;
-    static getFieldCreationSchema(): NumberField[];
+    static _validateMax: (path: string) => InputValidator<number>;
+    static getFieldCreationSchema(parentPath?: string): {
+        field: NumberField;
+        showDirectly: boolean;
+    }[];
     getFieldValidators(): InputFieldLevelValidator<string>[];
     protected _serialize(): SerializedStringOrTextField<TIdentifier>;
 }

package/dist/forms/fields/StringOrTextFields/TextField/TextField.d.ts

@@ -0,0 +1,22 @@
+import { ReactNode } from 'react';
+import { RiAlignJustify } from 'react-icons/ri';
+import { ISerializedField, SerializedTextField } from '../../../typings';
+import { GetInputProps } from '../../typings';
+import { StringOrTextField, StringOrTextFieldOptions } from '../StringOrTextField';
+export type TextFieldOptions = Omit<StringOrTextFieldOptions, "type">;
+export declare const emptyTextField: {
+    type: string;
+    maximum_length: number;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class TextField extends StringOrTextField<"text"> {
+    static readonly fieldTypeName = "Paragraph";
+    static readonly fieldTypeDescription = "Paragraph fields can hold up to 10000 characters and can have multiple lines.";
+    static Icon: typeof RiAlignJustify;
+    constructor(options: TextFieldOptions);
+    serialize(): SerializedTextField;
+    static deserialize(data: ISerializedField): TextField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/StringOrTextFields/TextField/TextInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../../typings';
+import { TextField } from './TextField';
+export declare const TextInput: import('react').MemoExoticComponent<(props: ComponentProps<TextField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/StringOrTextFields/TextField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TextField';
+export * from './TextInput';

package/dist/forms/fields/StringOrTextFields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './StringField';
+export * from './TextField';

package/dist/forms/fields/UploadField/UploadField.d.ts

@@ -0,0 +1,44 @@
+import { ReactNode } from 'react';
+import { RiUpload2Line } from 'react-icons/ri';
+import { ISerializedField, SerializedUploadField } from '../../typings';
+import { BaseField, ChildFieldOptions } from '../BaseField';
+import { NumberField } from '../NumberField';
+import { MultiSelectField } from '../SelectField';
+import { GetInputProps, InputFieldLevelValidator } from '../typings';
+export interface UploadFieldOptions extends ChildFieldOptions<File[]> {
+    extensions?: string[];
+    maximum_size?: number | string;
+    maximum_files?: number | string;
+}
+export declare const emptyUploadField: {
+    type: string;
+    extensions: never[];
+    maximum_size: undefined;
+    maximum_files: number;
+    label: string;
+    description: string;
+    required: boolean;
+};
+export declare class UploadField extends BaseField<File[], "upload"> {
+    static readonly fieldTypeName = "Upload";
+    static readonly fieldTypeDescription = "Allows a file to be uploaded.";
+    readonly extensions?: string[];
+    readonly maxFileSize: number | undefined;
+    readonly maxFiles: number;
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof RiUpload2Line;
+    constructor(options: UploadFieldOptions);
+    protected isBlank(value: File[] | undefined): boolean;
+    isEqual(value1: File[] | undefined, value2: File[] | undefined): boolean;
+    static getFieldCreationSchema(parentPath?: string): ({
+        field: NumberField;
+        showDirectly: boolean;
+    } | {
+        field: MultiSelectField;
+        showDirectly: boolean;
+    })[];
+    getFieldValidators(): InputFieldLevelValidator<File[]>[];
+    serialize(): SerializedUploadField;
+    static deserialize(data: ISerializedField): UploadField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/forms/fields/UploadField/UploadInput.d.ts

@@ -0,0 +1,3 @@
+import { ComponentProps } from '../typings';
+import { UploadField } from './UploadField';
+export declare const UploadInput: import('react').MemoExoticComponent<(props: ComponentProps<UploadField>) => import("react/jsx-runtime").JSX.Element>;

package/dist/forms/fields/UploadField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './UploadField';
+export * from './UploadInput';

package/dist/forms/fields/constants.d.ts

@@ -0,0 +1,106 @@
+import { BooleanField } from './BooleanField';
+import { CustomField } from './CustomField';
+import { DateField } from './DateField';
+import { MultiStringField } from './MultiStringField';
+import { NumberField } from './NumberField';
+import { QrField } from './QrField';
+import { MultiSelectField, SelectField } from './SelectField';
+import { StringField, TextField } from './StringOrTextFields';
+import { UploadField } from './UploadField';
+export declare const FieldTypeToClsMapping: {
+    readonly date: typeof DateField;
+    readonly number: typeof NumberField;
+    readonly boolean: typeof BooleanField;
+    readonly select: typeof SelectField;
+    readonly string: typeof StringField;
+    readonly text: typeof TextField;
+    readonly custom: typeof CustomField;
+    readonly upload: typeof UploadField;
+    readonly qr: typeof QrField;
+    readonly "multi-string": typeof MultiStringField;
+    readonly "multi-select": typeof MultiSelectField;
+};
+export declare const FieldTypeToEmptyFieldMapping: {
+    readonly date: {
+        type: string;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly number: {
+        type: string;
+        minimum: number;
+        maximum: number;
+        integers: boolean;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly boolean: {
+        type: string;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly select: {
+        type: string;
+        options: never[];
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly string: {
+        type: string;
+        maximum_length: number;
+        input_type: string;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly text: {
+        type: string;
+        maximum_length: number;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly custom: {
+        type: string;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly upload: {
+        type: string;
+        extensions: never[];
+        maximum_size: undefined;
+        maximum_files: number;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly qr: {
+        type: string;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly "multi-string": {
+        type: string;
+        minimum_length: number;
+        maximum_length: null;
+        label: string;
+        description: string;
+        required: boolean;
+    };
+    readonly "multi-select": {
+        type: string;
+        options: never[];
+        label: string;
+        description: string;
+        required: boolean;
+    };
+};
+export declare const maxFileSizeMB = 50;
+export declare const maxFileSizeKB: number;
+export declare const maxFileSizeB: number;

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

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import { FieldValue } from '../typings';
+import { BaseField, BaseFormElement } from './BaseField';
+import { GetInputProps } from './typings';
+export declare const useFieldInput: <TField extends BaseFormElement | null>(field: TField, props: TField extends BaseFormElement ? GetInputProps<TField> : null) => ReactNode;
+export declare const useFieldInputs: (fields: BaseFormElement[], props: GetInputProps<BaseField<FieldValue>>) => ReactNode;

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

@@ -0,0 +1,12 @@
+export * from './BaseField';
+export * from './BooleanField';
+export * from './DateField';
+export * from './FieldSection';
+export * from './hooks';
+export * from './MultiStringField';
+export * from './NumberField';
+export * from './QrField';
+export * from './SelectField';
+export * from './StringOrTextFields';
+export * from './typings';
+export * from './utils';

package/dist/{fields → forms/fields}/typings.d.ts

@@ -1,7 +1,8 @@
-import { HTMLProps, ReactNode } from "react";
-import { Form } from '../typings';
-import { BaseField, BaseFormElement } from "./BaseField";
-import { ISerializedField, SerializedFieldSection } from "@overmap-ai/core";
+import { TextSize } from '@overmap-ai/blocks';
+import { HTMLProps, ReactNode } from 'react';
+import { FormikFormRevision } from '../builder';
+import { FormValues, ValueOfField } from '../typings';
+import { BaseField, BaseFormElement } from './BaseField';
 export interface SchemaMeta {
     readonly: boolean;
 }
@@ -13,12 +14,14 @@ export interface ISchema {
     description?: ReactNode;
 }
 export type InputFieldLevelValidator<TValue> = (value: TValue | undefined) => string | null | undefined;
-export type InputFormLevelValidator<TValue> = (value: TValue | undefined, allValues: Form) => string | null | undefined;
+export type InputFormLevelValidator<TValue> = (value: TValue | undefined, allValues: FormValues | FormikFormRevision) => string | null | undefined;
 export type InputValidator<TValue> = InputFieldLevelValidator<TValue> | InputFormLevelValidator<TValue>;
 export interface ComponentProps<TField extends BaseFormElement> extends Omit<HTMLProps<HTMLElement>, "color" | "size" | "ref" | "type" | "onChange" | "onBlur" | "value" | "defaultValue" | "name" | "dir"> {
     field: TField;
     formId: string;
+    size?: TextSize;
+    onValuesChange?: (identifier: string, value: ValueOfField<AnyField>) => void;
+    showInputOnly?: boolean;
 }
 export type GetInputProps<TField extends BaseFormElement> = Omit<ComponentProps<TField>, "field">;
-export type AnyField = BaseField<any>;
-export type ISerializedOnlyField = Exclude<ISerializedField, SerializedFieldSection>;
+export type AnyField = BaseField<any, any>;

package/dist/forms/fields/utils.d.ts

@@ -0,0 +1,18 @@
+import { FormRevision, ISerializedOnlyField } from '@overmap-ai/core';
+import { FieldValue, ISerializedField, SerializedCondition } from '../typings';
+import { FieldSection } from './FieldSection';
+import { AnyField, ISchema, SchemaMeta } from './typings';
+/** Deserializes anything but a FieldSection.
+ * @see `deserialize` for most use cases
+ */
+export declare const deserializeField: (serializedField: ISerializedOnlyField) => AnyField;
+/** Deserializes anything */
+export declare const deserialize: (serialized: ISerializedField) => AnyField | FieldSection;
+export type PartialFormRevision = Pick<FormRevision, "title" | "fields" | "description"> & Partial<FormRevision>;
+export declare function formRevisionToSchema(formRevision: PartialFormRevision, meta?: Partial<SchemaMeta>): ISchema;
+export declare function flattenFields(schema: ISchema): AnyField[];
+export declare function getFieldsMapping(schema: ISchema): Record<string, AnyField>;
+export declare function decodeFormValues(schema: ISchema, values: Record<string, string>): Record<string, FieldValue>;
+export declare function encodeFormValues(schema: ISchema, values: Record<string, FieldValue>): Record<string, string>;
+export declare function valueIsFile(v: FieldValue | Promise<File>[] | undefined): v is File[] | Promise<File>[];
+export declare function isConditionMet<TValue extends FieldValue | Promise<File>[]>(condition: TValue extends FieldValue ? SerializedCondition<TValue> | null : null, value: TValue): boolean;

package/dist/forms/index.d.ts

@@ -0,0 +1,6 @@
+export * from './builder';
+export { fieldIcons } from './constants';
+export * from './fields';
+export * from './renderer';
+export * from './typings';
+export { initialFormValues, validateForm } from './utils';