fastapi-rtk 2.1.5 → 2.2.0

package/dist/.external/lib/@jsonforms/core/mappers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './renderer';
+export * from './cell';
+export * from './combinators';
+export * from './util';

package/dist/.external/lib/@jsonforms/core/mappers/renderer.d.ts

@@ -0,0 +1,452 @@
+import { ControlElement, JsonSchema, LabelElement, UISchemaElement } from '../models';
+import type { RankedTester } from '../testers';
+import { CoreActions } from '../actions';
+import type { ErrorObject } from '../../../ajv';
+import type { AnyAction, Dispatch, JsonFormsCellRendererRegistryEntry, JsonFormsRendererRegistryEntry, JsonFormsState, JsonFormsUISchemaRegistryEntry } from '../store';
+import { ArrayTranslations } from '../i18n';
+import { Translator } from '../store';
+import { CombinatorKeyword } from './combinators';
+export declare const moveUp: (array: any[], toMove: number) => void;
+export declare const moveDown: (array: any[], toMove: number) => void;
+/**
+ * Adds an asterisk to the given label string based
+ * on the required parameter.
+ *
+ * @param {string | undefined} label the label string
+ * @param {boolean} required whether the label belongs to a control which is required
+ * @param {boolean} hideRequiredAsterisk applied UI Schema option
+ * @returns {string} the label string
+ */
+export declare const computeLabel: (label: string | undefined, required: boolean, hideRequiredAsterisk: boolean) => string;
+/**
+ * Indicates whether to mark a field as required.
+ *
+ * @param {boolean} required whether the label belongs to a control which is required
+ * @param {boolean} hideRequiredAsterisk applied UI Schema option
+ * @returns {boolean} should the field be marked as required
+ */
+export declare const showAsRequired: (required: boolean, hideRequiredAsterisk: boolean) => boolean;
+/**
+ * Create a default value based on the given schema.
+ * @param schema the schema for which to create a default value.
+ * @returns {any}
+ */
+export declare const createDefaultValue: (schema: JsonSchema, rootSchema: JsonSchema) => any;
+/**
+ * Create a default value based on the given schema.
+ * @param schema the schema for which to create a default value.
+ * @returns the default value to use, undefined if none was found
+ */
+export declare const doCreateDefaultValue: (schema: JsonSchema, rootSchema: JsonSchema) => any;
+/**
+ * Returns the default value defined in the given schema.
+ * @param schema the schema for which to create a default value.
+ * @returns {any}
+ */
+export declare const extractDefaults: (schema: JsonSchema, rootSchema: JsonSchema) => any;
+/**
+ * Whether an element's description should be hidden.
+ *
+ * @param visible whether an element is visible
+ * @param description the element's description
+ * @param isFocused whether the element is focused
+ *
+ * @returns {boolean} true, if the description is to be hidden, false otherwise
+ */
+export declare const isDescriptionHidden: (visible: boolean, description: string | undefined, isFocused: boolean, showUnfocusedDescription: boolean) => boolean;
+export interface WithClassname {
+    className?: string;
+}
+export interface EnumOption {
+    label: string;
+    value: any;
+}
+export declare const enumToEnumOptionMapper: (e: any, t?: Translator, i18nKey?: string) => EnumOption;
+export declare const oneOfToEnumOptionMapper: (e: any, t?: Translator, fallbackI18nKey?: string) => EnumOption;
+export interface OwnPropsOfRenderer {
+    /**
+     * The UI schema to be rendered.
+     */
+    uischema?: UISchemaElement;
+    /**
+     * The JSON schema that describes the data.
+     */
+    schema?: JsonSchema;
+    /**
+     * Whether the rendered element should be enabled.
+     */
+    enabled?: boolean;
+    /**
+     * Whether the rendered element should be visible.
+     */
+    visible?: boolean;
+    /**
+     * Optional instance path. Necessary when the actual data
+     * path can not be inferred via the UI schema element as
+     * it is the case with nested controls.
+     */
+    path?: string;
+    renderers?: JsonFormsRendererRegistryEntry[];
+    cells?: JsonFormsCellRendererRegistryEntry[];
+    uischemas?: JsonFormsUISchemaRegistryEntry[];
+}
+export interface OwnPropsOfControl extends OwnPropsOfRenderer {
+    id?: string;
+    uischema?: ControlElement;
+}
+export interface OwnPropsOfLabel extends OwnPropsOfRenderer {
+    uischema?: LabelElement;
+}
+export interface OwnPropsOfEnum {
+    options?: EnumOption[];
+}
+export interface OwnPropsOfLayout extends OwnPropsOfRenderer {
+    direction?: 'row' | 'column';
+}
+/**
+ * State-based props of a {@link Renderer}.
+ */
+export interface StatePropsOfRenderer {
+    /**
+     * Any configuration options for the element.
+     */
+    config?: any;
+    /**
+     * The UI schema to be rendered.
+     */
+    uischema: UISchemaElement;
+    /**
+     * The JSON schema that describes the data.
+     */
+    schema: JsonSchema;
+    /**
+     * The data to be rendered.
+     */
+    data?: any;
+    /**
+     * Whether the rendered element should be enabled.
+     */
+    enabled: boolean;
+    /**
+     * Whether the rendered element should be visible.
+     */
+    visible: boolean;
+    /**
+     * Instance path the data is written to, in case of a control.
+     */
+    path: string;
+    /**
+     * All available renderers.
+     */
+    renderers?: JsonFormsRendererRegistryEntry[];
+    /**
+     * All available cell renderers.
+     */
+    cells?: JsonFormsCellRendererRegistryEntry[];
+}
+/**
+ * State-based properties for UI schema elements that have a scope.
+ */
+export interface StatePropsOfScopedRenderer extends StatePropsOfRenderer {
+    uischema: ControlElement;
+    /**
+     * Any validation errors that are caused by the data to be rendered.
+     */
+    errors: string;
+    /**
+     * The data to be rendered.
+     */
+    data: any;
+    /**
+     * The root schema as returned by the store.
+     */
+    rootSchema: JsonSchema;
+    /**
+     * A unique ID that should be used for rendering the scoped UI schema element.
+     */
+    id: string;
+}
+/**
+ * Props of a {@link Renderer}.
+ */
+export interface RendererProps extends StatePropsOfRenderer {
+}
+/**
+ * State-based props of a Control
+ */
+export interface StatePropsOfControl extends StatePropsOfScopedRenderer {
+    cells?: {
+        tester: RankedTester;
+        cell: any;
+    }[];
+    /**
+     * The label for the rendered element.
+     */
+    label: string;
+    /**
+     * Description of input cell
+     */
+    description?: string;
+    /**
+     * Whether the rendered data is required.
+     */
+    required?: boolean;
+    i18nKeyPrefix?: string;
+}
+/**
+ * Dispatch-based props of a Control.
+ */
+export interface DispatchPropsOfControl {
+    /**
+     * Update handler that emits a data change
+     *
+     * @param {string} path the path to the data to be updated
+     * @param {any} value the new value that should be written to the given path
+     */
+    handleChange(path: string, value: any): void;
+}
+/**
+ * Props of a Control.
+ */
+export interface ControlProps extends StatePropsOfControl, DispatchPropsOfControl {
+}
+/**
+ * State props of a layout;
+ */
+export interface StatePropsOfLayout extends StatePropsOfRenderer {
+    /**
+     * Direction for the layout to flow
+     */
+    direction: 'row' | 'column';
+    label?: string;
+}
+export interface LayoutProps extends StatePropsOfLayout {
+}
+/**
+ * The state of a control.
+ */
+export interface ControlState {
+    /**
+     * The current value.
+     */
+    value: any;
+    /**
+     * Whether the control is focused.
+     */
+    isFocused: boolean;
+}
+/**
+ * Map state to control props.
+ * @param state the store's state
+ * @param ownProps any own props
+ * @returns {StatePropsOfControl} state props for a control
+ */
+export declare const mapStateToControlProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfControl;
+/**
+ *
+ * Map dispatch to control props.
+ *
+ * @param dispatch the store's dispatch method
+ * @returns {DispatchPropsOfControl} dispatch props for a control
+ */
+export declare const mapDispatchToControlProps: (dispatch: Dispatch<AnyAction>) => DispatchPropsOfControl;
+/**
+ * Default mapStateToCellProps for enum control. Options is used for populating dropdown list
+ * @param state
+ * @param ownProps
+ * @returns {StatePropsOfControl & OwnPropsOfEnum}
+ */
+export declare const mapStateToEnumControlProps: (state: JsonFormsState, ownProps: OwnPropsOfControl & OwnPropsOfEnum) => StatePropsOfControl & OwnPropsOfEnum;
+/**
+ * Default mapStateToCellProps for enum control based on oneOf. Options is used for populating dropdown list
+ * @param state
+ * @param ownProps
+ * @returns {StatePropsOfControl & OwnPropsOfEnum}
+ */
+export declare const mapStateToOneOfEnumControlProps: (state: JsonFormsState, ownProps: OwnPropsOfControl & OwnPropsOfEnum) => StatePropsOfControl & OwnPropsOfEnum;
+/**
+ * Default mapStateToCellProps for multi enum control. Options is used for populating dropdown list
+ * @param state
+ * @param ownProps
+ * @returns {StatePropsOfControl & OwnPropsOfEnum}
+ */
+export declare const mapStateToMultiEnumControlProps: (state: JsonFormsState, ownProps: OwnPropsOfControl & OwnPropsOfEnum) => StatePropsOfControl & OwnPropsOfEnum;
+/**
+ * Map state to control props.
+ * @param state the store's state
+ * @param ownProps any own props
+ * @returns {StatePropsOfControl} state props for a control
+ */
+export declare const mapStateToMasterListItemProps: (state: JsonFormsState, ownProps: OwnPropsOfMasterListItem) => StatePropsOfMasterItem;
+/**
+ * State-based props of a table control.
+ */
+export interface StatePropsOfControlWithDetail extends StatePropsOfControl {
+    uischemas?: JsonFormsUISchemaRegistryEntry[];
+    renderers?: JsonFormsRendererRegistryEntry[];
+    cells?: JsonFormsCellRendererRegistryEntry[];
+}
+export interface OwnPropsOfMasterListItem {
+    index: number;
+    selected: boolean;
+    path: string;
+    enabled: boolean;
+    schema: JsonSchema;
+    uischema: UISchemaElement;
+    childLabelProp?: string;
+    handleSelect(index: number): () => void;
+    removeItem(path: string, value: number): () => void;
+    translations: ArrayTranslations;
+    disableRemove?: boolean;
+}
+export interface StatePropsOfMasterItem extends OwnPropsOfMasterListItem {
+    childLabel: string;
+}
+/**
+ * Map state to control with detail props
+ *
+ * @param state the store's state
+ * @param ownProps any element's own props
+ * @returns {StatePropsOfArrayControl} state props for a table control
+ */
+export declare const mapStateToControlWithDetailProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfControlWithDetail;
+export interface ControlWithDetailProps extends StatePropsOfControlWithDetail, DispatchPropsOfControl {
+}
+/**
+ * State-based props of a table control.
+ */
+export interface StatePropsOfArrayControl extends StatePropsOfControlWithDetail {
+    arraySchema: JsonSchema;
+    childErrors?: ErrorObject[];
+}
+/**
+ * Map state to table props
+ *
+ * @param state the store's state
+ * @param ownProps any element's own props
+ * @returns {StatePropsOfArrayControl} state props for a table control
+ */
+export declare const mapStateToArrayControlProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfArrayControl;
+/**
+ * Dispatch props of a table control
+ */
+export interface DispatchPropsOfArrayControl {
+    addItem(path: string, value: any): () => void;
+    removeItems?(path: string, toDelete: number[]): () => void;
+    moveUp?(path: string, toMove: number): () => void;
+    moveDown?(path: string, toMove: number): () => void;
+}
+/**
+ * Maps state to dispatch properties of an array control.
+ *
+ * @param dispatch the store's dispatch method
+ * @returns {DispatchPropsOfArrayControl} dispatch props of an array control
+ */
+export declare const mapDispatchToArrayControlProps: (dispatch: Dispatch<CoreActions>) => DispatchPropsOfArrayControl;
+export interface DispatchPropsOfMultiEnumControl {
+    addItem: (path: string, value: any) => void;
+    removeItem?: (path: string, toDelete: any) => void;
+}
+export declare const mapDispatchToMultiEnumProps: (dispatch: Dispatch<CoreActions>) => DispatchPropsOfMultiEnumControl;
+/**
+ * Props of an array control.
+ */
+export interface ArrayControlProps extends StatePropsOfArrayControl, DispatchPropsOfArrayControl {
+}
+export declare const layoutDefaultProps: {
+    visible: boolean;
+    enabled: boolean;
+    path: string;
+    direction: 'row' | 'column';
+};
+/**
+ * Map state to layout props.
+ * @param state JSONForms state tree
+ * @param ownProps any own props
+ * @returns {StatePropsOfLayout}
+ */
+export declare const mapStateToLayoutProps: (state: JsonFormsState, ownProps: OwnPropsOfLayout) => LayoutProps;
+export type RefResolver = (schema: JsonSchema) => Promise<JsonSchema>;
+export interface OwnPropsOfJsonFormsRenderer extends OwnPropsOfRenderer {
+}
+export interface StatePropsOfJsonFormsRenderer extends OwnPropsOfJsonFormsRenderer {
+    rootSchema: JsonSchema;
+    config: any;
+}
+export interface JsonFormsProps extends StatePropsOfJsonFormsRenderer {
+}
+export declare const mapStateToJsonFormsRendererProps: (state: JsonFormsState, ownProps: OwnPropsOfJsonFormsRenderer) => StatePropsOfJsonFormsRenderer;
+export declare const controlDefaultProps: {
+    errors: string[];
+    visible: boolean;
+    enabled: boolean;
+    path: string;
+    direction: "row" | "column";
+};
+export interface StatePropsOfCombinator extends StatePropsOfControl {
+    rootSchema: JsonSchema;
+    path: string;
+    id: string;
+    indexOfFittingSchema: number;
+    uischemas: JsonFormsUISchemaRegistryEntry[];
+    data: any;
+}
+export declare const mapStateToCombinatorRendererProps: (state: JsonFormsState, ownProps: OwnPropsOfControl, keyword: CombinatorKeyword) => StatePropsOfCombinator;
+export interface CombinatorRendererProps extends StatePropsOfCombinator, DispatchPropsOfControl {
+}
+/**
+ * Map state to all of renderer props.
+ * @param state the store's state
+ * @param ownProps any own props
+ * @returns {StatePropsOfCombinator} state props for a combinator
+ */
+export declare const mapStateToAllOfProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfCombinator;
+export declare const mapStateToAnyOfProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfCombinator;
+export declare const mapStateToOneOfProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfCombinator;
+export interface StatePropsOfArrayLayout extends StatePropsOfControlWithDetail {
+    data: number;
+    arraySchema: JsonSchema;
+    /**
+     * @deprecated Use `arraySchema.minItems` instead.
+     */
+    minItems?: number;
+    disableRemove?: boolean;
+    disableAdd?: boolean;
+}
+/**
+ * Map state to table props
+ *
+ * @param state the store's state
+ * @param ownProps any element's own props
+ * @returns {StatePropsOfArrayControl} state props for a table control
+ */
+export declare const mapStateToArrayLayoutProps: (state: JsonFormsState, ownProps: OwnPropsOfControl) => StatePropsOfArrayLayout;
+/**
+ * Props of an array control.
+ */
+export interface ArrayLayoutProps extends StatePropsOfArrayLayout, DispatchPropsOfArrayControl {
+}
+export interface StatePropsOfLabel extends StatePropsOfRenderer {
+    text?: string;
+}
+export interface LabelProps extends StatePropsOfLabel {
+}
+export declare const mapStateToLabelProps: (state: JsonFormsState, props: OwnPropsOfLabel) => {
+    text: string;
+    visible: boolean;
+    config: any;
+    renderers: JsonFormsRendererRegistryEntry[];
+    cells: JsonFormsCellRendererRegistryEntry[];
+    uischema: LabelElement;
+};
+/**
+ * Compute the child label title for array based controls
+ * @param data the data of the control
+ * @param childPath the child path
+ * @param childLabelProp the dotted path to the value used as child label
+ * @param {JsonSchema} schema the json schema for this control
+ * @param {JsonSchema} rootSchema the root json schema
+ * @param {Translator} translateFct the translator fonction
+ * @param {UISchemaElement} uiSchema the uiSchema of the control
+ */
+export declare const computeChildLabel: (data: any, childPath: string, childLabelProp: string, schema: JsonSchema, rootSchema: JsonSchema, translateFct: Translator, uiSchema: UISchemaElement) => string;

package/dist/.external/lib/@jsonforms/core/mappers/util.d.ts

@@ -0,0 +1,10 @@
+import { JsonSchema, UISchemaElement } from '../models';
+import { JsonFormsState } from '../store';
+/**
+ * Indicates whether the given `uischema` element shall be enabled or disabled.
+ * Checks the global readonly flag, uischema rule, uischema options (including the config),
+ * the schema and the enablement indicator of the parent.
+ */
+export declare const isInherentlyEnabled: (state: JsonFormsState, ownProps: any, uischema: UISchemaElement, schema: (JsonSchema & {
+    readOnly?: boolean;
+}) | undefined, rootData: any, config: any) => any;

package/dist/.external/lib/@jsonforms/core/models/draft4.d.ts

@@ -0,0 +1,198 @@
+export declare const Draft4: {
+    id: string;
+    $schema: string;
+    description: string;
+    definitions: {
+        schemaArray: {
+            type: string;
+            minItems: number;
+            items: {
+                $ref: string;
+            };
+        };
+        positiveInteger: {
+            type: string;
+            minimum: number;
+        };
+        positiveIntegerDefault0: {
+            allOf: ({
+                $ref: string;
+                default?: undefined;
+            } | {
+                default: number;
+                $ref?: undefined;
+            })[];
+        };
+        simpleTypes: {
+            enum: string[];
+        };
+        stringArray: {
+            type: string;
+            items: {
+                type: string;
+            };
+            minItems: number;
+            uniqueItems: boolean;
+        };
+    };
+    type: string;
+    properties: {
+        id: {
+            type: string;
+            format: string;
+        };
+        $schema: {
+            type: string;
+            format: string;
+        };
+        title: {
+            type: string;
+        };
+        description: {
+            type: string;
+        };
+        default: {};
+        multipleOf: {
+            type: string;
+            minimum: number;
+            exclusiveMinimum: boolean;
+        };
+        maximum: {
+            type: string;
+        };
+        exclusiveMaximum: {
+            type: string;
+            default: boolean;
+        };
+        minimum: {
+            type: string;
+        };
+        exclusiveMinimum: {
+            type: string;
+            default: boolean;
+        };
+        maxLength: {
+            $ref: string;
+        };
+        minLength: {
+            $ref: string;
+        };
+        pattern: {
+            type: string;
+            format: string;
+        };
+        additionalItems: {
+            anyOf: ({
+                type: string;
+                $ref?: undefined;
+            } | {
+                $ref: string;
+                type?: undefined;
+            })[];
+            default: {};
+        };
+        items: {
+            anyOf: {
+                $ref: string;
+            }[];
+            default: {};
+        };
+        maxItems: {
+            $ref: string;
+        };
+        minItems: {
+            $ref: string;
+        };
+        uniqueItems: {
+            type: string;
+            default: boolean;
+        };
+        maxProperties: {
+            $ref: string;
+        };
+        minProperties: {
+            $ref: string;
+        };
+        required: {
+            $ref: string;
+        };
+        additionalProperties: {
+            anyOf: ({
+                type: string;
+                $ref?: undefined;
+            } | {
+                $ref: string;
+                type?: undefined;
+            })[];
+            default: {};
+        };
+        definitions: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        properties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        patternProperties: {
+            type: string;
+            additionalProperties: {
+                $ref: string;
+            };
+            default: {};
+        };
+        dependencies: {
+            type: string;
+            additionalProperties: {
+                anyOf: {
+                    $ref: string;
+                }[];
+            };
+        };
+        enum: {
+            type: string;
+            minItems: number;
+            uniqueItems: boolean;
+        };
+        type: {
+            anyOf: ({
+                $ref: string;
+                type?: undefined;
+                items?: undefined;
+                minItems?: undefined;
+                uniqueItems?: undefined;
+            } | {
+                type: string;
+                items: {
+                    $ref: string;
+                };
+                minItems: number;
+                uniqueItems: boolean;
+                $ref?: undefined;
+            })[];
+        };
+        allOf: {
+            $ref: string;
+        };
+        anyOf: {
+            $ref: string;
+        };
+        oneOf: {
+            $ref: string;
+        };
+        not: {
+            $ref: string;
+        };
+    };
+    dependencies: {
+        exclusiveMaximum: string[];
+        exclusiveMinimum: string[];
+    };
+    default: {};
+};

package/dist/.external/lib/@jsonforms/core/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from './draft4';
+export * from './jsonSchema';
+export * from './jsonSchema4';
+export * from './jsonSchema7';
+export * from './uischema';

package/dist/.external/lib/@jsonforms/core/models/jsonSchema.d.ts

@@ -0,0 +1,3 @@
+import type { JsonSchema4 } from './jsonSchema4';
+import type { JsonSchema7 } from './jsonSchema7';
+export type JsonSchema = JsonSchema4 | JsonSchema7;