Accept ArrayBuffer as .parse data (#125)

* Accept ArrayBuffer as data

* update readme

Author: extremeheat

README.md

@@ -18,8 +18,13 @@ const nbt = require('prismarine-nbt')
 async function main(file) {
   const buffer = fs.readFileSync(file)
   const { parsed, type } = await nbt.parse(buffer)
-  console.log('JSON serialized', JSON.stringify(parsed, null, 2))
-  fs.createWriteStream('bigtest.nbt').write(nbt.writeUncompressed(parsed, type)) // Write it back 
+
+  console.log('As JSON', JSON.stringify(parsed))
+  console.log('Simplified', nbt.simplify(parsed))
+
+  // Write it back
+  fs.createWriteStream('bigtest.nbt')
+    .write(nbt.writeUncompressed(parsed, type))
 }
 main('bigtest.nbt')
 ```
@@ -47,7 +52,7 @@ If the data is gzipped, it is automatically decompressed, for the buffer see met
 ### parse(data, [format]): Promise<{ parsed, type, metadata: { size, buffer? } }>
 ### parse(data, [format,] callback)
 
-Takes an optionally compressed `data` buffer and reads the nbt data.
+Takes an optionally compressed `data` buffer (`Buffer` or `ArrayBuffer`) and reads the nbt data.
 
 If the endian `format` is known, it can be specified as 'big', 'little' or 'littleVarint'. If not specified, the library will
 try to sequentially load as big, little and little varint until the parse is successful. The deduced type is returned as `type`.
@@ -123,14 +128,13 @@ For webpack usage, see an example configuration [here](https://github.com/Prisma
 
 For a web bundle with browserify (after you ran `npm install prismarine-nbt` in your project):
 ```
-npx browserify -r prismarine-nbt -r buffer -o pnbt.js
+npx browserify -r prismarine-nbt -o pnbt.js
 ```
 ```html
 <script src="./pnbt.js"></script>
 <script>
   const nbt = require('prismarine-nbt')
-  const { Buffer } = require('buffer')
   fetch('test.nbt').then(resp => resp.arrayBuffer())
-    .then(buf => nbt.parse(Buffer.from(buf))).then(console.log)
+    .then(nbt.parse).then(console.log)
 </script>
 ```

nbt.js

@@ -72,6 +72,7 @@ const hasBedrockLevelHeader = (data) =>
   data[1] === 0 && data[2] === 0 && data[3] === 0
 
 async function parseAs (data, type, options = {}) {
+  if (!(data instanceof Buffer)) throw new Error('Invalid argument: `data` must be a Buffer object')
   if (hasGzipHeader(data)) {
     data = await new Promise((resolve, reject) => {
       zlib.gunzip(data, (error, uncompressed) => {
@@ -91,6 +92,12 @@ async function parseAs (data, type, options = {}) {
 }
 
 async function parse (data, format, callback) {
+  if (data instanceof ArrayBuffer) {
+    data = Buffer.from(data)
+  } else if (!(data instanceof Buffer)) {
+    throw new Error('Invalid argument: `data` must be a Buffer or ArrayBuffer object')
+  }
+
   let fmt = null
   if (typeof format === 'function') {
     callback = format

sample/builderExample.js

@@ -1,11 +1,14 @@
+const fs = require('fs')
 const nbt = require('prismarine-nbt')
 
-const writePlayerNbt = () => {}
-writePlayerNbt({
+const tag = nbt.comp({
   Air: nbt.short(300),
-  Armor: nbt.list(
-    nbt.comp({ Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('') }),
-    nbt.comp({ Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('') }),
-    nbt.comp({ Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('') })
-  )
+  Armor: nbt.list(nbt.comp([
+    { Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('a') },
+    { Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('b') },
+    { Count: nbt.byte(0), Damage: nbt.short(0), Name: nbt.string('c') }
+  ]))
 })
+
+const buffer = nbt.writeUncompressed(tag)
+fs.createWriteStream('tag.nbt').write(buffer)

typings/index.d.ts

@@ -1,35 +1,23 @@
 /// <reference types="node" resolution-mode="require"/>
-declare module 'prismarine-nbt'{
+declare module 'prismarine-nbt' {
   // @ts-expect-error - protodef is untyped
   import type { Compiler, Interpreter } from "protodef";
 
   export type Byte = { type: `${TagType.Byte}`, value: number };
-
   export type Short = { type: `${TagType.Short}`, value: number };
-
   export type Int = { type: `${TagType.Int}`, value: number };
-
   export type Long = { type: `${TagType.Long}`, value: [number, number] };
-
   export type Float = { type: `${TagType.Float}`, value: number };
-
   export type Double = { type: `${TagType.Double}`, value: number };
-
   export type String = { type: `${TagType.String}`, value: string };
-
   export type List<T extends TagType> = {
     type: `${TagType.List}`,
     value: { type: Tags[T]['type'], value: Tags[T]['value'][] }
   };
-
   export type Compound = { type: `${TagType.Compound}`, value: Record<string, undefined | Tags[TagType]> };
-
   export type ByteArray = { type: `${TagType.ByteArray}`, value: Byte["value"][] };
-
   export type ShortArray = { type: `${TagType.ShortArray}`, value: Short["value"][] };
-
   export type IntArray = { type: `${TagType.IntArray}`, value: Int["value"][] };
-
   export type LongArray = { type: `${TagType.LongArray}`, value: Long["value"][] };
 
   export enum TagType {
@@ -70,7 +58,7 @@ declare module 'prismarine-nbt'{
 
   export type NBTFormat = 'big' | 'little' | 'littleVarint'
 
-  export type NBT = Tags['compound'] & {name: string};
+  export type NBT = Tags['compound'] & { name: string };
   export type Metadata = {
     // The decompressed buffer
     buffer: Buffer
@@ -79,9 +67,9 @@ declare module 'prismarine-nbt'{
   }
   export function writeUncompressed(value: NBT, format?: NBTFormat): Buffer;
   export function parseUncompressed(value: Buffer, format?: NBTFormat, options?: ParseOptions): NBT;
-  export function parseAs(value: Buffer, type: NBTFormat, options?: ParseOptions): Promise<{parsed: NBT, type: NBTFormat, metadata: Metadata}>;
-  
-  export function parse(data: Buffer, nbtType?: NBTFormat): Promise<{parsed: NBT, type: NBTFormat, metadata: Metadata}>;
+  export function parseAs(value: Buffer, type: NBTFormat, options?: ParseOptions): Promise<{ parsed: NBT, type: NBTFormat, metadata: Metadata }>;
+
+  export function parse(data: Buffer | ArrayBuffer, nbtType?: NBTFormat): Promise<{ parsed: NBT, type: NBTFormat, metadata: Metadata }>;
   export function simplify(data: Tags[TagType]): any
   export function equal(nbt1: Tags[TagType], nbt2: Tags[TagType]): boolean
   // ProtoDef compiled protocols
@@ -106,22 +94,23 @@ declare module 'prismarine-nbt'{
   /** @deprecated */
   export function parse(data: Buffer, callback: (err: Error | null, value: NBT) => any): void;
 
-  export function bool(val: number): { type: `${TagType.Short}`, value: number }
-  export function short (val: number): { type: `${TagType.Short}`, value: number }
-  export function byte<T extends number> (val: number): { type: `${TagType.Byte}`, value: number }
-  export function string<T extends string | string[]> (val: T): { type: `${TagType.String}`, value: T }
-  export function comp<T extends object | object[]> (val: T, name?: string): { type: `${TagType.Compound}`, name?: string, value: T }
-  export function int<T extends number | number[]> (val: T): { type: `${TagType.Int}`, value: T }
-  export function list<T extends string, K extends {type: T}>(value: K): { type: `${TagType.List}`; value: { type: T | 'end', value: K } }
-  export function float<T extends number | number[]> (value: T): { type: `${TagType.Float}`, value: T}
-  export function double<T extends number | number[]> (value: T): { type: `${TagType.Double}`, value: T}
+  // Builder methods
+  export function bool<T extends number | number[]>(val: T): { type: `${TagType.Short}`, value: T }
+  export function short<T extends number | number[]>(val: T): { type: `${TagType.Short}`, value: T }
+  export function byte<T extends number | number[]>(val: T): { type: `${TagType.Byte}`, value: T }
+  export function string<T extends string | string[]>(val: T): { type: `${TagType.String}`, value: T }
+  export function comp<T extends object | object[]>(val: T, name?: string): { type: `${TagType.Compound}`, name?: string, value: T }
+  export function int<T extends number | number[]>(val: T): { type: `${TagType.Int}`, value: T }
+  export function list<T extends string, K extends { type: T }>(value: K): { type: `${TagType.List}`; value: { type: T | 'end', value: K } }
+  export function float<T extends number | number[]>(value: T): { type: `${TagType.Float}`, value: T }
+  export function double<T extends number | number[]>(value: T): { type: `${TagType.Double}`, value: T }
   /**
    * @param value Takes a BigInt or an array of two 32-bit integers
    */
-  export function long<T extends number | number[] |  BigInt> (value: T): { type: `${TagType.Long}`, value: T}
+  export function long<T extends number | number[] | BigInt>(value: T): { type: `${TagType.Long}`, value: T }
   // Arrays
-  export function byteArray (value: number[]): { type: `${TagType.ByteArray}`, value: number[]}
-  export function shortArray (value: number[]): { type: `${TagType.ShortArray}`, value: number[]}
-  export function intArray (value: number[]): { type: `${TagType.ByteArray}`, value: number[]}
-  export function longArray<T extends number[] | BigInt[]> (value: T): { type: `${TagType.LongArray}`, value: T}
+  export function byteArray(value: number[]): { type: `${TagType.ByteArray}`, value: number[] }
+  export function shortArray(value: number[]): { type: `${TagType.ShortArray}`, value: number[] }
+  export function intArray(value: number[]): { type: `${TagType.ByteArray}`, value: number[] }
+  export function longArray<T extends number[] | BigInt[]>(value: T): { type: `${TagType.LongArray}`, value: T }
 }