@nolwenture/formik-jsonschema-form 0.4.2 → 0.6.0

package/dist/templates/FieldTemplate.js

@@ -1,27 +1,15 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
-    var _a = useContext(FormRegistry).components, FieldWrapper = _a.FieldWrapper, FieldTitle = _a.FieldTitle, FieldDescription = _a.FieldDescription, ErrorMessage = _a.ErrorMessage, FieldHelp = _a.FieldHelp, RequiredIndicator = _a.RequiredIndicator, InfoFieldButton = _a.InfoFieldButton;
-    var name = props.name, uiSchema = props.uiSchema, children = props.children;
-    var title = getTitle(props);
-    var description = getDescription(props);
-    var _b = useExtractUiSchema(uiSchema), help = _b.help, info = _b.info, 
-    //TODO: This is not right
-    _c = _b.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
-    _d = _c === void 0 ? {} : _c, wrappertProps = _d.wrapper, titleProps = _d.title, descriptionProps = _d.description, helpProps = _d.help, errorProps = _d.error;
-    return (_jsxs(FieldWrapper, __assign({}, wrappertProps, { children: [title && (_jsxs(FieldTitle, __assign({}, titleProps, { htmlFor: name }, { children: [title, props.required && _jsx(RequiredIndicator, { children: "*" })] }))), info && _jsx(InfoFieldButton, __assign({}, info)), description && (_jsx(FieldDescription, __assign({}, descriptionProps, { children: description }))), children, help && _jsx(FieldHelp, __assign({}, helpProps, { children: help })), _jsx(ErrorMessage, __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,28 +1,18 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 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) {
-    var _a = useContext(FormRegistry).components, FieldDescription = _a.FieldDescription, ObjectFieldTitle = _a.ObjectFieldTitle, ObjectFieldWrapper = _a.ObjectFieldWrapper, FieldHelp = _a.FieldHelp, InfoFieldButton = _a.InfoFieldButton;
-    var children = props.children, uiSchema = props.uiSchema;
-    var title = getTitle(props);
-    var description = getDescription(props);
-    var _b = useExtractUiSchema(uiSchema), help = _b.help, info = _b.info, 
-    //TODO: This is not right
-    _c = _b.props, 
+export const ObjectFieldTemplate = (props) => {
+    const { components: { FieldDescription, ObjectFieldTitle, ObjectFieldWrapper, FieldHelp, InfoFieldButton, }, } = useContext(FormRegistry);
+    const { children, uiSchema } = props;
+    const title = getTitle(props);
+    const description = getDescription(props);
+    const { help, info, 
     //TODO: This is not right
-    _d = _c === void 0 ? {} : _c, wrapperProps = _d.wrapper, titleProps = _d.title, descriptionProps = _d.description, helpProps = _d.help;
-    return (_jsxs(ObjectFieldWrapper, __assign({}, wrapperProps, { children: [title && (_jsxs(ObjectFieldTitle, __assign({}, titleProps, { children: [title, (props === null || props === void 0 ? void 0 : props.required) && _jsx(RequiredIndicator, { children: "*" })] }))), info && _jsx(InfoFieldButton, __assign({}, info)), description && (_jsx(FieldDescription, __assign({}, descriptionProps, { children: description }))), children, help && _jsx(FieldHelp, __assign({}, helpProps, { children: help }))] })));
-}
+    props: { wrapper: wrapperProps, title: titleProps, description: descriptionProps, help: helpProps,
+    // 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;
@@ -37,6 +37,11 @@ export type UiSchema = {
     };
     "ui:help"?: React.ReactNode | React.ReactNode[];
     "ui:info"?: InfoFieldButtonProps;
+    "ui:placeholderOptionOptions"?: {
+        props: {
+            [key: string]: any;
+        };
+    };
     [name: string]: any;
 };
 export type FormRegistryContextValue = {
@@ -121,6 +126,9 @@ export type ComponentsType = {
     ErrorMessage: React.FunctionComponent<any>;
     FieldInput: React.FunctionComponent<any>;
     RequiredIndicator: React.FunctionComponent<any>;
+    RadioButtonField: React.FunctionComponent<any>;
+    ToggleSwitchField: React.FunctionComponent<any>;
+    SearchableMultiTagSelectField: React.FunctionComponent<any>;
 };
 export declare enum ObjectFieldButtonPurpose {
     ADD = 0,
@@ -147,10 +155,33 @@ export type ArrayFieldButtonProps = {
 export type InfoFieldButtonProps = {
     label?: React.ReactNode;
     content: React.ReactNode;
-    position?: 'top' | 'right' | 'bottom' | 'left';
+    position?: "top" | "right" | "bottom" | "left";
     className?: string;
     props: any;
 };
+type RadioButtonLabelObject = {
+    true?: string;
+    false?: string;
+};
+export type RadioButtonFieldProps = {
+    label?: RadioButtonLabelObject;
+    inputProps?: any;
+    name?: React.ReactNode;
+    className?: string;
+};
+export type ToggleSwitchFieldProps = {
+    inputProps: any;
+    name: React.ReactNode;
+    className?: string;
+};
+export type SelectFieldProps = {
+    name: string;
+    enums: any;
+    emptySearchMessage?: string;
+    placeholder?: string;
+    closeElement?: React.ReactNode;
+    className?: string;
+};
 /*** ***/
 export type AjvError = {
     message: string;

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/deepEqual.d.ts

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

package/dist/utils/deepEqual.js

@@ -0,0 +1,18 @@
+import { isObject } from "./getTypes";
+export const deepEqual = (object1, object2) => {
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
+    if (keys1.length !== keys2.length) {
+        return false;
+    }
+    for (const key of keys1) {
+        const val1 = object1[key];
+        const val2 = object2[key];
+        const areObjects = isObject(val1) && isObject(val2);
+        if ((areObjects && !deepEqual(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 "./deepEqual";
+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 "./deepEqual";
+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 { deepEqual } from "./deepEqual";
+import { mergeSchemas } from "./mergeSchemas";
+const resolveEquality = (value, expression) => {
+    const keyOfValue = Object.keys(value);
+    const valueOfValue = Object.values(value);
+    const newObject = {
+        properties: { [keyOfValue[0]]: { const: valueOfValue[0] } },
+    };
+    return deepEqual(newObject, expression);
+};
+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];
+};