@spyglassmc/java-edition 0.1.0

package/lib/dependency/mcmeta.js

@@ -0,0 +1,205 @@
+"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.Fluids = exports.symbolRegistrar = exports.getMcmetaSummaryUris = exports.resolveConfiguredVersion = exports.getMajorVersion = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const common_1 = require("./common");
+function getMajorVersion(version) {
+    const dotIndex = version.release_target.indexOf('.', 2);
+    return (dotIndex > 2 ? version.release_target.slice(0, dotIndex) : version.release_target);
+}
+exports.getMajorVersion = getMajorVersion;
+/**
+ * @param inputVersion {@link Config.env.gameVersion}
+ */
+function resolveConfiguredVersion(inputVersion, { packMcmeta, versions }) {
+    function toVersionInfo(index) {
+        if (index < 0) {
+            index = 0;
+        }
+        const version = versions[index];
+        return {
+            id: version.id,
+            name: version.name,
+            major: getMajorVersion(version),
+            isLatest: index === 0,
+        };
+    }
+    if (versions.length === 0) {
+        throw new Error('mcmeta version list is empty');
+    }
+    inputVersion = inputVersion.toLowerCase();
+    versions = versions.sort((a, b) => b.data_version - a.data_version);
+    if (inputVersion === 'auto') {
+        if (packMcmeta) {
+            const major = common_1.PackVersionMap[packMcmeta.pack.pack_format];
+            if (major) {
+                return toVersionInfo(versions.findIndex(v => getMajorVersion(v) === major));
+            }
+        }
+        return toVersionInfo(0);
+    }
+    else if (inputVersion === 'latest release') {
+        return toVersionInfo(versions.findIndex(v => v.type === 'release'));
+    }
+    else if (inputVersion === 'latest snapshot') {
+        return toVersionInfo(versions.findIndex(v => v.type === 'snapshot'));
+    }
+    return toVersionInfo(versions.findIndex(v => inputVersion === v.id.toLowerCase() || inputVersion === v.name.toLowerCase()));
+}
+exports.resolveConfiguredVersion = resolveConfiguredVersion;
+function getMcmetaSummaryUris(version, isLatest, source) {
+    const tag = isLatest ? 'summary' : `${version}-summary`;
+    function getUri(path) {
+        return source.toLowerCase() === 'jsdelivr'
+            ? `https://cdn.jsdelivr.net/gh/misode/mcmeta@${tag}/${path}`
+            : `https://raw.githubusercontent.com/misode/mcmeta/${tag}/${path}`;
+    }
+    return {
+        blocks: getUri('blocks/data.json.gz'),
+        commands: getUri('commands/data.json.gz'),
+        registries: getUri('registries/data.json.gz'),
+    };
+}
+exports.getMcmetaSummaryUris = getMcmetaSummaryUris;
+function symbolRegistrar(summary) {
+    const McmetaSummaryUri = 'mcmeta://summary/registries.json';
+    const SoundsBaseUri = 'https://misode.github.io/sounds/';
+    const WikiBaseUri = 'https://minecraft.fandom.com/wiki/';
+    const getWikiPageName = (id) => id === 'empty' ? 'Air' : id.split('_').map(v => `${v.charAt(0).toUpperCase()}${v.slice(1)}`).join('_');
+    /**
+     * Add states of blocks or fluids to the symbol table.
+     */
+    function addStatesSymbols(category, states, symbols) {
+        const capitalizedCategory = `${category[0].toUpperCase()}${category.slice(1)}`;
+        for (const [id, [properties, defaults]] of Object.entries(states)) {
+            const uri = `${WikiBaseUri}${getWikiPageName(id)}`;
+            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({
+                        data: { subcategory: 'state' },
+                        usage: { type: 'declaration' },
+                    })
+                        .onEach(values, value => {
+                        stateQuery.member(value, valueQuery => {
+                            valueQuery.enter({
+                                data: { subcategory: 'state_value' },
+                                usage: { type: 'declaration' },
+                            });
+                            if (value === defaultValue) {
+                                stateQuery.amend({
+                                    data: {
+                                        relations: {
+                                            default: { category, path: valueQuery.path },
+                                        },
+                                    },
+                                });
+                            }
+                        });
+                    });
+                });
+            });
+        }
+    }
+    function addRegistriesSymbols(registries, symbols) {
+        function isCategory(str) {
+            return (core.FileCategories.includes(str) || core.RegistryCategories.includes(str));
+        }
+        const getUri = (registryId, entryId) => {
+            /* istanbul ignore next */
+            switch (registryId) {
+                case 'attribute':
+                    return `${WikiBaseUri}Attribute#Attributes`;
+                case 'block':
+                case 'enchantment':
+                case 'entity_type':
+                case 'fluid':
+                case 'item':
+                case 'mob_effect':
+                    return `${WikiBaseUri}${getWikiPageName(entryId)}`;
+                case 'block_entity_type':
+                    return `${WikiBaseUri}${getWikiPageName(entryId)}#Block_data`;
+                case 'custom_stat':
+                    return `${WikiBaseUri}Statistics#List_of_custom_statistic_names`;
+                case 'game_event':
+                    return `${WikiBaseUri}Game_event`;
+                case 'loot_condition_type':
+                    return `${WikiBaseUri}Predicate#JSON_structure`;
+                case 'loot_function_type':
+                    return `${WikiBaseUri}Item_modifier#JSON_structure`;
+                case 'loot_number_provider_type':
+                case 'loot_score_provider_type':
+                    return `${WikiBaseUri}Loot_table#Number_Providers`;
+                case 'loot_pool_entry_type':
+                    return `${WikiBaseUri}Loot_table#Tags`;
+                case 'motive':
+                    return `${WikiBaseUri}Painting#Canvases`;
+                case 'potion':
+                    return `${WikiBaseUri}Potion#Item_data`;
+                case 'particle_type':
+                    return `${WikiBaseUri}Java_Edition_data_values#Particles`;
+                case 'recipe_serializer':
+                    return `${WikiBaseUri}Recipe#${entryId}`;
+                case 'sound_event':
+                    return `${SoundsBaseUri}?sound=${entryId}`;
+                case 'stat_type':
+                    return `${WikiBaseUri}Statistics#Statistic_types_and_names`;
+                case 'villager_profession':
+                    return `${WikiBaseUri}Villager#Villager_profession`;
+                case 'villager_type':
+                    return `${WikiBaseUri}Villager#Villager_type`;
+                case 'worldgen/biome_source':
+                    return `${WikiBaseUri}Java_Edition_data_values#Biome_sources`;
+                case 'worldgen/chunk_generator':
+                    return `${WikiBaseUri}Java_Edition_data_values#Chunk_generators`;
+                default:
+                    return McmetaSummaryUri;
+            }
+        };
+        for (const [registryId, registry] of Object.entries(registries)) {
+            if (isCategory(registryId)) {
+                for (const entryId of registry) {
+                    symbols
+                        .query(getUri(registryId, entryId), registryId, core.ResourceLocation.lengthen(entryId))
+                        .enter({ usage: { type: 'declaration' } });
+                }
+            }
+        }
+    }
+    return symbols => {
+        addRegistriesSymbols(summary.registries, symbols);
+        addStatesSymbols('block', summary.blocks, symbols);
+        addStatesSymbols('fluid', summary.fluids, symbols);
+    };
+}
+exports.symbolRegistrar = symbolRegistrar;
+exports.Fluids = {
+    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', level: '1' }],
+    lava: [{ falling: ['false', 'true'] }, { falling: 'false' }],
+    water: [{ falling: ['false', 'true'] }, { falling: 'false' }],
+};
+//#endregion
+//# sourceMappingURL=mcmeta.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import * as core from '@spyglassmc/core';
+export * as dependency from './dependency';
+export * as json from './json';
+export * as mcf from './mcfunction';
+export declare const initialize: core.ProjectInitializer;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,76 @@
+"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.initialize = exports.mcf = exports.json = exports.dependency = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const nbt = __importStar(require("@spyglassmc/nbt"));
+const binder_1 = require("./binder");
+const dependency_1 = require("./dependency");
+const jeJson = __importStar(require("./json"));
+const jeMcf = __importStar(require("./mcfunction"));
+exports.dependency = __importStar(require("./dependency"));
+exports.json = __importStar(require("./json"));
+exports.mcf = __importStar(require("./mcfunction"));
+const initialize = async (ctx) => {
+    async function getPackMcmeta() {
+        let ans;
+        const uri = `${projectRoot}pack.mcmeta`;
+        try {
+            const data = await core.fileUtil.readJson(uri);
+            dependency_1.PackMcmeta.assert(data);
+            ans = data;
+        }
+        catch (e) {
+            if (!core.isEnoent(e)) {
+                // `pack.mcmeta` exists but broken. Log an error.
+                logger.error(`[je.initialize] Failed loading pack.mcmeta “${uri}”`, e);
+            }
+        }
+        return ans;
+    }
+    const { config, downloader, logger, meta, projectRoot } = ctx;
+    meta.registerUriBinder(binder_1.uriBinder);
+    const versions = await (0, dependency_1.getVersions)(ctx.downloader);
+    if (!versions) {
+        ctx.logger.error('[je-initialize] Failed loading game version list. Expect everything to be broken.');
+        return;
+    }
+    const packMcmeta = await getPackMcmeta();
+    const { major, id: version, isLatest } = (0, dependency_1.resolveConfiguredVersion)(config.env.gameVersion, { packMcmeta, versions });
+    meta.registerDependencyProvider('@mc-nbtdoc', () => (0, dependency_1.getMcNbtdoc)(downloader, version, isLatest));
+    const summary = await (0, dependency_1.getMcmetaSummary)(downloader, logger, 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;
+    }
+    meta.registerSymbolRegistrar('mcmeta-summary', {
+        checksum: summary.checksum,
+        registrar: (0, dependency_1.symbolRegistrar)(summary),
+    });
+    jeJson.initialize(ctx);
+    jeMcf.initialize(ctx, summary.commands, major);
+    nbt.initialize(ctx);
+    return {
+        loadedVersion: major,
+    };
+};
+exports.initialize = initialize;
+//# sourceMappingURL=index.js.map

package/lib/json/checker/data/advancement.d.ts

@@ -0,0 +1,14 @@
+export declare const item_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const block_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const fluid_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const location_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const distance_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const mob_effect_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const statistic_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const player_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const entity_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const damage_source_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const damage_predicate: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const criterion: import("@spyglassmc/json/lib/checker").JsonChecker;
+export declare const advancement: import("@spyglassmc/json/lib/checker").JsonChecker;
+//# sourceMappingURL=advancement.d.ts.map