@wq2/brigadier-ts 1.0.3 → 1.0.5

package/README.md

@@ -4,6 +4,7 @@ Fork of [brigadier-ts](https://github.com/misode/brigadier-ts) with some changes
 
 - (breaking change) Predicates and Commands are async
 - Non-literal arguments don't unconditionally return empty suggestions (WHY DID THIS EXIST???)
+- No circular dependencies
 - Update branding
 
 (not many, but we'll probably add more later)
@@ -24,7 +25,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 class CommandSource {
     private a: number;
@@ -62,7 +63,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 const dispatcher = new CommandDispatcher<number>();
 const execute = dispatcher.register(literal("execute"));
@@ -100,7 +101,7 @@ import {
     IntegerArgumentType,
     literal,
     argument
-} from "brigadier-ts";
+} from "@wq2/brigadier-ts";
 
 const dispatcher = new CommandDispatcher<number>();
 dispatcher.register(literal("double")

package/dist/CommandDispatcher.d.ts

@@ -1,4 +1,10 @@
-import { type CommandNode, type LiteralArgumentBuilder, type LiteralCommandNode, ParseResults, RootCommandNode, StringReader, Suggestions } from ".";
+import type { LiteralArgumentBuilder } from "./builder/LiteralArgumentBuilder";
+import { ParseResults } from "./ParseResults";
+import { StringReader } from "./StringReader";
+import { Suggestions } from "./suggestion/Suggestions";
+import type { CommandNode } from "./tree/CommandNode";
+import type { LiteralCommandNode } from "./tree/LiteralCommandNode";
+import { RootCommandNode } from "./tree/RootCommandNode";
 export declare class CommandDispatcher<S> {
     private root;
     private static USAGE_OPTIONAL_OPEN;

package/dist/CommandDispatcher.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandDispatcher = void 0;
-const _1 = require(".");
+const CommandContextBuilder_1 = require("./context/CommandContextBuilder");
+const CommandSyntaxError_1 = require("./exceptions/CommandSyntaxError");
+const ParseResults_1 = require("./ParseResults");
+const StringReader_1 = require("./StringReader");
+const Suggestions_1 = require("./suggestion/Suggestions");
+const SuggestionsBuilder_1 = require("./suggestion/SuggestionsBuilder");
+const RootCommandNode_1 = require("./tree/RootCommandNode");
 class CommandDispatcher {
     constructor() {
-        this.root = new _1.RootCommandNode();
+        this.root = new RootCommandNode_1.RootCommandNode();
     }
     register(command) {
         const build = command.build();
@@ -13,17 +19,17 @@ class CommandDispatcher {
     }
     async execute(parse, source) {
         if (typeof parse === "string") {
-            parse = await this.parse(new _1.StringReader(parse), source);
+            parse = await this.parse(new StringReader_1.StringReader(parse), source);
         }
         if (parse.getReader().canRead()) {
             if (parse.getErrors().size === 1) {
                 throw parse.getErrors().values().next();
             }
             else if (parse.getContext().getRange().isEmpty()) {
-                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+                throw CommandSyntaxError_1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
             }
             else {
-                throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
+                throw CommandSyntaxError_1.CommandSyntaxError.DISPATCHER_UNKNOWN_ARGUMENT.createWithContext(parse.getReader());
             }
         }
         let result = 0;
@@ -78,13 +84,13 @@ class CommandDispatcher {
             next = [];
         }
         if (!foundCommand) {
-            throw _1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
+            throw CommandSyntaxError_1.CommandSyntaxError.DISPATCHER_UNKNOWN_COMMAND.createWithContext(parse.getReader());
         }
         return forked ? successfulForks : result;
     }
     async parse(reader, source) {
-        reader = new _1.StringReader(reader);
-        const context = new _1.CommandContextBuilder(this, source, this.root, reader.getCursor());
+        reader = new StringReader_1.StringReader(reader);
+        const context = new CommandContextBuilder_1.CommandContextBuilder(this, source, this.root, reader.getCursor());
         return this.parseNodes(this.root, reader, context);
     }
     async parseNodes(node, originalReader, contextSoFar) {
@@ -97,25 +103,25 @@ class CommandDispatcher {
                 continue;
             }
             const context = contextSoFar.copy();
-            const reader = new _1.StringReader(originalReader);
+            const reader = new StringReader_1.StringReader(originalReader);
             try {
                 try {
                     child.parse(reader, context);
                 }
                 catch (e) {
-                    if (e instanceof _1.CommandSyntaxError) {
+                    if (e instanceof CommandSyntaxError_1.CommandSyntaxError) {
                         throw e;
                     }
                     else {
-                        throw _1.CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
+                        throw CommandSyntaxError_1.CommandSyntaxError.DISPATCHER_PARSE_ERROR.createWithContext(reader, e.message);
                     }
                 }
                 if (reader.canRead() && reader.peek() !== " ") {
-                    throw _1.CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
+                    throw CommandSyntaxError_1.CommandSyntaxError.DISPATCHER_EXPECTED_ARGUMENT_SEPARATOR.createWithContext(reader);
                 }
             }
             catch (e) {
-                if (e instanceof _1.CommandSyntaxError) {
+                if (e instanceof CommandSyntaxError_1.CommandSyntaxError) {
                     errors.set(child, e);
                     reader.setCursor(cursor);
                     continue;
@@ -128,21 +134,21 @@ class CommandDispatcher {
             if (reader.canRead(child.getRedirect() === null ? 2 : 1)) {
                 reader.skip();
                 if (child.getRedirect()) {
-                    const childContext = new _1.CommandContextBuilder(this, source, child.getRedirect(), reader.getCursor());
+                    const childContext = new CommandContextBuilder_1.CommandContextBuilder(this, source, child.getRedirect(), reader.getCursor());
                     const parse = await this.parseNodes(child.getRedirect(), reader, childContext);
                     context.withChild(parse.getContext());
-                    return new _1.ParseResults(context, parse.getReader(), parse.getErrors());
+                    return new ParseResults_1.ParseResults(context, parse.getReader(), parse.getErrors());
                 }
                 else {
                     potentials.push(this.parseNodes(child, reader, context));
                 }
             }
             else {
-                potentials.push(new _1.ParseResults(context, reader, new Map()));
+                potentials.push(new ParseResults_1.ParseResults(context, reader, new Map()));
             }
         }
         if (potentials.length === 0) {
-            potentials.push(new _1.ParseResults(contextSoFar, originalReader, errors));
+            potentials.push(new ParseResults_1.ParseResults(contextSoFar, originalReader, errors));
         }
         return potentials[0];
     }
@@ -187,9 +193,9 @@ class CommandDispatcher {
         const truncatedInput = fullInput.substring(0, cursor);
         const promises = [];
         for (const node of parent.getChildren()) {
-            let promise = _1.Suggestions.empty();
+            let promise = Suggestions_1.Suggestions.empty();
             try {
-                promise = node.listSuggestions(context.build(truncatedInput), new _1.SuggestionsBuilder(truncatedInput, start));
+                promise = node.listSuggestions(context.build(truncatedInput), new SuggestionsBuilder_1.SuggestionsBuilder(truncatedInput, start));
             }
             catch (ignored) {
                 console.log("???", ignored);
@@ -197,7 +203,7 @@ class CommandDispatcher {
             promises.push(promise);
         }
         const suggestions = await Promise.all(promises);
-        return _1.Suggestions.merge(fullInput, suggestions);
+        return Suggestions_1.Suggestions.merge(fullInput, suggestions);
     }
     getSmartUsage(node, source, optional, deep) {
         if (optional === undefined && deep === undefined) {

package/dist/tree/ArgumentCommandNode.d.ts

@@ -8,9 +8,11 @@ import type { StringReader } from "../StringReader";
 import type { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
 import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 export declare class ArgumentCommandNode<S, T> extends CommandNode<S> {
     name: string;
     type: ArgumentType<T>;
+    _thing: CommandNodeThing;
     constructor(name: string, type: ArgumentType<T>, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
     getType(): ArgumentType<T>;
     parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;

package/dist/tree/ArgumentCommandNode.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArgumentCommandNode = void 0;
 const ParsedArgument_1 = require("../context/ParsedArgument");
 const CommandNode_1 = require("./CommandNode");
+const internal2_1 = require("./internal2");
 class ArgumentCommandNode extends CommandNode_1.CommandNode {
     constructor(name, type, command, requirement, redirect, modifier, forks) {
         super(command, requirement, redirect, modifier, forks);
+        this._thing = internal2_1.default.ARGUMENT;
         this.name = name;
         this.type = type;
     }

package/dist/tree/CommandNode.d.ts

@@ -6,6 +6,7 @@ import type { Predicate } from "../Predicate";
 import type { StringReader } from "../StringReader";
 import type { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import CommandNodeThing from "./internal2";
 export declare abstract class CommandNode<S> {
     private children;
     private literals;
@@ -15,6 +16,13 @@ export declare abstract class CommandNode<S> {
     private redirect;
     private modifier;
     private forks;
+    /**
+     * This is used for detecting what type of command node this is, without having circular dependencies.
+     * @internal
+     * @hidden
+     * @protected
+     */
+    _thing: CommandNodeThing;
     constructor(command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
     getCommand(): Command<S>;
     getChildren(): CommandNode<S>[];

package/dist/tree/CommandNode.js

@@ -1,9 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandNode = void 0;
-const __1 = require("..");
+const internal2_1 = require("./internal2");
 class CommandNode {
     constructor(command, requirement, redirect, modifier, forks) {
+        /**
+         * This is used for detecting what type of command node this is, without having circular dependencies.
+         * @internal
+         * @hidden
+         * @protected
+         */
+        this._thing = internal2_1.default.UNSPECIFIED;
         this.children = new Map();
         this.literals = new Map();
         this.arguments = new Map();
@@ -46,10 +53,10 @@ class CommandNode {
         }
         else {
             this.children.set(node.getName(), node);
-            if (node instanceof __1.LiteralCommandNode) {
+            if (node._thing === internal2_1.default.LITERAL) {
                 this.literals.set(node.getName(), node);
             }
-            else if (node instanceof __1.ArgumentCommandNode) {
+            else if (node._thing === internal2_1.default.ARGUMENT) {
                 this.arguments.set(node.getName(), node);
             }
         }

package/dist/tree/LiteralCommandNode.d.ts

@@ -7,8 +7,10 @@ import type { StringReader } from "../StringReader";
 import { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
 import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 export declare class LiteralCommandNode<S> extends CommandNode<S> {
     private literal;
+    _thing: CommandNodeThing;
     constructor(literal: string, command: Command<S>, requirement: Predicate<S>, redirect: CommandNode<S>, modifier: RedirectModifier<S>, forks: boolean);
     parse(reader: StringReader, contextBuilder: CommandContextBuilder<S>): void;
     private parseInternal;

package/dist/tree/LiteralCommandNode.js

@@ -5,9 +5,11 @@ const StringRange_1 = require("../context/StringRange");
 const CommandSyntaxError_1 = require("../exceptions/CommandSyntaxError");
 const Suggestions_1 = require("../suggestion/Suggestions");
 const CommandNode_1 = require("./CommandNode");
+const internal2_1 = require("./internal2");
 class LiteralCommandNode extends CommandNode_1.CommandNode {
     constructor(literal, command, requirement, redirect, modifier, forks) {
         super(command, requirement, redirect, modifier, forks);
+        this._thing = internal2_1.default.LITERAL;
         this.literal = literal;
     }
     parse(reader, contextBuilder) {

package/dist/tree/internal.d.ts

@@ -0,0 +1,3 @@
+import type { ArgumentCommandNode } from "./ArgumentCommandNode";
+import type { CommandNode } from "./CommandNode";
+export declare function isArgumentNode<A>(n: CommandNode<A>): n is ArgumentCommandNode<A, unknown>;

package/dist/tree/internal.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArgumentNode = isArgumentNode;
+const internal2_1 = require("./internal2");
+function isArgumentNode(n) {
+    return n._thing === internal2_1.default.ARGUMENT;
+}

package/dist/tree/internal2.d.ts

@@ -0,0 +1,6 @@
+export declare enum CommandNodeThing {
+    UNSPECIFIED = 0,
+    ARGUMENT = 1,
+    LITERAL = 2
+}
+export default CommandNodeThing;

package/dist/tree/internal2.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandNodeThing = void 0;
+var CommandNodeThing;
+(function (CommandNodeThing) {
+    CommandNodeThing[CommandNodeThing["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    CommandNodeThing[CommandNodeThing["ARGUMENT"] = 1] = "ARGUMENT";
+    CommandNodeThing[CommandNodeThing["LITERAL"] = 2] = "LITERAL";
+})(CommandNodeThing || (exports.CommandNodeThing = CommandNodeThing = {}));
+exports.default = CommandNodeThing;

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/Command.ts","../src/CommandDispatcher.ts","../src/ParseResults.ts","../src/Predicate.ts","../src/StringReader.ts","../src/index.ts","../src/arguments/ArgumentType.ts","../src/arguments/BoolArgumentType.ts","../src/arguments/FloatArgumentType.ts","../src/arguments/IntegerArgumentType.ts","../src/arguments/LongArgumentType.ts","../src/arguments/NumberArgumentType.ts","../src/arguments/StringArgumentType.ts","../src/builder/ArgumentBuilder.ts","../src/builder/LiteralArgumentBuilder.ts","../src/builder/RequiredArgumentBuilder.ts","../src/context/CommandContext.ts","../src/context/CommandContextBuilder.ts","../src/context/ParsedArgument.ts","../src/context/ParsedCommandNode.ts","../src/context/StringRange.ts","../src/context/SuggestionContext.ts","../src/exceptions/CommandErrorType.ts","../src/exceptions/CommandSyntaxError.ts","../src/suggestion/Suggestion.ts","../src/suggestion/Suggestions.ts","../src/suggestion/SuggestionsBuilder.ts","../src/tree/ArgumentCommandNode.ts","../src/tree/CommandNode.ts","../src/tree/LiteralCommandNode.ts","../src/tree/RootCommandNode.ts"],"version":"5.9.3"}
+{"root":["../src/Command.ts","../src/CommandDispatcher.ts","../src/ParseResults.ts","../src/Predicate.ts","../src/StringReader.ts","../src/index.ts","../src/arguments/ArgumentType.ts","../src/arguments/BoolArgumentType.ts","../src/arguments/FloatArgumentType.ts","../src/arguments/IntegerArgumentType.ts","../src/arguments/LongArgumentType.ts","../src/arguments/NumberArgumentType.ts","../src/arguments/StringArgumentType.ts","../src/builder/ArgumentBuilder.ts","../src/builder/LiteralArgumentBuilder.ts","../src/builder/RequiredArgumentBuilder.ts","../src/context/CommandContext.ts","../src/context/CommandContextBuilder.ts","../src/context/ParsedArgument.ts","../src/context/ParsedCommandNode.ts","../src/context/StringRange.ts","../src/context/SuggestionContext.ts","../src/exceptions/CommandErrorType.ts","../src/exceptions/CommandSyntaxError.ts","../src/suggestion/Suggestion.ts","../src/suggestion/Suggestions.ts","../src/suggestion/SuggestionsBuilder.ts","../src/tree/ArgumentCommandNode.ts","../src/tree/CommandNode.ts","../src/tree/LiteralCommandNode.ts","../src/tree/RootCommandNode.ts","../src/tree/internal.ts","../src/tree/internal2.ts"],"version":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wq2/brigadier-ts",
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"description": "Fork of brigadier-ts with some extra changes",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

package/src/CommandDispatcher.ts

@@ -1,15 +1,13 @@
-import {
-	CommandContextBuilder,
-	type CommandNode,
-	CommandSyntaxError,
-	type LiteralArgumentBuilder,
-	type LiteralCommandNode,
-	ParseResults,
-	RootCommandNode,
-	StringReader,
-	Suggestions,
-	SuggestionsBuilder,
-} from ".";
+import type { LiteralArgumentBuilder } from "./builder/LiteralArgumentBuilder";
+import { CommandContextBuilder } from "./context/CommandContextBuilder";
+import { CommandSyntaxError } from "./exceptions/CommandSyntaxError";
+import { ParseResults } from "./ParseResults";
+import { StringReader } from "./StringReader";
+import { Suggestions } from "./suggestion/Suggestions";
+import { SuggestionsBuilder } from "./suggestion/SuggestionsBuilder";
+import type { CommandNode } from "./tree/CommandNode";
+import type { LiteralCommandNode } from "./tree/LiteralCommandNode";
+import { RootCommandNode } from "./tree/RootCommandNode";
 
 export class CommandDispatcher<S> {
 	private root: RootCommandNode<S>;

package/src/builder/ArgumentBuilder.ts

@@ -22,7 +22,9 @@ export abstract class ArgumentBuilder<S, T extends ArgumentBuilder<S, T>> {
 	abstract getThis(): T;
 
 	// biome-ignore lint/suspicious/noThenProperty: proof?
-	then<A extends ArgumentBuilder<S, A>>(argument: ArgumentBuilder<S, A> | CommandNode<S>): T {
+	then<A extends ArgumentBuilder<S, A>>(
+		argument: ArgumentBuilder<S, A> | CommandNode<S>,
+	): T {
 		const child = argument instanceof CommandNode ? argument : argument.build();
 		this.arguments.addChild(child);
 		return this.getThis();

package/src/tree/ArgumentCommandNode.ts

@@ -9,10 +9,12 @@ import type { StringReader } from "../StringReader";
 import type { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
 import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 
 export class ArgumentCommandNode<S, T> extends CommandNode<S> {
 	name: string;
 	type: ArgumentType<T>;
+	_thing: CommandNodeThing = CommandNodeThing.ARGUMENT;
 
 	constructor(
 		name: string,

package/src/tree/CommandNode.ts

@@ -1,4 +1,4 @@
-import { ArgumentCommandNode, LiteralCommandNode } from "..";
+import type { ArgumentCommandNode, LiteralCommandNode } from "..";
 import type { RedirectModifier } from "../builder/ArgumentBuilder";
 import type { Command } from "../Command";
 import type { CommandContext } from "../context/CommandContext";
@@ -7,6 +7,7 @@ import type { Predicate } from "../Predicate";
 import type { StringReader } from "../StringReader";
 import type { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
+import CommandNodeThing from "./internal2";
 
 export abstract class CommandNode<S> {
 	private children: Map<string, CommandNode<S>>;
@@ -17,6 +18,13 @@ export abstract class CommandNode<S> {
 	private redirect: CommandNode<S>;
 	private modifier: RedirectModifier<S>;
 	private forks: boolean;
+	/**
+	 * This is used for detecting what type of command node this is, without having circular dependencies.
+	 * @internal
+	 * @hidden
+	 * @protected
+	 */
+	_thing: CommandNodeThing = CommandNodeThing.UNSPECIFIED;
 
 	constructor(
 		command: Command<S>,
@@ -74,10 +82,13 @@ export abstract class CommandNode<S> {
 			});
 		} else {
 			this.children.set(node.getName(), node);
-			if (node instanceof LiteralCommandNode) {
-				this.literals.set(node.getName(), node);
-			} else if (node instanceof ArgumentCommandNode) {
-				this.arguments.set(node.getName(), node);
+			if (node._thing === CommandNodeThing.LITERAL) {
+				this.literals.set(node.getName(), node as LiteralCommandNode<S>);
+			} else if (node._thing === CommandNodeThing.ARGUMENT) {
+				this.arguments.set(
+					node.getName(),
+					node as ArgumentCommandNode<S, unknown>,
+				);
 			}
 		}
 	}

package/src/tree/LiteralCommandNode.ts

@@ -9,9 +9,11 @@ import type { StringReader } from "../StringReader";
 import { Suggestions } from "../suggestion/Suggestions";
 import type { SuggestionsBuilder } from "../suggestion/SuggestionsBuilder";
 import { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
 
 export class LiteralCommandNode<S> extends CommandNode<S> {
 	private literal: string;
+	_thing: CommandNodeThing = CommandNodeThing.LITERAL;
 
 	constructor(
 		literal: string,

package/src/tree/internal.ts

@@ -0,0 +1,9 @@
+import type { ArgumentCommandNode } from "./ArgumentCommandNode";
+import type { CommandNode } from "./CommandNode";
+import CommandNodeThing from "./internal2";
+
+export function isArgumentNode<A>(
+	n: CommandNode<A>,
+): n is ArgumentCommandNode<A, unknown> {
+	return n._thing === CommandNodeThing.ARGUMENT;
+}

package/src/tree/internal2.ts

@@ -0,0 +1,6 @@
+export enum CommandNodeThing {
+	UNSPECIFIED,
+	ARGUMENT,
+	LITERAL,
+}
+export default CommandNodeThing;