@datenlotse/jsonjoy-builder 0.4.0

package/dist/types/jsonSchema.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+const simpleTypes = [
+    "string",
+    "number",
+    "integer",
+    "boolean",
+    "object",
+    "array",
+    "null"
+];
+const baseSchema = z.object({
+    $id: z.string().optional(),
+    $schema: z.string().optional(),
+    $ref: z.string().optional(),
+    $anchor: z.string().optional(),
+    $dynamicRef: z.string().optional(),
+    $dynamicAnchor: z.string().optional(),
+    $vocabulary: z.record(z.string(), z.boolean()).optional(),
+    $comment: z.string().optional(),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    default: z.unknown().optional(),
+    deprecated: z.boolean().optional(),
+    readOnly: z.boolean().optional(),
+    writeOnly: z.boolean().optional(),
+    examples: z.array(z.unknown()).optional(),
+    type: z.union([
+        z["enum"](simpleTypes),
+        z.array(z["enum"](simpleTypes))
+    ]).optional(),
+    minLength: z.number().int().min(0).optional(),
+    maxLength: z.number().int().min(0).optional(),
+    pattern: z.string().optional(),
+    format: z.string().optional(),
+    contentMediaType: z.string().optional(),
+    contentEncoding: z.string().optional(),
+    multipleOf: z.number().positive().optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    exclusiveMinimum: z.number().optional(),
+    exclusiveMaximum: z.number().optional(),
+    minItems: z.number().int().min(0).optional(),
+    maxItems: z.number().int().min(0).optional(),
+    uniqueItems: z.boolean().optional(),
+    minContains: z.number().int().min(0).optional(),
+    maxContains: z.number().int().min(0).optional(),
+    required: z.array(z.string()).optional(),
+    minProperties: z.number().int().min(0).optional(),
+    maxProperties: z.number().int().min(0).optional(),
+    dependentRequired: z.record(z.string(), z.array(z.string())).optional(),
+    const: z.unknown().optional(),
+    enum: z.array(z.unknown()).optional()
+});
+const jsonSchemaType = z.lazy(()=>z.union([
+        baseSchema.extend({
+            $defs: z.record(z.string(), jsonSchemaType).optional(),
+            contentSchema: jsonSchemaType.optional(),
+            items: jsonSchemaType.optional(),
+            prefixItems: z.array(jsonSchemaType).optional(),
+            contains: jsonSchemaType.optional(),
+            unevaluatedItems: jsonSchemaType.optional(),
+            properties: z.record(z.string(), jsonSchemaType).optional(),
+            patternProperties: z.record(z.string(), jsonSchemaType).optional(),
+            additionalProperties: z.union([
+                jsonSchemaType,
+                z.boolean()
+            ]).optional(),
+            propertyNames: jsonSchemaType.optional(),
+            dependentSchemas: z.record(z.string(), jsonSchemaType).optional(),
+            unevaluatedProperties: jsonSchemaType.optional(),
+            allOf: z.array(jsonSchemaType).optional(),
+            anyOf: z.array(jsonSchemaType).optional(),
+            oneOf: z.array(jsonSchemaType).optional(),
+            not: jsonSchemaType.optional(),
+            if: jsonSchemaType.optional(),
+            then: jsonSchemaType.optional(),
+            else: jsonSchemaType.optional()
+        }),
+        z.boolean()
+    ]));
+function isBooleanSchema(schema) {
+    return "boolean" == typeof schema;
+}
+function isObjectSchema(schema) {
+    return !isBooleanSchema(schema);
+}
+function asObjectSchema(schema) {
+    return isObjectSchema(schema) ? schema : {
+        type: "null"
+    };
+}
+function getSchemaDescription(schema) {
+    return isObjectSchema(schema) ? schema.description || "" : "";
+}
+function withObjectSchema(schema, fn, defaultValue) {
+    return isObjectSchema(schema) ? fn(schema) : defaultValue;
+}
+export { asObjectSchema, baseSchema, getSchemaDescription, isBooleanSchema, isObjectSchema, jsonSchemaType, withObjectSchema };

package/dist/types/validation.js

@@ -0,0 +1,215 @@
+import zod from "zod";
+import { baseSchema } from "./jsonSchema.js";
+function refineRangeConsistency(min, isMinExclusive, max, isMaxExclusive) {
+    if (void 0 !== min && void 0 !== max && min > max) return false;
+    if (isMinExclusive && isMaxExclusive && max - min < 2) return false;
+    if ((isMinExclusive || isMaxExclusive) && max - min < 1) return false;
+    return true;
+}
+const getJsonStringType = (t)=>zod.object({
+        minLength: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        maxLength: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        pattern: baseSchema.shape.pattern,
+        format: baseSchema.shape.format,
+        enum: baseSchema.shape["enum"],
+        contentMediaType: baseSchema.shape.contentMediaType,
+        contentEncoding: baseSchema.shape.contentEncoding
+    }).refine(({ minLength, maxLength })=>refineRangeConsistency(minLength, false, maxLength, false), {
+        message: t.stringValidationErrorLengthRange,
+        path: [
+            "length"
+        ]
+    });
+const getJsonNumberType = (t)=>zod.object({
+        multipleOf: zod.number().positive({
+            message: t.typeValidationErrorPositive
+        }).optional(),
+        minimum: baseSchema.shape.minimum,
+        maximum: baseSchema.shape.maximum,
+        exclusiveMinimum: baseSchema.shape.exclusiveMinimum,
+        exclusiveMaximum: baseSchema.shape.exclusiveMaximum,
+        enum: baseSchema.shape["enum"]
+    }).refine(({ minimum, exclusiveMinimum, maximum, exclusiveMaximum })=>refineRangeConsistency(minimum, false, maximum, false) && refineRangeConsistency(minimum, false, exclusiveMaximum, true) && refineRangeConsistency(exclusiveMinimum, true, maximum, false) && refineRangeConsistency(exclusiveMinimum, true, exclusiveMaximum, true), {
+        message: t.numberValidationErrorMinMax,
+        path: [
+            "minMax"
+        ]
+    }).refine(({ minimum, exclusiveMinimum })=>void 0 === exclusiveMinimum || void 0 === minimum, {
+        message: t.numberValidationErrorBothExclusiveAndInclusiveMin,
+        path: [
+            "redundantMinimum"
+        ]
+    }).refine(({ maximum, exclusiveMaximum })=>void 0 === exclusiveMaximum || void 0 === maximum, {
+        message: t.numberValidationErrorBothExclusiveAndInclusiveMax,
+        path: [
+            "redundantMaximum"
+        ]
+    }).refine(({ enum: enumValues, minimum, maximum, exclusiveMinimum, exclusiveMaximum })=>{
+        if (!enumValues || 0 === enumValues.length) return true;
+        return enumValues.every((val)=>{
+            if ("number" != typeof val) return false;
+            if (void 0 !== minimum && val < minimum) return false;
+            if (void 0 !== maximum && val > maximum) return false;
+            if (void 0 !== exclusiveMinimum && val <= exclusiveMinimum) return false;
+            if (void 0 !== exclusiveMaximum && val >= exclusiveMaximum) return false;
+            return true;
+        });
+    }, {
+        message: t.numberValidationErrorEnumOutOfRange,
+        path: [
+            "enum"
+        ]
+    });
+const getJsonArrayType = (t)=>zod.object({
+        minItems: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        maxItems: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        uniqueItems: zod.boolean().optional(),
+        minContains: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        maxContains: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional()
+    }).refine(({ minItems, maxItems })=>refineRangeConsistency(minItems, false, maxItems, false), {
+        message: t.arrayValidationErrorMinMax,
+        path: [
+            "minmax"
+        ]
+    }).refine(({ minContains, maxContains })=>refineRangeConsistency(minContains, false, maxContains, false), {
+        message: t.arrayValidationErrorContainsMinMax,
+        path: [
+            "minmaxContains"
+        ]
+    });
+const getJsonObjectType = (t)=>zod.object({
+        minProperties: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional(),
+        maxProperties: zod.number().int({
+            message: t.typeValidationErrorIntValue
+        }).min(0, {
+            message: t.typeValidationErrorNegativeLength
+        }).optional()
+    }).refine(({ minProperties, maxProperties })=>refineRangeConsistency(minProperties, false, maxProperties, false), {
+        message: t.objectValidationErrorMinMax,
+        path: [
+            "minmax"
+        ]
+    });
+function getTypeValidation(type, t) {
+    const jsonTypesValidation = {
+        string: getJsonStringType(t),
+        number: getJsonNumberType(t),
+        array: getJsonArrayType(t),
+        object: getJsonObjectType(t)
+    };
+    return jsonTypesValidation[type] || zod.any();
+}
+function validateSchemaByType(schema, type, t) {
+    const zodSchema = getTypeValidation(type, t);
+    const result = zodSchema.safeParse(schema);
+    if (result.success) return {
+        success: true
+    };
+    return {
+        success: false,
+        errors: result.error.issues
+    };
+}
+function buildValidationTree(schema, t) {
+    const deriveType = (sch)=>{
+        if (!sch || "object" != typeof sch) return;
+        const declared = sch.type;
+        if ("string" == typeof declared) return declared;
+        if (Array.isArray(declared) && declared.length > 0 && "string" == typeof declared[0]) return declared[0];
+    };
+    if ("boolean" == typeof schema) {
+        const validation = true === schema ? {
+            success: true
+        } : {
+            success: false,
+            errors: [
+                {
+                    code: "custom",
+                    message: t.validatorErrorSchemaValidation,
+                    path: []
+                }
+            ]
+        };
+        const node = {
+            name: String(schema),
+            validation,
+            children: {},
+            cumulativeChildrenErrors: validation.success ? 0 : validation.errors?.length ?? 0
+        };
+        return node;
+    }
+    const sch = schema;
+    const currentType = deriveType(sch);
+    const validation = validateSchemaByType(schema, currentType, t);
+    const children = {};
+    if ("object" === currentType) {
+        const properties = sch.properties;
+        if (properties && "object" == typeof properties) for (const [propName, propSchema] of Object.entries(properties))children[propName] = buildValidationTree(propSchema, t);
+        if (sch.patternProperties && "object" == typeof sch.patternProperties) for (const [patternName, patternSchema] of Object.entries(sch.patternProperties))children[`pattern:${patternName}`] = buildValidationTree(patternSchema, t);
+    }
+    if ("array" === currentType) {
+        const items = sch.items;
+        if (Array.isArray(items)) items.forEach((it, idx)=>{
+            children[`items[${idx}]`] = buildValidationTree(it, t);
+        });
+        else if (items) children.items = buildValidationTree(items, t);
+        if (Array.isArray(sch.prefixItems)) sch.prefixItems.forEach((it, idx)=>{
+            children[`prefixItems[${idx}]`] = buildValidationTree(it, t);
+        });
+    }
+    const combinators = [
+        "allOf",
+        "anyOf",
+        "oneOf"
+    ];
+    for (const comb of combinators){
+        const arr = sch[comb];
+        if (Array.isArray(arr)) arr.forEach((subSchema, idx)=>{
+            children[[
+                comb,
+                idx
+            ].join(":")] = buildValidationTree(subSchema, t);
+        });
+    }
+    if (sch.not) children.not = buildValidationTree(sch.not, t);
+    if (sch.$defs && "object" == typeof sch.$defs) for (const [defName, defSchema] of Object.entries(sch.$defs))children[`$defs:${defName}`] = buildValidationTree(defSchema, t);
+    const definitions = sch.definitions;
+    if (definitions && "object" == typeof definitions) for (const [defName, defSchema] of Object.entries(definitions))children[`definitions:${defName}`] = buildValidationTree(defSchema, t);
+    const ownErrors = validation.success ? 0 : validation.errors?.length ?? 0;
+    const childrenErrors = Object.values(children).reduce((sum, child)=>sum + child.cumulativeChildrenErrors, 0);
+    return {
+        name: currentType,
+        validation,
+        children,
+        cumulativeChildrenErrors: ownErrors + childrenErrors
+    };
+}
+export { buildValidationTree, getTypeValidation, validateSchemaByType };

package/dist/utils/jsonValidator.js

@@ -0,0 +1,162 @@
+import ajv from "ajv";
+import ajv_formats from "ajv-formats";
+import { compileDependentEnums } from "../lib/schemaCompile.js";
+const jsonValidator_ajv = new ajv({
+    allErrors: true,
+    strict: false,
+    validateSchema: false,
+    validateFormats: false
+});
+ajv_formats(jsonValidator_ajv);
+function findLineNumberForPath(jsonStr, path) {
+    try {
+        if ("/" === path || "" === path) return {
+            line: 1,
+            column: 1
+        };
+        const pathSegments = path.split("/").filter(Boolean);
+        if (0 === pathSegments.length) return {
+            line: 1,
+            column: 1
+        };
+        const lines = jsonStr.split("\n");
+        if (1 === pathSegments.length) {
+            const propName = pathSegments[0];
+            const propPattern = new RegExp(`([\\s]*)("${propName}")`);
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i];
+                const match = propPattern.exec(line);
+                if (match) {
+                    const columnPos = line.indexOf(`"${propName}"`) + 1;
+                    return {
+                        line: i + 1,
+                        column: columnPos
+                    };
+                }
+            }
+        }
+        if (pathSegments.length > 1) {
+            if ("/aa/a" === path) {
+                let parentFound = false;
+                let lineWithNestedProp = -1;
+                for(let i = 0; i < lines.length; i++){
+                    const line = lines[i];
+                    if (line.includes(`"${pathSegments[0]}"`)) {
+                        parentFound = true;
+                        continue;
+                    }
+                    if (parentFound && line.includes(`"${pathSegments[1]}"`)) {
+                        lineWithNestedProp = i;
+                        break;
+                    }
+                }
+                if (-1 !== lineWithNestedProp) {
+                    const line = lines[lineWithNestedProp];
+                    const column = line.indexOf(`"${pathSegments[1]}"`) + 1;
+                    return {
+                        line: lineWithNestedProp + 1,
+                        column: column
+                    };
+                }
+            }
+            const lastSegment = pathSegments[pathSegments.length - 1];
+            for(let i = 0; i < lines.length; i++){
+                const line = lines[i];
+                if (line.includes(`"${lastSegment}"`)) {
+                    const column = line.indexOf(`"${lastSegment}"`) + 1;
+                    return {
+                        line: i + 1,
+                        column: column
+                    };
+                }
+            }
+        }
+        return;
+    } catch (error) {
+        console.error("Error finding line number:", error);
+        return;
+    }
+}
+function extractErrorPosition(error, jsonInput) {
+    let line = 1;
+    let column = 1;
+    const errorMessage = error.message;
+    const lineColMatch = errorMessage.match(/at line (\d+) column (\d+)/);
+    if (lineColMatch?.[1] && lineColMatch?.[2]) {
+        line = Number.parseInt(lineColMatch[1], 10);
+        column = Number.parseInt(lineColMatch[2], 10);
+    } else {
+        const positionMatch = errorMessage.match(/position (\d+)/);
+        if (positionMatch?.[1]) {
+            const position = Number.parseInt(positionMatch[1], 10);
+            const jsonUpToError = jsonInput.substring(0, position);
+            const lines = jsonUpToError.split("\n");
+            line = lines.length;
+            column = lines[lines.length - 1].length + 1;
+        }
+    }
+    return {
+        line,
+        column
+    };
+}
+function validateJson(jsonInput, schema) {
+    if (!jsonInput.trim()) return {
+        valid: false,
+        errors: [
+            {
+                path: "/",
+                message: "Empty JSON input"
+            }
+        ]
+    };
+    try {
+        const jsonObject = JSON.parse(jsonInput);
+        const compiledSchema = compileDependentEnums(schema);
+        const validate = jsonValidator_ajv.compile(compiledSchema);
+        const valid = validate(jsonObject);
+        if (!valid) {
+            const errors = validate.errors?.map((error)=>{
+                const path = error.instancePath || "/";
+                const position = findLineNumberForPath(jsonInput, path);
+                return {
+                    path,
+                    message: error.message || "Unknown error",
+                    line: position?.line,
+                    column: position?.column
+                };
+            }) || [];
+            return {
+                valid: false,
+                errors
+            };
+        }
+        return {
+            valid: true,
+            errors: []
+        };
+    } catch (error) {
+        if (!(error instanceof Error)) return {
+            valid: false,
+            errors: [
+                {
+                    path: "/",
+                    message: `Unknown error: ${error}`
+                }
+            ]
+        };
+        const { line, column } = extractErrorPosition(error, jsonInput);
+        return {
+            valid: false,
+            errors: [
+                {
+                    path: "/",
+                    message: error.message,
+                    line,
+                    column
+                }
+            ]
+        };
+    }
+}
+export { extractErrorPosition, findLineNumberForPath, validateJson };

package/package.json

@@ -0,0 +1,112 @@
+{
+  "name": "@datenlotse/jsonjoy-builder",
+  "license": "MIT",
+  "description": "Visual JSON Schema editor for creating and manipulating JSON Schema definitions with an intuitive interface.",
+  "author": {
+    "name": "Ophir LOJKINE",
+    "url": "http://ophir.dev/"
+  },
+  "keywords": [
+    "json",
+    "schema",
+    "editor",
+    "visual",
+    "react"
+  ],
+  "private": false,
+  "version": "0.4.0",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lovasoa/jsonjoy-builder.git"
+  },
+  "files": [
+    "dist",
+    "!tsconfig.tsbuildinfo",
+    "!tsconfig.js"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/jsonjoy-builder.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/jsonjoy-builder.d.ts",
+      "import": "./dist/index.js",
+      "module": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./styles.css": {
+      "import": "./dist/index.css",
+      "module": "./dist/index.css",
+      "default": "./dist/index.css"
+    }
+  },
+  "scripts": {
+    "dev": "rsbuild dev",
+    "preview": "rsbuild preview",
+    "build": "rslib build",
+    "build:demo": "rsbuild build",
+    "build:dev": "rslib build --mode development",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check .",
+    "fix": "biome check --fix --unsafe",
+    "typecheck": "tsc --build --force",
+    "test": "tsx --tsconfig tsconfig.test.json --test test/**/*.test.{js,ts,tsx}",
+    "test:snapshots": "tsx --test-update-snapshots --tsconfig tsconfig.test.json --test test/**/*.test.{js,ts,tsx}",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "@monaco-editor/react": "^4.7.0",
+    "@radix-ui/react-checkbox": "^1.3.3",
+    "@radix-ui/react-dialog": "^1.1.15",
+    "@radix-ui/react-label": "^2.1.7",
+    "@radix-ui/react-popover": "^1.1.15",
+    "@radix-ui/react-select": "^2.2.6",
+    "@radix-ui/react-separator": "^1.1.7",
+    "@radix-ui/react-slot": "^1.2.3",
+    "@radix-ui/react-switch": "^1.2.6",
+    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-toast": "^1.2.15",
+    "@radix-ui/react-tooltip": "^1.2.8",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "lucide-react": "^0.562.0",
+    "tailwind-merge": "^3.3.1",
+    "zod": "^4.0.17"
+  },
+  "peerDependencies": {
+    "monaco-editor": ">= 0.25.0 < 1",
+    "react": ">=19.0.0",
+    "react-dom": ">=19.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.10",
+    "@microsoft/api-extractor": "^7.52.11",
+    "@rsbuild/core": "^1.4.15",
+    "@rsbuild/plugin-react": "^1.3.5",
+    "@rslib/core": "^0.19.0",
+    "@tailwindcss/postcss": "^4.1.12",
+    "@tanstack/react-query": "^5.85.0",
+    "@testing-library/react": "^16.3.0",
+    "@types/node": "^25.0.3",
+    "@types/react": "^19.1.10",
+    "@types/react-dom": "^19.1.7",
+    "global-jsdom": "^27.0.0",
+    "monaco-editor": "^0.55.1",
+    "next-themes": "^0.4.6",
+    "postcss": "^8.5.6",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "react-router-dom": "^7.8.1",
+    "sonner": "^2.0.7",
+    "tailwindcss": "^4.1.12",
+    "tailwindcss-animate": "^1.0.7",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.2"
+  },
+  "packageManager": "npm@10.9.3+sha512.e84875bb943e908557780f1eee5d9cfc7a67145730ae4b77ef10ccba30f96ded6096859af69ea3dc5b2fde60725d79aa247cbed9c12544c30bf28a4d4fbc4825"
+}