@spyglassmc/java-edition 0.3.8 → 0.3.10

package/lib/dependency/mcmeta.js

@@ -2,7 +2,7 @@ import * as core from '@spyglassmc/core';
 /**
  * @param inputVersion {@link core.Config.env.gameVersion}
  */
-export function resolveConfiguredVersion(inputVersion, { packMcmeta, versions, }) {
+export async function resolveConfiguredVersion(inputVersion, versions, getPackMcmeta) {
     function findReleaseTarget(version) {
         if (version.release_target) {
             return version.release_target;
@@ -35,6 +35,7 @@ export function resolveConfiguredVersion(inputVersion, { packMcmeta, versions, }
     versions = versions.sort((a, b) => b.data_version - a.data_version);
     const latestRelease = versions.find((v) => v.type === 'release');
     if (inputVersion === 'auto') {
+        const packMcmeta = await getPackMcmeta();
         if (packMcmeta && latestRelease) {
             // If the pack format is larger than the latest release, use the latest snapshot
             if (packMcmeta.pack.pack_format > latestRelease.data_pack_version) {
@@ -66,8 +67,7 @@ export function resolveConfiguredVersion(inputVersion, { packMcmeta, versions, }
     else if (inputVersion === 'latest snapshot') {
         return toVersionInfo(versions[0]);
     }
-    return toVersionInfo(versions.find((v) => inputVersion === v.id.toLowerCase() ||
-        inputVersion === v.name.toLowerCase()));
+    return toVersionInfo(versions.find((v) => inputVersion === v.id.toLowerCase() || inputVersion === v.name.toLowerCase()));
 }
 const DataSources = {
     fastly: 'https://fastly.jsdelivr.net/gh/${user}/${repo}@${tag}/${path}',
@@ -78,11 +78,7 @@ export function getMcmetaSummaryUris(version, isLatest, source) {
     const tag = isLatest ? 'summary' : `${version}-summary`;
     function getUri(path) {
         const template = DataSources[source.toLowerCase()] ?? source;
-        const ans = template
-            .replace(/\${user}/g, 'misode')
-            .replace(/\${repo}/g, 'mcmeta')
-            .replace(/\${tag}/g, tag)
-            .replace(/\${path}/g, path);
+        const ans = template.replace(/\${user}/g, 'misode').replace(/\${repo}/g, 'mcmeta').replace(/\${tag}/g, tag).replace(/\${path}/g, path);
         if (!core.RemoteUriString.is(ans)) {
             throw new Error(`Expected a remote URI from data source template but got ${ans}`);
         }
@@ -103,17 +99,13 @@ export function symbolRegistrar(summary) {
         const capitalizedCategory = `${category[0].toUpperCase()}${category.slice(1)}`;
         for (const [id, [properties, defaults]] of Object.entries(states)) {
             const uri = McmetaSummaryUri;
-            symbols
-                .query(uri, category, core.ResourceLocation.lengthen(id))
-                .onEach(Object.entries(properties), ([state, values], blockQuery) => {
+            symbols.query(uri, category, core.ResourceLocation.lengthen(id)).onEach(Object.entries(properties), ([state, values], blockQuery) => {
                 const defaultValue = defaults[state];
                 blockQuery.member(`${uri}#${capitalizedCategory}_states`, state, (stateQuery) => {
-                    stateQuery
-                        .enter({
+                    stateQuery.enter({
                         data: { subcategory: 'state' },
                         usage: { type: 'declaration' },
-                    })
-                        .onEach(values, (value) => {
+                    }).onEach(values, (value) => {
                         stateQuery.member(value, (valueQuery) => {
                             valueQuery.enter({
                                 data: { subcategory: 'state_value' },
@@ -121,14 +113,7 @@ export function symbolRegistrar(summary) {
                             });
                             if (value === defaultValue) {
                                 stateQuery.amend({
-                                    data: {
-                                        relations: {
-                                            default: {
-                                                category,
-                                                path: valueQuery.path,
-                                            },
-                                        },
-                                    },
+                                    data: { relations: { default: { category, path: valueQuery.path } } },
                                 });
                             }
                         });
@@ -139,38 +124,36 @@ export function symbolRegistrar(summary) {
     }
     function addRegistriesSymbols(registries, symbols) {
         function isCategory(str) {
-            return (core.FileCategories.includes(str) ||
-                core.RegistryCategories.includes(str));
+            return (core.FileCategories.includes(str)
+                || core.RegistryCategories.includes(str));
         }
         for (const [registryId, registry] of Object.entries(registries)) {
             if (isCategory(registryId)) {
                 for (const entryId of registry) {
-                    symbols
-                        .query(McmetaSummaryUri, registryId, core.ResourceLocation.lengthen(entryId))
+                    symbols.query(McmetaSummaryUri, registryId, core.ResourceLocation.lengthen(entryId))
                         .enter({ usage: { type: 'declaration' } });
                 }
             }
         }
     }
+    function addBuiltinSymbols(symbols) {
+        symbols.query(McmetaSummaryUri, 'loot_table', 'minecraft:empty')
+            .enter({ usage: { type: 'declaration' } });
+    }
     return (symbols) => {
         addRegistriesSymbols(summary.registries, symbols);
         addStatesSymbols('block', summary.blocks, symbols);
         addStatesSymbols('fluid', summary.fluids, symbols);
+        addBuiltinSymbols(symbols);
     };
 }
 export const Fluids = {
-    flowing_lava: [
-        {
-            falling: ['false', 'true'],
-            level: ['1', '2', '3', '4', '5', '6', '7', '8'],
-        },
-        { falling: 'false', level: '1' },
-    ],
+    flowing_lava: [{ falling: ['false', 'true'], level: ['1', '2', '3', '4', '5', '6', '7', '8'] }, {
+            falling: 'false',
+            level: '1',
+        }],
     flowing_water: [
-        {
-            falling: ['false', 'true'],
-            level: ['1', '2', '3', '4', '5', '6', '7', '8'],
-        },
+        { falling: ['false', 'true'], level: ['1', '2', '3', '4', '5', '6', '7', '8'] },
         { falling: 'false', level: '1' },
     ],
     lava: [{ falling: ['false', 'true'] }, { falling: 'false' }],

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 import * as core from '@spyglassmc/core';
+export * as binder from './binder/index.js';
 export * as dependency from './dependency/index.js';
 export * as json from './json/index.js';
 export * as mcf from './mcfunction/index.js';

package/lib/index.js

@@ -1,23 +1,22 @@
 import * as core from '@spyglassmc/core';
+import * as json from '@spyglassmc/json';
 import * as mcdoc from '@spyglassmc/mcdoc';
 import * as nbt from '@spyglassmc/nbt';
 import { uriBinder } from './binder/index.js';
-import { getVanillaDatapack } from './dependency/index.js';
-import { getMcmetaSummary, getVanillaMcdoc, getVersions, PackMcmeta, resolveConfiguredVersion, symbolRegistrar, } from './dependency/index.js';
+import { getMcmetaSummary, getVanillaDatapack, getVanillaMcdoc, getVersions, PackMcmeta, ReleaseVersion, resolveConfiguredVersion, symbolRegistrar, } from './dependency/index.js';
 import * as jeJson from './json/index.js';
 import * as jeMcf from './mcfunction/index.js';
+export * as binder from './binder/index.js';
 export * as dependency from './dependency/index.js';
 export * as json from './json/index.js';
 export * as mcf from './mcfunction/index.js';
 export const initialize = async (ctx) => {
     const { config, downloader, externals, logger, meta, projectRoot } = ctx;
-    async function getPackMcmeta() {
-        let ans;
-        const uri = `${projectRoot}pack.mcmeta`;
+    async function readPackMcmeta(uri) {
         try {
             const data = await core.fileUtil.readJson(externals, uri);
             PackMcmeta.assert(data);
-            ans = data;
+            return data;
         }
         catch (e) {
             if (!externals.error.isKind(e, 'ENOENT')) {
@@ -25,7 +24,26 @@ export const initialize = async (ctx) => {
                 logger.error(`[je.initialize] Failed loading pack.mcmeta “${uri}”`, e);
             }
         }
-        return ans;
+        return undefined;
+    }
+    async function findPackMcmeta() {
+        const searched = new Set();
+        for (let depth = 0; depth <= 2; depth += 1) {
+            const files = await externals.fs.getAllFiles(projectRoot, depth + 1);
+            for (const uri of files.filter(uri => uri.endsWith('/pack.mcmeta'))) {
+                if (searched.has(uri)) {
+                    continue;
+                }
+                searched.add(uri);
+                const data = await readPackMcmeta(uri);
+                if (data) {
+                    logger.info(`[je.initialize] Found a valid pack.mcmeta “${uri}” with pack_format “${data.pack.pack_format}”`);
+                    return data;
+                }
+            }
+        }
+        logger.warn('[je.initialize] Failed finding a valid pack.mcmeta');
+        return undefined;
     }
     meta.registerUriBinder(uriBinder);
     const versions = await getVersions(ctx.externals, ctx.downloader);
@@ -33,18 +51,12 @@ export const initialize = async (ctx) => {
         ctx.logger.error('[je-initialize] Failed loading game version list. Expect everything to be broken.');
         return;
     }
-    const packMcmeta = await getPackMcmeta();
-    const { release, id: version, isLatest, } = resolveConfiguredVersion(config.env.gameVersion, {
-        packMcmeta,
-        versions,
-    });
-    meta.registerDependencyProvider('@vanilla-datapack', () => getVanillaDatapack(downloader, version, isLatest));
+    const version = await resolveConfiguredVersion(config.env.gameVersion, versions, findPackMcmeta);
+    const release = version.release;
+    meta.registerDependencyProvider('@vanilla-datapack', () => getVanillaDatapack(downloader, version.id, version.isLatest));
     meta.registerDependencyProvider('@vanilla-mcdoc', () => getVanillaMcdoc(downloader));
-    const summary = await getMcmetaSummary(ctx.externals, downloader, logger, version, isLatest, config.env.dataSource, config.env.mcmetaSummaryOverrides);
-    if (!summary.blocks ||
-        !summary.commands ||
-        !summary.fluids ||
-        !summary.registries) {
+    const summary = await getMcmetaSummary(ctx.externals, downloader, logger, version.id, version.isLatest, config.env.dataSource, config.env.mcmetaSummaryOverrides);
+    if (!summary.blocks || !summary.commands || !summary.fluids || !summary.registries) {
         ctx.logger.error('[je-initialize] Failed loading mcmeta summaries. Expect everything to be broken.');
         return;
     }
@@ -57,23 +69,53 @@ export const initialize = async (ctx) => {
         linter: core.linter.nameConvention('value'),
         nodePredicate: (n) => 
         // nbt compound keys without mcdoc definition.
-        (!n.symbol &&
-            n.parent?.parent?.type === 'nbt:compound' &&
-            core.PairNode.is(n.parent) &&
-            n.type === 'string' &&
-            n.parent.key === n) ||
-            // nbt path keys without mcdoc definition.
-            (!n.symbol && n.parent?.type === 'nbt:path' && n.type === 'string') ||
-            // mcdoc compound key definition outside of `::minecraft` modules.
-            (mcdoc.StructFieldNode.is(n.parent) &&
-                mcdoc.StructKeyNode.is(n) &&
-                !n.symbol?.path[0]?.startsWith('::minecraft')),
+        (!n.symbol
+            && n.parent?.parent?.type === 'nbt:compound'
+            && core.PairNode.is(n.parent)
+            && n.type === 'string'
+            && n.parent.key === n) // nbt path keys without mcdoc definition.
+            || (!n.symbol && n.parent?.type === 'nbt:path' && n.type === 'string') // mcdoc compound key definition outside of `::minecraft` modules.
+            || (mcdoc.StructFieldNode.is(n.parent)
+                && mcdoc.StructKeyNode.is(n)
+                && !n.symbol?.path[0]?.startsWith('::minecraft')),
+    });
+    mcdoc.runtime.registerAttribute(meta, 'since', mcdoc.runtime.attribute.validator.string, {
+        filterElement: (config, ctx) => {
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "since": ${config}`);
+                return true;
+            }
+            return ReleaseVersion.cmp(release, config) >= 0;
+        },
+    });
+    mcdoc.runtime.registerAttribute(meta, 'until', mcdoc.runtime.attribute.validator.string, {
+        filterElement: (config, ctx) => {
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "until": ${config}`);
+                return true;
+            }
+            return ReleaseVersion.cmp(release, config) < 0;
+        },
+    });
+    mcdoc.runtime.registerAttribute(meta, 'deprecated', mcdoc.runtime.attribute.validator.optional(mcdoc.runtime.attribute.validator.string), {
+        mapField: (config, field, ctx) => {
+            if (config === undefined) {
+                return { ...field, deprecated: true };
+            }
+            if (!config.startsWith('1.')) {
+                ctx.logger.warn(`Invalid mcdoc attribute for "deprecated": ${config}`);
+                return field;
+            }
+            if (ReleaseVersion.cmp(release, config) >= 0) {
+                return { ...field, deprecated: true };
+            }
+            return field;
+        },
     });
+    json.initialize(ctx);
     jeJson.initialize(ctx);
     jeMcf.initialize(ctx, summary.commands, release);
     nbt.initialize(ctx);
-    return {
-        loadedVersion: release,
-    };
+    return { loadedVersion: release };
 };
 //# sourceMappingURL=index.js.map

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

@@ -1,12 +1,5 @@
-import * as core from '@spyglassmc/core';
-import type { JsonNode } from '@spyglassmc/json';
-import * as mcdoc from '@spyglassmc/mcdoc';
-export declare const entry: core.Checker<JsonNode>;
+import type * as core from '@spyglassmc/core';
+import * as json from '@spyglassmc/json';
+export declare const file: core.Checker<json.JsonFileNode>;
 export declare function register(meta: core.MetaRegistry): void;
-/**
- * @param identifier An identifier of mcdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
- */
-export declare function definition(identifier: `::${string}::${string}`): core.SyncChecker<JsonNode>;
-export declare function object(typeDef: mcdoc.StructType): core.SyncChecker<JsonNode>;
-export declare function fieldValue(type: mcdoc.McdocType): core.SyncChecker<JsonNode>;
 //# sourceMappingURL=index.d.ts.map

package/lib/json/checker/index.js

@@ -1,251 +1,43 @@
-import * as core from '@spyglassmc/core';
-import { JsonObjectNode } from '@spyglassmc/json';
-import { localeQuote, localize } from '@spyglassmc/locales';
-import * as mcdoc from '@spyglassmc/mcdoc';
-import { dissectUri } from '../../binder/index.js';
-const Checkers = new Map([
-    ['advancement', '::java::data::advancement::Advancement'],
-    ['dimension', '::java::data::worldgen::dimension::Dimension'],
-    ['dimension_type', '::java::data::worldgen::dimension::DimensionType'],
-    ['item_modifier', '::java::data::item_modifier::ItemModifier'],
-    ['loot_table', '::java::data::loot::LootTable'],
-    ['predicate', '::java::data::predicate::Predicate'],
-    ['recipe', '::java::data::recipe::Recipe'],
-    ['worldgen/biome', '::java::data::worldgen::biome::Biome'],
-    [
-        'worldgen/configured_carver',
-        '::java::data::worldgen::carver::ConfiguredCarver',
-    ],
-    [
-        'worldgen/configured_surface_builder',
-        '::java::data::worldgen::surface_builder::ConfiguredSurfaceBuilder',
-    ],
-    ['worldgen/configured_feature', '::java::data::feature::ConfiguredFeature'],
-    [
-        'worldgen/configured_structure_feature',
-        '::java::data::worldgen::structure::Structure',
-    ],
-    [
-        'worldgen/density_function',
-        '::java::data::worldgen::density_function::DensityFunction',
-    ],
-    [
-        'worldgen/noise',
-        '::java::data::worldgen::dimension::biome_source::NoiseParameters',
-    ],
-    [
-        'worldgen/noise_settings',
-        '::java::data::worldgen::noise_settings::NoiseGeneratorSettings',
-    ],
-    [
-        'worldgen/processor_list',
-        '::java::data::worldgen::processor_list::ProcessorList',
-    ],
-    [
-        'worldgen/template_pool',
-        '::java::data::worldgen::template_pool::TemplatePool',
-    ],
-]);
-export const entry = (node, ctx) => {
-    const parts = dissectUri(ctx.doc.uri, ctx);
-    if (parts && Checkers.has(parts.category)) {
-        const identifier = Checkers.get(parts.category);
-        return definition(identifier)(node, ctx);
-    }
-    else if (parts?.category.startsWith('tag/')) {
-        // TODO
+import * as json from '@spyglassmc/json';
+import { dissectUri, reportDissectError } from '../../binder/index.js';
+function createTagDefinition(registry) {
+    const id = {
+        kind: 'tree',
+        values: {
+            registry: { kind: 'literal', value: { kind: 'string', value: registry } },
+            tags: { kind: 'literal', value: { kind: 'string', value: 'allowed' } },
+        },
+    };
+    return {
+        kind: 'concrete',
+        child: { kind: 'reference', path: '::java::data::tag::Tag' },
+        typeArgs: [{ kind: 'string', attributes: [{ name: 'id', value: id }] }],
+    };
+}
+export const file = (node, ctx) => {
+    const child = node.children[0];
+    if (ctx.doc.uri.endsWith('/pack.mcmeta')) {
+        const type = { kind: 'reference', path: '::java::pack::Pack' };
+        return json.checker.index(type)(child, ctx);
     }
-    else if (ctx.doc.uri.endsWith('/pack.mcmeta')) {
-        return definition('::java::Pack')(node, ctx);
+    const parts = dissectUri(ctx.doc.uri, ctx);
+    if (parts?.ok) {
+        if (parts?.category.startsWith('tag/')) {
+            const type = createTagDefinition(parts.category.slice(4));
+            return json.checker.index(type)(child, ctx);
+        }
+        const type = {
+            kind: 'dispatcher',
+            registry: 'minecraft:resource',
+            parallelIndices: [{ kind: 'static', value: parts.category }],
+        };
+        return json.checker.index(type, { discardDuplicateKeyErrors: true })(child, ctx);
     }
-    else {
-        return;
+    else if (parts?.ok === false) {
+        reportDissectError(parts.path, parts.expected, ctx);
     }
 };
 export function register(meta) {
-    meta.registerChecker('json:array', entry);
-    meta.registerChecker('json:boolean', entry);
-    meta.registerChecker('json:null', entry);
-    meta.registerChecker('json:number', entry);
-    meta.registerChecker('json:object', entry);
-    meta.registerChecker('json:string', entry);
-}
-/**
- * @param identifier An identifier of mcdoc compound definition. e.g. `::minecraft::util::invitem::InventoryItem`
- */
-export function definition(identifier) {
-    return (node, ctx) => {
-        const symbol = ctx.symbols.query(ctx.doc, 'mcdoc', identifier);
-        const typeDef = symbol.getData(mcdoc.binder.TypeDefSymbolData.is)?.typeDef;
-        if (!typeDef) {
-            return;
-        }
-        switch (typeDef.kind) {
-            case 'struct':
-                object(typeDef)(node, ctx);
-                break;
-            default:
-                ctx.logger.error(`[json.checker.definition] Expected a struct type, but got ${typeDef.kind}`);
-        }
-    };
-}
-export function object(typeDef) {
-    return (node, ctx) => {
-        if (!JsonObjectNode.is(node)) {
-            // TODO
-            return;
-        }
-        for (const { key: keyNode, value: valueNode } of node.children) {
-            if (!keyNode || !valueNode) {
-                continue;
-            }
-            const key = keyNode.value;
-            // TODO: handle spread types
-            const fieldDef = typeDef.fields.find((p) => p.kind === 'pair' && p.key === key);
-            if (fieldDef) {
-                // TODO: enter a reference to the mcdoc key
-                fieldValue(fieldDef.type)(valueNode, ctx);
-            }
-            else {
-                ctx.err.report(localize('unknown-key', localeQuote(key)), keyNode, 2 /* core.ErrorSeverity.Warning */);
-            }
-        }
-        // TODO: check for required fields
-    };
-}
-export function fieldValue(type) {
-    const isInRange = (value, { kind, min = -Infinity, max = Infinity }) => {
-        const comparator = (a, b, exclusive) => exclusive ? a < b : a <= b;
-        return (comparator(min, value, kind & 0b10) &&
-            comparator(value, max, kind & 0b01));
-    };
-    const ExpectedTypes = {
-        boolean: 'json:boolean',
-        byte: 'json:number',
-        byte_array: 'json:array',
-        double: 'json:number',
-        float: 'json:number',
-        int: 'json:number',
-        int_array: 'json:array',
-        list: 'json:array',
-        long: 'json:number',
-        long_array: 'json:array',
-        short: 'json:number',
-        string: 'json:string',
-        struct: 'json:object',
-        tuple: 'json:array',
-    };
-    return (node, ctx) => {
-        // Rough type check.
-        if (type.kind !== 'any' &&
-            type.kind !== 'dispatcher' &&
-            type.kind !== 'enum' &&
-            type.kind !== 'literal' &&
-            type.kind !== 'reference' &&
-            type.kind !== 'union' &&
-            type.kind !== 'attributed' &&
-            type.kind !== 'unsafe' &&
-            type.kind !== 'concrete' &&
-            type.kind !== 'indexed' &&
-            type.kind !== 'template' &&
-            node.type !== ExpectedTypes[type.kind]) {
-            ctx.err.report(localize('expected', localizeTag(ExpectedTypes[type.kind])), node, 2 /* core.ErrorSeverity.Warning */);
-            return;
-        }
-        switch (type.kind) {
-            case 'boolean':
-                break;
-            case 'byte_array':
-            case 'int_array':
-            case 'long_array':
-                node = node;
-                if (type.lengthRange &&
-                    !isInRange(node.children.length, type.lengthRange)) {
-                    ctx.err.report(localize('expected', localize('json.checker.array.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
-                }
-                if (type.valueRange) {
-                    for (const { value: childNode } of node.children) {
-                        if (childNode?.type !== 'json:number') {
-                            ctx.err.report(localize('expected', localizeTag('json:number')), node, 2 /* core.ErrorSeverity.Warning */);
-                        }
-                        else if (childNode &&
-                            !isInRange(Number(childNode.value), type.valueRange)) {
-                            ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
-                        }
-                    }
-                }
-                break;
-            case 'byte':
-            case 'short':
-            case 'int':
-            case 'long':
-            case 'float':
-            case 'double':
-                node = node;
-                if (type.valueRange &&
-                    !isInRange(Number(node.value), type.valueRange)) {
-                    ctx.err.report(localize('number.between', type.valueRange.min ?? '-∞', type.valueRange.max ?? '+∞'), node, 2 /* core.ErrorSeverity.Warning */);
-                }
-                break;
-            case 'dispatcher':
-                node = node;
-                // const id = resolveFieldPath(node.parent?.parent, type.index.path)
-                // if (type.index.registry) {
-                // 	if (ExtendableRootRegistry.is(type.index.registry)) {
-                // 		index(type.index.registry, id ? core.ResourceLocation.lengthen(id) : undefined, options)(node, ctx)
-                // 	} else if (id) {
-                // 		index(type.index.registry, core.ResourceLocation.lengthen(id), options)(node, ctx)
-                // 	}
-                // }
-                break;
-            case 'list':
-                node = node;
-                type = mcdoc.simplifyListType(type);
-                if (type.lengthRange &&
-                    !isInRange(node.children.length, type.lengthRange)) {
-                    ctx.err.report(localize('expected', localize('json.checker.collection.length-between', localizeTag(node.type), type.lengthRange.min ?? '-∞', type.lengthRange.max ?? '+∞')), node, 2 /* core.ErrorSeverity.Warning */);
-                }
-                for (const { value: childNode } of node.children) {
-                    if (childNode) {
-                        fieldValue(type.item)(childNode, ctx);
-                    }
-                }
-                break;
-            case 'struct':
-                node = node;
-                object(type)(node, ctx);
-                break;
-            case 'string':
-                break;
-            case 'reference':
-                // node = node as JsonObjectNode
-                // if (type.symbol) {
-                // 	const { allowUnknownKey, value } = resolveSymbolPaths([type.symbol], ctx, node)
-                // 	compound(value, { ...options, allowUnknownKey: options.allowUnknownKey || allowUnknownKey })(node, ctx)
-                // }
-                break;
-            case 'union':
-                type = mcdoc.flattenUnionType(type);
-                if (type.members.length === 0) {
-                    ctx.err.report(localize('json.checker.object.field.union-empty-members'), core.PairNode.is(node.parent)
-                        ? node.parent.key ?? node.parent
-                        : node, 2 /* core.ErrorSeverity.Warning */);
-                }
-                else {
-                    ;
-                    core.checker.any(type.members.map((t) => fieldValue(t)))(node, ctx);
-                }
-                break;
-            case 'attributed':
-                // TODO: don't just ignore the attribute
-                fieldValue(type.child)(node, ctx);
-                break;
-        }
-    };
-}
-function localizeTag(type) {
-    const key = `json.node.${type.replace(/^json:/, '')}`;
-    const res = localize(key);
-    return res;
+    meta.registerChecker('json:file', file);
 }
 //# sourceMappingURL=index.js.map

package/lib/json/index.d.ts

@@ -1,4 +1,3 @@
 import type * as core from '@spyglassmc/core';
-export * as checker from './checker/index.js';
 export declare const initialize: (ctx: core.ProjectInitializerContext) => void;
 //# sourceMappingURL=index.d.ts.map

package/lib/json/index.js

@@ -1,9 +1,6 @@
 /* istanbul ignore file */
-import * as json from '@spyglassmc/json';
 import * as checker from './checker/index.js';
-export * as checker from './checker/index.js';
 export const initialize = (ctx) => {
-    json.initialize(ctx);
     checker.register(ctx.meta);
 };
 //# sourceMappingURL=index.js.map

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

@@ -1,7 +1,5 @@
 import * as core from '@spyglassmc/core';
 import * as mcf from '@spyglassmc/mcfunction';
-import { EntityNode } from '../node/index.js';
 export declare const command: core.Checker<mcf.CommandNode>;
-export declare const getTypesFromEntity: (entity: EntityNode, ctx: core.CheckerContext) => core.FullResourceLocation[] | undefined;
 export declare function register(meta: core.MetaRegistry): void;
 //# sourceMappingURL=index.d.ts.map