@spyglassmc/json 0.3.2 → 0.3.4

package/lib/index.d.ts

@@ -1,5 +1,4 @@
-import type * as core from '@spyglassmc/core';
-export * as checker from './checker/index.js';
+import * as core from '@spyglassmc/core';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';
 export * as formatter from './formatter/index.js';

package/lib/index.js

@@ -1,9 +1,9 @@
 /* istanbul ignore file */
+import * as core from '@spyglassmc/core';
 import * as colorizer from './colorizer/index.js';
 import * as completer from './completer/index.js';
 import * as formatter from './formatter/index.js';
 import * as parser from './parser/index.js';
-export * as checker from './checker/index.js';
 export * as colorizer from './colorizer/index.js';
 export * as completer from './completer/index.js';
 export * as formatter from './formatter/index.js';
@@ -13,7 +13,7 @@ export const initialize = ({ meta }) => {
     meta.registerLanguage('json', {
         extensions: ['.json', '.mcmeta'],
         triggerCharacters: completer.JsonTriggerCharacters,
-        parser: parser.entry,
+        parser: core.dumpErrors(parser.entry),
     });
     meta.registerParser('json:entry', parser.entry);
     colorizer.register(meta);

package/lib/node/JsonAstNode.d.ts

@@ -1,7 +1,7 @@
 import type { DeepReadonly, ItemNode, PairNode } from '@spyglassmc/core';
 import * as core from '@spyglassmc/core';
-export declare type JsonNode = JsonObjectNode | JsonArrayNode | JsonStringNode | JsonNumberNode | JsonBooleanNode | JsonNullNode;
-export declare type JsonRelatedNode = JsonNode | JsonPairNode | JsonItemNode;
+export type JsonNode = JsonObjectNode | JsonArrayNode | JsonStringNode | JsonNumberNode | JsonBooleanNode | JsonNullNode;
+export type JsonRelatedNode = JsonNode | JsonPairNode | JsonItemNode;
 export declare namespace JsonNode {
     function is(node: core.AstNode): node is JsonNode;
     function isRelated(node: core.AstNode): node is JsonRelatedNode;
@@ -9,7 +9,7 @@ export declare namespace JsonNode {
 interface JsonBaseAstNode {
     expectation?: JsonExpectation[];
 }
-export declare type JsonExpectation = JsonObjectExpectation | JsonArrayExpectation | JsonStringExpectation | JsonNumberExpectation | JsonBooleanExpectation;
+export type JsonExpectation = JsonObjectExpectation | JsonArrayExpectation | JsonStringExpectation | JsonNumberExpectation | JsonBooleanExpectation;
 export declare namespace JsonExpectation {
     function isArray(e: DeepReadonly<JsonExpectation>): e is DeepReadonly<JsonArrayExpectation>;
     function isObject(e: DeepReadonly<JsonExpectation>): e is DeepReadonly<JsonObjectExpectation>;
@@ -35,7 +35,7 @@ export declare namespace JsonObjectNode {
     function is(obj: object | undefined): obj is JsonObjectNode;
     function mock(range: core.RangeLike): JsonObjectNode;
 }
-export declare type JsonPairNode = PairNode<JsonStringNode, JsonNode>;
+export type JsonPairNode = PairNode<JsonStringNode, JsonNode>;
 export declare namespace JsonPairNode {
     function is(obj: object): obj is JsonPairNode;
 }
@@ -50,7 +50,7 @@ export declare namespace JsonArrayNode {
     function is(obj: object | undefined): obj is JsonArrayNode;
     function mock(range: core.RangeLike): JsonArrayNode;
 }
-export declare type JsonItemNode = ItemNode<JsonNode>;
+export type JsonItemNode = ItemNode<JsonNode>;
 export declare namespace JsonItemNode {
     function is(obj: object): obj is JsonItemNode;
 }

package/lib/parser/entry.d.ts

@@ -1,5 +1,4 @@
 import * as core from '@spyglassmc/core';
 import type { JsonNode } from '../node/index.js';
-export declare function json(dumpErrors?: boolean): core.Parser<JsonNode>;
 export declare const entry: core.Parser<JsonNode>;
 //# sourceMappingURL=entry.d.ts.map

package/lib/parser/entry.js

@@ -18,24 +18,18 @@ const LegalNumberStart = new Set([
     '9',
     '-',
 ]);
-export function json(dumpErrors = false) {
-    return (src, ctx) => {
-        const result = core.select([
-            { predicate: (src) => src.tryPeek('['), parser: array },
-            {
-                predicate: (src) => src.tryPeek('false') || src.tryPeek('true'),
-                parser: boolean,
-            },
-            { predicate: (src) => src.tryPeek('null'), parser: null_ },
-            { predicate: (src) => LegalNumberStart.has(src.peek()), parser: number },
-            { predicate: (src) => src.tryPeek('{'), parser: object },
-            { parser: string },
-        ])(src, ctx);
-        if (dumpErrors) {
-            ctx.err.dump();
-        }
-        return result;
-    };
-}
-export const entry = json(true);
+export const entry = (src, ctx) => core.select([
+    { predicate: (src) => src.tryPeek('['), parser: array },
+    {
+        predicate: (src) => src.tryPeek('false') || src.tryPeek('true'),
+        parser: boolean,
+    },
+    { predicate: (src) => src.tryPeek('null'), parser: null_ },
+    {
+        predicate: (src) => LegalNumberStart.has(src.peek()),
+        parser: number,
+    },
+    { predicate: (src) => src.tryPeek('{'), parser: object },
+    { parser: string },
+])(src, ctx);
 //# sourceMappingURL=entry.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/json",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.1",
-    "@spyglassmc/locales": "0.3.1"
+    "@spyglassmc/core": "0.4.3",
+    "@spyglassmc/locales": "0.3.3"
   }
 }

package/lib/checker/JsonChecker.d.ts

@@ -1,8 +0,0 @@
-import type { CheckerContext } from '@spyglassmc/core';
-import type { JsonNode } from '../node/index.js';
-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

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=JsonChecker.js.map

package/lib/checker/index.d.ts

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

package/lib/checker/index.js

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

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

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

package/lib/checker/primitives/boolean.js

@@ -1,9 +0,0 @@
-import { localize } from '@spyglassmc/locales';
-import { JsonBooleanNode } from '../../node/index.js';
-export function boolean(node, ctx) {
-    node.expectation = [{ type: 'json:boolean', typedoc: 'Boolean' }];
-    if (!JsonBooleanNode.is(node)) {
-        ctx.err.report(localize('expected', localize('boolean')), node);
-    }
-}
-//# sourceMappingURL=boolean.js.map

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

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

package/lib/checker/primitives/index.js

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

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

@@ -1,10 +0,0 @@
-import type { JsonNode } from '../../node/index.js';
-import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
-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

@@ -1,48 +0,0 @@
-import { localize } from '@spyglassmc/locales';
-import { JsonArrayNode, JsonStringNode } from '../../node/index.js';
-import { expectation } from './util.js';
-export function listOf(checker) {
-    return (node, ctx) => {
-        node.expectation = [{ type: 'json:array', typedoc: 'Array' }];
-        if (!ctx.depth || ctx.depth <= 0) {
-            ;
-            node.expectation[0].items = expectation(checker, ctx);
-        }
-        if (!JsonArrayNode.is(node)) {
-            ctx.err.report(localize('expected', localize('array')), node);
-        }
-        else {
-            node.children
-                .filter((e) => e.value)
-                .forEach((e) => checker(e.value, ctx));
-        }
-    };
-}
-export function uniqueListOf(checker, options = {}) {
-    const getItem = options.items ??
-        ((node) => [JsonStringNode.is(node) ? node.value : undefined, node]);
-    const reporter = options.report ??
-        ((node, ctx) => ctx.err.report(localize('json.checker.item.duplicate'), node, 2 /* ErrorSeverity.Warning */));
-    return (node, ctx) => {
-        listOf(checker)(node, ctx);
-        if (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));
-        }
-    };
-}
-//# sourceMappingURL=list.js.map

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

@@ -1,6 +0,0 @@
-import type { JsonChecker } from '../JsonChecker.js';
-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

@@ -1,31 +0,0 @@
-import { localize } from '@spyglassmc/locales';
-import { JsonNumberNode } from '../../node/index.js';
-const number = (type) => (min, max) => {
-    return (node, ctx) => {
-        const typedoc = 'Number' +
-            (min === undefined && max === undefined
-                ? ''
-                : `(${min ?? '-∞'}, ${max ?? '+∞'})`);
-        node.expectation = [{ type: 'json:number', typedoc }];
-        if (!JsonNumberNode.is(node) ||
-            (type === 'integer' && !Number.isInteger(node.value))) {
-            ctx.err.report(localize('expected', localize(type)), node);
-        }
-        else if (min !== undefined &&
-            max !== undefined &&
-            (node.value < min || node.value > max)) {
-            ctx.err.report(localize('expected', localize('number.between', min, max)), node);
-        }
-        else if (min !== undefined && node.value < min) {
-            ctx.err.report(localize('expected', localize('number.>=', min)), node);
-        }
-        else if (max !== undefined && node.value > max) {
-            ctx.err.report(localize('expected', localize('number.<=', max)), node);
-        }
-    };
-};
-export const int = number('integer')(undefined, undefined);
-export const float = number('float')(undefined, undefined);
-export const intRange = number('integer');
-export const floatRange = number('float');
-//# sourceMappingURL=number.js.map

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

@@ -1,34 +0,0 @@
-import type { PairNode } from '@spyglassmc/core';
-import type { JsonNode, JsonStringNode } from '../../node/index.js';
-import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
-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

@@ -1,198 +0,0 @@
-import { Range, ResourceLocation } from '@spyglassmc/core';
-import { localeQuote, localize } from '@spyglassmc/locales';
-import { JsonObjectNode, JsonStringExpectation } from '../../node/index.js';
-import { any, expectation } from './util.js';
-function isComplex(checker) {
-    return checker?.checker !== undefined;
-}
-export function object(keys, values, options = {}) {
-    return (node, ctx) => {
-        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);
-                node.expectation[0].fields = fields.map(([key, prop]) => {
-                    return {
-                        key,
-                        value: 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) {
-                ;
-                node.expectation[0].keys = expectation(keys, ctx)?.filter(JsonStringExpectation.is);
-            }
-        }
-        if (!JsonObjectNode.is(node)) {
-            ctx.err.report(localize('expected', 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(localize('json.checker.property.missing', localeQuote(k)), 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(localize('json.checker.property.unknown', localeQuote(key)), prop.key, 2 /* ErrorSeverity.Warning */);
-                    }
-                    return;
-                }
-                if (isComplex(value) && value.deprecated) {
-                    ctx.err.report(localize('json.checker.property.deprecated', localeQuote(key)), prop.key, 0 /* ErrorSeverity.Hint */, { deprecated: true });
-                }
-                const context = ctx.context +
-                    (isComplex(value) && value.context ? `.${value.context}` : '');
-                const doc = localize(`json.doc.${context}`);
-                const propNode = prop.value !== undefined
-                    ? prop.value
-                    : { type: 'json:null', range: 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);
-                    }
-                }
-            });
-        }
-    };
-}
-export function record(properties, options) {
-    return object(Object.keys(properties), (key) => properties[key], options);
-}
-export function opt(checker, defaultValue) {
-    if (checker === undefined)
-        return undefined;
-    return isComplex(checker)
-        ? { ...checker, opt: true, def: defaultValue }
-        : { checker, opt: true, def: defaultValue };
-}
-export function deprecate(checker) {
-    if (checker === undefined)
-        return undefined;
-    return isComplex(checker)
-        ? { ...checker, deprecated: true }
-        : { checker, deprecated: true };
-}
-export function dispatch(arg1, arg2) {
-    return (node, ctx) => {
-        if (!JsonObjectNode.is(node)) {
-            ctx.err.report(localize('expected', 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);
-        }
-    };
-}
-export function pick(value, cases) {
-    if (value === undefined) {
-        return {};
-    }
-    const properties = cases[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: ResourceLocation.shorten(value),
-        };
-    });
-    return properties;
-}
-export function when(value, values, properties, notProperties = {}) {
-    if (value === undefined) {
-        return {};
-    }
-    if (!values.includes(ResourceLocation.shorten(value))) {
-        return notProperties;
-    }
-    return properties;
-}
-export function extract(value, children) {
-    const node = children?.find((p) => p.key?.value === value);
-    return node?.value?.type === 'json:string' ? node.value.value : undefined;
-}
-export 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;
-}
-export 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;
-}
-export function having(node, ctx, cases) {
-    const givenKeys = new Set(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(localize('json.checker.property.missing', Object.keys(cases)), Range.create(node.range.start, node.range.start + 1));
-        return Object.fromEntries(Object.entries(cases).map(([k, v]) => [
-            k,
-            opt(typeof v === 'function' ? any() : v[k] ?? any()),
-        ]));
-    }
-    const c = cases[key];
-    return typeof c === 'function' ? c() : c;
-}
-//# sourceMappingURL=object.js.map

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

@@ -1,12 +0,0 @@
-import type { AllCategory, AstNode, Parser, ResourceLocationCategory, SyncChecker, TaggableResourceLocationCategory } from '@spyglassmc/core';
-import { Lazy } from '@spyglassmc/core';
-import type { JsonExpectation } from '../../node/index.js';
-import { JsonStringNode } from '../../node/index.js';
-import type { JsonChecker } from '../JsonChecker.js';
-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<SyncChecker<T>>, expectation?: Partial<JsonExpectation>): JsonChecker;
-export declare function string(name?: string | readonly string[], parser?: undefined, checker?: Lazy<SyncChecker<JsonStringNode>>, expectation?: Partial<JsonExpectation>): JsonChecker;
-export declare const simpleString: JsonChecker;
-//# sourceMappingURL=string.d.ts.map

package/lib/checker/primitives/string.js

@@ -1,51 +0,0 @@
-import * as core from '@spyglassmc/core';
-import { Failure, Lazy, ResourceLocation } from '@spyglassmc/core';
-import { localize } from '@spyglassmc/locales';
-import { JsonStringNode } from '../../node/index.js';
-export function resource(id, allowTag = false) {
-    return string(id, core.resourceLocation(typeof id === 'string'
-        ? { category: id, allowTag }
-        : { pool: id.map(ResourceLocation.lengthen) }), core.checker.resourceLocation);
-}
-export function literal(value) {
-    return typeof value === 'string'
-        ? string(value, core.symbol(value))
-        : string(value, core.literal(...value));
-}
-export function string(name, parser, checker, expectation) {
-    return (node, ctx) => {
-        node.expectation = [
-            { type: 'json:string', typedoc: typedoc(name), ...expectation },
-        ];
-        if (!JsonStringNode.is(node)) {
-            ctx.err.report(localize('expected', localize('string')), node);
-        }
-        else if (parser) {
-            const result = core.parseStringValue(Lazy.resolve(parser), node.value, node.valueMap, ctx);
-            if (result !== Failure) {
-                node.children = [result];
-                result.parent = node;
-                if (checker) {
-                    Lazy.resolve(checker)(result, ctx);
-                }
-            }
-        }
-        else if (checker) {
-            Lazy.resolve(checker)(node, ctx);
-        }
-    };
-}
-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 ? ' | ...' : ''));
-}
-export const simpleString = string();
-//# sourceMappingURL=string.js.map

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

@@ -1,15 +0,0 @@
-import type { ErrorSeverity } from '@spyglassmc/core';
-import type { JsonExpectation, JsonNode } from '../../node/index.js';
-import type { JsonChecker, JsonCheckerContext } from '../JsonChecker.js';
-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

@@ -1,72 +0,0 @@
-import { ErrorReporter, Range, StateProxy } from '@spyglassmc/core';
-import { arrayToMessage, localize } from '@spyglassmc/locales';
-export function ref(checker) {
-    return (node, ctx) => {
-        return checker()(node, ctx);
-    };
-}
-export function as(context, checker) {
-    return (node, ctx) => {
-        checker(node, { ...ctx, context });
-    };
-}
-export 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 ErrorReporter(),
-        symbols: ctx.symbols.clone(),
-    };
-    checker(node, tempCtx);
-    const tempExpectation = node.expectation;
-    StateProxy.undoChanges(node);
-    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);
-            StateProxy.redoChanges(node);
-            tempCtx.symbols.applyDelayedEdits();
-        },
-    };
-}
-export 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) => localize(e.type.slice(5)));
-            ctx.err.report(localize('expected', arrayToMessage(allowedTypes, false)), node);
-        }
-        else {
-            sameTypeAttempts[0].updateNodeAndCtx();
-        }
-        node.expectation = allExpectations;
-    };
-}
-export function expectation(checker, ctx) {
-    const node = StateProxy.create({
-        type: 'json:null',
-        range: Range.create(0),
-    });
-    const tempCtx = {
-        ...ctx,
-        err: new ErrorReporter(),
-        depth: (ctx.depth ?? 0) + 1,
-    };
-    checker(node, tempCtx);
-    return node.expectation;
-}
-//# sourceMappingURL=util.js.map