@datenlotse/jsonjoy-builder 0.4.0

package/dist/components/ui/tooltip.js

@@ -0,0 +1,15 @@
+import { jsx } from "react/jsx-runtime";
+import { Content, Provider, Root, Trigger } from "@radix-ui/react-tooltip";
+import { forwardRef } from "react";
+import { cn } from "../../lib/utils.js";
+const TooltipProvider = Provider;
+const Tooltip = Root;
+const TooltipTrigger = Trigger;
+const TooltipContent = /*#__PURE__*/ forwardRef(({ className, sideOffset = 4, ...props }, ref)=>/*#__PURE__*/ jsx(Content, {
+        ref: ref,
+        sideOffset: sideOffset,
+        className: cn("z-50 overflow-hidden rounded-md border bg-popover px-3 py-1.5 text-sm text-popover-foreground shadow-md animate-in fade-in-0 zoom-in-95 data-[state=closed]:animate-out data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2", className),
+        ...props
+    }));
+TooltipContent.displayName = Content.displayName;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };

package/dist/hooks/use-monaco-theme.js

@@ -0,0 +1,197 @@
+import { json } from "monaco-editor";
+import { useEffect, useState } from "react";
+const defaultEditorOptions = {
+    minimap: {
+        enabled: false
+    },
+    fontSize: 14,
+    fontFamily: "var(--font-sans), 'SF Mono', Monaco, Menlo, Consolas, monospace",
+    lineNumbers: "on",
+    roundedSelection: false,
+    scrollBeyondLastLine: false,
+    readOnly: false,
+    automaticLayout: true,
+    formatOnPaste: true,
+    formatOnType: true,
+    tabSize: 2,
+    insertSpaces: true,
+    detectIndentation: true,
+    folding: true,
+    foldingStrategy: "indentation",
+    renderLineHighlight: "all",
+    matchBrackets: "always",
+    autoClosingBrackets: "always",
+    autoClosingQuotes: "always",
+    guides: {
+        bracketPairs: true,
+        indentation: true
+    }
+};
+function useMonacoTheme() {
+    const [isDarkMode, setIsDarkMode] = useState(false);
+    useEffect(()=>{
+        const checkDarkMode = ()=>{
+            const backgroundColor = getComputedStyle(document.documentElement).getPropertyValue("--background").trim();
+            const isDark = backgroundColor.includes("222.2") || backgroundColor.includes("84% 4.9%");
+            setIsDarkMode(isDark);
+        };
+        checkDarkMode();
+        const observer = new MutationObserver(checkDarkMode);
+        observer.observe(document.documentElement, {
+            attributes: true,
+            attributeFilter: [
+                "class",
+                "style"
+            ]
+        });
+        return ()=>observer.disconnect();
+    }, []);
+    const defineMonacoThemes = (monaco)=>{
+        monaco.editor.defineTheme("appLightTheme", {
+            base: "vs",
+            inherit: true,
+            rules: [
+                {
+                    token: "string",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "number",
+                    foreground: "A855F7"
+                },
+                {
+                    token: "keyword",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "delimiter",
+                    foreground: "0F172A"
+                },
+                {
+                    token: "keyword.json",
+                    foreground: "A855F7"
+                },
+                {
+                    token: "string.key.json",
+                    foreground: "2563EB"
+                },
+                {
+                    token: "string.value.json",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "boolean",
+                    foreground: "22C55E"
+                },
+                {
+                    token: "null",
+                    foreground: "64748B"
+                }
+            ],
+            colors: {
+                "editor.background": "#f8fafc",
+                "editor.foreground": "#0f172a",
+                "editorCursor.foreground": "#0f172a",
+                "editor.lineHighlightBackground": "#f1f5f9",
+                "editorLineNumber.foreground": "#64748b",
+                "editor.selectionBackground": "#e2e8f0",
+                "editor.inactiveSelectionBackground": "#e2e8f0",
+                "editorIndentGuide.background": "#e2e8f0",
+                "editor.findMatchBackground": "#cbd5e1",
+                "editor.findMatchHighlightBackground": "#cbd5e133"
+            }
+        });
+        monaco.editor.defineTheme("appDarkTheme", {
+            base: "vs-dark",
+            inherit: true,
+            rules: [
+                {
+                    token: "string",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "number",
+                    foreground: "A855F7"
+                },
+                {
+                    token: "keyword",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "delimiter",
+                    foreground: "F8FAFC"
+                },
+                {
+                    token: "keyword.json",
+                    foreground: "A855F7"
+                },
+                {
+                    token: "string.key.json",
+                    foreground: "60A5FA"
+                },
+                {
+                    token: "string.value.json",
+                    foreground: "3B82F6"
+                },
+                {
+                    token: "boolean",
+                    foreground: "22C55E"
+                },
+                {
+                    token: "null",
+                    foreground: "94A3B8"
+                }
+            ],
+            colors: {
+                "editor.background": "#0f172a",
+                "editor.foreground": "#f8fafc",
+                "editorCursor.foreground": "#f8fafc",
+                "editor.lineHighlightBackground": "#1e293b",
+                "editorLineNumber.foreground": "#64748b",
+                "editor.selectionBackground": "#334155",
+                "editor.inactiveSelectionBackground": "#334155",
+                "editorIndentGuide.background": "#1e293b",
+                "editor.findMatchBackground": "#475569",
+                "editor.findMatchHighlightBackground": "#47556933"
+            }
+        });
+    };
+    const configureJsonDefaults = (_monaco, schema)=>{
+        const diagnosticsOptions = {
+            validate: true,
+            allowComments: false,
+            schemaValidation: "error",
+            enableSchemaRequest: true,
+            schemas: schema ? [
+                {
+                    uri: "object" == typeof schema && schema.$id ? schema.$id : "https://jsonjoy-builder/schema",
+                    fileMatch: [
+                        "*"
+                    ],
+                    schema
+                }
+            ] : [
+                {
+                    uri: "http://json-schema.org/draft-07/schema",
+                    fileMatch: [
+                        "*"
+                    ],
+                    schema: {
+                        $schema: "http://json-schema.org/draft-07/schema",
+                        type: "object",
+                        additionalProperties: true
+                    }
+                }
+            ]
+        };
+        json.jsonDefaults.setDiagnosticsOptions(diagnosticsOptions);
+    };
+    return {
+        isDarkMode,
+        currentTheme: isDarkMode ? "appDarkTheme" : "appLightTheme",
+        defineMonacoThemes,
+        configureJsonDefaults,
+        defaultEditorOptions
+    };
+}
+export { defaultEditorOptions, useMonacoTheme };

package/dist/hooks/use-translation.js

@@ -0,0 +1,14 @@
+import { useContext } from "react";
+import { en } from "../i18n/locales/en.js";
+import { TranslationContext } from "../i18n/translation-context.js";
+function useTranslation() {
+    const translation = useContext(TranslationContext);
+    return translation ?? en;
+}
+function formatTranslation(template, values) {
+    return template.replace(/\{(\w+)\}/g, (_, key)=>{
+        const value = values[key];
+        return void 0 !== value ? String(value) : `{${key}}`;
+    });
+}
+export { formatTranslation, useTranslation };

package/dist/i18n/locales/de.js

@@ -0,0 +1,143 @@
+const de = {
+    collapse: "Einklappen",
+    expand: "Ausklappen",
+    fieldDescriptionPlaceholder: "Zweck dieses Felds beschreiben",
+    fieldDelete: "Feld löschen",
+    fieldDescription: "Beschreibung",
+    fieldDescriptionTooltip: "Kontext zur Bedeutung dieses Felds hinzufügen",
+    fieldNameLabel: "Feldname",
+    fieldNamePlaceholder: "z.B. firstName, age, isActive",
+    fieldNameTooltip: "CamelCase für bessere Lesbarkeit verwenden (z.B. firstName)",
+    fieldRequiredLabel: "Pflichtfeld",
+    fieldType: "Feldart",
+    fieldTypeExample: "Beispiel:",
+    fieldTypeTooltipString: "string: Text",
+    fieldTypeTooltipNumber: "number: Zahl",
+    fieldTypeTooltipBoolean: "boolean: Wahr/Falsch",
+    fieldTypeTooltipObject: "object: Verschachteltes JSON",
+    fieldTypeTooltipArray: "array: Liste von Werten",
+    fieldAddNewButton: "Feld hinzufügen",
+    fieldAddNewBadge: "Schema-Builder",
+    fieldAddNewCancel: "Abbrechen",
+    fieldAddNewConfirm: "Feld hinzufügen",
+    fieldAddNewDescription: "Neues Feld für das JSON-Schema erstellen",
+    fieldAddNewLabel: "Neues Feld hinzufügen",
+    fieldTypeTextLabel: "Text",
+    fieldTypeTextDescription: "Für Textwerte wie Namen, Beschreibungen usw.",
+    fieldTypeNumberLabel: "Zahl",
+    fieldTypeNumberDescription: "Für Dezimal- oder Ganzzahlen",
+    fieldTypeBooleanLabel: "Ja/Nein",
+    fieldTypeBooleanDescription: "Für Wahr/Falsch-Werte",
+    fieldTypeObjectLabel: "Gruppe",
+    fieldTypeObjectDescription: "Zum Gruppieren verwandter Felder",
+    fieldTypeArrayLabel: "Liste",
+    fieldTypeArrayDescription: "Für Sammlungen von Elementen",
+    propertyDescriptionPlaceholder: "Beschreibung hinzufügen...",
+    propertyDescriptionButton: "Beschreibung hinzufügen...",
+    propertyRequired: "Erforderlich",
+    propertyOptional: "Optional",
+    propertyDelete: "Feld löschen",
+    propertyMoveUp: "Feld nach oben verschieben",
+    propertyMoveDown: "Feld nach unten verschieben",
+    propertyDefaultLabel: "Standardwert",
+    propertyDefaultPlaceholder: "Standardwert eingeben...",
+    schemaEditorTitle: "JSON-Schema-Editor",
+    schemaEditorToggleFullscreen: "Vollbild umschalten",
+    schemaEditorEditModeVisual: "Visuell",
+    schemaEditorEditModeJson: "JSON",
+    schemaEditorLoading: "Editor wird geladen...",
+    arrayNoConstraint: "Keine Einschränkung",
+    arrayMinimumLabel: "Mindestanzahl an Elementen",
+    arrayMinimumPlaceholder: "Kein Minimum",
+    arrayMaximumLabel: "Maximale Anzahl an Elemente",
+    arrayMaximumPlaceholder: "Kein Maximum",
+    arrayForceUniqueItemsLabel: "Nur eindeutige Elemente erlauben",
+    arrayItemTypeLabel: "Elementtyp",
+    arrayValidationErrorMinMax: "'minItems' darf nicht größer als 'maxItems' sein.",
+    arrayValidationErrorContainsMinMax: "'minContains' darf nicht größer als 'maxContains' sein.",
+    booleanNoConstraint: "Keine Einschränkung",
+    booleanAllowedValuesLabel: "Erlaubte Werte",
+    booleanAllowFalseLabel: "Falsch-Werte erlauben",
+    booleanAllowTrueLabel: "Wahr-Werte erlauben",
+    booleanNeitherWarning: "Achtung: Mindestens einer von beiden Werten muss erlaubt sein.",
+    numberNoConstraint: "Keine Einschränkung",
+    numberMinimumLabel: "Minimalwert",
+    numberMinimumPlaceholder: "Kein Minimum",
+    numberMaximumLabel: "Maximalwert",
+    numberMaximumPlaceholder: "Kein Maximum",
+    numberExclusiveMinimumLabel: "Exklusives Minimum",
+    numberExclusiveMinimumPlaceholder: "Kein exklusives Minimum",
+    numberExclusiveMaximumLabel: "Exklusives Maximum",
+    numberExclusiveMaximumPlaceholder: "Kein exklusives Maximum",
+    numberMultipleOfLabel: "Vielfaches von",
+    numberMultipleOfPlaceholder: "Beliebig",
+    numberAllowedValuesEnumLabel: "Erlaubte Werte (Enum)",
+    numberAllowedValuesEnumNone: "Keine Einschränkung für Werte festgelegt",
+    numberAllowedValuesEnumAddLabel: "Hinzufügen",
+    numberAllowedValuesEnumAddPlaceholder: "Erlaubten Wert hinzufügen...",
+    numberValidationErrorMinMax: "Minimum und Maximum müssen konsistent sein.",
+    numberValidationErrorBothExclusiveAndInclusiveMin: "Sowohl 'exclusiveMinimum' als auch 'minimum' dürfen nicht gleichzeitig festgelegt werden.",
+    numberValidationErrorBothExclusiveAndInclusiveMax: "Sowohl 'exclusiveMaximum' als auch 'maximum' dürfen nicht gleichzeitig festgelegt werden.",
+    numberValidationErrorEnumOutOfRange: "Enum-Werte müssen innerhalb des definierten Bereichs liegen.",
+    objectPropertiesNone: "Keine Eigenschaften definiert",
+    objectValidationErrorMinMax: "'minProperties' darf nicht größer als 'maxProperties' sein.",
+    stringNoConstraint: "Keine Einschränkung",
+    stringMinimumLengthLabel: "Minimale Länge",
+    stringMinimumLengthPlaceholder: "Kein Minimum",
+    stringMaximumLengthLabel: "Maximale Länge",
+    stringMaximumLengthPlaceholder: "Kein Maximum",
+    stringPatternLabel: "Muster (Regex)",
+    stringPatternPlaceholder: "^[a-zA-Z]+$",
+    stringFormatLabel: "Format",
+    stringFormatNone: "Keins",
+    stringFormatDateTime: "Datum und Uhrzeit",
+    stringFormatDate: "Datum",
+    stringFormatTime: "Uhrzeit",
+    stringFormatEmail: "E-Mail",
+    stringFormatUri: "URI",
+    stringFormatUuid: "UUID",
+    stringFormatHostname: "Hostname",
+    stringFormatIpv4: "IPv4-Adresse",
+    stringFormatIpv6: "IPv6-Adresse",
+    stringAllowedValuesEnumLabel: "Erlaubte Werte (Enum)",
+    stringAllowedValuesEnumNone: "Keine Einschränkung für Werte festgelegt",
+    stringAllowedValuesEnumAddPlaceholder: "Erlaubten Wert hinzufügen...",
+    stringAllowedValuesEnumAddLabel: "Hinzufügen",
+    enumModeStatic: "Feste Liste",
+    enumModeDependsOn: "Abhängig von Eigenschaft",
+    enumDependsOnPlaceholder: "Eigenschaft wählen...",
+    whenPropertyEquals: "Wenn {property} = {value}",
+    stringFormatSelectPlaceholder: "Format auswählen",
+    stringValidationErrorLengthRange: "'Minimale Länge' darf nicht größer als 'Maximale Länge' sein.",
+    schemaTypeArray: "Liste",
+    schemaTypeBoolean: "Ja/Nein",
+    schemaTypeNumber: "Zahl",
+    schemaTypeObject: "Objekt",
+    schemaTypeString: "Text",
+    schemaTypeNull: "Leer",
+    inferrerTitle: "JSON-Schema ableiten",
+    inferrerDescription: "JSON-Dokument unten einfügen, um ein Schema daraus zu erstellen.",
+    inferrerCancel: "Abbrechen",
+    inferrerGenerate: "Schema erstellen",
+    inferrerErrorInvalidJson: "Ungültiges JSON-Format. Bitte Eingabe prüfen.",
+    validatorTitle: "JSON validieren",
+    validatorDescription: "JSON-Dokument einfügen, um es gegen das aktuelle Schema zu prüfen. Die Validierung erfolgt automatisch beim Tippen.",
+    validatorCurrentSchema: "Aktuelles Schema:",
+    validatorContent: "Zu prüfendes JSON:",
+    validatorValid: "JSON ist gültig zum Schema!",
+    validatorErrorInvalidSyntax: "Ungültige JSON-Syntax",
+    validatorErrorSchemaValidation: "Schema-Validierungsfehler",
+    validatorErrorCount: "{count} Validierungsfehler gefunden",
+    validatorErrorPathRoot: "Wurzel",
+    validatorErrorLocationLineAndColumn: "Zeile {line}, Spalte {column}",
+    validatorErrorLocationLineOnly: "Zeile {line}",
+    visualizerDownloadTitle: "Schema herunterladen",
+    visualizerDownloadFileName: "schema.json",
+    visualizerSource: "JSON-Schema-Quelle",
+    visualEditorNoFieldsHint1: "Noch keine Felder definiert",
+    visualEditorNoFieldsHint2: "Erstes Feld hinzufügen, um zu starten",
+    typeValidationErrorNegativeLength: "Längenwerte dürfen nicht negativ sein.",
+    typeValidationErrorIntValue: "Der Wert muss eine ganze Zahl sein.",
+    typeValidationErrorPositive: "Der Wert muss positiv sein."
+};
+export { de };

package/dist/i18n/locales/en.js

@@ -0,0 +1,143 @@
+const en = {
+    collapse: "Collapse",
+    expand: "Expand",
+    fieldDescriptionPlaceholder: "Describe the purpose of this field",
+    fieldDelete: "Delete field",
+    fieldDescription: "Description",
+    fieldDescriptionTooltip: "Add context about what this field represents",
+    fieldNameLabel: "Field Name",
+    fieldNamePlaceholder: "e.g. firstName, age, isActive",
+    fieldNameTooltip: "Use camelCase for better readability (e.g., firstName)",
+    fieldRequiredLabel: "Required Field",
+    fieldType: "Field Type",
+    fieldTypeExample: "Example:",
+    fieldTypeTooltipString: "string: Text",
+    fieldTypeTooltipNumber: "number: Numeric",
+    fieldTypeTooltipBoolean: "boolean: True/false",
+    fieldTypeTooltipObject: "object: Nested JSON",
+    fieldTypeTooltipArray: "array: Lists of values",
+    fieldAddNewButton: "Add Field",
+    fieldAddNewBadge: "Schema Builder",
+    fieldAddNewCancel: "Cancel",
+    fieldAddNewConfirm: "Add Field",
+    fieldAddNewDescription: "Create a new field for your JSON schema",
+    fieldAddNewLabel: "Add New Field",
+    fieldTypeTextLabel: "Text",
+    fieldTypeTextDescription: "For text values like names, descriptions, etc.",
+    fieldTypeNumberLabel: "Number",
+    fieldTypeNumberDescription: "For decimal or whole numbers",
+    fieldTypeBooleanLabel: "Yes/No",
+    fieldTypeBooleanDescription: "For true/false values",
+    fieldTypeObjectLabel: "Group",
+    fieldTypeObjectDescription: "For grouping related fields together",
+    fieldTypeArrayLabel: "List",
+    fieldTypeArrayDescription: "For collections of items",
+    propertyDescriptionPlaceholder: "Add description...",
+    propertyDescriptionButton: "Add description...",
+    propertyRequired: "Required",
+    propertyOptional: "Optional",
+    propertyDelete: "Delete field",
+    propertyMoveUp: "Move field up",
+    propertyMoveDown: "Move field down",
+    propertyDefaultLabel: "Default Value",
+    propertyDefaultPlaceholder: "Enter default value...",
+    schemaEditorTitle: "JSON Schema Editor",
+    schemaEditorToggleFullscreen: "Toggle fullscreen",
+    schemaEditorEditModeVisual: "Visual",
+    schemaEditorEditModeJson: "JSON",
+    schemaEditorLoading: "Loading editor...",
+    arrayNoConstraint: "No constraint",
+    arrayMinimumLabel: "Minimum Items",
+    arrayMinimumPlaceholder: "No minimum",
+    arrayMaximumLabel: "Maximum Items",
+    arrayMaximumPlaceholder: "No maximum",
+    arrayForceUniqueItemsLabel: "Force unique items",
+    arrayItemTypeLabel: "Item Type",
+    arrayValidationErrorMinMax: "'minItems' cannot be greater than 'maxItems'.",
+    arrayValidationErrorContainsMinMax: "'minContains' cannot be greater than 'maxContains'.",
+    booleanNoConstraint: "No constraint",
+    booleanAllowedValuesLabel: "Allowed Values",
+    booleanAllowFalseLabel: "Allow false value",
+    booleanAllowTrueLabel: "Allow true value",
+    booleanNeitherWarning: "Warning: You must allow at least one value.",
+    numberNoConstraint: "No constraint",
+    numberMinimumLabel: "Minimum Value",
+    numberMinimumPlaceholder: "No minimum",
+    numberMaximumLabel: "Maximum Value",
+    numberMaximumPlaceholder: "No maximum",
+    numberExclusiveMinimumLabel: "Exclusive Minimum",
+    numberExclusiveMinimumPlaceholder: "No exclusive min",
+    numberExclusiveMaximumLabel: "Exclusive Maximum",
+    numberExclusiveMaximumPlaceholder: "No exclusive max",
+    numberMultipleOfLabel: "Multiple Of",
+    numberMultipleOfPlaceholder: "Any",
+    numberAllowedValuesEnumLabel: "Allowed Values (enum)",
+    numberAllowedValuesEnumNone: "No restricted values set",
+    numberAllowedValuesEnumAddLabel: "Add",
+    numberAllowedValuesEnumAddPlaceholder: "Add allowed value...",
+    numberValidationErrorMinMax: "Minimum and maximum values must be consistent.",
+    numberValidationErrorBothExclusiveAndInclusiveMin: "Both 'exclusiveMinimum' and 'minimum' cannot be set at the same time.",
+    numberValidationErrorBothExclusiveAndInclusiveMax: "Both 'exclusiveMaximum' and 'maximum' cannot be set at the same time.",
+    numberValidationErrorEnumOutOfRange: "Enum values must be within the defined range.",
+    objectPropertiesNone: "No properties defined",
+    objectValidationErrorMinMax: "'minProperties' cannot be greater than 'maxProperties'.",
+    stringNoConstraint: "No constraint",
+    stringMinimumLengthLabel: "Minimum Length",
+    stringMinimumLengthPlaceholder: "No minimum",
+    stringMaximumLengthLabel: "Maximum Length",
+    stringMaximumLengthPlaceholder: "No maximum",
+    stringPatternLabel: "Pattern (regex)",
+    stringPatternPlaceholder: "^[a-zA-Z]+$",
+    stringFormatLabel: "Format",
+    stringFormatNone: "None",
+    stringFormatDateTime: "Date-Time",
+    stringFormatDate: "Date",
+    stringFormatTime: "Time",
+    stringFormatEmail: "Email",
+    stringFormatUri: "URI",
+    stringFormatUuid: "UUID",
+    stringFormatHostname: "Hostname",
+    stringFormatIpv4: "IPv4 Address",
+    stringFormatIpv6: "IPv6 Address",
+    stringAllowedValuesEnumLabel: "Allowed Values (enum)",
+    stringAllowedValuesEnumNone: "No restricted values set",
+    stringAllowedValuesEnumAddPlaceholder: "Add allowed value...",
+    stringAllowedValuesEnumAddLabel: "Add",
+    enumModeStatic: "Fixed list",
+    enumModeDependsOn: "Depends on property",
+    enumDependsOnPlaceholder: "Select property...",
+    whenPropertyEquals: "When {property} = {value}",
+    stringFormatSelectPlaceholder: "Select format",
+    stringValidationErrorLengthRange: "'Minimum Length' cannot be greater than 'Maximum Length'.",
+    schemaTypeArray: "List",
+    schemaTypeBoolean: "Yes/No",
+    schemaTypeNumber: "Number",
+    schemaTypeObject: "Object",
+    schemaTypeString: "Text",
+    schemaTypeNull: "Empty",
+    inferrerTitle: "Infer JSON Schema",
+    inferrerDescription: "Paste your JSON document below to generate a schema from it.",
+    inferrerCancel: "Cancel",
+    inferrerGenerate: "Generate Schema",
+    inferrerErrorInvalidJson: "Invalid JSON format. Please check your input.",
+    validatorTitle: "Validate JSON",
+    validatorDescription: "Paste your JSON document to validate against the current schema. Validation occurs automatically as you type.",
+    validatorCurrentSchema: "Current Schema:",
+    validatorContent: "Your JSON:",
+    validatorValid: "JSON is valid according to the schema!",
+    validatorErrorInvalidSyntax: "Invalid JSON syntax",
+    validatorErrorSchemaValidation: "Schema validation error",
+    validatorErrorCount: "{count} validation errors detected",
+    validatorErrorPathRoot: "Root",
+    validatorErrorLocationLineAndColumn: "Line {line}, Col {column}",
+    validatorErrorLocationLineOnly: "Line {line}",
+    visualizerDownloadTitle: "Download Schema",
+    visualizerDownloadFileName: "schema.json",
+    visualizerSource: "JSON Schema Source",
+    visualEditorNoFieldsHint1: "No fields defined yet",
+    visualEditorNoFieldsHint2: "Add your first field to get started",
+    typeValidationErrorNegativeLength: "Length values cannot be negative.",
+    typeValidationErrorIntValue: "Value must be an integer.",
+    typeValidationErrorPositive: "Value must be positive."
+};
+export { en };

package/dist/i18n/locales/es.js

@@ -0,0 +1,143 @@
+const es = {
+    collapse: "Colapsar",
+    expand: "Expandir",
+    fieldDescriptionPlaceholder: "Describe el propósito de este campo",
+    fieldDelete: "Eliminar campo",
+    fieldDescription: "Descripción",
+    fieldDescriptionTooltip: "Añade contexto sobre lo que representa este campo",
+    fieldNameLabel: "Nombre del Campo",
+    fieldNamePlaceholder: "ej. firstName, age, isActive",
+    fieldNameTooltip: "Usa camelCase para mejor legibilidad (ej., firstName)",
+    fieldRequiredLabel: "Campo Requerido",
+    fieldType: "Tipo de Campo",
+    fieldTypeExample: "Ejemplo:",
+    fieldTypeTooltipString: "string: Texto",
+    fieldTypeTooltipNumber: "number: Numérico",
+    fieldTypeTooltipBoolean: "boolean: Verdadero/falso",
+    fieldTypeTooltipObject: "object: JSON anidado",
+    fieldTypeTooltipArray: "array: Listas de valores",
+    fieldAddNewButton: "Agregar Campo",
+    fieldAddNewBadge: "Constructor de Schema",
+    fieldAddNewCancel: "Cancelar",
+    fieldAddNewConfirm: "Agregar Campo",
+    fieldAddNewDescription: "Crea un nuevo campo para tu JSON schema",
+    fieldAddNewLabel: "Agregar Nuevo Campo",
+    fieldTypeTextLabel: "Texto",
+    fieldTypeTextDescription: "Para valores de texto como nombres, descripciones, etc.",
+    fieldTypeNumberLabel: "Número",
+    fieldTypeNumberDescription: "Para números decimales o enteros",
+    fieldTypeBooleanLabel: "Sí/No",
+    fieldTypeBooleanDescription: "Para valores verdadero/falso",
+    fieldTypeObjectLabel: "Grupo",
+    fieldTypeObjectDescription: "Para agrupar campos relacionados",
+    fieldTypeArrayLabel: "Lista",
+    fieldTypeArrayDescription: "Para colecciones de elementos",
+    propertyDescriptionPlaceholder: "Agregar descripción...",
+    propertyDescriptionButton: "Agregar descripción...",
+    propertyRequired: "Requerido",
+    propertyOptional: "Opcional",
+    propertyDelete: "Eliminar campo",
+    propertyMoveUp: "Mover campo hacia arriba",
+    propertyMoveDown: "Mover campo hacia abajo",
+    propertyDefaultLabel: "Valor por defecto",
+    propertyDefaultPlaceholder: "Ingresar valor por defecto...",
+    schemaEditorTitle: "Editor de JSON Schema",
+    schemaEditorToggleFullscreen: "Cambiar a pantalla completa",
+    schemaEditorEditModeVisual: "Visual",
+    schemaEditorEditModeJson: "JSON",
+    schemaEditorLoading: "Cargando editor...",
+    arrayNoConstraint: "Sin restricción",
+    arrayMinimumLabel: "Mínimo de Elementos",
+    arrayMinimumPlaceholder: "Sin mínimo",
+    arrayMaximumLabel: "Máximo de Elementos",
+    arrayMaximumPlaceholder: "Sin máximo",
+    arrayForceUniqueItemsLabel: "Forzar elementos únicos",
+    arrayItemTypeLabel: "Tipo de Elemento",
+    arrayValidationErrorMinMax: "'minItems' no puede ser mayor que 'maxItems'.",
+    arrayValidationErrorContainsMinMax: "'minContains' no puede ser mayor que 'maxContains'.",
+    booleanNoConstraint: "Sin restricción",
+    booleanAllowedValuesLabel: "Valores Permitidos",
+    booleanAllowFalseLabel: "Permitir valor falso",
+    booleanAllowTrueLabel: "Permitir valor verdadero",
+    booleanNeitherWarning: "Advertencia: Debes permitir al menos un valor.",
+    numberNoConstraint: "Sin restricción",
+    numberMinimumLabel: "Valor Mínimo",
+    numberMinimumPlaceholder: "Sin mínimo",
+    numberMaximumLabel: "Valor Máximo",
+    numberMaximumPlaceholder: "Sin máximo",
+    numberExclusiveMinimumLabel: "Mínimo Exclusivo",
+    numberExclusiveMinimumPlaceholder: "Sin mínimo exclusivo",
+    numberExclusiveMaximumLabel: "Máximo Exclusivo",
+    numberExclusiveMaximumPlaceholder: "Sin máximo exclusivo",
+    numberMultipleOfLabel: "Múltiplo De",
+    numberMultipleOfPlaceholder: "Cualquiera",
+    numberAllowedValuesEnumLabel: "Valores Permitidos (enum)",
+    numberAllowedValuesEnumNone: "No hay valores restringidos",
+    numberAllowedValuesEnumAddLabel: "Agregar",
+    numberAllowedValuesEnumAddPlaceholder: "Agregar valor permitido...",
+    numberValidationErrorMinMax: "Los valores mínimo y máximo deben ser consistentes.",
+    numberValidationErrorBothExclusiveAndInclusiveMin: "No puedes definir a la vez 'exclusiveMinimum' y 'minimum'.",
+    numberValidationErrorBothExclusiveAndInclusiveMax: "No puedes definir a la vez 'exclusiveMaximum' y 'maximum'.",
+    numberValidationErrorEnumOutOfRange: "Los valores del enum deben estar dentro del rango definido.",
+    objectPropertiesNone: "No hay propiedades definidas",
+    objectValidationErrorMinMax: "'minProperties' no puede ser mayor que 'maxProperties'.",
+    stringNoConstraint: "Sin restricción",
+    stringMinimumLengthLabel: "Longitud Mínima",
+    stringMinimumLengthPlaceholder: "Sin mínimo",
+    stringMaximumLengthLabel: "Longitud Máxima",
+    stringMaximumLengthPlaceholder: "Sin máximo",
+    stringPatternLabel: "Patrón (regex)",
+    stringPatternPlaceholder: "^[a-zA-Z]+$",
+    stringFormatLabel: "Formato",
+    stringFormatNone: "Ninguno",
+    stringFormatDateTime: "Fecha-Hora",
+    stringFormatDate: "Fecha",
+    stringFormatTime: "Hora",
+    stringFormatEmail: "Correo",
+    stringFormatUri: "URI",
+    stringFormatUuid: "UUID",
+    stringFormatHostname: "Hostname",
+    stringFormatIpv4: "Dirección IPv4",
+    stringFormatIpv6: "Dirección IPv6",
+    stringAllowedValuesEnumLabel: "Valores Permitidos (enum)",
+    stringAllowedValuesEnumNone: "No hay valores restringidos",
+    stringAllowedValuesEnumAddPlaceholder: "Agregar valor permitido...",
+    stringAllowedValuesEnumAddLabel: "Agregar",
+    enumModeStatic: "Lista fija",
+    enumModeDependsOn: "Depende de propiedad",
+    enumDependsOnPlaceholder: "Seleccionar propiedad...",
+    whenPropertyEquals: "Cuando {property} = {value}",
+    stringFormatSelectPlaceholder: "Seleccionar formato",
+    stringValidationErrorLengthRange: "'Longitud Mínima' no puede ser mayor que 'Longitud Máxima'.",
+    schemaTypeArray: "Lista",
+    schemaTypeBoolean: "Sí/No",
+    schemaTypeNumber: "Número",
+    schemaTypeObject: "Objeto",
+    schemaTypeString: "Texto",
+    schemaTypeNull: "Vacío",
+    inferrerTitle: "Inferir JSON Schema",
+    inferrerDescription: "Pega tu documento JSON abajo para generar un schema a partir de él.",
+    inferrerCancel: "Cancelar",
+    inferrerGenerate: "Generar Schema",
+    inferrerErrorInvalidJson: "Formato JSON inválido. Revisa tu entrada.",
+    validatorTitle: "Validar JSON",
+    validatorDescription: "Pega tu documento JSON para validarlo contra el schema actual. La validación se hace automáticamente mientras escribes.",
+    validatorCurrentSchema: "Schema Actual:",
+    validatorContent: "Tu JSON:",
+    validatorValid: "¡El JSON es válido según el schema!",
+    validatorErrorInvalidSyntax: "Sintaxis JSON inválida",
+    validatorErrorSchemaValidation: "Error de validación del schema",
+    validatorErrorCount: "{count} errores de validación detectados",
+    validatorErrorPathRoot: "Raíz",
+    validatorErrorLocationLineAndColumn: "Línea {line}, Col {column}",
+    validatorErrorLocationLineOnly: "Línea {line}",
+    visualizerDownloadTitle: "Descargar Schema",
+    visualizerDownloadFileName: "schema.json",
+    visualizerSource: "Fuente del JSON Schema",
+    visualEditorNoFieldsHint1: "Aún no hay campos definidos",
+    visualEditorNoFieldsHint2: "Agrega tu primer campo para comenzar",
+    typeValidationErrorNegativeLength: "Los valores de longitud no pueden ser negativos.",
+    typeValidationErrorIntValue: "El valor debe ser un entero.",
+    typeValidationErrorPositive: "El valor debe ser positivo."
+};
+export { es };