mca-json 1.0.0

package/src/nbt/snbt-parse.ts

@@ -0,0 +1,256 @@
+import debug from 'debug';
+import { SnbtData, SnbtTokenType } from './snbt-data';
+
+const debugLog = debug('snbt:parse');
+
+interface TokenParser {
+    type: SnbtTokenType;
+    pattern: RegExp;
+    callback: (
+        offset: number,
+        type: SnbtTokenType,
+        snbtData: SnbtData,
+        match: RegExpMatchArray
+    ) => number;
+}
+
+function testParsers(
+    snbtData: SnbtData,
+    str: string,
+    tokenParsers: TokenParser[],
+    pos: number
+) {
+    for (const { type, pattern, callback } of tokenParsers) {
+        const match = str.match(pattern);
+
+        if (match) {
+            debugLog(`Matched ${type} at position ${pos}: ${match[0]}`);
+
+            return callback(pos, type, snbtData, match);
+        }
+    }
+
+    return false;
+}
+
+const tokenParsers: TokenParser[] = [
+    {
+        type: 'WHITESPACE',
+        pattern: /^\s+/,
+        callback: (_pos, _type, _snbtData, matches) => {
+            return matches[0].length;
+        },
+    },
+    {
+        type: 'COLON',
+        pattern: /^:/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, ':');
+
+            return 1;
+        },
+    },
+    {
+        type: 'COMMA',
+        pattern: /^,/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, ',');
+
+            return 1;
+        },
+    },
+    {
+        type: 'BYTE_ARRAY_START',
+        pattern: /^\[\s*[bB]\s*;/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '[');
+
+            return 3;
+        },
+    },
+    {
+        type: 'INT_ARRAY_START',
+        pattern: /^\[\s*[iI]\s*;/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '[');
+
+            return 3;
+        },
+    },
+    {
+        type: 'LONG_ARRAY_START',
+        pattern: /^\[\s*[lL]\s*;/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '[');
+
+            return 3;
+        },
+    },
+    {
+        type: 'COMPOUND_START',
+        pattern: /^\{/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '{');
+
+            return 1;
+        },
+    },
+    {
+        type: 'COMPOUND_END',
+        pattern: /^\}/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '}');
+
+            return 1;
+        },
+    },
+    {
+        type: 'LIST_START',
+        pattern: /^\[/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, '[');
+
+            return 1;
+        },
+    },
+    {
+        type: 'LIST_END',
+        pattern: /^\]/,
+        callback: (pos, type, snbtData) => {
+            snbtData.addToken(pos, type, ']');
+
+            return 1;
+        },
+    },
+    {
+        // Byte - true / false converts to 1 / 0
+        type: 'BYTE',
+        pattern: anchorPattern('([tT][rR][uU][eE]|[fF][aA][lL][sS][eE])'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(
+                pos,
+                type,
+                matches[0].toLowerCase() === 'true' ? '1' : '0'
+            );
+
+            return matches[0].length;
+        },
+    },
+    {
+        // Byte - number with a suffix
+        type: 'BYTE',
+        pattern: anchorPattern('[-+]?[0-9]+[bB]'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        // Double - there's another without the D later
+        type: 'DOUBLE',
+        pattern: anchorPattern('[-+]?[0-9.]+[dD]'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        type: 'FLOAT',
+        pattern: anchorPattern('[-+]?[0-9.]+[fF]'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        type: 'LONG',
+        pattern: anchorPattern('[-+]?[0-9]+[lL]'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        type: 'SHORT',
+        pattern: anchorPattern('[-+]?[0-9]+[sS]'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        // Double - this must come after other suffixed number types but before
+        // Int's matcher
+        type: 'DOUBLE',
+        pattern: anchorPattern('[-+]?[0-9.]+'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        // Int - this must come after all other number types
+        type: 'INT',
+        pattern: anchorPattern('[-+]?[0-9]+'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+    {
+        // String - single or double quotes
+        type: 'STRING',
+        pattern: /^([\"'])(?:\\.|.)*?\1/,
+        callback: (pos, type, snbtData, matches) => {
+            const chunk = JSON.parse(`"${matches[0].slice(1, -1)}"`);
+            snbtData.addToken(pos, type, chunk);
+
+            return matches[0].length;
+        },
+    },
+    {
+        // String - not quoted and all else failed
+        type: 'STRING',
+        pattern: anchorPattern('^[-0-9a-zA-Z_.+]+'),
+        callback: (pos, type, snbtData, matches) => {
+            snbtData.addToken(pos, type, matches[0]);
+
+            return matches[0].length;
+        },
+    },
+];
+
+// Creates a regular expression that will start at the beginning of the string
+// and conclude with an "end of token" marker at the end.
+function anchorPattern(pattern: string) {
+    return new RegExp(`^${pattern}\s*(?:$|,|}|]|:)`);
+}
+
+export function snbtParse(snbt: string) {
+    const snbtData = new SnbtData();
+    let pos = 0;
+
+    while (pos < snbt.length) {
+        const increment = testParsers(
+            snbtData,
+            snbt.slice(pos),
+            tokenParsers,
+            pos
+        );
+
+        if (!increment) {
+            throw new Error(`Unexpected token at position ${pos}`);
+        }
+
+        pos += increment;
+    }
+
+    return snbtData;
+}

package/src/nbt/snbt-to-nbt.ts

@@ -0,0 +1,219 @@
+import { NbtBase } from '../nbt/nbt-base';
+import { NbtByteArray } from '../nbt/nbt-byte-array';
+import { NbtByte } from '../nbt/nbt-byte';
+import { NbtCompound } from '../nbt/nbt-compound';
+import { NbtDouble } from '../nbt/nbt-double';
+import { NbtFloat } from '../nbt/nbt-float';
+import { NbtIntArray } from '../nbt/nbt-int-array';
+import { NbtInt } from '../nbt/nbt-int';
+import { NbtList } from '../nbt/nbt-list';
+import { NbtLongArray } from '../nbt/nbt-long-array';
+import { NbtLong } from '../nbt/nbt-long';
+import { NbtShort } from '../nbt/nbt-short';
+import { NbtString } from '../nbt/nbt-string';
+import { SnbtData, SnbtToken } from './snbt-data';
+
+export const fromSnbtData: {
+    [key: string]: (token: SnbtToken, snbtData: SnbtData) => NbtBase<any>;
+} = {
+    BYTE: snbtToNbtByte,
+    BYTE_ARRAY_START: snbtToNbtByteArray,
+    COMPOUND_START: snbtToNbtCompound,
+    DOUBLE: snbtToNbtDouble,
+    FLOAT: snbtToNbtFloat,
+    INT: snbtToNbtInt,
+    INT_ARRAY_START: snbtToNbtIntArray,
+    LIST_START: snbtToNbtList,
+    LONG: snbtToNbtLong,
+    LONG_ARRAY_START: snbtToNbtLongArray,
+    SHORT: snbtToNbtShort,
+    STRING: snbtToNbtString,
+};
+
+export function snbtToNbt(snbtData: SnbtData): NbtBase<any> {
+    const token = snbtData.token();
+    const processor = fromSnbtData[token.type];
+
+    if (processor) {
+        return processor(token, snbtData);
+    }
+
+    throw new Error(`Invalid, non-matching token ${snbtData.showToken(token)}`);
+}
+
+function snbtToNbtByte(token: SnbtToken): NbtByte {
+    return new NbtByte(parseInt(token.content || ''));
+}
+
+function snbtToNbtByteArray(_token: SnbtToken, snbtData: SnbtData): NbtByteArray {
+    const bytes: number[] = [];
+    let token = snbtData.token();
+
+    while (token && token.type === 'BYTE') {
+        bytes.push(parseInt(token.content || ''));
+
+        try {
+            token = snbtData.token();
+        } catch (err) {
+            throw new Error(`${err} - Unexpected end of SNBT data while parsing byte array`);
+        }
+
+        if (token.type !== 'COMMA') {
+            throw new Error(`Expecting a comma but found ${snbtData.showToken(token)}`);
+        }
+
+        token = snbtData.token();
+    }
+
+    return new NbtByteArray(bytes);
+}
+
+function snbtToNbtCompound(_token: SnbtToken, snbtData: SnbtData): NbtCompound {
+    const data: NbtBase<any>[] = [];
+    let token = snbtData.token();
+
+    while (token && token.type !== 'COMPOUND_END') {
+        if (token.type !== 'STRING') {
+            throw new Error(`Expecting a string but found ${snbtData.showToken(token)}`);
+        }
+
+        const name = token.content;
+        let colon;
+
+        try {
+            colon = snbtData.token();
+        } catch (err) {
+            throw new Error(`${err} - Unexpected end of SNBT data while looking for colon`);
+        }
+
+        if (colon.type !== 'COLON') {
+            throw new Error(`Expecting a colon but found ${snbtData.showToken(colon)}`);
+        }
+
+        const nbt = snbtToNbt(snbtData);
+        nbt.name = name;
+        data.push(nbt);
+        token = snbtData.token();
+    }
+
+    return new NbtCompound(data);
+}
+
+function snbtToNbtDouble(token: SnbtToken): NbtDouble {
+    return new NbtDouble(parseFloat(token.content.slice(0, -1) || ''));
+}
+
+function snbtToNbtFloat(token: SnbtToken): NbtFloat {
+    return new NbtFloat(parseFloat(token.content || ''));
+}
+
+function snbtToNbtInt(token: SnbtToken): NbtInt {
+    return new NbtInt(parseInt(token.content || ''));
+}
+
+function snbtToNbtIntArray(_token: SnbtToken, snbtData: SnbtData): NbtIntArray {
+    const ints: number[] = [];
+    let token = snbtData.token();
+
+    while (token && token.type === 'INT') {
+        ints.push(parseInt(token.content || ''));
+
+        try {
+            token = snbtData.token();
+        } catch (err) {
+            throw new Error(`${err} - Unexpected end of SNBT data while parsing int array`);
+        }
+
+        if (token.type !== 'COMMA') {
+            throw new Error(`Expecting a comma but found ${snbtData.showToken(token)}`);
+        }
+
+        token = snbtData.token();
+    }
+
+    return new NbtIntArray(ints);
+}
+
+function snbtToNbtList(_token: SnbtToken, snbtData: SnbtData): NbtList<any> {
+    const list: NbtBase<any>[] = [];
+    let token;
+
+    try {
+        token = snbtData.token();
+    } catch (err) {
+        throw new Error(`${err} - Unexpected end of SNBT data while parsing list at beginning`);
+    }
+
+    while (token.type !== 'LIST_END') {
+        snbtData.step(-1);
+        let nbt;
+
+        try {
+            nbt = snbtToNbt(snbtData);
+        } catch (err) {
+            throw new Error(`${err} - Error parsing list element`);
+        }
+
+        list.push(nbt);
+        token = snbtData.token();
+
+        if (token.type === 'COMMA') {
+            try {
+                token = snbtData.token();
+            } catch (err) {
+                throw new Error(`${err} - Unexpected end of SNBT data while looking for comma or end of list`);
+            }
+        } else if (token.type !== 'LIST_END') {
+            throw new Error(`Expecting a comma or list end but found ${snbtData.showToken(token)}`);
+        }
+    }
+
+    if (!list.length) {
+        throw new Error('Empty list not allowed in SNBT because the type cannot be inferred');
+    }
+
+    const firstType = list[0].type;
+
+    for (let i = 1; i < list.length; i++) {
+        if (list[i].type !== firstType) {
+            throw new Error(`List contains mixed types: ${firstType} and ${list[i].type}`);
+        }
+    }
+
+    return new NbtList(list, firstType);
+}
+
+function snbtToNbtLong(token: SnbtToken): NbtLong {
+    return new NbtLong(BigInt(token.content.slice(0, -1) || ''));
+}
+
+function snbtToNbtLongArray(_token: SnbtToken, snbtData: SnbtData): NbtLongArray {
+    const longs: bigint[] = [];
+    let token = snbtData.token();
+
+    while (token && token.type === 'LONG') {
+        longs.push(BigInt(token.content.slice(0, -1) || ''));
+
+        try {
+            token = snbtData.token();
+        } catch (err) {
+            throw new Error(`${err} - Unexpected end of SNBT data while parsing long array`);
+        }
+
+        if (token.type !== 'COMMA') {
+            throw new Error(`Expecting a comma but found ${snbtData.showToken(token)}`);
+        }
+
+        token = snbtData.token();
+    }
+
+    return new NbtLongArray(longs);
+}
+
+function snbtToNbtShort(token: SnbtToken): NbtShort {
+    return new NbtShort(parseInt(token.content || ''));
+}
+
+function snbtToNbtString(token: SnbtToken): NbtString {
+    return new NbtString(token.content);
+}

package/src/types/coords.ts

@@ -0,0 +1,2 @@
+export type Coords2d = [number, number]; // X and Z
+export type Coords3d = [number, number, number]; // X, Y, and Z

package/src/types/neodoc.d.ts

@@ -0,0 +1,28 @@
+declare module 'neodoc' {
+    export interface ParsedArguments {
+        [key: string]: string | string[] | boolean;
+    }
+
+    export function run(
+        usage: string,
+        options?: {
+            allowUnknown?: boolean,
+            argv?: string[],
+            dontExit?: boolean,
+            env?: { [key: string]: string },
+            helpFlags?: string[],
+            laxPlacement?: boolean,
+            optionsFirst?: boolean,
+            repeatableOptions?: boolean,
+            requireFlags?: boolean,
+            smartOptions?: boolean,
+            stopAt?: string[],
+            transforms?: {
+                postsolve?: ((spec: any) => any)[],
+                presolve?: ((spec: any) => any)[],
+            },
+            version?: string,
+            versionFlags?: string[],
+        },
+    ): ParsedArguments;
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+    "compilerOptions": {
+        "allowSyntheticDefaultImports": true,
+        "alwaysStrict": true,
+        "declaration": true,
+        "declarationMap": true,
+        "experimentalDecorators": true,
+        "inlineSources": true,
+        "lib": ["esnext"],
+        "module": "esnext",
+        "moduleResolution": "node",
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitAny": true,
+        "noImplicitOverride": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "outDir": "dist",
+        "sourceMap": true,
+        "strict": true,
+        "target": "esnext"
+    },
+    "include": ["src"]
+}