@overmap-ai/forms 1.0.0 → 1.0.2

package/dist/builder/utils.d.ts

@@ -8,4 +8,4 @@ export declare function insert<T>(list: T[] | undefined, index: number, value: 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)[];
+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 | import("@overmap-ai/core").SerializedUploadField)[];

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

@@ -21,9 +21,17 @@ export declare abstract class BaseField<TValue extends FieldValue, TIdentifier e
     private readonly formValidators;
     private readonly fieldValidators;
     readonly label: string;
+    /**
+     * By default, validation doesn't execute on `onChange` events when editing fields
+     * until the field has been `touched`. This can be overridden by setting this to `false`
+     * if you want to validate on every `onChange` event. This is important for fields like booleans
+     * which don't have a `onBlur` event (which is used to set the `touched` state).
+     */
+    readonly onlyValidateAfterTouched: boolean;
     protected constructor(options: FieldOptions<TValue>);
     static getFieldCreationSchema(): AnyField[];
     protected isBlank(value: TValue): boolean;
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement>): TValue;
     getError(value: TValue, allValues?: Form): string | undefined;
     protected _serialize(): BaseSerializedField<TIdentifier>;
     abstract serialize(): ISerializedOnlyField;

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

@@ -0,0 +1,17 @@
+import { ISerializedField, SerializedBooleanField } from "@overmap-ai/core";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { ChangeEvent, ReactNode } from "react";
+import { ComponentProps } from "../typings";
+import { CheckCircledIcon } from "@overmap-ai/blocks";
+export declare class BooleanField extends BaseField<boolean, "boolean"> {
+    static readonly fieldTypeName = "Checkbox";
+    static readonly fieldTypeDescription = "Perfect for both optional and required yes/no questions.";
+    readonly onlyValidateAfterTouched = false;
+    static Icon: typeof CheckCircledIcon;
+    constructor(options: ChildFieldOptions<boolean>);
+    protected isBlank(value: boolean): boolean;
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement> | boolean): boolean;
+    serialize(): SerializedBooleanField;
+    static deserialize(data: ISerializedField): BooleanField;
+    getInput(props: ComponentProps<BooleanField>): ReactNode;
+}

package/dist/fields/DateField/DateField.d.ts

@@ -0,0 +1,16 @@
+import { ISerializedField, SerializedDateField } from "@overmap-ai/core";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps } from "../typings";
+import React from "react";
+import { CalendarIcon } from "@overmap-ai/blocks";
+export declare class DateField extends BaseField<string, "date"> {
+    static readonly fieldTypeName = "Date";
+    static readonly fieldTypeDescription = "Allows specifying a date.";
+    static Icon: typeof CalendarIcon;
+    readonly onlyValidateAfterTouched = false;
+    constructor(options: ChildFieldOptions<string>);
+    serialize(): SerializedDateField;
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement>): string;
+    static deserialize(data: ISerializedField): DateField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}

package/dist/fields/DateField/DateInput.d.ts

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

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

@@ -0,0 +1,30 @@
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { ISerializedField, SelectFieldOption, SerializedMultiStringField } from "@overmap-ai/core";
+import { GetInputProps, InputFieldLevelValidator } from "../typings.ts";
+import { ReactNode } from "react";
+import { ListBulletIcon } from "@overmap-ai/blocks";
+type MultiStringFieldOptions = ChildFieldOptions<SelectFieldOption[]> & {
+    minimum_length?: number;
+    maximum_length?: number;
+};
+/**
+ * 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<SelectFieldOption[], "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;
+    static Icon: typeof ListBulletIcon;
+    constructor(options: MultiStringFieldOptions);
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | SelectFieldOption[]): SelectFieldOption[];
+    getInput(props: GetInputProps<this>): ReactNode;
+    serialize(): SerializedMultiStringField;
+    protected isBlank(value: SelectFieldOption[]): boolean;
+    getFieldValidators(): InputFieldLevelValidator<SelectFieldOption[]>[];
+    static deserialize(data: ISerializedField): MultiStringField;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ISerializedField, SerializedNumberField } from "@overmap-ai/core";
+import { BooleanField } from "../BooleanField";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps, InputFieldLevelValidator, InputValidator } from "../typings";
+import { ChangeEvent, ReactNode } from "react";
+import { FontFamilyIcon } from "@overmap-ai/blocks";
+export type NumberFieldValue = number | "";
+export interface NumberFieldOptions extends ChildFieldOptions<NumberFieldValue> {
+    maximum?: number;
+    minimum?: number;
+    integers?: boolean;
+}
+export declare class NumberField extends BaseField<NumberFieldValue, "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;
+    static Icon: typeof FontFamilyIcon;
+    constructor(options: NumberFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement>): NumberFieldValue;
+    static _validateMin: InputValidator<NumberFieldValue>;
+    static _validateMax: InputValidator<NumberFieldValue>;
+    static getFieldCreationSchema(): (BooleanField | NumberField)[];
+    getFieldValidators(): InputFieldLevelValidator<NumberFieldValue>[];
+    serialize(): SerializedNumberField;
+    static deserialize(data: ISerializedField): NumberField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

package/dist/fields/SelectField/BaseSelectField.d.ts

@@ -13,6 +13,7 @@ export interface BaseSelectFieldOptions<TValue, TIdentifier extends "select" | "
 }
 export declare abstract class BaseSelectField<TValue extends FieldValue, TIdentifier extends "select" | "multi-select"> extends BaseField<TValue, TIdentifier> {
     readonly options: SelectFieldOption[];
+    readonly onlyValidateAfterTouched = false;
     protected constructor(options: BaseSelectFieldOptions<TValue, TIdentifier>);
     protected _serialize(): {
         options: SelectFieldOption[];

package/dist/fields/SelectField/MultiSelectField.d.ts

@@ -0,0 +1,20 @@
+import { ISerializedField, SelectFieldOptionValue, SerializedMultiSelectField } from "@overmap-ai/core";
+import { ReactNode } from "react";
+import { GetInputProps } from "../typings";
+import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
+import { CheckboxIcon } from "@overmap-ai/blocks";
+/**
+ * The options passed to the constructor of MultiSelectField.
+ */
+export type MultiSelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue[], "multi-select">, "type">;
+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;
+    constructor(options: MultiSelectFieldOptions);
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | string[]): string[];
+    protected isBlank(value: SelectFieldOptionValue[]): boolean;
+    serialize(): SerializedMultiSelectField;
+    static deserialize(data: ISerializedField): MultiSelectField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

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

@@ -0,0 +1,19 @@
+import { ISerializedField, SelectFieldOptionValue, SerializedSelectField } from "@overmap-ai/core";
+import { ReactNode } from "react";
+import { GetInputProps } from "../typings";
+import { BaseSelectField, BaseSelectFieldOptions } from "./BaseSelectField";
+import { DropdownMenuIcon } from "@overmap-ai/blocks";
+/**
+ * The options passed to the constructor of SelectField.
+ */
+export type SelectFieldOptions = Omit<BaseSelectFieldOptions<SelectFieldOptionValue, "select">, "type">;
+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;
+    constructor(options: SelectFieldOptions);
+    getValueFromChangeEvent(event: React.ChangeEvent<HTMLInputElement> | string): SelectFieldOptionValue;
+    serialize(): SerializedSelectField;
+    static deserialize(data: ISerializedField): SelectField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

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

@@ -0,0 +1,19 @@
+import { ISerializedField, SerializedStringField, StringInputType } from "@overmap-ai/core";
+import { StringOrTextField, StringOrTextFieldOptions } from "../StringOrTextField";
+import { GetInputProps } from "../../typings";
+import React from "react";
+import { InputIcon } from "@overmap-ai/blocks";
+interface StringFieldOptions extends Omit<StringOrTextFieldOptions, "type"> {
+    inputType?: StringInputType;
+}
+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 InputIcon;
+    constructor(options: StringFieldOptions);
+    serialize(): SerializedStringField;
+    static deserialize(data: ISerializedField): StringField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { ISerializedField, SerializedTextField } from "@overmap-ai/core";
+import { StringOrTextField, StringOrTextFieldOptions } from "../StringOrTextField";
+import { GetInputProps } from "../../typings";
+import React from "react";
+import { RowsIcon } from "@overmap-ai/blocks";
+export interface TextFieldOptions extends Omit<StringOrTextFieldOptions, "type"> {
+}
+export declare class TextField extends StringOrTextField<"text"> {
+    static readonly fieldTypeName = "Paragraph";
+    static readonly fieldTypeDescription = "Paragraph fields can hold up to 5000 characters and can have multiple lines.";
+    static Icon: typeof RowsIcon;
+    constructor(options: TextFieldOptions);
+    serialize(): SerializedTextField;
+    static deserialize(data: ISerializedField): TextField;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}

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

@@ -0,0 +1,29 @@
+import { ISerializedField, SerializedUploadField } from "@overmap-ai/core";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { GetInputProps, InputFieldLevelValidator } from "../typings";
+import { ChangeEvent, ReactNode } from "react";
+import { UploadIcon } from "@overmap-ai/blocks";
+import { NumberField } from "../NumberField";
+import { MultiSelectField } from "../SelectField";
+export interface UploadFieldOptions extends ChildFieldOptions<File[]> {
+    extensions?: string[];
+    maximum_size?: number | string;
+    maximum_files?: number | string;
+}
+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 UploadIcon;
+    constructor(options: UploadFieldOptions);
+    getValueFromChangeEvent(event: ChangeEvent<HTMLInputElement>): File[];
+    protected isBlank(value: File[]): boolean;
+    static getFieldCreationSchema(): (NumberField | MultiSelectField)[];
+    getFieldValidators(): InputFieldLevelValidator<File[]>[];
+    serialize(): SerializedUploadField;
+    static deserialize(data: ISerializedField): UploadField;
+    getInput(props: GetInputProps<this>): ReactNode;
+}

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

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

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

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

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

@@ -0,0 +1 @@
+export declare const convertBytesToLargestUnit: (bytes: number) => string;

package/dist/fields/constants.d.ts

@@ -5,6 +5,7 @@ import { NumberField } from "./NumberField";
 import { MultiSelectField, SelectField } from "./SelectField";
 import { CustomField } from "./CustomField";
 import { MultiStringField } from "./MultiStringField";
+import { UploadField } from "./UploadField";
 export declare const FieldTypeToClsMapping: {
     readonly date: typeof DateField;
     readonly number: typeof NumberField;
@@ -13,6 +14,7 @@ export declare const FieldTypeToClsMapping: {
     readonly string: typeof StringField;
     readonly text: typeof TextField;
     readonly custom: typeof CustomField;
+    readonly upload: typeof UploadField;
     readonly "multi-string": typeof MultiStringField;
     readonly "multi-select": typeof MultiSelectField;
 };

package/dist/fields/utils.d.ts

@@ -9,4 +9,5 @@ export declare const deserializeField: (serializedField: ISerializedOnlyField) =
 export declare const deserialize: (serialized: ISerializedField) => AnyField | FieldSection;
 export type PartialFormRevision = Pick<UserFormRevision, "title" | "fields" | "description"> & Partial<UserFormRevision>;
 export declare function formRevisionToSchema(formRevision: PartialFormRevision, meta?: Partial<SchemaMeta>): ISchema;
-export declare function isConditionMet<TValue extends FieldValue>(condition: SerializedCondition<TValue> | null, value: TValue): boolean;
+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;