@overmap-ai/forms 1.0.38 → 1.0.39-field-groups.0

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

@@ -1,14 +1,10 @@
 import { ReactNode } from 'react';
 import { SerializedScanField } from './typings';
 import { BaseField, FieldOptions } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
 export interface ScanFieldOptions extends FieldOptions {
 }
 export declare class ScanField extends BaseField<"qr", string, string, ScanField> {
     readonly type = "qr";
-    static readonly fieldTypeName = "Scan";
-    static readonly fieldTypeDescription = "Used for scanning/reading QR and barcodes.";
-    readonly onlyValidateAfterTouched = false;
     constructor(options: ScanFieldOptions);
     serialize(): SerializedScanField;
     getOptions(): ScanFieldOptions;
@@ -17,7 +13,7 @@ export declare class ScanField extends BaseField<"qr", string, string, ScanField
     static deserialize(data: SerializedScanField): ScanField;
     serializeValue(value: string): string;
     deserializeValue(value: string): string;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string;
     isValue(value: unknown): value is string;
     blankValue(): string;

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

@@ -1,3 +1,3 @@
 export * from './ScanField';
 export * from './ScanFieldInput';
-export * from './typings';
+export type * from './typings';

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

@@ -1,14 +1,11 @@
 import { ReactNode } from 'react';
 import { SerializedSelectField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseOptionsField, BaseOptionsFieldOptions } from '../BaseOptionsField';
 export type SelectFieldOptions = BaseOptionsFieldOptions & {
     placeholder?: string;
 };
 export declare class SelectField extends BaseOptionsField<"select", string | null, string | null, SelectField> {
     readonly type = "select";
-    static readonly fieldTypeName = "Dropdown";
-    static readonly fieldTypeDescription = "Allows the user to select a single option from a list of options.";
     placeholder?: string;
     constructor(options: SelectFieldOptions);
     serialize(): SerializedSelectField;
@@ -18,7 +15,7 @@ export declare class SelectField extends BaseOptionsField<"select", string | nul
     static deserialize(data: SerializedSelectField): SelectField;
     serializeValue(value: string | null): string | null;
     deserializeValue(value: string | null): string | null;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is string | null;
     isValue(value: unknown): value is string | null;
     blankValue(): string | null;

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

@@ -1,3 +1,3 @@
 export * from './SelectField';
 export * from './SelectFieldInput';
-export * from './typings';
+export type * from './typings';

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

@@ -1,18 +1,15 @@
 import { ReactNode } from 'react';
 import { SerializedStringField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
 export interface StringFieldOptions extends BaseStringFieldOptions {
 }
 export declare class StringField extends BaseStringField<"string", StringField> {
     readonly type = "string";
-    static readonly fieldTypeName = "Short Text";
-    static readonly fieldTypeDescription = "Short text fields can hold up to 500 characters on a single line.";
     constructor(options: StringFieldOptions);
     serialize(): SerializedStringField;
     getOptions(): StringFieldOptions;
     duplicate(identifier: string): StringField;
     setOptions(options: Partial<StringFieldOptions>): void;
     static deserialize(data: SerializedStringField): StringField;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
 }

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

@@ -1,4 +1,4 @@
 export * from './constants';
 export * from './StringField';
 export * from './StringFieldInput';
-export * from './typings';
+export type * from './typings';

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

@@ -1,17 +1,14 @@
 import { ReactNode } from 'react';
 import { SerializedTextField } from './typings';
-import { FieldRenderProps } from '../BaseFormElement';
 import { BaseStringField, BaseStringFieldOptions } from '../BaseStringField';
 export type TextFieldOptions = BaseStringFieldOptions;
 export declare class TextField extends BaseStringField<"text", TextField> {
     readonly type = "text";
-    static readonly fieldTypeName = "Paragraph";
-    static readonly fieldTypeDescription = "Paragraph fields can hold up to 10000 characters and can have multiple lines.";
     constructor(options: TextFieldOptions);
     serialize(): SerializedTextField;
     getOptions(): TextFieldOptions;
     duplicate(identifier: string): TextField;
     setOptions(options: Partial<TextFieldOptions>): void;
     static deserialize(data: SerializedTextField): TextField;
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
 }

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

@@ -1,4 +1,4 @@
 export * from './constants';
 export * from './TextField';
 export * from './TextFieldInput';
-export * from './typings';
+export type * from './typings';

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

@@ -0,0 +1,25 @@
+import { ReactNode } from 'react';
+import { SerializedURLField } from './typings';
+import { BaseField, FieldOptions } from '../BaseField';
+export interface URLFieldOptions extends FieldOptions {
+    placeholder?: string;
+}
+export declare class URLField extends BaseField<"url", URL | null, string | null, URLField> {
+    readonly type = "url";
+    placeholder: string;
+    constructor(options: URLFieldOptions);
+    serialize(): SerializedURLField;
+    getOptions(): URLFieldOptions;
+    duplicate(identifier: string): URLField;
+    setOptions(options: Partial<URLFieldOptions>): void;
+    static deserialize(data: SerializedURLField): URLField;
+    serializeValue(value: URL | null): string | null;
+    deserializeValue(value: string | null): URL | null;
+    isSerializedValue(value: unknown): value is string | null;
+    isValue(value: unknown): value is URL | null;
+    blankValue(): URL | null;
+    blankSerializedValue(): string | null;
+    areSerializedValuesEqual(value1: string | null, value2: string | null): boolean;
+    areValuesEqual(value1: URL | null, value2: URL | null): boolean;
+    render(): ReactNode;
+}

package/dist/form/fields/URLField/URLField.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/form/fields/URLField/URLFieldInput.d.ts

@@ -0,0 +1,7 @@
+import { URLField } from './URLField';
+import { FieldRenderProps } from '../BaseFormElement';
+interface URLFieldInputProps extends FieldRenderProps {
+    field: URLField;
+}
+export declare const URLFieldInput: import('react').NamedExoticComponent<URLFieldInputProps>;
+export {};

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

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

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

@@ -0,0 +1,4 @@
+import { BaseSerializedField } from '../BaseField';
+export interface SerializedURLField extends BaseSerializedField<"url"> {
+    placeholder?: string;
+}

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

@@ -3,7 +3,6 @@ import { SerializedUploadField } from './typings';
 import { UUIDFile } from '../../UUIDFile';
 import { UUIDPromise } from '../../UUIDPromise';
 import { BaseField, FieldOptions, FieldValidator } from '../BaseField';
-import { FieldRenderProps } from '../BaseFormElement';
 import { MultiSelectField } from '../MultiSelectField';
 import { NumberField } from '../NumberField';
 export interface UploadFieldOptions extends FieldOptions {
@@ -13,12 +12,9 @@ export interface UploadFieldOptions extends FieldOptions {
 }
 export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFile> | UUIDFile)[], never[], UploadField> {
     readonly type = "upload";
-    static readonly fieldTypeName = "Upload";
-    static readonly fieldTypeDescription = "Allows a file to be uploaded.";
     extensions?: string[];
     maxFileSize: number | undefined;
     maxFiles: number;
-    readonly onlyValidateAfterTouched = false;
     constructor(options: UploadFieldOptions);
     static getFieldCreationSchema(parentPath?: string): ({
         field: NumberField;
@@ -35,7 +31,7 @@ export declare class UploadField extends BaseField<"upload", (UUIDPromise<UUIDFi
     static deserialize(data: SerializedUploadField): UploadField;
     serializeValue(_value: (UUIDPromise<UUIDFile> | UUIDFile)[]): never[];
     deserializeValue(_value: never[]): (UUIDPromise<UUIDFile> | UUIDFile)[];
-    render(props: FieldRenderProps): ReactNode;
+    render(): ReactNode;
     isSerializedValue(value: unknown): value is never[];
     isValue(value: unknown): value is (UUIDPromise<UUIDFile> | UUIDFile)[];
     areValuesEqual(value1: (UUIDPromise<UUIDFile> | UUIDFile)[], value2: (UUIDPromise<UUIDFile> | UUIDFile)[]): boolean;

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

@@ -1,3 +1,3 @@
-export * from './typings';
+export type * from './typings';
 export * from './UploadField';
 export * from './UploadFieldInput';

package/dist/form/fields/components/InputWithLabel.d.ts

@@ -3,12 +3,11 @@ import { FieldsRendererSize } from '../../renderer';
 export interface InputWithLabelProps {
     size: FieldsRendererSize;
     inputId: string;
-    labelId: string;
     label: string;
-    description: string;
+    required: boolean;
+    description?: string | null;
     image: File | Promise<File> | undefined;
     children: ReactNode;
     error: string;
-    className?: string;
 }
 export declare const InputWithLabel: import('react').MemoExoticComponent<(props: InputWithLabelProps) => import("react/jsx-runtime").JSX.Element>;

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

@@ -1,38 +1,17 @@
 import { IconComponent } from '@overmap-ai/blocks';
-import { FieldType } from './typings';
-import { BooleanField } from './BooleanField';
-import { CheckboxListField } from './CheckboxListField';
-import { DateField } from './DateField';
-import { MultiSelectField } from './MultiSelectField';
-import { MultiStringField } from './MultiStringField';
-import { NumberField } from './NumberField';
-import { OTPField } from './OTPField';
-import { PassFailField } from './PassFailField';
-import { RadioField } from './RadioField';
-import { RatingField } from './RatingField';
-import { ScanField } from './ScanField';
-import { SelectField } from './SelectField';
-import { StringField } from './StringField';
-import { TextField } from './TextField';
-import { UploadField } from './UploadField';
-export declare const FieldTypeToClsMapping: {
-    date: typeof DateField;
-    number: typeof NumberField;
-    boolean: typeof BooleanField;
-    select: typeof SelectField;
-    string: typeof StringField;
-    text: typeof TextField;
-    upload: typeof UploadField;
-    qr: typeof ScanField;
-    "multi-string": typeof MultiStringField;
-    "multi-select": typeof MultiSelectField;
-    radio: typeof RadioField;
-    "checkbox-list": typeof CheckboxListField;
-    "pass-fail": typeof PassFailField;
-    otp: typeof OTPField;
-    rating: typeof RatingField;
-};
-export declare const fieldIcons: Record<FieldType, IconComponent>;
+import { FieldClass, FieldType } from './typings';
+import { FieldTypeGroup } from './enums';
+export declare const FieldTypeToClsMapping: Record<Exclude<FieldType, "section">, FieldClass>;
+export declare const FIELD_TYPES: Exclude<FieldType, "section">[];
+export declare const fieldDataMapping: Record<Exclude<FieldType, "section">, {
+    icon: IconComponent;
+    name: string;
+    description: string;
+    group: FieldTypeGroup;
+}>;
+export declare const fieldTypeGroupDataMapping: Record<FieldTypeGroup, {
+    name: string;
+}>;
 export declare const maxFileSizeMB = 50;
 export declare const maxFileSizeKB: number;
 export declare const maxFileSizeB: number;

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

@@ -0,0 +1,9 @@
+export declare enum FieldTypeGroup {
+    Text = "text",
+    Selection = "selection",
+    Numeric = "numeric",
+    Temporal = "temporal",
+    Capture = "capture",
+    Assessment = "assessment",
+    Verification = "verification"
+}

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

@@ -1,31 +1,17 @@
 import { ReactNode } from 'react';
-import { AnyField, AnyFormElement, ValueOfField } from './typings';
-import { FieldRenderProps } from './BaseFormElement';
-export declare const useFieldInputs: (fields: AnyFormElement[], props: Omit<FieldRenderProps, "index">) => ReactNode;
-export declare const useFormikInput: <TField extends AnyField>(props: FieldRenderProps & {
+import { AnyField, ValueOfField } from './typings';
+import { FieldSection } from './FieldSection';
+export declare const useFieldSectionInputs: (fieldSections: FieldSection[]) => import("react/jsx-runtime").JSX.Element[];
+export declare const useFieldInputs: (fields: AnyField[]) => ReactNode;
+export interface useFieldInputProps<TField extends AnyField> {
     field: TField;
-}) => readonly [{
-    readonly error: string;
-    readonly size: import('..').FieldsRendererSize;
-    readonly inputId: string;
-    readonly labelId: string;
-    readonly label: string;
-    readonly description: string;
-    readonly showInputOnly: boolean | undefined;
-    readonly fieldProps: {
-        onChange: (value: ValueOfField<TField>) => void;
-        onBlur: (value: ValueOfField<TField>) => void;
-        value: ValueOfField<TField>;
-        name: string;
-        multiple?: boolean;
-        checked?: boolean;
-    };
-    readonly helpers: import('formik').FieldHelperProps<ValueOfField<TField>>;
-    readonly field: TField;
-    readonly touched: boolean;
-}, {
-    readonly "aria-labelledby": string;
-    readonly formId: string;
-    readonly index: number;
-    readonly disabled?: boolean;
-}];
+}
+export declare const useFieldInput: <TField extends AnyField>(props: useFieldInputProps<TField>) => {
+    value: ValueOfField<TField>;
+    name: TField["identifier"];
+    disabled: boolean | undefined;
+    isTouched: boolean;
+    error: string;
+    onChange: (value: ValueOfField<TField>) => void;
+    onBlur: import('react-hook-form').Noop;
+};

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

@@ -23,4 +23,6 @@ export * from './StringField';
 export * from './TextField';
 export type * from './typings';
 export * from './UploadField';
+export * from './URLField';
 export * from './utils';
+export * from './enums';

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

@@ -16,17 +16,19 @@ import { SelectField, SerializedSelectField } from './SelectField';
 import { SerializedStringField, StringField } from './StringField';
 import { SerializedTextField, TextField } from './TextField';
 import { SerializedUploadField, UploadField } from './UploadField';
+import { SerializedURLField, URLField } from './URLField';
 export type AnyFormElement = BaseFormElement<any, any>;
 export type AnyField = BaseField<any, any, any, any>;
 export type TypeOfField<TField extends AnyFormElement> = TField extends BaseFormElement<infer TType, infer _TThis> ? TType : never;
 export type ValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer TValue, infer _TSerializedValue, infer _TThis> ? TValue : never;
 export type SerializedValueOfField<TField extends AnyField> = TField extends BaseField<infer _TType, infer _TValue, infer TSerializedValue, infer _TThis> ? TSerializedValue : never;
-export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | RatingField | ScanField | SelectField | StringField | TextField | UploadField | OTPField;
-export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof RatingField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof OTPField;
+export type Field = BooleanField | CheckboxListField | PassFailField | DateField | MultiSelectField | MultiStringField | NumberField | RadioField | RatingField | ScanField | SelectField | StringField | TextField | UploadField | URLField | OTPField;
+export type FieldClass = typeof BooleanField | typeof CheckboxListField | typeof PassFailField | typeof DateField | typeof MultiSelectField | typeof MultiStringField | typeof NumberField | typeof RadioField | typeof RatingField | typeof ScanField | typeof SelectField | typeof StringField | typeof TextField | typeof UploadField | typeof URLField | typeof OTPField;
 export type FieldType = TypeOfField<Field> | TypeOfField<FieldSection>;
 export type FieldValue = ValueOfField<Field>;
+export type FieldError = string;
 export type SerializedFieldValue = SerializedValueOfField<Field>;
-export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedRatingField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField;
+export type SerializedField = SerializedTextField | SerializedBooleanField | SerializedNumberField | SerializedDateField | SerializedStringField | SerializedURLField | SerializedSelectField | SerializedFieldSection | SerializedMultiStringField | SerializedMultiSelectField | SerializedUploadField | SerializedScanField | SerializedRadioField | SerializedRatingField | SerializedCheckboxListField | SerializedOTPField | SerializedPassFailField;
 export type SerializedOnlyField = Exclude<SerializedField, SerializedFieldSection>;
 export interface FieldsManager {
     readonly fields: Field[];

package/dist/form/index.d.ts

@@ -1,6 +1,5 @@
 export * from './builder';
 export * from './conditions';
-export * from './constants';
 export * from './fields';
 export * from './modifiers';
 export * from './Observable';
@@ -10,3 +9,4 @@ export type * from './typings';
 export * from './utils';
 export * from './UUIDFile';
 export * from './UUIDPromise';
+export { fieldSpacingCva } from './cva';

package/dist/form/renderer/FieldsRenderer.d.ts

@@ -3,20 +3,16 @@ import { FieldValues } from '../typings';
 import { FieldsRendererSize } from './typings';
 import { FieldSchema } from '../schema';
 interface FieldsRendererProps {
-    readonly?: boolean;
+    disabled?: boolean;
     fieldSchema: FieldSchema;
     values?: FieldValues;
-    onValuesChange?: (allValues: FieldValues, changedValues: FieldValues) => void;
-    enableReinitialize?: boolean;
-    excludeUnchangedFields?: boolean;
+    onValuesChange?: (values: FieldValues) => void;
     hideSubmit?: boolean;
-    onSubmit?: (values: FieldValues) => Promise<void> | void;
+    onSubmit?: (values: FieldValues) => void;
     submitText?: string;
     hideCancel?: boolean;
     cancelText?: string;
     onCancel?: () => void;
-    onDirty?: () => void;
-    onDirtyChange?: (dirty: boolean) => void;
     className?: string;
     buttonProps?: Omit<ButtonProps, "children">;
     size?: FieldsRendererSize;

package/dist/form/schema/FieldSchema.d.ts

@@ -24,7 +24,7 @@ export declare class FieldSchema extends Observable<FieldSchema> implements Fiel
     deserializeValues(values: SerializedFieldValues, clean?: boolean): FieldValues;
     serializeValues(values: FieldValues, clean?: boolean): SerializedFieldValues;
     initializeValues(values: FieldValues): FieldValues;
-    validateValues(values: FieldValues): import('formik').FormikErrors<FieldValues> | undefined;
+    validateValues(values: FieldValues): import('..').FieldErrors;
     deserializeConditions(serializedConditions: SerializedCondition[]): Condition[];
     cleanConditions(conditions: Condition[]): Condition[];
     serializeConditions(conditions: Condition[]): SerializedCondition[];

package/dist/form/typings.d.ts

@@ -1,8 +1,10 @@
-import { Field, FieldValue, SerializedFieldValue } from './fields';
+import { Field, FieldError, FieldValue, SerializedFieldValue } from './fields';
 import { UUIDFile } from './UUIDFile';
 import { UUIDPromise } from './UUIDPromise';
 export type FieldValues = Record<Field["identifier"], FieldValue>;
+export type FieldErrors = {
+    [identifier: Field["identifier"]]: FieldError | FieldErrors;
+};
 export type FieldFilesAndPromises = Record<Field["identifier"], (UUIDFile | UUIDPromise<UUIDFile>)[]>;
 export type FieldFiles = Record<Field["identifier"], UUIDFile[]>;
 export type SerializedFieldValues = Record<Field["identifier"], SerializedFieldValue>;
-export type Severity = "danger" | "warning" | "info" | "success";

package/dist/form/utils.d.ts

@@ -1,7 +1,6 @@
-import { FormikErrors } from 'formik';
-import { FieldFiles, FieldFilesAndPromises, FieldValues } from './typings';
+import { FieldErrors, FieldFiles, FieldFilesAndPromises, FieldValues } from './typings';
 import { AnyFormElement, SerializedFieldSection } from './fields';
-export declare const validateFields: (fields: AnyFormElement[], values: FieldValues) => FormikErrors<FieldValues> | undefined;
+export declare const validateFieldValues: (fields: AnyFormElement[], values: FieldValues) => FieldErrors;
 export declare const separateImagesFromFields: (fields: SerializedFieldSection[]) => Promise<{
     fields: SerializedFieldSection[];
     images: Record<string, File>;