@datenlotse/jsonjoy-builder 0.4.0

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

@@ -0,0 +1,583 @@
+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 NumberEditor = ({ schema, validationNode, onChange, integer = false, readOnly = false, parentSchema, propertyName })=>{
+    const [enumValue, setEnumValue] = useState("");
+    const [dependentEnumValue, setDependentEnumValue] = useState({});
+    const [selectedControllingValue, setSelectedControllingValue] = useState("");
+    const t = useTranslation();
+    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 maximumId = useId();
+    const minimumId = useId();
+    const exclusiveMinimumId = useId();
+    const exclusiveMaximumId = useId();
+    const multipleOfId = useId();
+    const minimum = withObjectSchema(schema, (s)=>s.minimum, void 0);
+    const maximum = withObjectSchema(schema, (s)=>s.maximum, void 0);
+    const exclusiveMinimum = withObjectSchema(schema, (s)=>s.exclusiveMinimum, void 0);
+    const exclusiveMaximum = withObjectSchema(schema, (s)=>s.exclusiveMaximum, void 0);
+    const multipleOf = withObjectSchema(schema, (s)=>s.multipleOf, void 0);
+    const enumValues = withObjectSchema(schema, (s)=>s.enum || [], []);
+    const basePropertiesForValidation = useMemo(()=>{
+        const base = {
+            type: integer ? "integer" : "number"
+        };
+        if (!isBooleanSchema(schema)) {
+            if (void 0 !== schema.minimum) base.minimum = schema.minimum;
+            if (void 0 !== schema.maximum) base.maximum = schema.maximum;
+            if (void 0 !== schema.exclusiveMinimum) base.exclusiveMinimum = schema.exclusiveMinimum;
+            if (void 0 !== schema.exclusiveMaximum) base.exclusiveMaximum = schema.exclusiveMaximum;
+            if (void 0 !== schema.multipleOf) base.multipleOf = schema.multipleOf;
+            if (void 0 !== schema.enum) base.enum = schema.enum;
+            if (void 0 !== schema.$dependentEnum) base.$dependentEnum = schema.$dependentEnum;
+        }
+        return base;
+    }, [
+        schema,
+        integer
+    ]);
+    const handleValidationChange = (property, value)=>{
+        const baseProperties = {
+            ...basePropertiesForValidation
+        };
+        if ("$dependentEnum" === property) {
+            if (null != value) {
+                baseProperties.$dependentEnum = value;
+                delete baseProperties.enum;
+            } else delete baseProperties.$dependentEnum;
+            onChange(baseProperties);
+            return;
+        }
+        if ("enum" === property) delete baseProperties.$dependentEnum;
+        if (void 0 !== value) {
+            if ("minimum" === property) baseProperties.minimum = value;
+            else if ("maximum" === property) baseProperties.maximum = value;
+            else if ("exclusiveMinimum" === property) baseProperties.exclusiveMinimum = value;
+            else if ("exclusiveMaximum" === property) baseProperties.exclusiveMaximum = value;
+            else if ("multipleOf" === property) baseProperties.multipleOf = value;
+            else if ("enum" === property) baseProperties.enum = value;
+            onChange(baseProperties);
+            return;
+        }
+        if ("minimum" === property) {
+            const { minimum: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        if ("maximum" === property) {
+            const { maximum: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        if ("exclusiveMinimum" === property) {
+            const { exclusiveMinimum: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        if ("exclusiveMaximum" === property) {
+            const { exclusiveMaximum: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        if ("multipleOf" === property) {
+            const { multipleOf: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        if ("enum" === property) {
+            const { enum: _, ...rest } = baseProperties;
+            onChange(rest);
+            return;
+        }
+        onChange(baseProperties);
+    };
+    const handleSetEnumMode = (mode, controllerName)=>{
+        if ("static" === mode) {
+            const { $dependentEnum: _, ...rest } = basePropertiesForValidation;
+            onChange({
+                ...rest,
+                type: integer ? "integer" : "number"
+            });
+        } 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] ?? []).slice();
+            }
+            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;
+        const numValue = Number(enumValue);
+        if (Number.isNaN(numValue)) return;
+        const validValue = integer ? Math.floor(numValue) : numValue;
+        if (!enumValues.includes(validValue)) handleValidationChange("enum", [
+            ...enumValues,
+            validValue
+        ]);
+        setEnumValue("");
+    };
+    const handleRemoveEnumValue = (index)=>{
+        const newEnumValues = [
+            ...enumValues
+        ];
+        newEnumValues.splice(index, 1);
+        0 === newEnumValues.length ? handleValidationChange("enum", void 0) : handleValidationChange("enum", newEnumValues);
+    };
+    const minMaxError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"minMax" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const redundantMinError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"redundantMinimum" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const redundantMaxError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"redundantMaximum" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const enumError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"enum" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const multipleOfError = useMemo(()=>validationNode?.validation.errors?.find((err)=>"multipleOf" === err.path[0])?.message, [
+        validationNode
+    ]);
+    const hasConstraint = !!minimum || !!maximum || !!exclusiveMinimum || !!exclusiveMaximum || !!multipleOf || enumValues.length > 0 || null != dependentEnum && Object.keys(dependentValuesMap).length > 0;
+    return /*#__PURE__*/ jsxs("div", {
+        className: "space-y-4",
+        children: [
+            readOnly && !hasConstraint && /*#__PURE__*/ jsx("p", {
+                className: "text-sm text-muted-foreground italic",
+                children: t.numberNoConstraint
+            }),
+            (!readOnly || hasConstraint) && /*#__PURE__*/ jsxs("div", {
+                className: "grid grid-cols-1 md:grid-cols-2 gap-4",
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-0 md:col-span-2",
+                        children: [
+                            !!minMaxError && /*#__PURE__*/ jsx("div", {
+                                className: "text-xs text-destructive italic",
+                                children: minMaxError
+                            }),
+                            !!redundantMinError && /*#__PURE__*/ jsx("div", {
+                                className: "text-xs text-destructive italic",
+                                children: redundantMinError
+                            }),
+                            !!redundantMaxError && /*#__PURE__*/ jsx("div", {
+                                className: "text-xs text-destructive italic",
+                                children: redundantMaxError
+                            }),
+                            !!enumError && /*#__PURE__*/ jsx("div", {
+                                className: "text-xs text-destructive italic",
+                                children: enumError
+                            })
+                        ]
+                    }),
+                    (!readOnly || !!minimum) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: minimumId,
+                                className: void 0 !== minimum && (!!minMaxError || !!redundantMinError) && "text-destructive",
+                                children: t.numberMinimumLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: minimumId,
+                                type: "number",
+                                value: void 0 !== minimum ? minimum : "",
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("minimum", value);
+                                },
+                                placeholder: t.numberMinimumPlaceholder,
+                                className: cn("h-8", void 0 !== minimum && (!!minMaxError || !!redundantMinError) && "border-destructive"),
+                                step: integer ? 1 : "any"
+                            })
+                        ]
+                    }),
+                    (!readOnly || !!maximum) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: maximumId,
+                                className: void 0 !== maximum && (!!minMaxError || !!redundantMaxError) && "text-destructive",
+                                children: t.numberMaximumLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: maximumId,
+                                type: "number",
+                                value: maximum ?? "",
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("maximum", value);
+                                },
+                                placeholder: t.numberMaximumPlaceholder,
+                                className: cn("h-8", void 0 !== maximum && (!!minMaxError || !!redundantMaxError) && "border-destructive"),
+                                step: integer ? 1 : "any"
+                            })
+                        ]
+                    })
+                ]
+            }),
+            (!readOnly || !!exclusiveMaximum || !!exclusiveMinimum) && /*#__PURE__*/ jsxs("div", {
+                className: "grid grid-cols-1 md:grid-cols-2 gap-4",
+                children: [
+                    (!readOnly || !!exclusiveMinimum) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: exclusiveMinimumId,
+                                className: void 0 !== exclusiveMinimum && (!!minMaxError || !!redundantMinError) && "text-destructive",
+                                children: t.numberExclusiveMinimumLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: exclusiveMinimumId,
+                                type: "number",
+                                value: exclusiveMinimum ?? "",
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("exclusiveMinimum", value);
+                                },
+                                placeholder: t.numberExclusiveMinimumPlaceholder,
+                                className: cn("h-8", void 0 !== exclusiveMinimum && (!!minMaxError || !!redundantMinError) && "border-destructive"),
+                                step: integer ? 1 : "any"
+                            })
+                        ]
+                    }),
+                    (!readOnly || !!exclusiveMaximum) && /*#__PURE__*/ jsxs("div", {
+                        className: "space-y-2",
+                        children: [
+                            /*#__PURE__*/ jsx(Label, {
+                                htmlFor: exclusiveMaximumId,
+                                className: void 0 !== exclusiveMaximum && (!!minMaxError || !!redundantMaxError) && "text-destructive",
+                                children: t.numberExclusiveMaximumLabel
+                            }),
+                            /*#__PURE__*/ jsx(Input, {
+                                id: exclusiveMaximumId,
+                                type: "number",
+                                value: exclusiveMaximum ?? "",
+                                onChange: (e)=>{
+                                    const value = e.target.value ? Number(e.target.value) : void 0;
+                                    handleValidationChange("exclusiveMaximum", value);
+                                },
+                                placeholder: t.numberExclusiveMaximumPlaceholder,
+                                className: cn("h-8", void 0 !== exclusiveMaximum && (!!minMaxError || !!redundantMaxError) && "border-destructive"),
+                                step: integer ? 1 : "any"
+                            })
+                        ]
+                    })
+                ]
+            }),
+            (!readOnly || !!multipleOf) && /*#__PURE__*/ jsxs("div", {
+                className: "space-y-2",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        htmlFor: multipleOfId,
+                        className: !!multipleOfError && "text-destructive",
+                        children: t.numberMultipleOfLabel
+                    }),
+                    /*#__PURE__*/ jsx(Input, {
+                        id: multipleOfId,
+                        type: "number",
+                        value: multipleOf ?? "",
+                        onChange: (e)=>{
+                            const value = e.target.value ? Number(e.target.value) : void 0;
+                            handleValidationChange("multipleOf", value);
+                        },
+                        placeholder: t.numberMultipleOfPlaceholder,
+                        className: cn("h-8", !!multipleOfError && "border-destructive"),
+                        min: 0,
+                        step: integer ? 1 : "any"
+                    }),
+                    !!multipleOfError && /*#__PURE__*/ jsx("div", {
+                        className: "text-xs text-destructive italic whitespace-pre-line",
+                        children: multipleOfError
+                    })
+                ]
+            }),
+            (!readOnly || enumValues.length > 0 || null != dependentEnum) && /*#__PURE__*/ jsxs("div", {
+                className: "space-y-2 pt-2 border-t border-border/40",
+                children: [
+                    /*#__PURE__*/ jsx(Label, {
+                        className: !!enumError && "text-destructive",
+                        children: t.numberAllowedValuesEnumLabel
+                    }),
+                    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, index)=>/*#__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(index),
+                                                className: "text-muted-foreground hover:text-destructive",
+                                                children: /*#__PURE__*/ jsx(X, {
+                                                    size: 12
+                                                })
+                                            })
+                                        ]
+                                    }, `enum-number-${value}`)) : /*#__PURE__*/ jsx("p", {
+                                    className: "text-xs text-muted-foreground italic",
+                                    children: t.numberAllowedValuesEnumNone
+                                })
+                            }),
+                            !readOnly && /*#__PURE__*/ jsxs("div", {
+                                className: "flex items-center gap-2",
+                                children: [
+                                    /*#__PURE__*/ jsx(Input, {
+                                        type: "number",
+                                        value: enumValue,
+                                        onChange: (e)=>setEnumValue(e.target.value),
+                                        placeholder: t.numberAllowedValuesEnumAddPlaceholder,
+                                        className: "h-8 text-xs flex-1",
+                                        onKeyDown: (e)=>"Enter" === e.key && handleAddEnumValue(),
+                                        step: integer ? 1 : "any"
+                                    }),
+                                    /*#__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.numberAllowedValuesEnumAddLabel
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    "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.numberAllowedValuesEnumNone
+                                            })
+                                        ]
+                                    }),
+                                    !readOnly && /*#__PURE__*/ jsxs("div", {
+                                        className: "flex items-center gap-2",
+                                        children: [
+                                            /*#__PURE__*/ jsx(Input, {
+                                                type: "number",
+                                                value: dependentEnumValue[activeKey] ?? "",
+                                                onChange: (e)=>setDependentEnumValue((prev)=>({
+                                                            ...prev,
+                                                            [activeKey]: e.target.value
+                                                        })),
+                                                placeholder: t.numberAllowedValuesEnumAddPlaceholder,
+                                                className: "h-8 text-xs flex-1",
+                                                step: integer ? 1 : "any",
+                                                onKeyDown: (e)=>{
+                                                    if ("Enter" === e.key) {
+                                                        const list = dependentValuesMap[activeKey] ?? [];
+                                                        const raw = (dependentEnumValue[activeKey] ?? "").trim();
+                                                        const num = Number(raw);
+                                                        if ("" !== raw && !Number.isNaN(num) && !list.includes(integer ? Math.floor(num) : num)) {
+                                                            const valid = integer ? Math.floor(num) : num;
+                                                            handleDependentEnumValuesChange(activeKey, [
+                                                                ...list,
+                                                                valid
+                                                            ]);
+                                                            setDependentEnumValue((prev)=>({
+                                                                    ...prev,
+                                                                    [activeKey]: ""
+                                                                }));
+                                                        }
+                                                    }
+                                                }
+                                            }),
+                                            /*#__PURE__*/ jsx("button", {
+                                                type: "button",
+                                                onClick: ()=>{
+                                                    const list = dependentValuesMap[activeKey] ?? [];
+                                                    const raw = (dependentEnumValue[activeKey] ?? "").trim();
+                                                    const num = Number(raw);
+                                                    if ("" !== raw && !Number.isNaN(num) && !list.includes(integer ? Math.floor(num) : num)) {
+                                                        const valid = integer ? Math.floor(num) : num;
+                                                        handleDependentEnumValuesChange(activeKey, [
+                                                            ...list,
+                                                            valid
+                                                        ]);
+                                                        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.numberAllowedValuesEnumAddLabel
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+const types_NumberEditor = NumberEditor;
+export { types_NumberEditor as default };