@serenityjs/nbt 0.8.3 → 0.8.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @serenityjs/nbt
 
+## 0.8.4
+
+### Patch Changes
+
+- [`2b1b755`](https://github.com/SerenityJS/serenity/commit/2b1b7550799534f58061e330133bbd459635837c) Thanks [@PMK744](https://github.com/PMK744)! - init v0.8.4-beta
+
 ## 0.8.3
 
 ### Patch Changes

package/dist/index.d.mts

@@ -8,157 +8,212 @@ declare enum TagType {
     Long = 4,
     Float = 5,
     Double = 6,
-    ByteArray = 7,
+    ByteList = 7,
     String = 8,
     List = 9,
     Compound = 10,
-    IntArray = 11,
-    LongArray = 12
+    IntList = 11,
+    LongList = 12
 }
 
-interface TagProperties<T = unknown> {
-    name: string;
-    value: T;
-}
-interface ReadingProperties {
+interface ReadWriteOptions {
     name: boolean;
     type: boolean;
+    varint: boolean;
 }
-interface WritingProperties {
-    name: boolean;
-    type: boolean;
-}
-declare class Tag<T = unknown> {
-    /**
-     * The nbt tag type of the data type.
-     */
-    static readonly type: TagType;
+
+declare abstract class BaseTag {
     /**
      * The nbt tag type of the data type.
      */
-    readonly type: TagType;
+    abstract readonly type: TagType;
     /**
-     * The name of the tag.
+     * The name of the nbt tag.
      */
-    name: string;
+    name: string | null;
     /**
-     * The value of the tag.
+     * Convert the tag to a JSON object.
      */
-    value: T;
-    constructor(properties?: Partial<TagProperties<T>>);
-    toJSON(): TagProperties<T> & {
-        type: TagType;
-    };
-    static from(buffer: Buffer, varint?: boolean): Tag;
+    abstract toJSON(): unknown;
     /**
-     * Read a nbt tag from a binary stream.
+     * Read the nbt tag from the stream.
      * @param stream The binary stream to read from.
-     * @param varint Whether to read the tag as a varint.
+     * @param options The options for reading the tag.
      */
-    static read(_stream: BinaryStream, _varint?: number | boolean, _properties?: Partial<ReadingProperties>): Tag;
+    static read(_stream: BinaryStream, _options?: ReadWriteOptions): BaseTag;
     /**
-     * Write a nbt tag to a binary stream.
+     * Write the nbt tag to the stream.
      * @param stream The binary stream to write to.
-     * @param value The value of the tag.
-     * @param varint Whether to write the tag as a varint.
+     * @param value The value of the tag to write.
+     * @param options The options for writing the tag.
      */
-    static write(_stream: BinaryStream, _value: Tag, _varint?: number | boolean, _properties?: Partial<WritingProperties>): void;
-    protected static readString(stream: BinaryStream, varint?: boolean): string;
-    protected static writeString(value: string, stream: BinaryStream, varint?: boolean): void;
+    static write(_stream: BinaryStream, _value: BaseTag, _options?: ReadWriteOptions): void;
 }
 
-declare class ByteTag extends Tag<number> {
-    static readonly type = TagType.Byte;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): ByteTag;
-    static write(stream: BinaryStream, value: ByteTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class ByteTag extends Number implements BaseTag {
+    readonly type = TagType.Byte;
+    name: string | null;
+    /**
+     * Create a new ByteTag instance.
+     * @param value The byte value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: number, name?: string | null);
+    toJSON(): number;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): ByteTag;
+    static write(stream: BinaryStream, value: ByteTag, options?: ReadWriteOptions): void;
 }
 
-declare class ShortTag extends Tag<number> {
-    static readonly type = TagType.Short;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: ShortTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class ShortTag extends Number implements BaseTag {
+    readonly type = TagType.Short;
+    name: string | null;
+    /**
+     * Create a new ShortTag instance.
+     * @param value The short value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: number, name?: string | null);
+    toJSON(): number;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): ShortTag;
+    static write(stream: BinaryStream, value: ShortTag, options?: ReadWriteOptions): void;
 }
 
-declare class IntTag extends Tag<number> {
-    static readonly type = TagType.Int;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: IntTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class IntTag extends Number implements BaseTag {
+    readonly type = TagType.Int;
+    name: string | null;
+    /**
+     * Create a new IntTag instance.
+     * @param value The int value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: number, name?: string | null);
+    toJSON(): number;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): IntTag;
+    static write(stream: BinaryStream, value: IntTag, options?: ReadWriteOptions): void;
 }
 
-declare class LongTag extends Tag<bigint> {
-    static readonly type = TagType.Long;
-    toJSON(): TagProperties<bigint> & {
-        type: TagType;
-    };
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: LongTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class LongTag extends String implements BaseTag {
+    readonly type = TagType.Long;
+    name: string | null;
+    /**
+     * Create a new LongTag instance.
+     * @param value The long value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: bigint, name?: string | null);
+    toJSON(): string;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): LongTag;
+    static write(stream: BinaryStream, value: LongTag, options?: ReadWriteOptions): void;
 }
 
-declare class FloatTag extends Tag<number> {
-    static readonly type = TagType.Float;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: FloatTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class FloatTag extends Number implements BaseTag {
+    readonly type = TagType.Float;
+    name: string | null;
+    /**
+     * Create a new FloatTag instance.
+     * @param value The float value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: number, name?: string | null);
+    toJSON(): number;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): FloatTag;
+    static write(stream: BinaryStream, value: FloatTag, options?: ReadWriteOptions): void;
 }
 
-declare class DoubleTag extends Tag<number> {
-    static readonly type = TagType.Double;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: DoubleTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class DoubleTag extends Number implements BaseTag {
+    readonly type = TagType.Double;
+    name: string | null;
+    /**
+     * Create a new DoubleTag instance.
+     * @param value The double value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: number, name?: string | null);
+    toJSON(): number;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): DoubleTag;
+    static write(stream: BinaryStream, value: DoubleTag, options?: ReadWriteOptions): void;
 }
 
-declare class ByteArrayTag extends Tag<Array<number>> {
-    static readonly type = TagType.ByteArray;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): ByteArrayTag;
-    static write(stream: BinaryStream, value: ByteArrayTag, varint: boolean, properties?: Partial<WritingProperties>): void;
+declare class ByteListTag extends Array<number> implements BaseTag {
+    readonly type = TagType.ByteList;
+    name: string | null;
+    /**
+     * Create a new ByteListTag instance.
+     * @param elements The elements of the byte list.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(elements: Array<number>, name?: string | null);
+    map<U>(callbackfn: (value: number, index: number, array: Array<number>) => U, thisArg?: unknown): Array<U>;
+    toJSON(): Array<number>;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): ByteListTag;
+    static write(stream: BinaryStream, value: ByteListTag, options?: ReadWriteOptions): void;
 }
 
-declare class StringTag extends Tag<string> {
-    static readonly type = TagType.String;
-    static read(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): Tag;
-    static write(stream: BinaryStream, value: StringTag, varint?: boolean, properties?: Partial<WritingProperties>): void;
+declare class StringTag extends String implements BaseTag {
+    readonly type = TagType.String;
+    name: string | null;
+    /**
+     * Create a new StringTag instance.
+     * @param value The string value.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(value: string, name?: string | null);
+    toJSON(): string;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): StringTag;
+    static write(stream: BinaryStream, value: StringTag, options?: ReadWriteOptions): void;
 }
 
-type GenericList<T extends Tag<unknown>> = Array<T>;
-declare class ListTag<T extends Tag> extends Tag<GenericList<T>> {
-    static readonly type = TagType.List;
-    readonly listType: TagType;
-    value: GenericList<T>;
-    constructor(properties: Partial<TagProperties<GenericList<T>>> & {
-        listType: TagType;
-    });
-    push(...tag: Array<T>): void;
-    static read<T extends Tag>(stream: BinaryStream, varint: boolean, properties?: Partial<ReadingProperties>): ListTag<T>;
-    static write<T extends Tag>(stream: BinaryStream, value: ListTag<T>, varint: boolean, properties?: Partial<ReadingProperties>): void;
+declare class ListTag<T extends BaseTag> extends Array<T> implements BaseTag {
+    readonly type = TagType.List;
+    name: string | null;
+    /**
+     * Create a new ListTag instance.
+     * @param elements The elements of the list.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(elements?: Array<T>, name?: string | null);
+    map<U>(callbackfn: (value: T, index: number, array: Array<T>) => U, thisArg?: unknown): Array<U>;
+    toJSON(): Array<unknown>;
+    static read<T extends BaseTag>(stream: BinaryStream, options?: ReadWriteOptions): ListTag<T>;
+    static write<T extends BaseTag>(stream: BinaryStream, value: ListTag<T>, options?: ReadWriteOptions): void;
 }
 
-type GenericCompound<T = Record<string, Tag>> = T;
-declare class CompoundTag<T> extends Tag<GenericCompound<T>> {
-    static readonly type = TagType.Compound;
-    value: T;
-    constructor(properties?: Partial<TagProperties<T>>);
-    hasTag(name: string): boolean;
-    getTag<K extends Tag>(name: string): K;
-    getTags(): Array<Tag>;
-    setTag(name: string, tag: Tag): void;
-    addTag(tag: Tag): void;
-    removeTag(name: string): void;
-    createByteTag(properties: Partial<TagProperties<number>>): ByteTag;
-    createShortTag(properties: Partial<TagProperties<number>>): ShortTag;
-    createIntTag(properties: Partial<TagProperties<number>>): IntTag;
-    createLongTag(properties: Partial<TagProperties<bigint>>): LongTag;
-    createFloatTag(properties: Partial<TagProperties<number>>): FloatTag;
-    createDoubleTag(properties: Partial<TagProperties<number>>): DoubleTag;
-    createStringTag(properties: Partial<TagProperties<string>>): StringTag;
-    createListTag<T extends Tag>(properties: Partial<TagProperties<Array<T>>> & {
-        listType: TagType;
-    }): ListTag<T>;
-    createCompoundTag<T>(properties: Partial<TagProperties<GenericCompound<T>>>): CompoundTag<T>;
-    toJSON(): TagProperties<T> & {
-        type: TagType;
-    };
-    static read<T>(stream: BinaryStream, varint?: boolean, properties?: Partial<ReadingProperties>): CompoundTag<T>;
-    static write<T>(stream: BinaryStream, value: CompoundTag<T>, varint?: boolean, properties?: Partial<WritingProperties>): void;
-    static from<T>(buffer: Buffer, varint?: boolean): CompoundTag<T>;
+declare class CompoundTag extends Map<string, BaseTag> implements BaseTag {
+    readonly type = TagType.Compound;
+    name: string | null;
+    /**
+     * Create a new CompoundTag instance.
+     * @param name The name of the tag, defaults to null.
+     */
+    constructor(name?: string | null);
+    toJSON(): Record<string, unknown>;
+    /**
+     * Get a nbt tag by its key.
+     * @param key The key of the tag to retrieve.
+     * @returns The tag associated with the key, or undefined if not found.
+     */
+    get<T extends BaseTag>(key: string): T | undefined;
+    /**
+     * Set a nbt tag with a specific key.
+     * @param key The key to associate with the tag.
+     * @param value The tag to set.
+     * @returns The current instance for method chaining.
+     */
+    set<T extends BaseTag>(key: string, value: T): this;
+    /**
+     * Add multiple tags to the compound tag.
+     * @param tags An array of tags to add.
+     * @returns The current instance for method chaining.
+     */
+    push<T extends BaseTag>(...tags: Array<T>): this;
+    /**
+     * Add a single tag to the compound tag.
+     * @param tag The tag to add to the compound tag.
+     * @returns The tag that was added.
+     */
+    add<T extends BaseTag>(tag: T): T;
+    static read(stream: BinaryStream, options?: ReadWriteOptions): CompoundTag;
+    static write(stream: BinaryStream, value: CompoundTag, options?: ReadWriteOptions): void;
 }
 
-export { ByteArrayTag, ByteTag, CompoundTag, DoubleTag, FloatTag, IntTag, ListTag, LongTag, type ReadingProperties, ShortTag, StringTag, Tag, type TagProperties, TagType, type WritingProperties };
+export { BaseTag, ByteListTag, ByteTag, CompoundTag, DoubleTag, FloatTag, IntTag, ListTag, LongTag, ShortTag, StringTag, TagType };