@datenlotse/jsonjoy-builder 0.4.0 → 0.5.0

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/i18n/locales/de.js

@@ -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",

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.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/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.0",
   "type": "module",
   "sideEffects": false,
   "repository": {