@spyglassmc/java-edition 0.3.52 → 0.3.54

package/lib/binder/index.js

@@ -1,4 +1,4 @@
-import { fileUtil, Range, TaggableResourceLocationCategories, } from '@spyglassmc/core';
+import { ErrorSeverity, fileUtil, Range, TaggableResourceLocationCategories, } from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
 import { ReleaseVersion } from '../dependency/index.js';
 const Resources = new Map();
@@ -61,9 +61,11 @@ resource('pig_variant', { since: '1.21.5' });
 resource('test_instance', { since: '1.21.5' });
 resource('test_environment', { since: '1.21.5' });
 resource('timeline', { since: '1.21.11' });
+resource('trade_set', { since: '26.1' });
 resource('trial_spawner', { since: '1.21.2' });
 resource('trim_pattern', { since: '1.19.4' });
 resource('trim_material', { since: '1.19.4' });
+resource('villager_trade', { since: '26.1' });
 resource('wolf_sound_variant', { since: '1.21.5' });
 resource('wolf_variant', { since: '1.20.5' });
 resource('zombie_nautilus_variant', { since: '1.21.11' });
@@ -275,10 +277,10 @@ export function reportDissectError(realPath, expectedPath, ctx) {
         return;
     }
     if (expectedPath) {
-        ctx.err.report(localize('java-edition.binder.wrong-folder', localeQuote(realPath), release, localeQuote(expectedPath)), Range.Beginning, 0 /* ErrorSeverity.Hint */);
+        ctx.err.report(localize('java-edition.binder.wrong-folder', localeQuote(realPath), release, localeQuote(expectedPath)), Range.Beginning, ErrorSeverity.Hint);
     }
     else {
-        ctx.err.report(localize('java-edition.binder.wrong-version', localeQuote(realPath), release), Range.Beginning, 0 /* ErrorSeverity.Hint */);
+        ctx.err.report(localize('java-edition.binder.wrong-version', localeQuote(realPath), release), Range.Beginning, ErrorSeverity.Hint);
     }
 }
 function uriBuilder(resources) {

package/lib/dependency/common.d.ts

@@ -1,5 +1,5 @@
 import type * as core from '@spyglassmc/core';
-export type ReleaseVersion = `1.${number}`;
+export type ReleaseVersion = `${bigint}.${bigint}.${bigint}` | `${bigint}.${bigint}`;
 export declare namespace ReleaseVersion {
     /**
      * @returns
@@ -18,6 +18,8 @@ export interface VersionInfo {
     release: ReleaseVersion;
     id: string;
     name: string;
+    data_pack_version: number;
+    resource_pack_version: number;
 }
 export declare namespace PackMcmeta {
     function readPackFormat(data: any): number;

package/lib/dependency/common.js

@@ -7,8 +7,11 @@ export var ReleaseVersion;
      * * `1` if `a` is newer than `b`.
      */
     function cmp(a, b) {
-        const [minorA, patchA = 0] = a.slice(2).split('.');
-        const [minorB, patchB = 0] = b.slice(2).split('.');
+        const [majorA, minorA, patchA = 0] = a.split('.');
+        const [majorB, minorB, patchB = 0] = b.split('.');
+        if (majorA !== majorB) {
+            return Math.sign(Number(majorA) - Number(majorB));
+        }
         if (minorA !== minorB) {
             return Math.sign(Number(minorA) - Number(minorB));
         }

package/lib/dependency/mcmeta.d.ts

@@ -1,7 +1,12 @@
 import * as core from '@spyglassmc/core';
 import type { PackInfo, VersionInfo } from './common.js';
 import { ReleaseVersion } from './common.js';
-export declare const NEXT_RELEASE_VERSION = "1.21.11";
+/**
+ * Determines the latest development release for which a release target could be determined
+ * @param versions List of all versions in mcmeta
+ * @returns latest development release
+ */
+export declare function getLatestSnapshot(versions: McmetaVersions): VersionInfo;
 /**
  * @param inputVersion {@link core.Config.env.gameVersion}
  */

package/lib/dependency/mcmeta.js

@@ -1,33 +1,57 @@
 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.11';
+// Matches development versions with the release version in its name
+const DevelopmentVersionPattern = /^(\d\d\.\d(?:\.\d?\d)?)\-\w+\-\d+$/;
+function toVersionInfo(version, release) {
+    return {
+        id: version.id,
+        name: version.name,
+        release: release ?? version.id,
+        data_pack_version: version.data_pack_version,
+        resource_pack_version: version.resource_pack_version,
+    };
+}
+/**
+ * Determines the latest development release for which a release target could be determined
+ * @param versions List of all versions in mcmeta
+ * @returns latest development release
+ */
+export function getLatestSnapshot(versions) {
+    for (const version of versions) {
+        if (version.type === 'release') {
+            return toVersionInfo(version);
+        }
+        const matches = version.id.match(DevelopmentVersionPattern);
+        if (matches) {
+            return toVersionInfo(version, matches[1]);
+        }
+    }
+    throw new Error('no next release version found');
+}
 /**
  * @param inputVersion {@link core.Config.env.gameVersion}
  */
 export function resolveConfiguredVersion(inputVersion, versions, packs, logger) {
-    function findReleaseTarget(version) {
-        if (version.release_target) {
-            return version.release_target;
-        }
+    // Gets the release version id for any version, only used when specifically selecting release in config
+    function getReleaseVersion(version) {
+        // Is release, so return own id
         if (version.type === 'release') {
             return version.id;
         }
+        // Development versions with release version in name
+        const matches = version.id.match(DevelopmentVersionPattern);
+        if (matches) {
+            return matches[1];
+        }
+        // Old snapshots without release version in name
         const index = versions.findIndex((v) => v.id === version.id);
         for (let i = index; i >= 0; i -= 1) {
             if (versions[i].type === 'release') {
                 return versions[i].id;
             }
         }
-        return NEXT_RELEASE_VERSION;
-    }
-    function toVersionInfo(version) {
-        version = version ?? versions[0];
-        return {
-            id: version.id,
-            name: version.name,
-            release: findReleaseTarget(version),
-        };
+        // No release version found. This should only happen in exceptional circumstances, such as april fools or experimental versions.
+        return undefined;
     }
     if (versions.length === 0) {
         throw new Error('mcmeta version list is empty');
@@ -40,28 +64,33 @@ export function resolveConfiguredVersion(inputVersion, versions, packs, logger)
     }
     inputVersion = inputVersion.toLowerCase();
     versions = versions.sort((a, b) => b.data_version - a.data_version);
-    const latestRelease = versions.find((v) => v.type === 'release');
+    const latestReleaseMcmeta = versions.find((v) => v.type === 'release');
+    if (latestReleaseMcmeta === undefined) {
+        throw new Error('mcmeta version list does not contain any releases');
+    }
+    const latestRelease = toVersionInfo(latestReleaseMcmeta);
+    const latestSnaphot = getLatestSnapshot(versions);
     if (inputVersion === '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);
+            return 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];
+        let nextReleaseVersionInfo = latestSnaphot;
         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);
+                logger.info(`[resolveConfiguredVersion] Detected data pack format ${maxData.format} in ${maxData.packRoot}, selecting version ${nextReleaseVersionInfo.id}`);
+                return nextReleaseVersionInfo;
             }
             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);
+                logger.info(`[resolveConfiguredVersion] Detected resource pack format ${maxAssets.format} in ${maxAssets.packRoot}, selecting version ${nextReleaseVersionInfo.id}`);
+                return nextReleaseVersionInfo;
             }
             if (maxData && maxData.format === version.data_pack_version) {
                 logger.info(`[resolveConfiguredVersion] Detected data pack format ${maxData.format} in ${maxData.packRoot}, selecting version ${version.id}`);
@@ -71,23 +100,32 @@ export function resolveConfiguredVersion(inputVersion, versions, packs, logger)
                 logger.info(`[resolveConfiguredVersion] Detected resource pack format ${maxAssets.format} in ${maxAssets.packRoot}, selecting version ${version.id}`);
                 return toVersionInfo(version);
             }
-            oldestRelease = version;
+            nextReleaseVersionInfo = toVersionInfo(version);
         }
         // 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);
+        logger.info(`[resolveConfiguredVersion] Detected pack format too low, selecting oldest supported release ${nextReleaseVersionInfo?.id}`);
+        return nextReleaseVersionInfo;
     }
     else if (inputVersion === 'latest release') {
-        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${latestRelease?.id}`);
-        return toVersionInfo(latestRelease);
+        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${latestRelease.id}`);
+        return latestRelease;
     }
     else if (inputVersion === 'latest snapshot') {
-        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${versions[0]?.id}`);
-        return toVersionInfo(versions[0]);
+        logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${latestSnaphot.id}`);
+        return latestSnaphot;
     }
     const configVersion = versions.find((v) => inputVersion === v.id.toLowerCase() || inputVersion === v.name.toLowerCase());
+    if (configVersion === undefined) {
+        logger.info(`[resolveConfiguredVersion] Could not find config version "${inputVersion}", selecting version ${latestSnaphot.id}`);
+        return latestSnaphot;
+    }
+    const configReleaseVersion = getReleaseVersion(configVersion);
+    if (configReleaseVersion === undefined) {
+        logger.info(`[resolveConfiguredVersion] Could not determine release version of config "${inputVersion}", selecting version ${latestSnaphot.id}`);
+        return latestSnaphot;
+    }
     logger.info(`[resolveConfiguredVersion] Using config "${inputVersion}", selecting version ${configVersion?.id}`);
-    return toVersionInfo(configVersion);
+    return toVersionInfo(configVersion, configReleaseVersion);
 }
 export function symbolRegistrar(summary, release) {
     const McmetaSummaryUri = 'mcmeta://summary/registries.json';

package/lib/mcdocAttributes.js

@@ -1,6 +1,6 @@
 import * as core from '@spyglassmc/core';
 import * as mcdoc from '@spyglassmc/mcdoc';
-import { NEXT_RELEASE_VERSION, ReleaseVersion } from './dependency/index.js';
+import { getLatestSnapshot, ReleaseVersion } from './dependency/index.js';
 const validator = mcdoc.runtime.attribute.validator;
 const gameRuleValidator = validator.tree({
     type: validator.options('boolean', 'int'),
@@ -62,9 +62,10 @@ export function registerMcdocAttributes(meta, commands, release) {
 export function registerPackFormatAttribute(meta, versions, packs) {
     const dataFormats = new Map();
     const assetsFormats = new Map();
-    if (versions[0]?.type !== 'release') {
-        dataFormats.set(versions[0].data_pack_version, [NEXT_RELEASE_VERSION]);
-        assetsFormats.set(versions[0].resource_pack_version, [NEXT_RELEASE_VERSION]);
+    const latestSnapshot = getLatestSnapshot(versions);
+    if (latestSnapshot.release !== latestSnapshot.id) {
+        dataFormats.set(latestSnapshot.data_pack_version, [latestSnapshot.release]);
+        assetsFormats.set(latestSnapshot.resource_pack_version, [latestSnapshot.release]);
     }
     for (const version of versions) {
         if (version.type === 'release') {

package/lib/mcfunction/checker/index.js

@@ -150,7 +150,7 @@ const itemStack = (node, ctx) => {
     for (const [_, group] of groupedComponents) {
         if (group.length > 1) {
             for (const node of group) {
-                ctx.err.report(localize('mcfunction.parser.duplicate-components'), node.range, 2 /* core.ErrorSeverity.Warning */);
+                ctx.err.report(localize('mcfunction.parser.duplicate-components'), node.range, core.ErrorSeverity.Warning);
             }
         }
     }

package/lib/mcfunction/tree/patch.js

@@ -665,6 +665,51 @@ export function getPatch(release) {
                     },
                 },
             },
+            ...(ReleaseVersion.cmp(release, '1.21.11') >= 0
+                ? {
+                    stopwatch: {
+                        children: {
+                            create: {
+                                children: {
+                                    id: {
+                                        properties: {
+                                            category: 'stopwatch',
+                                            usageType: 'definition',
+                                        },
+                                    },
+                                },
+                            },
+                            query: {
+                                children: {
+                                    id: {
+                                        properties: {
+                                            category: 'stopwatch',
+                                        },
+                                    },
+                                },
+                            },
+                            remove: {
+                                children: {
+                                    id: {
+                                        properties: {
+                                            category: 'stopwatch',
+                                        },
+                                    },
+                                },
+                            },
+                            restart: {
+                                children: {
+                                    id: {
+                                        properties: {
+                                            category: 'stopwatch',
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                }
+                : {}),
             summon: {
                 children: {
                     entity: {
@@ -1018,6 +1063,15 @@ const ExecuteCondition = Object.freeze({
                 },
             },
         },
+        stopwatch: {
+            children: {
+                id: {
+                    properties: {
+                        category: 'stopwatch',
+                    },
+                },
+            },
+        },
     },
 });
 const ExecuteStoreTarget = Object.freeze({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/java-edition",
-  "version": "0.3.52",
+  "version": "0.3.54",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -17,12 +17,12 @@
     "release:dry": "npm publish --tag latest --dry-run"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.40",
-    "@spyglassmc/json": "0.3.44",
-    "@spyglassmc/locales": "0.3.20",
-    "@spyglassmc/mcfunction": "0.2.43",
-    "@spyglassmc/mcdoc": "0.3.44",
-    "@spyglassmc/nbt": "0.3.46"
+    "@spyglassmc/core": "0.4.42",
+    "@spyglassmc/json": "0.3.46",
+    "@spyglassmc/locales": "0.3.21",
+    "@spyglassmc/mcfunction": "0.2.45",
+    "@spyglassmc/mcdoc": "0.3.46",
+    "@spyglassmc/nbt": "0.3.48"
   },
   "devDependencies": {},
   "publishConfig": {