@spyglassmc/nbt 0.3.51 → 0.3.53

package/lib/checker/index.js

@@ -1,7 +1,7 @@
 import * as core from '@spyglassmc/core';
 import { localeQuote, localize } from '@spyglassmc/locales';
 import * as mcdoc from '@spyglassmc/mcdoc';
-import { NbtCompoundNode, NbtNode, NbtPathFilterNode, NbtPathIndexNode, NbtPathKeyNode, NbtPrimitiveNode, NbtStringNode, } from '../node/index.js';
+import { NbtByteNode, NbtCollectionNode, NbtCompoundNode, NbtIntegerAlikeNode, NbtListNode, NbtNode, NbtNumberNode, NbtPathFilterNode, NbtPathIndexNode, NbtPathKeyNode, NbtPrimitiveNode, NbtStringNode, } from '../node/index.js';
 import { getBlocksFromItem, getEntityFromItem } from './mcdocUtil.js';
 export const typed = (node, ctx) => {
     typeDefinition(node.targetType)(node.children[0], ctx);
@@ -53,31 +53,42 @@ export function typeDefinition(typeDef, options = {}) {
         mcdoc.runtime.checker.typeDefinition([{ originalNode: node, inferredType: inferType(node) }], typeDef, mcdoc.runtime.checker.McdocCheckerContext.create(ctx, {
             allowMissingKeys: options.isPredicate || options.isMerge,
             requireCanonical: options.isPredicate,
-            isEquivalent: (inferred, def) => {
-                if (def.kind === 'boolean') {
-                    // TODO: this should check whether the value is 0 or 1
-                    return inferred.kind === 'byte';
-                }
-                if (inferred.kind === 'list') {
-                    return def.kind === 'list' || def.kind === 'tuple';
+            tryConvertTo: (node, target) => {
+                if (target.kind === 'boolean' && NbtByteNode.is(node)) {
+                    if (node.value === 0) {
+                        return { kind: 'literal', value: { kind: 'boolean', value: false } };
+                    }
+                    else if (node.value === 1) {
+                        return { kind: 'literal', value: { kind: 'boolean', value: true } };
+                    }
                 }
-                if (options.isPredicate) {
-                    return inferred.kind === def.kind;
+                if (target.kind === 'tuple' && NbtListNode.is(node)) {
+                    return {
+                        kind: 'tuple',
+                        items: [],
+                    };
                 }
-                switch (inferred.kind) {
-                    case 'struct':
-                        return def.kind === 'struct';
-                    case 'byte':
-                    case 'short':
-                    case 'int':
-                    case 'long':
-                        return ['byte', 'short', 'int', 'long', 'float', 'double'].includes(def.kind);
-                    case 'float':
-                    case 'double':
-                        return ['float', 'double'].includes(def.kind);
-                    default:
-                        return false;
+                if (!options.isPredicate) {
+                    if (NbtNumberNode.is(node)) {
+                        const literalValue = mcdoc.LiteralNumericValue.makeIfValid(target.kind, node.value, NbtIntegerAlikeNode.is(node), true);
+                        if (literalValue !== undefined) {
+                            return { kind: 'literal', value: literalValue };
+                        }
+                    }
+                    if (NbtCollectionNode.is(node)) {
+                        switch (target.kind) {
+                            case 'list':
+                                return { kind: 'list', item: { kind: 'any' } };
+                            case 'byte_array':
+                            case 'int_array':
+                            case 'long_array':
+                                return { kind: target.kind };
+                            case 'tuple':
+                                return { kind: 'tuple', items: [] };
+                        }
+                    }
                 }
+                return undefined;
             },
             getChildren: node => {
                 const { type } = node;
@@ -99,7 +110,7 @@ export function typeDefinition(typeDef, options = {}) {
                 if (options.isPredicate && error.kind === 'invalid_collection_length') {
                     return;
                 }
-                mcdoc.runtime.checker.getDefaultErrorReporter(ctx, (mcdoc.runtime.checker.getDefaultErrorRange))(error);
+                mcdoc.runtime.checker.getDefaultErrorReporter(ctx, mcdoc.runtime.checker.getDefaultErrorRange)(error);
             },
             attachTypeInfo: (node, definition, desc = '') => {
                 node.typeDef = definition;
@@ -151,11 +162,7 @@ function inferType(node) {
         case 'nbt:float':
             return { kind: 'literal', value: { kind: 'float', value: node.value } };
         case 'nbt:long':
-            return {
-                kind: 'literal',
-                // TODO: this should NOT change type from `bigint` to `number`
-                value: { kind: 'long', value: Number(node.value) },
-            };
+            return { kind: 'literal', value: { kind: 'long', value: node.value } };
         case 'nbt:int':
             return { kind: 'literal', value: { kind: 'int', value: node.value } };
         case 'nbt:short':
@@ -232,16 +239,20 @@ export function path(registry, id) {
         mcdoc.runtime.checker.typeDefinition([{ originalNode: link, inferredType: inferPath(link) }], typeDef, mcdoc.runtime.checker.McdocCheckerContext.create(ctx, {
             allowMissingKeys: true,
             requireCanonical: true,
-            isEquivalent: (inferred, def) => {
-                switch (inferred.kind) {
-                    case 'list':
-                    case 'byte_array':
-                    case 'int_array':
-                    case 'long_array':
-                        return ['list', 'tuple', 'byte_array', 'int_array', 'long_array'].includes(def.kind);
-                    default:
-                        return false;
+            tryConvertTo: (node, target) => {
+                if (NbtPathIndexNode.is(node.node)) {
+                    switch (target.kind) {
+                        case 'list':
+                            return { kind: 'list', item: { kind: 'any' } };
+                        case 'byte_array':
+                        case 'int_array':
+                        case 'long_array':
+                            return { kind: target.kind };
+                        case 'tuple':
+                            return { kind: 'tuple', items: [] };
+                    }
                 }
+                return undefined;
             },
             getChildren: (link) => {
                 while (link.next && link.node.type !== 'leaf' && NbtPathFilterNode.is(link.node)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spyglassmc/nbt",
-  "version": "0.3.51",
+  "version": "0.3.53",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -25,8 +25,8 @@
     "url": "https://github.com/SpyglassMC/Spyglass/issues"
   },
   "dependencies": {
-    "@spyglassmc/core": "0.4.45",
-    "@spyglassmc/locales": "0.3.23",
-    "@spyglassmc/mcdoc": "0.3.49"
+    "@spyglassmc/core": "0.4.47",
+    "@spyglassmc/locales": "0.3.24",
+    "@spyglassmc/mcdoc": "0.3.51"
   }
 }