@spyglassmc/java-edition 0.3.1 → 0.3.2

package/lib/mcfunction/parser/argument.js

@@ -5,8 +5,8 @@ import { localeQuote, localize } from '@spyglassmc/locales';
 import * as mcf from '@spyglassmc/mcfunction';
 import * as nbt from '@spyglassmc/nbt';
 import { ReleaseVersion } from '../../dependency/index.js';
-import { ColorArgumentValues, EntityAnchorArgumentValues, ItemSlotArgumentValues, OperationArgumentValues, ScoreboardSlotArgumentValues, SwizzleArgumentValues } from '../common/index.js';
-import { BlockStatesNode, EntitySelectorArgumentsNode, EntitySelectorAtVariable, EntitySelectorAtVariables, EntitySelectorNode, ObjectiveCriteriaNode, TimeNode } from '../node/index.js';
+import { ColorArgumentValues, EntityAnchorArgumentValues, ItemSlotArgumentValues, OperationArgumentValues, ScoreboardSlotArgumentValues, SwizzleArgumentValues, } from '../common/index.js';
+import { BlockStatesNode, EntitySelectorArgumentsNode, EntitySelectorAtVariable, EntitySelectorAtVariables, EntitySelectorNode, ObjectiveCriteriaNode, TimeNode, } from '../node/index.js';
 const IntegerPattern = /^-?\d+$/;
 /**
  * A combination of:
@@ -24,7 +24,7 @@ const IntegerPattern = /^-?\d+$/;
 const FloatPattern = /^-?(?:\d+\.?\d*|\.\d+)$/;
 const DoubleMax = Number.MAX_VALUE;
 const DoubleMin = -DoubleMax;
-const FloatMax = (2 - (2 ** -23)) * (2 ** 127);
+const FloatMax = (2 - 2 ** -23) * 2 ** 127;
 const FloatMin = -FloatMax;
 const IntegerMax = 2 ** 31 - 1;
 const IntegerMin = -(2 ** 31);
@@ -66,7 +66,7 @@ export const argument = (rawTreeNode) => {
                     return wrap(greedyString);
             }
         case 'minecraft:angle':
-            return wrap(core.validate(coordinate(), res => res.notation !== '^', localize('mcfunction.parser.vector.local-disallowed')));
+            return wrap(core.validate(coordinate(), (res) => res.notation !== '^', localize('mcfunction.parser.vector.local-disallowed')));
         case 'minecraft:block_pos':
             return wrap(vector({ dimension: 3, integersOnly: true }));
         case 'minecraft:block_predicate':
@@ -74,7 +74,7 @@ export const argument = (rawTreeNode) => {
         case 'minecraft:block_state':
             return wrap(blockState);
         case 'minecraft:color':
-            return wrap(core.map(core.literal(...ColorArgumentValues), res => ({
+            return wrap(core.map(core.literal(...ColorArgumentValues), (res) => ({
                 ...res,
                 color: core.Color.NamedColors.has(res.value)
                     ? core.Color.fromCompositeInt(core.Color.NamedColors.get(res.value))
@@ -198,12 +198,12 @@ function block(isPredicate) {
                 trailingEnd: true,
             },
             end: ']',
-        })), res => ({
+        })), (res) => ({
             ...res,
             type: 'mcfunction:block/states',
         }))),
         core.optional(core.failOnEmpty(nbt.parser.compound)),
-    ]), res => {
+    ]), (res) => {
         const ans = {
             type: 'mcfunction:block',
             range: res.range,
@@ -271,7 +271,7 @@ function coordinate(integerOnly = false) {
 function entity(amount, type) {
     return core.map(core.select([
         {
-            predicate: src => EntitySelectorAtVariable.is(src.peek(2)),
+            predicate: (src) => EntitySelectorAtVariable.is(src.peek(2)),
             parser: selector(),
         },
         {
@@ -298,7 +298,11 @@ function entity(amount, type) {
         if (amount === 'single' && ans.selector && !ans.selector.single) {
             ctx.err.report(localize('mcfunction.parser.entity-selector.multiple-disallowed'), ans);
         }
-        if (type === 'players' && (ans.uuid || (ans.selector && !ans.selector.playersOnly && !ans.selector.currentEntity))) {
+        if (type === 'players' &&
+            (ans.uuid ||
+                (ans.selector &&
+                    !ans.selector.playersOnly &&
+                    !ans.selector.currentEntity))) {
             ctx.err.report(localize('mcfunction.parser.entity-selector.entities-disallowed'), ans);
         }
         return ans;
@@ -311,7 +315,7 @@ function item(isPredicate) {
     return core.map(core.sequence([
         core.resourceLocation({ category: 'item', allowTag: isPredicate }),
         core.optional(core.failOnEmpty(nbt.parser.compound)),
-    ]), res => {
+    ]), (res) => {
         const ans = {
             type: 'mcfunction:item',
             range: res.range,
@@ -343,7 +347,7 @@ const message = (src, ctx) => {
 export const particle = (() => {
     const sep = core.map(mcf.sep, () => []);
     const vec = vector({ dimension: 3 });
-    const color = core.map(vec, res => ({
+    const color = core.map(vec, (res) => ({
         ...res,
         color: res.children.length === 3
             ? {
@@ -366,11 +370,11 @@ export const particle = (() => {
     return core.map(sequence([
         core.resourceLocation({ category: 'particle_type' }),
         {
-            get: res => {
+            get: (res) => {
                 return map[core.ResourceLocationNode.toString(res.children[0], 'short')];
             },
         },
-    ], sep), res => {
+    ], sep), (res) => {
         const ans = {
             type: 'mcfunction:particle',
             range: res.range,
@@ -407,7 +411,10 @@ function range(type, min, max, cycleable) {
                         : [undefined, valueNodes[0].value]
                 : [valueNodes[0].value, valueNodes[0].value],
         };
-        if (!cycleable && ans.value[0] !== undefined && ans.value[1] !== undefined && ans.value[0] > ans.value[1]) {
+        if (!cycleable &&
+            ans.value[0] !== undefined &&
+            ans.value[1] !== undefined &&
+            ans.value[0] > ans.value[1]) {
             ctx.err.report(localize('mcfunction.parser.range.min>max', ans.value[0], ans.value[1]), res);
         }
         return ans;
@@ -425,27 +432,39 @@ function selector() {
     let single;
     let typeLimited;
     return core.map(core.sequence([
-        core.failOnEmpty(core.literal({ pool: EntitySelectorAtVariables, colorTokenType: 'keyword' })),
+        core.failOnEmpty(core.literal({
+            pool: EntitySelectorAtVariables,
+            colorTokenType: 'keyword',
+        })),
         {
-            get: res => {
-                const variable = core.LiteralNode.is(res.children?.[0]) ? res.children[0].value : undefined;
+            get: (res) => {
+                const variable = core.LiteralNode.is(res.children?.[0])
+                    ? res.children[0].value
+                    : undefined;
                 currentEntity = variable ? variable === '@s' : undefined;
-                playersOnly = variable ? variable === '@p' || variable === '@a' || variable === '@r' : undefined;
+                playersOnly = variable
+                    ? variable === '@p' || variable === '@a' || variable === '@r'
+                    : undefined;
                 predicates = variable === '@e' ? ['Entity::isAlive'] : undefined;
-                single = variable ? variable === '@p' || variable === '@r' || variable === '@s' : undefined;
+                single = variable
+                    ? variable === '@p' || variable === '@r' || variable === '@s'
+                    : undefined;
                 typeLimited = playersOnly;
                 function invertable(parser) {
                     return core.map(core.sequence([
                         core.optional(core.failOnEmpty(core.literal({ pool: ['!'], colorTokenType: 'keyword' }))),
-                        src => { src.skipSpace(); return undefined; },
+                        (src) => {
+                            src.skipSpace();
+                            return undefined;
+                        },
                         parser,
-                    ]), res => {
+                    ]), (res) => {
                         const ans = {
                             type: 'mcfunction:entity_selector/arguments/value/invertable',
                             range: res.range,
                             children: res.children,
-                            inverted: !!res.children.find(n => core.LiteralNode.is(n) && n.value === '!'),
-                            value: res.children.find(n => !core.LiteralNode.is(n) || n.value !== '!'),
+                            inverted: !!res.children.find((n) => core.LiteralNode.is(n) && n.value === '!'),
+                            value: res.children.find((n) => !core.LiteralNode.is(n) || n.value !== '!'),
                         };
                         return ans;
                     });
@@ -456,25 +475,31 @@ function selector() {
                         key: core.string({
                             ...core.BrigadierStringOptions,
                             value: {
-                                parser: core.literal({ pool: [...EntitySelectorNode.ArgumentKeys], colorTokenType: 'property' }),
+                                parser: core.literal({
+                                    pool: [...EntitySelectorNode.ArgumentKeys],
+                                    colorTokenType: 'property',
+                                }),
                                 type: 'literal',
                             },
                         }),
                         sep: '=',
                         value: {
                             get: (record, key) => {
-                                const hasKey = (key) => !!record.children.find(p => p.key?.value === key);
-                                const hasNonInvertedKey = (key) => !!record.children.find(p => p.key?.value === key && !p.value?.inverted);
+                                const hasKey = (key) => !!record.children.find((p) => p.key?.value === key);
+                                const hasNonInvertedKey = (key) => !!record.children.find((p) => p.key?.value === key &&
+                                    !p.value?.inverted);
                                 switch (key?.value) {
                                     case 'advancements':
                                         return core.map(core.record({
                                             start: '{',
                                             pair: {
-                                                key: core.resourceLocation({ category: 'advancement' }),
+                                                key: core.resourceLocation({
+                                                    category: 'advancement',
+                                                }),
                                                 sep: '=',
                                                 value: core.select([
                                                     {
-                                                        predicate: src => src.peek() === '{',
+                                                        predicate: (src) => src.peek() === '{',
                                                         parser: core.map(core.record({
                                                             start: '{',
                                                             pair: {
@@ -485,7 +510,7 @@ function selector() {
                                                                 trailingEnd: true,
                                                             },
                                                             end: '}',
-                                                        }), res => {
+                                                        }), (res) => {
                                                             const ans = {
                                                                 ...res,
                                                                 type: 'mcfunction:entity_selector/arguments/advancements/criteria',
@@ -515,7 +540,8 @@ function selector() {
                                         return core.map(range('float', 0), (res, _, ctx) => {
                                             dimensionLimited = true;
                                             // x, y, z, dx, dy, dz take precedence over distance, so we use ??= instead of = to ensure it won't override the result.
-                                            chunkLimited ??= !playersOnly && res.value[1] !== undefined;
+                                            chunkLimited ??=
+                                                !playersOnly && res.value[1] !== undefined;
                                             if (hasKey(key.value)) {
                                                 ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
                                             }
@@ -530,7 +556,9 @@ function selector() {
                                             },
                                         })), (res, _, ctx) => {
                                             playersOnly = true;
-                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                            if (res.inverted
+                                                ? hasNonInvertedKey(key.value)
+                                                : hasKey(key.value)) {
                                                 ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
                                             }
                                             return res;
@@ -556,7 +584,9 @@ function selector() {
                                         });
                                     case 'name':
                                         return core.map(invertable(core.brigadierString), (res, _, ctx) => {
-                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                            if (res.inverted
+                                                ? hasNonInvertedKey(key.value)
+                                                : hasKey(key.value)) {
                                                 ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
                                             }
                                             return res;
@@ -569,7 +599,14 @@ function selector() {
                                         return core.map(core.record({
                                             start: '{',
                                             pair: {
-                                                key: objective('reference', ['[', '=', ',', ']', '{', '}']),
+                                                key: objective('reference', [
+                                                    '[',
+                                                    '=',
+                                                    ',',
+                                                    ']',
+                                                    '{',
+                                                    '}',
+                                                ]),
                                                 sep: '=',
                                                 value: range('integer'),
                                                 end: ',',
@@ -605,14 +642,26 @@ function selector() {
                                     case 'tag':
                                         return invertable(tag(['[', '=', ',', ']', '{', '}']));
                                     case 'team':
-                                        return core.map(invertable(team('reference', ['[', '=', ',', ']', '{', '}'])), (res, _, ctx) => {
-                                            if (res.inverted ? hasNonInvertedKey(key.value) : hasKey(key.value)) {
+                                        return core.map(invertable(team('reference', [
+                                            '[',
+                                            '=',
+                                            ',',
+                                            ']',
+                                            '{',
+                                            '}',
+                                        ])), (res, _, ctx) => {
+                                            if (res.inverted
+                                                ? hasNonInvertedKey(key.value)
+                                                : hasKey(key.value)) {
                                                 ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
                                             }
                                             return res;
                                         });
                                     case 'type':
-                                        return core.map(invertable(core.resourceLocation({ category: 'entity_type', allowTag: true })), (res, _, ctx) => {
+                                        return core.map(invertable(core.resourceLocation({
+                                            category: 'entity_type',
+                                            allowTag: true,
+                                        })), (res, _, ctx) => {
                                             if (typeLimited) {
                                                 if (hasKey(key.value)) {
                                                     ctx.err.report(localize('duplicate-key', localeQuote(key.value)), key);
@@ -674,7 +723,7 @@ function selector() {
                         trailingEnd: true,
                     },
                     end: ']',
-                })), res => {
+                })), (res) => {
                     const ans = {
                         ...res,
                         type: 'mcfunction:entity_selector/arguments',
@@ -683,12 +732,14 @@ function selector() {
                 }));
             },
         },
-    ]), res => {
+    ]), (res) => {
         const ans = {
             type: 'mcfunction:entity_selector',
             range: res.range,
             children: res.children,
-            variable: res.children.find(core.LiteralNode.is).value.slice(1),
+            variable: res.children
+                .find(core.LiteralNode.is)
+                .value.slice(1),
             arguments: res.children.find(EntitySelectorArgumentsNode.is),
             chunkLimited,
             currentEntity,
@@ -718,7 +769,12 @@ function getEntitySelectorHover(node) {
 - \`currentEntity\`: \`${node.currentEntity}\``;
     }
     else {
-        const amountOfTrue = [node.chunkLimited, node.dimensionLimited, node.playersOnly, node.typeLimited].filter(v => v).length;
+        const amountOfTrue = [
+            node.chunkLimited,
+            node.dimensionLimited,
+            node.playersOnly,
+            node.typeLimited,
+        ].filter((v) => v).length;
         ans = `**Performance**: ${grades.get(amountOfTrue)}  
 - \`chunkLimited\`: \`${!!node.chunkLimited}\`
 - \`dimensionLimited\`: \`${!!node.dimensionLimited}\`
@@ -730,7 +786,7 @@ function getEntitySelectorHover(node) {
 
 ------
 **Predicates**: 
-${node.predicates.map(p => `- \`${p}\``).join('\n')}`;
+${node.predicates.map((p) => `- \`${p}\``).join('\n')}`;
     }
     return ans;
 }
@@ -738,7 +794,7 @@ export const scoreHolderFakeName = validateLength(symbol('score_holder'), FakeNa
 function scoreHolder(amount) {
     return core.map(core.select([
         {
-            predicate: src => EntitySelectorAtVariable.is(src.peek(2)),
+            predicate: (src) => EntitySelectorAtVariable.is(src.peek(2)),
             parser: selector(),
         },
         {
@@ -770,22 +826,32 @@ function objective(usageType, terminators = []) {
 }
 const objectiveCriteria = core.map(core.any([
     core.sequence([
-        core.stopBefore(core.resourceLocation({ category: 'stat_type', namespacePathSep: '.' }), ':'),
+        core.stopBefore(core.resourceLocation({
+            category: 'stat_type',
+            namespacePathSep: '.',
+        }), ':'),
         core.failOnEmpty(core.literal(':')),
         {
-            get: res => {
+            get: (res) => {
                 if (core.ResourceLocationNode.is(res.children[0])) {
                     const category = ObjectiveCriteriaNode.ComplexCategories.get(core.ResourceLocationNode.toString(res.children[0], 'short'));
                     if (category) {
-                        return core.resourceLocation({ category, namespacePathSep: '.' });
+                        return core.resourceLocation({
+                            category,
+                            namespacePathSep: '.',
+                        });
                     }
                 }
-                return core.resourceLocation({ pool: [], allowUnknown: true, namespacePathSep: '.' });
+                return core.resourceLocation({
+                    pool: [],
+                    allowUnknown: true,
+                    namespacePathSep: '.',
+                });
             },
         },
     ]),
     core.literal(...ObjectiveCriteriaNode.SimpleValues),
-]), res => {
+]), (res) => {
     const ans = {
         type: 'mcfunction:objective_criteria',
         range: res.range,
@@ -807,7 +873,10 @@ export function team(usageType, terminators = []) {
 function unquotableSymbol(options, terminators) {
     return validateUnquotable(symbol(options, terminators));
 }
-const time = core.map(core.sequence([float(0, undefined), core.optional(core.failOnEmpty(core.literal(...TimeNode.Units)))]), res => {
+const time = core.map(core.sequence([
+    float(0, undefined),
+    core.optional(core.failOnEmpty(core.literal(...TimeNode.Units))),
+]), (res) => {
     const valueNode = res.children.find(core.FloatNode.is);
     const unitNode = res.children.find(core.LiteralNode.is);
     const ans = {
@@ -840,8 +909,8 @@ const uuid = (src, ctx) => {
     let isLegal = false;
     if (raw.match(UuidPattern)) {
         try {
-            const parts = raw.split('-').map(p => BigInt(`0x${p}`));
-            if (parts.every(p => p <= LongMax)) {
+            const parts = raw.split('-').map((p) => BigInt(`0x${p}`));
+            if (parts.every((p) => p <= LongMax)) {
                 isLegal = true;
                 ans.bits[0] = BigInt.asIntN(64, (parts[0] << 32n) | (parts[1] << 16n) | parts[2]);
                 ans.bits[1] = BigInt.asIntN(64, (parts[3] << 48n) | parts[4]);
@@ -894,9 +963,12 @@ function vector(options) {
             if (i > 0) {
                 mcf.sep(src, ctx);
             }
-            const coord = options.integersOnly ? coordinate(options.integersOnly)(src, ctx) : coordinate(options.integersOnly)(src, ctx);
+            const coord = options.integersOnly
+                ? coordinate(options.integersOnly)(src, ctx)
+                : coordinate(options.integersOnly)(src, ctx);
             ans.children.push(coord);
-            if ((ans.system === 1 /* CoordinateSystem.Local */) !== (coord.notation === '^')) {
+            if ((ans.system === 1 /* CoordinateSystem.Local */) !==
+                (coord.notation === '^')) {
                 ctx.err.report(localize('mcfunction.parser.vector.mixed'), coord);
             }
         }

package/lib/mcfunction/signatureHelpProvider.js

@@ -35,7 +35,7 @@ export function signatureHelpProvider(commandTreeName) {
             activeSignature: 0,
             signatures: [],
         };
-        ans.signatures = options.map(v => {
+        ans.signatures = options.map((v) => {
             const part1 = v[selectedIndex];
             const part2 = selectedIndex + 1 < v.length ? ` ${v[selectedIndex + 1]}` : '';
             const label = `${part1}${part2}`;
@@ -63,7 +63,8 @@ function getOptions(rootTreeNode, argumentNodes) {
         if (!name) {
             break;
         }
-        treeNode = mcf.resolveParentTreeNode(treeNode, rootTreeNode).treeNode?.children?.[name];
+        treeNode = mcf.resolveParentTreeNode(treeNode, rootTreeNode).treeNode
+            ?.children?.[name];
         if (!treeNode) {
             break;
         }
@@ -72,7 +73,9 @@ function getOptions(rootTreeNode, argumentNodes) {
     if (treeNode) {
         treeNode = mcf.resolveParentTreeNode(treeNode, rootTreeNode).treeNode;
         if (treeNode?.children) {
-            return mcf.treeNodeChildrenToStringArray(treeNode.children, treeNode.executable).map(v => [...current, v]);
+            return mcf
+                .treeNodeChildrenToStringArray(treeNode.children, treeNode.executable)
+                .map((v) => [...current, v]);
         }
     }
     return current.length ? [current] : [];