Added null/undefined encoding

Author: stephenberry

javascript/beve.js

@@ -500,7 +500,10 @@
     }
 
     function write_value(writer, value) {
-        if (Array.isArray(value) && value.length > 1 && typeof value[0] === 'number') {
+        if (value === null || value === undefined) {
+            // null header: type 0, is_bool = 0
+            writer.append_uint8(0);
+        } else if (Array.isArray(value) && value.length > 1 && value.every(v => typeof v === 'number')) {
             let header = 4;
             if (typeof value[0] === 'number' && !Number.isInteger(value[0])) {
                 header |= 0b01100000; // float64_t (double)
@@ -542,15 +545,17 @@
             for (let i = 0; i < value.length; i++) {
                 write_value(writer, value[i]);
             }
-        } else if (typeof value === 'object' && Object.keys(value).length > 0) {
+        } else if (typeof value === 'object') {
+            // Filter out undefined values (matching JSON.stringify behavior)
+            const keys = Object.keys(value).filter(k => value[k] !== undefined);
             let header = 3;
             let keyType = 0; // Assuming keys are always strings
             let isSigned = false;
             header |= keyType << 3;
             header |= isSigned << 5;
             writer.append_uint8(header);
-            writeCompressed(writer, Object.keys(value).length);
-            for (const key in value) {
+            writeCompressed(writer, keys.length);
+            for (const key of keys) {
                 const keyBytes = new TextEncoder().encode(key);
                 writeCompressed(writer, keyBytes.length);
                 writer.ensureCapacity(keyBytes.length);

javascript/beve.test.js

@@ -76,6 +76,62 @@ describe('BEVE JavaScript Library', () => {
         });
     });
 
+    describe('Null and Undefined Handling (Issue #7)', () => {
+
+        test('null value', () => {
+            expect(roundTrip(null)).toBe(null);
+        });
+
+        test('undefined converts to null', () => {
+            expect(roundTrip(undefined)).toBe(null);
+        });
+
+        test('object with null value', () => {
+            const input = { value: null };
+            expect(roundTrip(input)).toEqual(input);
+        });
+
+        test('object with undefined value is omitted', () => {
+            const input = { defined: 'yes', notDefined: undefined };
+            const expected = { defined: 'yes' };
+            expect(roundTrip(input)).toEqual(expected);
+        });
+
+        test('object with only undefined values becomes empty', () => {
+            const input = { a: undefined, b: undefined };
+            expect(roundTrip(input)).toEqual({});
+        });
+
+        test('array with null elements', () => {
+            const input = [1, null, 3];
+            expect(roundTrip(input)).toEqual([1, null, 3]);
+        });
+
+        test('array with undefined elements converts to null', () => {
+            const input = [1, undefined, 3];
+            const expected = [1, null, 3];
+            expect(roundTrip(input)).toEqual(expected);
+        });
+
+        test('nested object with null', () => {
+            const input = { outer: { inner: null } };
+            expect(roundTrip(input)).toEqual(input);
+        });
+
+        test('mixed null and undefined in object', () => {
+            const input = {
+                present: 'value',
+                isNull: null,
+                isUndefined: undefined
+            };
+            const expected = {
+                present: 'value',
+                isNull: null
+            };
+            expect(roundTrip(input)).toEqual(expected);
+        });
+    });
+
     describe('String Handling', () => {
 
         test('empty string', () => {
@@ -194,9 +250,8 @@ describe('BEVE JavaScript Library', () => {
 
     describe('Objects', () => {
 
-        test('empty object throws', () => {
-            // Current implementation throws on empty objects
-            expect(() => roundTrip({})).toThrow();
+        test('empty object', () => {
+            expect(roundTrip({})).toEqual({});
         });
 
         test('simple object with string value', () => {