@overmap-ai/forms 1.0.31 → 1.0.32-condition-manager.1

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

@@ -1,36 +1,13 @@
-import { ReactNode } from 'react';
-import { FormBuilderValues } from '../../builder';
-import { FormValues } from '../../typings';
-import { FieldSection } from '../FieldSection';
-import { AnyField, FieldTypeIdentifier, FieldValue, GetInputProps, InputFieldLevelValidator, InputFormLevelValidator, ISerializedField, ISerializedOnlyField } from '../typings';
-import { BaseSerializedField, BaseSerializedObject, FieldOptions } from './typings';
-export declare abstract class BaseFormElement<TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> {
-    readonly type: TIdentifier;
-    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 const emptyBaseField: {
-    label: string;
-    description: string;
-    required: boolean;
-};
-export interface FieldCreationSchemaObject {
-    field: AnyField;
-    showDirectly: boolean;
-}
-export declare abstract class BaseField<TValue extends FieldValue, TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> extends BaseFormElement<TIdentifier> {
+import { BaseFormElement } from '../BaseFormElement';
+import { BaseSerializedField, FieldOptions, FieldValidator } from './typings';
+export declare abstract class BaseField<TIdentifier extends string, TValue, TSerializedValue, This extends BaseField<TIdentifier, TValue, TSerializedValue, This>> extends BaseFormElement<TIdentifier, This> {
     static readonly fieldTypeName: string;
     static readonly fieldTypeDescription: string;
-    readonly required: boolean;
-    private readonly formValidators;
-    private readonly fieldValidators;
-    readonly label: string;
-    readonly image: File | Promise<File> | undefined;
+    label: string;
+    description: string | null;
+    required: boolean;
+    private fieldValidators;
+    image: File | Promise<File> | undefined;
     /**
      * 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`
@@ -39,14 +16,16 @@ export declare abstract class BaseField<TValue extends FieldValue, TIdentifier e
      */
     readonly onlyValidateAfterTouched: boolean;
     protected constructor(options: FieldOptions<TValue>);
-    static getFieldCreationSchema(): FieldCreationSchemaObject[];
-    protected isBlank(value: TValue | undefined): boolean;
-    isEqual(value1: TValue | undefined, value2: TValue | undefined): boolean;
-    getError(value: TValue | undefined, allValues?: FormValues | FormBuilderValues): string | undefined;
-    protected _serialize(): BaseSerializedField<TIdentifier>;
-    abstract serialize(): ISerializedOnlyField;
-    getFieldValidators(): InputFieldLevelValidator<TValue>[];
-    getFormValidators(): InputFormLevelValidator<TValue>[];
-    encodeValueToJson(value: TValue): string;
-    decodeJsonToValue(json: string): TValue;
+    getError(value: TValue): string | undefined;
+    serialize(): BaseSerializedField<TIdentifier>;
+    getOptions(): FieldOptions<TValue>;
+    setOptions(options: Partial<FieldOptions<TValue>>): void;
+    abstract isSerializedValueValid(value: unknown): value is TSerializedValue;
+    abstract serializeValue(value: TValue): TSerializedValue;
+    abstract isValueValid(value: unknown): value is TValue;
+    abstract areValuesEqual(value1: TValue, value2: TValue): boolean;
+    abstract deserializeValue(value: TSerializedValue): TValue;
+    isValueBlank(value: TValue): boolean;
+    abstract blankValue(): TValue;
+    getFieldValidators(): FieldValidator<TValue>[];
 }

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

@@ -1,3 +1,2 @@
 export * from './BaseField';
-export * from './hooks';
 export * from './typings';

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

@@ -1,16 +1,20 @@
-import { FieldTypeIdentifier, InputFieldLevelValidator, InputFormLevelValidator } from '../typings';
-export interface BaseSerializedObject<TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> {
+import { BaseSerializedObject, FormElementOptions } from '../BaseFormElement';
+import { AnyField } from '../typings';
+export interface BaseSerializedField<TIdentifier extends string> extends BaseSerializedObject<TIdentifier> {
+    label: string;
     description?: string | null;
-    identifier: string;
-    type: TIdentifier;
+    required: boolean;
+    image?: File | Promise<File>;
 }
-export interface BaseSerializedField<TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> extends BaseSerializedObject<TIdentifier> {
+export interface FieldOptions<TValue> extends FormElementOptions {
     label: string;
+    description?: string | null;
     required: boolean;
     image?: File | Promise<File>;
+    fieldValidators?: FieldValidator<TValue>[];
 }
-export interface FieldOptions<TValue> extends BaseSerializedField {
-    fieldValidators?: InputFieldLevelValidator<TValue>[];
-    formValidators?: InputFormLevelValidator<TValue>[];
+export interface FieldCreationSchemaObject {
+    field: AnyField;
+    showDirectly: boolean;
 }
-export type ChildFieldOptions<TValue> = Omit<FieldOptions<TValue>, "type">;
+export type FieldValidator<TValue> = (value: TValue) => string | null | undefined;

package/dist/form/fields/BaseFormElement/BaseFormElement.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { Observable } from '../../Observable/Observable';
+import { BaseSerializedObject, FieldRenderProps, FormElementOptions } from './typings';
+export declare abstract class BaseFormElement<TIdentifier extends string, This extends BaseFormElement<TIdentifier, This>> extends Observable<This> {
+    abstract readonly type: TIdentifier;
+    identifier: string;
+    protected constructor(options: FormElementOptions);
+    getOptions(): FormElementOptions;
+    setOptions(options: Partial<FormElementOptions>): void;
+    abstract duplicate(identifier: string): BaseFormElement<TIdentifier, This>;
+    serialize(): BaseSerializedObject<TIdentifier>;
+    abstract render(props: FieldRenderProps): ReactNode;
+}

package/dist/form/fields/BaseFormElement/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BaseFormElement';
+export * from './typings';

package/dist/form/fields/BaseFormElement/typings.d.ts

@@ -0,0 +1,15 @@
+import { TextSize } from '@overmap-ai/blocks';
+export interface FormElementOptions {
+    identifier: string;
+}
+export interface BaseSerializedObject<TIdentifier extends string> {
+    identifier: string;
+    type: TIdentifier;
+}
+export interface FieldRenderProps {
+    formId: string;
+    size?: TextSize;
+    disabled?: boolean;
+    onValuesChange?: (identifier: string, value: any) => void;
+    showInputOnly?: boolean;
+}

package/dist/form/fields/BaseOptionsField/BaseOptionsField.d.ts

@@ -0,0 +1,14 @@
+import { BaseField, FieldCreationSchemaObject, FieldOptions } from '../BaseField';
+import { BaseSerializedSelectField, SelectFieldOption } from './typings';
+export interface BaseOptionsFieldOptions<TValue> extends FieldOptions<TValue> {
+    options: string[] | SelectFieldOption[];
+}
+export declare abstract class BaseOptionsField<TIdentifier extends string, TValue, TSerializedValue, This extends BaseOptionsField<TIdentifier, TValue, TSerializedValue, This>> extends BaseField<TIdentifier, TValue, TSerializedValue, This> {
+    options: SelectFieldOption[];
+    readonly onlyValidateAfterTouched = false;
+    protected constructor(options: BaseOptionsFieldOptions<TValue>);
+    serialize(): BaseSerializedSelectField<TIdentifier>;
+    getOptions(): BaseOptionsFieldOptions<TValue>;
+    setOptions(options: Partial<BaseOptionsFieldOptions<TValue>>): void;
+    static getFieldCreationSchema(parentPath?: string): FieldCreationSchemaObject[];
+}

package/dist/form/fields/BaseOptionsField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BaseOptionsField';
+export * from './typings';

package/dist/form/fields/BaseOptionsField/typings.d.ts

@@ -0,0 +1,9 @@
+import { BaseSerializedField } from '../BaseField';
+export interface SelectFieldOption {
+    value: string;
+    label: string;
+}
+export interface BaseSerializedSelectField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
+    type: TIdentifier;
+    options: SelectFieldOption[];
+}

package/dist/form/fields/BaseStringField/BaseStringField.d.ts

@@ -0,0 +1,28 @@
+import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
+import { NumberField } from '../NumberField';
+import { BaseSerializedStringField } from './typings';
+export interface BaseStringFieldOptions extends FieldOptions<string> {
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
+}
+export declare abstract class BaseStringField<TIdentifier extends string, This extends BaseStringField<TIdentifier, This>> extends BaseField<TIdentifier, string, string, This> {
+    minLength?: number;
+    maxLength: number;
+    placeholder?: string;
+    protected constructor(options: BaseStringFieldOptions);
+    static getFieldCreationSchema(parentPath?: string): {
+        field: NumberField;
+        showDirectly: boolean;
+    }[];
+    getFieldValidators(): FieldValidator<string>[];
+    serialize(): BaseSerializedStringField<TIdentifier>;
+    getOptions(): BaseStringFieldOptions;
+    setOptions(options: Partial<BaseStringFieldOptions>): void;
+    serializeValue(value: string): string;
+    deserializeValue(value: string): string;
+    isSerializedValueValid(value: unknown): value is string;
+    isValueValid(value: unknown): value is string;
+    blankValue(): string;
+    areValuesEqual(value1: string, value2: string): boolean;
+}

package/dist/form/fields/BaseStringField/index.d.ts

@@ -0,0 +1,2 @@
+export * from './BaseStringField';
+export * from './typings';

package/dist/form/fields/{StringOrTextField → BaseStringField}/typings.d.ts

@@ -1,5 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-export interface BaseSerializedStringField extends BaseSerializedField {
+export interface BaseSerializedStringField<TIdentifier extends string> extends BaseSerializedField<TIdentifier> {
     minimum_length?: number;
     maximum_length: number;
     placeholder?: string;

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

@@ -1,22 +1,25 @@
 import { ReactNode } from 'react';
-import { RiCheckboxCircleLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { ComponentProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
+import { SerializedField } from '../typings';
 import { SerializedBooleanField } from './typings';
-export declare const emptyBooleanField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
-};
-export declare class BooleanField extends BaseField<boolean, "boolean"> {
+export type BooleanFieldOptions = FieldOptions<boolean>;
+export declare class BooleanField extends BaseField<"boolean", boolean, boolean, BooleanField> {
+    readonly type = "boolean";
     static readonly fieldTypeName = "Checkbox";
     static readonly fieldTypeDescription = "Perfect for both optional and required yes/no questions.";
-    readonly onlyValidateAfterTouched = false;
-    static Icon: typeof RiCheckboxCircleLine;
-    constructor(options: ChildFieldOptions<boolean>);
-    protected isBlank(value: boolean | undefined): boolean;
+    readonly onlyValidateAfterTouched: boolean;
+    constructor(options: BooleanFieldOptions);
     serialize(): SerializedBooleanField;
-    static deserialize(data: ISerializedField): BooleanField;
-    getInput(props: ComponentProps<BooleanField>): ReactNode;
+    getOptions(): BooleanFieldOptions;
+    setOptions(options: Partial<BooleanFieldOptions>): void;
+    duplicate(identifier: string): BooleanField;
+    static deserialize(data: SerializedField): BooleanField;
+    serializeValue(value: boolean): boolean;
+    deserializeValue(value: boolean): boolean;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is boolean;
+    isValueValid(value: unknown): value is boolean;
+    blankValue(): boolean;
+    areValuesEqual(value1: boolean, value2: boolean): boolean;
 }

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

@@ -1,3 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { BooleanField } from './BooleanField';
-export declare const BooleanInput: import('react').MemoExoticComponent<(props: ComponentProps<BooleanField>) => import("react/jsx-runtime").JSX.Element>;
+interface BooleanInputProps extends FieldRenderProps {
+    field: BooleanField;
+}
+export declare const BooleanInput: import('react').MemoExoticComponent<(props: BooleanInputProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -1,4 +1,3 @@
 import { BaseSerializedField } from '../BaseField';
-export interface SerializedBooleanField extends BaseSerializedField {
-    type: "boolean";
+export interface SerializedBooleanField extends BaseSerializedField<"boolean"> {
 }

package/dist/form/fields/CheckboxListField/CheckboxListField.d.ts

@@ -1,31 +1,24 @@
 import { ReactNode } from 'react';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-import { MultiStringField } from '../MultiStringField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
 import { SerializedCheckboxListField } from './typings';
-export declare const emptyCheckboxListField: {
-    type: string;
-    options: never[];
-    label: string;
-    description: string;
-    required: boolean;
-};
-export interface CheckboxListFieldConfig extends ChildFieldOptions<string[]> {
-    options: SelectFieldOption[];
+export interface CheckboxListFieldOptions extends BaseOptionsFieldOptions<string[]> {
 }
-export declare class CheckboxListField extends BaseField<string[], "checkbox-list"> {
-    readonly options: SelectFieldOption[];
+export declare class CheckboxListField extends BaseOptionsField<"checkbox-list", string[], string[], CheckboxListField> {
+    readonly type = "checkbox-list";
     readonly onlyValidateAfterTouched = false;
     static readonly fieldTypeName = "Checkbox list";
     static readonly fieldTypeDescription = "Allows the user to select a multiple options from a list.";
-    static Icon: import('react-icons').IconType;
-    constructor(config: CheckboxListFieldConfig);
+    constructor(options: CheckboxListFieldOptions);
     serialize(): SerializedCheckboxListField;
-    static deserialize(data: ISerializedField): CheckboxListField;
-    static getFieldCreationSchema(parentPath?: string): {
-        field: MultiStringField;
-        showDirectly: boolean;
-    }[];
-    getInput(props: GetInputProps<this>): ReactNode;
+    getOptions(): CheckboxListFieldOptions;
+    duplicate(identifier: string): CheckboxListField;
+    static deserialize(data: SerializedCheckboxListField): CheckboxListField;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string[];
+    isValueValid(value: unknown): value is string[];
+    blankValue(): string[];
+    areValuesEqual(value1: string[], value2: string[]): boolean;
 }

package/dist/form/fields/CheckboxListField/CheckboxListInput.d.ts

@@ -1,3 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { CheckboxListField } from './CheckboxListField';
-export declare const CheckboxListInput: import('react').MemoExoticComponent<(props: ComponentProps<CheckboxListField>) => import("react/jsx-runtime").JSX.Element>;
+interface CheckboxListInputProps extends FieldRenderProps {
+    field: CheckboxListField;
+}
+export declare const CheckboxListInput: import('react').NamedExoticComponent<CheckboxListInputProps>;
+export {};

package/dist/form/fields/CheckboxListField/typings.d.ts

@@ -1,6 +1,5 @@
 import { BaseSerializedField } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-export interface SerializedCheckboxListField extends BaseSerializedField {
-    type: "checkbox-list";
+import { SelectFieldOption } from '../BaseOptionsField';
+export interface SerializedCheckboxListField extends BaseSerializedField<"checkbox-list"> {
     options: SelectFieldOption[];
 }

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

@@ -1,21 +1,29 @@
 import { ReactNode } from 'react';
-import { RiCalendarLine } from 'react-icons/ri';
-import { BaseField, ChildFieldOptions } from '../BaseField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { BaseField, FieldOptions } from '../BaseField';
+import { FieldRenderProps } from '../BaseFormElement';
 import { SerializedDateField } from './typings';
-export declare const emptyDateField: {
-    type: string;
-    label: string;
-    description: string;
-    required: boolean;
+export type SerializedDateRange = {
+    to: string | null;
+    from: string | null;
 };
-export declare class DateField extends BaseField<string, "date"> {
+export interface DateFieldOptions extends FieldOptions<Date | null> {
+}
+export declare class DateField extends BaseField<"date", Date | null, string | null, DateField> {
+    readonly type = "date";
     static readonly fieldTypeName = "Date";
     static readonly fieldTypeDescription = "Allows specifying a date.";
-    static Icon: typeof RiCalendarLine;
-    readonly onlyValidateAfterTouched = false;
-    constructor(options: ChildFieldOptions<string>);
+    readonly onlyValidateAfterTouched: boolean;
+    constructor(options: DateFieldOptions);
     serialize(): SerializedDateField;
-    static deserialize(data: ISerializedField): DateField;
-    getInput(props: GetInputProps<this>): ReactNode;
+    getOptions(): DateFieldOptions;
+    duplicate(identifier: string): DateField;
+    static deserialize(data: SerializedDateField): DateField;
+    setOptions(options: Partial<DateFieldOptions>): void;
+    serializeValue(value: Date | null): string | null;
+    deserializeValue(value: string | null): Date | null;
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string | null;
+    isValueValid(value: unknown): value is Date | null;
+    blankValue(): Date | null;
+    areValuesEqual(value1: Date | null, value2: Date | null): boolean;
 }

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

@@ -1,3 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { DateField } from './DateField';
-export declare const DateInput: import('react').MemoExoticComponent<(props: ComponentProps<DateField>) => import("react/jsx-runtime").JSX.Element>;
+interface DateInputProps extends FieldRenderProps {
+    field: DateField;
+}
+export declare const DateInput: import('react').MemoExoticComponent<(props: DateInputProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -1,4 +1,3 @@
 import { BaseSerializedField } from '../BaseField';
-export interface SerializedDateField extends BaseSerializedField {
-    type: "date";
+export interface SerializedDateField extends BaseSerializedField<"date"> {
 }

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

@@ -1,36 +1,47 @@
 import { ReactNode } from 'react';
-import { FormBuilderValues } from '../../builder';
-import { FormValues } from '../../typings';
-import { BaseFormElement, BaseSerializedObject } from '../BaseField';
-import { BooleanField } from '../BooleanField';
-import { AnyField, GetInputProps, ISerializedField } from '../typings';
-import { SerializedCondition, SerializedFieldSection } from './typings';
-interface FieldSectionOptions extends Omit<BaseSerializedObject, "type"> {
+import { Condition, FieldConditionManager } from '../../conditions';
+import { FieldValues } from '../../typings';
+import { BaseFormElement, FieldRenderProps, FormElementOptions } from '../BaseFormElement';
+import { Field, FieldsManager } from '../typings';
+import { FieldSectionConditions, SerializedFieldSection } from './typings';
+export interface FieldSectionOptions extends FormElementOptions {
     label?: string | null;
-    conditional?: boolean;
-    condition?: SerializedCondition | null;
-    fields: AnyField[];
+    description?: string | null;
+    conditions?: FieldSectionConditions;
+    fields: Field[];
 }
-export declare class FieldSection extends BaseFormElement<"section"> {
+export declare class FieldSection extends BaseFormElement<"section", FieldSection> implements FieldConditionManager<Condition>, FieldsManager {
     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;
+    readonly type = "section";
+    label: string | null;
+    description: string | null;
+    conditions: FieldSectionConditions;
+    fields: Field[];
     constructor(options: FieldSectionOptions);
-    static getFieldCreationSchema(options: ISerializedField[], parentPath?: string): ({
-        field: BooleanField;
-        showDirectly: boolean;
-    } | {
-        field: FieldSection;
-        showDirectly: boolean;
-    })[];
-    static deserialize(data: ISerializedField): FieldSection;
-    conditional(): this is {
-        condition: SerializedCondition;
-    };
     serialize(): SerializedFieldSection;
-    getErrors(allValues: FormValues | FormBuilderValues): Record<string, string>;
-    getInput(props: GetInputProps<this>): ReactNode;
+    static deserialize(data: SerializedFieldSection): FieldSection;
+    getOptions(): FieldSectionOptions;
+    duplicate(identifier: string): FieldSection;
+    setOptions(options: Partial<FieldSectionOptions>): void;
+    getErrors(values: FieldValues): Record<string, string>;
+    private fieldObserver;
+    private initFields;
+    getFields(): Field[];
+    addField(field: Field): void;
+    addFields(fields: Field[]): void;
+    moveField(sourceIndex: number, targetIndex: number): void;
+    removeField(field: Field): void;
+    removeFields(fields: Field[]): void;
+    private conditionObserver;
+    private initConditions;
+    getConditions(identifier: string): Condition[];
+    addCondition(identifier: string, condition: Condition): void;
+    addConditions(identifier: string, conditions: Condition[]): void;
+    removeCondition(identifier: string, condition: Condition): void;
+    removeConditions(identifier: string, conditions: Condition[]): void;
+    getConditionals(): Set<string>;
+    addConditional(identifier: string): void;
+    removeConditional(identifier: string): void;
+    render(props: FieldRenderProps): ReactNode;
 }
-export {};

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

@@ -1,6 +1,7 @@
-import { ComponentProps } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
 import { FieldSection } from './FieldSection';
-/**
- * Used by FieldSection to render a section of fields.
- */
-export declare const FieldSectionLayout: import('react').MemoExoticComponent<(props: ComponentProps<FieldSection>) => import("react/jsx-runtime").JSX.Element | null>;
+interface FieldSectionLayoutProps extends FieldRenderProps {
+    fieldSection: FieldSection;
+}
+export declare const FieldSectionLayout: import('react').NamedExoticComponent<FieldSectionLayoutProps>;
+export {};

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

@@ -1,13 +1,11 @@
-import { BaseSerializedObject } from '../BaseField';
-import { FieldValue, ISerializedField } from '../typings';
-export interface SerializedCondition<TValue extends FieldValue = FieldValue> {
-    identifier: string;
-    value: TValue;
-}
-export interface SerializedFieldSection extends BaseSerializedObject {
+import { Condition, SerializedCondition } from '../../conditions';
+import { BaseSerializedObject } from '../BaseFormElement';
+import { SerializedOnlyField } from '../typings';
+export type FieldSectionConditions = Record<string, Condition[]>;
+export type SerializedFieldSectionConditions = Record<string, SerializedCondition[]>;
+export interface SerializedFieldSection extends BaseSerializedObject<"section"> {
     label: string | null;
-    type: "section";
-    conditional: boolean;
-    condition: SerializedCondition | null;
-    fields: Exclude<ISerializedField, SerializedFieldSection>[];
+    description?: string | null;
+    conditions: SerializedFieldSectionConditions;
+    fields: SerializedOnlyField[];
 }

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

@@ -1,27 +1,26 @@
 import { ReactNode } from 'react';
-import { RiCheckboxLine } from 'react-icons/ri';
-import { BaseSelectField, BaseSelectFieldOptions, SelectFieldOptionValue } from '../BaseSelectField';
-import { GetInputProps, ISerializedField } from '../typings';
+import { FieldRenderProps } from '../BaseFormElement';
+import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
 import { SerializedMultiSelectField } from './typings';
-/**
- * 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 type MultiSelectFieldOptions = BaseOptionsFieldOptions<string[]> & {
+    placeholder?: string;
 };
-export declare class MultiSelectField extends BaseSelectField<SelectFieldOptionValue[], "multi-select"> {
+export declare class MultiSelectField extends BaseOptionsField<"multi-select", string[], string[], MultiSelectField> {
+    readonly type = "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 RiCheckboxLine;
+    placeholder?: string;
     constructor(options: MultiSelectFieldOptions);
-    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;
+    getOptions(): MultiSelectFieldOptions;
+    duplicate(identifier: string): MultiSelectField;
+    setOptions(options: Partial<MultiSelectFieldOptions>): void;
+    static deserialize(data: SerializedMultiSelectField): MultiSelectField;
+    serializeValue(value: string[]): string[];
+    deserializeValue(value: string[]): string[];
+    render(props: FieldRenderProps): ReactNode;
+    isSerializedValueValid(value: unknown): value is string[];
+    isValueValid(value: unknown): value is string[];
+    blankValue(): string[];
+    areValuesEqual(value1: string[], value2: string[]): boolean;
 }

package/dist/form/fields/MultiSelectField/MultiSelectInput.d.ts

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

package/dist/form/fields/MultiSelectField/typings.d.ts

@@ -1,7 +1,4 @@
-import { BaseSerializedField } from '../BaseField';
-import { SelectFieldOption } from '../BaseSelectField';
-export interface SerializedMultiSelectField extends BaseSerializedField {
-    type: "multi-select";
-    options: SelectFieldOption[];
+import { BaseSerializedSelectField } from '../BaseOptionsField';
+export interface SerializedMultiSelectField extends BaseSerializedSelectField<"multi-select"> {
     placeholder?: string;
 }