@spyglassmc/java-edition 0.3.37 → 0.3.39

package/lib/dependency/common.d.ts

@@ -14,27 +14,19 @@ export declare namespace ReleaseVersion {
      */
     function isBetween(version: ReleaseVersion, since: ReleaseVersion, until: ReleaseVersion): boolean;
 }
-export type VersionInfoReason = 'auto' | 'config' | 'fallback';
 export interface VersionInfo {
     release: ReleaseVersion;
     id: string;
     name: string;
     isLatest: boolean;
-    reason: VersionInfoReason;
-}
-export interface PackMcmeta {
-    pack: {
-        pack_format: number;
-    };
 }
 export declare namespace PackMcmeta {
-    function assert(data: any): asserts data is PackMcmeta;
+    function readPackFormat(data: any): number;
     function getType(packRoot: string, externals: core.Externals): Promise<"assets" | "data">;
 }
 export interface PackInfo {
     type: 'data' | 'assets';
     packRoot: string;
-    packMcmeta: PackMcmeta | undefined;
-    versionInfo: VersionInfo;
+    format: number;
 }
 //# sourceMappingURL=common.d.ts.map

package/lib/dependency/common.js

@@ -21,13 +21,21 @@ export var ReleaseVersion;
 })(ReleaseVersion || (ReleaseVersion = {}));
 export var PackMcmeta;
 (function (PackMcmeta) {
-    function assert(data) {
-        const format = data?.pack?.pack_format?.toString();
-        if (!format) {
-            throw new Error('“pack.pack_format” undefined');
+    function readPackFormat(data) {
+        const supported = data?.pack?.supported_formats;
+        if (Array.isArray(supported) && supported.length === 2 && typeof supported[1] === 'number') {
+            return supported[1];
         }
+        if (typeof supported === 'object' && typeof supported?.max_inclusive === 'number') {
+            return supported.max_inclusive;
+        }
+        const format = data?.pack?.pack_format;
+        if (typeof format === 'number') {
+            return format;
+        }
+        throw new Error('“pack.pack_format” is not a number');
     }
-    PackMcmeta.assert = assert;
+    PackMcmeta.readPackFormat = readPackFormat;
     async function getType(packRoot, externals) {
         const dir = await externals.fs.readdir(packRoot);
         const isResourcePack = dir.some(e => e.isDirectory() && e.name === 'assets')

package/lib/dependency/mcmeta.d.ts

@@ -1,11 +1,11 @@
 import * as core from '@spyglassmc/core';
-import type { PackMcmeta, VersionInfo } from './common.js';
+import type { PackInfo, VersionInfo } from './common.js';
 import { ReleaseVersion } from './common.js';
-export declare const NEXT_RELEASE_VERSION = "1.21.5";
+export declare const NEXT_RELEASE_VERSION = "1.21.6";
 /**
  * @param inputVersion {@link core.Config.env.gameVersion}
  */
-export declare function resolveConfiguredVersion(inputVersion: string, versions: McmetaVersions, packMcmeta: PackMcmeta | undefined, packType: 'assets' | 'data' | undefined, logger: core.Logger): VersionInfo;
+export declare function resolveConfiguredVersion(inputVersion: string, versions: McmetaVersions, packs: PackInfo[], logger: core.Logger): VersionInfo;
 export declare function getMcmetaSummaryUris(version: string, isLatest: boolean, source: string): {
     blocks: core.RemoteUriString;
     commands: core.RemoteUriString;

package/lib/dependency/mcmeta.js

@@ -1,11 +1,11 @@
 import * as core from '@spyglassmc/core';
 import { ReleaseVersion } from './common.js';
 // DOCS: Update this when a new snapshot cycle begins
-export const NEXT_RELEASE_VERSION = '1.21.5';
+export const NEXT_RELEASE_VERSION = '1.21.6';
 /**
  * @param inputVersion {@link core.Config.env.gameVersion}
  */
-export function resolveConfiguredVersion(inputVersion, versions, packMcmeta, packType, logger) {
+export function resolveConfiguredVersion(inputVersion, versions, packs, logger) {
     function findReleaseTarget(version) {
         if (version.release_target) {
             return version.release_target;
@@ -21,14 +21,13 @@ export function resolveConfiguredVersion(inputVersion, versions, packMcmeta, pac
         }
         return NEXT_RELEASE_VERSION;
     }
-    function toVersionInfo(version, reason) {
+    function toVersionInfo(version) {
         version = version ?? versions[0];
         return {
             id: version.id,
             name: version.name,
             release: findReleaseTarget(version),
             isLatest: version === versions[0],
-            reason,
         };
     }
     if (versions.length === 0) {
@@ -44,45 +43,52 @@ export function resolveConfiguredVersion(inputVersion, versions, packMcmeta, pac
     versions = versions.sort((a, b) => b.data_version - a.data_version);
     const latestRelease = versions.find((v) => v.type === 'release');
     if (inputVersion === 'auto') {
-        const packFormat = packMcmeta?.pack.pack_format;
-        if (packFormat && latestRelease) {
-            // If the pack format is larger than the latest release, use the latest snapshot
-            if (packFormat > (packType === 'assets'
-                ? latestRelease.resource_pack_version
-                : latestRelease.data_pack_version)) {
-                return toVersionInfo(versions[0], 'auto');
+        if (packs.length === 0) {
+            // Fall back to the latest release if pack mcmeta is not available
+            logger.info(`[resolveConfiguredVersion] No pack format detected, selecting latest release ${latestRelease?.id}`);
+            return toVersionInfo(latestRelease);
+        }
+        packs.sort((a, b) => b.format - a.format);
+        const maxData = packs.filter(p => p.type === 'data')[0];
+        const maxAssets = packs.filter(p => p.type === 'assets')[0];
+        // Look for versions from recent to oldest, picking the most recent release that matches
+        let oldestRelease = versions[0];
+        const releases = versions.filter(v => v.type === 'release');
+        for (const version of releases) {
+            // If we already passed the pack format, use the oldest release so far
+            if (maxData && maxData.format > version.data_pack_version) {
+                logger.info(`[resolveConfiguredVersion] Detected data pack format ${maxData.format} in ${maxData.packRoot}, selecting version ${oldestRelease.id}`);
+                return toVersionInfo(oldestRelease);
             }
-            // Look for versions from recent to oldest, picking the most recent release that matches
-            let oldestRelease = undefined;
-            for (const version of versions) {
-                if (version.type === 'release') {
-                    // If we already passed the pack format, use the oldest release so far
-                    if (packFormat > (packType === 'assets'
-                        ? version.resource_pack_version
-                        : version.data_pack_version)) {
-                        return toVersionInfo(oldestRelease, 'auto');
-                    }
-                    if (packFormat === (packType === 'assets'
-                        ? version.resource_pack_version
-                        : version.data_pack_version)) {
-                        return toVersionInfo(version, 'auto');
-                    }
-                    oldestRelease = version;
-                }
+            if (maxAssets && maxAssets.format > version.resource_pack_version) {
+                logger.info(`[resolveConfiguredVersion] Detected resource pack format ${maxAssets.format} in ${maxAssets.packRoot}, selecting version ${oldestRelease.id}`);
+                return toVersionInfo(oldestRelease);
+            }
+            if (maxData && maxData.format === version.data_pack_version) {
+                logger.info(`[resolveConfiguredVersion] Detected data pack format ${maxData.format} in ${maxData.packRoot}, selecting version ${version.id}`);
+                return toVersionInfo(version);
+            }
+            if (maxAssets && maxAssets.format === version.resource_pack_version) {
+                logger.info(`[resolveConfiguredVersion] Detected resource pack format ${maxAssets.format} in ${maxAssets.packRoot}, selecting version ${version.id}`);
+                return toVersionInfo(version);
             }
-            // If the pack format is still lower, use the oldest known release version
-            return toVersionInfo(oldestRelease, 'auto');
+            oldestRelease = version;
         }
-        // Fall back to the latest release if pack mcmeta is not available
-        return toVersionInfo(latestRelease, 'fallback');
+        // If the pack format is still lower, use the oldest known release version
+        logger.info(`[resolveConfiguredVersion] Detected pack format too low, selecting oldest supported release ${oldestRelease?.id}`);
+        return toVersionInfo(oldestRelease);
     }
     else if (inputVersion === 'latest release') {
-        return toVersionInfo(latestRelease, 'config');
+        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${latestRelease?.id}`);
+        return toVersionInfo(latestRelease);
     }
     else if (inputVersion === 'latest snapshot') {
-        return toVersionInfo(versions[0], 'config');
+        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${versions[0]?.id}`);
+        return toVersionInfo(versions[0]);
     }
-    return toVersionInfo(versions.find((v) => inputVersion === v.id.toLowerCase() || inputVersion === v.name.toLowerCase()), 'config');
+    const configVersion = versions.find((v) => inputVersion === v.id.toLowerCase() || inputVersion === v.name.toLowerCase());
+    logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${configVersion?.id}`);
+    return toVersionInfo(configVersion);
 }
 const DataSources = {
     fastly: 'https://fastly.jsdelivr.net/gh/${user}/${repo}@${tag}/${path}',

package/lib/index.js

@@ -14,11 +14,10 @@ export * from './mcdocAttributes.js';
 export * as mcf from './mcfunction/index.js';
 export const initialize = async (ctx) => {
     const { config, downloader, externals, logger, meta, projectRoots } = ctx;
-    async function readPackMcmeta(uri) {
+    async function readPackFormat(uri) {
         try {
             const data = await core.fileUtil.readJson(externals, uri);
-            PackMcmeta.assert(data);
-            return data;
+            return PackMcmeta.readPackFormat(data);
         }
         catch (e) {
             if (!externals.error.isKind(e, 'ENOENT')) {
@@ -28,7 +27,7 @@ export const initialize = async (ctx) => {
         }
         return undefined;
     }
-    async function findPackMcmetas(versions) {
+    async function findPackMcmetas() {
         const searchedUris = new Set();
         const packs = [];
         for (let depth = 0; depth <= 2; depth += 1) {
@@ -40,12 +39,13 @@ export const initialize = async (ctx) => {
                     }
                     searchedUris.add(uri);
                     const packRoot = core.fileUtil.dirname(uri);
-                    const [packMcmeta, type] = await Promise.all([
-                        readPackMcmeta(uri),
+                    const [format, type] = await Promise.all([
+                        readPackFormat(uri),
                         PackMcmeta.getType(packRoot, externals),
                     ]);
-                    const versionInfo = resolveConfiguredVersion(config.env.gameVersion, versions, packMcmeta, type, logger);
-                    packs.push({ type, packRoot, packMcmeta, versionInfo });
+                    if (format !== undefined) {
+                        packs.push({ type, packRoot, format });
+                    }
                 }
             }
         }
@@ -53,34 +53,15 @@ export const initialize = async (ctx) => {
     }
     meta.registerUriBinder(uriBinder);
     registerUriBuilders(meta);
-    const versions = await getVersions(ctx.externals, ctx.downloader);
+    const [versions, packs] = await Promise.all([
+        getVersions(ctx.externals, ctx.downloader),
+        findPackMcmetas(),
+    ]);
     if (!versions) {
         ctx.logger.error('[je-initialize] Failed loading game version list. Expect everything to be broken.');
         return;
     }
-    const packs = await findPackMcmetas(versions);
-    function selectVersionInfo(packs, versions) {
-        // Select the first valid pack.mcmeta, prioritizing data packs
-        const pack = packs.find(p => p.packMcmeta !== undefined && p.type === 'data')
-            ?? packs.find(p => p.packMcmeta !== undefined && p.type === 'assets');
-        const version = pack === undefined
-            ? resolveConfiguredVersion(config.env.gameVersion, versions, undefined, undefined, logger)
-            : pack.versionInfo;
-        const packMessage = pack === undefined
-            ? 'Failed finding a valid pack.mcmeta'
-            : `Found a valid pack.mcmeta ${pack.packRoot}/pack.mcmeta`;
-        const reasonMessage = pack && version.reason === 'auto'
-            ? `using ${pack.type} pack format ${pack.packMcmeta?.pack.pack_format} to select`
-            : version.reason === 'config'
-                ? `but using config override "${config.env.gameVersion}" to select`
-                : version.reason === 'fallback'
-                    ? 'using fallback'
-                    : 'impossible'; // should never occur
-        const versionMessage = `version ${version.release}${version.id === version.release ? '' : ` (${version.id})`}`;
-        ctx.logger.info(`[je.initialize] ${packMessage}, ${reasonMessage} ${versionMessage}`);
-        return version;
-    }
-    const version = selectVersionInfo(packs, versions);
+    const version = resolveConfiguredVersion(config.env.gameVersion, versions, packs, logger);
     const release = version.release;
     meta.registerDependencyProvider('@vanilla-datapack', () => getVanillaDatapack(downloader, version.id, version.isLatest));
     meta.registerDependencyProvider('@vanilla-resourcepack', () => getVanillaResourcepack(downloader, version.id, version.isLatest));
@@ -110,7 +91,7 @@ export const initialize = async (ctx) => {
                 && !n.symbol?.path[0]?.startsWith('::minecraft')),
     });
     registerMcdocAttributes(meta, summary.commands, release);
-    registerPackFormatAttribute(meta, release, versions, packs);
+    registerPackFormatAttribute(meta, versions, packs);
     meta.registerLanguage('zip', { extensions: ['.zip'] });
     meta.registerLanguage('png', { extensions: ['.png'] });
     meta.registerLanguage('ogg', { extensions: ['.ogg'] });

package/lib/mcdocAttributes.d.ts

@@ -2,5 +2,5 @@ import * as core from '@spyglassmc/core';
 import { ReleaseVersion } from './dependency/index.js';
 import type { McmetaCommands, McmetaVersions, PackInfo } from './dependency/index.js';
 export declare function registerMcdocAttributes(meta: core.MetaRegistry, commands: McmetaCommands, release: ReleaseVersion): void;
-export declare function registerPackFormatAttribute(meta: core.MetaRegistry, release: ReleaseVersion, versions: McmetaVersions, packs: PackInfo[]): void;
+export declare function registerPackFormatAttribute(meta: core.MetaRegistry, versions: McmetaVersions, packs: PackInfo[]): void;
 //# sourceMappingURL=mcdocAttributes.d.ts.map

package/lib/mcdocAttributes.js

@@ -1,5 +1,4 @@
 import * as core from '@spyglassmc/core';
-import { localize } from '@spyglassmc/locales';
 import * as mcdoc from '@spyglassmc/mcdoc';
 import { NEXT_RELEASE_VERSION, ReleaseVersion } from './dependency/index.js';
 const validator = mcdoc.runtime.attribute.validator;
@@ -60,7 +59,7 @@ export function registerMcdocAttributes(meta, commands, release) {
         });
     }
 }
-export function registerPackFormatAttribute(meta, release, versions, packs) {
+export function registerPackFormatAttribute(meta, versions, packs) {
     const dataFormats = new Map();
     const assetsFormats = new Map();
     if (versions[0]?.type !== 'release') {
@@ -84,21 +83,6 @@ export function registerPackFormatAttribute(meta, release, versions, packs) {
         return thisPack?.type === 'assets' ? assetsFormats : dataFormats;
     }
     mcdoc.runtime.registerAttribute(meta, 'pack_format', () => undefined, {
-        checker: (_, typeDef) => {
-            if (typeDef.kind !== 'literal' || typeof typeDef.value.value !== 'number') {
-                return undefined;
-            }
-            const target = typeDef.value.value;
-            return (node, ctx) => {
-                const targetVersions = getFormats(ctx.doc.uri).get(target);
-                if (!targetVersions) {
-                    ctx.err.report(localize('java-edition.pack-format.unsupported', target), node, 2 /* core.ErrorSeverity.Warning */);
-                }
-                else if (!targetVersions.some(v => v === release)) {
-                    ctx.err.report(localize('java-edition.pack-format.not-loaded', target, release), node, 2 /* core.ErrorSeverity.Warning */);
-                }
-            };
-        },
         numericCompleter: (_, ctx) => {
             return [...getFormats(ctx.doc.uri).entries()].map(([k, v], i) => ({
                 range: core.Range.create(ctx.offset),

package/lib/mcfunction/mcdocAttributes.js

@@ -11,6 +11,7 @@ const commandValidator = validator.alternatives(validator.tree({
     slash: validator.optional(validator.options('allowed', 'required', 'chat')),
     max_length: validator.optional(validator.number),
     empty: validator.optional(validator.options('allowed')),
+    incomplete: validator.optional(validator.options('allowed')),
 }), () => ({}));
 const entityValidator = validator.alternatives(validator.tree({
     amount: validator.options('multiple', 'single'),
@@ -22,17 +23,23 @@ const scoreHolderValidator = validator.alternatives(validator.tree({
 export function registerMcdocAttributes(meta, rootTreeNode) {
     mcdoc.runtime.registerAttribute(meta, 'command', commandValidator, {
         // TODO: fix completer inside commands
-        stringParser: ({ slash, max_length, empty }) => {
+        stringParser: ({ slash, max_length, empty, incomplete }) => {
             return (src, ctx) => {
                 if ((empty && !src.canRead()) || (slash === 'chat' && src.peek() !== '/')) {
                     return core.string({
                         unquotable: { blockList: new Set(), allowEmpty: true },
                     })(src, ctx);
                 }
-                return mcf.command(rootTreeNode, parser.argument, {
+                const tmpCtx = { ...ctx, err: new core.ErrorReporter(ctx.err.source) };
+                const result = mcf.command(rootTreeNode, parser.argument, {
                     slash: slash === 'chat' ? 'allowed' : slash,
                     maxLength: max_length,
-                })(src, ctx);
+                })(src, tmpCtx);
+                if (incomplete) {
+                    tmpCtx.err.errors = tmpCtx.err.errors.filter(e => e.range.end < result.range.end);
+                }
+                ctx.err.absorb(tmpCtx.err);
+                return result;
             };
         },
     });

package/lib/mcfunction/tree/patch.js

@@ -164,6 +164,18 @@ export function getPatch(release) {
                     }),
                 },
             },
+            datapack: {
+                children: {
+                    ...(ReleaseVersion.cmp(release, '1.21.6') >= 0
+                        ? {
+                            // Added in 21w15a (1.21.6, pack format 72)
+                            create: {
+                                permission: 4,
+                            },
+                        }
+                        : {}),
+                },
+            },
             debug: {
                 permission: 3,
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/java-edition",
-  "version": "0.3.37",
+  "version": "0.3.39",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -17,12 +17,12 @@
     "release:dry": "npm publish --dry-run"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.28",
-    "@spyglassmc/json": "0.3.32",
-    "@spyglassmc/locales": "0.3.14",
-    "@spyglassmc/mcfunction": "0.2.30",
-    "@spyglassmc/mcdoc": "0.3.32",
-    "@spyglassmc/nbt": "0.3.33"
+    "@spyglassmc/core": "0.4.29",
+    "@spyglassmc/json": "0.3.33",
+    "@spyglassmc/locales": "0.3.15",
+    "@spyglassmc/mcfunction": "0.2.31",
+    "@spyglassmc/mcdoc": "0.3.33",
+    "@spyglassmc/nbt": "0.3.34"
   },
   "devDependencies": {},
   "publishConfig": {