@nolwenture/formik-jsonschema-form 0.5.0 → 0.7.0

package/dist/templates/FieldTemplate.js

@@ -1,14 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useContext } from "react";
 import { FormRegistry } from "../Form";
-import { useExtractUiSchema, getDescription, getTitle } from "../utils";
-export function FieldTemplate(props) {
+import { getDescription, getTitle } from "../utils";
+import { useExtractUiSchema } from "../hooks";
+export const FieldTemplate = (props) => {
     const { components: { FieldWrapper, FieldTitle, FieldDescription, ErrorMessage, FieldHelp, RequiredIndicator, InfoFieldButton, }, } = useContext(FormRegistry);
     const { name, uiSchema, children } = props;
     const title = getTitle(props);
     const description = getDescription(props);
     const { help, info, 
     //TODO: This is not right
-    props: { wrapper: wrappertProps, title: titleProps, description: descriptionProps, help: helpProps, error: errorProps, } = {}, } = useExtractUiSchema(uiSchema);
-    return (_jsxs(FieldWrapper, Object.assign({}, wrappertProps, { children: [title && (_jsxs(FieldTitle, Object.assign({}, titleProps, { htmlFor: name }, { children: [title, props.required && _jsx(RequiredIndicator, { children: "*" })] }))), info && _jsx(InfoFieldButton, Object.assign({}, info)), description && (_jsx(FieldDescription, Object.assign({}, descriptionProps, { children: description }))), children, help && _jsx(FieldHelp, Object.assign({}, helpProps, { children: help })), _jsx(ErrorMessage, Object.assign({}, errorProps, { name: name }))] })));
-}
+    props: { wrapper: wrapperProps, title: titleProps, description: descriptionProps, help: helpProps, error: errorProps, } = {}, } = useExtractUiSchema(uiSchema);
+    return (_jsxs(FieldWrapper, Object.assign({}, wrapperProps, { children: [title && (_jsxs(FieldTitle, Object.assign({}, titleProps, { htmlFor: name, children: [title, props.required && _jsx(RequiredIndicator, { children: "*" })] }))), info && _jsx(InfoFieldButton, Object.assign({}, info)), description && (_jsx(FieldDescription, Object.assign({}, descriptionProps, { children: description }))), children, help && _jsx(FieldHelp, Object.assign({}, helpProps, { children: help })), _jsx(ErrorMessage, Object.assign({}, errorProps, { name: name }))] })));
+};

package/dist/templates/ObjectFieldTemplate.d.ts

@@ -1,3 +1,3 @@
-/// <reference types="react" />
-import { ObjectFieldTemplateProps } from "../types";
-export declare function ObjectFieldTemplate(props: ObjectFieldTemplateProps): JSX.Element;
+import type { ObjectFieldTemplateProps } from "../types";
+import React from "react";
+export declare const ObjectFieldTemplate: React.FC<ObjectFieldTemplateProps>;

package/dist/templates/ObjectFieldTemplate.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useContext } from "react";
 import { FormRegistry } from "../Form";
-import { getDescription, getTitle, useExtractUiSchema } from "../utils";
+import { getDescription, getTitle } from "../utils";
+import { useExtractUiSchema } from "../hooks";
 import { RequiredIndicator } from "../styledComponents";
-export function ObjectFieldTemplate(props) {
+export const ObjectFieldTemplate = (props) => {
     const { components: { FieldDescription, ObjectFieldTitle, ObjectFieldWrapper, FieldHelp, InfoFieldButton, }, } = useContext(FormRegistry);
     const { children, uiSchema } = props;
     const title = getTitle(props);
@@ -14,4 +15,4 @@ export function ObjectFieldTemplate(props) {
     // error: errorProps,
      } = {}, } = useExtractUiSchema(uiSchema);
     return (_jsxs(ObjectFieldWrapper, Object.assign({}, wrapperProps, { children: [title && (_jsxs(ObjectFieldTitle, Object.assign({}, titleProps, { children: [title, (props === null || props === void 0 ? void 0 : props.required) && _jsx(RequiredIndicator, { children: "*" })] }))), info && _jsx(InfoFieldButton, Object.assign({}, info)), description && (_jsx(FieldDescription, Object.assign({}, descriptionProps, { children: description }))), children, help && _jsx(FieldHelp, Object.assign({}, helpProps, { children: help }))] })));
-}
+};

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import * as React from "react";
-import { JSONSchema7 } from "json-schema";
+import type { JSONSchema7 } from "json-schema";
+import React from "react";
 export type FormProps<T> = React.PropsWithChildren<{
     /** If true, disabled prop is passed down to each field on the form */
     disabled?: boolean | undefined;

package/dist/utils/__tests/getEnums.test.d.ts

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

package/dist/utils/__tests/getEnums.test.js

@@ -0,0 +1,64 @@
+import { getEnums } from "../getEnums";
+describe("getEnums", () => {
+    test("enum works", () => {
+        const result = getEnums({ schema: { enum: ["one", "two", "three"] } });
+        expect(result).toEqual({
+            type: "select",
+            values: [
+                { const: "one", title: "one" },
+                { const: "two", title: "two" },
+                { const: "three", title: "three" },
+            ],
+        });
+    });
+    test("oneOf works", () => {
+        const result = getEnums({
+            schema: {
+                oneOf: [
+                    {
+                        const: "horse",
+                        title: "Horse",
+                    },
+                    { const: "frog", title: "Frog" },
+                    { const: "bird", title: "Bird" },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            type: "select",
+            values: [
+                {
+                    const: "horse",
+                    title: "Horse",
+                },
+                { const: "frog", title: "Frog" },
+                { const: "bird", title: "Bird" },
+            ],
+        });
+    });
+    test("anyOf works", () => {
+        const result = getEnums({
+            schema: {
+                anyOf: [
+                    {
+                        const: "tangerine",
+                        title: "Tangerine",
+                    },
+                    { const: "mandarin", title: "Mandarin" },
+                    { const: "bruno", title: "Bruno" },
+                ],
+            },
+        });
+        expect(result).toEqual({
+            type: "multiSelect",
+            values: [
+                {
+                    const: "tangerine",
+                    title: "Tangerine",
+                },
+                { const: "mandarin", title: "Mandarin" },
+                { const: "bruno", title: "Bruno" },
+            ],
+        });
+    });
+});

package/dist/utils/__tests/resolveSchema.test.d.ts

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

package/dist/utils/__tests/resolveSchema.test.js

@@ -0,0 +1,106 @@
+import { resolveSchema } from "../resolveSchema";
+const simpleConditionalSchema = {
+    type: "object",
+    title: "Title",
+    properties: {
+        animal: {
+            type: "string",
+            enum: ["cat", "bird"],
+        },
+    },
+    allOf: [
+        {
+            if: {
+                properties: {
+                    animal: {
+                        const: "cat",
+                    },
+                },
+            },
+            then: {
+                properties: {
+                    food: {
+                        type: "string",
+                        enum: ["meat", "grass", "fish"],
+                    },
+                },
+                required: ["food"],
+            },
+        },
+    ],
+};
+describe("resolveSchema", () => {
+    test("with matching if value", () => {
+        const value = { animal: "cat" };
+        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
+        expect(resolvedSchema).toEqual([
+            {
+                type: "object",
+                title: "Title",
+                properties: {
+                    animal: {
+                        type: "string",
+                        enum: ["cat", "bird"],
+                    },
+                    food: {
+                        type: "string",
+                        enum: ["meat", "grass", "fish"],
+                    },
+                },
+                required: ["food"],
+            },
+            [],
+        ]);
+    });
+    test("with non-matching if value", () => {
+        const value = { animal: "bird" };
+        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
+        expect(resolvedSchema).toEqual([
+            {
+                type: "object",
+                title: "Title",
+                properties: {
+                    animal: {
+                        type: "string",
+                        enum: ["cat", "bird"],
+                    },
+                },
+            },
+            [],
+        ]);
+    });
+    test("with empty values", () => {
+        const value = {};
+        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
+        expect(resolvedSchema).toEqual([
+            {
+                type: "object",
+                title: "Title",
+                properties: {
+                    animal: {
+                        type: "string",
+                        enum: ["cat", "bird"],
+                    },
+                },
+            },
+            [],
+        ]);
+    });
+    test("with value changed", () => {
+        const value = { animal: "bird", food: "meat" };
+        const resolvedSchema = resolveSchema(simpleConditionalSchema, value);
+        expect(resolvedSchema).toEqual([
+            {
+                type: "object",
+                title: "Title",
+                properties: {
+                    animal: {
+                        type: "string",
+                        enum: ["cat", "bird"],
+                    },
+                },
+            },
+            ["food"],
+        ]);
+    });
+});

package/dist/utils/deepOverlap.d.ts

@@ -0,0 +1 @@
+export declare const deepOverlap: (object1: any, object2: any) => boolean;

package/dist/utils/deepOverlap.js

@@ -0,0 +1,14 @@
+import { isObject } from "./getTypes";
+export const deepOverlap = (object1, object2) => {
+    const keys1 = Object.keys(object1);
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = isObject(val1) && isObject(val2);
+        if ((areObjects && !deepOverlap(val1, val2)) ||
+            (!areObjects && val1 !== val2)) {
+            return false;
+        }
+    }
+    return true;
+};

package/dist/utils/getEnums.d.ts

@@ -0,0 +1,10 @@
+import type { FieldProps } from "../types";
+export declare const getEnums: ({ schema }: {
+    schema: FieldProps["schema"];
+}) => {
+    type: string;
+    values: {
+        const: any;
+        title: string;
+    }[];
+} | undefined;

package/dist/utils/getEnums.js

@@ -0,0 +1,30 @@
+export const getEnums = ({ schema }) => {
+    const numberOfDefined = [schema.enum, schema.oneOf, schema.anyOf].filter((x) => x).length;
+    if (numberOfDefined === 0) {
+        return;
+    }
+    if (numberOfDefined > 1) {
+        throw new Error('Only one of "enum", "oneOf" or "anyOf" can be defined!');
+    }
+    if (schema.enum) {
+        return {
+            type: "select",
+            values: schema.enum.map((option) => ({
+                const: option,
+                title: `${option}`,
+            })),
+        };
+    }
+    if (schema.oneOf) {
+        return {
+            type: "select",
+            values: schema.oneOf,
+        };
+    }
+    if (schema.anyOf) {
+        return {
+            type: "multiSelect",
+            values: schema.anyOf,
+        };
+    }
+};

package/dist/utils/getTitleAndDescription.d.ts

@@ -0,0 +1,12 @@
+import type { Schema, UiSchema } from "../types";
+export declare const getTitle: ({ title, uiSchema, schema, name, }: {
+    title?: string | undefined;
+    uiSchema?: UiSchema | undefined;
+    schema?: import("json-schema").JSONSchema7 | undefined;
+    name?: string | undefined;
+}) => any;
+export declare const getDescription: ({ description, uiSchema, schema, }: {
+    description?: string | undefined;
+    uiSchema?: UiSchema | undefined;
+    schema?: import("json-schema").JSONSchema7 | undefined;
+}) => any;

package/dist/utils/getTitleAndDescription.js

@@ -0,0 +1,15 @@
+export const getTitle = ({ title, uiSchema, schema, name, }) => {
+    var _a;
+    return (title ||
+        ((_a = uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:options"]) === null || _a === void 0 ? void 0 : _a.title) ||
+        (uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:title"]) ||
+        (schema === null || schema === void 0 ? void 0 : schema.title) ||
+        (name === null || name === void 0 ? void 0 : name.split(".")[(name === null || name === void 0 ? void 0 : name.split(".").length) - 1]));
+};
+export const getDescription = ({ description, uiSchema, schema, }) => {
+    var _a;
+    return (description ||
+        ((_a = uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:options"]) === null || _a === void 0 ? void 0 : _a.description) ||
+        (uiSchema === null || uiSchema === void 0 ? void 0 : uiSchema["ui:description"]) ||
+        (schema === null || schema === void 0 ? void 0 : schema.description));
+};

package/dist/utils/getTypes.d.ts

@@ -0,0 +1,5 @@
+import type { Schema } from "../types";
+export declare const isObject: (object: any) => boolean;
+export declare const getDefaultValueForType: (type: Schema["type"]) => {} | null;
+export declare const guessType: (value: any) => "string" | "number" | "boolean" | "object" | "array" | "null";
+export declare const getSchemaType: (schema: Schema) => import("json-schema").JSONSchema7TypeName | import("json-schema").JSONSchema7TypeName[] | undefined;

package/dist/utils/getTypes.js

@@ -0,0 +1,53 @@
+export const isObject = (object) => {
+    return object != null && typeof object === "object";
+};
+export const getDefaultValueForType = (type) => {
+    if (type && !Array.isArray(type)) {
+        if (type === "array")
+            return [];
+        if (type === "object")
+            return {};
+    }
+    return null;
+};
+export const guessType = (value) => {
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    else if (typeof value === "string") {
+        return "string";
+    }
+    else if (value == null) {
+        return "null";
+    }
+    else if (typeof value === "boolean") {
+        return "boolean";
+    }
+    else if (!isNaN(value)) {
+        return "number";
+    }
+    else if (typeof value === "object") {
+        return "object";
+    }
+    // Default to string if we can't figure it out
+    return "string";
+};
+export const getSchemaType = (schema) => {
+    if (!schema) {
+        return undefined;
+    }
+    let { type } = schema;
+    if (!type && schema.const) {
+        return guessType(schema.const);
+    }
+    if (!type && schema.enum) {
+        return "string";
+    }
+    if (!type && (schema.properties || schema.additionalProperties)) {
+        return "object";
+    }
+    if (type instanceof Array && type.length === 2 && type.includes("null")) {
+        return type.find((type) => type !== "null");
+    }
+    return type;
+};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./deepOverlap";
+export * from "./getEnums";
+export * from "./getTitleAndDescription";
+export * from "./getTypes";
+export * from "./mergeSchemas";
+export * from "./resolveSchema";
+export declare const warnFromUnsupportedKeys: (componentName: string, data: Record<string, any>, supportedKeys: string[]) => void;

package/dist/utils/index.js

@@ -0,0 +1,14 @@
+export * from "./deepOverlap";
+export * from "./getEnums";
+export * from "./getTitleAndDescription";
+export * from "./getTypes";
+export * from "./mergeSchemas";
+export * from "./resolveSchema";
+//TODO: REMOVE WHEN ALL SUPPORTED
+export const warnFromUnsupportedKeys = (componentName, data, supportedKeys) => {
+    Object.keys(data).forEach((key) => {
+        if (!supportedKeys.includes(key)) {
+            console.warn(`Component "${componentName}" does not support (yet) key "${key}"`);
+        }
+    });
+};

package/dist/utils/mergeSchemas.d.ts

@@ -0,0 +1 @@
+export declare const mergeSchemas: (obj1: any, obj2: any) => any;

package/dist/utils/mergeSchemas.js

@@ -0,0 +1,26 @@
+import { getSchemaType } from "./getTypes";
+export const mergeSchemas = (obj1, obj2) => {
+    const acc = Object.assign({}, obj1); // Prevent mutation of source object.
+    return Object.keys(obj2).reduce((acc, key) => {
+        const left = obj1 ? obj1[key] : {}, right = obj2[key];
+        if (obj1 &&
+            key in obj1 &&
+            typeof right === "object" &&
+            !Array.isArray(right)) {
+            acc[key] = mergeSchemas(left, right);
+        }
+        else if (obj1 &&
+            obj2 &&
+            (getSchemaType(obj1) === "object" || getSchemaType(obj2) === "object") &&
+            key === "required" &&
+            Array.isArray(left) &&
+            Array.isArray(right)) {
+            // Don't include duplicate values when merging 'required' fields.
+            acc[key] = [...new Set([...left, ...right])];
+        }
+        else {
+            acc[key] = right;
+        }
+        return acc;
+    }, acc);
+};

package/dist/utils/resolveSchema.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from "../types";
+export declare const resolveSchema: ({ allOf, ...schema }: Schema, value: Record<string, any>) => [Schema, string[]];

package/dist/utils/resolveSchema.js

@@ -0,0 +1,68 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { deepOverlap } from "./deepOverlap";
+import { mergeSchemas } from "./mergeSchemas";
+const resolveEquality = (value, expression) => {
+    const keyOfValue = Object.keys(value);
+    const valueOfValue = Object.values(value);
+    const newObject = {
+        properties: keyOfValue.reduce((properties, key, index) => (Object.assign(Object.assign({}, properties), { [key]: { const: valueOfValue[index] } })), {}),
+    };
+    return deepOverlap(expression, newObject);
+};
+export const resolveSchema = (_a, value) => {
+    var _b;
+    var { allOf } = _a, schema = __rest(_a, ["allOf"]);
+    if (!allOf) {
+        return [schema, []];
+    }
+    const { resolvedSchema, notAddedProperties } = allOf.reduce(({ resolvedSchema, notAddedProperties }, current) => {
+        var _a, _b;
+        if (!current || typeof current === "boolean") {
+            return { resolvedSchema, notAddedProperties };
+        }
+        const { if: expression, then, else: otherwise } = current, resolvedSchemaLessConditional = __rest(current, ["if", "then", "else"]);
+        if (!expression || typeof expression === "boolean") {
+            return {
+                resolvedSchema: mergeSchemas(resolvedSchema, resolvedSchemaLessConditional),
+                notAddedProperties,
+            };
+        }
+        if (resolveEquality(value, expression)) {
+            if (then && typeof then !== "boolean") {
+                resolvedSchema = mergeSchemas(resolvedSchema, then);
+            }
+            if (otherwise && typeof otherwise !== "boolean") {
+                notAddedProperties = [
+                    ...notAddedProperties,
+                    ...Object.keys((_a = otherwise.properties) !== null && _a !== void 0 ? _a : {}),
+                ];
+            }
+        }
+        else {
+            if (then && typeof then !== "boolean") {
+                notAddedProperties = [
+                    ...notAddedProperties,
+                    ...Object.keys((_b = then.properties) !== null && _b !== void 0 ? _b : {}),
+                ];
+            }
+            if (otherwise && typeof otherwise !== "boolean") {
+                resolvedSchema = mergeSchemas(resolvedSchema, otherwise);
+            }
+        }
+        return { resolvedSchema, notAddedProperties };
+    }, { resolvedSchema: schema, notAddedProperties: [] });
+    //Values that do not exists due to conditions
+    const usedProperties = Object.keys((_b = resolvedSchema.properties) !== null && _b !== void 0 ? _b : {});
+    const valuesToRemove = [...new Set([...notAddedProperties])].filter((key) => !usedProperties.includes(key) && typeof value[key] !== "undefined");
+    return [resolvedSchema, valuesToRemove];
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nolwenture/formik-jsonschema-form",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Formik form generation from json schema",
   "author": "Antti Vikman <antti.vikman@nolwenture.com>",
   "contributors": [
@@ -27,32 +27,41 @@
     "package.json",
     "LICENSE"
   ],
+  "scripts": {
+    "build": "tsc --build",
+    "clean": "tsc --build --clean",
+    "test": "jest",
+    "storybook": "storybook dev -p 6006"
+  },
   "dependencies": {
-    "@testing-library/jest-dom": "^5.16.4",
-    "@testing-library/react": "^13.3.0",
-    "@testing-library/user-event": "^13.5.0",
-    "@types/jest": "^27.5.2",
-    "@types/node": "^16.11.45",
-    "@types/react": "^18.0.15",
-    "@types/react-dom": "^18.0.6",
-    "@types/styled-components": "^5.1.25",
-    "formik": "^2.2.9",
+    "formik": "^2.4.5",
     "json-schema": "^0.4.0",
     "react": "^18.2.0",
-    "react-dom": "^18.2.0",
-    "react-scripts": "5.0.1",
-    "styled-components": "^5.3.5",
-    "typescript": "^4.7.4",
-    "web-vitals": "^2.1.4"
+    "styled-components": "^6.1.8",
+    "typescript": "^5.4.3"
   },
-  "scripts": {
-    "start": "react-scripts start",
-    "build": "tsc --build",
-    "clean": "tsc --build --clean",
-    "test": "react-scripts test",
-    "eject": "react-scripts eject",
-    "storybook": "start-storybook -p 6006",
-    "build-storybook": "build-storybook"
+  "devDependencies": {
+    "@babel/preset-react": "^7.24.1",
+    "@babel/preset-typescript": "^7.24.1",
+    "@storybook/addon-essentials": "^8.0.5",
+    "@storybook/addon-interactions": "^8.0.5",
+    "@storybook/addon-links": "^8.0.5",
+    "@storybook/addon-webpack5-compiler-babel": "^3.0.3",
+    "@storybook/react": "^8.0.5",
+    "@storybook/react-webpack5": "^8.0.5",
+    "@storybook/test": "^8.0.5",
+    "@testing-library/jest-dom": "^6.4.2",
+    "@testing-library/react": "^14.2.2",
+    "@testing-library/user-event": "^14.5.2",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^20.12.2",
+    "@types/react": "^18.2.73",
+    "@types/styled-components": "^5.1.34",
+    "babel-plugin-named-exports-order": "^0.0.2",
+    "jest": "^29.7.0",
+    "storybook": "^8.0.5",
+    "ts-jest": "^29.1.2",
+    "webpack": "^5.91.0"
   },
   "eslintConfig": {
     "extends": [
@@ -81,19 +90,5 @@
       "last 1 firefox version",
       "last 1 safari version"
     ]
-  },
-  "devDependencies": {
-    "@storybook/addon-essentials": "^6.5.15",
-    "@storybook/addon-interactions": "^6.5.15",
-    "@storybook/addon-links": "^6.5.15",
-    "@storybook/builder-webpack5": "^6.5.15",
-    "@storybook/manager-webpack5": "^6.5.15",
-    "@storybook/node-logger": "^6.5.15",
-    "@storybook/preset-create-react-app": "^4.1.2",
-    "@storybook/react": "^6.5.15",
-    "@storybook/testing-library": "^0.0.13",
-    "babel-plugin-named-exports-order": "^0.0.2",
-    "prop-types": "^15.8.1",
-    "webpack": "^5.73.0"
   }
 }

package/dist/_sampleData.d.ts

@@ -1,12 +0,0 @@
-import { Schema, UiSchema } from "./types";
-export type SimpleFormDataType = {
-    firstName: string;
-    lastName: string;
-};
-export declare const simpleSchema: Schema;
-export declare const simpleUiSchema: UiSchema;
-export declare const completeSchema: Schema;
-export declare const completeUiSchema: UiSchema;
-export declare const generatedSchema: Schema;
-export declare const requiredInputSchema: Schema;
-export declare const requiredInputUiSchema: UiSchema;

package/dist/utils.d.ts

@@ -1,32 +0,0 @@
-import { FieldProps, Schema, UiSchema } from "./types";
-import { JSONSchema7 } from "json-schema";
-export declare function getTitle({ title, uiSchema, schema, name, }: {
-    title?: string;
-    uiSchema?: UiSchema;
-    schema?: Schema;
-    name?: string;
-}): any;
-export declare function getDescription({ description, uiSchema, schema, }: {
-    description?: string;
-    uiSchema?: UiSchema;
-    schema?: Schema;
-}): any;
-export declare function getEnums({ schema }: FieldProps): {
-    type: string;
-    values: {
-        const: any;
-        title: string;
-    }[];
-} | undefined;
-export declare function getDefaultValueForType(type: JSONSchema7["type"]): {} | null;
-export declare function useSetDefault(props: FieldProps): void;
-export declare function useExtractUiSchema(props?: UiSchema | undefined): {
-    [name: string]: any;
-    field?: UiSchema["ui:field"];
-    props?: UiSchema["ui:props"];
-    help?: UiSchema["ui:help"];
-    info?: UiSchema["ui:info"];
-};
-export declare const guessType: (value: any) => "string" | "number" | "boolean" | "object" | "array" | "null";
-export declare function getSchemaType(schema: Schema): import("json-schema").JSONSchema7TypeName | import("json-schema").JSONSchema7TypeName[] | undefined;
-export declare function warnFromUnsupportedKeys(componentName: string, data: Record<string, any>, supportedKeys: string[]): void;