@spyglassmc/mcfunction 0.2.33 → 0.2.34

package/lib/colorizer/macro.js

@@ -1,9 +1,11 @@
 import * as core from '@spyglassmc/core';
 export const macro = (node, ctx) => {
     const tokens = [];
-    tokens.push(core.ColorToken.create(core.Range.create(node.range.start, node.range.start + 1), 'literal')); // Dollar Sign
     for (const child of node.children) {
-        if (child.type === 'mcfunction:macro/other') {
+        if (child.type === 'mcfunction:macro/prefix') {
+            tokens.push(core.ColorToken.create(child.range, 'literal'));
+        }
+        else if (child.type === 'mcfunction:macro/other') {
             tokens.push(core.ColorToken.create(child.range, 'string'));
         }
         else {

package/lib/completer/index.js

@@ -1,5 +1,5 @@
 import * as core from '@spyglassmc/core';
-import { CommandNode, MacroNode } from '../node/index.js';
+import { CommandNode } from '../node/index.js';
 import { categorizeTreeChildren, redirect, resolveParentTreeNode } from '../tree/index.js';
 /**
  * @param getMockNodes A function that returns a mock AST Node from given {@link ArgumentTreeNode}. These mock nodes
@@ -8,11 +8,11 @@ import { categorizeTreeChildren, redirect, resolveParentTreeNode } from '../tree
 export function entry(tree, getMockNodes) {
     return (node, ctx) => {
         const childNode = core.AstNode.findChild(node, ctx.offset, true);
-        if (core.CommentNode.is(childNode) || MacroNode.is(childNode)) {
-            return [];
+        if (CommandNode.is(childNode)) {
+            return command(tree, getMockNodes)(childNode ?? CommandNode.mock(ctx.offset), ctx);
         }
         else {
-            return command(tree, getMockNodes)(childNode ?? CommandNode.mock(ctx.offset), ctx);
+            return [];
         }
     };
 }

package/lib/node/entry.d.ts

@@ -1,7 +1,7 @@
 import type * as core from '@spyglassmc/core';
 import type { CommandNode } from './command.js';
 import type { MacroNode } from './macro.js';
-export interface McfunctionNode extends core.SequenceNode<CommandNode | MacroNode | core.CommentNode> {
+export interface McfunctionNode extends core.SequenceNode<CommandNode | MacroNode | core.CommentNode | core.ErrorNode> {
     type: 'mcfunction:entry';
 }
 export declare namespace McfunctionNode {

package/lib/node/macro.d.ts

@@ -1,12 +1,15 @@
 import * as core from '@spyglassmc/core';
-export interface MacroNode extends core.SequenceNode<MacroOtherNode | MacroArgumentNode> {
+export interface MacroNode extends core.SequenceNode<MacroPrefixNode | MacroOtherNode | MacroArgumentNode> {
     type: 'mcfunction:macro';
-    children: (MacroOtherNode | MacroArgumentNode)[];
+    children: (MacroPrefixNode | MacroOtherNode | MacroArgumentNode)[];
 }
 export declare namespace MacroNode {
     function is<T extends core.DeepReadonly<core.AstNode> | undefined>(obj: T): obj is core.InheritReadonly<MacroNode, T>;
     function mock(range: core.RangeLike): MacroNode;
 }
+export interface MacroPrefixNode extends core.AstNode {
+    type: 'mcfunction:macro/prefix';
+}
 export interface MacroOtherNode extends core.AstNode {
     type: 'mcfunction:macro/other';
     value?: string;

package/lib/parser/entry.js

@@ -1,4 +1,5 @@
 import * as core from '@spyglassmc/core';
+import { localize } from '@spyglassmc/locales';
 import { command } from './command.js';
 import { macro } from './macro.js';
 function mcfunction(commandTree, argument, options) {
@@ -14,7 +15,19 @@ function mcfunction(commandTree, argument, options) {
                 result = comment(src, ctx);
             }
             else if (src.peek() === '$') {
-                result = macro(options.macros ?? false)(src, ctx);
+                const start = src.cursor;
+                if (options.macros) {
+                    result = macro()(src, ctx);
+                }
+                else {
+                    src.skipLine();
+                    ans.range.end = src.cursor;
+                    result = {
+                        type: 'error',
+                        range: core.Range.create(start, src),
+                    };
+                    ctx.err.report(localize('mcfunction.parser.macro.disallowed'), result);
+                }
             }
             else {
                 result = command(commandTree, argument, options.commandOptions)(src, ctx);

package/lib/parser/macro.d.ts

@@ -2,8 +2,7 @@ import * as core from '@spyglassmc/core';
 import type { MacroNode } from '../node/index.js';
 /**
  * Parse a macro line.
- * @param supportsMacros When false, reports the entire line as an error (due to
- * the Minecraft version not supporting macros).
+ * @param hasPrefix When false, don't look for a starting '$'.
  */
-export declare function macro(supportsMacros?: boolean): core.Parser<MacroNode | core.ErrorNode>;
+export declare function macro(hasPrefix?: boolean): core.InfallibleParser<MacroNode>;
 //# sourceMappingURL=macro.d.ts.map

package/lib/parser/macro.js

@@ -2,26 +2,30 @@ import * as core from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
 /**
  * Parse a macro line.
- * @param supportsMacros When false, reports the entire line as an error (due to
- * the Minecraft version not supporting macros).
+ * @param hasPrefix When false, don't look for a starting '$'.
  */
-export function macro(supportsMacros = true) {
+export function macro(hasPrefix = true) {
     return (src, ctx) => {
         const ans = {
             type: 'mcfunction:macro',
             range: core.Range.create(src.cursor),
             children: [],
         };
-        if (!supportsMacros) {
-            src.skipLine();
-            ans.range.end = src.cursor;
-            ctx.err.report(localize('mcfunction.parser.macro.disallowed'), ans.range);
-            return { ...ans, type: 'error' };
-        }
-        // Skip the starting '$'
-        src.skip();
         let start = src.cursor;
         let hasMacroArgs = false;
+        if (hasPrefix) {
+            // Skip the starting '$'
+            if (src.trySkip('$')) {
+                ans.children.push({
+                    type: 'mcfunction:macro/prefix',
+                    range: core.Range.create(start, src),
+                });
+                start = src.cursor;
+            }
+            else {
+                ctx.err.report(localize('expected', localeQuote('$')), ans);
+            }
+        }
         while (src.canReadInLine()) {
             src.skipUntilOrEnd(core.LF, core.CR, '$');
             if (src.peek(2) === '$(') {
@@ -31,7 +35,7 @@ export function macro(supportsMacros = true) {
                 if (other.length > 0) {
                     ans.children.push({
                         type: 'mcfunction:macro/other',
-                        range: core.Range.create(start, src.cursor),
+                        range: core.Range.create(start, src),
                         value: other,
                     });
                     start = src.cursor;
@@ -53,7 +57,7 @@ export function macro(supportsMacros = true) {
                     // No more macro arguments, add the remaining other stuff
                     ans.children.push({
                         type: 'mcfunction:macro/other',
-                        range: core.Range.create(start, src.cursor),
+                        range: core.Range.create(start, src),
                         value: src.sliceToCursor(start),
                     });
                 }
@@ -61,7 +65,7 @@ export function macro(supportsMacros = true) {
         }
         // A line with no macro arguments is invalid
         if (!hasMacroArgs) {
-            ctx.err.report(localize('expected', localize('mcfunction.parser.macro.at-least-one')), core.Range.create(start, src.cursor));
+            ctx.err.report(localize('expected', localize('mcfunction.parser.macro.at-least-one')), core.Range.create(start, src));
         }
         ans.range.end = src.cursor;
         return ans;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcfunction",
-  "version": "0.2.33",
+  "version": "0.2.34",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",