@maif/react-forms 1.0.60 → 1.1.2

package/lib/index.d.ts

@@ -0,0 +1,364 @@
+/// <reference types="react" />
+import * as yup_lib_types from 'yup/lib/types';
+import * as yup from 'yup';
+import { AnySchema, StringSchema, NumberSchema, ArraySchema, TestFunction } from 'yup';
+import Reference from 'yup/lib/Reference';
+import * as yup_lib_object from 'yup/lib/object';
+import React from 'react';
+
+declare const type: {
+    readonly string: "string";
+    readonly number: "number";
+    readonly bool: "bool";
+    readonly date: "date";
+    readonly object: "object";
+    readonly file: "file";
+    readonly json: "json";
+};
+declare let typeValues: ("string" | "number" | "object" | "json" | "bool" | "date" | "file")[];
+declare type Type = typeof typeValues[number];
+
+declare const format: {
+    readonly array: "array";
+    readonly select: "select";
+    readonly code: "code";
+    readonly markdown: "markdown";
+    readonly text: "textarea";
+    readonly textarea: "textarea";
+    readonly email: "email";
+    readonly password: "password";
+    readonly hidden: "hidden";
+    readonly form: "form";
+    readonly buttonsSelect: "buttons";
+    readonly singleLineCode: "singleLineCode";
+};
+declare let formatValues: ("markdown" | "email" | "array" | "select" | "code" | "textarea" | "password" | "hidden" | "form" | "buttons" | "singleLineCode")[];
+declare type Format = typeof formatValues[number];
+
+declare type Constraint = (resolver: any, key: string, dependencies: any[]) => AnySchema;
+declare type NumberRef = Reference<number> | number;
+declare const required: (message?: string) => (r: AnySchema) => any;
+declare const url: (message?: string) => (r: StringSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined>;
+declare const email: (message?: string) => (r: StringSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined>;
+declare const uuid: (message?: string) => (r: StringSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined>;
+declare const matches: (regexp?: RegExp, message?: string) => (r: StringSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined>;
+declare const min: (ref: NumberRef, message?: string) => (r: StringSchema | NumberSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined> | yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const max: (ref: NumberRef, message?: string) => (r: StringSchema | NumberSchema) => yup.StringSchema<string | undefined, yup_lib_types.AnyObject, string | undefined> | yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const positive: (message?: string) => (r: NumberSchema) => yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const negative: (message?: string) => (r: NumberSchema) => yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const integer: (message?: string) => (r: NumberSchema) => yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const lessThan: (ref: NumberRef, message?: string) => (r: NumberSchema, key: any, dependencies: Array<[any, Reference]>) => yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const moreThan: (ref: NumberRef, message?: string) => (r: NumberSchema, key: any, dependencies: Array<[any, Reference]>) => yup.NumberSchema<number | undefined, yup_lib_types.AnyObject, number | undefined>;
+declare const length: (ref: NumberRef, message?: string) => (r: ArraySchema<any>) => yup.ArraySchema<any, yup_lib_types.AnyObject, any[] | undefined, any[] | undefined>;
+declare const supportedFormat: (arrayOfValues: string[], message?: string) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const unsupportedFormat: (arrayOfValues: string[], message?: string) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const maxSize: (ref: Reference, message?: string) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const test: (name: string, message: string | undefined, test: TestFunction<any, object>) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const when: (ref: string, test: TestFunction<any, object>, then?: Constraint[], otherwise?: Constraint[]) => (r: AnySchema, key: string, dependencies: any[]) => yup.AnySchema<any, any, any>;
+declare const oneOf: (arrayOfValues: any[], message?: string) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const blacklist: (arrayOfValues: any[], message?: string) => (r: AnySchema) => yup.AnySchema<any, any, any>;
+declare const ref: (ref: string) => Reference<unknown>;
+declare const jsonConstraints: Record<string, any>;
+declare type TConstraintType = keyof typeof jsonConstraints;
+
+type constraints_d_Constraint = Constraint;
+declare const constraints_d_required: typeof required;
+declare const constraints_d_url: typeof url;
+declare const constraints_d_email: typeof email;
+declare const constraints_d_uuid: typeof uuid;
+declare const constraints_d_matches: typeof matches;
+declare const constraints_d_min: typeof min;
+declare const constraints_d_max: typeof max;
+declare const constraints_d_positive: typeof positive;
+declare const constraints_d_negative: typeof negative;
+declare const constraints_d_integer: typeof integer;
+declare const constraints_d_lessThan: typeof lessThan;
+declare const constraints_d_moreThan: typeof moreThan;
+declare const constraints_d_length: typeof length;
+declare const constraints_d_supportedFormat: typeof supportedFormat;
+declare const constraints_d_unsupportedFormat: typeof unsupportedFormat;
+declare const constraints_d_maxSize: typeof maxSize;
+declare const constraints_d_test: typeof test;
+declare const constraints_d_when: typeof when;
+declare const constraints_d_oneOf: typeof oneOf;
+declare const constraints_d_blacklist: typeof blacklist;
+declare const constraints_d_ref: typeof ref;
+declare const constraints_d_jsonConstraints: typeof jsonConstraints;
+type constraints_d_TConstraintType = TConstraintType;
+declare namespace constraints_d {
+  export {
+    constraints_d_Constraint as Constraint,
+    constraints_d_required as required,
+    constraints_d_url as url,
+    constraints_d_email as email,
+    constraints_d_uuid as uuid,
+    constraints_d_matches as matches,
+    constraints_d_min as min,
+    constraints_d_max as max,
+    constraints_d_positive as positive,
+    constraints_d_negative as negative,
+    constraints_d_integer as integer,
+    constraints_d_lessThan as lessThan,
+    constraints_d_moreThan as moreThan,
+    constraints_d_length as length,
+    constraints_d_supportedFormat as supportedFormat,
+    constraints_d_unsupportedFormat as unsupportedFormat,
+    constraints_d_maxSize as maxSize,
+    constraints_d_test as test,
+    constraints_d_when as when,
+    constraints_d_oneOf as oneOf,
+    constraints_d_blacklist as blacklist,
+    constraints_d_ref as ref,
+    constraints_d_jsonConstraints as jsonConstraints,
+    constraints_d_TConstraintType as TConstraintType,
+  };
+}
+
+interface PropType {
+    onChange?: (v: boolean) => void;
+    value?: boolean;
+    readOnly?: boolean;
+}
+declare const BooleanInput: React.ForwardRefExoticComponent<PropType & React.RefAttributes<HTMLInputElement>>;
+
+declare const Collapse: (props: {
+    initCollapsed?: boolean;
+    collapsed?: boolean;
+    errored: boolean;
+    label?: React.ReactNode;
+    inline?: any;
+    children: React.ReactNode;
+    lineEnd?: boolean;
+}) => JSX.Element;
+
+declare type SelectOption = {
+    label: string;
+    value: any;
+};
+declare const SelectInput: <T extends {
+    [x: string]: any;
+}>(props: {
+    possibleValues: T[];
+    transformer?: {
+        label: string;
+        value: string;
+    } | ((v: T) => SelectOption) | undefined;
+    value?: any;
+    defaultValue?: any;
+    isMulti?: boolean | undefined;
+    optionsFrom: string | Promise<T[]> | ((param: {
+        rawValues: object;
+        value: any;
+    }) => string | Promise<T[]>);
+    fetchCondition?: (() => boolean) | undefined;
+    id?: string | undefined;
+    httpClient?: ((url: string, method: string) => Promise<Response>) | undefined;
+    onChange?: ((options: any[] | any) => void) | undefined;
+    onCreateOption?: ((option: string) => T) | undefined;
+    buttons: boolean;
+    disabled?: boolean | undefined;
+    createOption?: boolean | undefined;
+    label?: string | undefined;
+    placeholder?: React.ReactNode;
+    className: string;
+}) => JSX.Element;
+
+declare type InternalState = {
+    [x: string]: {
+        key: string;
+        value: any;
+    };
+};
+declare const ObjectInput: (props: {
+    value?: object | undefined;
+    onChange?: ((value: InternalState) => void) | undefined;
+    defaultKeyValue?: {
+        key: string;
+        value: string;
+    } | undefined;
+    className: string;
+    disabled?: boolean | undefined;
+    placeholderKey?: string | undefined;
+    placeholderValue?: string | undefined;
+}) => JSX.Element;
+
+declare type LanguageMode = "javascript" | "css" | "json" | "html" | "markdown";
+
+declare function CodeInput({ onChange, value, mode, tabSize, readOnly, showLinesNumber, highlightLine, themeStyle, setRef }: {
+    onChange?: (v: string) => void;
+    value?: string;
+    mode?: LanguageMode;
+    tabSize?: number;
+    readOnly?: boolean;
+    showLinesNumber?: boolean;
+    highlightLine?: boolean;
+    themeStyle?: {
+        height: string;
+        minHeight: string;
+        maxHeight: string;
+        width: string;
+        minWidth: string;
+        maxWidth: string;
+    };
+    setRef?: (editor: any) => void;
+}): JSX.Element;
+
+declare const MarkdownInput: (props: {
+    value?: string | undefined;
+    preview?: boolean | undefined;
+    className: string;
+    readOnly?: boolean | undefined;
+    onChange?: ((value: string) => void) | undefined;
+}) => JSX.Element;
+
+declare function SingleLineCode({ onChange, value, mode, tabSize, readOnly, showLinesNumber, highlightLine, themeStyle }: {
+    onChange?: (newValue: string) => void;
+    value?: string;
+    mode?: LanguageMode;
+    tabSize?: number;
+    readOnly?: boolean;
+    showLinesNumber?: boolean;
+    highlightLine?: boolean;
+    themeStyle?: {
+        height: string;
+        minHeight: string;
+        maxHeight: string;
+        width: string;
+        minWidth: string;
+        maxWidth: string;
+    };
+}): JSX.Element;
+
+interface OptionActionItem {
+    display?: boolean;
+    label?: string;
+}
+interface OptionActions {
+    reset?: OptionActionItem;
+    submit?: OptionActionItem;
+}
+declare type HttpClient = (url: string, method: string) => Promise<Response>;
+interface Option {
+    httpClient?: HttpClient;
+    watch?: boolean | ((param: any) => void);
+    autosubmit?: boolean;
+    actions?: OptionActions;
+    showErrorsOnStart?: boolean;
+}
+interface Schema {
+    [key: string]: SchemaEntry;
+}
+declare type SchemaRenderType = ({ rawValues, value, onChange, error, setValue, parent }: {
+    rawValues?: any;
+    value?: any;
+    onChange?: (param: object) => void;
+    error?: boolean;
+    parent?: string;
+    setValue?: (data: any) => void;
+}) => JSX.Element;
+interface ConditionnalSchemaElement {
+    default?: boolean;
+    condition?: ({ rawValues, ref }: {
+        rawValues: {
+            [x: string]: any;
+        };
+        ref: any;
+    }) => boolean | any;
+    schema: Schema;
+    flow: Array<FlowObject | string>;
+}
+interface ConditionnalSchema {
+    ref: string;
+    switch: ConditionnalSchemaElement[];
+}
+interface SchemaEntry {
+    schema?: Schema;
+    type: Type;
+    format?: Format;
+    array?: boolean;
+    createOption?: boolean;
+    onCreateOption?: (option: string) => any;
+    isMulti?: boolean;
+    defaultKeyValue?: object;
+    visible?: boolean | {
+        ref: string;
+        test: (b: any, idx?: number) => boolean;
+    };
+    disabled?: boolean | ((prop: {
+        rawValues: {
+            [x: string]: any;
+        };
+        value: any;
+    }) => boolean);
+    label?: React.ReactNode | ((prop: {
+        rawValues: {
+            [x: string]: any;
+        };
+        value: any;
+    }) => React.ReactNode);
+    placeholder?: string;
+    defaultValue?: any;
+    help?: string;
+    className?: string;
+    style?: object;
+    onChange?: (param: object) => void;
+    render: SchemaRenderType;
+    itemRender?: SchemaRenderType;
+    props: object;
+    options: Array<any | {
+        label: string;
+        value: any;
+    }>;
+    optionsFrom: string;
+    transformer: ((v: any) => SelectOption) | {
+        label: string;
+        value: string;
+    };
+    conditionalSchema: ConditionnalSchema;
+    constraints: Array<Constraint | {
+        type: TConstraintType;
+        message?: string;
+    }>;
+    flow: Array<string | FlowObject>;
+    onAfterChange?: (obj: {
+        entry: string;
+        value: object;
+        rawValues: object;
+        previousValue?: object;
+        getValue: (entry: string) => any;
+        setValue: (entry: string, value: any) => void;
+        onChange: (v: any) => void;
+        informations?: Informations;
+    }) => void;
+    visibleOnCollapse?: boolean;
+    addableDefaultValue: any;
+    collapsed?: boolean;
+    collapsable?: boolean;
+}
+interface FlowObject {
+    label: string;
+    flow: Flow;
+    collapse: boolean;
+}
+declare type Flow = Array<string | FlowObject>;
+interface Informations {
+    path: string;
+    parent?: Informations;
+    index?: number;
+}
+declare const validate: (flow: string[], schema: Schema, value: object) => Promise<yup_lib_object.AssertsShape<yup_lib_object.Assign<yup_lib_object.ObjectShape, yup_lib_object.ObjectShape>>>;
+declare const Form: React.ForwardRefExoticComponent<{
+    schema: Schema;
+    flow: Array<string | FlowObject>;
+    value?: object | undefined;
+    inputWrapper?: ((props: object) => JSX.Element) | undefined;
+    onSubmit: (obj: object) => void;
+    onError?: (() => void) | undefined;
+    footer?: ((props: object) => JSX.Element) | undefined;
+    style?: object | undefined;
+    className?: string | undefined;
+    options?: Option | undefined;
+    nostyle: boolean;
+} & React.RefAttributes<unknown>>;
+
+export { BooleanInput, CodeInput, Collapse, ConditionnalSchema, Flow, Form, Format, MarkdownInput, ObjectInput, Schema, SchemaEntry, SelectInput, SelectOption, SingleLineCode, Type, constraints_d as constraints, format, type, validate };