mca-json 1.0.0

package/src/nbt/nbt-int-array.ts

@@ -0,0 +1,38 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:int-array:from-binary-data');
+
+export class NbtIntArray extends NbtBase<number[]> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtIntArray {
+        name ??= NbtIntArray.readName(bd);
+        const data: number[] = [];
+        const length = bd.getInt();
+        debugLogFromBinaryData(`INT_ARRAY, name ${name}, length ${length}`);
+
+        for (let i = 0; i < length; i++) {
+            data.push(bd.getInt());
+        }
+
+        debugLogFromBinaryData(`INT_ARRAY, name ${name}, data ${data}`);
+
+        return new NbtIntArray(data, name);
+    }
+
+    constructor(data: number[], name?: string) {
+        super(NbtTagType.INT_ARRAY, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            intArray: this.data,
+        };
+    }
+
+    toSnbt() {
+        return `[I;${this.data.join(', ')}]`;
+    }
+}

package/src/nbt/nbt-int.ts

@@ -0,0 +1,31 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:int:from-binary-data');
+
+export class NbtInt extends NbtBase<number> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtInt {
+        name ??= NbtInt.readName(bd);
+        const data = bd.getInt();
+        debugLogFromBinaryData(`INT, name ${name}, data ${data}`);
+
+        return new NbtInt(data, name);
+    }
+
+    constructor(data: number, name?: string) {
+        super(NbtTagType.INT, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            int: this.data,
+        };
+    }
+
+    toSnbt() {
+        return `${this.data}`;
+    }
+}

package/src/nbt/nbt-list.ts

@@ -0,0 +1,103 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { fromBinaryData } from './nbt';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:list:from-binary-data');
+const debugLogFindChild = debug('nbt:list:find-child');
+
+export class NbtList<T extends NbtBase<any>> extends NbtBase<T[]> {
+    static fromBinaryData<SOURCE extends NbtBase<any>>(
+        bd: BinaryData,
+        name?: string
+    ): NbtList<SOURCE> {
+        name ??= NbtList.readName(bd);
+        const subtype = bd.getByte();
+        const length = bd.getInt();
+        const data: SOURCE[] = [];
+        debugLogFromBinaryData(
+            `LIST, name ${name}, subtype ${subtype}, length ${length}, start`
+        );
+        const reader = fromBinaryData[subtype];
+
+        if (!reader) {
+            throw new Error(`Invalid NBT tag type ${subtype} for list tag`);
+        }
+
+        while (data.length < length) {
+            // All list items are unnamed
+            data.push(reader(bd, '') as SOURCE);
+        }
+
+        debugLogFromBinaryData(
+            `LIST, name ${name}, subtype ${subtype}, element count ${data.length}, end`
+        );
+
+        return new NbtList<SOURCE>(data, subtype, name);
+    }
+
+    subtype: NbtTagType;
+
+    constructor(data: T[], subtype: NbtTagType, name?: string) {
+        super(NbtTagType.LIST, data, name);
+        this.subtype = subtype;
+    }
+
+    override findChild<RESULT extends NbtBase<any>>(
+        path: string
+    ): RESULT | undefined {
+        const pathSegments = path.split('/');
+        const currentSegment = pathSegments.shift();
+
+        if (!currentSegment) {
+            return;
+        }
+
+        const index = parseInt(currentSegment, 10);
+
+        if (isNaN(index)) {
+            debugLogFindChild(`LIST, name ${this.name}, subtype ${this.subtype}, path ${path}, segment ${currentSegment}, not a number`);
+
+            return;
+        }
+
+        const result = this.data[index];
+
+        if (!result) {
+            debugLogFindChild(`LIST, name ${this.name}, subtype ${this.subtype}, path ${path}, segment ${currentSegment}, no child found at index ${index}`);
+
+            return;
+        }
+
+        if (pathSegments.length) {
+            debugLogFindChild(`LIST, name ${this.name}, subtype ${this.subtype}, path ${path}, segment ${currentSegment}, recurse`);
+
+            return result.findChild<RESULT>(pathSegments.join('/'));
+        }
+
+        debugLogFindChild(`LIST, name ${this.name}, subtype ${this.subtype}, path ${path}, segment ${currentSegment}, found`);
+
+        return result as unknown as RESULT;
+    }
+
+    override isList(subtype?: NbtTagType) {
+        if (subtype !== undefined && this.subtype !== subtype) {
+            return false;
+        }
+
+        return true;
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            subtype: this.subtype,
+            list: this.data.map((v) => v.toObject()),
+        };
+    }
+
+    toSnbt() {
+        return this.data.map((v) => v.toSnbt()).join(',');
+    }
+}

package/src/nbt/nbt-long-array.ts

@@ -0,0 +1,40 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:long-array:from-binary-data');
+
+export class NbtLongArray extends NbtBase<bigint[]> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtLongArray {
+        name ??= NbtLongArray.readName(bd);
+        const data: bigint[] = [];
+        const length = bd.getInt();
+        debugLogFromBinaryData(`LONG_ARRAY, name ${name}, length ${length}`);
+
+        for (let i = 0; i < length; i++) {
+            // This needs to be able to be converted back to a bit stream in
+            // BitData. See BitData.fromLongArrayTag().
+            data.push(bd.getInt64LE());
+        }
+
+        debugLogFromBinaryData(`LONG_ARRAY, name ${name}, data ${data}`);
+
+        return new NbtLongArray(data, name);
+    }
+
+    constructor(data: bigint[], name?: string) {
+        super(NbtTagType.LONG_ARRAY, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            longArray: this.data.map((v) => v.toString()),
+        };
+    }
+
+    toSnbt() {
+        return `[L;${this.data.map((v) => v.toString()).join(', ')}]`;
+    }
+}

package/src/nbt/nbt-long.ts

@@ -0,0 +1,31 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:long:from-binary-data');
+
+export class NbtLong extends NbtBase<bigint> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtLong {
+        name ??= NbtLong.readName(bd);
+        const data = bd.getInt64LE();
+        debugLogFromBinaryData(`LONG, name ${name}, data ${data}`);
+
+        return new NbtLong(data, name);
+    }
+
+    constructor(data: bigint, name?: string) {
+        super(NbtTagType.LONG, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            long: this.data.toString(),
+        };
+    }
+
+    toSnbt() {
+        return `${this.data}l`;
+    }
+}

package/src/nbt/nbt-short.ts

@@ -0,0 +1,31 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:short:from-binary-data');
+
+export class NbtShort extends NbtBase<number> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtShort {
+        name ??= NbtShort.readName(bd);
+        const data = bd.getShort();
+        debugLogFromBinaryData(`SHORT, name ${name}, data ${data}`);
+
+        return new NbtShort(data, name);
+    }
+
+    constructor(data: number, name?: string) {
+        super(NbtTagType.SHORT, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            short: this.data,
+        };
+    }
+
+    toSnbt() {
+        return `${this.data}s`;
+    }
+}

package/src/nbt/nbt-string.ts

@@ -0,0 +1,35 @@
+import debug from 'debug';
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from './nbt-base';
+import { NbtTagType } from './nbt-tag-type';
+
+const debugLogFromBinaryData = debug('nbt:string:from-binary-data');
+
+export class NbtString extends NbtBase<string> {
+    static fromBinaryData(bd: BinaryData, name?: string): NbtString {
+        name ??= NbtString.readName(bd);
+        const length = bd.getUShort();
+        const data = bd.getString(length);
+        debugLogFromBinaryData(
+            `STRING, name ${name}, length ${length}, data ${data}`
+        );
+
+        return new NbtString(data, name);
+    }
+
+    constructor(data: string, name?: string) {
+        super(NbtTagType.STRING, data, name);
+    }
+
+    toObject() {
+        return {
+            type: this.type,
+            string: this.data,
+        };
+    }
+
+    toSnbt() {
+        // This always works but doesn't always produce the shortest string
+        return JSON.stringify(this.data);
+    }
+}

package/src/nbt/nbt-tag-type.ts

@@ -0,0 +1,15 @@
+export enum NbtTagType {
+    END = 0,
+    BYTE = 1,
+    SHORT = 2,
+    INT = 3,
+    LONG = 4,
+    FLOAT = 5,
+    DOUBLE = 6,
+    BYTE_ARRAY = 7,
+    STRING = 8,
+    LIST = 9,
+    COMPOUND = 10,
+    INT_ARRAY = 11,
+    LONG_ARRAY = 12,
+}

package/src/nbt/nbt.ts

@@ -0,0 +1,70 @@
+import { BinaryData } from '../lib/binary-data';
+import { NbtBase } from '../nbt/nbt-base';
+import { NbtByte } from '../nbt/nbt-byte';
+import { NbtByteArray } from '../nbt/nbt-byte-array';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { NbtDouble } from '../nbt/nbt-double';
+import { NbtEnd } from '../nbt/nbt-end';
+import { NbtFloat } from '../nbt/nbt-float';
+import { NbtInt } from '../nbt/nbt-int';
+import { NbtIntArray } from '../nbt/nbt-int-array';
+import { NbtList } from '../nbt/nbt-list';
+import { NbtLong } from '../nbt/nbt-long';
+import { NbtLongArray } from '../nbt/nbt-long-array';
+import { NbtShort } from '../nbt/nbt-short';
+import { NbtString } from '../nbt/nbt-string';
+import { NbtTagType } from '../nbt/nbt-tag-type';
+import { snbtParse } from './snbt-parse';
+import { snbtToNbt } from './snbt-to-nbt';
+
+export const fromBinaryData: {
+    [key: number]: (bd: BinaryData, name?: string) => NbtBase<any>;
+} = {
+    [NbtTagType.BYTE_ARRAY]: NbtByteArray.fromBinaryData,
+    [NbtTagType.BYTE]: NbtByte.fromBinaryData,
+    [NbtTagType.COMPOUND]: NbtCompound.fromBinaryData,
+    [NbtTagType.DOUBLE]: NbtDouble.fromBinaryData,
+    [NbtTagType.END]: NbtEnd.fromBinaryData,
+    [NbtTagType.FLOAT]: NbtFloat.fromBinaryData,
+    [NbtTagType.INT_ARRAY]: NbtIntArray.fromBinaryData,
+    [NbtTagType.INT]: NbtInt.fromBinaryData,
+    [NbtTagType.LIST]: NbtList.fromBinaryData,
+    [NbtTagType.LONG_ARRAY]: NbtLongArray.fromBinaryData,
+    [NbtTagType.LONG]: NbtLong.fromBinaryData,
+    [NbtTagType.SHORT]: NbtShort.fromBinaryData,
+    [NbtTagType.STRING]: NbtString.fromBinaryData,
+};
+
+export class Nbt {
+    static fromBuffer(data: ArrayBufferLike): NbtBase<any> {
+        const bd = new BinaryData(data);
+        bd.seek(0);
+
+        return Nbt.getTag(bd);
+    }
+
+    static fromSnbt(snbt: string): NbtBase<any> {
+        const snbtData = snbtParse(snbt);
+        const token = snbtToNbt(snbtData);
+
+        if (snbtData.remainingLength()) {
+            const nextToken = snbtData.token();
+            throw new Error(
+                `Extra, unparsed SNBT tokens leftover starting with ${nextToken.type}, "${nextToken.content}" at position ${snbtData.currentPosition()}`
+            );
+        }
+
+        return token;
+    }
+
+    static getTag(bd: BinaryData): NbtBase<any> {
+        const type = bd.getByte();
+        const reader = fromBinaryData[type];
+
+        if (!reader) {
+            throw new Error(`Invalid NBT tag ID ${type}`);
+        }
+
+        return reader(bd);
+    }
+}

package/src/nbt/snbt-data.ts

@@ -0,0 +1,70 @@
+export type SnbtTokenType =
+    | 'BYTE'
+    | 'BYTE_ARRAY_START'
+    | 'COLON'
+    | 'COMMA'
+    | 'COMPOUND_END'
+    | 'COMPOUND_START'
+    | 'DOUBLE'
+    | 'FLOAT'
+    | 'INT'
+    | 'INT_ARRAY_START'
+    | 'LIST_END'
+    | 'LIST_START'
+    | 'LONG'
+    | 'LONG_ARRAY_START'
+    | 'SHORT'
+    | 'STRING'
+    | 'WHITESPACE'; // For logging, but not made into tokens
+
+export interface SnbtToken {
+    content: string;
+    offset: number;
+    type: SnbtTokenType;
+}
+
+export class SnbtData {
+    position = 0;
+    data: SnbtToken[] = [];
+
+    addToken(offset: number, type: SnbtTokenType, content: string) {
+        this.data.push({ type, content, offset });
+    }
+
+    currentPosition() {
+        return this.position;
+    }
+
+    remainingLength() {
+        return this.data.length - this.position;
+    }
+
+    seek(offset: number) {
+        this.position = offset;
+    }
+
+    showToken(token?: SnbtToken) {
+        if (!token) {
+            return 'undefined';
+        }
+
+        return `${token.type} at ${token.offset}: "${token.content}"`;
+    }
+
+    step(offset: number) {
+        this.position += offset;
+    }
+
+    token() {
+        if (this.position >= this.data.length) {
+            throw new Error(
+                `Ran out of tokens at position ${this.position} - previous token was ${this.showToken(this.data[this.position - 1])}`
+            );
+        }
+
+        const token = this.data[this.position];
+        this.position += 1;
+
+        return token;
+    }
+}