@spyglassmc/mcdoc 0.3.6 → 0.3.8

package/lib/binder/index.js

@@ -739,9 +739,11 @@ function convertLiteralValue(node, ctx) {
     else if (TypedNumberNode.is(node)) {
         const { suffix, value } = TypedNumberNode.destruct(node);
         return {
-            kind: 'number',
+            kind: convertLiteralNumberSuffix(suffix, ctx) ??
+                (value.type === 'integer'
+                    ? 'int'
+                    : 'double'),
             value: value.value,
-            suffix: convertLiteralNumberSuffix(suffix, ctx),
         };
     }
     else {
@@ -753,7 +755,20 @@ function convertLiteralValue(node, ctx) {
 }
 function convertLiteralNumberSuffix(node, ctx) {
     const suffix = node?.value;
-    return suffix?.toLowerCase();
+    switch (suffix?.toLowerCase()) {
+        case 'b':
+            return 'byte';
+        case 's':
+            return 'short';
+        case 'l':
+            return 'long';
+        case 'f':
+            return 'float';
+        case 'd':
+            return 'double';
+        default:
+            return undefined;
+    }
 }
 function convertNumericType(node, ctx) {
     const { numericKind, valueRange } = NumericTypeNode.destruct(node);

package/lib/node/index.d.ts

@@ -1,5 +1,5 @@
-import type { AstNode, ColorTokenType, IntegerNode, SymbolBaseNode } from '@spyglassmc/core';
-import { CommentNode, FloatNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
+import type { AstNode, ColorTokenType, SymbolBaseNode } from '@spyglassmc/core';
+import { CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode } from '@spyglassmc/core';
 export interface ModuleNode extends AstNode {
     type: 'mcdoc:module';
     children: TopLevelNode[];
@@ -185,11 +185,11 @@ export declare namespace LiteralTypeValueNode {
 }
 export interface TypedNumberNode extends AstNode {
     type: 'mcdoc:typed_number';
-    children: (FloatNode | LiteralNode)[];
+    children: (FloatNode | IntegerNode | LiteralNode)[];
 }
 export declare namespace TypedNumberNode {
     function destruct(node: TypedNumberNode): {
-        value: FloatNode;
+        value: FloatNode | IntegerNode;
         suffix?: LiteralNode;
     };
     function is(node: AstNode | undefined): node is TypedNumberNode;

package/lib/node/index.js

@@ -1,4 +1,4 @@
-import { atArray, CommentNode, FloatNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
+import { atArray, CommentNode, FloatNode, IntegerNode, ResourceLocationNode, StringNode, } from '@spyglassmc/core';
 export var ModuleNode;
 (function (ModuleNode) {
     function is(node) {
@@ -272,7 +272,8 @@ export var TypedNumberNode;
 (function (TypedNumberNode) {
     function destruct(node) {
         return {
-            value: node.children.find(FloatNode.is),
+            value: node.children.find(FloatNode.is) ??
+                node.children.find(IntegerNode.is),
             suffix: node.children.find(LiteralNode.is),
         };
     }

package/lib/parser/index.d.ts

@@ -21,6 +21,19 @@ export declare const docComment: Parser<CommentNode>;
 export declare const docComments: InfallibleParser<DocCommentsNode>;
 export declare const dispatchStatement: Parser<DispatchStatementNode>;
 export declare const float: InfallibleParser<FloatNode>;
+export declare const integer: InfallibleParser<IntegerNode>;
+export declare const LiteralIntSuffixes: readonly ["b", "s", "l"];
+export type LiteralIntSuffix = (typeof LiteralIntSuffixes)[number];
+export declare const LiteralIntCaseInsensitiveSuffixes: readonly ["b", "s", "l", "B", "S", "L"];
+export type LiteralIntCaseInsensitiveSuffix = (typeof LiteralIntCaseInsensitiveSuffixes)[number];
+export declare const LiteralFloatSuffixes: readonly ["f", "d"];
+export type LiteralFloatSuffix = (typeof LiteralFloatSuffixes)[number];
+export declare const LiteralFloatCaseInsensitiveSuffixes: readonly ["f", "d", "F", "D"];
+export type LiteralFloatCaseInsensitiveSuffix = (typeof LiteralFloatCaseInsensitiveSuffixes)[number];
+export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
+export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
+export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "b", "s", "l", "B", "S", "L", "f", "d", "F", "D"];
+export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
 export declare const typedNumber: InfallibleParser<TypedNumberNode>;
 export declare const enum_: Parser<EnumNode>;
 export declare const struct: Parser<StructNode>;
@@ -30,7 +43,6 @@ export declare const useStatement: Parser<UseStatementNode>;
 export declare const module_: Parser<ModuleNode>;
 export declare const anyType: Parser<AnyTypeNode>;
 export declare const booleanType: Parser<BooleanTypeNode>;
-export declare const integer: InfallibleParser<IntegerNode>;
 export declare const intRange: InfallibleParser<IntRangeNode>;
 export declare const stringType: Parser<StringTypeNode>;
 export declare const literalType: Parser<LiteralTypeNode>;

package/lib/parser/index.js

@@ -2,7 +2,7 @@ import * as core from '@spyglassmc/core';
 import { any, Arrayable, failOnEmpty, failOnError, Failure, map, optional, Range, repeat, ResourceLocation, select, sequence, setType, stopBefore, validate, } from '@spyglassmc/core';
 import { arrayToMessage, localeQuote, localize } from '@spyglassmc/locales';
 import { RangeExclusiveChar } from '../node/index.js';
-import { LiteralNumberCaseInsensitiveSuffixes, NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords, } from '../type/index.js';
+import { NumericTypeFloatKinds, NumericTypeIntKinds, PrimitiveArrayValueKinds, StaticIndexKeywords, } from '../type/index.js';
 /**
  * @returns A comment parser that accepts normal comments (`//`) and reports an error if it's a doc comment (`///`).
  *
@@ -354,11 +354,56 @@ const enumType = literal(['byte', 'short', 'int', 'long', 'string', 'float', 'do
 export const float = core.float({
     pattern: /^[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)?|[0-9]*\.[0-9]+(?:[eE][-+]?[0-9]+)?)$/,
 });
-export const typedNumber = setType('mcdoc:typed_number', sequence([
-    float,
-    optional(keyword(LiteralNumberCaseInsensitiveSuffixes, {
-        colorTokenType: 'keyword',
-    })),
+export const integer = core.integer({
+    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
+});
+export const LiteralIntSuffixes = Object.freeze([
+    'b',
+    's',
+    'l',
+]);
+export const LiteralIntCaseInsensitiveSuffixes = Object.freeze([
+    ...LiteralIntSuffixes,
+    'B',
+    'S',
+    'L',
+]);
+export const LiteralFloatSuffixes = Object.freeze([
+    'f',
+    'd',
+]);
+export const LiteralFloatCaseInsensitiveSuffixes = Object.freeze([
+    ...LiteralFloatSuffixes,
+    'F',
+    'D',
+]);
+export const LiteralNumberSuffixes = Object.freeze([
+    ...LiteralIntSuffixes,
+    ...LiteralFloatSuffixes,
+]);
+export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
+    ...LiteralNumberSuffixes,
+    ...LiteralIntCaseInsensitiveSuffixes,
+    ...LiteralFloatCaseInsensitiveSuffixes,
+]);
+export const typedNumber = setType('mcdoc:typed_number', select([
+    {
+        regex: /^(?:\+|-)?\d+(?!\d|[.dfe])/i,
+        parser: sequence([
+            integer,
+            optional(keyword(LiteralIntCaseInsensitiveSuffixes, {
+                colorTokenType: 'keyword',
+            })),
+        ]),
+    },
+    {
+        parser: sequence([
+            float,
+            optional(keyword(LiteralFloatCaseInsensitiveSuffixes, {
+                colorTokenType: 'keyword',
+            })),
+        ]),
+    },
 ]));
 const enumValue = select([
     { prefix: '"', parser: string },
@@ -500,9 +545,6 @@ function typeBase(type, parser) {
 }
 export const anyType = typeBase('mcdoc:type/any', keyword('any', { colorTokenType: 'type' }));
 export const booleanType = typeBase('mcdoc:type/boolean', keyword('boolean', { colorTokenType: 'type' }));
-export const integer = core.integer({
-    pattern: /^(?:0|[-+]?[1-9][0-9]*)$/,
-});
 function range(type, number) {
     const delimiterPredicate = (src) => src.tryPeek('..') || src.tryPeek(`${RangeExclusiveChar}..`);
     const delimiterParser = literal([

package/lib/type/index.d.ts

@@ -16,7 +16,7 @@ export type NumericRange = {
     min?: number;
     max?: number;
 };
-export declare const StaticIndexKeywords: readonly ["fallback", "none", "unknown", "spawnitem"];
+export declare const StaticIndexKeywords: readonly ["fallback", "none", "unknown", "spawnitem", "blockitem"];
 export type StaticIndexKeyword = (typeof StaticIndexKeywords)[number];
 export interface StaticIndex {
     kind: 'static';
@@ -106,25 +106,23 @@ export interface StringType {
     kind: 'string';
     lengthRange?: NumericRange;
 }
-export type LiteralValue = {
+export type LiteralValue = LiteralBooleanValue | LiteralStringValue | LiteralNumericValue;
+export interface LiteralBooleanValue {
     kind: 'boolean';
     value: boolean;
-} | {
+}
+export interface LiteralStringValue {
     kind: 'string';
     value: string;
-} | {
-    kind: 'number';
+}
+export interface LiteralNumericValue {
+    kind: NumericTypeKind;
     value: number;
-    suffix: 'b' | 's' | 'l' | 'f' | 'd' | undefined;
-};
+}
 export interface LiteralType {
     kind: 'literal';
     value: LiteralValue;
 }
-export declare const LiteralNumberSuffixes: readonly ["b", "s", "l", "f", "d"];
-export type LiteralNumberSuffix = (typeof LiteralNumberSuffixes)[number];
-export declare const LiteralNumberCaseInsensitiveSuffixes: readonly ["b", "s", "l", "f", "d", "B", "S", "L", "F", "D"];
-export type LiteralNumberCaseInsensitiveSuffix = (typeof LiteralNumberCaseInsensitiveSuffixes)[number];
 export interface NumericType {
     kind: NumericTypeKind;
     valueRange?: NumericRange;

package/lib/type/index.js

@@ -6,6 +6,7 @@ export const StaticIndexKeywords = Object.freeze([
     'none',
     'unknown',
     'spawnitem',
+    'blockitem',
 ]);
 export const EmptyUnion = Object.freeze({
     kind: 'union',
@@ -17,21 +18,6 @@ export function createEmptyUnion(attributes) {
         // attributes,
     };
 }
-export const LiteralNumberSuffixes = Object.freeze([
-    'b',
-    's',
-    'l',
-    'f',
-    'd',
-]);
-export const LiteralNumberCaseInsensitiveSuffixes = Object.freeze([
-    ...LiteralNumberSuffixes,
-    'B',
-    'S',
-    'L',
-    'F',
-    'D',
-]);
 export const NumericTypeIntKinds = Object.freeze([
     'byte',
     'short',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/mcdoc",
-  "version": "0.3.6",
+  "version": "0.3.8",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",