@datenlotse/jsonjoy-builder 0.4.0

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

@@ -0,0 +1,90 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useTranslation } from "../../../hooks/use-translation.js";
+import { getSchemaProperties, removeObjectProperty, reorderObjectProperty, updateObjectProperty, updatePropertyRequired } from "../../../lib/schemaEditor.js";
+import { asObjectSchema, isBooleanSchema } from "../../../types/jsonSchema.js";
+import AddFieldButton from "../AddFieldButton.js";
+import SchemaPropertyEditor from "../SchemaPropertyEditor.js";
+const ObjectEditor = ({ schema, validationNode, onChange, depth = 0, readOnly = false })=>{
+    const t = useTranslation();
+    const properties = getSchemaProperties(schema);
+    const normalizedSchema = isBooleanSchema(schema) ? {
+        type: "object",
+        properties: {}
+    } : {
+        ...schema,
+        type: "object",
+        properties: schema.properties || {}
+    };
+    const handleAddProperty = (newField)=>{
+        const fieldSchema = {
+            type: newField.type,
+            description: newField.description || void 0,
+            ...newField.validation || {}
+        };
+        if (void 0 !== newField.default) fieldSchema.default = newField.default;
+        let newSchema = updateObjectProperty(normalizedSchema, newField.name, fieldSchema);
+        if (newField.required) newSchema = updatePropertyRequired(newSchema, newField.name, true);
+        onChange(newSchema);
+    };
+    const handleDeleteProperty = (propertyName)=>{
+        const newSchema = removeObjectProperty(normalizedSchema, propertyName);
+        onChange(newSchema);
+    };
+    const handlePropertyNameChange = (oldName, newName)=>{
+        if (oldName === newName) return;
+        const property = properties.find((p)=>p.name === oldName);
+        if (!property) return;
+        const propertySchemaObj = asObjectSchema(property.schema);
+        let newSchema = updateObjectProperty(normalizedSchema, newName, propertySchemaObj);
+        if (property.required) newSchema = updatePropertyRequired(newSchema, newName, true);
+        newSchema = removeObjectProperty(newSchema, oldName);
+        onChange(newSchema);
+    };
+    const handlePropertyRequiredChange = (propertyName, required)=>{
+        const newSchema = updatePropertyRequired(normalizedSchema, propertyName, required);
+        onChange(newSchema);
+    };
+    const handlePropertySchemaChange = (propertyName, propertySchema)=>{
+        const newSchema = updateObjectProperty(normalizedSchema, propertyName, propertySchema);
+        onChange(newSchema);
+    };
+    const handleReorderProperty = (propertyName, direction)=>{
+        const newSchema = reorderObjectProperty(normalizedSchema, propertyName, direction);
+        onChange(newSchema);
+    };
+    return /*#__PURE__*/ jsxs("div", {
+        className: "space-y-4",
+        children: [
+            properties.length > 0 ? /*#__PURE__*/ jsx("div", {
+                className: "space-y-2",
+                children: properties.map((property, index)=>/*#__PURE__*/ jsx(SchemaPropertyEditor, {
+                        readOnly: readOnly,
+                        name: property.name,
+                        schema: property.schema,
+                        required: property.required,
+                        parentSchema: normalizedSchema,
+                        validationNode: validationNode?.children[property.name],
+                        onDelete: ()=>handleDeleteProperty(property.name),
+                        onNameChange: (newName)=>handlePropertyNameChange(property.name, newName),
+                        onRequiredChange: (required)=>handlePropertyRequiredChange(property.name, required),
+                        onSchemaChange: (schema)=>handlePropertySchemaChange(property.name, schema),
+                        onMoveUp: index > 0 ? ()=>handleReorderProperty(property.name, "up") : void 0,
+                        onMoveDown: index < properties.length - 1 ? ()=>handleReorderProperty(property.name, "down") : void 0,
+                        depth: depth
+                    }, property.name))
+            }) : /*#__PURE__*/ jsx("div", {
+                className: "text-sm text-muted-foreground italic p-2 text-center border rounded-md",
+                children: t.objectPropertiesNone
+            }),
+            !readOnly && /*#__PURE__*/ jsx("div", {
+                className: "mt-4",
+                children: /*#__PURE__*/ jsx(AddFieldButton, {
+                    onAddField: handleAddProperty,
+                    variant: "secondary"
+                })
+            })
+        ]
+    });
+};
+const types_ObjectEditor = ObjectEditor;
+export { types_ObjectEditor as default };

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

@@ -0,0 +1,542 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { X } from "lucide-react";
+import { useEffect, useId, useMemo, useState } from "react";
+import { Input } from "../../ui/input.js";
+import { Label } from "../../ui/label.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../../ui/select.js";
+import { useTranslation } from "../../../hooks/use-translation.js";
+import { getEligibleEnumControllingProperties } from "../../../lib/schemaEditor.js";
+import { cn } from "../../../lib/utils.js";
+import { isBooleanSchema, withObjectSchema } from "../../../types/jsonSchema.js";
+const StringEditor = ({ schema, validationNode, onChange, readOnly = false, parentSchema, propertyName })=>{
+    const t = useTranslation();
+    const [enumValue, setEnumValue] = useState("");
+    const [dependentEnumValue, setDependentEnumValue] = useState({});
+    const [selectedControllingValue, setSelectedControllingValue] = useState("");
+    const eligibleControllers = useMemo(()=>parentSchema && propertyName ? getEligibleEnumControllingProperties(parentSchema, propertyName) : [], [
+        parentSchema,
+        propertyName
+    ]);
+    const dependentEnum = withObjectSchema(schema, (s)=>s.$dependentEnum, void 0);
+    const enumMode = null != dependentEnum ? "depends" : "static";
+    const controllingProperty = dependentEnum?.property;
+    const dependentValuesMap = dependentEnum?.values ?? {};
+    const currentController = useMemo(()=>eligibleControllers.find((c)=>c.name === controllingProperty), [
+        eligibleControllers,
+        controllingProperty
+    ]);
+    const controllingValues = currentController?.values ?? [];
+    const activeKey = useMemo(()=>{
+        if (0 === controllingValues.length) return "";
+        const first = String(controllingValues[0]);
+        if (selectedControllingValue && controllingValues.some((v)=>String(v) === selectedControllingValue)) return selectedControllingValue;
+        return first;
+    }, [
+        controllingValues,
+        selectedControllingValue
+    ]);
+    useEffect(()=>{
+        if ("depends" === enumMode && controllingValues.length > 0) {
+            const valid = selectedControllingValue && controllingValues.some((v)=>String(v) === selectedControllingValue);
+            if (!valid) setSelectedControllingValue(String(controllingValues[0]));
+        }
+    }, [
+        enumMode,
+        controllingProperty,
+        controllingValues,
+        selectedControllingValue
+    ]);
+    const minLengthId = useId();
+    const maxLengthId = useId();
+    const patternId = useId();
+    const formatId = useId();
+    const minLength = withObjectSchema(schema, (s)=>s.minLength, void 0);
+    const maxLength = withObjectSchema(schema, (s)=>s.maxLength, void 0);
+    const pattern = withObjectSchema(schema, (s)=>s.pattern, void 0);
+    const format = withObjectSchema(schema, (s)=>s.format, void 0);
+    const enumValues = withObjectSchema(schema, (s)=>s.enum || [], []);
+    const baseSchemaForValidation = useMemo(()=>isBooleanSchema(schema) ? {
+            type: "string"
+        } : (()=>{
+            const { enum: _e, $dependentEnum: _d, ...rest } = schema;
+            return {
+                ...rest,
+                type: "string"
+            };
+        })(), [
+        schema
+    ]);
+    const handleValidationChange = (property, value)=>{
+        const updated = {
+            ...baseSchemaForValidation
+        };
+        if ("enum" === property) {
+            updated.enum = value;
+            if ("$dependentEnum" in updated) delete updated.$dependentEnum;
+        } else if ("$dependentEnum" === property) if (null != value) {
+            updated.$dependentEnum = value;
+            if ("enum" in updated) delete updated.enum;
+        } else delete updated.$dependentEnum;
+        else updated[property] = value;
+        onChange(updated);
+    };
+    const handleSetEnumMode = (mode, controllerName)=>{
+        if ("static" === mode) {
+            const rest = {
+                ...baseSchemaForValidation
+            };
+            delete rest.$dependentEnum;
+            onChange({
+                ...rest,
+                type: "string"
+            });
+        } else if (controllerName && eligibleControllers.some((c)=>c.name === controllerName)) {
+            const controller = eligibleControllers.find((c)=>c.name === controllerName);
+            const values = {};
+            for (const v of controller.values){
+                const key = String(v);
+                values[key] = dependentValuesMap[key] ?? [];
+            }
+            handleValidationChange("$dependentEnum", {
+                property: controllerName,
+                values
+            });
+        }
+    };
+    const handleDependentEnumValuesChange = (controllingValue, newList)=>{
+        const prop = dependentEnum?.property;
+        if (!prop) return;
+        const next = {
+            ...dependentValuesMap,
+            [controllingValue]: newList
+        };
+        if (0 === newList.length) {
+            const { [controllingValue]: _, ...rest } = next;
+            if (0 === Object.keys(rest).length) return void handleValidationChange("$dependentEnum", void 0);
+            handleValidationChange("$dependentEnum", {
+                property: prop,
+                values: rest
+            });
+        } else handleValidationChange("$dependentEnum", {
+            property: prop,
+            values: next
+        });
+    };
+    const handleAddEnumValue = ()=>{
+        if (!enumValue.trim()) return;
+        if (!enumValues.includes(enumValue)) handleValidationChange("enum", [
+            ...enumValues,
+            enumValue
+        ]);
+        setEnumValue("");
+    };
+    const handleRemoveEnumValue = (index)=>{
+        const newEnumValues = [
+            ...enumValues
+        ];
+        newEnumValues.splice(index, 1);
+        if (0 === newEnumValues.length) {
+            const baseSchema = isBooleanSchema(schema) ? {
+                type: "string"
+            } : {
+                ...schema
+            };
+            if (!isBooleanSchema(baseSchema) && "enum" in baseSchema) {
+                const { enum: _, ...rest } = baseSchema;
+                onChange(rest);
+            } else onChange(baseSchema);
+        } else handleValidationChange("enum", newEnumValues);
+    };
+    const minMaxError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"length" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const minLengthError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"minLength" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const maxLengthError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"maxLength" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const patternError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"pattern" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const formatError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"format" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const minLengthValue = minLength ?? "";
+    const maxLengthValue = maxLength ?? "";
+    const patternValue = pattern ?? "";
+    const formatValue = format || "none";
+    const needsDetail = !readOnly || "" !== minLengthValue || "" !== maxLengthValue || "" !== patternValue || "none" !== formatValue || enumValues.length > 0 || null != dependentEnum && Object.keys(dependentValuesMap).length > 0;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "space-y-4",
+        children: [
+            /*#__PURE__*/ jsxs("div", {
+                className: "grid grid-cols-1 md:grid-cols-2 gap-4 items-start",
+                children: [
+                    readOnly && !needsDetail && /*#__PURE__*/ jsx("p", {
+                        className: "text-sm text-muted-foreground italic",
+                        children: t.stringNoConstraint
+                    }),
+                    (!readOnly || "" !== minLengthValue) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: minLengthId,
+                                className: (!!minMaxError || !!minLengthError) && "text-destructive",
+                                children: t.stringMinimumLengthLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: minLengthId,
+                                type: "number",
+                                min: 0,
+                                value: minLengthValue,
+                                disabled: readOnly,
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("minLength", value);
+                                },
+                                placeholder: t.stringMinimumLengthPlaceholder,
+                                className: cn("h-8", (!!minMaxError || !!minLengthError) && "border-destructive")
+                            })
+                        ]
+                    }),
+                    (!readOnly || "" !== maxLengthValue) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: maxLengthId,
+                                className: (!!minMaxError || !!maxLengthError) && "text-destructive",
+                                children: t.stringMaximumLengthLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: maxLengthId,
+                                type: "number",
+                                min: 0,
+                                disabled: readOnly,
+                                value: maxLengthValue,
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("maxLength", value);
+                                },
+                                placeholder: t.stringMaximumLengthPlaceholder,
+                                className: cn("h-8", (!!minMaxError || !!maxLengthError) && "border-destructive")
+                            })
+                        ]
+                    }),
+                    (!!minMaxError || !!minLengthError || !!maxLengthError) && /*#__PURE__*/ jsx("div", {
+                        className: "text-xs text-destructive italic md:col-span-2 whitespace-pre-line",
+                        children: [
+                            minMaxError,
+                            minLengthError ?? maxLengthError
+                        ].filter(Boolean).join("\n")
+                    })
+                ]
+            }),
+            (!readOnly || "" !== patternValue) && /*#__PURE__*/ jsxs("div", {
+                className: "space-y-2",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        htmlFor: patternId,
+                        className: !!patternError && "text-destructive",
+                        children: t.stringPatternLabel
+                    }),
+                    /*#__PURE__*/ jsx(Input, {
+                        id: patternId,
+                        type: "text",
+                        value: patternValue,
+                        onChange: (e)=>{
+                            const value = e.target.value || void 0;
+                            handleValidationChange("pattern", value);
+                        },
+                        placeholder: t.stringPatternPlaceholder,
+                        className: "h-8"
+                    })
+                ]
+            }),
+            (!readOnly || "none" !== formatValue) && /*#__PURE__*/ jsxs("div", {
+                className: "space-y-2",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        htmlFor: formatId,
+                        className: !!formatError && "text-destructive",
+                        children: t.stringFormatLabel
+                    }),
+                    /*#__PURE__*/ jsxs(Select, {
+                        value: formatValue,
+                        onValueChange: (value)=>{
+                            handleValidationChange("format", "none" === value ? void 0 : value);
+                        },
+                        children: [
+                            /*#__PURE__*/ jsx(SelectTrigger, {
+                                id: formatId,
+                                className: "h-8",
+                                children: /*#__PURE__*/ jsx(SelectValue, {
+                                    placeholder: t.stringFormatSelectPlaceholder
+                                })
+                            }),
+                            /*#__PURE__*/ jsxs(SelectContent, {
+                                children: [
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "none",
+                                        children: t.stringFormatNone
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "date-time",
+                                        children: t.stringFormatDateTime
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "date",
+                                        children: t.stringFormatDate
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "time",
+                                        children: t.stringFormatTime
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "email",
+                                        children: t.stringFormatEmail
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "uri",
+                                        children: t.stringFormatUri
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "uuid",
+                                        children: t.stringFormatUuid
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "hostname",
+                                        children: t.stringFormatHostname
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "ipv4",
+                                        children: t.stringFormatIpv4
+                                    }),
+                                    /*#__PURE__*/ jsx(SelectItem, {
+                                        value: "ipv6",
+                                        children: t.stringFormatIpv6
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            }),
+            (!readOnly || enumValues.length > 0 || null != dependentEnum) && /*#__PURE__*/ jsxs("div", {
+                className: "space-y-2 pt-2 border-t border-border/40",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        children: t.stringAllowedValuesEnumLabel
+                    }),
+                    eligibleControllers.length > 0 && !readOnly && /*#__PURE__*/ jsxs("div", {
+                        className: "flex flex-wrap items-center gap-2 mb-2",
+                        children: [
+                            /*#__PURE__*/ jsxs(Label, {
+                                className: "text-xs text-muted-foreground",
+                                children: [
+                                    t.enumModeDependsOn,
+                                    ":"
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(Select, {
+                                value: "depends" === enumMode ? controllingProperty ?? "" : "__static__",
+                                onValueChange: (v)=>{
+                                    "__static__" === v ? handleSetEnumMode("static") : handleSetEnumMode("depends", v);
+                                },
+                                children: [
+                                    /*#__PURE__*/ jsx(SelectTrigger, {
+                                        className: "h-8 w-[180px]",
+                                        children: /*#__PURE__*/ jsx(SelectValue, {
+                                            placeholder: t.enumDependsOnPlaceholder
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsxs(SelectContent, {
+                                        children: [
+                                            /*#__PURE__*/ jsx(SelectItem, {
+                                                value: "__static__",
+                                                children: t.enumModeStatic
+                                            }),
+                                            eligibleControllers.map((c)=>/*#__PURE__*/ jsx(SelectItem, {
+                                                    value: c.name,
+                                                    children: c.name
+                                                }, c.name))
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    "static" === enumMode && /*#__PURE__*/ jsxs(Fragment, {
+                        children: [
+                            /*#__PURE__*/ jsx("div", {
+                                className: "flex flex-wrap gap-2 mb-4",
+                                children: enumValues.length > 0 ? enumValues.map((value)=>/*#__PURE__*/ jsxs("div", {
+                                        className: "flex items-center bg-muted/40 border rounded-md px-2 py-1 text-xs",
+                                        children: [
+                                            /*#__PURE__*/ jsx("span", {
+                                                className: "mr-1",
+                                                children: value
+                                            }),
+                                            !readOnly && /*#__PURE__*/ jsx("button", {
+                                                type: "button",
+                                                onClick: ()=>handleRemoveEnumValue(enumValues.indexOf(value)),
+                                                className: "text-muted-foreground hover:text-destructive",
+                                                children: /*#__PURE__*/ jsx(X, {
+                                                    size: 12
+                                                })
+                                            })
+                                        ]
+                                    }, `enum-string-${value}`)) : /*#__PURE__*/ jsx("p", {
+                                    className: "text-xs text-muted-foreground italic",
+                                    children: t.stringAllowedValuesEnumNone
+                                })
+                            }),
+                            !readOnly && /*#__PURE__*/ jsxs("div", {
+                                className: "flex items-center gap-2",
+                                children: [
+                                    /*#__PURE__*/ jsx(Input, {
+                                        type: "text",
+                                        value: enumValue,
+                                        onChange: (e)=>setEnumValue(e.target.value),
+                                        placeholder: t.stringAllowedValuesEnumAddPlaceholder,
+                                        className: "h-8 text-xs flex-1",
+                                        onKeyDown: (e)=>"Enter" === e.key && handleAddEnumValue()
+                                    }),
+                                    /*#__PURE__*/ jsx("button", {
+                                        type: "button",
+                                        onClick: handleAddEnumValue,
+                                        className: "px-3 py-1 h-8 rounded-md bg-secondary text-xs font-medium hover:bg-secondary/80",
+                                        children: t.stringAllowedValuesEnumAddLabel
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    "depends" === enumMode && controllingProperty && currentController && controllingValues.length > 0 && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-3",
+                        children: [
+                            /*#__PURE__*/ jsxs("div", {
+                                className: "flex flex-wrap items-center gap-2",
+                                children: [
+                                    /*#__PURE__*/ jsx(Label, {
+                                        className: "text-xs text-muted-foreground",
+                                        children: t.whenPropertyEquals.replace("{property}", controllingProperty).replace("{value}", "")
+                                    }),
+                                    /*#__PURE__*/ jsxs(Select, {
+                                        value: activeKey || void 0,
+                                        onValueChange: (value)=>setSelectedControllingValue(value ?? ""),
+                                        children: [
+                                            /*#__PURE__*/ jsx(SelectTrigger, {
+                                                className: "h-8 w-[160px] text-xs",
+                                                children: /*#__PURE__*/ jsx(SelectValue, {
+                                                    placeholder: t.whenPropertyEquals.replace("{property}", controllingProperty).replace("{value}", "")
+                                                })
+                                            }),
+                                            /*#__PURE__*/ jsx(SelectContent, {
+                                                children: controllingValues.map((v)=>/*#__PURE__*/ jsx(SelectItem, {
+                                                        value: String(v),
+                                                        children: String(v)
+                                                    }, String(v)))
+                                            })
+                                        ]
+                                    })
+                                ]
+                            }),
+                            activeKey && /*#__PURE__*/ jsxs("div", {
+                                className: "space-y-1",
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "text-xs font-medium text-muted-foreground",
+                                        children: t.whenPropertyEquals.replace("{property}", controllingProperty).replace("{value}", activeKey)
+                                    }),
+                                    /*#__PURE__*/ jsxs("div", {
+                                        className: "flex flex-wrap gap-2",
+                                        children: [
+                                            (dependentValuesMap[activeKey] ?? []).map((v)=>/*#__PURE__*/ jsxs("div", {
+                                                    className: "flex items-center bg-muted/40 border rounded-md px-2 py-1 text-xs",
+                                                    children: [
+                                                        /*#__PURE__*/ jsx("span", {
+                                                            className: "mr-1",
+                                                            children: v
+                                                        }),
+                                                        !readOnly && /*#__PURE__*/ jsx("button", {
+                                                            type: "button",
+                                                            onClick: ()=>{
+                                                                const list = dependentValuesMap[activeKey] ?? [];
+                                                                const next = list.filter((x)=>x !== v);
+                                                                handleDependentEnumValuesChange(activeKey, next);
+                                                            },
+                                                            className: "text-muted-foreground hover:text-destructive",
+                                                            children: /*#__PURE__*/ jsx(X, {
+                                                                size: 12
+                                                            })
+                                                        })
+                                                    ]
+                                                }, v)),
+                                            0 === (dependentValuesMap[activeKey] ?? []).length && readOnly && /*#__PURE__*/ jsx("p", {
+                                                className: "text-xs text-muted-foreground italic",
+                                                children: t.stringAllowedValuesEnumNone
+                                            })
+                                        ]
+                                    }),
+                                    !readOnly && /*#__PURE__*/ jsxs("div", {
+                                        className: "flex items-center gap-2",
+                                        children: [
+                                            /*#__PURE__*/ jsx(Input, {
+                                                type: "text",
+                                                value: dependentEnumValue[activeKey] ?? "",
+                                                onChange: (e)=>setDependentEnumValue((prev)=>({
+                                                            ...prev,
+                                                            [activeKey]: e.target.value
+                                                        })),
+                                                placeholder: t.stringAllowedValuesEnumAddPlaceholder,
+                                                className: "h-8 text-xs flex-1",
+                                                onKeyDown: (e)=>{
+                                                    if ("Enter" === e.key) {
+                                                        const list = dependentValuesMap[activeKey] ?? [];
+                                                        const val = (dependentEnumValue[activeKey] ?? "").trim();
+                                                        if (val && !list.includes(val)) {
+                                                            handleDependentEnumValuesChange(activeKey, [
+                                                                ...list,
+                                                                val
+                                                            ]);
+                                                            setDependentEnumValue((prev)=>({
+                                                                    ...prev,
+                                                                    [activeKey]: ""
+                                                                }));
+                                                        }
+                                                    }
+                                                }
+                                            }),
+                                            /*#__PURE__*/ jsx("button", {
+                                                type: "button",
+                                                onClick: ()=>{
+                                                    const list = dependentValuesMap[activeKey] ?? [];
+                                                    const val = (dependentEnumValue[activeKey] ?? "").trim();
+                                                    if (val && !list.includes(val)) {
+                                                        handleDependentEnumValuesChange(activeKey, [
+                                                            ...list,
+                                                            val
+                                                        ]);
+                                                        setDependentEnumValue((prev)=>({
+                                                                ...prev,
+                                                                [activeKey]: ""
+                                                            }));
+                                                    }
+                                                },
+                                                className: "px-3 py-1 h-8 rounded-md bg-secondary text-xs font-medium hover:bg-secondary/80",
+                                                children: t.stringAllowedValuesEnumAddLabel
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+const types_StringEditor = StringEditor;
+export { types_StringEditor as default };