@spyglassmc/mcdoc 0.3.1 → 0.3.3

package/lib/colorizer/index.js

@@ -1,8 +1,8 @@
 import { ColorToken } from '@spyglassmc/core';
-export const identifier = node => {
+export const identifier = (node) => {
     return [ColorToken.create(node, 'variable')];
 };
-export const literal = node => {
+export const literal = (node) => {
     return [ColorToken.create(node, node.colorTokenType ?? 'literal')];
 };
 export function registerMcdocColorizer(meta) {

package/lib/common.d.ts

@@ -1,4 +1,4 @@
-export declare type Segments = readonly string[];
+export type Segments = readonly string[];
 export declare function identifierToSeg(identifier: string): Segments;
 export declare function segToIdentifier(seg: Segments): string;
 export interface AdditionalContext {

package/lib/node/index.d.ts

@@ -7,13 +7,13 @@ export interface ModuleNode extends AstNode {
 export declare const ModuleNode: Readonly<{
     is(node: AstNode | undefined): node is ModuleNode;
 }>;
-export declare type TopLevelNode = CommentNode | DispatchStatementNode | EnumNode | InjectionNode | StructNode | TypeAliasNode | UseStatementNode;
+export type TopLevelNode = CommentNode | DispatchStatementNode | EnumNode | InjectionNode | StructNode | TypeAliasNode | UseStatementNode;
 export declare const TopLevelNode: Readonly<{
     is(node: AstNode | undefined): node is TopLevelNode;
 }>;
 export interface DispatchStatementNode extends AstNode {
     type: 'mcdoc:dispatch_statement';
-    children: (CommentNode | AttributeNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeNode)[];
+    children: (CommentNode | AttributeNode | LiteralNode | ResourceLocationNode | IndexBodyNode | TypeParamBlockNode | TypeNode)[];
 }
 export declare const DispatchStatementNode: Readonly<{
     destruct(node: DispatchStatementNode): {
@@ -21,6 +21,7 @@ export declare const DispatchStatementNode: Readonly<{
         location?: ResourceLocationNode;
         index?: IndexBodyNode;
         target?: TypeNode;
+        typeParams?: TypeParamBlockNode;
     };
     is(node: AstNode | undefined): node is DispatchStatementNode;
 }>;
@@ -42,11 +43,11 @@ export declare const IndexBodyNode: Readonly<{
     };
     is(node: AstNode | undefined): node is IndexBodyNode;
 }>;
-export declare type IndexNode = StaticIndexNode | DynamicIndexNode;
+export type IndexNode = StaticIndexNode | DynamicIndexNode;
 export declare const IndexNode: Readonly<{
     is(node: AstNode | undefined): node is IndexNode;
 }>;
-export declare type StaticIndexNode = LiteralNode | IdentifierNode | StringNode | ResourceLocationNode;
+export type StaticIndexNode = LiteralNode | IdentifierNode | StringNode | ResourceLocationNode;
 export declare const StaticIndexNode: Readonly<{
     is(node: AstNode | undefined): node is StaticIndexNode;
 }>;
@@ -66,22 +67,22 @@ export declare const DynamicIndexNode: Readonly<{
     };
     is(node: AstNode | undefined): node is DynamicIndexNode;
 }>;
-export declare type AccessorKeyNode = LiteralNode | IdentifierNode | StringNode;
+export type AccessorKeyNode = LiteralNode | IdentifierNode | StringNode;
 export declare const AccessorKeyNode: Readonly<{
     is(node: AstNode | undefined): node is AccessorKeyNode;
 }>;
-export declare type TypeNode = AnyTypeNode | BooleanTypeNode | StringTypeNode | LiteralTypeNode | NumericTypeNode | PrimitiveArrayTypeNode | ListTypeNode | TupleTypeNode | EnumNode | StructNode | ReferenceTypeNode | DispatcherTypeNode | UnionTypeNode;
+export type TypeNode = AnyTypeNode | BooleanTypeNode | StringTypeNode | LiteralTypeNode | NumericTypeNode | PrimitiveArrayTypeNode | ListTypeNode | TupleTypeNode | EnumNode | StructNode | ReferenceTypeNode | DispatcherTypeNode | UnionTypeNode;
 export declare const TypeNode: Readonly<{
     is(node: AstNode | undefined): node is TypeNode;
 }>;
 export interface TypeBaseNode<CN extends AstNode> extends AstNode {
     type: `mcdoc:${string}`;
-    children: (CommentNode | AttributeNode | IndexBodyNode | CN)[];
+    children: (CommentNode | AttributeNode | IndexBodyNode | TypeArgBlockNode | CN)[];
 }
 export declare const TypeBaseNode: Readonly<{
     destruct(node: TypeBaseNode<any>): {
+        appendixes: (IndexBodyNode | TypeArgBlockNode)[];
         attributes: AttributeNode[];
-        indices: IndexBodyNode[];
     };
 }>;
 export interface AttributeNode extends AstNode {
@@ -95,7 +96,7 @@ export declare const AttributeNode: Readonly<{
     };
     is(node: AstNode | undefined): node is AttributeNode;
 }>;
-export declare type AttributeValueNode = TypeNode | AttributeTreeNode;
+export type AttributeValueNode = TypeNode | AttributeTreeNode;
 export declare const AttributeValueNode: Readonly<{
     is(node: AstNode | undefined): node is AttributeValueNode;
 }>;
@@ -135,6 +136,16 @@ export interface AttributeTreeNamedKeyValuePair {
     key: IdentifierNode | StringNode;
     value: AttributeValueNode;
 }
+export interface TypeArgBlockNode extends AstNode {
+    type: 'mcdoc:type_arg_block';
+    children: (CommentNode | TypeNode)[];
+}
+export declare const TypeArgBlockNode: Readonly<{
+    destruct(node: TypeArgBlockNode): {
+        args: TypeNode[];
+    };
+    is(node: AstNode | undefined): node is TypeArgBlockNode;
+}>;
 export interface AnyTypeNode extends TypeBaseNode<LiteralNode> {
     type: 'mcdoc:type/any';
 }
@@ -168,7 +179,7 @@ export declare const LiteralTypeNode: Readonly<{
     };
     is(node: AstNode | undefined): node is LiteralTypeNode;
 }>;
-export declare type LiteralTypeValueNode = LiteralNode | TypedNumberNode | StringNode;
+export type LiteralTypeValueNode = LiteralNode | TypedNumberNode | StringNode;
 export declare const LiteralTypeValueNode: Readonly<{
     is(node: AstNode | undefined): node is LiteralTypeValueNode;
 }>;
@@ -199,7 +210,7 @@ export declare const RangeExclusiveChar = "<";
  * The first bit from the left represents the start, the second bit from the left represents the end.
  * The bit is turned on if the range is exclusive on that end.
  */
-export declare type RangeKind = 0b00 | 0b01 | 0b10 | 0b11;
+export type RangeKind = 0b00 | 0b01 | 0b10 | 0b11;
 export declare function getRangeDelimiter(kind: RangeKind): string;
 export interface FloatRangeNode extends AstNode {
     type: 'mcdoc:float_range';
@@ -256,7 +267,7 @@ export interface EnumNode extends TypeBaseNode<DocCommentsNode | LiteralNode | I
     type: 'mcdoc:enum';
 }
 declare const EnumKinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
-export declare type EnumKind = typeof EnumKinds extends Set<infer V> ? V : never;
+export type EnumKind = typeof EnumKinds extends Set<infer V> ? V : never;
 export declare const EnumNode: Readonly<{
     kinds: Set<"string" | "float" | "byte" | "short" | "int" | "long" | "double">;
     destruct(node: EnumNode): {
@@ -301,11 +312,11 @@ export declare const EnumFieldNode: Readonly<{
     };
     is(node: AstNode | undefined): node is EnumFieldNode;
 }>;
-export declare type EnumValueNode = TypedNumberNode | StringNode;
+export type EnumValueNode = TypedNumberNode | StringNode;
 export declare const EnumValueNode: Readonly<{
     is(node: AstNode | undefined): node is EnumValueNode;
 }>;
-export declare type PrelimNode = AttributeNode | DocCommentsNode;
+export type PrelimNode = AttributeNode | DocCommentsNode;
 export declare const PrelimNode: Readonly<{
     is(node: AstNode | undefined): node is PrelimNode;
 }>;
@@ -321,13 +332,12 @@ export declare const StructNode: Readonly<{
     };
     is(node: AstNode | undefined): node is StructNode;
 }>;
-export interface ReferenceTypeNode extends TypeBaseNode<PathNode | TypeNode> {
+export interface ReferenceTypeNode extends TypeBaseNode<PathNode> {
     type: 'mcdoc:type/reference';
 }
 export declare const ReferenceTypeNode: Readonly<{
     destruct(node: ReferenceTypeNode): {
         path: PathNode;
-        typeParameters: TypeNode[];
     };
     is(node: AstNode | undefined): node is ReferenceTypeNode;
 }>;
@@ -374,7 +384,7 @@ export declare const StructBlockNode: Readonly<{
     };
     is(node: AstNode | undefined): node is StructBlockNode;
 }>;
-export declare type StructFieldNode = StructPairFieldNode | StructSpreadFieldNode;
+export type StructFieldNode = StructPairFieldNode | StructSpreadFieldNode;
 export declare const StructFieldNode: Readonly<{
     is(node: AstNode | undefined): node is StructFieldNode;
 }>;
@@ -392,7 +402,7 @@ export declare const StructPairFieldNode: Readonly<{
     };
     is(node: AstNode | undefined): node is StructPairFieldNode;
 }>;
-export declare type StructKeyNode = StringNode | IdentifierNode | StructMapKeyNode;
+export type StructKeyNode = StringNode | IdentifierNode | StructMapKeyNode;
 export declare const StructKeyNode: Readonly<{
     is(node: AstNode | undefined): node is StructKeyNode;
 }>;
@@ -446,7 +456,7 @@ export declare const InjectionNode: Readonly<{
     };
     is(node: AstNode | undefined): node is InjectionNode;
 }>;
-export declare type InjectionContentNode = EnumInjectionNode | StructInjectionNode;
+export type InjectionContentNode = EnumInjectionNode | StructInjectionNode;
 export declare const InjectionContentNode: Readonly<{
     is(node: AstNode | undefined): node is InjectionContentNode;
 }>;
@@ -466,12 +476,13 @@ export declare const StructInjectionNode: Readonly<{
 }>;
 export interface TypeAliasNode extends AstNode {
     type: 'mcdoc:type_alias';
-    children: (CommentNode | DocCommentsNode | LiteralNode | IdentifierNode | TypeParamBlockNode | TypeNode)[];
+    children: (CommentNode | PrelimNode | LiteralNode | IdentifierNode | TypeParamBlockNode | TypeNode)[];
 }
 export declare const TypeAliasNode: Readonly<{
     destruct(node: TypeAliasNode): {
+        attributes: AttributeNode[];
         docComments?: DocCommentsNode;
-        identifier?: IdentifierNode;
+        identifier: IdentifierNode;
         keyword: LiteralNode;
         typeParams?: TypeParamBlockNode;
         rhs?: TypeNode;

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
 export const ModuleNode = Object.freeze({
     is(node) {
         return node?.type === 'mcdoc:module';
@@ -22,10 +22,12 @@ export const DispatchStatementNode = Object.freeze({
             location: node.children.find(ResourceLocationNode.is),
             index: node.children.find(IndexBodyNode.is),
             target: node.children.find(TypeNode.is),
+            typeParams: node.children.find(TypeParamBlockNode.is),
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:dispatch_statement';
+        return (node?.type ===
+            'mcdoc:dispatch_statement');
     },
 });
 export const LiteralNode = Object.freeze({
@@ -50,7 +52,10 @@ export const IndexNode = Object.freeze({
 });
 export const StaticIndexNode = Object.freeze({
     is(node) {
-        return LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node) || ResourceLocationNode.is(node);
+        return (LiteralNode.is(node) ||
+            IdentifierNode.is(node) ||
+            StringNode.is(node) ||
+            ResourceLocationNode.is(node));
     },
 });
 export const IdentifierNode = Object.freeze({
@@ -65,12 +70,12 @@ export const DynamicIndexNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:dynamic_index';
+        return (node?.type === 'mcdoc:dynamic_index');
     },
 });
 export const AccessorKeyNode = Object.freeze({
     is(node) {
-        return LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node);
+        return (LiteralNode.is(node) || IdentifierNode.is(node) || StringNode.is(node));
     },
 });
 export const TypeNode = Object.freeze({
@@ -93,8 +98,8 @@ export const TypeNode = Object.freeze({
 export const TypeBaseNode = Object.freeze({
     destruct(node) {
         return {
+            appendixes: node.children.filter((n) => IndexBodyNode.is(n) || TypeArgBlockNode.is(n)),
             attributes: node.children.filter(AttributeNode.is),
-            indices: node.children.filter(IndexBodyNode.is),
         };
     },
 });
@@ -122,7 +127,8 @@ export const AttributeTreeNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:attribute/tree';
+        return (node?.type ===
+            'mcdoc:attribute/tree');
     },
 });
 export const AttributeTreePosValuesNode = Object.freeze({
@@ -132,7 +138,8 @@ export const AttributeTreePosValuesNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:attribute/tree/pos';
+        return (node?.type ===
+            'mcdoc:attribute/tree/pos');
     },
 });
 export const AttributeTreeNamedValuesNode = Object.freeze({
@@ -156,7 +163,18 @@ export const AttributeTreeNamedValuesNode = Object.freeze({
         return ans;
     },
     is(node) {
-        return node?.type === 'mcdoc:attribute/tree/named';
+        return (node?.type ===
+            'mcdoc:attribute/tree/named');
+    },
+});
+export const TypeArgBlockNode = Object.freeze({
+    destruct(node) {
+        return {
+            args: node.children.filter(TypeNode.is),
+        };
+    },
+    is(node) {
+        return (node?.type === 'mcdoc:type_arg_block');
     },
 });
 export const AnyTypeNode = Object.freeze({
@@ -166,7 +184,8 @@ export const AnyTypeNode = Object.freeze({
 });
 export const BooleanTypeNode = Object.freeze({
     is(node) {
-        return node?.type === 'mcdoc:type/boolean';
+        return node?.type ===
+            'mcdoc:type/boolean';
     },
 });
 export const IntRangeNode = Object.freeze({
@@ -184,12 +203,13 @@ export const LiteralTypeNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:type/literal';
+        return node?.type ===
+            'mcdoc:type/literal';
     },
 });
 export const LiteralTypeValueNode = Object.freeze({
     is(node) {
-        return LiteralNode.is(node) || TypedNumberNode.is(node) || StringNode.is(node);
+        return (LiteralNode.is(node) || TypedNumberNode.is(node) || StringNode.is(node));
     },
 });
 export const TypedNumberNode = Object.freeze({
@@ -200,18 +220,21 @@ export const TypedNumberNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:typed_number';
+        return node?.type ===
+            'mcdoc:typed_number';
     },
 });
 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),
+            valueRange: node.children.find(FloatRangeNode.is) ||
+                node.children.find(IntRangeNode.is),
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:type/numeric_type';
+        return (node?.type ===
+            'mcdoc:type/numeric_type');
     },
 });
 export const RangeExclusiveChar = '<';
@@ -294,7 +317,8 @@ export const PrimitiveArrayTypeNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:type/primitive_array';
+        return (node?.type ===
+            'mcdoc:type/primitive_array');
     },
 });
 export const ListTypeNode = Object.freeze({
@@ -328,7 +352,15 @@ export const TupleTypeNode = Object.freeze({
         return node?.type === 'mcdoc:type/tuple';
     },
 });
-const EnumKinds = new Set(['byte', 'short', 'int', 'long', 'float', 'double', 'string']);
+const EnumKinds = new Set([
+    'byte',
+    'short',
+    'int',
+    'long',
+    'float',
+    'double',
+    'string',
+]);
 export const EnumNode = Object.freeze({
     kinds: EnumKinds,
     destruct(node) {
@@ -360,19 +392,20 @@ export const DocCommentsNode = Object.freeze({
         if (!node) {
             return undefined;
         }
-        let comments = node.children.map(doc => doc.comment);
+        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));
+        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';
+        return node?.type ===
+            'mcdoc:doc_comments';
     },
 });
 export const EnumBlockNode = Object.freeze({
@@ -424,11 +457,11 @@ 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';
+        return (node?.type ===
+            'mcdoc:type/reference');
     },
 });
 export const TypeParamBlockNode = Object.freeze({
@@ -438,7 +471,8 @@ export const TypeParamBlockNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:type_param_block';
+        return (node?.type ===
+            'mcdoc:type_param_block');
     },
 });
 export const TypeParamNode = Object.freeze({
@@ -472,7 +506,8 @@ export const StructBlockNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:struct/block';
+        return node?.type ===
+            'mcdoc:struct/block';
     },
 });
 export const StructFieldNode = Object.freeze({
@@ -490,12 +525,15 @@ export const StructPairFieldNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:struct/field/pair';
+        return (node?.type ===
+            'mcdoc:struct/field/pair');
     },
 });
 export const StructKeyNode = Object.freeze({
     is(node) {
-        return StringNode.is(node) || IdentifierNode.is(node) || StructMapKeyNode.is(node);
+        return (StringNode.is(node) ||
+            IdentifierNode.is(node) ||
+            StructMapKeyNode.is(node));
     },
 });
 export const StructMapKeyNode = Object.freeze({
@@ -505,7 +543,7 @@ export const StructMapKeyNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:struct/map_key';
+        return (node?.type === 'mcdoc:struct/map_key');
     },
 });
 export const StructSpreadFieldNode = Object.freeze({
@@ -516,7 +554,8 @@ export const StructSpreadFieldNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:struct/field/spread';
+        return (node?.type ===
+            'mcdoc:struct/field/spread');
     },
 });
 export const DispatcherTypeNode = Object.freeze({
@@ -527,7 +566,8 @@ export const DispatcherTypeNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:type/dispatcher';
+        return (node?.type ===
+            'mcdoc:type/dispatcher');
     },
 });
 export const UnionTypeNode = Object.freeze({
@@ -557,17 +597,20 @@ export const InjectionContentNode = Object.freeze({
 });
 export const EnumInjectionNode = Object.freeze({
     is(node) {
-        return node?.type === 'mcdoc:injection/enum';
+        return (node?.type ===
+            'mcdoc:injection/enum');
     },
 });
 export const StructInjectionNode = Object.freeze({
     is(node) {
-        return node?.type === 'mcdoc:injection/struct';
+        return (node?.type ===
+            'mcdoc:injection/struct');
     },
 });
 export const TypeAliasNode = Object.freeze({
     destruct(node) {
         return {
+            attributes: node.children.filter(AttributeNode.is),
             docComments: node.children.find(DocCommentsNode.is),
             identifier: node.children.find(IdentifierNode.is),
             keyword: node.children.find(LiteralNode.is),
@@ -587,7 +630,7 @@ export const UseStatementNode = Object.freeze({
         };
     },
     is(node) {
-        return node?.type === 'mcdoc:use_statement';
+        return (node?.type === 'mcdoc:use_statement');
     },
 });
 //# sourceMappingURL=index.js.map

package/lib/parser/index.d.ts

@@ -25,7 +25,7 @@ export declare const typedNumber: InfallibleParser<TypedNumberNode>;
 export declare const enum_: Parser<EnumNode>;
 export declare const struct: Parser<StructNode>;
 export declare const injection: Parser<InjectionNode>;
-export declare const typeAlias: Parser<TypeAliasNode>;
+export declare const typeAliasStatement: Parser<TypeAliasNode>;
 export declare const useStatement: Parser<UseStatementNode>;
 export declare const module_: Parser<ModuleNode>;
 export declare const anyType: Parser<AnyTypeNode>;