@nolwenture/formik-jsonschema-form 2.0.2 → 3.0.0-beta.1

package/dist/esm/FormView/templates/ObjectFieldTemplate/ObjectFieldTemplate.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useContext, useMemo } from "react";
-import { extractUiSchema, getDescription, getTitle } from "../../../utils";
-import { FormViewRegistry } from "../../FormViewRegistry";
-import { getComponents } from "./styledComponents";
-export const ObjectFieldTemplate = (props) => {
-    const { components } = useContext(FormViewRegistry);
-    const { Wrapper, Title, Description } = getComponents(components);
-    const { children, uiSchema, ...otherProps } = props;
-    const title = getTitle(props);
-    const description = getDescription(props);
-    const { help, info, 
-    //TODO: This is not right
-    props: { wrapper: wrapperProps, title: titleProps, description: descriptionProps, help: helpProps, } = {}, } = useMemo(() => extractUiSchema(uiSchema), [uiSchema]);
-    const dataAttributes = Object.keys(otherProps)
-        .filter((key) => key.startsWith("data-"))
-        .reduce((acc, key) => {
-        acc[key] = otherProps[key];
-        return acc;
-    }, {});
-    const mergedWrapperProps = {
-        ...wrapperProps,
-        ...dataAttributes,
-    };
-    return (_jsxs(Wrapper, { ...mergedWrapperProps, children: [title && _jsx(Title, { ...titleProps, children: title }), description && (_jsx(Description, { ...descriptionProps, children: description })), children] }));
-};

package/dist/esm/FormView/templates/ObjectFieldTemplate/index.js

@@ -1,2 +0,0 @@
-export * as components from "./styledComponents";
-export * as templates from "./ObjectFieldTemplate";

package/dist/esm/FormView/templates/ObjectFieldTemplate/styledComponents.js

@@ -1,58 +0,0 @@
-import styled from "styled-components";
-export const ObjectFieldTemplateWrapper = styled.div `
-  display: flex;
-  flex-direction: column;
-  gap: ${(props) => props.theme.spacing.l};
-
-  &[data-fjsf-level="1"],
-  &[data-fjsf-level="2"] {
-    @media print {
-      display: block;
-      break-inside: auto;
-      page-break-inside: auto;
-
-      & > div {
-        margin-bottom: 1rem;
-      }
-
-      & > div:last-child {
-        margin-bottom: 0;
-      }
-    }
-  }
-`;
-export const ObjectFieldTemplateTitle = styled.div `
-  color: ${(props) => props.theme.color.text.default};
-  font-family: ${(props) => props.theme.typography.fontFamily.base};
-  font-size: ${(props) => props.theme.typography.size.base};
-  font-weight: ${(props) => props.theme.typography.weight.medium};
-  page-break-after: avoid;
-  break-after: avoid;
-
-  ${ObjectFieldTemplateWrapper}[data-fjsf-level] > & {
-    font-size: ${(props) => props.theme.typography.size.base};
-  }
-  ${ObjectFieldTemplateWrapper}[data-fjsf-level="0"] > & {
-    font-family: ${(props) => props.theme.typography.fontFamily.heading};
-    font-size: ${(props) => props.theme.typography.size.h2};
-    font-weight: ${(props) => props.theme.typography.weight.bold};
-    max-width: 85%;
-  }
-  ${ObjectFieldTemplateWrapper}[data-fjsf-level="1"] > & {
-    font-size: ${(props) => props.theme.typography.size.h3};
-    font-weight: ${(props) => props.theme.typography.weight.medium};
-    margin-top: ${(props) => props.theme.spacing.m};
-  }
-  ${ObjectFieldTemplateWrapper}[data-fjsf-level="2"] > & {
-    font-size: ${(props) => props.theme.typography.size.h4};
-    font-weight: ${(props) => props.theme.typography.weight.medium};
-  }
-`;
-export const ObjectFieldTemplateDescription = undefined;
-export function getComponents(components) {
-    return {
-        Wrapper: components.ObjectFieldTemplateWrapper,
-        Title: components.ObjectFieldTemplateTitle,
-        Description: components.ObjectFieldTemplateDescription ?? components.FieldDescription,
-    };
-}

package/dist/esm/FormView/templates/index.js

@@ -1,16 +0,0 @@
-//Please keep this in alphabetical order
-import * as ArrayFieldTemplate from "./ArrayFieldTemplate";
-import * as FieldTemplate from "./FieldTemplate";
-import * as ObjectFieldTemplate from "./ObjectFieldTemplate";
-//Please keep this in alphabetical order
-export const templateComponents = {
-    ...ArrayFieldTemplate.components,
-    //...FieldTemplate.components, // Field template uses generic components (should it own those?)
-    ...ObjectFieldTemplate.components,
-};
-//Please keep this in alphabetical order
-export const templates = {
-    ...ArrayFieldTemplate.templates,
-    ...FieldTemplate.templates,
-    ...ObjectFieldTemplate.templates,
-};

package/dist/esm/common/FileUploadContext.js

@@ -1,12 +0,0 @@
-import { createContext } from "react";
-export const FileUploadContext = createContext({
-    uploadFile: () => {
-        console.error("Lacking upload from FileUploadContext");
-        return Promise.reject();
-    },
-    fetchFile: (value) => Promise.resolve(value),
-    removeFile: () => {
-        console.error("Lacking remove from FileUploadContext");
-        return Promise.reject();
-    },
-});

package/dist/esm/common/FilesUploadContext.js

@@ -1,11 +0,0 @@
-import { createContext } from "react";
-export const FilesUploadContext = createContext({
-    uploadFiles: () => {
-        console.error("Lacking upload from FilesUploadContext");
-        return Promise.reject();
-    },
-    removeFile: () => {
-        console.error("Lacking remove from FileUploadContext");
-        return Promise.reject();
-    },
-});

package/dist/esm/common/constants.js

@@ -1,10 +0,0 @@
-export const COMPONENT_TYPES = {
-    array: "ArrayField",
-    boolean: "BooleanField",
-    integer: "NumberField",
-    number: "NumberField",
-    object: "ObjectField",
-    string: "StringField",
-    null: "NullField",
-    any: "AnyField",
-};

package/dist/esm/common/index.js

@@ -1,4 +0,0 @@
-export * from "./types";
-export * from "./constants";
-export * from "./FileUploadContext";
-export * from "./FilesUploadContext";

package/dist/esm/utils/createInitialValues.js

@@ -1,35 +0,0 @@
-import { solveReferences } from "./solveReferences";
-export function createInitialValues(schema, definitions = {}) {
-    if (!schema || !schema.properties) {
-        return {};
-    }
-    const schemaDefinitions = { ...definitions, ...(schema.definitions ?? {}) };
-    function getValue(schema) {
-        if (schema.properties) {
-            return createInitialValues(schema, schemaDefinitions);
-        }
-        const type = schema.type;
-        switch (type) {
-            case "array":
-                return [];
-            case "number":
-                return 0;
-            // Boolean cannot be true/false by default, since that is a valid value
-            case "boolean":
-            case "null":
-            case "string":
-                return "";
-            default:
-                console.error({ schema });
-                throw new Error(`createInitialValues: Unsupported schema type: ${type}`);
-        }
-    }
-    return Object.keys(schema?.properties).reduce((acc, key) => {
-        const value = schema?.properties?.[key];
-        const solvedValue = solveReferences(value, schemaDefinitions, {}, {});
-        return {
-            ...acc,
-            [key]: getValue(solvedValue.schema),
-        };
-    }, {});
-}

package/dist/esm/utils/createValidationSchema.js

@@ -1,361 +0,0 @@
-import * as Yup from "yup";
-import { resolveOneOfValue } from "./resolveSchema";
-import { solveReferences } from "./solveReferences";
-const DEFAULT_ERROR_MESSAGES = {
-    required: "Required",
-    minLength: (params) => `Must be at least ${params.limit} characters`,
-    maxLength: (params) => `Must be at most ${params.limit} characters`,
-    pattern: "Invalid format",
-    minimum: (params) => `Must be at least ${params.min}`,
-    maximum: (params) => `Must be at most ${params.max}`,
-    exclusiveMinimum: (params) => `Must be more than ${params.min}`,
-    exclusiveMaximum: (params) => `Must be less than ${params.max}`,
-    multipleOf: (params) => `Must be a multiple of ${params.multipleOf}`,
-    minItems: (params) => `Must have at least ${params.min} items`,
-    maxItems: (params) => `Must have at most ${params.max} items`,
-    uniqueItems: "Items must be unique",
-    enum: "Invalid value",
-    const: "Invalid value",
-    notConst: "Invalid value",
-};
-// Difficult to solve
-// @ts-expect-error
-Yup.addMethod(Yup.array, "mixedOf", function ({ itemSchemas, additionalItemSchema }) {
-    return Yup.lazy((value) => {
-        if (value === undefined) {
-            return Yup.mixed().notRequired();
-        }
-        const valueLength = value?.length ?? 0;
-        const numOfAdditionalItems = itemSchemas.length > valueLength ? 0 : valueLength - itemSchemas.length;
-        const additionalSchemas = additionalItemSchema
-            ? Array(numOfAdditionalItems).fill(additionalItemSchema)
-            : Array(numOfAdditionalItems).fill(Yup.mixed());
-        return Yup.tuple([...itemSchemas, ...additionalSchemas]).typeError("Required");
-    });
-});
-function getConditionalValidations(schema) {
-    const { dependencies, allOf } = schema;
-    let conditionalValidations = [];
-    if (dependencies) {
-        conditionalValidations = Object.entries(dependencies).reduce((validations, [key, dependency]) => {
-            if (typeof dependency === "boolean" || Array.isArray(dependency)) {
-                return validations;
-            }
-            const oneOf = dependency.oneOf;
-            if (Array.isArray(oneOf)) {
-                oneOf.forEach((oneOfSchema) => {
-                    if (typeof oneOfSchema === "boolean") {
-                        return;
-                    }
-                    const { [key]: propertyToCheck, ...propertiesSansKey } = oneOfSchema.properties ?? {};
-                    // Push validation only if there are additions in schema
-                    if (Object.keys(propertiesSansKey)?.length ||
-                        Object.keys(oneOfSchema).length > 1) {
-                        validations.push({
-                            schema: { ...oneOfSchema, properties: propertiesSansKey },
-                            condition: {
-                                dependentKeys: [key],
-                                conditionFn: (value) => value === resolveOneOfValue(propertyToCheck),
-                            },
-                        });
-                    }
-                });
-                return validations;
-            }
-            // Depends on presence of `key` property value
-            validations.push({
-                schema: dependency,
-                condition: {
-                    dependentKeys: [key],
-                    conditionFn: (value) => value !== undefined && value !== "",
-                },
-            });
-            return validations;
-        }, conditionalValidations);
-    }
-    if (allOf) {
-        conditionalValidations = allOf.reduce((validations, condition) => {
-            if (typeof condition === "boolean") {
-                return validations;
-            }
-            const { if: expression, then, else: otherwise, ...schemaWithoutCondition } = condition;
-            if (expression &&
-                typeof expression !== "boolean" &&
-                expression.properties) {
-                const keyValueMap = Object.entries(expression.properties).reduce((result, [key, value]) => {
-                    if (typeof value !== "boolean") {
-                        return { ...result, [key]: value.const };
-                    }
-                    return result;
-                }, {});
-                const dependentKeys = Object.keys(keyValueMap);
-                if (then && typeof then !== "boolean") {
-                    validations.push({
-                        schema: then,
-                        condition: {
-                            dependentKeys,
-                            conditionFn: (...args) => args.every((value, index) => keyValueMap[dependentKeys[index]] === value),
-                        },
-                    });
-                }
-                if (otherwise && typeof otherwise !== "boolean") {
-                    validations.push({
-                        schema: otherwise,
-                        condition: {
-                            dependentKeys,
-                            conditionFn: (...args) => args.some((value, index) => keyValueMap[dependentKeys[index]] !== value),
-                        },
-                    });
-                }
-            }
-            else {
-                validations.push({ schema: schemaWithoutCondition });
-            }
-            return validations;
-        }, conditionalValidations);
-    }
-    return conditionalValidations;
-}
-function getYupType(schema) {
-    const type = schema?.type;
-    switch (type) {
-        case "object":
-            return Yup.object();
-        case "array":
-            return Yup.array();
-        case "boolean":
-            return Yup.boolean();
-        case "integer":
-        case "number":
-            return Yup.number();
-        case "null":
-            return Yup.string();
-        case "string":
-            return Yup.string();
-        default:
-            console.error({ schema });
-            throw new Error(`createValidationSchema: Unsupported schema type: ${type}`);
-    }
-}
-export function createValidationSchema(schemas, options) {
-    const { schema, uiSchema = {} } = schemas;
-    const { localize, definitions, conditionsContext = {}, condition } = options ?? {};
-    if (!schema?.properties) {
-        return Yup.object().shape({});
-    }
-    const getErrorMessage = (key, fieldUiSchema, params) => {
-        const uiError = fieldUiSchema?.["ui:validation"]?.error?.[key];
-        if (uiError)
-            return uiError;
-        if (localize) {
-            return localize(`validation.error.${key}`, params);
-        }
-        const defaultMsg = DEFAULT_ERROR_MESSAGES[key];
-        return typeof defaultMsg === "function" ? defaultMsg(params) : defaultMsg;
-    };
-    const schemaDefinitions = (definitions ?? schema.definitions ?? {});
-    const requiredFields = schema.required;
-    function getValue(givenSchema, key, required) {
-        const { schema } = solveReferences(givenSchema, schemaDefinitions, {}, {});
-        const isRequired = requiredFields?.includes(key) || required === true;
-        let type = schema.type;
-        let yupSchema;
-        const fieldUiSchema = uiSchema?.[key];
-        if (schema.properties) {
-            yupSchema = createValidationSchema({
-                schema,
-                uiSchema: fieldUiSchema
-            }, {
-                localize,
-                definitions: schemaDefinitions,
-                conditionsContext,
-            });
-            type = type ?? "object";
-        }
-        else if (type === "array" && schema.anyOf) {
-            if (!schema.items && !schema.additionalItems) {
-                yupSchema = Yup.array();
-            }
-            else {
-                const anyOf = schema.anyOf;
-                // anyOf is optional, therefore we cannot change it to array.mixedOf() aka tuple
-                const anyOfSchema = Yup.array().of(Yup.lazy(() => {
-                    // value has to match with one of the anyOf values in the schema
-                    return Yup.mixed().oneOf(anyOf.map((item) => item.const));
-                }));
-                // In case the property is required, there should be at least one item in the array
-                yupSchema = isRequired
-                    ? anyOfSchema.min(1, getErrorMessage("required", fieldUiSchema))
-                    : anyOfSchema;
-            }
-        }
-        else if (type === "array") {
-            if (!schema.items && !schema.additionalItems) {
-                yupSchema = Yup.array();
-            }
-            else {
-                const additionalItemSchema = (() => {
-                    const additionalItems = schema.additionalItems;
-                    if (!additionalItems) {
-                        return undefined;
-                    }
-                    // Yup.lazy() enables validation for infinitely nested schemas
-                    // aka references that refer to themselves or in circular references
-                    return Yup.lazy(() => {
-                        return getValue(schema?.additionalItems, "#ignore-this", true);
-                    });
-                })();
-                const schemaItems = schema?.items ?? [];
-                const items = Array.isArray(schemaItems) ? schemaItems : [schemaItems];
-                yupSchema = Yup.array().mixedOf({
-                    itemSchemas: items.map((item) => getValue(item, "#ignore-this", true)),
-                    additionalItemSchema,
-                });
-            }
-        }
-        else {
-            yupSchema = getYupType(schema);
-        }
-        if (type === "null")
-            yupSchema.nullable();
-        // Apply JSON Schema validation keywords based on type
-        if (type === "string") {
-            let stringSchema = yupSchema;
-            if (schema.minLength !== undefined) {
-                stringSchema = stringSchema.min(schema.minLength, getErrorMessage("minLength", fieldUiSchema, { limit: schema.minLength }));
-            }
-            if (schema.maxLength !== undefined) {
-                stringSchema = stringSchema.max(schema.maxLength, getErrorMessage("maxLength", fieldUiSchema, { limit: schema.maxLength }));
-            }
-            if (schema.pattern !== undefined) {
-                stringSchema = stringSchema.matches(new RegExp(schema.pattern), getErrorMessage("pattern", fieldUiSchema));
-            }
-            yupSchema = stringSchema;
-        }
-        if (type === "number" || type === "integer") {
-            let numberSchema = yupSchema;
-            if (schema.minimum !== undefined) {
-                numberSchema = numberSchema.min(schema.minimum, getErrorMessage("minimum", fieldUiSchema, { min: schema.minimum }));
-            }
-            if (schema.maximum !== undefined) {
-                numberSchema = numberSchema.max(schema.maximum, getErrorMessage("maximum", fieldUiSchema, { max: schema.maximum }));
-            }
-            if (schema.exclusiveMinimum !== undefined) {
-                numberSchema = numberSchema.moreThan(schema.exclusiveMinimum, getErrorMessage("exclusiveMinimum", fieldUiSchema, { min: schema.exclusiveMinimum }));
-            }
-            if (schema.exclusiveMaximum !== undefined) {
-                numberSchema = numberSchema.lessThan(schema.exclusiveMaximum, getErrorMessage("exclusiveMaximum", fieldUiSchema, { max: schema.exclusiveMaximum }));
-            }
-            if (schema.multipleOf !== undefined) {
-                numberSchema = numberSchema.test("multipleOf", getErrorMessage("multipleOf", fieldUiSchema, { multipleOf: schema.multipleOf }), (value) => value === undefined ||
-                    value === null ||
-                    value % schema.multipleOf === 0);
-            }
-            yupSchema = numberSchema;
-        }
-        if (type === "array") {
-            const applyArrayTests = (s) => {
-                let result = s;
-                if (schema.minItems !== undefined) {
-                    result = result.test("minItems", getErrorMessage("minItems", fieldUiSchema, { min: schema.minItems }), (value) => !value || value.length >= schema.minItems);
-                }
-                if (schema.maxItems !== undefined) {
-                    result = result.test("maxItems", getErrorMessage("maxItems", fieldUiSchema, { max: schema.maxItems }), (value) => !value || value.length <= schema.maxItems);
-                }
-                if (schema.uniqueItems === true) {
-                    result = result.test("uniqueItems", getErrorMessage("uniqueItems", fieldUiSchema), (value) => {
-                        if (!value)
-                            return true;
-                        return new Set(value).size === value.length;
-                    });
-                }
-                return result;
-            };
-            if (yupSchema.test) {
-                yupSchema = applyArrayTests(yupSchema);
-            }
-            else {
-                // It's likely a Lazy schema (from mixedOf). Wrap it to apply tests.
-                const originalLazy = yupSchema;
-                yupSchema = Yup.lazy((value, options) => {
-                    return applyArrayTests(originalLazy.resolve(options));
-                });
-            }
-        }
-        const isOptionEnum = schema.enum !== undefined;
-        const isOptionConst = schema.const !== undefined;
-        if (isOptionEnum || isOptionConst) {
-            // Check for $data reference (cross-field validation)
-            const constValue = schema.const;
-            const isDataRef = typeof constValue === "object" && constValue?.$data;
-            if (isDataRef) {
-                // Cross-field reference: const: { $data: "1/otherFieldName" }
-                // JSON Pointer format: "1/fieldName" means go up 1 level and reference fieldName
-                const dataPath = constValue.$data;
-                const pathParts = dataPath.split("/");
-                const refFieldName = pathParts[pathParts.length - 1]; // Get the field name (last part)
-                yupSchema = yupSchema.oneOf([Yup.ref(refFieldName)], getErrorMessage("const", fieldUiSchema));
-            }
-            else {
-                // Standard const or enum validation
-                const allowedValues = isOptionConst ? [schema.const] : schema.enum;
-                const errorKey = isOptionConst ? "const" : "enum";
-                yupSchema = yupSchema.oneOf(allowedValues, getErrorMessage(errorKey, fieldUiSchema));
-            }
-        }
-        if (schema.not &&
-            typeof schema.not !== "boolean" &&
-            schema.not.const !== undefined) {
-            yupSchema = yupSchema.notOneOf([schema.not.const], getErrorMessage("notConst", fieldUiSchema));
-        }
-        // JSON Schema validation keywords
-        if (isRequired && type !== "array") {
-            yupSchema = yupSchema.required(getErrorMessage("required", fieldUiSchema));
-        }
-        if (!condition) {
-            return yupSchema;
-        }
-        const existing = conditionsContext[key] ?? [];
-        conditionsContext[key] = [...existing, { yupSchema, condition }];
-        // TODO: The latest given type for duplicate field is used.
-        // This might become a problem at some point, but testing has not
-        // shown any problems so far.
-        const yupType = getYupType(schema).when(condition.dependentKeys, {
-            is: condition.conditionFn,
-            then: () => yupSchema,
-        });
-        // If there are existing conditions for the field with same name
-        // for example definition or duplicate field, add those clauses in.
-        // Otherwise the validation would be overwritten by the latest one
-        // breaking the earlier validations.
-        return existing.reduce((result, context) => {
-            const { condition: ctxCondition, yupSchema: ctxYupSchema } = context;
-            return result.when(ctxCondition.dependentKeys, {
-                is: ctxCondition.conditionFn,
-                then: () => ctxYupSchema,
-            });
-        }, yupType);
-    }
-    const baseValidationSchema = Object.keys(schema.properties).reduce((validationSchema, key) => {
-        const value = schema.properties?.[key];
-        return validationSchema.concat(Yup.object().shape({ [key]: getValue(value, key) }));
-    }, Yup.object().shape({}));
-    return getConditionalValidations(schema).reduce((validationSchema, conditionalValidation) => {
-        const solvedSchemas = solveReferences(conditionalValidation.schema, schemaDefinitions, {}, {});
-        /*
-        "Only schemas of the same type can be concatenated. concat is not
-        a "merge" function in the sense that all settings from the provided schema,
-        override ones in the base, including type, presence and nullability."
-        Source: https://github.com/jquense/yup?tab=readme-ov-file#schemaconcatschema-schema-schema
-        */
-        return validationSchema.concat(createValidationSchema({
-            schema: solvedSchemas.schema,
-            uiSchema
-        }, {
-            localize,
-            definitions: schemaDefinitions,
-            conditionsContext,
-            condition: conditionalValidation.condition
-        }));
-    }, baseValidationSchema);
-}

package/dist/esm/utils/deepOverlap.js

@@ -1,14 +0,0 @@
-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/esm/utils/extractUiSchema.js

@@ -1,18 +0,0 @@
-export const extractUiSchema = (props = {}) => {
-    // props is frozen by React, so it needs to be copied
-    const schema = { ...props };
-    if (schema.props !== undefined) {
-        schema["ui:props"] = {
-            ...(schema["ui:props"] ?? {}),
-            ...(schema.props ?? {}),
-        };
-    }
-    const { "ui:options": options = {}, ...uiSchema } = schema;
-    return {
-        ...Object.keys(uiSchema || {}).reduce((result, key) => ({
-            ...result,
-            [key.replace("ui:", "")]: uiSchema[key],
-        }), {}),
-        ...options,
-    };
-};

package/dist/esm/utils/getEnums.js

@@ -1,51 +0,0 @@
-export var EnumsTypes;
-(function (EnumsTypes) {
-    EnumsTypes["SELECT"] = "select";
-    EnumsTypes["MULTI_SELECT"] = "multiSelect";
-})(EnumsTypes || (EnumsTypes = {}));
-//TODO: Add some proper typing
-export const getEnums = ({ schema }) => {
-    if (!schema) {
-        return { values: [] };
-    }
-    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: EnumsTypes.SELECT,
-            values: schema.enum.map((option) => ({
-                const: option,
-                title: `${option}`,
-            })),
-        };
-    }
-    if (schema.oneOf) {
-        return {
-            type: EnumsTypes.SELECT,
-            values: schema.oneOf,
-        };
-    }
-    if (schema.anyOf) {
-        return {
-            type: EnumsTypes.MULTI_SELECT,
-            values: schema.anyOf,
-        };
-    }
-};
-export const getSelectedEnum = (selected, enums) => {
-    if (Array.isArray(selected)) {
-        const stuff = selected
-            .map((v) => enums?.values.find((e) => e.const === v))
-            .filter((e) => !!e);
-        return stuff.length > 0 ? stuff : undefined;
-    }
-    if (typeof selected === "string" || typeof selected === "number") {
-        return enums?.values.filter((e) => e.const === selected);
-    }
-    return undefined;
-};

package/dist/esm/utils/getHiddenProperties.js

@@ -1,7 +0,0 @@
-export const getHiddenProperties = (order, properties) => {
-    if (!order || order.includes("*")) {
-        return [];
-    }
-    const propertiesInOrder = order.flatMap((entry) => typeof entry === "string" ? entry : entry.fields);
-    return properties.filter((key) => !propertiesInOrder.includes(key));
-};

package/dist/esm/utils/getStyle.js

@@ -1,18 +0,0 @@
-export function getStyle(key) {
-    const style = {};
-    if (key === "inline") {
-        style.flexDirection = "row";
-    }
-    if (key === "oneColumn") {
-        style.display = "grid";
-    }
-    if (key === "twoColumns") {
-        style.display = "grid";
-        style["gridTemplateColumns"] = "1fr 1fr";
-    }
-    if (key === "threeColumns") {
-        style.display = "grid";
-        style["gridTemplateColumns"] = "1fr 1fr 1fr";
-    }
-    return style;
-}