@rjsf/utils 5.0.0-beta.1 → 5.0.0-beta.5

package/dist/schema/retrieveSchema.d.ts

@@ -1,98 +0,0 @@
-import { GenericObjectType, RJSFSchema, RJSFSchemaDefinition, ValidatorType } from "../types";
-/** Resolves a conditional block (if/else/then) by removing the condition and merging the appropriate conditional branch
- * with the rest of the schema
- *
- * @param validator - An implementation of the `ValidatorType` interface that is used to detect valid schema conditions
- * @param schema - The schema for which resolving a condition is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param formData - The current formData to assist retrieving a schema
- * @returns - A schema with the appropriate condition resolved
- */
-export declare function resolveCondition<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData: T): import("json-schema").JSONSchema7;
-/** Resolves references and dependencies within a schema and its 'allOf' children.
- * Called internally by retrieveSchema.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a schema is desired
- * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema having its references and dependencies resolved
- */
-export declare function resolveSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema, formData?: T): RJSFSchema;
-/** Resolves references within a schema and its 'allOf' children.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a reference is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema having its references resolved
- */
-export declare function resolveReference<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
-/** Creates new 'properties' items for each key in the `formData`
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param theSchema - The schema for which the existing additional properties is desired
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s * @param validator
- * @param [aFormData] - The current formData, if any, to assist retrieving a schema
- * @returns - The updated schema with additional properties stubbed
- */
-export declare function stubExistingAdditionalProperties<T = any>(validator: ValidatorType, theSchema: RJSFSchema, rootSchema?: RJSFSchema, aFormData?: T): RJSFSchema;
-/** Retrieves an expanded schema that has had all of its conditions, additional properties, references and dependencies
- * resolved and merged into the `schema` given a `validator`, `rootSchema` and `rawFormData` that is used to do the
- * potentially recursive resolution.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which retrieving a schema is desired
- * @param [rootSchema={}] - The root schema that will be forwarded to all the APIs
- * @param [rawFormData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema having its conditions, additional properties, references and dependencies resolved
- */
-export default function retrieveSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema?: RJSFSchema, rawFormData?: T): RJSFSchema;
-/** Resolves dependencies within a schema and its 'allOf' children.
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a dependency is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema with its dependencies resolved
- */
-export declare function resolveDependencies<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
-/** Processes all the `dependencies` recursively into the `resolvedSchema` as needed
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param dependencies - The set of dependencies that needs to be processed
- * @param resolvedSchema - The schema for which processing dependencies is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The schema with the `dependencies` resolved into it
- */
-export declare function processDependencies<T = any>(validator: ValidatorType, dependencies: RJSFSchema["dependencies"], resolvedSchema: RJSFSchema, rootSchema: RJSFSchema, formData?: T): RJSFSchema;
-/** Updates a schema with additionally required properties added
- *
- * @param schema - The schema for which resolving a dependent properties is desired
- * @param [additionallyRequired] - An optional array of additionally required names
- * @returns - The schema with the additional required values merged in
- */
-export declare function withDependentProperties(schema: RJSFSchema, additionallyRequired?: string[]): import("json-schema").JSONSchema7;
-/** Merges a dependent schema into the `schema` dealing with oneOfs and references
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be forwarded to all the APIs
- * @param schema - The schema for which resolving a dependent schema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param dependencyKey - The key name of the dependency
- * @param dependencyValue - The potentially dependent schema
- * @param formData- The current formData to assist retrieving a schema
- * @returns - The schema with the dependent schema resolved into it
- */
-export declare function withDependentSchema<T>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, dependencyKey: string, dependencyValue: RJSFSchema, formData?: T): GenericObjectType;
-/** Returns a `schema` with the best choice from the `oneOf` options merged into it
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used to validate oneOf options
- * @param schema - The schema for which resolving a oneOf subschema is desired
- * @param rootSchema - The root schema that will be forwarded to all the APIs
- * @param dependencyKey - The key name of the oneOf dependency
- * @param oneOf - The list of schemas representing the oneOf options
- * @param [formData] - The current formData to assist retrieving a schema
- * @returns  The schema with best choice of oneOf schemas merged into
- */
-export declare function withExactlyOneSubschema<T = any>(validator: ValidatorType, schema: RJSFSchema, rootSchema: RJSFSchema, dependencyKey: string, oneOf: RJSFSchemaDefinition[], formData?: T): GenericObjectType;

package/dist/schema/toIdSchema.d.ts

@@ -1,13 +0,0 @@
-import { IdSchema, RJSFSchema, ValidatorType } from "../types";
-/** Generates an `IdSchema` object for the `schema`, recursively
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `IdSchema` is desired
- * @param [id] - The base id for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @param [idPrefix='root'] - The prefix to use for the id
- * @param [idSeparator='_'] - The separator to use for the path segments in the id
- * @returns - The `IdSchema` object for the `schema`
- */
-export default function toIdSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, id?: string | null, rootSchema?: RJSFSchema, formData?: T, idPrefix?: string, idSeparator?: string): IdSchema<T>;

package/dist/schema/toPathSchema.d.ts

@@ -1,11 +0,0 @@
-import { PathSchema, RJSFSchema, ValidatorType } from "../types";
-/** Generates an `PathSchema` object for the `schema`, recursively
- *
- * @param validator - An implementation of the `ValidatorType` interface that will be used when necessary
- * @param schema - The schema for which the `PathSchema` is desired
- * @param [name=''] - The base name for the schema
- * @param [rootSchema] - The root schema, used to primarily to look up `$ref`s
- * @param [formData] - The current formData, if any, to assist retrieving a schema
- * @returns - The `PathSchema` object for the `schema`
- */
-export default function toPathSchema<T = any>(validator: ValidatorType, schema: RJSFSchema, name?: string, rootSchema?: RJSFSchema, formData?: T): PathSchema<T>;

package/dist/schemaRequiresTrueValue.d.ts

@@ -1,11 +0,0 @@
-import { RJSFSchema } from "./types";
-/** Check to see if a `schema` specifies that a value must be true. This happens when:
- * - `schema.const` is truthy
- * - `schema.enum` == `[true]`
- * - `schema.anyOf` or `schema.oneOf` has a single value which recursively returns true
- * - `schema.allOf` has at least one value which recursively returns true
- *
- * @param schema - The schema to check
- * @returns - True if the schema specifies a value that must be true, false otherwise
- */
-export default function schemaRequiresTrueValue(schema: RJSFSchema): boolean;

package/dist/shouldRender.d.ts

@@ -1,10 +0,0 @@
-import React from "react";
-/** Determines whether the given `component` should be rerendered by comparing its current set of props and state
- * against the next set. If either of those two sets are not the same, then the component should be rerendered.
- *
- * @param component - A React component being checked
- * @param nextProps - The next set of props against which to check
- * @param nextState - The next set of state against which to check
- * @returns - True if the component should be re-rendered, false otherwise
- */
-export default function shouldRender(component: React.Component, nextProps: any, nextState: any): boolean;

package/dist/toConstant.d.ts

@@ -1,9 +0,0 @@
-import { RJSFSchema } from "./types";
-/** Returns the constant value from the schema when it is either a single value enum or has a const key. Otherwise
- * throws an error.
- *
- * @param schema - The schema from which to obtain the constant value
- * @returns - The constant value for the schema
- * @throws - Error when the schema does not have a constant value
- */
-export default function toConstant(schema: RJSFSchema): import("json-schema").JSONSchema7Type | undefined;

package/dist/toDateString.d.ts

@@ -1,9 +0,0 @@
-import { DateObject } from "./types";
-/** Returns a UTC date string for the given `dateObject`. If `time` is false, then the time portion of the string is
- * removed.
- *
- * @param dateObject - The `DateObject` to convert to a date string
- * @param [time=true] - Optional flag used to remove the time portion of the date string if false
- * @returns - The UTC date string
- */
-export default function toDateString(dateObject: DateObject, time?: boolean): string;