@rjsf/core 6.0.0-alpha.0 → 6.0.0-beta.2

package/lib/components/fields/BooleanField.js

@@ -1,24 +1,23 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { getWidget, getUiOptions, optionsList, TranslatableString, } from '@rjsf/utils';
-import isObject from 'lodash/isObject';
+import isObject from 'lodash-es/isObject.js';
 /** The `BooleanField` component is used to render a field in the schema is boolean. It constructs `enumOptions` for the
  * two boolean values based on the various alternatives in the schema.
  *
  * @param props - The `FieldProps` for this template
  */
 function BooleanField(props) {
-    var _a, _b, _c;
     const { schema, name, uiSchema, idSchema, formData, registry, required, disabled, readonly, hideError, autofocus, title, onChange, onFocus, onBlur, rawErrors, } = props;
     const { title: schemaTitle } = schema;
     const { widgets, formContext, translateString, globalUiOptions } = registry;
     const { widget = 'checkbox', title: uiTitle, 
     // Unlike the other fields, don't use `getDisplayLabel()` since it always returns false for the boolean type
-    label: displayLabel = true, ...options } = getUiOptions(uiSchema, globalUiOptions);
+    label: displayLabel = true, enumNames, ...options } = getUiOptions(uiSchema, globalUiOptions);
     const Widget = getWidget(schema, widget, widgets);
     const yes = translateString(TranslatableString.YesLabel);
     const no = translateString(TranslatableString.NoLabel);
     let enumOptions;
-    const label = (_b = (_a = uiTitle !== null && uiTitle !== void 0 ? uiTitle : schemaTitle) !== null && _a !== void 0 ? _a : title) !== null && _b !== void 0 ? _b : name;
+    const label = uiTitle ?? schemaTitle ?? title ?? name;
     if (Array.isArray(schema.oneOf)) {
         enumOptions = optionsList({
             oneOf: schema.oneOf
@@ -35,10 +34,8 @@ function BooleanField(props) {
         }, uiSchema);
     }
     else {
-        // We deprecated enumNames in v5. It's intentionally omitted from RSJFSchema type, so we need to cast here.
-        const schemaWithEnumNames = schema;
-        const enums = (_c = schema.enum) !== null && _c !== void 0 ? _c : [true, false];
-        if (!schemaWithEnumNames.enumNames && enums.length === 2 && enums.every((v) => typeof v === 'boolean')) {
+        const enums = schema.enum ?? [true, false];
+        if (!enumNames && enums.length === 2 && enums.every((v) => typeof v === 'boolean')) {
             enumOptions = [
                 {
                     value: enums[0],
@@ -51,14 +48,9 @@ function BooleanField(props) {
             ];
         }
         else {
-            enumOptions = optionsList({
-                enum: enums,
-                // NOTE: enumNames is deprecated, but still supported for now.
-                enumNames: schemaWithEnumNames.enumNames,
-            }, uiSchema);
+            enumOptions = optionsList({ enum: enums }, uiSchema);
         }
     }
     return (_jsx(Widget, { options: { ...options, enumOptions }, schema: schema, uiSchema: uiSchema, id: idSchema.$id, name: name, onChange: onChange, onFocus: onFocus, onBlur: onBlur, label: label, hideLabel: !displayLabel, value: formData, required: required, disabled: disabled, readonly: readonly, hideError: hideError, registry: registry, formContext: formContext, autofocus: autofocus, rawErrors: rawErrors }));
 }
 export default BooleanField;
-//# sourceMappingURL=BooleanField.js.map

package/lib/components/fields/LayoutGridField.d.ts

@@ -0,0 +1,480 @@
+import { ComponentType, PureComponent, ReactNode } from 'react';
+import { ErrorSchema, FieldProps, FormContextType, GenericObjectType, IdSchema, RJSFSchema, Registry, SchemaUtilsType, StrictRJSFSchema, UiSchema } from '@rjsf/utils';
+/** The enumeration of the three different Layout GridTemplate type values
+ */
+export declare enum GridType {
+    ROW = "ui:row",
+    COLUMN = "ui:col",
+    COLUMNS = "ui:columns",
+    CONDITION = "ui:condition"
+}
+/** The enumeration of the different operators within a condition
+ */
+export declare enum Operators {
+    ALL = "all",
+    SOME = "some",
+    NONE = "none"
+}
+/** Type used to represent an object that contains anything */
+type ConfigObject = Record<string, any>;
+export interface GridProps extends GenericObjectType {
+    /** The optional operator to use when comparing a field's value with the expected value for `GridType.CONDITION`
+     */
+    operator?: Operators;
+    /** The optional name of the field from which to get the value for `GridType.CONDITION`
+     */
+    field?: string;
+    /** The optional expected value against which to compare the field's value using the `operator`
+     */
+    value?: unknown;
+}
+export type GridSchemaType = {
+    [gridType in GridType]?: object;
+};
+/** The types which comprise the possibilities for the `layoutGridSchema` prop
+ */
+export type LayoutGridSchemaType = GridSchemaType | ConfigObject | string;
+export interface LayoutGridFieldProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> extends FieldProps<T, S, F> {
+    /** Optional string or object used to describe the current level of the `LayoutGridField`
+     */
+    layoutGridSchema?: LayoutGridSchemaType;
+}
+/** The regular expression that is used to detect whether a string contains a lookup key
+ */
+export declare const LOOKUP_REGEX: RegExp;
+/** The constant representing the main layout grid schema option name in the `uiSchema`
+ */
+export declare const LAYOUT_GRID_UI_OPTION = "layoutGrid";
+/** The constant representing the main layout grid schema option name in the `uiSchema`
+ */
+export declare const LAYOUT_GRID_OPTION = "ui:layoutGrid";
+/** The constant representing the global UI Options object potentially contained within the `uiSchema`
+ */
+export declare const UI_GLOBAL_OPTIONS = "ui:global_options";
+/** Type used to return options list and whether it has a discriminator */
+type OneOfOptionsInfoType<S extends StrictRJSFSchema = RJSFSchema> = {
+    options: S[];
+    hasDiscriminator: boolean;
+};
+/** Type used to represent a React-based rendering component */
+type RenderComponent = ComponentType<any>;
+/** Type used to determine what are the UIComponent and props from the grid schema */
+type UIComponentPropsType = {
+    /** The name of the component */
+    name: string;
+    /** The render component if specified */
+    UIComponent: RenderComponent | null;
+    /** Any uiProps associated with the render component */
+    uiProps: ConfigObject;
+    /** The special case where the component is immediately rendered */
+    rendered: ReactNode;
+};
+/** The `LayoutGridField` will render a schema, uiSchema and formData combination out into a GridTemplate in the shape
+ * described in the uiSchema. To define the grid to use to render the elements within a field in the schema, provide in
+ * the uiSchema for that field the object contained under a `ui:layoutGrid` element. E.g. (as a JSON object):
+ *
+ * ```
+ * {
+ *   "field1" : {
+ *     "ui:field": "LayoutGridField",
+ *     "ui:layoutGrid": {
+ *       "ui:row": { ... }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The outermost level of a `LayoutGridField` is the `ui:row` that defines the nested rows, columns, and/or condition
+ * elements (i.e. "grid elements") in the grid. This definition is either a simple "grid elements" OR an object with
+ * native `GridTemplate` implementation specific props and a `children` array of "grid elements". E.g. (as JSON objects):
+ *
+ * Simple `ui:row` definition, without additional `GridTemplate` props:
+ * ```
+ *  "ui:row": [
+ *    { "ui:row"|"ui:col"|"ui:columns"|"ui:condition": ... },
+ *    ...
+ *  ]
+ * ```
+ *
+ * Complex `ui:row` definition, with additional `GridTemplate` (this example uses @mui/material/Grid2 native props):
+ * ```
+ *  "ui:row": {
+ *    "spacing": 2,
+ *    "size": { md": 4 },
+ *    "alignContent": "flex-start",
+ *    "className": "GridRow",
+ *    "children": [
+ *      { "ui:row"|"ui:col"|"ui:columns"|"ui:condition": ... },
+ *      ...
+ *    ]
+ *  }
+ * ```
+ *
+ * NOTE: Special note about the native `className` prop values. All className values will automatically be looked up in
+ *       the `formContext.lookupMap` in case they have been defined using a CSS-in-JS approach. In other words, from the
+ *       example above, if the `Form` was constructed with a `lookupMap` set to `{ GridRow: cssInJs.GridRowClass }`
+ *       then when rendered, the native `GridTemplate` will get the `className` with the value from
+ *       `cssInJs.GridRowClass`. This automatic lookup will happen for any of the "grid elements" when rendering with
+ *       `GridTemplate` props. If multiple className values are present, for example:
+ *       `{ className: 'GridRow GridColumn' }`, the classNames are split apart, looked up individually, and joined
+ *       together to form one className with the values from `cssInJs.GridRowClass` and `cssInJs.GridColumnClass`.
+ *
+ * The `ui:col` grid element is used to specify the list of columns within a grid row. A `ui:col` element can take on
+ * several forms: 1) a simple list of dotted-path field names within the root field; 2) a list of objects containing the
+ * dotted-path field `name` any other props that are gathered into `ui:options` for the field; 3) a list with a one-off
+ * `render` functional component with or without a non-field `name` identifier and any other to-be-spread props; and
+ * 4) an object with native `GridTemplate` implementation specific props and a `children` array with 1) or 2) or even a
+ * nested `ui:row` or a `ui:condition` containing a `ui:row` (although this should be used carefully). E.g.
+ * (as JSON objects):
+ *
+ * Simple `ui:col` definition, without additional `GridTemplate` props and form 1 only children:
+ * ```
+ * "ui:col": ["innerField", "inner.grandChild", ...]
+ * ```
+ *
+ * Complicated `ui:col` definition, without additional `GridTemplate` props and form 2 only children:
+ * ```
+ * "ui:col": [
+ *    { "name": "innerField", "fullWidth": true },
+ *    { "name": "inner.grandChild", "convertOther": true },
+ *    ...
+ *  ]
+ * ```
+ *
+ * More complicated `ui:col` definition, without additional `GridTemplate` props and form 2 children, one being a
+ * one-off `render` functional component without a non-field `name` identifier
+ * ```
+ * "ui:col": [
+ *   "innerField",
+ *     {
+ *       "render": "WizardNavButton",
+ *       "isNext": true,
+ *       "size": "large"
+ *     }
+ *  ]
+ *  ```
+ *
+ * Most complicated `ui:col` definition, additional `GridTemplate` props and form 1, 2 and 3 children  (this example
+ * uses @mui/material/Grid2 native props):
+ * ```
+ * "ui:col": {
+ *    "size": { "md": 4 },
+ *    "className": "GridColumn",
+ *    "children": [
+ *      "innerField",
+ *      { "name": "inner.grandChild", "convertOther": true },
+ *      { "name": "customRender", "render": "CustomRender", toSpread: "prop-value" }
+ *      { "ui:row|ui:condition": ... }
+ *      ...
+ *    ]
+ *    }
+ * ```
+ *
+ * NOTE: If a `name` prop does not exist or its value does not match any field in a schema, then it is assumed to be a
+ *       custom `render` component. If the `render` prop does not exist, a null render will occur. If `render` is a
+ *       string, its value will be looked up in the `formContext.lookupMap` first before defaulting to a null render.
+ *
+ * The `ui:columns` grid element is syntactic sugar to specify a set of `ui:col` columns that all share the same set of
+ * native `GridTemplate` props. In other words rather than writing the following configuration that renders a
+ * `<GridTemplate>` element with 3 `<GridTemplate column className="GridColumn col-md-4">` nodes and 2
+ * `<GridTemplate column className="col-md-6">` nodes within it (one for each of the fields contained in the `children`
+ * list):
+ *
+ * ```
+ * "ui:row": {
+ *   "children": [
+ *     {
+ *       "ui:col": {
+ *         "className": "GridColumn col-md-4",
+ *         "children": ["innerField"],
+ *       }
+ *     },
+ *     {
+ *       "ui:col": {
+ *         "className": "GridColumn col-md-4",
+ *         "children": ["inner.grandChild"],
+ *       }
+ *     },
+ *     {
+ *       "ui:col": {
+ *         "className": "GridColumn col-md-4",
+ *         "children": [{ "name": "inner.grandChild2" }],
+ *       }
+ *     },
+ *     {
+ *       "ui:col": {
+ *         "className": "col-md-6",
+ *         "children": ["innerField2"],
+ *       }
+ *     },
+ *     {
+ *       "ui:col": {
+ *         "className": "col-md-6",
+ *         "children": ["inner.grandChild3"],
+ *       }
+ *     },
+
+ *   ]
+ * }
+ * ```
+ *
+ * One can write this instead:
+ * ```
+ * "ui:row": {
+ *   "children": [
+ *     {
+ *       "ui:columns": {
+ *         "className": "GridColumn col-md-4",
+ *         "children": ["innerField", "inner.grandChild", { "name": "inner.grandChild2", "convertOther": true }],
+ *       }
+ *     },
+ *     {
+ *       "ui:columns": {
+ *         "className": "col-md-6",
+ *         "children": ["innerField2", "inner.grandChild3"],
+ *       }
+ *     }
+ *   ]
+ * }
+ * ```
+ *
+ * NOTE: This syntax differs from
+ *       `"ui:col": { "className": "col-md-6", "children": ["innerField2", "inner.grandChild3"] }` in that
+ *       the `ui:col` will render the two children fields inside a single `<GridTemplate "className": "col-md-6",>`
+ *       element.
+ *
+ * The final grid element, `ui:condition`, allows for conditionally displaying "grid elements" within a row based on the
+ * current value of a field as it relates to a (list of) hard-coded value(s). There are four elements that make up a
+ * `ui:condition`: 1) the dotted-path `field` name within the root field that makes up the left-side of the condition;
+ * 2) the hard-coded `value` (single or list) that makes up the right-side of the condition; 3) the `operator` that
+ * controls how the left and right sides of the condition are compared; and 4) the `children` array that defines the
+ * "grid elements" to display if the condition passes.
+ *
+ * A `ui:condition` uses one of three `operators` when deciding if a condition passes: 1) The `all` operator will pass
+ * when the right-side and left-side contains all the same value(s); 2) the `some` operator will pass when the
+ * right-side and left-side contain as least one value in common; 3) the `none` operator will pass when the right-side
+ * and left-side do not contain any values in common. E.g. (as JSON objects):
+ *
+ * Here is how to render an if-then-else for `field2` which is an enum that has 3 known values and supports allowing
+ * any other value:
+ * ```
+ * "ui:row": [
+ *   {
+ *     "ui:condition": {
+ *       "field": "field2",
+ *       "operator": "all",
+ *       "value": "value1",
+ *       "children": [
+ *         { "ui:row": [...] },
+ *       ],
+ *     }
+ *   },
+ *   {
+ *     "ui:condition": {
+ *       "field": "field2",
+ *       "operator": "some",
+ *       "value": ["value2", "value3"],
+ *       "children": [
+ *         { "ui:row": [...] },
+ *       ],
+ *     }
+ *   },
+ *   {
+ *     "ui:condition": {
+ *       "field": "field2",
+ *       "operator": "none",
+ *       "value": ["value1", "value2", "value3"],
+ *       "children": [
+ *         { "ui:row": [...] },
+ *       ],
+ *     }
+ *   }
+ * ]
+ * ```
+ */
+export default class LayoutGridField<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any> extends PureComponent<LayoutGridFieldProps<T, S, F>> {
+    static defaultProps: {
+        layoutGridSchema: undefined;
+    };
+    static TEST_IDS: import("@rjsf/utils").TestIdShape;
+    /** Computes the uiSchema for the field with `name` from the `uiProps` and `uiSchema` provided. The field UI Schema
+     * will always contain a copy of the global options from the `uiSchema` (so they can be passed down) as well as
+     * copying them into the local ui options. When the `forceReadonly` flag is true, then the field UI Schema is
+     * updated to make "readonly" be true. When the `schemaReadonly` flag is true AND the field UI Schema does NOT have
+     * the flag already provided, then we also make "readonly" true. We always make sure to return the final value of the
+     * field UI Schema's "readonly" flag as `uiReadonly` along with the `fieldUiSchema` in the return value.
+     *
+     * @param field - The name of the field to pull the existing UI Schema for
+     * @param uiProps - Any props that should be put into the field's uiSchema
+     * @param [uiSchema] - The optional UI Schema from which to get the UI schema for the field
+     * @param [schemaReadonly] - Optional flag indicating whether the schema indicates the field is readonly
+     * @param [forceReadonly] - Optional flag indicating whether the Form itself is in readonly mode
+     */
+    static computeFieldUiSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(field: string, uiProps: ConfigObject, uiSchema?: UiSchema<T, S, F>, schemaReadonly?: boolean, forceReadonly?: boolean): {
+        fieldUiSchema: any;
+        uiReadonly: boolean | undefined;
+    };
+    /** Given an `operator`, `datum` and `value` determines whether this condition is considered matching. Matching
+     * depends on the `operator`. The `datum` and `value` are converted into arrays if they aren't already and then the
+     * contents of the two arrays are compared using the `operator`. When `operator` is All, then the two arrays must be
+     * equal to match. When `operator` is SOME then the intersection of the two arrays must have at least one value in
+     * common to match. When `operator` is NONE then the intersection of the two arrays must not have any values in common
+     * to match.
+     *
+     * @param [operator] - The optional operator for the condition
+     * @param [datum] - The optional datum for the condition, this can be an item or a list of items of type unknown
+     * @param [value='$0m3tH1nG Un3xP3cT3d'] The optional value for the condition, defaulting to a highly unlikely value
+     *        to avoid comparing two undefined elements when `value` was forgotten in the condition definition.
+     *        This can be an item or a list of items of type unknown
+     * @returns - True if the condition matches, false otherwise
+     */
+    static conditionMatches(operator?: Operators, datum?: unknown, value?: unknown): boolean;
+    /** From within the `layoutGridSchema` finds the `children` and any extra `gridProps` from the object keyed by
+     * `schemaKey`. If the `children` contains extra `gridProps` and those props contain a `className` string, try to
+     * lookup whether that `className` has a replacement value in the `registry` using the `FORM_CONTEXT_LOOKUP_BASE`.
+     * When the `className` value contains multiple classNames separated by a space, the lookup will look for a
+     * replacement value for each `className` and combine them into one.
+     *
+     * @param layoutGridSchema - The GridSchemaType instance from which to obtain the `schemaKey` children and extra props
+     * @param schemaKey - A `GridType` value, used to get the children and extra props from within the `layoutGridSchema`
+     * @param registry - The `@rjsf` Registry from which to look up `classNames` if they are present in the extra props
+     * @returns - An object containing the list of `LayoutGridSchemaType` `children` and any extra `gridProps`
+     * @throws - A `TypeError` when the `children` is not an array
+     */
+    static findChildrenAndProps<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(layoutGridSchema: GridSchemaType, schemaKey: GridType, registry: Registry<T, S, F>): {
+        children: LayoutGridSchemaType[];
+        gridProps: GridProps;
+    };
+    /** Generates an idSchema for the `schema` using `@rjsf`'s `toIdSchema` util, passing the `baseIdSchema`'s `$id` value
+     * as the id prefix.
+     *
+     * @param schemaUtils - The `SchemaUtilsType` used to call `toIdSchema`
+     * @param schema - The schema to generate the idSchema for
+     * @param baseIdSchema - The IdSchema for the base
+     * @param formData - The formData to pass the `toIdSchema`
+     * @param [idSeparator] - The param to pass into the `toIdSchema` util which will use it to join the `idSchema` paths
+     * @returns - The generated `idSchema` for the `schema`
+     */
+    static getIdSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schemaUtils: SchemaUtilsType<T, S, F>, baseIdSchema: IdSchema<T>, formData: FieldProps['formData'], schema?: S, idSeparator?: string): FieldProps<T, S, F>['idSchema'];
+    /** Given a `dottedPath` to a field in the `initialSchema`, iterate through each individual path in the schema until
+     * the leaf path is found and returned (along with whether that leaf path `isRequired`) OR no schema exists for an
+     * element in the path. If the leaf schema element happens to be a oneOf/anyOf then also return the oneOf/anyOf as
+     * `options`.
+     *
+     * @param schemaUtils - The `SchemaUtilsType` used to call `retrieveSchema`
+     * @param dottedPath - The dotted-path to the field for which to get the schema
+     * @param initialSchema - The initial schema to start the search from
+     * @param formData - The formData, useful for resolving a oneOf/anyOf selection in the path hierarchy
+     * @param initialIdSchema - The initial idSchema to start the search from
+     * @param [idSeparator] - The param to pass into the `toIdSchema` util which will use it to join the `idSchema` paths
+     * @returns - An object containing the destination schema, isRequired and isReadonly flags for the field and options
+     *            info if a oneOf/anyOf
+     */
+    static getSchemaDetailsForField<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(schemaUtils: SchemaUtilsType<T, S, F>, dottedPath: string, initialSchema: S, formData: FieldProps<T, S, F>['formData'], initialIdSchema: IdSchema<T>, idSeparator?: string): {
+        schema?: S;
+        isRequired: boolean;
+        isReadonly?: boolean;
+        optionsInfo?: OneOfOptionsInfoType<S>;
+        idSchema: IdSchema<T>;
+    };
+    /** Gets the custom render component from the `render`, by either determining that it is either already a function or
+     * it is a non-function value that can be used to look up the function in the registry. If no function can be found,
+     * null is returned.
+     *
+     * @param render - The potential render function or lookup name to one
+     * @param registry - The `@rjsf` Registry from which to look up `classNames` if they are present in the extra props
+     * @returns - Either a render function if available, or null if not
+     */
+    static getCustomRenderComponent<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(render: string | RenderComponent, registry: Registry<T, S, F>): RenderComponent | null;
+    /** Extract the `name`, and optional `render` and all other props from the `gridSchema`. We look up the `render` to
+     * see if can be resolved to a UIComponent. If `name` does not exist and there is an optional `render` UIComponent, we
+     * set the `rendered` component with only specified props for that component in the object.
+     *
+     * @param registry - The `@rjsf` Registry from which to look up `classNames` if they are present in the extra props
+     * @param gridSchema - The string or object that represents the configuration for the grid field
+     * @returns - The UIComponentPropsType computed from the gridSchema
+     */
+    static computeUIComponentPropsFromGridSchema<T = any, S extends StrictRJSFSchema = RJSFSchema, F extends FormContextType = any>(registry: Registry<T, S, F>, gridSchema?: string | ConfigObject): UIComponentPropsType;
+    /** Constructs an `LayoutGridField` with the given `props`
+     *
+     * @param props - The `LayoutGridField` for this template
+     */
+    constructor(props: LayoutGridFieldProps<T, S, F>);
+    /** Generates an `onChange` handler for the field associated with the `dottedPath`. This handler will clone and update
+     * the `formData` with the new `value` and the `errorSchema` if an `errSchema` is provided. After updating those two
+     * elements, they will then be passed on to the `onChange` handler of the `LayoutFieldGrid`.
+     *
+     * @param dottedPath - The dotted-path to the field for which to generate the onChange handler
+     * @returns - The `onChange` handling function for the `dottedPath` field
+     */
+    onFieldChange: (dottedPath: string) => (value: unknown, errSchema?: ErrorSchema<T>, id?: string) => void;
+    /** Renders the `children` of the `GridType.CONDITION` if it passes. The `layoutGridSchema` for the
+     * `GridType.CONDITION` is separated into the `children` and other `gridProps`. The `gridProps` are used to extract
+     * the `operator`, `field` and `value` of the condition. If the condition matches, then all of the `children` are
+     * rendered, otherwise null is returned.
+     *
+     * @param layoutGridSchema - The string or object that represents the configuration for the grid field
+     * @returns - The rendered the children for the `GridType.CONDITION` or null
+     */
+    renderCondition(layoutGridSchema: GridSchemaType): import("react/jsx-runtime").JSX.Element[] | null;
+    /** Renders a material-ui `GridTemplate` as an item. The `layoutGridSchema` for the `GridType.COLUMN` is separated
+     * into the `children` and other `gridProps`. The `gridProps` will be spread onto the outer `GridTemplate`. Inside
+     * the `GridTemplate` all the `children` are rendered.
+     *
+     * @param layoutGridSchema - The string or object that represents the configuration for the grid field
+     * @returns - The rendered `GridTemplate` containing the children for the `GridType.COLUMN`
+     */
+    renderCol(layoutGridSchema: GridSchemaType): import("react/jsx-runtime").JSX.Element;
+    /** Renders a material-ui `GridTemplate` as an item. The `layoutGridSchema` for the `GridType.COLUMNS` is separated
+     * into the `children` and other `gridProps`. The `children` is iterated on and `gridProps` will be spread onto the
+     * outer `GridTemplate`. Each child will have their own rendered `GridTemplate`.
+     *
+     * @param layoutGridSchema - The string or object that represents the configuration for the grid field
+     * @returns - The rendered `GridTemplate` containing the children for the `GridType.COLUMNS`
+     */
+    renderColumns(layoutGridSchema: GridSchemaType): import("react/jsx-runtime").JSX.Element[];
+    /** Renders a material-ui `GridTemplate` as a container. The
+     * `layoutGridSchema` for the `GridType.ROW` is separated into the `children` and other `gridProps`. The `gridProps`
+     * will be spread onto the outer `GridTemplate`. Inside of the `GridTemplate` all of the `children` are rendered.
+     *
+     * @param layoutGridSchema - The string or object that represents the configuration for the grid field
+     * @returns - The rendered `GridTemplate` containing the children for the `GridType.ROW`
+     */
+    renderRow(layoutGridSchema: GridSchemaType): import("react/jsx-runtime").JSX.Element;
+    /** Iterates through all the `childrenLayoutGridSchema`, rendering a nested `LayoutGridField` for each item in the
+     * list, passing all the props for the current `LayoutGridField` along, updating the `schema` by calling
+     * `retrieveSchema()` on it to resolve any `$ref`s. In addition to the updated `schema`, each item in
+     * `childrenLayoutGridSchema` is passed as `layoutGridSchema`.
+     *
+     * @param childrenLayoutGridSchema - The list of strings or objects that represents the configurations for the
+     *          children fields
+     * @returns - The nested `LayoutGridField`s
+     */
+    renderChildren(childrenLayoutGridSchema: LayoutGridSchemaType[]): import("react/jsx-runtime").JSX.Element[];
+    /** Renders the field described by `gridSchema`. If `gridSchema` is not an object, then is will be assumed
+     * to be the dotted-path to the field in the schema. Otherwise, we extract the `name`, and optional `render` and all
+     * other props. If `name` does not exist and there is an optional `render`, we return the `render` component with only
+     * specified props for that component. If `name` exists, we take the name, the initial & root schemas and the formData
+     * and get the destination schema, is required state and optional oneOf/anyOf options for it. If the destination
+     * schema was located along with oneOf/anyOf options then a `LayoutMultiSchemaField` will be rendered with the
+     * `uiSchema`, `errorSchema`, `idSchema` and `formData` drilled down to the dotted-path field, spreading any other
+     * props from `gridSchema` into the `ui:options`. If the destination schema located without any oneOf/anyOf options,
+     * then a `SchemaField` will be rendered with the same props as mentioned in the previous sentence. If no destination
+     * schema was located, but a custom render component was found, then it will be rendered with many of the non-event
+     * handling props. If none of the previous render paths are valid, then a null is returned.
+     *
+     * @param gridSchema - The string or object that represents the configuration for the grid field
+     * @returns - One of `LayoutMultiSchemaField`, `SchemaField`, a custom render component or null, depending
+     */
+    renderField(gridSchema?: ConfigObject | string): string | number | true | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | null;
+    /** Renders the `LayoutGridField`. If there isn't a `layoutGridSchema` prop defined, then try pulling it out of the
+     * `uiSchema` via `ui:LayoutGridField`. If `layoutGridSchema` is an object, then check to see if any of the properties
+     * match one of the `GridType`s. If so, call the appropriate render function for the type. Otherwise, just call the
+     * generic `renderField()` function with the `layoutGridSchema`.
+     *
+     * @returns - the rendered `LayoutGridField`
+     */
+    render(): string | number | true | Iterable<ReactNode> | import("react/jsx-runtime").JSX.Element | import("react/jsx-runtime").JSX.Element[] | null;
+}
+export {};
+//# sourceMappingURL=LayoutGridField.d.ts.map

package/lib/components/fields/LayoutGridField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LayoutGridField.d.ts","sourceRoot":"","sources":["../../../src/components/fields/LayoutGridField.tsx"],"names":[],"mappings":"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"}