@spyglassmc/mcdoc 0.1.1 → 0.3.1

package/lib/node/index.js

@@ -1,275 +1,591 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseStatementNode = exports.TypeAliasNode = exports.StructInjectionNode = exports.EnumInjectionNode = exports.InjectionNode = exports.UnionTypeNode = exports.DispatcherTypeNode = exports.StructSpreadFieldNode = exports.StructMapKeyNode = exports.StructKeyNode = exports.StructPairFieldNode = exports.StructFieldNode = exports.StructBlockNode = exports.PathNode = exports.TypeParamNode = exports.TypeParamBlockNode = exports.StructNode = exports.PrelimNode = exports.EnumValueNode = exports.EnumFieldNode = exports.EnumBlockNode = exports.DocCommentsNode = exports.EnumNode = exports.TupleTypeNode = exports.ListTypeNode = exports.PrimitiveArrayTypeNode = exports.FloatRangeNode = exports.NumericTypeNode = exports.TypedNumberNode = exports.LiteralTypeNode = exports.IntRangeNode = exports.StringTypeNode = exports.BooleanTypeNode = exports.AnyTypeNode = exports.AttributeTreeNamedValuesNode = exports.AttributeTreePosValuesNode = exports.AttributeTreeNode = exports.AttributeValueNode = exports.AttributeNode = exports.TypeNode = exports.AccessorKeyNode = exports.DynamicIndexNode = exports.IdentifierNode = exports.StaticIndexNode = exports.IndexNode = exports.IndexBodyNode = exports.LiteralNode = exports.DispatchStatementNode = exports.TopLevelNode = exports.ModuleNode = void 0;
-const core_1 = require("@spyglassmc/core");
-exports.ModuleNode = Object.freeze({
+import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+export const ModuleNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:module';
     },
 });
-exports.TopLevelNode = Object.freeze({
+export const TopLevelNode = Object.freeze({
     is(node) {
-        return (core_1.CommentNode.is(node) ||
-            exports.DispatchStatementNode.is(node) ||
-            exports.EnumNode.is(node) ||
-            exports.InjectionNode.is(node) ||
-            exports.StructNode.is(node) ||
-            exports.TypeAliasNode.is(node) ||
-            exports.UseStatementNode.is(node));
+        return (CommentNode.is(node) ||
+            DispatchStatementNode.is(node) ||
+            EnumNode.is(node) ||
+            InjectionNode.is(node) ||
+            StructNode.is(node) ||
+            TypeAliasNode.is(node) ||
+            UseStatementNode.is(node));
     },
 });
-exports.DispatchStatementNode = Object.freeze({
+export const DispatchStatementNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            location: node.children.find(ResourceLocationNode.is),
+            index: node.children.find(IndexBodyNode.is),
+            target: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:dispatch_statement';
     },
 });
-exports.LiteralNode = Object.freeze({
+export const LiteralNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:literal';
     },
 });
-exports.IndexBodyNode = Object.freeze({
+export const IndexBodyNode = Object.freeze({
+    destruct(node) {
+        return {
+            parallelIndices: node.children.filter(IndexNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:index_body';
     },
 });
-exports.IndexNode = Object.freeze({
+export const IndexNode = Object.freeze({
     is(node) {
-        return exports.StaticIndexNode.is(node) || exports.DynamicIndexNode.is(node);
+        return StaticIndexNode.is(node) || DynamicIndexNode.is(node);
     },
 });
-exports.StaticIndexNode = Object.freeze({
+export const StaticIndexNode = Object.freeze({
     is(node) {
-        return exports.LiteralNode.is(node) || exports.IdentifierNode.is(node) || core_1.StringNode.is(node) || core_1.ResourceLocationNode.is(node);
+        return LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node) || ResourceLocationNode.is(node);
     },
 });
-exports.IdentifierNode = Object.freeze({
+export const IdentifierNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:identifier';
     },
 });
-exports.DynamicIndexNode = Object.freeze({
+export const DynamicIndexNode = Object.freeze({
+    destruct(node) {
+        return {
+            keys: node.children.filter(AccessorKeyNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:dynamic_index';
     },
 });
-exports.AccessorKeyNode = Object.freeze({
+export const AccessorKeyNode = Object.freeze({
     is(node) {
-        return exports.LiteralNode.is(node) || exports.IdentifierNode.is(node) || core_1.StringNode.is(node);
+        return LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node);
     },
 });
-exports.TypeNode = Object.freeze({
+export const TypeNode = Object.freeze({
     is(node) {
-        return (exports.AnyTypeNode.is(node) ||
-            exports.BooleanTypeNode.is(node) ||
-            exports.StringTypeNode.is(node) ||
-            exports.LiteralTypeNode.is(node) ||
-            exports.NumericTypeNode.is(node) ||
-            exports.PrimitiveArrayTypeNode.is(node) ||
-            exports.ListTypeNode.is(node) ||
-            exports.TupleTypeNode.is(node) ||
-            exports.EnumNode.is(node) ||
-            exports.StructNode.is(node) ||
-            exports.PathNode.is(node) ||
-            exports.DispatcherTypeNode.is(node) ||
-            exports.UnionTypeNode.is(node));
+        return (AnyTypeNode.is(node) ||
+            BooleanTypeNode.is(node) ||
+            StringTypeNode.is(node) ||
+            LiteralTypeNode.is(node) ||
+            NumericTypeNode.is(node) ||
+            PrimitiveArrayTypeNode.is(node) ||
+            ListTypeNode.is(node) ||
+            TupleTypeNode.is(node) ||
+            EnumNode.is(node) ||
+            StructNode.is(node) ||
+            ReferenceTypeNode.is(node) ||
+            DispatcherTypeNode.is(node) ||
+            UnionTypeNode.is(node));
     },
-    asType(node) {
-        throw '// TODO';
+});
+export const TypeBaseNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            indices: node.children.filter(IndexBodyNode.is),
+        };
     },
 });
-exports.AttributeNode = Object.freeze({
+export const AttributeNode = Object.freeze({
+    destruct(node) {
+        return {
+            name: node.children.find(IdentifierNode.is),
+            value: node.children.find(AttributeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute';
     },
 });
-exports.AttributeValueNode = Object.freeze({
+export const AttributeValueNode = Object.freeze({
     is(node) {
-        return exports.TypeNode.is(node) || exports.AttributeTreeNode.is(node);
+        return TypeNode.is(node) || AttributeTreeNode.is(node);
     },
 });
-exports.AttributeTreeNode = Object.freeze({
+export const AttributeTreeNode = Object.freeze({
+    destruct(node) {
+        return {
+            positional: node.children.find(AttributeTreePosValuesNode.is),
+            named: node.children.find(AttributeTreeNamedValuesNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree';
     },
 });
-exports.AttributeTreePosValuesNode = Object.freeze({
+export const AttributeTreePosValuesNode = Object.freeze({
+    destruct(node) {
+        return {
+            values: node.children.filter(AttributeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree/pos';
     },
 });
-exports.AttributeTreeNamedValuesNode = Object.freeze({
+export const AttributeTreeNamedValuesNode = Object.freeze({
+    destruct(node) {
+        const ans = {
+            values: [],
+        };
+        let key;
+        for (const child of node.children) {
+            if (CommentNode.is(child)) {
+                continue;
+            }
+            if (IdentifierNode.is(child) || StringNode.is(child)) {
+                key = child;
+            }
+            else if (key) {
+                ans.values.push({ key, value: child });
+                key = undefined;
+            }
+        }
+        return ans;
+    },
     is(node) {
         return node?.type === 'mcdoc:attribute/tree/named';
     },
 });
-exports.AnyTypeNode = Object.freeze({
+export const AnyTypeNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:type/any';
     },
 });
-exports.BooleanTypeNode = Object.freeze({
+export const BooleanTypeNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:type/boolean';
     },
 });
-exports.StringTypeNode = Object.freeze({
-    is(node) {
-        return node?.type === 'mcdoc:type/string';
+export const IntRangeNode = Object.freeze({
+    destruct(node) {
+        return destructRangeNode(node);
     },
-});
-exports.IntRangeNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:int_range';
     },
 });
-exports.LiteralTypeNode = Object.freeze({
+export const LiteralTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            value: node.children.find(LiteralTypeValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/literal';
     },
 });
-exports.TypedNumberNode = Object.freeze({
+export const LiteralTypeValueNode = Object.freeze({
+    is(node) {
+        return LiteralNode.is(node) || TypedNumberNode.is(node) || StringNode.is(node);
+    },
+});
+export const TypedNumberNode = Object.freeze({
+    destruct(node) {
+        return {
+            value: node.children.find(FloatNode.is),
+            suffix: node.children.find(LiteralNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:typed_number';
     },
 });
-exports.NumericTypeNode = Object.freeze({
+export const NumericTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            numericKind: node.children.find(LiteralNode.is),
+            valueRange: node.children.find(FloatRangeNode.is) || node.children.find(IntRangeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/numeric_type';
     },
 });
-exports.FloatRangeNode = Object.freeze({
+export const RangeExclusiveChar = '<';
+export function getRangeDelimiter(kind) {
+    const prefix = kind & 0b10 ? RangeExclusiveChar : '';
+    const suffix = kind & 0b01 ? RangeExclusiveChar : '';
+    return `${prefix}..${suffix}`;
+}
+function destructRangeNode(node) {
+    let kind;
+    let min;
+    let max;
+    if (node.children.length === 1) {
+        // a
+        kind = 0b00;
+        min = max = node.children[0];
+    }
+    else if (node.children.length === 3) {
+        // a..b
+        kind = getKind(node.children[1]);
+        min = node.children[0];
+        max = node.children[2];
+    }
+    else if (LiteralNode.is(node.children[0])) {
+        // ..b
+        kind = getKind(node.children[0]);
+        max = node.children[1];
+    }
+    else {
+        // a..
+        kind = getKind(node.children[1]);
+        min = node.children[0];
+    }
+    return {
+        kind,
+        min,
+        max,
+    };
+    function getKind(delimiter) {
+        let ans = 0b00;
+        if (delimiter.value.startsWith(RangeExclusiveChar)) {
+            ans |= 0b10;
+        }
+        if (delimiter.value.endsWith(RangeExclusiveChar)) {
+            ans |= 0b01;
+        }
+        return ans;
+    }
+}
+export const FloatRangeNode = Object.freeze({
+    destruct(node) {
+        return destructRangeNode(node);
+    },
     is(node) {
         return node?.type === 'mcdoc:float_range';
     },
 });
-exports.PrimitiveArrayTypeNode = Object.freeze({
+export const PrimitiveArrayTypeNode = Object.freeze({
+    destruct(node) {
+        let lengthRange;
+        let valueRange;
+        let afterBrackets = false;
+        for (const child of node.children) {
+            if (LiteralNode.is(child) && child.value === '[]') {
+                afterBrackets = true;
+            }
+            else if (IntRangeNode.is(child)) {
+                if (afterBrackets) {
+                    lengthRange = child;
+                }
+                else {
+                    valueRange = child;
+                }
+            }
+        }
+        return {
+            arrayKind: node.children.find(LiteralNode.is),
+            lengthRange,
+            valueRange,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/primitive_array';
     },
 });
-exports.ListTypeNode = Object.freeze({
+export const ListTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            item: node.children.find(TypeNode.is),
+            lengthRange: node.children.find(IntRangeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/list';
     },
 });
-exports.TupleTypeNode = Object.freeze({
+export const StringTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            lengthRange: node.children.find(IntRangeNode.is),
+        };
+    },
+    is(node) {
+        return node?.type === 'mcdoc:type/string';
+    },
+});
+export const TupleTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            items: node.children.filter(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/tuple';
     },
 });
-exports.EnumNode = Object.freeze({
+const EnumKinds = new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']);
+export const EnumNode = Object.freeze({
+    kinds: EnumKinds,
+    destruct(node) {
+        return {
+            block: node.children.find(EnumBlockNode.is),
+            docComments: node.children.find(DocCommentsNode.is),
+            enumKind: getEnumKind(node),
+            identifier: node.children.find(IdentifierNode.is),
+            keyword: node.children.find(LiteralNode.is),
+        };
+        function getEnumKind(node) {
+            for (const literal of node.children.filter(LiteralNode.is)) {
+                if (EnumKinds.has(literal.value)) {
+                    return literal.value;
+                }
+            }
+            return undefined;
+        }
+    },
     is(node) {
         return node?.type === 'mcdoc:enum';
     },
-    kinds: new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']),
 });
-exports.DocCommentsNode = Object.freeze({
+export const DocCommentsNode = Object.freeze({
+    /**
+     * @returns The text content of this doc comment block.
+     */
+    asText(node) {
+        if (!node) {
+            return undefined;
+        }
+        let comments = node.children.map(doc => doc.comment);
+        // If every comment contains a leading space or is empty, stripe the leading spaces off.
+        // e.g. /// This is an example doc comment.
+        //      ///
+        //      /// Another line.
+        // should be converted to "This is an example doc comment.\n\nAnother line."
+        if (comments.every(s => s.length === 0 || s.startsWith(' '))) {
+            comments = comments.map(s => s.slice(1));
+        }
+        return comments.join('\n');
+    },
     is(node) {
         return node?.type === 'mcdoc:doc_comments';
     },
 });
-exports.EnumBlockNode = Object.freeze({
+export const EnumBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            fields: node.children.filter(EnumFieldNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:enum/block';
     },
 });
-exports.EnumFieldNode = Object.freeze({
+export const EnumFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+            value: node.children.find(EnumValueNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:enum/field';
     },
 });
-exports.EnumValueNode = Object.freeze({
+export const EnumValueNode = Object.freeze({
     is(node) {
-        return exports.TypedNumberNode.is(node) || core_1.StringNode.is(node);
+        return TypedNumberNode.is(node) || StringNode.is(node);
     },
 });
-exports.PrelimNode = Object.freeze({
+export const PrelimNode = Object.freeze({
     is(node) {
-        return exports.AttributeNode.is(node) || exports.DocCommentsNode.is(node);
+        return AttributeNode.is(node) || DocCommentsNode.is(node);
     },
 });
-exports.StructNode = Object.freeze({
+export const StructNode = Object.freeze({
+    destruct(node) {
+        return {
+            block: node.children.find(StructBlockNode.is),
+            docComments: node.children.find(DocCommentsNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+            keyword: node.children.find(LiteralNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct';
     },
 });
-exports.TypeParamBlockNode = Object.freeze({
+export const ReferenceTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            path: node.children.find(PathNode.is),
+            typeParameters: node.children.filter(TypeNode.is),
+        };
+    },
+    is(node) {
+        return node?.type === 'mcdoc:type/reference';
+    },
+});
+export const TypeParamBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            params: node.children.filter(TypeParamNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_param_block';
     },
 });
-exports.TypeParamNode = Object.freeze({
+export const TypeParamNode = Object.freeze({
+    destruct(node) {
+        return {
+            // constraint: node.children.find(TypeNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_param';
     },
 });
-exports.PathNode = Object.freeze({
+export const PathNode = Object.freeze({
+    destruct(node) {
+        const lastChild = atArray(node?.children, -1);
+        return {
+            children: node?.children ?? [],
+            isAbsolute: node?.isAbsolute,
+            lastIdentifier: IdentifierNode.is(lastChild) ? lastChild : undefined,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:path';
     },
 });
-exports.StructBlockNode = Object.freeze({
+export const StructBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            fields: node.children.filter(StructFieldNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/block';
     },
 });
-exports.StructFieldNode = Object.freeze({
+export const StructFieldNode = Object.freeze({
     is(node) {
-        return exports.StructPairFieldNode.is(node) || exports.StructSpreadFieldNode.is(node);
+        return StructPairFieldNode.is(node) || StructSpreadFieldNode.is(node);
     },
 });
-exports.StructPairFieldNode = Object.freeze({
+export const StructPairFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            key: node.children.find(StructKeyNode.is),
+            type: node.children.find(TypeNode.is),
+            isOptional: node.isOptional,
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/field/pair';
     },
 });
-exports.StructKeyNode = Object.freeze({
+export const StructKeyNode = Object.freeze({
     is(node) {
-        return core_1.StringNode.is(node) || exports.IdentifierNode.is(node) || exports.StructMapKeyNode.is(node);
+        return StringNode.is(node) || IdentifierNode.is(node) || StructMapKeyNode.is(node);
     },
 });
-exports.StructMapKeyNode = Object.freeze({
+export const StructMapKeyNode = Object.freeze({
+    destruct(node) {
+        return {
+            type: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/map_key';
     },
 });
-exports.StructSpreadFieldNode = Object.freeze({
+export const StructSpreadFieldNode = Object.freeze({
+    destruct(node) {
+        return {
+            attributes: node.children.filter(AttributeNode.is),
+            type: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:struct/field/spread';
     },
 });
-exports.DispatcherTypeNode = Object.freeze({
+export const DispatcherTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            location: node.children.find(ResourceLocationNode.is),
+            index: node.children.find(IndexBodyNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/dispatcher';
     },
 });
-exports.UnionTypeNode = Object.freeze({
+export const UnionTypeNode = Object.freeze({
+    destruct(node) {
+        return {
+            members: node.children.filter(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type/union';
     },
 });
-exports.InjectionNode = Object.freeze({
+export const InjectionNode = Object.freeze({
+    destruct(node) {
+        return {
+            injection: node.children.find(InjectionContentNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:injection';
     },
 });
-exports.EnumInjectionNode = Object.freeze({
+export const InjectionContentNode = Object.freeze({
+    is(node) {
+        return EnumInjectionNode.is(node) || StructInjectionNode.is(node);
+    },
+});
+export const EnumInjectionNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:injection/enum';
     },
 });
-exports.StructInjectionNode = Object.freeze({
+export const StructInjectionNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:injection/struct';
     },
 });
-exports.TypeAliasNode = Object.freeze({
+export const TypeAliasNode = Object.freeze({
+    destruct(node) {
+        return {
+            docComments: node.children.find(DocCommentsNode.is),
+            identifier: node.children.find(IdentifierNode.is),
+            keyword: node.children.find(LiteralNode.is),
+            typeParams: node.children.find(TypeParamBlockNode.is),
+            rhs: node.children.find(TypeNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:type_alias';
     },
 });
-exports.UseStatementNode = Object.freeze({
+export const UseStatementNode = Object.freeze({
+    destruct(node) {
+        return {
+            binding: node.children.find(IdentifierNode.is),
+            path: node.children.find(PathNode.is),
+        };
+    },
     is(node) {
         return node?.type === 'mcdoc:use_statement';
     },