@overmap-ai/forms 1.0.0

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

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { FieldInputClonerProps } from "./typings.ts";
+/**
+ * Used to dynamically "clone" a field's input for use in conditional sections. When a field is selected for a
+ * condition, we need to render the same input in the condition section, so the user can input a value for the
+ * condition.
+ */
+export declare const FieldInputCloner: import("react").NamedExoticComponent<FieldInputClonerProps>;

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

@@ -0,0 +1,18 @@
+import { CustomField, CustomFieldOptions } from "../CustomField";
+import { FieldValue, ISerializedField } from "@overmap-ai/core";
+import { FieldInputClonerProps } from "./index";
+export interface FieldInputClonerFieldOptions extends CustomFieldOptions<unknown> {
+    /** Given an identifier, should return the options of the field with the
+     * corresponding identifier (the field being cloned) */
+    getFieldToClone: (identifier: string) => ISerializedField | null;
+    /** The identifier of the field to clone */
+    clonedFieldIdentifier: string;
+}
+/**
+ * The purpose of this is to display a value input field in the condition of a section. The input field will look like
+ * the input field of the condition. For example, when specifying the conditional value of a SelectField, a SelectInput
+ * will be rendered.
+ */
+export declare class FieldInputClonerField extends CustomField<FieldValue, FieldInputClonerFieldOptions, FieldInputClonerProps> {
+    constructor(options: FieldInputClonerFieldOptions);
+}

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

@@ -0,0 +1,3 @@
+export * from "./FieldInputCloner";
+export * from "./FieldInputClonerField";
+export * from "./typings";

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

@@ -0,0 +1,5 @@
+import { FieldValue } from "@overmap-ai/core";
+import { AnyField, ComponentProps, GetInputProps } from "../../typings";
+import { CustomField } from "../CustomField";
+import { FieldInputClonerFieldOptions } from "./FieldInputClonerField";
+export type FieldInputClonerProps = ComponentProps<CustomField<FieldValue, FieldInputClonerFieldOptions, GetInputProps<AnyField>>>;

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

@@ -0,0 +1 @@
+export * from "./CustomField";

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

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

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

@@ -0,0 +1,2 @@
+export * from "./DateField";
+export * from "./DateInput";

package/dist/fields/FieldSection/FieldSection.d.ts

@@ -0,0 +1,29 @@
+import { BaseSerializedObject, ISerializedField, SerializedCondition, SerializedFieldSection } from "@overmap-ai/core";
+import { GetInputProps } from '..';
+import { AnyField } from '../typings';
+import { BaseFormElement } from '../BaseField';
+import React from "react";
+import { Form } from '../../typings';
+interface FieldSectionOptions extends Omit<BaseSerializedObject, "type"> {
+    label?: string | null;
+    conditional?: boolean;
+    condition?: SerializedCondition | null;
+    fields: AnyField[];
+}
+export declare class FieldSection extends BaseFormElement<"section"> {
+    static readonly fieldTypeName = "Section";
+    static readonly fieldTypeDescription = "Sections can be useful for grouping fields together. They can also be conditionally shown or hidden.";
+    readonly label: string | null;
+    readonly fields: AnyField[];
+    readonly condition: SerializedCondition | null;
+    constructor(options: FieldSectionOptions);
+    static getFieldCreationSchema(options: ISerializedField[]): BaseFormElement[];
+    static deserialize(data: ISerializedField): FieldSection;
+    conditional(): this is {
+        condition: SerializedCondition;
+    };
+    serialize(): SerializedFieldSection;
+    getErrors(allValues: Form): Record<string, string>;
+    getInput(props: GetInputProps<this>): React.ReactNode;
+}
+export {};

package/dist/fields/FieldSection/FieldSectionLayout.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { ComponentProps } from '..';
+import { FieldSection } from ".";
+/**
+ * Used by FieldSection to render a section of fields.
+ */
+export declare const FieldSectionLayout: import("react").NamedExoticComponent<ComponentProps<FieldSection>>;

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

@@ -0,0 +1 @@
+export * from "./FieldSection";

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

@@ -0,0 +1,8 @@
+import { ComponentProps } from "../typings.ts";
+import React from "react";
+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: React.NamedExoticComponent<ComponentProps<MultiStringField>>;

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

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

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

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

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

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

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

@@ -0,0 +1,26 @@
+import { FieldValue, SelectFieldOption } from "@overmap-ai/core";
+import { BaseField, ChildFieldOptions } from "../BaseField";
+import { MultiStringField } from "../MultiStringField";
+/**
+ * The options passed to the constructor of SelectField.
+ */
+export interface BaseSelectFieldOptions<TValue, TIdentifier extends "select" | "multi-select"> extends ChildFieldOptions<TValue> {
+    /** When instantiating a SelectField, you can either pass an array of strings or an array of objects. User-created
+     * forms only support arrays of strings. For more complex internal purposes, you can provide an array of objects
+     * 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;
+}
+export declare abstract class BaseSelectField<TValue extends FieldValue, TIdentifier extends "select" | "multi-select"> extends BaseField<TValue, TIdentifier> {
+    readonly options: SelectFieldOption[];
+    protected constructor(options: BaseSelectFieldOptions<TValue, TIdentifier>);
+    protected _serialize(): {
+        options: SelectFieldOption[];
+        label: string;
+        required: boolean;
+        description?: string | null | undefined;
+        identifier: string;
+        type: TIdentifier;
+    };
+    static getFieldCreationSchema(): MultiStringField[];
+}

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+import { NumberField, NumberFieldValue } from "../NumberField";
+import { BaseField, FieldOptions } from "../BaseField";
+import { SerializedStringField } from "@overmap-ai/core";
+import { InputFieldLevelValidator, InputValidator } from '../typings';
+export interface StringOrTextFieldOptions extends FieldOptions<string> {
+    minLength?: NumberFieldValue;
+    maxLength?: NumberFieldValue;
+}
+export type SerializedStringOrTextField<TIdentifier extends "string" | "text"> = Omit<SerializedStringField, "type"> & {
+    type: TIdentifier;
+};
+export declare abstract class StringOrTextField<TIdentifier extends "string" | "text"> extends BaseField<string, TIdentifier> {
+    readonly minLength?: number;
+    readonly maxLength: number;
+    protected constructor(options: StringOrTextFieldOptions);
+    /**
+     * This function 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>;
+    /**
+     * This function 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[];
+    getFieldValidators(): InputFieldLevelValidator<string>[];
+    protected _serialize(): SerializedStringOrTextField<TIdentifier>;
+}

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

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

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

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

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

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

package/dist/fields/constants.d.ts

@@ -0,0 +1,18 @@
+import { StringField, TextField } from "./StringOrTextFields";
+import { BooleanField } from "./BooleanField";
+import { DateField } from "./DateField";
+import { NumberField } from "./NumberField";
+import { MultiSelectField, SelectField } from "./SelectField";
+import { CustomField } from "./CustomField";
+import { MultiStringField } from "./MultiStringField";
+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 "multi-string": typeof MultiStringField;
+    readonly "multi-select": typeof MultiSelectField;
+};

package/dist/fields/hooks.d.ts

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

package/dist/fields/index.d.ts

@@ -0,0 +1,11 @@
+export type { BaseField } from "./BaseField";
+export * from "./NumberField";
+export * from "./DateField";
+export * from "./StringOrTextFields";
+export * from "./BooleanField";
+export * from "./SelectField";
+export * from "./MultiStringField";
+export * from "./FieldSection";
+export * from "./utils";
+export * from "./hooks";
+export type * from "./typings";

package/dist/fields/typings.d.ts

@@ -0,0 +1,24 @@
+import { HTMLProps, ReactNode } from "react";
+import { Form } from '../typings';
+import { BaseField, BaseFormElement } from "./BaseField";
+import { ISerializedField, SerializedFieldSection } from "@overmap-ai/core";
+export interface SchemaMeta {
+    readonly: boolean;
+}
+export interface ISchema {
+    id?: string;
+    fields: BaseFormElement[];
+    meta: SchemaMeta;
+    title: ReactNode;
+    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 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;
+}
+export type GetInputProps<TField extends BaseFormElement> = Omit<ComponentProps<TField>, "field">;
+export type AnyField = BaseField<any>;
+export type ISerializedOnlyField = Exclude<ISerializedField, SerializedFieldSection>;

package/dist/fields/utils.d.ts

@@ -0,0 +1,12 @@
+import { AnyField, ISchema, ISerializedOnlyField, SchemaMeta } from "./typings";
+import { FieldValue, ISerializedField, SerializedCondition, UserFormRevision } from "@overmap-ai/core";
+import { FieldSection } from "./FieldSection";
+/** 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<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;