bestjsonformatter 0.1.0 → 0.2.1

package/dist/lib/json-check.js

@@ -0,0 +1,132 @@
+import { canonicalJsonNumber, JsonSyntaxError, parseLosslessJson, } from "./lossless-json.js";
+function locationFromOffset(input, offset) {
+    let line = 1;
+    let column = 1;
+    for (let index = 0; index < offset; index += 1) {
+        if (input.charCodeAt(index) === 10) {
+            line += 1;
+            column = 1;
+        }
+        else {
+            column += 1;
+        }
+    }
+    return { line, column, offset };
+}
+function diagnosticPath(path) {
+    return path.reduce((result, part) => {
+        if (typeof part === "number")
+            return `${result}[${part}]`;
+        return /^[A-Za-z_$][\w$]*$/.test(part)
+            ? `${result}.${part}`
+            : `${result}[${JSON.stringify(part)}]`;
+    }, "$");
+}
+function numberIssue(input, node, path) {
+    const numeric = Number(node.raw);
+    const locations = [locationFromOffset(input, node.start)];
+    if (!Number.isFinite(numeric)) {
+        return {
+            code: "number-overflow",
+            severity: "error",
+            path,
+            token: node.raw,
+            locations,
+            message: `${node.raw} overflows JavaScript Number and becomes Infinity.`,
+        };
+    }
+    if (numeric === 0 && canonicalJsonNumber(node.raw) !== "0") {
+        return {
+            code: "number-underflow",
+            severity: "error",
+            path,
+            token: node.raw,
+            locations,
+            message: `${node.raw} underflows JavaScript Number and becomes zero.`,
+        };
+    }
+    const roundTrip = String(numeric);
+    if (canonicalJsonNumber(node.raw) !== canonicalJsonNumber(roundTrip)) {
+        return {
+            code: "unsafe-number",
+            severity: "error",
+            path,
+            token: node.raw,
+            locations,
+            message: `${node.raw} rounds to ${roundTrip} as a JavaScript Number.`,
+        };
+    }
+    if (roundTrip !== node.raw) {
+        return {
+            code: "number-spelling",
+            severity: "warning",
+            path,
+            token: node.raw,
+            locations,
+            message: `${node.raw} keeps its value but ordinary parsers may rewrite it as ${roundTrip}.`,
+        };
+    }
+}
+export function checkJson(input) {
+    try {
+        const parsed = parseLosslessJson(input, { buildTree: true });
+        const issues = [];
+        const visit = (node, path) => {
+            if (node.kind === "array") {
+                node.items.forEach((item, index) => {
+                    visit(item, [...path, index]);
+                });
+                return;
+            }
+            if (node.kind === "object") {
+                const entriesByKey = new Map();
+                for (const entry of node.entries) {
+                    const entries = entriesByKey.get(entry.key);
+                    if (entries)
+                        entries.push(entry);
+                    else
+                        entriesByKey.set(entry.key, [entry]);
+                    visit(entry.value, [...path, entry.key]);
+                }
+                for (const [key, entries] of entriesByKey) {
+                    if (entries.length < 2)
+                        continue;
+                    issues.push({
+                        code: "duplicate-key",
+                        severity: "error",
+                        path: diagnosticPath([...path, key]),
+                        locations: entries.map((entry) => locationFromOffset(input, entry.keyStart)),
+                        message: `${entries.length} properties named ${JSON.stringify(key)} occur in the same object; ordinary parsers usually keep only the last value.`,
+                    });
+                }
+                return;
+            }
+            if (node.kind !== "number")
+                return;
+            const issue = numberIssue(input, node, diagnosticPath(path));
+            if (issue)
+                issues.push(issue);
+        };
+        visit(parsed.root, []);
+        return {
+            valid: true,
+            clean: issues.length === 0,
+            issues,
+            metadata: parsed.metadata,
+        };
+    }
+    catch (error) {
+        if (error instanceof JsonSyntaxError) {
+            return {
+                valid: false,
+                clean: false,
+                issues: [],
+                message: error.message,
+                line: error.line,
+                column: error.column,
+                offset: error.offset,
+            };
+        }
+        throw error;
+    }
+}

package/dist/lib/json-schema.d.ts

@@ -0,0 +1,19 @@
+export declare function inferJsonSchema(input: string): {
+    schema: {
+        $schema: string;
+    };
+    metadata: import("./lossless-json.js").JsonParseMetadata;
+};
+export declare function validateJsonSchema(input: string, schemaInput: string): Promise<{
+    valid: boolean;
+    errors: string[];
+    metadata: {
+        duplicateKeys: number;
+        unsafeNumbers: number;
+        schemaErrors: number;
+    };
+}>;
+export declare function generateJsonSample(schemaInput: string): {
+    value: string;
+    metadata: import("./lossless-json.js").JsonParseMetadata;
+};

package/dist/lib/json-schema.js

@@ -0,0 +1,195 @@
+import Ajv2020 from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import { jsonNodeToNative, parseLosslessJson, stringifyNativeLosslessly, } from "./lossless-json.js";
+function stableSchemaKey(schema) {
+    const canonicalize = (value) => {
+        if (Array.isArray(value))
+            return value.map(canonicalize);
+        if (value && typeof value === "object") {
+            return Object.fromEntries(Object.entries(value)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([key, child]) => [key, canonicalize(child)]));
+        }
+        return value;
+    };
+    return JSON.stringify(canonicalize(schema));
+}
+function inferNode(node) {
+    switch (node.kind) {
+        case "null":
+            return { type: "null" };
+        case "boolean":
+            return { type: "boolean" };
+        case "string":
+            return { type: "string" };
+        case "number":
+            return { type: node.raw.includes(".") || /[eE]/.test(node.raw) ? "number" : "integer" };
+        case "object": {
+            const properties = {};
+            const required = [];
+            for (const entry of node.entries) {
+                if (!(entry.key in properties))
+                    required.push(entry.key);
+                properties[entry.key] = inferNode(entry.value);
+            }
+            return { type: "object", properties, required };
+        }
+        case "array": {
+            if (!node.items.length)
+                return { type: "array" };
+            const unique = new Map();
+            for (const item of node.items) {
+                const schema = inferNode(item);
+                unique.set(stableSchemaKey(schema), schema);
+            }
+            const schemas = [...unique.values()];
+            return {
+                type: "array",
+                items: schemas.length === 1 ? schemas[0] : { anyOf: schemas },
+            };
+        }
+    }
+}
+export function inferJsonSchema(input) {
+    const parsed = parseLosslessJson(input, { buildTree: true });
+    return {
+        schema: {
+            $schema: "https://json-schema.org/draft/2020-12/schema",
+            ...inferNode(parsed.root),
+        },
+        metadata: parsed.metadata,
+    };
+}
+function formatError(error) {
+    const path = error.instancePath || "/";
+    const message = error.message ?? "does not satisfy the schema";
+    return `${path} ${message}`;
+}
+export async function validateJsonSchema(input, schemaInput) {
+    const document = parseLosslessJson(input, { buildTree: true });
+    const schema = parseLosslessJson(schemaInput, { buildTree: true });
+    if (schema.root?.kind !== "object") {
+        throw new TypeError("The JSON Schema must be an object.");
+    }
+    const ajv = new Ajv2020({
+        allErrors: true,
+        strict: false,
+        validateFormats: true,
+    });
+    addFormats(ajv);
+    const validate = ajv.compile(jsonNodeToNative(schema.root, false));
+    const valid = validate(jsonNodeToNative(document.root, false));
+    const errors = valid ? [] : (validate.errors ?? []).map(formatError);
+    return {
+        valid: Boolean(valid),
+        errors,
+        metadata: {
+            duplicateKeys: document.metadata.duplicateKeys + schema.metadata.duplicateKeys,
+            unsafeNumbers: document.metadata.unsafeNumbers,
+            schemaErrors: errors.length,
+        },
+    };
+}
+function resolveLocalReference(root, reference) {
+    if (!reference.startsWith("#/"))
+        return undefined;
+    return reference
+        .slice(2)
+        .split("/")
+        .reduce((value, segment) => {
+        if (!value || typeof value !== "object")
+            return undefined;
+        const key = segment.replaceAll("~1", "/").replaceAll("~0", "~");
+        return value[key];
+    }, root);
+}
+function sampleForSchema(schema, root, references, depth = 0) {
+    if (!schema || typeof schema !== "object" || depth > 50)
+        return null;
+    const current = schema;
+    if ("const" in current)
+        return current.const;
+    if ("default" in current)
+        return current.default;
+    if (Array.isArray(current.examples) && current.examples.length)
+        return current.examples[0];
+    if (Array.isArray(current.enum) && current.enum.length)
+        return current.enum[0];
+    if (typeof current.$ref === "string") {
+        if (references.has(current.$ref))
+            return null;
+        const target = resolveLocalReference(root, current.$ref);
+        if (target !== undefined) {
+            const nextReferences = new Set(references);
+            nextReferences.add(current.$ref);
+            return sampleForSchema(target, root, nextReferences, depth + 1);
+        }
+    }
+    for (const keyword of ["oneOf", "anyOf"]) {
+        const alternatives = current[keyword];
+        if (Array.isArray(alternatives) && alternatives.length) {
+            return sampleForSchema(alternatives[0], root, references, depth + 1);
+        }
+    }
+    if (Array.isArray(current.allOf)) {
+        const merged = Object.assign({}, ...current.allOf
+            .map((part) => sampleForSchema(part, root, references, depth + 1))
+            .filter((part) => part && typeof part === "object" && !Array.isArray(part)));
+        if (Object.keys(merged).length)
+            return merged;
+    }
+    const type = Array.isArray(current.type)
+        ? (current.type.find((value) => value !== "null") ?? current.type[0])
+        : current.type;
+    if (type === "object" || current.properties) {
+        const properties = current.properties && typeof current.properties === "object"
+            ? current.properties
+            : {};
+        return Object.fromEntries(Object.entries(properties).map(([key, child]) => [
+            key,
+            sampleForSchema(child, root, references, depth + 1),
+        ]));
+    }
+    if (type === "array" || current.items) {
+        return current.items ? [sampleForSchema(current.items, root, references, depth + 1)] : [];
+    }
+    if (type === "integer") {
+        const minimum = Number(current.minimum ?? current.exclusiveMinimum ?? 0);
+        return Number.isFinite(minimum) ? Math.ceil(minimum) : 0;
+    }
+    if (type === "number") {
+        const minimum = Number(current.minimum ?? current.exclusiveMinimum ?? 0);
+        return Number.isFinite(minimum) ? minimum : 0;
+    }
+    if (type === "boolean")
+        return true;
+    if (type === "null")
+        return null;
+    if (type === "string" || current.format || current.minLength) {
+        const formatSamples = {
+            date: "2026-01-01",
+            "date-time": "2026-01-01T00:00:00Z",
+            email: "user@example.com",
+            hostname: "example.com",
+            ipv4: "192.0.2.1",
+            uri: "https://example.com/",
+            uuid: "00000000-0000-4000-8000-000000000000",
+        };
+        if (typeof current.format === "string" && formatSamples[current.format]) {
+            return formatSamples[current.format];
+        }
+        return "x".repeat(Math.min(100, Math.max(0, Number(current.minLength ?? 0))));
+    }
+    return null;
+}
+export function generateJsonSample(schemaInput) {
+    const schema = parseLosslessJson(schemaInput, { buildTree: true });
+    if (schema.root?.kind !== "object")
+        throw new TypeError("The JSON Schema must be an object.");
+    const nativeSchema = jsonNodeToNative(schema.root, true);
+    const sample = sampleForSchema(nativeSchema, nativeSchema, new Set());
+    return {
+        value: stringifyNativeLosslessly(sample, 2),
+        metadata: schema.metadata,
+    };
+}

package/dist/lib/json-tools.d.ts

@@ -0,0 +1,41 @@
+export type ToolOperation = "format" | "minify" | "validate" | "repair" | "sort" | "yaml" | "csv" | "xml" | "jsonpath" | "compare" | "duplicates" | "precision" | "schema" | "schema_validate" | "schema_sample";
+export type TextEdit = {
+    from: number;
+    to: number;
+    insert: string;
+};
+type ToolSuccess = {
+    ok: true;
+    value: string;
+    edits?: TextEdit[];
+    metadata?: Record<string, string | number | boolean>;
+};
+export type ToolFailure = {
+    ok: false;
+    message: string;
+    line?: number;
+    column?: number;
+    offset?: number;
+    suggestion?: string;
+    metadata?: Record<string, string | number | boolean>;
+};
+export type ToolResult = ToolSuccess | ToolFailure;
+export type ToolRequest = {
+    id: number;
+    operation: ToolOperation;
+    input: string;
+    secondaryInput?: string;
+    indent?: 0 | 2 | 3 | 4 | "tab";
+    query?: string;
+    includeEdits?: boolean;
+};
+export type ToolResponse = {
+    id: number;
+    result: ToolResult;
+};
+export declare function parseJson(input: string): {
+    ok: true;
+    data: unknown;
+} | ToolFailure;
+export declare function runTool(request: Omit<ToolRequest, "id">): Promise<ToolResult>;
+export {};