@datenlotse/jsonjoy-builder 0.4.0 → 0.5.1

package/dist/components/SchemaEditor/AddFieldButton.js

@@ -1,6 +1,6 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import { CirclePlus, HelpCircle, Info } from "lucide-react";
-import { useId, useState } from "react";
+import { useEffect, useId, useState } from "react";
 import { Badge } from "../ui/badge.js";
 import { Button } from "../ui/button.js";
 import { Dialog, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogTitle } from "../ui/dialog.js";
@@ -8,30 +8,64 @@ import { Input } from "../ui/input.js";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../ui/tooltip.js";
 import { useTranslation } from "../../hooks/use-translation.js";
 import SchemaTypeSelector from "./SchemaTypeSelector.js";
-const AddFieldButton = ({ onAddField, variant = "primary" })=>{
+import TypeEditor from "./TypeEditor.js";
+const ENUM_TYPES = [
+    "string",
+    "number",
+    "integer"
+];
+function createEmptyDraftSchema(type) {
+    return {
+        type
+    };
+}
+const AddFieldButton = ({ parentSchema, onAddField, variant = "primary" })=>{
     const [dialogOpen, setDialogOpen] = useState(false);
     const [fieldName, setFieldName] = useState("");
     const [fieldType, setFieldType] = useState("string");
     const [fieldDesc, setFieldDesc] = useState("");
     const [fieldRequired, setFieldRequired] = useState(false);
+    const [draftSchema, setDraftSchema] = useState(()=>createEmptyDraftSchema("string"));
     const fieldNameId = useId();
     const fieldDescId = useId();
     const fieldRequiredId = useId();
     const fieldTypeId = useId();
     const t = useTranslation();
+    useEffect(()=>{
+        setDraftSchema((prev)=>{
+            const nextType = fieldType;
+            const prevType = prev.type;
+            if (prevType === nextType) return prev;
+            return createEmptyDraftSchema(nextType);
+        });
+    }, [
+        fieldType
+    ]);
+    useEffect(()=>{
+        if (dialogOpen) setDraftSchema(createEmptyDraftSchema(fieldType));
+    }, [
+        dialogOpen
+    ]);
     const handleSubmit = (e)=>{
         e.preventDefault();
         if (!fieldName.trim()) return;
+        const validation = ENUM_TYPES.includes(fieldType) && Object.keys(draftSchema).length > 1 ? {
+            ...draftSchema,
+            type: fieldType
+        } : void 0;
         onAddField({
-            name: fieldName,
+            name: fieldName.trim(),
             type: fieldType,
             description: fieldDesc,
-            required: fieldRequired
+            required: fieldRequired,
+            default: draftSchema.default,
+            validation
         });
         setFieldName("");
         setFieldType("string");
         setFieldDesc("");
         setFieldRequired(false);
+        setDraftSchema(createEmptyDraftSchema("string"));
         setDialogOpen(false);
     };
     return /*#__PURE__*/ jsxs(Fragment, {
@@ -283,6 +317,27 @@ const AddFieldButton = ({ onAddField, variant = "primary" })=>{
                                         })
                                     ]
                                 }),
+                                ENUM_TYPES.includes(fieldType) && /*#__PURE__*/ jsxs("details", {
+                                    className: "group rounded-lg border bg-muted/30",
+                                    children: [
+                                        /*#__PURE__*/ jsx("summary", {
+                                            className: "cursor-pointer list-none px-4 py-3 text-sm font-medium",
+                                            children: t.stringAllowedValuesEnumLabel
+                                        }),
+                                        /*#__PURE__*/ jsx("div", {
+                                            className: "border-t px-4 pb-4 pt-2",
+                                            children: /*#__PURE__*/ jsx(TypeEditor, {
+                                                schema: draftSchema,
+                                                readOnly: false,
+                                                parentSchema: parentSchema,
+                                                propertyName: fieldName.trim() || void 0,
+                                                validationNode: void 0,
+                                                onChange: setDraftSchema,
+                                                depth: 1
+                                            })
+                                        })
+                                    ]
+                                }),
                                 /*#__PURE__*/ jsxs(DialogFooter, {
                                     className: "mt-6 gap-2 flex-wrap",
                                     children: [

package/dist/components/SchemaEditor/SchemaPropertyEditor.js

@@ -2,9 +2,10 @@ import { jsx, jsxs } from "react/jsx-runtime";
 import { ChevronDown, ChevronRight, ChevronUp, X } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 import { Input } from "../ui/input.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../ui/select.js";
 import { useTranslation } from "../../hooks/use-translation.js";
 import { cn } from "../../lib/utils.js";
-import { asObjectSchema, getSchemaDescription, withObjectSchema } from "../../types/jsonSchema.js";
+import { asObjectSchema, getSchemaDescription, isBooleanSchema, withObjectSchema } from "../../types/jsonSchema.js";
 import { Badge } from "../ui/badge.js";
 import TypeDropdown from "./TypeDropdown.js";
 import TypeEditor from "./TypeEditor.js";
@@ -23,6 +24,33 @@ const SchemaPropertyEditor = ({ name, schema, required, readOnly = false, parent
         schema
     ]);
     const [tempDefault, setTempDefault] = useState(defaultValue);
+    const defaultValueOptions = useMemo(()=>{
+        if ("string" !== type && "number" !== type && "integer" !== type) return null;
+        const objSchema = asObjectSchema(schema);
+        const enumValues = objSchema.enum;
+        const dependentEnum = objSchema.$dependentEnum;
+        if (Array.isArray(enumValues) && enumValues.length > 0) return enumValues.map((v)=>String(v));
+        if (dependentEnum && parentSchema) {
+            const controllingPropertyName = dependentEnum.property;
+            const controllingPropertySchema = parentSchema.properties?.[controllingPropertyName];
+            if (controllingPropertySchema && "object" == typeof controllingPropertySchema && !isBooleanSchema(controllingPropertySchema)) {
+                const controllingDefault = controllingPropertySchema.default;
+                if (void 0 !== controllingDefault) {
+                    const ctrlDefaultStr = String(controllingDefault);
+                    const allowedValues = dependentEnum.values[ctrlDefaultStr];
+                    if (Array.isArray(allowedValues) && allowedValues.length > 0) return allowedValues.map((v)=>String(v));
+                }
+            }
+        }
+        return null;
+    }, [
+        schema,
+        type,
+        parentSchema
+    ]);
+    const defaultError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"default" === err.path[0])?.message, [
+        validationNode
+    ]);
     useEffect(()=>{
         setTempName(name);
         setTempDesc(getSchemaDescription(schema));
@@ -78,6 +106,26 @@ const SchemaPropertyEditor = ({ name, schema, required, readOnly = false, parent
             });
         }
     };
+    const handleDefaultSelectChange = (value)=>{
+        const objSchema = asObjectSchema(schema);
+        const currentDefault = objSchema.default;
+        if ("__none__" === value || "" === value) {
+            if (void 0 !== currentDefault) {
+                const { default: _, ...rest } = objSchema;
+                onSchemaChange(rest);
+            }
+        } else {
+            let parsedValue = value;
+            if ("number" === type || "integer" === type) {
+                parsedValue = Number(value);
+                if (Number.isNaN(parsedValue)) parsedValue = value;
+            }
+            if (JSON.stringify(currentDefault) !== JSON.stringify(parsedValue)) onSchemaChange({
+                ...objSchema,
+                default: parsedValue
+            });
+        }
+    };
     return /*#__PURE__*/ jsxs("div", {
         className: cn("mb-2 animate-in rounded-lg border transition-all duration-200", depth > 0 && "ml-0 sm:ml-4 border-l border-l-border/40"),
         children: [
@@ -221,13 +269,40 @@ const SchemaPropertyEditor = ({ name, schema, required, readOnly = false, parent
                                 className: "text-xs font-medium text-muted-foreground",
                                 children: t.propertyDefaultLabel
                             }),
-                            /*#__PURE__*/ jsx(Input, {
+                            defaultValueOptions && defaultValueOptions.length > 0 ? /*#__PURE__*/ jsxs(Select, {
+                                value: "" !== defaultValue && defaultValueOptions.includes(defaultValue) ? defaultValue : "__none__",
+                                onValueChange: handleDefaultSelectChange,
+                                children: [
+                                    /*#__PURE__*/ jsx(SelectTrigger, {
+                                        className: "h-8 text-sm",
+                                        children: /*#__PURE__*/ jsx(SelectValue, {
+                                            placeholder: t.propertyDefaultPlaceholder
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsxs(SelectContent, {
+                                        children: [
+                                            /*#__PURE__*/ jsx(SelectItem, {
+                                                value: "__none__",
+                                                children: t.propertyDefaultNone
+                                            }),
+                                            defaultValueOptions.map((option)=>/*#__PURE__*/ jsx(SelectItem, {
+                                                    value: option,
+                                                    children: option
+                                                }, option))
+                                        ]
+                                    })
+                                ]
+                            }) : /*#__PURE__*/ jsx(Input, {
                                 value: tempDefault,
                                 onChange: (e)=>setTempDefault(e.target.value),
                                 onBlur: handleDefaultSubmit,
                                 onKeyDown: (e)=>"Enter" === e.key && handleDefaultSubmit(),
                                 placeholder: t.propertyDefaultPlaceholder,
                                 className: "h-8 text-sm"
+                            }),
+                            defaultError && /*#__PURE__*/ jsx("div", {
+                                className: "text-xs text-destructive italic",
+                                children: defaultError
                             })
                         ]
                     }),

package/dist/components/SchemaEditor/SchemaVisualEditor.js

@@ -44,6 +44,7 @@ const SchemaVisualEditor = ({ schema, onChange, readOnly = false })=>{
             !readOnly && /*#__PURE__*/ jsx("div", {
                 className: "mb-6 shrink-0",
                 children: /*#__PURE__*/ jsx(AddFieldButton, {
+                    parentSchema: asObjectSchema(schema),
                     onAddField: handleAddField
                 })
             }),

package/dist/components/SchemaEditor/types/ObjectEditor.js

@@ -79,6 +79,7 @@ const ObjectEditor = ({ schema, validationNode, onChange, depth = 0, readOnly =
             !readOnly && /*#__PURE__*/ jsx("div", {
                 className: "mt-4",
                 children: /*#__PURE__*/ jsx(AddFieldButton, {
+                    parentSchema: normalizedSchema,
                     onAddField: handleAddProperty,
                     variant: "secondary"
                 })

package/dist/i18n/locales/de.js

@@ -30,7 +30,7 @@ const de = {
     fieldTypeBooleanDescription: "Für Wahr/Falsch-Werte",
     fieldTypeObjectLabel: "Gruppe",
     fieldTypeObjectDescription: "Zum Gruppieren verwandter Felder",
-    fieldTypeArrayLabel: "Liste",
+    fieldTypeArrayLabel: "Mehrfach-Auswahl",
     fieldTypeArrayDescription: "Für Sammlungen von Elementen",
     propertyDescriptionPlaceholder: "Beschreibung hinzufügen...",
     propertyDescriptionButton: "Beschreibung hinzufügen...",
@@ -41,6 +41,9 @@ const de = {
     propertyMoveDown: "Feld nach unten verschieben",
     propertyDefaultLabel: "Standardwert",
     propertyDefaultPlaceholder: "Standardwert eingeben...",
+    propertyDefaultMustBeInEnum: "Der Standardwert muss einer der erlaubten Werte sein.",
+    propertyDefaultRequiresDependentDefault: "Ein Standardwert kann nur gesetzt werden, wenn die abhängige Eigenschaft einen Standardwert hat.",
+    propertyDefaultNone: "Kein Standardwert",
     schemaEditorTitle: "JSON-Schema-Editor",
     schemaEditorToggleFullscreen: "Vollbild umschalten",
     schemaEditorEditModeVisual: "Visuell",
@@ -109,10 +112,10 @@ const de = {
     whenPropertyEquals: "Wenn {property} = {value}",
     stringFormatSelectPlaceholder: "Format auswählen",
     stringValidationErrorLengthRange: "'Minimale Länge' darf nicht größer als 'Maximale Länge' sein.",
-    schemaTypeArray: "Liste",
+    schemaTypeArray: "Mehrfach-Auswahl",
     schemaTypeBoolean: "Ja/Nein",
     schemaTypeNumber: "Zahl",
-    schemaTypeObject: "Objekt",
+    schemaTypeObject: "Gruppe",
     schemaTypeString: "Text",
     schemaTypeNull: "Leer",
     inferrerTitle: "JSON-Schema ableiten",

package/dist/i18n/locales/en.js

@@ -41,6 +41,9 @@ const en = {
     propertyMoveDown: "Move field down",
     propertyDefaultLabel: "Default Value",
     propertyDefaultPlaceholder: "Enter default value...",
+    propertyDefaultMustBeInEnum: "Default value must be one of the allowed values.",
+    propertyDefaultRequiresDependentDefault: "Default can only be set when the dependent property has a default.",
+    propertyDefaultNone: "No default",
     schemaEditorTitle: "JSON Schema Editor",
     schemaEditorToggleFullscreen: "Toggle fullscreen",
     schemaEditorEditModeVisual: "Visual",

package/dist/i18n/locales/es.js

@@ -41,6 +41,9 @@ const es = {
     propertyMoveDown: "Mover campo hacia abajo",
     propertyDefaultLabel: "Valor por defecto",
     propertyDefaultPlaceholder: "Ingresar valor por defecto...",
+    propertyDefaultMustBeInEnum: "El valor por defecto debe ser uno de los valores permitidos.",
+    propertyDefaultRequiresDependentDefault: "El valor por defecto solo puede establecerse cuando la propiedad dependiente tiene un valor por defecto.",
+    propertyDefaultNone: "Sin valor por defecto",
     schemaEditorTitle: "Editor de JSON Schema",
     schemaEditorToggleFullscreen: "Cambiar a pantalla completa",
     schemaEditorEditModeVisual: "Visual",

package/dist/i18n/locales/fr.js

@@ -41,6 +41,9 @@ const fr = {
     propertyMoveDown: "Déplacer le champ vers le bas",
     propertyDefaultLabel: "Valeur par défaut",
     propertyDefaultPlaceholder: "Entrer la valeur par défaut...",
+    propertyDefaultMustBeInEnum: "La valeur par défaut doit être l'une des valeurs autorisées.",
+    propertyDefaultRequiresDependentDefault: "La valeur par défaut ne peut être définie que lorsque la propriété dépendante a une valeur par défaut.",
+    propertyDefaultNone: "Aucune valeur par défaut",
     schemaEditorTitle: "Éditeur de schéma JSON",
     schemaEditorToggleFullscreen: "Basculer en plein écran",
     schemaEditorEditModeVisual: "Visuel",

package/dist/i18n/locales/ru.js

@@ -41,6 +41,9 @@ const ru = {
     propertyMoveDown: "Переместить поле вниз",
     propertyDefaultLabel: "Значение по умолчанию",
     propertyDefaultPlaceholder: "Введите значение по умолчанию...",
+    propertyDefaultMustBeInEnum: "Значение по умолчанию должно быть одним из разрешенных значений.",
+    propertyDefaultRequiresDependentDefault: "Значение по умолчанию может быть установлено только тогда, когда зависимое свойство имеет значение по умолчанию.",
+    propertyDefaultNone: "Нет значения по умолчанию",
     schemaEditorTitle: "Редактор JSON схем",
     schemaEditorToggleFullscreen: "Переключить полноэкранный режим",
     schemaEditorEditModeVisual: "Визуальный",

package/dist/i18n/locales/uk.js

@@ -41,6 +41,9 @@ const uk = {
     propertyMoveDown: "Перемістити поле вниз",
     propertyDefaultLabel: "Значення за замовчуванням",
     propertyDefaultPlaceholder: "Введіть значення за замовчуванням...",
+    propertyDefaultMustBeInEnum: "Значення за замовчуванням повинно бути одним з дозволених значень.",
+    propertyDefaultRequiresDependentDefault: "Значення за замовчуванням може бути встановлено лише тоді, коли залежна властивість має значення за замовчуванням.",
+    propertyDefaultNone: "Немає значення за замовчуванням",
     schemaEditorTitle: "Редактор JSON-схем",
     schemaEditorToggleFullscreen: "Перемкнути повноекранний режим",
     schemaEditorEditModeVisual: "Візуальний",

package/dist/i18n/locales/zh.js

@@ -41,6 +41,9 @@ const zh = {
     propertyMoveDown: "向下移动字段",
     propertyDefaultLabel: "默认值",
     propertyDefaultPlaceholder: "输入默认值...",
+    propertyDefaultMustBeInEnum: "默认值必须是允许的值之一。",
+    propertyDefaultRequiresDependentDefault: "只有在依赖属性具有默认值时才能设置默认值。",
+    propertyDefaultNone: "无默认值",
     schemaEditorTitle: "JSON Schema 编辑器",
     schemaEditorToggleFullscreen: "切换全屏",
     schemaEditorEditModeVisual: "可视化",

package/dist/index.css

@@ -1356,6 +1356,10 @@
     cursor: text;
   }
 
+  .jsonjoy .list-none, .jsonjoy.list-none {
+    list-style-type: none;
+  }
+
   .jsonjoy .grid-cols-1, .jsonjoy.grid-cols-1 {
     grid-template-columns: repeat(1, minmax(0, 1fr));
   }
@@ -1719,7 +1723,17 @@
     background-color: var(--jsonjoy-color-green-50);
   }
 
-  .jsonjoy .bg-muted, .jsonjoy.bg-muted, .jsonjoy .bg-muted\/40, .jsonjoy.bg-muted\/40 {
+  .jsonjoy .bg-muted, .jsonjoy.bg-muted, .jsonjoy .bg-muted\/30, .jsonjoy.bg-muted\/30 {
+    background-color: var(--jsonjoy-color-muted);
+  }
+
+  @supports (color: color-mix(in lab, red, red)) {
+    .jsonjoy .bg-muted\/30, .jsonjoy.bg-muted\/30 {
+      background-color: color-mix(in oklab, var(--jsonjoy-color-muted) 30%, transparent);
+    }
+  }
+
+  .jsonjoy .bg-muted\/40, .jsonjoy.bg-muted\/40 {
     background-color: var(--jsonjoy-color-muted);
   }
 
@@ -1968,6 +1982,10 @@
     padding-bottom: calc(var(--jsonjoy-spacing) * 2);
   }
 
+  .jsonjoy .pb-4, .jsonjoy.pb-4 {
+    padding-bottom: calc(var(--jsonjoy-spacing) * 4);
+  }
+
   .jsonjoy .pb-24, .jsonjoy.pb-24 {
     padding-bottom: calc(var(--jsonjoy-spacing) * 24);
   }

package/dist/index.d.ts

@@ -400,6 +400,24 @@ export declare interface Translation {
      * > Enter default value...
      */
     readonly propertyDefaultPlaceholder: string;
+    /**
+     * The translation for the key `propertyDefaultMustBeInEnum`. English default is:
+     *
+     * > Default value must be one of the allowed values.
+     */
+    readonly propertyDefaultMustBeInEnum: string;
+    /**
+     * The translation for the key `propertyDefaultRequiresDependentDefault`. English default is:
+     *
+     * > Default can only be set when the dependent property has a default.
+     */
+    readonly propertyDefaultRequiresDependentDefault: string;
+    /**
+     * The translation for the key `propertyDefaultNone`. English default is:
+     *
+     * > No default
+     */
+    readonly propertyDefaultNone: string;
     /**
      * The translation for the key `arrayNoConstraint`. English default is:
      *

package/dist/lib/schemaEditor.js

@@ -129,7 +129,9 @@ function renameObjectProperty(schema, oldName, newName) {
     const propertyOrder = newSchema.$propertyOrder || Object.keys(newSchema.properties);
     for (const key of propertyOrder)if (key === oldName) newProperties[newName] = newSchema.properties[oldName];
     else if (key in newSchema.properties) newProperties[key] = newSchema.properties[key];
-    for (const [key, value] of Object.entries(newSchema.properties))if (!(key in newProperties)) newProperties[key] = value;
+    for (const [key, value] of Object.entries(newSchema.properties))if (key !== oldName) {
+        if (!(key in newProperties)) newProperties[key] = value;
+    }
     newSchema.properties = newProperties;
     if (newSchema.required) newSchema.required = newSchema.required.map((field)=>field === oldName ? newName : field);
     if (newSchema.$propertyOrder) newSchema.$propertyOrder = newSchema.$propertyOrder.map((name)=>name === oldName ? newName : name);

package/dist/types/validation.js

@@ -138,7 +138,75 @@ function validateSchemaByType(schema, type, t) {
         errors: result.error.issues
     };
 }
-function buildValidationTree(schema, t) {
+function validateDefaultInEnum(schema, type, t, parentSchema) {
+    if ("string" !== type && "number" !== type && "integer" !== type) return null;
+    const defaultValue = schema.default;
+    if (void 0 === defaultValue) return null;
+    const enumValues = schema.enum;
+    if (Array.isArray(enumValues) && enumValues.length > 0) {
+        const isInEnum = enumValues.some((val)=>{
+            if ("number" === type || "integer" === type) return val === defaultValue || "number" == typeof val && "number" == typeof defaultValue && val === defaultValue;
+            return String(val) === String(defaultValue);
+        });
+        if (!isInEnum) return {
+            code: "custom",
+            message: t.propertyDefaultMustBeInEnum,
+            path: [
+                "default"
+            ]
+        };
+    }
+    const dependentEnum = schema.$dependentEnum;
+    if (dependentEnum) {
+        const controllingPropertyName = dependentEnum.property;
+        const dependentValuesMap = dependentEnum.values;
+        if (!parentSchema) return {
+            code: "custom",
+            message: t.propertyDefaultRequiresDependentDefault,
+            path: [
+                "default"
+            ]
+        };
+        const controllingPropertySchema = parentSchema.properties?.[controllingPropertyName];
+        if (!controllingPropertySchema || "object" != typeof controllingPropertySchema) return {
+            code: "custom",
+            message: t.propertyDefaultRequiresDependentDefault,
+            path: [
+                "default"
+            ]
+        };
+        const controllingDefault = controllingPropertySchema.default;
+        if (void 0 === controllingDefault) return {
+            code: "custom",
+            message: t.propertyDefaultRequiresDependentDefault,
+            path: [
+                "default"
+            ]
+        };
+        const ctrlDefaultStr = String(controllingDefault);
+        const allowedValues = dependentValuesMap[ctrlDefaultStr];
+        if (!Array.isArray(allowedValues) || 0 === allowedValues.length) return {
+            code: "custom",
+            message: t.propertyDefaultRequiresDependentDefault,
+            path: [
+                "default"
+            ]
+        };
+        const isInAllowedValues = allowedValues.some((val)=>{
+            if ("number" === type || "integer" === type) return val === defaultValue || "number" == typeof val && "number" == typeof defaultValue && val === defaultValue;
+            return String(val) === String(defaultValue);
+        });
+        if (!isInAllowedValues) return {
+            code: "custom",
+            message: t.propertyDefaultMustBeInEnum,
+            path: [
+                "default"
+            ]
+        };
+    }
+    return null;
+}
+function buildValidationTree(schema, t, parentSchema) {
     const deriveType = (sch)=>{
         if (!sch || "object" != typeof sch) return;
         const declared = sch.type;
@@ -169,20 +237,33 @@ function buildValidationTree(schema, t) {
     const sch = schema;
     const currentType = deriveType(sch);
     const validation = validateSchemaByType(schema, currentType, t);
+    if ("string" === currentType || "number" === currentType || "integer" === currentType) {
+        const defaultError = validateDefaultInEnum(schema, currentType, t, parentSchema);
+        if (defaultError) if (validation.success) {
+            validation.success = false;
+            validation.errors = [
+                defaultError
+            ];
+        } else validation.errors = [
+            ...validation.errors || [],
+            defaultError
+        ];
+    }
     const children = {};
     if ("object" === currentType) {
+        const currentObjectSchema = schema;
         const properties = sch.properties;
-        if (properties && "object" == typeof properties) for (const [propName, propSchema] of Object.entries(properties))children[propName] = buildValidationTree(propSchema, t);
-        if (sch.patternProperties && "object" == typeof sch.patternProperties) for (const [patternName, patternSchema] of Object.entries(sch.patternProperties))children[`pattern:${patternName}`] = buildValidationTree(patternSchema, t);
+        if (properties && "object" == typeof properties) for (const [propName, propSchema] of Object.entries(properties))children[propName] = buildValidationTree(propSchema, t, currentObjectSchema);
+        if (sch.patternProperties && "object" == typeof sch.patternProperties) for (const [patternName, patternSchema] of Object.entries(sch.patternProperties))children[`pattern:${patternName}`] = buildValidationTree(patternSchema, t, currentObjectSchema);
     }
     if ("array" === currentType) {
         const items = sch.items;
         if (Array.isArray(items)) items.forEach((it, idx)=>{
-            children[`items[${idx}]`] = buildValidationTree(it, t);
+            children[`items[${idx}]`] = buildValidationTree(it, t, parentSchema);
         });
-        else if (items) children.items = buildValidationTree(items, t);
+        else if (items) children.items = buildValidationTree(items, t, parentSchema);
         if (Array.isArray(sch.prefixItems)) sch.prefixItems.forEach((it, idx)=>{
-            children[`prefixItems[${idx}]`] = buildValidationTree(it, t);
+            children[`prefixItems[${idx}]`] = buildValidationTree(it, t, parentSchema);
         });
     }
     const combinators = [
@@ -196,13 +277,13 @@ function buildValidationTree(schema, t) {
             children[[
                 comb,
                 idx
-            ].join(":")] = buildValidationTree(subSchema, t);
+            ].join(":")] = buildValidationTree(subSchema, t, parentSchema);
         });
     }
-    if (sch.not) children.not = buildValidationTree(sch.not, t);
-    if (sch.$defs && "object" == typeof sch.$defs) for (const [defName, defSchema] of Object.entries(sch.$defs))children[`$defs:${defName}`] = buildValidationTree(defSchema, t);
+    if (sch.not) children.not = buildValidationTree(sch.not, t, parentSchema);
+    if (sch.$defs && "object" == typeof sch.$defs) for (const [defName, defSchema] of Object.entries(sch.$defs))children[`$defs:${defName}`] = buildValidationTree(defSchema, t, parentSchema);
     const definitions = sch.definitions;
-    if (definitions && "object" == typeof definitions) for (const [defName, defSchema] of Object.entries(definitions))children[`definitions:${defName}`] = buildValidationTree(defSchema, t);
+    if (definitions && "object" == typeof definitions) for (const [defName, defSchema] of Object.entries(definitions))children[`definitions:${defName}`] = buildValidationTree(defSchema, t, parentSchema);
     const ownErrors = validation.success ? 0 : validation.errors?.length ?? 0;
     const childrenErrors = Object.values(children).reduce((sum, child)=>sum + child.cumulativeChildrenErrors, 0);
     return {

package/package.json

@@ -14,7 +14,7 @@
     "react"
   ],
   "private": false,
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "sideEffects": false,
   "repository": {