@spyglassmc/json 0.1.0

package/lib/checker/JsonChecker.d.ts

@@ -0,0 +1,8 @@
+import type { CheckerContext } from '@spyglassmc/core';
+import type { JsonNode } from '../node';
+export interface JsonCheckerContext extends CheckerContext {
+    context: string;
+    depth?: number;
+}
+export declare type JsonChecker = (node: JsonNode, ctx: JsonCheckerContext) => void;
+//# sourceMappingURL=JsonChecker.d.ts.map

package/lib/checker/JsonChecker.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=JsonChecker.js.map

package/lib/checker/index.d.ts

@@ -0,0 +1,3 @@
+export * from './JsonChecker';
+export * from './primitives';
+//# sourceMappingURL=index.d.ts.map

package/lib/checker/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./JsonChecker"), exports);
+__exportStar(require("./primitives"), exports);
+//# sourceMappingURL=index.js.map

package/lib/checker/primitives/boolean.d.ts

@@ -0,0 +1,4 @@
+import type { JsonNode } from '../../node';
+import type { JsonCheckerContext } from '../JsonChecker';
+export declare function boolean(node: JsonNode, ctx: JsonCheckerContext): void;
+//# sourceMappingURL=boolean.d.ts.map

package/lib/checker/primitives/boolean.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boolean = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const node_1 = require("../../node");
+function boolean(node, ctx) {
+    ctx.ops.set(node, 'expectation', [{ type: 'json:boolean', typedoc: 'Boolean' }]);
+    if (!node_1.JsonBooleanNode.is(node)) {
+        ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('boolean')), node);
+    }
+}
+exports.boolean = boolean;
+//# sourceMappingURL=boolean.js.map

package/lib/checker/primitives/index.d.ts

@@ -0,0 +1,7 @@
+export * from './boolean';
+export * from './list';
+export * from './number';
+export * from './object';
+export * from './string';
+export * from './util';
+//# sourceMappingURL=index.d.ts.map

package/lib/checker/primitives/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./boolean"), exports);
+__exportStar(require("./list"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./util"), exports);
+//# sourceMappingURL=index.js.map

package/lib/checker/primitives/list.d.ts

@@ -0,0 +1,10 @@
+import type { JsonNode } from '../../node';
+import type { JsonChecker, JsonCheckerContext } from '../JsonChecker';
+export declare function listOf(checker: JsonChecker): JsonChecker;
+declare type UniqueListOptions = {
+    items?: (node: JsonNode) => [string | undefined, JsonNode];
+    report?: (node: JsonNode, ctx: JsonCheckerContext) => unknown;
+};
+export declare function uniqueListOf(checker: JsonChecker, options?: UniqueListOptions): JsonChecker;
+export {};
+//# sourceMappingURL=list.d.ts.map

package/lib/checker/primitives/list.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqueListOf = exports.listOf = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const node_1 = require("../../node");
+const util_1 = require("./util");
+function listOf(checker) {
+    return (node, ctx) => {
+        ctx.ops.set(node, 'expectation', [{ type: 'json:array', typedoc: 'Array' }]);
+        if (!ctx.depth || ctx.depth <= 0) {
+            ctx.ops.set(node.expectation[0], 'items', (0, util_1.expectation)(checker, ctx));
+        }
+        if (!node_1.JsonArrayNode.is(node)) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('array')), node);
+        }
+        else {
+            node.children.filter(e => e.value)
+                .forEach(e => checker(e.value, ctx));
+        }
+    };
+}
+exports.listOf = listOf;
+function uniqueListOf(checker, options = {}) {
+    const getItem = (options.items ?? (node => [node_1.JsonStringNode.is(node) ? node.value : undefined, node]));
+    const reporter = options.report ?? ((node, ctx) => ctx.err.report((0, locales_1.localize)('json.checker.item.duplicate'), node, 2 /* Warning */));
+    return (node, ctx) => {
+        listOf(checker)(node, ctx);
+        if (node_1.JsonArrayNode.is(node)) {
+            const items = new Map();
+            const duplicates = new Set();
+            node.children.forEach(c => {
+                if (!c.value)
+                    return;
+                const [value, item] = getItem(c.value);
+                if (!value)
+                    return;
+                const existing = items.get(value);
+                if (existing) {
+                    duplicates.add(existing);
+                    duplicates.add(item);
+                }
+                items.set(value, item);
+            });
+            duplicates.forEach(node => reporter(node, ctx));
+        }
+    };
+}
+exports.uniqueListOf = uniqueListOf;
+//# sourceMappingURL=list.js.map

package/lib/checker/primitives/number.d.ts

@@ -0,0 +1,6 @@
+import type { JsonChecker } from '../JsonChecker';
+export declare const int: JsonChecker;
+export declare const float: JsonChecker;
+export declare const intRange: (min: number | undefined, max: number | undefined) => JsonChecker;
+export declare const floatRange: (min: number | undefined, max: number | undefined) => JsonChecker;
+//# sourceMappingURL=number.d.ts.map

package/lib/checker/primitives/number.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.floatRange = exports.intRange = exports.float = exports.int = void 0;
+const locales_1 = require("@spyglassmc/locales");
+const node_1 = require("../../node");
+const number = (type) => (min, max) => {
+    return (node, ctx) => {
+        const typedoc = 'Number' + (min === undefined && max === undefined ? '' : `(${min ?? '-∞'}, ${max ?? '+∞'})`);
+        ctx.ops.set(node, 'expectation', [{ type: 'json:number', typedoc }]);
+        if (!node_1.JsonNumberNode.is(node) || (type === 'integer' && !Number.isInteger(node.value))) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)(type)), node);
+        }
+        else if (min !== undefined && max !== undefined && (node.value < min || node.value > max)) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('number.between', min, max)), node);
+        }
+        else if (min !== undefined && node.value < min) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('number.>=', min)), node);
+        }
+        else if (max !== undefined && node.value > max) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('number.<=', max)), node);
+        }
+    };
+};
+exports.int = number('integer')(undefined, undefined);
+exports.float = number('float')(undefined, undefined);
+exports.intRange = number('integer');
+exports.floatRange = number('float');
+//# sourceMappingURL=number.js.map

package/lib/checker/primitives/object.d.ts

@@ -0,0 +1,34 @@
+import type { PairNode } from '@spyglassmc/core';
+import type { JsonNode, JsonStringNode } from '../../node';
+import type { JsonChecker, JsonCheckerContext } from '../JsonChecker';
+declare type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+declare type ComplexProperty = {
+    checker: JsonChecker;
+    opt?: boolean;
+    def?: JsonValue;
+    deprecated?: boolean;
+    context?: string;
+};
+declare type CheckerProperty = JsonChecker | ComplexProperty;
+declare type CheckerRecord = Record<string, CheckerProperty | undefined>;
+declare type ObjectCheckerOptions = {
+    allowUnknownProperties?: boolean;
+};
+export declare function object(): JsonChecker;
+export declare function object(keys: string[], values: (key: string, ctx: JsonCheckerContext) => CheckerProperty | undefined, options?: ObjectCheckerOptions): JsonChecker;
+export declare function object(keys: JsonChecker, values: (key: string, ctx: JsonCheckerContext) => CheckerProperty | undefined, options?: ObjectCheckerOptions): JsonChecker;
+export declare function record(properties: CheckerRecord, options?: ObjectCheckerOptions): JsonChecker;
+export declare function opt(checker?: JsonChecker | ComplexProperty, defaultValue?: JsonValue): ComplexProperty | undefined;
+export declare function deprecate(checker?: JsonChecker | ComplexProperty): ComplexProperty | undefined;
+export declare function dispatch(values: (children: PairNode<JsonStringNode, JsonNode>[], ctx: JsonCheckerContext) => JsonChecker): JsonChecker;
+export declare function dispatch(keyName: string, values: (value: string | undefined, children: PairNode<JsonStringNode, JsonNode>[], ctx: JsonCheckerContext) => JsonChecker): JsonChecker;
+export declare function pick(value: string | undefined, cases: Record<string, CheckerRecord>): CheckerRecord;
+export declare function when(value: string | undefined, values: string[], properties: CheckerRecord, notProperties?: CheckerRecord): CheckerRecord;
+export declare function extract(value: string, children: PairNode<JsonStringNode, JsonNode>[] | undefined): string | undefined;
+export declare function extractNested(wrap: string, value: string, children: PairNode<JsonStringNode, JsonNode>[] | undefined): string | undefined;
+export declare function extractStringArray(value: string, children?: PairNode<JsonStringNode, JsonNode>[] | undefined): readonly string[] | undefined;
+export declare function having(node: JsonNode, ctx: JsonCheckerContext, cases: Record<string, CheckerRecord | (() => CheckerRecord)>): CheckerRecord;
+export {};
+//# sourceMappingURL=object.d.ts.map

package/lib/checker/primitives/object.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.having = exports.extractStringArray = exports.extractNested = exports.extract = exports.when = exports.pick = exports.dispatch = exports.deprecate = exports.opt = exports.record = exports.object = void 0;
+const core_1 = require("@spyglassmc/core");
+const locales_1 = require("@spyglassmc/locales");
+const node_1 = require("../../node");
+const util_1 = require("./util");
+function isComplex(checker) {
+    return checker?.checker !== undefined;
+}
+function object(keys, values, options = {}) {
+    return (node, ctx) => {
+        ctx.ops.set(node, 'expectation', [{ type: 'json:object', typedoc: 'Object' }]);
+        if (!ctx.depth || ctx.depth <= 0) {
+            if (Array.isArray(keys) && values) {
+                const fields = keys.map(key => [key, values(key, ctx)]).filter(([_, v]) => v !== undefined);
+                ctx.ops.set(node.expectation[0], 'fields', fields.map(([key, prop]) => {
+                    return {
+                        key,
+                        value: (0, util_1.expectation)(isComplex(prop) ? prop.checker : prop, ctx),
+                        ...isComplex(prop) && (prop.opt || prop.deprecated) ? { opt: true } : {},
+                        ...isComplex(prop) && prop.deprecated ? { deprecated: true } : {},
+                    };
+                }));
+            }
+            else if (typeof keys === 'function' && values) {
+                ctx.ops.set(node.expectation[0], 'keys', (0, util_1.expectation)(keys, ctx)
+                    ?.filter(node_1.JsonStringExpectation.is));
+            }
+        }
+        if (!node_1.JsonObjectNode.is(node)) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('object')), node);
+        }
+        else if (Array.isArray(keys) && values) {
+            const givenKeys = node.children.map(n => n.key?.value);
+            keys.forEach(k => {
+                const value = values(k, ctx);
+                if (!value || isComplex(value) && (value.opt || value.deprecated)) {
+                    return;
+                }
+                if (!givenKeys.includes(k)) {
+                    ctx.err.report((0, locales_1.localize)('json.checker.property.missing', (0, locales_1.localeQuote)(k)), core_1.Range.create(node.range.start, node.range.start + 1));
+                }
+            });
+            node.children.filter(p => p.key).forEach(prop => {
+                const key = prop.key.value;
+                const value = values(key, ctx);
+                if (!value || !keys.includes(key)) {
+                    if (!options.allowUnknownProperties) {
+                        ctx.err.report((0, locales_1.localize)('json.checker.property.unknown', (0, locales_1.localeQuote)(key)), prop.key, 2 /* Warning */);
+                    }
+                    return;
+                }
+                if (isComplex(value) && value.deprecated) {
+                    ctx.err.report((0, locales_1.localize)('json.checker.property.deprecated', (0, locales_1.localeQuote)(key)), prop.key, 0 /* Hint */, { deprecated: true });
+                }
+                const context = ctx.context + (isComplex(value) && value.context ? `.${value.context}` : '');
+                const doc = (0, locales_1.localize)(`json.doc.${context}`);
+                const propNode = prop.value !== undefined ? prop.value : { type: 'json:null', range: core_1.Range.create(0) };
+                const checker = isComplex(value) ? value.checker : value;
+                try {
+                    checker(propNode, { ...ctx, context: `${context}.${key}` });
+                }
+                catch (e) {
+                    const pos = ctx.doc.positionAt(prop.range.start);
+                    ctx.logger.error(`Checking "${key}" at ${pos.line}:${pos.character} in "${ctx.doc.uri}"`, e);
+                }
+                const defaultValue = isComplex(value) ? value.def : undefined;
+                const typedoc = propNode.expectation?.map(e => e.typedoc).join(' | ');
+                prop.key.hover = `\`\`\`typescript\n${context}.${key}: ${typedoc}\n\`\`\`${doc || defaultValue !== undefined ? '\n******\n ' : ''}${doc}${defaultValue !== undefined ? `\n\`@default\` ${JSON.stringify(defaultValue)}` : ''}`;
+            });
+        }
+        else if (typeof keys === 'function' && values) {
+            node.children.filter(p => p.key).forEach(prop => {
+                keys(prop.key, ctx);
+                if (prop.value !== undefined) {
+                    const value = values(prop.key.value, ctx);
+                    if (value) {
+                        const checker = isComplex(value) ? value.checker : value;
+                        checker(prop.value, ctx);
+                    }
+                }
+            });
+        }
+    };
+}
+exports.object = object;
+function record(properties, options) {
+    return object(Object.keys(properties), (key) => properties[key], options);
+}
+exports.record = record;
+function opt(checker, defaultValue) {
+    if (checker === undefined)
+        return undefined;
+    return isComplex(checker)
+        ? { ...checker, opt: true, def: defaultValue }
+        : { checker, opt: true, def: defaultValue };
+}
+exports.opt = opt;
+function deprecate(checker) {
+    if (checker === undefined)
+        return undefined;
+    return isComplex(checker)
+        ? { ...checker, deprecated: true }
+        : { checker, deprecated: true };
+}
+exports.deprecate = deprecate;
+function dispatch(arg1, arg2) {
+    return (node, ctx) => {
+        if (!node_1.JsonObjectNode.is(node)) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('object')), node);
+        }
+        else if (arg2) {
+            const dispatcherIndex = node.children.findIndex(p => p.key?.value === arg1);
+            const dispatcher = node.children[dispatcherIndex];
+            const value = dispatcher?.value?.type === 'json:string' ? dispatcher.value.value : undefined;
+            arg2(value, node.children, ctx)(node, ctx);
+        }
+        else {
+            arg1(node.children, ctx)(node, ctx);
+        }
+    };
+}
+exports.dispatch = dispatch;
+function pick(value, cases) {
+    if (value === undefined) {
+        return {};
+    }
+    const properties = cases[core_1.ResourceLocation.shorten(value)];
+    if (properties === undefined) {
+        return {};
+    }
+    Object.keys(properties).forEach(key => {
+        const p = properties[key];
+        if (p === undefined)
+            return;
+        properties[key] = {
+            checker: isComplex(p) ? p.checker : p,
+            opt: isComplex(p) ? p.opt : undefined,
+            deprecated: isComplex(p) ? p.deprecated : undefined,
+            context: core_1.ResourceLocation.shorten(value),
+        };
+    });
+    return properties;
+}
+exports.pick = pick;
+function when(value, values, properties, notProperties = {}) {
+    if (value === undefined) {
+        return {};
+    }
+    if (!values.includes(core_1.ResourceLocation.shorten(value))) {
+        return notProperties;
+    }
+    return properties;
+}
+exports.when = when;
+function extract(value, children) {
+    const node = children?.find(p => p.key?.value === value);
+    return node?.value?.type === 'json:string' ? node.value.value : undefined;
+}
+exports.extract = extract;
+function extractNested(wrap, value, children) {
+    const wrapper = children?.find(p => p.key?.value === wrap);
+    if (wrapper?.value?.type !== 'json:object')
+        return undefined;
+    const node = wrapper.children?.find(p => p.key?.value === value);
+    return node?.type === 'json:string' ? node.value : undefined;
+}
+exports.extractNested = extractNested;
+function extractStringArray(value, children) {
+    const node = children?.find(p => p.key?.value === value);
+    return node?.value?.type === 'json:array' && node.value.children?.every((n) => n.value?.type === 'json:string')
+        ? node.value.children.map(n => n.value.value)
+        : undefined;
+}
+exports.extractStringArray = extractStringArray;
+function having(node, ctx, cases) {
+    const givenKeys = new Set(node_1.JsonObjectNode.is(node)
+        ? node.children.map(n => n.key?.value) : []);
+    const key = Object.keys(cases).find(c => givenKeys.has(c));
+    if (key === undefined) {
+        ctx.err.report((0, locales_1.localize)('json.checker.property.missing', Object.keys(cases)), core_1.Range.create(node.range.start, node.range.start + 1));
+        return Object.fromEntries(Object.entries(cases)
+            .map(([k, v]) => [k, opt(typeof v === 'function' ? (0, util_1.any)() : v[k] ?? (0, util_1.any)())]));
+    }
+    const c = cases[key];
+    return typeof c === 'function' ? c() : c;
+}
+exports.having = having;
+//# sourceMappingURL=object.js.map

package/lib/checker/primitives/string.d.ts

@@ -0,0 +1,12 @@
+import type { AllCategory, AstNode, Checker, Parser, ResourceLocationCategory, TaggableResourceLocationCategory } from '@spyglassmc/core';
+import { Lazy } from '@spyglassmc/core';
+import type { JsonExpectation } from '../../node';
+import { JsonStringNode } from '../../node';
+import type { JsonChecker } from '../JsonChecker';
+export declare function resource(id: TaggableResourceLocationCategory, allowTag?: boolean): JsonChecker;
+export declare function resource(id: ResourceLocationCategory | string[], allowTag?: false): JsonChecker;
+export declare function literal(value: AllCategory | readonly string[]): JsonChecker;
+export declare function string<T extends AstNode>(name: string | readonly string[] | undefined, parser: Lazy<Parser<T>>, checker?: Lazy<Checker<T>>, expectation?: Partial<JsonExpectation>): JsonChecker;
+export declare function string(name?: string | readonly string[], parser?: undefined, checker?: Lazy<Checker<JsonStringNode>>, expectation?: Partial<JsonExpectation>): JsonChecker;
+export declare const simpleString: JsonChecker;
+//# sourceMappingURL=string.d.ts.map

package/lib/checker/primitives/string.js

@@ -0,0 +1,72 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleString = exports.string = exports.literal = exports.resource = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const locales_1 = require("@spyglassmc/locales");
+const node_1 = require("../../node");
+function resource(id, allowTag = false) {
+    return string(id, core.resourceLocation(typeof id === 'string'
+        ? { category: id, allowTag }
+        : { pool: id.map(core_1.ResourceLocation.lengthen) }), core.checker.resourceLocation);
+}
+exports.resource = resource;
+function literal(value) {
+    return typeof value === 'string'
+        ? string(value, core.symbol(value))
+        : string(value, core.literal(...value));
+}
+exports.literal = literal;
+function string(name, parser, checker, expectation) {
+    return (node, ctx) => {
+        ctx.ops.set(node, 'expectation', [{ type: 'json:string', typedoc: typedoc(name), ...expectation }]);
+        if (!node_1.JsonStringNode.is(node)) {
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.localize)('string')), node);
+        }
+        else if (parser) {
+            const result = core.parseStringValue(core_1.Lazy.resolve(parser), node.value, node.valueMap, ctx);
+            if (result !== core_1.Failure) {
+                node.children = [result];
+                result.parent = node;
+                if (checker) {
+                    core_1.Lazy.resolve(checker)(result, ctx);
+                }
+            }
+        }
+        else if (checker) {
+            core_1.Lazy.resolve(checker)(node, ctx);
+        }
+    };
+}
+exports.string = string;
+function typedoc(id) {
+    if (!id) {
+        return 'String';
+    }
+    if (typeof id === 'string') {
+        return `String("${id}")`;
+    }
+    return id.slice(0, 10).map(e => `"${e}"`).join(' | ')
+        + (id.length > 10 ? ' | ...' : '');
+}
+exports.simpleString = string();
+//# sourceMappingURL=string.js.map

package/lib/checker/primitives/util.d.ts

@@ -0,0 +1,15 @@
+import type { ErrorSeverity } from '@spyglassmc/core';
+import type { JsonExpectation, JsonNode } from '../../node';
+import type { JsonChecker, JsonCheckerContext } from '../JsonChecker';
+export declare function ref(checker: () => JsonChecker): JsonChecker;
+export declare function as(context: string, checker: JsonChecker): JsonChecker;
+export declare type AttemptResult = {
+    totalErrorSpan: number;
+    maxSeverity: ErrorSeverity;
+    expectation?: JsonExpectation[];
+    updateNodeAndCtx: () => void;
+};
+export declare function attempt(checker: JsonChecker, node: JsonNode, ctx: JsonCheckerContext): AttemptResult;
+export declare function any(checkers?: JsonChecker[]): JsonChecker;
+export declare function expectation(checker: JsonChecker, ctx: JsonCheckerContext): JsonExpectation[] | undefined;
+//# sourceMappingURL=util.d.ts.map

package/lib/checker/primitives/util.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expectation = exports.any = exports.attempt = exports.as = exports.ref = void 0;
+const core_1 = require("@spyglassmc/core");
+const locales_1 = require("@spyglassmc/locales");
+function ref(checker) {
+    return (node, ctx) => {
+        return checker()(node, ctx);
+    };
+}
+exports.ref = ref;
+function as(context, checker) {
+    return (node, ctx) => {
+        checker(node, { ...ctx, context });
+    };
+}
+exports.as = as;
+function attempt(checker, node, ctx) {
+    // TODO: The code below is mostly copied from core with some changes to support `expectation`. Could be refactored... I guess.
+    const tempCtx = {
+        ...ctx,
+        err: new core_1.ErrorReporter(),
+        ops: new core_1.Operations(),
+        symbols: ctx.symbols.clone(),
+    };
+    checker(node, tempCtx);
+    const tempExpectation = node.expectation;
+    tempCtx.ops.undo();
+    const totalErrorSpan = tempCtx.err.errors
+        .map(e => e.range.end - e.range.start)
+        .reduce((a, b) => a + b, 0);
+    return {
+        totalErrorSpan,
+        maxSeverity: Math.max(...tempCtx.err.errors.map(e => e.severity)),
+        expectation: tempExpectation,
+        updateNodeAndCtx: () => {
+            ctx.err.absorb(tempCtx.err);
+            tempCtx.ops.redo();
+            tempCtx.symbols.applyDelayedEdits();
+        },
+    };
+}
+exports.attempt = attempt;
+function any(checkers = []) {
+    return (node, ctx) => {
+        if (checkers.length === 0) {
+            return;
+        }
+        const attempts = checkers
+            .map(checker => attempt(checker, node, ctx))
+            .sort((a, b) => a.maxSeverity - b.maxSeverity || a.totalErrorSpan - b.totalErrorSpan);
+        const sameTypeAttempts = attempts
+            .filter(a => a.expectation?.map(e => e.type).includes(node.type));
+        const allExpectations = attempts.filter(a => a.expectation).flatMap(a => a.expectation);
+        if (sameTypeAttempts.length === 0) {
+            const allowedTypes = allExpectations.map(e => (0, locales_1.localize)(e.type.slice(5)));
+            ctx.err.report((0, locales_1.localize)('expected', (0, locales_1.arrayToMessage)(allowedTypes, false)), node);
+        }
+        else {
+            sameTypeAttempts[0].updateNodeAndCtx();
+        }
+        ctx.ops.set(node, 'expectation', allExpectations);
+    };
+}
+exports.any = any;
+function expectation(checker, ctx) {
+    const node = { type: 'json:null', range: core_1.Range.create(0) };
+    const tempCtx = {
+        ...ctx,
+        err: new core_1.ErrorReporter(),
+        depth: (ctx.depth ?? 0) + 1,
+    };
+    checker(node, tempCtx);
+    return node.expectation;
+}
+exports.expectation = expectation;
+//# sourceMappingURL=util.js.map

package/lib/colorizer/index.d.ts

@@ -0,0 +1,7 @@
+import type { Colorizer, MetaRegistry } from '@spyglassmc/core';
+import type { JsonBooleanNode, JsonNullNode, JsonObjectNode } from '../node';
+export declare const boolean: Colorizer<JsonBooleanNode>;
+export declare const null_: Colorizer<JsonNullNode>;
+export declare const object: Colorizer<JsonObjectNode>;
+export declare function register(meta: MetaRegistry): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/colorizer/index.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = exports.object = exports.null_ = exports.boolean = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const core_1 = require("@spyglassmc/core");
+const boolean = node => {
+    return [core_1.ColorToken.create(node, 'literal')];
+};
+exports.boolean = boolean;
+const null_ = node => {
+    return [core_1.ColorToken.create(node, 'literal')];
+};
+exports.null_ = null_;
+const object = (node, ctx) => {
+    const ans = [];
+    for (const pair of node.children) {
+        if (pair.key) {
+            ans.push(core_1.ColorToken.create(pair.key, 'property'));
+        }
+        if (pair.value) {
+            const colorizer = ctx.meta.getColorizer(pair.value.type);
+            ans.push(...colorizer(pair.value, ctx));
+        }
+    }
+    return ans;
+};
+exports.object = object;
+function register(meta) {
+    meta.registerColorizer('json:boolean', exports.boolean);
+    meta.registerColorizer('json:null', exports.null_);
+    meta.registerColorizer('json:number', core.colorizer.number);
+    meta.registerColorizer('json:object', exports.object);
+    meta.registerColorizer('json:string', core.colorizer.string);
+}
+exports.register = register;
+//# sourceMappingURL=index.js.map