@spyglassmc/java-edition 0.1.0

package/lib/mcfunction/parser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './argument';
+//# sourceMappingURL=index.d.ts.map

package/lib/mcfunction/parser/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./argument"), exports);
+//# sourceMappingURL=index.js.map

package/lib/mcfunction/signatureHelpProvider.d.ts

@@ -0,0 +1,8 @@
+import * as core from '@spyglassmc/core';
+import * as mcf from '@spyglassmc/mcfunction';
+/**
+ * Only command options that can be satisfied by the current command node will be listed in `signatures`.
+ * Only parameters at and immediately after the `offset` will be listed in `parameters`.
+ */
+export declare function signatureHelpProvider(commandTreeName: string): core.SignatureHelpProvider<core.FileNode<mcf.McfunctionNode>>;
+//# sourceMappingURL=signatureHelpProvider.d.ts.map

package/lib/mcfunction/signatureHelpProvider.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signatureHelpProvider = void 0;
+const core = __importStar(require("@spyglassmc/core"));
+const mcf = __importStar(require("@spyglassmc/mcfunction"));
+/**
+ * Only command options that can be satisfied by the current command node will be listed in `signatures`.
+ * Only parameters at and immediately after the `offset` will be listed in `parameters`.
+ */
+function signatureHelpProvider(commandTreeName) {
+    const rootTreeNode = mcf.CommandTreeRegistry.instance.get(commandTreeName);
+    return (fileNode, ctx) => {
+        if (fileNode.children[0]?.type !== 'mcfunction:entry') {
+            // Not mcfunction.
+            return undefined;
+        }
+        const node = getSelectedCommandNode(fileNode, ctx.offset);
+        const argumentNodes = node ? node.children : [];
+        const options = getOptions(rootTreeNode, argumentNodes);
+        if (options.length === 0) {
+            // Not matching any syntax at all.
+            return undefined;
+        }
+        let selectedIndex = 0;
+        for (const child of argumentNodes) {
+            if (ctx.offset > child.range.end) {
+                selectedIndex += 1;
+            }
+            else {
+                break;
+            }
+        }
+        if (selectedIndex >= options[0].length) {
+            // No matching syntax for the selected argument node.
+            return undefined;
+        }
+        const ans = {
+            activeSignature: 0,
+            signatures: [],
+        };
+        ans.signatures = options.map(v => {
+            const part1 = v[selectedIndex];
+            const part2 = selectedIndex + 1 < v.length ? ` ${v[selectedIndex + 1]}` : '';
+            const label = `${part1}${part2}`;
+            return {
+                label,
+                activeParameter: 0,
+                // documentation: localize('mcfunction.signature-help.command-documentation', v[0]),
+                parameters: [
+                    { label: [0, part1.length] },
+                    { label: [part1.length, label.length] },
+                ],
+            };
+        });
+        return ans;
+    };
+}
+exports.signatureHelpProvider = signatureHelpProvider;
+function getSelectedCommandNode(fileNode, offset) {
+    return core.AstNode.findChild(fileNode.children[0], offset, true);
+}
+function getOptions(rootTreeNode, argumentNodes) {
+    const current = [];
+    let treeNode = rootTreeNode;
+    for (const argumentNode of argumentNodes) {
+        const name = argumentNode.path[argumentNode.path.length - 1];
+        if (!name) {
+            break;
+        }
+        treeNode = mcf.resolveParentTreeNode(treeNode, rootTreeNode).treeNode?.children?.[name];
+        if (!treeNode) {
+            break;
+        }
+        current.push(mcf.treeNodeToString(name, treeNode));
+    }
+    if (treeNode) {
+        treeNode = mcf.resolveParentTreeNode(treeNode, rootTreeNode).treeNode;
+        if (treeNode?.children) {
+            return mcf.treeNodeChildrenToStringArray(treeNode.children, treeNode.executable).map(v => [...current, v]);
+        }
+    }
+    return current.length ? [current] : [];
+}
+//# sourceMappingURL=signatureHelpProvider.js.map

package/lib/mcfunction/tree/1.15.d.ts

@@ -0,0 +1,9 @@
+import type { PartialRootTreeNode } from '@spyglassmc/mcfunction';
+/**
+ * Patch for Minecraft: Java Edition 1.15.2
+ *
+ * The following parsers are patched with new properties:
+ * - `minecraft:resource_location`
+ */
+export declare const Tree1_15: PartialRootTreeNode;
+//# sourceMappingURL=1.15.d.ts.map

package/lib/mcfunction/tree/1.15.js

@@ -0,0 +1,542 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tree1_15 = void 0;
+const AdvancementTargets = {
+    children: {
+        targets: {
+            children: {
+                from: {
+                    children: {
+                        advancement: {
+                            properties: {
+                                category: 'advancement',
+                            },
+                        },
+                    },
+                },
+                only: {
+                    children: {
+                        advancement: {
+                            properties: {
+                                category: 'advancement',
+                            },
+                        },
+                    },
+                },
+                through: {
+                    children: {
+                        advancement: {
+                            properties: {
+                                category: 'advancement',
+                            },
+                        },
+                    },
+                },
+                until: {
+                    children: {
+                        advancement: {
+                            properties: {
+                                category: 'advancement',
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+const DataSource = {
+    children: {
+        storage: {
+            children: {
+                source: {
+                    properties: {
+                        category: 'storage',
+                    },
+                },
+            },
+        },
+    },
+};
+const DataTarget = {
+    children: {
+        storage: {
+            children: {
+                target: {
+                    properties: {
+                        category: 'storage',
+                        accessType: 1 /* Write */,
+                    },
+                },
+            },
+        },
+    },
+};
+const DataModifySource = {
+    children: {
+        from: DataSource,
+    },
+};
+const DataModifyOperation = {
+    children: {
+        append: DataModifySource,
+        insert: {
+            children: {
+                index: DataModifySource,
+            },
+        },
+        merge: DataModifySource,
+        prepend: DataModifySource,
+        set: DataModifySource,
+    },
+};
+const ExecuteCondition = {
+    children: {
+        data: DataSource,
+        predicate: {
+            children: {
+                predicate: {
+                    properties: {
+                        category: 'predicate',
+                    },
+                },
+            },
+        },
+    },
+};
+const ExecuteStoreTarget = {
+    children: {
+        ...DataTarget.children,
+        bossbar: {
+            children: {
+                id: {
+                    properties: {
+                        category: 'bossbar',
+                        accessType: 1 /* Write */,
+                    },
+                },
+            },
+        },
+    },
+};
+const LootSource = {
+    children: {
+        fish: {
+            children: {
+                loot_table: {
+                    properties: {
+                        category: 'loot_table',
+                    },
+                },
+            },
+        },
+        loot: {
+            children: {
+                loot_table: {
+                    properties: {
+                        category: 'loot_table',
+                    },
+                },
+            },
+        },
+    },
+};
+const ObjectiveWriteTargets = {
+    children: {
+        targets: {
+            children: {
+                objective: {
+                    properties: {
+                        accessType: 1 /* Write */,
+                    },
+                },
+            },
+        },
+    },
+};
+const RecipeTargets = {
+    children: {
+        targets: {
+            children: {
+                recipe: {
+                    properties: {
+                        category: 'recipe',
+                    },
+                },
+            },
+        },
+    },
+};
+const Sound = {
+    children: {
+        sound: {
+            properties: {
+                category: 'sound_event',
+            },
+        },
+    },
+};
+/**
+ * Patch for Minecraft: Java Edition 1.15.2
+ *
+ * The following parsers are patched with new properties:
+ * - `minecraft:resource_location`
+ */
+exports.Tree1_15 = {
+    children: {
+        advancement: {
+            children: {
+                grant: AdvancementTargets,
+                revoke: AdvancementTargets,
+            },
+        },
+        ban: {
+            permission: 3,
+        },
+        'ban-ip': {
+            permission: 3,
+        },
+        banlist: {
+            permission: 3,
+        },
+        bossbar: {
+            children: {
+                add: {
+                    children: {
+                        id: {
+                            properties: {
+                                category: 'bossbar',
+                                usageType: 'definition',
+                            },
+                        },
+                    },
+                },
+                get: {
+                    children: {
+                        id: {
+                            properties: {
+                                category: 'bossbar',
+                            },
+                        },
+                    },
+                },
+                remove: {
+                    children: {
+                        id: {
+                            properties: {
+                                category: 'bossbar',
+                            },
+                        },
+                    },
+                },
+                set: {
+                    children: {
+                        id: {
+                            properties: {
+                                category: 'bossbar',
+                                accessType: 1 /* Write */,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        data: {
+            children: {
+                get: DataSource,
+                merge: DataTarget,
+                modify: {
+                    children: {
+                        block: {
+                            children: {
+                                targetPos: {
+                                    children: {
+                                        targetPath: DataModifyOperation,
+                                    },
+                                },
+                            },
+                        },
+                        entity: {
+                            children: {
+                                target: {
+                                    children: {
+                                        targetPath: DataModifyOperation,
+                                    },
+                                },
+                            },
+                        },
+                        storage: {
+                            children: {
+                                target: {
+                                    properties: {
+                                        category: 'storage',
+                                        accessType: 1 /* Write */,
+                                    },
+                                    children: {
+                                        targetPath: DataModifyOperation,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                remove: DataSource,
+            },
+        },
+        debug: {
+            permission: 3,
+        },
+        deop: {
+            permission: 3,
+        },
+        execute: {
+            children: {
+                if: ExecuteCondition,
+                store: {
+                    children: {
+                        result: ExecuteStoreTarget,
+                        success: ExecuteStoreTarget,
+                    },
+                },
+                unless: ExecuteCondition,
+            },
+        },
+        help: {
+            permission: 0,
+        },
+        kick: {
+            permission: 3,
+        },
+        list: {
+            permission: 0,
+        },
+        loot: {
+            children: {
+                give: {
+                    children: {
+                        players: LootSource,
+                    },
+                },
+                insert: {
+                    children: {
+                        targetPos: LootSource,
+                    },
+                },
+                replace: {
+                    children: {
+                        block: {
+                            children: {
+                                targetPos: {
+                                    children: {
+                                        slot: {
+                                            children: {
+                                                ...LootSource.children,
+                                                count: LootSource,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                        entity: {
+                            children: {
+                                entities: {
+                                    children: {
+                                        slot: {
+                                            children: {
+                                                ...LootSource.children,
+                                                count: LootSource,
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                spawn: {
+                    children: {
+                        targetPos: LootSource,
+                    },
+                },
+            },
+        },
+        me: {
+            permission: 0,
+        },
+        msg: {
+            permission: 0,
+        },
+        op: {
+            permission: 3,
+        },
+        pardon: {
+            permission: 3,
+        },
+        'pardon-ip': {
+            permission: 3,
+        },
+        playsound: Sound,
+        publish: {
+            permission: 4,
+        },
+        recipe: {
+            children: {
+                give: RecipeTargets,
+                take: RecipeTargets,
+            },
+        },
+        'save-all': {
+            permission: 4,
+        },
+        'save-off': {
+            permission: 4,
+        },
+        'save-on': {
+            permission: 4,
+        },
+        scoreboard: {
+            children: {
+                objectives: {
+                    children: {
+                        add: {
+                            children: {
+                                objective: {
+                                    parser: 'minecraft:objective',
+                                    properties: {
+                                        usageType: 'definition',
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+                players: {
+                    children: {
+                        add: ObjectiveWriteTargets,
+                        operation: ObjectiveWriteTargets,
+                        remove: ObjectiveWriteTargets,
+                        reset: ObjectiveWriteTargets,
+                        set: ObjectiveWriteTargets,
+                    },
+                },
+            },
+        },
+        setidletimeout: {
+            permission: 3,
+        },
+        stop: {
+            permission: 4,
+        },
+        stopsound: {
+            children: {
+                targets: {
+                    children: {
+                        '*': Sound,
+                        ambient: Sound,
+                        block: Sound,
+                        hostile: Sound,
+                        master: Sound,
+                        music: Sound,
+                        neutral: Sound,
+                        player: Sound,
+                        record: Sound,
+                        voice: Sound,
+                        weather: Sound,
+                    },
+                },
+            },
+        },
+        tag: {
+            children: {
+                targets: {
+                    children: {
+                        add: {
+                            children: {
+                                name: {
+                                    parser: 'spyglassmc:tag',
+                                },
+                            },
+                        },
+                        remove: {
+                            children: {
+                                name: {
+                                    parser: 'spyglassmc:tag',
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        team: {
+            children: {
+                add: {
+                    children: {
+                        team: {
+                            parser: 'minecraft:team',
+                            properties: {
+                                usageType: 'definition',
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        teammsg: {
+            permission: 0,
+        },
+        /**
+         * Original command syntax:
+         * 1. `teleport <destination: entity(single)>`
+         * 2. `teleport <location: vec3>`
+         * 3. `teleport <targets: entity(multiple)> <...arguments>`
+         *
+         * It is impossible for Spyglass to differentiate between (1) and (3) when it encouters a single entity
+         * at the position of the first argument, due to its lack of ability to backtrack.
+         *
+         * Therefore, we have compromised to patch the trees to something like this:
+         * - `teleport <location: vec3>`
+         * - `teleport <targets: entity(multiple)> [<...arguments>]`
+         *
+         * Diff:
+         * - Removed (1) `teleport <destination: entity(single)>`.
+         * - Marked `<...arguments>` in (3) as optional.
+         *
+         * The downside of this patch is that entity selectors tracking multiple entities can now be used as the
+         * `<destination>` argument. We will see how this work.
+         */
+        teleport: {
+            children: {
+                destination: undefined,
+                targets: {
+                    executable: true,
+                },
+            },
+        },
+        tell: {
+            permission: 0,
+        },
+        tm: {
+            permission: 0,
+        },
+        trigger: {
+            permission: 0,
+            children: {
+                objective: {
+                    properties: {
+                        category: 'objective',
+                        accessType: 1 /* Write */,
+                    },
+                },
+            },
+        },
+        w: {
+            permission: 0,
+        },
+        whitelist: {
+            permission: 3,
+        },
+    },
+};
+//# sourceMappingURL=1.15.js.map

package/lib/mcfunction/tree/1.16.d.ts

@@ -0,0 +1,10 @@
+import type { PartialRootTreeNode } from '@spyglassmc/mcfunction';
+/**
+ * Patch for Minecraft: Java Edition 1.16.5
+ *
+ * The following parsers are patched with new properties:
+ * - `minecraft:resource_location`
+ * - `minecraft:uuid`
+ */
+export declare const Tree1_16: PartialRootTreeNode;
+//# sourceMappingURL=1.16.d.ts.map