@wq2/brigadier-ts 1.0.3 → 1.0.4

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/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.4",
 	"description": "Fork of brigadier-ts with some extra changes",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",

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;