@overmap-ai/forms 1.0.32-react-flow-david.1 → 1.0.32-react-flow-david-fixes.1

package/dist/form/conditions/RadioFieldCondition/RadioFieldCondition.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { RadioField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { RadioConditionModifiers, SerializedRadioCondition } from './typings';
+export interface RadioFieldConditionOptions extends ConditionOptions<RadioField, string | string[], RadioConditionModifiers> {
+}
+export declare class RadioFieldCondition extends BaseCondition<RadioField, string | string[], string | string[], RadioConditionModifiers, RadioFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string, string>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string, string>;
+        includes: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string[], string[]>;
+        excludes: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string[], string[]>;
+    };
+    constructor(options: RadioFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedRadioCondition, field: RadioField): RadioFieldCondition;
+    render(props: ConditionRenderProps<RadioFieldCondition>): ReactNode;
+}

package/dist/form/conditions/RadioFieldCondition/RadioFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { RadioFieldCondition } from './RadioFieldCondition';
+interface RadioFieldConditionCellProps extends BaseConditionCellProps<RadioFieldCondition> {
+}
+export declare const RadioFieldConditionCell: (props: RadioFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/RadioFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './RadioFieldCondition';
+export * from './RadioFieldConditionCell';
+export type * from './typings';

package/dist/form/conditions/RadioFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { RadioField, TypeOfField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type RadioConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
+export type SerializedRadioCondition = SerializedCondition<TypeOfField<RadioField>, string | string[], RadioConditionModifiers>;

package/dist/form/conditions/ScanFieldCondition/ScanFieldCondition.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { ScanField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { ScanConditionModifiers, SerializedScanCondition } from './typings';
+export interface ScanFieldConditionOptions extends ConditionOptions<ScanField, string, ScanConditionModifiers> {
+}
+export declare class ScanFieldCondition extends BaseCondition<ScanField, string, string, ScanConditionModifiers, ScanFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        includes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        excludes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+    };
+    constructor(options: ScanFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedScanCondition, field: ScanField): ScanFieldCondition;
+    render(props: ConditionRenderProps<ScanFieldCondition>): ReactNode;
+}

package/dist/form/conditions/ScanFieldCondition/ScanFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { ScanFieldCondition } from './ScanFieldCondition';
+interface ScanFieldConditionCellProps extends BaseConditionCellProps<ScanFieldCondition> {
+}
+export declare const ScanFieldConditionCell: (props: ScanFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/ScanFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ScanFieldCondition';
+export * from './ScanFieldConditionCell';
+export type * from './typings';

package/dist/form/conditions/ScanFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { ScanField, TypeOfField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type ScanConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
+export type SerializedScanCondition = SerializedCondition<TypeOfField<ScanField>, string, ScanConditionModifiers>;

package/dist/form/conditions/SelectFieldCondition/SelectFieldCondition.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { SelectField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { SelectConditionModifiers, SerializedSelectCondition } from './typings';
+export interface SelectFieldConditionOptions extends ConditionOptions<SelectField, string | string[], SelectConditionModifiers> {
+}
+export declare class SelectFieldCondition extends BaseCondition<SelectField, string | string[], string | string[], SelectConditionModifiers, SelectFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string, string>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string, string>;
+        includes: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string[], string[]>;
+        excludes: import('../../modifiers').FieldConditionModifierConfig<string, string | string[], string | string[], string, string[], string[]>;
+    };
+    constructor(options: SelectFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedSelectCondition, field: SelectField): SelectFieldCondition;
+    render(props: ConditionRenderProps<SelectFieldCondition>): ReactNode;
+}

package/dist/form/conditions/SelectFieldCondition/SelectFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { SelectFieldCondition } from './SelectFieldCondition';
+interface SelectFieldConditionCellProps extends BaseConditionCellProps<SelectFieldCondition> {
+}
+export declare const SelectFieldConditionCell: (props: SelectFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/SelectFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SelectFieldCondition';
+export * from './SelectFieldConditionCell';
+export type * from './typings';

package/dist/form/conditions/SelectFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { SelectField, TypeOfField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type SelectConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
+export type SerializedSelectCondition = SerializedCondition<TypeOfField<SelectField>, string | string[], SelectConditionModifiers>;

package/dist/form/conditions/StringFieldCondition/StringFieldCondition.d.ts

@@ -0,0 +1,19 @@
+import { ReactNode } from 'react';
+import { StringField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { SerializedStringCondition, StringConditionModifiers } from './typings';
+export interface StringFieldConditionOptions extends ConditionOptions<StringField, string, StringConditionModifiers> {
+}
+export declare class StringFieldCondition extends BaseCondition<StringField, string, string, StringConditionModifiers, StringFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        includes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        excludes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+    };
+    constructor(options: StringFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedStringCondition, field: StringField): StringFieldCondition;
+    render(props: ConditionRenderProps<StringFieldCondition>): ReactNode;
+}

package/dist/form/conditions/StringFieldCondition/StringFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { StringFieldCondition } from './StringFieldCondition';
+interface StringFieldConditionCellProps extends BaseConditionCellProps<StringFieldCondition> {
+}
+export declare const StringFieldConditionCell: (props: StringFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/StringFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './StringFieldCondition';
+export * from './StringFieldConditionCell';
+export type * from './typings';

package/dist/form/conditions/StringFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { StringField, TypeOfField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type StringConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
+export type SerializedStringCondition = SerializedCondition<TypeOfField<StringField>, string, StringConditionModifiers>;

package/dist/form/conditions/TextFieldCondition/TextFieldCondition.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+import { TextField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { SerializedTextCondition, TextConditionModifiers } from './typings';
+export interface TextFieldConditionOptions extends ConditionOptions<TextField, string, TextConditionModifiers> {
+    field: TextField;
+}
+export declare class TextFieldCondition extends BaseCondition<TextField, string, string, TextConditionModifiers, TextFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        includes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+        excludes: import('../../modifiers').FieldConditionModifierConfig<string, string, string, string, string, string>;
+    };
+    constructor(options: TextFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedTextCondition, field: TextField): TextFieldCondition;
+    render(props: ConditionRenderProps<TextFieldCondition>): ReactNode;
+}

package/dist/form/conditions/TextFieldCondition/TextFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { TextFieldCondition } from './TextFieldCondition';
+interface TextFieldConditionCellProps extends BaseConditionCellProps<TextFieldCondition> {
+}
+export declare const TextFieldConditionCell: (props: TextFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/TextFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export * from './TextFieldCondition';
+export * from './TextFieldConditionCell';
+export type * from './typings';

package/dist/form/conditions/TextFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { TextField, TypeOfField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type TextConditionModifiers = "equals" | "notEquals" | "includes" | "excludes";
+export type SerializedTextCondition = SerializedCondition<TypeOfField<TextField>, string, TextConditionModifiers>;

package/dist/form/conditions/UploadFieldCondition/UploadFieldCondition.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from 'react';
+import { UploadField } from '../../fields';
+import { BaseCondition, ConditionOptions, ConditionRenderProps } from '../BaseCondition';
+import { SerializedUploadCondition, UploadConditionModifiers } from './typings';
+export interface UploadFieldConditionOptions extends ConditionOptions<UploadField, boolean, UploadConditionModifiers> {
+}
+export declare class UploadFieldCondition extends BaseCondition<UploadField, boolean, boolean, UploadConditionModifiers, UploadFieldCondition> {
+    readonly defaultConditionValue: undefined;
+    readonly defaultConditionModifier = "equals";
+    readonly modifiers: {
+        equals: import('../../modifiers').FieldConditionModifierConfig<File[], boolean, boolean, File[], boolean, boolean>;
+        notEquals: import('../../modifiers').FieldConditionModifierConfig<File[], boolean, boolean, File[], boolean, boolean>;
+    };
+    constructor(options: UploadFieldConditionOptions);
+    static deserialize(serializedCondition: SerializedUploadCondition, field: UploadField): UploadFieldCondition;
+    render(props: ConditionRenderProps<UploadFieldCondition>): ReactNode;
+}

package/dist/form/conditions/UploadFieldCondition/UploadFieldConditionCell.d.ts

@@ -0,0 +1,6 @@
+import { BaseConditionCellProps } from '../BaseCondition';
+import { UploadFieldCondition } from './UploadFieldCondition';
+interface UploadFieldConditionCellProps extends BaseConditionCellProps<UploadFieldCondition> {
+}
+export declare const UploadFieldConditionCell: (props: UploadFieldConditionCellProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/form/conditions/UploadFieldCondition/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './typings';
+export * from './UploadFieldCondition';
+export * from './UploadFieldConditionCell';

package/dist/form/conditions/UploadFieldCondition/typings.d.ts

@@ -0,0 +1,4 @@
+import { TypeOfField, UploadField } from '../../fields';
+import { SerializedCondition } from '../BaseCondition';
+export type UploadConditionModifiers = "equals" | "notEquals";
+export type SerializedUploadCondition = SerializedCondition<TypeOfField<UploadField>, boolean, UploadConditionModifiers>;

package/dist/form/conditions/components/ConditionModifierDropdown.d.ts

@@ -1,13 +1,9 @@
 import { MenuRootProps, MenuVariantProps } from '@overmap-ai/blocks';
 import { ReactElement } from 'react';
-import { AnyField } from '../../fields';
-import { Condition } from '../condition';
-import { ConditionModifiersOfField } from '../typings';
-interface ConditionModifierDropdownProps<TField extends AnyField> extends MenuVariantProps, MenuRootProps {
+import { AnyCondition } from '../BaseCondition';
+interface ConditionModifierDropdownProps<TCondition extends AnyCondition> extends MenuVariantProps, MenuRootProps {
     children: ReactElement;
-    field: TField;
-    condition: Condition<TField>;
-    onModifierChange?: (modifierId: ConditionModifiersOfField<TField>) => void;
+    condition: TCondition;
 }
-export declare const ConditionModifierDropdown: <TFilterDef extends AnyField>(props: ConditionModifierDropdownProps<TFilterDef>) => import("react/jsx-runtime").JSX.Element;
+export declare const ConditionModifierDropdown: <TCondition extends AnyCondition>(props: ConditionModifierDropdownProps<TCondition>) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/form/conditions/components/RemoveConditionButton.d.ts

@@ -1,9 +1,11 @@
 import { ButtonProps } from '@overmap-ai/blocks';
-import { AnyCondition } from '../condition/typings';
-import { ConditionManager } from '../manager';
-interface RemoveConditionButtonProps extends Omit<ButtonProps, "children" | "onClick"> {
-    condition: AnyCondition;
-    conditionManager: ConditionManager;
+import { AnyCondition } from '../BaseCondition/typings';
+interface RemoveConditionButtonProps<TCondition extends AnyCondition> extends Omit<ButtonProps, "children" | "onClick"> {
+    condition: TCondition;
+    onClick: (condition: TCondition) => void;
 }
-export declare const RemoveConditionButton: import('react').NamedExoticComponent<RemoveConditionButtonProps>;
+export declare const RemoveConditionButton: {
+    <TCondition extends AnyCondition>(props: RemoveConditionButtonProps<TCondition>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
 export {};

package/dist/form/conditions/components/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ConditionModifierDropdown';
+export * from './constants';
+export * from './DayPickerPopover';
+export * from './RemoveConditionButton';
+export * from './SelectFieldOptionMultiSelectGroup';
+export * from './SelectFieldOptionSelectGroup';
+export * from './TextInputPopover';

package/dist/form/conditions/index.d.ts

@@ -1 +1,15 @@
-export {};
+export * from './BaseCondition';
+export * from './BooleanFieldCondition';
+export * from './CheckboxListFieldCondition';
+export * from './DateFieldCondition';
+export * from './MultiSelectFieldCondition';
+export * from './MultiStringFieldCondition';
+export * from './NumberFieldCondition';
+export * from './RadioFieldCondition';
+export * from './ScanFieldCondition';
+export * from './SelectFieldCondition';
+export * from './StringFieldCondition';
+export * from './TextFieldCondition';
+export type * from './typings';
+export * from './UploadFieldCondition';
+export * from './utils';

package/dist/form/conditions/typings.d.ts

@@ -1,14 +1,26 @@
-import { ReactNode } from 'react';
-import { AnyField, BaseField } from '../fields';
-import { ConditionModifier } from './modifier/conditionModifier';
-export type ConditionModifierRenderFn<TConditionValue> = (conditionValue: TConditionValue) => ReactNode;
-export type ConditionModifierFn<TValue, TConditionValue> = (value: TValue, conditionValue: TConditionValue) => boolean;
-export interface FieldConditionModifierConfig<TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue, TModifierValue extends TFieldValue, TModifierConditionValue extends TFieldConditionValue, TSerializedModifierConditionValue extends TSerializedFieldConditionValue> {
-    modifier: ConditionModifier<TModifierValue, TModifierConditionValue, TSerializedModifierConditionValue>;
-    isValueValid: (value: TFieldValue) => value is TModifierValue;
-    isConditionValueValid: (conditionValue: TFieldConditionValue) => conditionValue is TModifierConditionValue;
+import { AnyCondition } from './BaseCondition';
+import { BooleanFieldCondition, SerializedBooleanCondition } from './BooleanFieldCondition';
+import { CheckboxListFieldCondition, SerializedCheckboxListCondition } from './CheckboxListFieldCondition';
+import { DateFieldCondition, SerializedDateCondition } from './DateFieldCondition';
+import { MultiSelectFieldCondition, SerializedMultiSelectCondition } from './MultiSelectFieldCondition';
+import { MultiStringFieldCondition, SerializedMultiStringCondition } from './MultiStringFieldCondition';
+import { NumberFieldCondition, SerializedNumberCondition } from './NumberFieldCondition';
+import { RadioFieldCondition, SerializedRadioCondition } from './RadioFieldCondition';
+import { ScanFieldCondition, SerializedScanCondition } from './ScanFieldCondition';
+import { SelectFieldCondition, SerializedSelectCondition } from './SelectFieldCondition';
+import { SerializedStringCondition, StringFieldCondition } from './StringFieldCondition';
+import { SerializedTextCondition, TextFieldCondition } from './TextFieldCondition';
+import { SerializedUploadCondition, UploadFieldCondition } from './UploadFieldCondition';
+export type Condition = BooleanFieldCondition | CheckboxListFieldCondition | DateFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | RadioFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition;
+export type ISerializedCondition = SerializedTextCondition | SerializedBooleanCondition | SerializedNumberCondition | SerializedDateCondition | SerializedStringCondition | SerializedSelectCondition | SerializedMultiStringCondition | SerializedMultiSelectCondition | SerializedUploadCondition | SerializedScanCondition | SerializedRadioCondition | SerializedCheckboxListCondition;
+export interface ConditionManager<TCondition extends AnyCondition> {
+    readonly conditions: Record<string, TCondition[]>;
+    getConditions(identifier: string): TCondition[];
+    addCondition(identifier: string, condition: TCondition): void;
+    addConditions(identifier: string, conditions: TCondition[]): void;
+    removeCondition(identifier: string, condition: TCondition): void;
+    removeConditions(identifier: string, conditions: TCondition[]): void;
+    getConditionals(): Set<string>;
+    addConditional(identifier: string): void;
+    removeConditional(identifier: string): void;
 }
-export type AnyConditionModifierConfig<TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue> = FieldConditionModifierConfig<TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue, any, // eslint-disable-line @typescript-eslint/no-explicit-any
-any, // eslint-disable-line @typescript-eslint/no-explicit-any
-any>;
-export type ConditionModifiersOfField<TFilterDef extends AnyField> = TFilterDef extends BaseField<infer _TIdentifier, infer _TValue, infer _TFilterValue, infer _TSerializedFilterValue> ? keyof TFilterDef["modifiers"] : never;

package/dist/form/conditions/utils.d.ts

@@ -1,2 +1,19 @@
-import { FieldConditionModifierConfig } from './typings';
-export declare const createConditionModifierConfig: <TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue, TModifierValue extends TFieldValue, TModifierConditionalValue extends TFieldConditionValue, TSerializedModifierConditionValue extends TSerializedFieldConditionValue>(conifg: FieldConditionModifierConfig<TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue, TModifierValue, TModifierConditionalValue, TSerializedModifierConditionValue>) => FieldConditionModifierConfig<TFieldValue, TFieldConditionValue, TSerializedFieldConditionValue, TModifierValue, TModifierConditionalValue, TSerializedModifierConditionValue>;
+import { Field } from '../fields';
+import { FieldValues } from '../typings';
+import { AnyCondition } from './BaseCondition';
+import { BooleanFieldCondition } from './BooleanFieldCondition';
+import { CheckboxListFieldCondition } from './CheckboxListFieldCondition';
+import { DateFieldCondition } from './DateFieldCondition';
+import { MultiSelectFieldCondition } from './MultiSelectFieldCondition';
+import { MultiStringFieldCondition } from './MultiStringFieldCondition';
+import { NumberFieldCondition } from './NumberFieldCondition';
+import { RadioFieldCondition } from './RadioFieldCondition';
+import { ScanFieldCondition } from './ScanFieldCondition';
+import { SelectFieldCondition } from './SelectFieldCondition';
+import { StringFieldCondition } from './StringFieldCondition';
+import { TextFieldCondition } from './TextFieldCondition';
+import { Condition, ISerializedCondition } from './typings';
+import { UploadFieldCondition } from './UploadFieldCondition';
+export declare const deserializeCondition: (serializedCondition: ISerializedCondition, field: Field) => BooleanFieldCondition | CheckboxListFieldCondition | DateFieldCondition | MultiSelectFieldCondition | MultiStringFieldCondition | NumberFieldCondition | RadioFieldCondition | ScanFieldCondition | SelectFieldCondition | StringFieldCondition | TextFieldCondition | UploadFieldCondition;
+export declare const deserializeConditions: (serializedConditions: ISerializedCondition[], fields: Field[]) => Condition[];
+export declare const applyConditions: (conditions: AnyCondition[], values: FieldValues) => boolean;

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

@@ -1,39 +1,18 @@
-import { ReactNode } from 'react';
-import { FormBuilderValues } from '../../builder';
-import { Condition } from '../../conditions/condition';
-import { CreateConditionConfig, SerializedCondition } from '../../conditions/condition/typings';
-import { AnyConditionModifierConfig } from '../../conditions/typings';
-import { FormValues } from '../../typings';
-import { FieldSection } from '../FieldSection';
-import { AnyField, FieldTypeIdentifier, FieldValue, GetInputProps, InputFieldLevelValidator, InputFormLevelValidator, ISerializedField, ISerializedOnlyField } from '../typings';
-import { BaseSerializedField, BaseSerializedObject, ConditionRenderProps, 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;
-};
+import { BaseFormElement } from '../BaseFormElement';
+import { AnyField, FieldValidator } from '../typings';
+import { BaseSerializedField, FieldOptions } from './typings';
 export interface FieldCreationSchemaObject {
     field: AnyField;
     showDirectly: boolean;
 }
-export declare abstract class BaseField<TIdentifier extends FieldTypeIdentifier, TValue extends FieldValue, TConditionValue, TSerializedConditionValue = TConditionValue> extends BaseFormElement<TIdentifier> {
+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`
@@ -42,23 +21,13 @@ export declare abstract class BaseField<TIdentifier extends FieldTypeIdentifier,
      */
     readonly onlyValidateAfterTouched: boolean;
     protected constructor(options: FieldOptions<TValue>);
-    static getFieldCreationSchema(): FieldCreationSchemaObject[];
-    protected isBlank(value: TValue | undefined): boolean;
+    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;
-    abstract readonly defaultConditionValue: TConditionValue | undefined;
-    abstract readonly defaultConditionModifier: keyof typeof this.modifiers;
-    abstract readonly modifiers: Record<string, AnyConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue>>;
-    abstract renderCondition(props: ConditionRenderProps<BaseField<TIdentifier, TValue, TConditionValue, TSerializedConditionValue>>): ReactNode;
-    getConditionModifier: (modifier: keyof typeof this.modifiers) => AnyConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue>;
-    getConditionModifiers: () => [keyof typeof this.modifiers, AnyConditionModifierConfig<TValue, TConditionValue, TSerializedConditionValue>][];
-    createCondition(config?: CreateConditionConfig<typeof this>): Condition<typeof this>;
-    serializeCondition(condition: Condition<typeof this>): SerializedCondition<typeof this>;
-    deserializeCondition(serializedFilter: SerializedCondition<typeof this>): Condition<typeof this>;
+    getError(value: TValue | undefined): string | undefined;
+    serialize(): BaseSerializedField<TIdentifier>;
+    getOptions(): FieldOptions<TValue>;
+    setOptions(options: Partial<FieldOptions<TValue>>): void;
+    abstract serializeValue(value: TValue): TSerializedValue;
+    abstract deserializeValue(value: TSerializedValue): TValue;
+    getFieldValidators(): FieldValidator<TValue>[];
 }

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

@@ -1,5 +1,7 @@
 import { AnyField, ComponentProps, ValueOfField } from '../typings';
-export declare const useFormikInput: <TField extends AnyField>(props: ComponentProps<TField>) => readonly [{
+export declare const useFormikInput: <TField extends AnyField>(props: ComponentProps & {
+    field: TField;
+}) => readonly [{
     readonly helpText: string | null;
     readonly size: import('@overmap-ai/blocks').TextSize | undefined;
     readonly severity: "danger" | undefined;
@@ -20,6 +22,7 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly touched: boolean;
 }, {
     readonly "aria-labelledby": string;
+    readonly formId: string;
     readonly cite?: string | undefined;
     readonly data?: string | undefined;
     readonly form?: string | undefined;
@@ -43,6 +46,7 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly draggable?: (boolean | "true" | "false") | undefined;
     readonly enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined;
     readonly hidden?: boolean | undefined;
+    readonly id?: string | undefined;
     readonly lang?: string | undefined;
     readonly nonce?: string | undefined;
     readonly spellCheck?: (boolean | "true" | "false") | undefined;
@@ -310,14 +314,29 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly width?: number | string | undefined;
     readonly crossOrigin?: "" | "anonymous" | "use-credentials" | undefined;
     readonly href?: string | undefined;
+    readonly download?: any;
+    readonly rows?: number | undefined;
     readonly default?: boolean | undefined;
     readonly required?: boolean | undefined;
+    readonly placeholder?: string | undefined;
+    readonly minLength?: number | undefined;
+    readonly maxLength?: number | undefined;
+    readonly open?: boolean | undefined;
+    readonly loop?: boolean | undefined;
+    readonly disabled?: boolean | undefined;
+    readonly formAction?: string | undefined | ((formData: FormData) => void | Promise<void>) | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
+    readonly formEncType?: string | undefined;
+    readonly formMethod?: string | undefined;
+    readonly formNoValidate?: boolean | undefined;
+    readonly formTarget?: string | undefined;
+    readonly src?: string | undefined;
+    readonly alt?: string | undefined;
+    readonly htmlFor?: string | undefined;
     readonly accept?: string | undefined;
     readonly acceptCharset?: string | undefined;
     readonly action?: string | undefined | ((formData: FormData) => void | Promise<void>) | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
     readonly allowFullScreen?: boolean | undefined;
     readonly allowTransparency?: boolean | undefined;
-    readonly alt?: string | undefined;
     readonly as?: string | undefined;
     readonly async?: boolean | undefined;
     readonly autoComplete?: string | undefined;
@@ -335,44 +354,30 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly coords?: string | undefined;
     readonly dateTime?: string | undefined;
     readonly defer?: boolean | undefined;
-    readonly disabled?: boolean | undefined;
-    readonly download?: any;
     readonly encType?: string | undefined;
-    readonly formAction?: string | undefined | ((formData: FormData) => void | Promise<void>) | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_FORM_ACTIONS];
-    readonly formEncType?: string | undefined;
-    readonly formMethod?: string | undefined;
-    readonly formNoValidate?: boolean | undefined;
-    readonly formTarget?: string | undefined;
     readonly frameBorder?: number | string | undefined;
     readonly headers?: string | undefined;
     readonly high?: number | 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 loop?: boolean | undefined;
     readonly low?: number | undefined;
     readonly manifest?: string | undefined;
     readonly marginHeight?: number | undefined;
     readonly marginWidth?: number | undefined;
-    readonly maxLength?: number | undefined;
     readonly mediaGroup?: string | 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 placeholder?: string | undefined;
     readonly playsInline?: boolean | undefined;
     readonly poster?: string | undefined;
     readonly preload?: string | undefined;
     readonly readOnly?: boolean | undefined;
     readonly reversed?: boolean | undefined;
-    readonly rows?: number | undefined;
     readonly rowSpan?: number | undefined;
     readonly sandbox?: string | undefined;
     readonly scope?: string | undefined;
@@ -382,7 +387,6 @@ export declare const useFormikInput: <TField extends AnyField>(props: ComponentP
     readonly selected?: boolean | undefined;
     readonly shape?: string | undefined;
     readonly sizes?: string | undefined;
-    readonly src?: string | undefined;
     readonly srcDoc?: string | undefined;
     readonly srcLang?: string | undefined;
     readonly srcSet?: string | undefined;

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

@@ -1,23 +1,15 @@
-import { Condition } from '../../conditions/condition';
-import { ConditionManager } from '../../conditions/manager';
-import { AnyField, FieldTypeIdentifier, InputFieldLevelValidator, InputFormLevelValidator } from '../typings';
-export interface BaseSerializedObject<TIdentifier extends FieldTypeIdentifier = FieldTypeIdentifier> {
+import { BaseSerializedObject, FormElementOptions } from '../BaseFormElement';
+import { FieldValidator } 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>;
-}
-export interface FieldOptions<TValue> extends BaseSerializedField {
-    fieldValidators?: InputFieldLevelValidator<TValue>[];
-    formValidators?: InputFormLevelValidator<TValue>[];
-}
-export type ChildFieldOptions<TValue> = Omit<FieldOptions<TValue>, "type">;
-export interface ConditionRenderProps<TField extends AnyField> {
-    field: TField;
-    condition: Condition<TField>;
-    conditionManager: ConditionManager;
+    fieldValidators?: FieldValidator<TValue>[];
 }

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

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+import { Observable } from '../../observable/Observable';
+import { ComponentProps } from '../typings';
+import { BaseSerializedObject, 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: ComponentProps): ReactNode;
+}