snbt-js 1.0.4 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snbt-js",
-  "version": "1.0.4",
+  "version": "1.0.5",
   "description": "JavaScript library for parsing and manipulating Minecraft SNBT data",
   "main": "src/snbt.js",
   "type": "module",

package/src/snbt.d.ts

@@ -51,7 +51,7 @@ export declare class NbtString extends NbtValue {
 }
 
 export declare class NbtBool extends NbtValue {
-  value: string;
+  value: boolean;
   constructor(value: boolean);
 }
 

package/src/snbt.js

@@ -43,7 +43,11 @@ export class NbtObject {
             if (args.length == 1) {
                 return this.childs[args[0]];
             } else if (args.length > 1) {
-                return this.childs[args[0]].get(args.slice(1));
+                var child = this.childs[args[0]];
+                if (child === undefined) {
+                    return undefined;
+                }
+                return child.get(args.slice(1));
             } else {
                 return this;
             };
@@ -55,7 +59,10 @@ export class NbtObject {
                 if (index.length == 1) {
                     this.childs[index[0]] = value;
                 } else if (index.length > 1) {
-                    this.get(index.slice(0, -1)).set(index.slice(-1), value);
+                    var parent = this.get(index.slice(0, -1));
+                    if (parent !== undefined) {
+                        parent.set(index.slice(-1), value);
+                    }
                 };
             };
         };
@@ -94,7 +101,11 @@ export class NbtList {
             if (args.length == 1) {
                 return this.childs[args[0]];
             } else if (args.length > 1) {
-                return this.childs[args[0]].get(args.slice(1));
+                var child = this.childs[args[0]];
+                if (child === undefined) {
+                    return undefined;
+                }
+                return child.get(args.slice(1));
             } else {
                 return this;
             };
@@ -106,7 +117,10 @@ export class NbtList {
                 if (index.length == 1) {
                     this.childs[index[0]] = value;
                 } else if (index.length > 1) {
-                    this.get(index.slice(0, -1)).set(index.slice(-1), value);
+                    var parent = this.get(index.slice(0, -1));
+                    if (parent !== undefined) {
+                        parent.set(index.slice(-1), value);
+                    }
                 };
             };
         };
@@ -251,7 +265,7 @@ export class NbtString {
 
 export class NbtBool {
     constructor(value) {
-        this.value = value ? "true" : "false";
+        this.value = !!value;
         this.text = function (ispretty) {
             if (ispretty) {
                 return highlightCode(`${this.value}`, "bool")

package/test/boolean-tests.js

@@ -0,0 +1,81 @@
+import { expect } from 'chai';
+import { parseNbtString, NbtBool, NbtObject } from '../src/snbt.js';
+
+describe('NbtBool Tests', () => {
+  it('should store boolean value as boolean, not string', () => {
+    const boolTrue = new NbtBool(true);
+    const boolFalse = new NbtBool(false);
+    
+    expect(boolTrue.value).to.be.a('boolean');
+    expect(boolTrue.value).to.equal(true);
+    
+    expect(boolFalse.value).to.be.a('boolean');
+    expect(boolFalse.value).to.equal(false);
+  });
+
+  it('should parse true boolean from SNBT', () => {
+    const result = parseNbtString('{ flag: true }');
+    const flag = result.get('flag');
+    
+    expect(flag).to.be.instanceOf(NbtBool);
+    expect(flag.value).to.be.a('boolean');
+    expect(flag.value).to.equal(true);
+  });
+
+  it('should parse false boolean from SNBT', () => {
+    const result = parseNbtString('{ flag: false }');
+    const flag = result.get('flag');
+    
+    expect(flag).to.be.instanceOf(NbtBool);
+    expect(flag.value).to.be.a('boolean');
+    expect(flag.value).to.equal(false);
+  });
+
+  it('should convert truthy values to true', () => {
+    const bool1 = new NbtBool(1);
+    const bool2 = new NbtBool("yes");
+    const bool3 = new NbtBool({});
+    
+    expect(bool1.value).to.equal(true);
+    expect(bool2.value).to.equal(true);
+    expect(bool3.value).to.equal(true);
+  });
+
+  it('should convert falsy values to false', () => {
+    const bool1 = new NbtBool(0);
+    const bool2 = new NbtBool("");
+    const bool3 = new NbtBool(null);
+    const bool4 = new NbtBool(undefined);
+    
+    expect(bool1.value).to.equal(false);
+    expect(bool2.value).to.equal(false);
+    expect(bool3.value).to.equal(false);
+    expect(bool4.value).to.equal(false);
+  });
+
+  it('should output boolean as string in text() method', () => {
+    const boolTrue = new NbtBool(true);
+    const boolFalse = new NbtBool(false);
+    
+    expect(boolTrue.text()).to.equal('true');
+    expect(boolFalse.text()).to.equal('false');
+  });
+
+  it('should handle boolean in nested objects', () => {
+    const result = parseNbtString(`{
+      player: {
+        isAlive: true,
+        isFlying: false
+      }
+    }`);
+    
+    const isAlive = result.get('player.isAlive');
+    const isFlying = result.get('player.isFlying');
+    
+    expect(isAlive.value).to.be.a('boolean');
+    expect(isAlive.value).to.equal(true);
+    
+    expect(isFlying.value).to.be.a('boolean');
+    expect(isFlying.value).to.equal(false);
+  });
+});

package/test/path-access-tests.js

@@ -0,0 +1,176 @@
+import { expect } from 'chai';
+import { parseNbtString, NbtObject, NbtList, NbtString, NbtNumber } from '../src/snbt.js';
+
+describe('Path Access Tests', () => {
+  describe('NbtObject.get() with non-existent paths', () => {
+    it('should return undefined when accessing non-existent key', () => {
+      const nbt = new NbtObject({
+        'minecraft:enchantments': new NbtObject()
+      });
+      
+      const result = nbt.get(['minecraft:enchantments', 'levels']);
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when accessing nested non-existent path', () => {
+      const nbt = parseNbtString(`{
+        player: {
+          name: "Steve"
+        }
+      }`);
+      
+      const result = nbt.get(['player', 'inventory', 0]);
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when accessing non-existent top-level key', () => {
+      const nbt = new NbtObject({
+        name: new NbtString('Steve')
+      });
+      
+      const result = nbt.get('age');
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when using dot notation on non-existent path', () => {
+      const nbt = parseNbtString(`{ player: { name: "Steve" } }`);
+      
+      const result = nbt.get('player.health');
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when accessing deeply nested non-existent path', () => {
+      const nbt = parseNbtString(`{
+        level1: {
+          level2: {
+            level3: "value"
+          }
+        }
+      }`);
+      
+      const result = nbt.get(['level1', 'level2', 'level4', 'level5']);
+      expect(result).to.be.undefined;
+    });
+  });
+
+  describe('NbtList.get() with non-existent paths', () => {
+    it('should return undefined when accessing non-existent index in nested list', () => {
+      const nbt = parseNbtString(`{
+        items: [
+          { id: "diamond" }
+        ]
+      }`);
+      
+      const result = nbt.get(['items', 5, 'id']);
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when accessing property on undefined array element', () => {
+      const nbt = new NbtObject({
+        inventory: new NbtList([
+          new NbtObject({ id: new NbtString('sword') })
+        ])
+      });
+      
+      const result = nbt.get(['inventory', 10, 'id']);
+      expect(result).to.be.undefined;
+    });
+
+    it('should return undefined when list element exists but nested path does not', () => {
+      const nbt = parseNbtString(`{
+        items: [
+          { name: "item1" },
+          { name: "item2" }
+        ]
+      }`);
+      
+      const result = nbt.get(['items', 0, 'count']);
+      expect(result).to.be.undefined;
+    });
+  });
+
+  describe('NbtObject.set() with non-existent paths', () => {
+    it('should not throw error when setting on non-existent intermediate path', () => {
+      const nbt = new NbtObject({
+        player: new NbtObject()
+      });
+      
+      // This should not throw an error, but also should not set the value
+      // since 'inventory' doesn't exist on the player object (parent is undefined)
+      expect(() => {
+        nbt.set(['player', 'inventory', 'count'], new NbtNumber(5));
+      }).to.not.throw();
+      
+      // Verify the value was not set (because 'inventory' doesn't exist)
+      const result = nbt.get(['player', 'inventory', 'count']);
+      expect(result).to.be.undefined;
+    });
+
+    it('should handle setting on deeply nested non-existent path gracefully', () => {
+      const nbt = parseNbtString(`{ level1: { level2: {} } }`);
+      
+      expect(() => {
+        nbt.set(['level1', 'level2', 'level3', 'value'], new NbtString('test'));
+      }).to.not.throw();
+    });
+  });
+
+  describe('NbtList.set() with non-existent paths', () => {
+    it('should not throw error when setting on non-existent array index path', () => {
+      const nbt = new NbtObject({
+        items: new NbtList([
+          new NbtObject({ id: new NbtString('item1') })
+        ])
+      });
+      
+      expect(() => {
+        nbt.set(['items', 5, 'id'], new NbtString('item2'));
+      }).to.not.throw();
+      
+      // The value at index 5 should still be undefined
+      const result = nbt.get(['items', 5]);
+      expect(result).to.be.undefined;
+    });
+  });
+
+  describe('Valid path access should still work', () => {
+    it('should correctly access existing nested paths', () => {
+      const nbt = parseNbtString(`{
+        "minecraft:enchantments": {
+          levels: {
+            sharpness: 5
+          }
+        }
+      }`);
+      
+      const result = nbt.get(['minecraft:enchantments', 'levels', 'sharpness']);
+      expect(result).to.not.be.undefined;
+      expect(result.value).to.equal(5);
+    });
+
+    it('should correctly access array elements', () => {
+      const nbt = parseNbtString(`{
+        items: [
+          { id: "diamond", count: 5 },
+          { id: "gold", count: 10 }
+        ]
+      }`);
+      
+      const result = nbt.get(['items', 1, 'id']);
+      expect(result).to.not.be.undefined;
+      expect(result.value).to.equal('gold');
+    });
+
+    it('should correctly set values on existing paths', () => {
+      const nbt = new NbtObject({
+        player: new NbtObject({
+          health: new NbtNumber(20)
+        })
+      });
+      
+      nbt.set(['player', 'health'], new NbtNumber(15));
+      const result = nbt.get(['player', 'health']);
+      expect(result.value).to.equal(15);
+    });
+  });
+});