@spyglassmc/mcfunction 0.2.9 → 0.2.10

package/lib/completer/index.d.ts

@@ -1,8 +1,8 @@
 import * as core from '@spyglassmc/core';
-import type { McfunctionNode } from '../node/index.js';
+import type { CommandChildNode, McfunctionNode } from '../node/index.js';
 import { CommandNode } from '../node/index.js';
 import type { ArgumentTreeNode, RootTreeNode } from '../tree/index.js';
-export type MockNodesGetter = (treeNode: ArgumentTreeNode, range: core.CompleterContext) => core.Arrayable<core.AstNode>;
+export type MockNodesGetter = (treeNode: ArgumentTreeNode, prevNodes: CommandChildNode[], range: core.CompleterContext) => core.Arrayable<core.AstNode>;
 /**
  * @param getMockNodes A function that returns a mock AST Node from given {@link ArgumentTreeNode}. These mock nodes
  * will be used for completing the argument.

package/lib/completer/index.js

@@ -34,9 +34,11 @@ export function command(tree, getMockNodes) {
             return [];
         }
         const { literalTreeNodes, argumentTreeNodes } = categorizeTreeChildren(parentTreeNode.children);
+        const lastIndex = node.children.indexOf(lastChildNode);
+        const prevNodes = node.children.slice(0, lastIndex + 1);
         return [
             ...literalTreeNodes.map(([name]) => core.CompletionItem.create(name, ctx.offset, { kind: 14 /* core.CompletionKind.Keyword */ })),
-            ...argumentTreeNodes.flatMap(([_name, treeNode]) => core.Arrayable.toArray(getMockNodes(treeNode, ctx)).flatMap((n) => core.completer.dispatch(n, ctx))),
+            ...argumentTreeNodes.flatMap(([_name, treeNode]) => core.Arrayable.toArray(getMockNodes(treeNode, prevNodes, ctx)).flatMap((n) => core.completer.dispatch(n, ctx))),
         ];
     };
 }

package/lib/node/command.d.ts

@@ -1,11 +1,16 @@
 import * as core from '@spyglassmc/core';
+export interface CommandOptions {
+    slash?: 'allowed' | 'required';
+    maxLength?: number;
+}
 export interface CommandNode extends core.SequenceNode<CommandChildNode> {
     type: 'mcfunction:command';
+    readonly options: CommandOptions;
     slash?: core.Range;
 }
 export declare namespace CommandNode {
     function is<T extends core.DeepReadonly<core.AstNode> | undefined>(node: T): node is core.InheritReadonly<CommandNode, T>;
-    function mock(range: core.RangeLike): CommandNode;
+    function mock(range: core.RangeLike, options?: CommandOptions): CommandNode;
 }
 export interface CommandChildNode extends core.AstNode {
     type: 'mcfunction:command_child';

package/lib/node/command.js

@@ -6,8 +6,8 @@ export var CommandNode;
         return node?.type === 'mcfunction:command';
     }
     CommandNode.is = is;
-    function mock(range) {
-        return { type: 'mcfunction:command', range: core.Range.get(range), children: [] };
+    function mock(range, options = {}) {
+        return { type: 'mcfunction:command', range: core.Range.get(range), children: [], options };
     }
     CommandNode.mock = mock;
 })(CommandNode || (CommandNode = {}));

package/lib/parser/argument.d.ts

@@ -1,4 +1,5 @@
 import type * as core from '@spyglassmc/core';
+import type { CommandChildNode } from '../node/command.js';
 import type { ArgumentTreeNode } from '../tree/index.js';
 /**
  * A function that returns a parser for the provided tree node.
@@ -7,6 +8,6 @@ import type { ArgumentTreeNode } from '../tree/index.js';
  *
  * @returns The parser corresponding to that tree node, or `undefined` if such parser doesn't exist.
  */
-export type ArgumentParserGetter = (treeNode: ArgumentTreeNode) => core.Parser | undefined;
+export type ArgumentParserGetter = (treeNode: ArgumentTreeNode, prevNodes: CommandChildNode[]) => core.Parser | undefined;
 export declare function argumentTreeNodeToString(name: string, treeNode: ArgumentTreeNode): string;
 //# sourceMappingURL=argument.d.ts.map

package/lib/parser/command.d.ts

@@ -1,11 +1,11 @@
 import * as core from '@spyglassmc/core';
-import type { CommandNode } from '../node/index.js';
+import type { CommandNode, CommandOptions } from '../node/index.js';
 import type { RootTreeNode, TreeNode } from '../tree/type.js';
 import type { ArgumentParserGetter } from './argument.js';
 /**
  * @returns A parser that always takes a whole line (excluding line turn characters) and tries to parse it as a command.
  */
-export declare function command(tree: RootTreeNode, argument: ArgumentParserGetter): core.InfallibleParser<CommandNode>;
+export declare function command(tree: RootTreeNode, argument: ArgumentParserGetter, options?: CommandOptions): core.InfallibleParser<CommandNode>;
 export declare function treeNodeChildrenToStringArray(children: Exclude<TreeNode['children'], undefined>, executable?: boolean): string[];
 export declare function treeNodeChildrenToString(children: Exclude<TreeNode['children'], undefined>): string;
 export declare function treeNodeToString(name: string, treeNode: TreeNode): string;

package/lib/parser/command.js

@@ -7,16 +7,24 @@ import { literal } from './literal.js';
 /**
  * @returns A parser that always takes a whole line (excluding line turn characters) and tries to parse it as a command.
  */
-export function command(tree, argument) {
+export function command(tree, argument, options = {}) {
     return (src, ctx) => {
         const ans = {
             type: 'mcfunction:command',
             range: core.Range.create(src),
             children: [],
+            options,
         };
         const start = src.cursor;
+        const innerStart = src.innerCursor;
         if (src.trySkip('/')) {
             ans.slash = core.Range.create(start, src.cursor);
+            if (!options.slash) {
+                ctx.err.report(localize('mcfunction.parser.leading-slash.unexpected'), ans.slash);
+            }
+        }
+        else if (options.slash === 'required') {
+            ctx.err.report(localize('expected', localize('mcfunction.parser.leading-slash')), core.Range.create(start, start + 1));
         }
         dispatch(ans.children, src, ctx, [], tree, tree, argument);
         if (src.canReadInLine()) {
@@ -30,6 +38,12 @@ export function command(tree, argument) {
             });
         }
         ans.range.end = src.cursor;
+        if (options.maxLength) {
+            const commandLength = src.innerCursor - innerStart;
+            if (commandLength > options.maxLength) {
+                ctx.err.report(localize('mcfunction.parser.command-too-long', commandLength, options.maxLength), ans);
+            }
+        }
         return ans;
     };
 }
@@ -48,7 +62,7 @@ function dispatch(ans, src, ctx, path, rootTreeNode, parentTreeNode, argument) {
             return false;
         }
         const { literalTreeNodes, argumentTreeNodes } = categorizeTreeChildren(children);
-        const argumentParsers = argumentTreeNodes.map(([name, treeNode]) => ({ name, parser: argument(treeNode) ?? unknown(treeNode) }));
+        const argumentParsers = argumentTreeNodes.map(([name, treeNode]) => ({ name, parser: argument(treeNode, ans) ?? unknown(treeNode) }));
         const literalParser = literalTreeNodes.length
             ? literal(literalTreeNodes.map(([name, _treeNode]) => name), parent.type === 'root')
             : undefined;

package/lib/parser/entry.d.ts

@@ -1,14 +1,11 @@
 import * as core from '@spyglassmc/core';
-import type { McfunctionNode } from '../node/index.js';
+import type { CommandOptions, McfunctionNode } from '../node/index.js';
 import type { RootTreeNode } from '../tree/index.js';
 import type { ArgumentParserGetter } from './argument.js';
-/**
- * @param supportsBackslashContinuation Whether or not to concatenate lines together on trailing backslashes.
- * @param supportsMacros Whether or not to parse macro lines as an error.
- * Disabled by default.
- */
-export declare const entry: (commandTree: RootTreeNode, argument: ArgumentParserGetter, { supportsBackslashContinuation, supportsMacros }?: {
-    supportsBackslashContinuation?: boolean | undefined;
-    supportsMacros?: boolean | undefined;
-}) => core.Parser<McfunctionNode>;
+export interface McfunctionOptions {
+    lineContinuation?: boolean;
+    macros?: boolean;
+    commandOptions?: CommandOptions;
+}
+export declare const entry: (commandTree: RootTreeNode, argument: ArgumentParserGetter, options?: McfunctionOptions) => core.Parser<McfunctionNode>;
 //# sourceMappingURL=entry.d.ts.map

package/lib/parser/entry.js

@@ -1,7 +1,7 @@
 import * as core from '@spyglassmc/core';
 import { command } from './command.js';
 import { macro } from './macro.js';
-function mcfunction(commandTree, argument, { supportsMacros }) {
+function mcfunction(commandTree, argument, options) {
     return (src, ctx) => {
         const ans = {
             type: 'mcfunction:entry',
@@ -14,10 +14,10 @@ function mcfunction(commandTree, argument, { supportsMacros }) {
                 result = comment(src, ctx);
             }
             else if (src.peek() === '$') {
-                result = macro(supportsMacros)(src, ctx);
+                result = macro(options.macros ?? false)(src, ctx);
             }
             else {
-                result = command(commandTree, argument)(src, ctx);
+                result = command(commandTree, argument, options.commandOptions)(src, ctx);
             }
             ans.children.push(result);
             src.nextLine();
@@ -27,13 +27,8 @@ function mcfunction(commandTree, argument, { supportsMacros }) {
     };
 }
 const comment = core.comment({ singleLinePrefixes: new Set(['#']) });
-/**
- * @param supportsBackslashContinuation Whether or not to concatenate lines together on trailing backslashes.
- * @param supportsMacros Whether or not to parse macro lines as an error.
- * Disabled by default.
- */
-export const entry = (commandTree, argument, { supportsBackslashContinuation = false, supportsMacros = false } = {}) => {
-    const parser = mcfunction(commandTree, argument, { supportsMacros });
-    return supportsBackslashContinuation ? core.concatOnTrailingBackslash(parser) : parser;
+export const entry = (commandTree, argument, options = {}) => {
+    const parser = mcfunction(commandTree, argument, options);
+    return options.lineContinuation ? core.concatOnTrailingBackslash(parser) : parser;
 };
 //# sourceMappingURL=entry.js.map

package/lib/parser/macro.js

@@ -74,7 +74,7 @@ function validateMacroArgument(src, ctx, start) {
     src.skip(2);
     const keyStart = src.cursor;
     src.skipUntilOrEnd(core.LF, core.CR, ')');
-    if (src.peek() != ')') {
+    if (src.peek() !== ')') {
         // Macro key was not closed
         ctx.err.report(localize('expected', localeQuote(')')), core.Range.create(keyStart, src.cursor));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcfunction",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,7 +25,7 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.7",
-    "@spyglassmc/locales": "0.3.7"
+    "@spyglassmc/core": "0.4.8",
+    "@spyglassmc/locales": "0.3.8"
   }
 }