@maplibre/mlt 1.1.0 → 1.1.2

package/dist/decoding/propertyDecoder.spec.js

@@ -1,6 +1,6 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { StreamMetadataDecoder } from "../metadata/tile/streamMetadataDecoder";
-import IntegerStreamDecoder from "./integerStreamDecoder";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import * as StreamMetadataDecoder from "../metadata/tile/streamMetadataDecoder";
+import * as IntegerStreamDecoder from "./integerStreamDecoder";
 import { decodePropertyColumn } from "./propertyDecoder";
 import { ScalarType } from "../metadata/tile/scalarType";
 import IntWrapper from "./intWrapper";
@@ -11,8 +11,8 @@ import { LongSequenceVector } from "../vector/sequence/longSequenceVector";
 import { IntConstVector } from "../vector/constant/intConstVector";
 import { LongConstVector } from "../vector/constant/longConstVector";
 import { VectorType } from "../vector/vectorType";
-import { StringDecoder } from "./stringDecoder";
-import * as decodingUtils from './decodingUtils';
+import * as StringDecoder from "./stringDecoder";
+import * as decodingUtils from "./decodingUtils";
 import { BooleanFlatVector } from "../vector/flat/booleanFlatVector";
 import { FloatFlatVector } from "../vector/flat/floatFlatVector";
 import { DoubleFlatVector } from "../vector/flat/doubleFlatVector";
@@ -21,22 +21,22 @@ const TEST_DATA = {
     BYTE_LENGTH: 12,
     NUM_VALUES: 3,
     NULLABILITY_BYTE_LENGTH: 1,
-    BUFFER_SIZE: 100
+    BUFFER_SIZE: 100,
 };
 // Helper: Create column with specific configuration
 function createColumn(scalarType, nullable = false) {
     return {
-        name: 'age',
+        name: "age",
         nullable,
         columnScope: null,
-        type: 'scalarType',
+        type: "scalarType",
         scalarType: {
             longID: false,
             physicalType: scalarType,
             logicalType: null,
-            type: 'physicalType'
+            type: "physicalType",
         },
-        complexType: null
+        complexType: null,
     };
 }
 // Helper: Setup stream metadata mock
@@ -62,81 +62,65 @@ function mockRleStreamMetadata(byteLength = TEST_DATA.BYTE_LENGTH, numValues = T
 }
 // Helper: Mock integer decoders (INT_32 or INT_64)
 function mockIntegerDecoder(scalarType) {
-    vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-        .mockReturnValue(VectorType.FLAT);
+    vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
     if (scalarType === ScalarType.INT_64 || scalarType === ScalarType.UINT_64) {
-        vi.spyOn(IntegerStreamDecoder, 'decodeLongStream')
-            .mockReturnValue(new BigInt64Array([100n, 200n, 300n]));
+        vi.spyOn(IntegerStreamDecoder, "decodeLongStream").mockReturnValue(new BigInt64Array([100n, 200n, 300n]));
     }
     else {
-        vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-            .mockReturnValue(new Int32Array([100, 200, 300]));
+        vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array([100, 200, 300]));
     }
 }
 // Helper: Mock integer sequence decoders
 function mockIntegerSequenceDecoder(scalarType) {
-    vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-        .mockReturnValue(VectorType.SEQUENCE);
+    vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.SEQUENCE);
     if (scalarType === ScalarType.INT_64 || scalarType === ScalarType.UINT_64) {
-        vi.spyOn(IntegerStreamDecoder, 'decodeSequenceLongStream')
-            .mockReturnValue([10n, 20n]);
+        vi.spyOn(IntegerStreamDecoder, "decodeSequenceLongStream").mockReturnValue([10n, 20n]);
     }
     else {
-        vi.spyOn(IntegerStreamDecoder, 'decodeSequenceIntStream')
-            .mockReturnValue([10, 20]);
+        vi.spyOn(IntegerStreamDecoder, "decodeSequenceIntStream").mockReturnValue([10, 20]);
     }
 }
 // Helper: Mock integer const decoders
 function mockIntegerConstDecoder(scalarType) {
-    vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-        .mockReturnValue(VectorType.CONST);
+    vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.CONST);
     if (scalarType === ScalarType.INT_64 || scalarType === ScalarType.UINT_64) {
-        vi.spyOn(IntegerStreamDecoder, 'decodeConstLongStream')
-            .mockReturnValue(42n);
+        vi.spyOn(IntegerStreamDecoder, "decodeConstLongStream").mockReturnValue(42n);
     }
     else {
-        vi.spyOn(IntegerStreamDecoder, 'decodeConstIntStream')
-            .mockReturnValue(42);
+        vi.spyOn(IntegerStreamDecoder, "decodeConstIntStream").mockReturnValue(42);
     }
 }
 // Helper: Mock float decoders (FLOAT or DOUBLE)
 function mockFloatDecoder(scalarType) {
     if (scalarType === ScalarType.FLOAT) {
-        vi.spyOn(decodingUtils, 'decodeFloatsLE')
-            .mockReturnValue(new Float32Array([100.5, 200.5, 300.5]));
+        vi.spyOn(decodingUtils, "decodeFloatsLE").mockReturnValue(new Float32Array([100.5, 200.5, 300.5]));
     }
     else if (scalarType === ScalarType.DOUBLE) {
-        vi.spyOn(decodingUtils, 'decodeDoublesLE')
-            .mockReturnValue(new Float64Array([100.5, 200.5, 300.5]));
+        vi.spyOn(decodingUtils, "decodeDoublesLE").mockReturnValue(new Float64Array([100.5, 200.5, 300.5]));
     }
 }
 // Helper: Mock nullable float decoders
 function mockNullableFloatDecoder(scalarType) {
     if (scalarType === ScalarType.FLOAT) {
-        vi.spyOn(decodingUtils, 'decodeNullableFloatsLE')
-            .mockReturnValue(new Float32Array([100.5, 200.5, 300.5]));
+        vi.spyOn(decodingUtils, "decodeNullableFloatsLE").mockReturnValue(new Float32Array([100.5, 200.5, 300.5]));
     }
     else if (scalarType === ScalarType.DOUBLE) {
-        vi.spyOn(decodingUtils, 'decodeNullableDoublesLE')
-            .mockReturnValue(new Float64Array([100.5, 200.5, 300.5]));
+        vi.spyOn(decodingUtils, "decodeNullableDoublesLE").mockReturnValue(new Float64Array([100.5, 200.5, 300.5]));
     }
 }
 // Helper: Mock nullable integer decoders
 function mockNullableIntegerDecoder(scalarType) {
-    vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-        .mockReturnValue(VectorType.FLAT);
+    vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
     if (scalarType === ScalarType.INT_64 || scalarType === ScalarType.UINT_64) {
-        vi.spyOn(IntegerStreamDecoder, 'decodeNullableLongStream')
-            .mockReturnValue(new BigInt64Array([100n, 200n, 300n]));
+        vi.spyOn(IntegerStreamDecoder, "decodeNullableLongStream").mockReturnValue(new BigInt64Array([100n, 200n, 300n]));
     }
     else {
-        vi.spyOn(IntegerStreamDecoder, 'decodeNullableIntStream')
-            .mockReturnValue(new Int32Array([100, 200, 300]));
+        vi.spyOn(IntegerStreamDecoder, "decodeNullableIntStream").mockReturnValue(new Int32Array([100, 200, 300]));
     }
 }
 // Helper: Setup nullable column with separate nullability stream
 function setupNullableStreamMocks() {
-    const metadataSpy = vi.spyOn(StreamMetadataDecoder, 'decode');
+    const metadataSpy = vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata");
     // First call: nullability stream
     metadataSpy.mockReturnValueOnce({
         byteLength: TEST_DATA.NULLABILITY_BYTE_LENGTH,
@@ -148,29 +132,28 @@ function setupNullableStreamMocks() {
     // Subsequent calls: data stream
     metadataSpy.mockReturnValue(mockStreamMetadata());
     // Mock the nullability bitmap decoding
-    vi.spyOn(decodingUtils, 'decodeBooleanRle')
-        .mockReturnValue(new Uint8Array([0b00000111]));
+    vi.spyOn(decodingUtils, "decodeBooleanRle").mockReturnValue(new Uint8Array([0b00000111]));
 }
-describe('decodePropertyColumn', () => {
+describe("decodePropertyColumn", () => {
     afterEach(() => vi.restoreAllMocks());
-    describe('Number Columns - Non-Nullable - Signed Types', () => {
+    describe("Number Columns - Non-Nullable - Signed Types", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.INT_32,
                 vectorClass: IntFlatVector,
                 mockFn: mockIntegerDecoder,
-                testName: 'INT_32'
+                testName: "INT_32",
             },
             {
                 scalarType: ScalarType.INT_64,
                 vectorClass: LongFlatVector,
                 mockFn: mockIntegerDecoder,
-                testName: 'INT_64'
-            }
+                testName: "INT_64",
+            },
         ];
-        it.each(numberTypes)('should decode $testName column', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode $testName column", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             mockFn(scalarType);
             const column = createColumn(scalarType, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -179,28 +162,28 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
             expect(result.dataBuffer).toHaveLength(TEST_DATA.NUM_VALUES);
         });
     });
-    describe('Number Columns - Non-Nullable - Unsigned Types', () => {
+    describe("Number Columns - Non-Nullable - Unsigned Types", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.UINT_32,
                 vectorClass: IntFlatVector,
                 mockFn: mockIntegerDecoder,
-                testName: 'UINT_32'
+                testName: "UINT_32",
             },
             {
                 scalarType: ScalarType.UINT_64,
                 vectorClass: LongFlatVector,
                 mockFn: mockIntegerDecoder,
-                testName: 'UINT_64'
-            }
+                testName: "UINT_64",
+            },
         ];
-        it.each(numberTypes)('should decode $testName column', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode $testName column", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             mockFn(scalarType);
             const column = createColumn(scalarType, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -209,16 +192,16 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
             expect(result.dataBuffer).toHaveLength(TEST_DATA.NUM_VALUES);
         });
     });
-    describe('Number Columns - Nullable - Signed Types', () => {
+    describe("Number Columns - Nullable - Signed Types", () => {
         const numberTypes = [
-            { scalarType: ScalarType.INT_32, mockFn: mockNullableIntegerDecoder, testName: 'INT_32' },
-            { scalarType: ScalarType.INT_64, mockFn: mockNullableIntegerDecoder, testName: 'INT_64' }
+            { scalarType: ScalarType.INT_32, mockFn: mockNullableIntegerDecoder, testName: "INT_32" },
+            { scalarType: ScalarType.INT_64, mockFn: mockNullableIntegerDecoder, testName: "INT_64" },
         ];
-        it.each(numberTypes)('should decode nullable $testName column with null mask', ({ scalarType, mockFn }) => {
+        it.each(numberTypes)("should decode nullable $testName column with null mask", ({ scalarType, mockFn }) => {
             // Arrange
             setupNullableStreamMocks();
             mockFn(scalarType);
@@ -229,15 +212,15 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 2, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeDefined();
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('Number Columns - Nullable - Unsigned Types', () => {
+    describe("Number Columns - Nullable - Unsigned Types", () => {
         const numberTypes = [
-            { scalarType: ScalarType.UINT_32, mockFn: mockNullableIntegerDecoder, testName: 'UINT_32' },
-            { scalarType: ScalarType.UINT_64, mockFn: mockNullableIntegerDecoder, testName: 'UINT_64' }
+            { scalarType: ScalarType.UINT_32, mockFn: mockNullableIntegerDecoder, testName: "UINT_32" },
+            { scalarType: ScalarType.UINT_64, mockFn: mockNullableIntegerDecoder, testName: "UINT_64" },
         ];
-        it.each(numberTypes)('should decode nullable $testName column with null mask', ({ scalarType, mockFn }) => {
+        it.each(numberTypes)("should decode nullable $testName column with null mask", ({ scalarType, mockFn }) => {
             // Arrange
             setupNullableStreamMocks();
             mockFn(scalarType);
@@ -248,27 +231,27 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 2, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeDefined();
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('Integer Vector Encoding Types - SEQUENCE', () => {
+    describe("Integer Vector Encoding Types - SEQUENCE", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.INT_32,
                 vectorClass: IntSequenceVector,
                 mockFn: mockIntegerSequenceDecoder,
-                testName: 'INT_32'
+                testName: "INT_32",
             },
             {
                 scalarType: ScalarType.INT_64,
                 vectorClass: LongSequenceVector,
                 mockFn: mockIntegerSequenceDecoder,
-                testName: 'INT_64'
-            }
+                testName: "INT_64",
+            },
         ];
-        it.each(numberTypes)('should decode $testName with SEQUENCE encoding', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode $testName with SEQUENCE encoding", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockRleStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockRleStreamMetadata());
             mockFn(scalarType);
             const column = createColumn(scalarType, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -277,27 +260,27 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('Integer Vector Encoding Types - CONST', () => {
+    describe("Integer Vector Encoding Types - CONST", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.INT_32,
                 vectorClass: IntConstVector,
                 mockFn: mockIntegerConstDecoder,
-                testName: 'INT_32'
+                testName: "INT_32",
             },
             {
                 scalarType: ScalarType.INT_64,
                 vectorClass: LongConstVector,
                 mockFn: mockIntegerConstDecoder,
-                testName: 'INT_64'
-            }
+                testName: "INT_64",
+            },
         ];
-        it.each(numberTypes)('should decode $testName with CONST encoding', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode $testName with CONST encoding", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             mockFn(scalarType);
             const column = createColumn(scalarType, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -306,27 +289,27 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('Float Columns - Non-Nullable', () => {
+    describe("Float Columns - Non-Nullable", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.FLOAT,
                 vectorClass: FloatFlatVector,
                 mockFn: mockFloatDecoder,
-                testName: 'FLOAT'
+                testName: "FLOAT",
             },
             {
                 scalarType: ScalarType.DOUBLE,
                 vectorClass: DoubleFlatVector,
                 mockFn: mockFloatDecoder,
-                testName: 'DOUBLE'
-            }
+                testName: "DOUBLE",
+            },
         ];
-        it.each(numberTypes)('should decode $testName column', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode $testName column", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             mockFn(scalarType);
             const column = createColumn(scalarType, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -335,26 +318,26 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
             expect(result.dataBuffer).toHaveLength(TEST_DATA.NUM_VALUES);
         });
     });
-    describe('Float Columns - Nullable', () => {
+    describe("Float Columns - Nullable", () => {
         const numberTypes = [
             {
                 scalarType: ScalarType.FLOAT,
                 vectorClass: FloatFlatVector,
                 mockFn: mockNullableFloatDecoder,
-                testName: 'FLOAT'
+                testName: "FLOAT",
             },
             {
                 scalarType: ScalarType.DOUBLE,
                 vectorClass: DoubleFlatVector,
                 mockFn: mockNullableFloatDecoder,
-                testName: 'DOUBLE'
-            }
+                testName: "DOUBLE",
+            },
         ];
-        it.each(numberTypes)('should decode nullable $testName column with null mask', ({ scalarType, vectorClass, mockFn }) => {
+        it.each(numberTypes)("should decode nullable $testName column with null mask", ({ scalarType, vectorClass, mockFn }) => {
             // Arrange
             setupNullableStreamMocks();
             mockFn(scalarType);
@@ -365,15 +348,14 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 2, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(vectorClass);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('Boolean Columns', () => {
-        it('should decode non-nullable BOOLEAN column', () => {
+    describe("Boolean Columns", () => {
+        it("should decode non-nullable BOOLEAN column", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            vi.spyOn(decodingUtils, 'decodeBooleanRle')
-                .mockReturnValue(new Uint8Array([0b00000111]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            vi.spyOn(decodingUtils, "decodeBooleanRle").mockReturnValue(new Uint8Array([0b00000111]));
             const column = createColumn(ScalarType.BOOLEAN, false);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -381,13 +363,12 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(BooleanFlatVector);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
-        it('should decode nullable BOOLEAN column with null mask', () => {
+        it("should decode nullable BOOLEAN column with null mask", () => {
             // Arrange
             setupNullableStreamMocks();
-            vi.spyOn(decodingUtils, 'decodeNullableBooleanRle')
-                .mockReturnValue(new Uint8Array([0b00000111]));
+            vi.spyOn(decodingUtils, "decodeNullableBooleanRle").mockReturnValue(new Uint8Array([0b00000111]));
             const column = createColumn(ScalarType.BOOLEAN, true);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -395,20 +376,19 @@ describe('decodePropertyColumn', () => {
             const result = decodePropertyColumn(data, offset, column, 2, TEST_DATA.NUM_VALUES);
             // Assert
             expect(result).toBeInstanceOf(BooleanFlatVector);
-            expect(result._name).toBe('age');
+            expect(result._name).toBe("age");
         });
     });
-    describe('String Columns - Nullable', () => {
+    describe("String Columns - Nullable", () => {
         const streamConfigs = [
-            { totalStreams: 2, description: 'single data stream' },
-            { totalStreams: 4, description: 'multiple data streams' }
+            { totalStreams: 2, description: "single data stream" },
+            { totalStreams: 4, description: "multiple data streams" },
         ];
-        it.each(streamConfigs)('should decode nullable STRING with $description', ({ totalStreams }) => {
+        it.each(streamConfigs)("should decode nullable STRING with $description", ({ totalStreams }) => {
             // Arrange
             setupNullableStreamMocks();
-            const mockStringVector = { name: 'age' };
-            const stringDecodeSpy = vi.spyOn(StringDecoder, 'decode')
-                .mockReturnValue(mockStringVector);
+            const mockStringVector = { name: "age" };
+            const stringDecodeSpy = vi.spyOn(StringDecoder, "decodeString").mockReturnValue(mockStringVector);
             const column = createColumn(ScalarType.STRING, true);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -418,13 +398,13 @@ describe('decodePropertyColumn', () => {
             expect(result.name).toBe(mockStringVector.name);
         });
     });
-    describe('Column Filtering', () => {
-        it('should return null when column NOT in propertyColumnNames filter', () => {
+    describe("Column Filtering", () => {
+        it("should return null when column NOT in propertyColumnNames filter", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            const skipColumnSpy = vi.spyOn(decodingUtils, 'skipColumn');
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            const skipColumnSpy = vi.spyOn(decodingUtils, "skipColumn");
             const column = createColumn(ScalarType.STRING);
-            const filterList = new Set(['name', 'value']);
+            const filterList = new Set(["name", "value"]);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
             // Act
@@ -433,13 +413,12 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeNull();
             expect(skipColumnSpy).toHaveBeenCalledWith(1, data, offset);
         });
-        it('should decode column when it IS in propertyColumnNames filter', () => {
+        it("should decode column when it IS in propertyColumnNames filter", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            vi.spyOn(decodingUtils, 'decodeBooleanRle')
-                .mockReturnValue(new Uint8Array([0b00000111]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            vi.spyOn(decodingUtils, "decodeBooleanRle").mockReturnValue(new Uint8Array([0b00000111]));
             const column = createColumn(ScalarType.BOOLEAN);
-            const filterList = new Set(['age', 'name']);
+            const filterList = new Set(["age", "name"]);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
             // Act
@@ -447,11 +426,10 @@ describe('decodePropertyColumn', () => {
             // Assert
             expect(result).toBeInstanceOf(BooleanFlatVector);
         });
-        it('should ignore filter when propertyColumnNames is undefined', () => {
+        it("should ignore filter when propertyColumnNames is undefined", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            vi.spyOn(decodingUtils, 'decodeBooleanRle')
-                .mockReturnValue(new Uint8Array([0b00000111]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            vi.spyOn(decodingUtils, "decodeBooleanRle").mockReturnValue(new Uint8Array([0b00000111]));
             const column = createColumn(ScalarType.BOOLEAN);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -460,10 +438,10 @@ describe('decodePropertyColumn', () => {
             // Assert
             expect(result).toBeInstanceOf(BooleanFlatVector);
         });
-        it('should handle empty filter set', () => {
+        it("should handle empty filter set", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            const skipColumnSpy = vi.spyOn(decodingUtils, 'skipColumn');
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            const skipColumnSpy = vi.spyOn(decodingUtils, "skipColumn");
             const column = createColumn(ScalarType.BOOLEAN);
             const filterList = new Set();
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -475,15 +453,12 @@ describe('decodePropertyColumn', () => {
             expect(skipColumnSpy).toHaveBeenCalled();
         });
     });
-    describe('Edge Cases', () => {
-        it('should handle single value column', () => {
+    describe("Edge Cases", () => {
+        it("should handle single value column", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode')
-                .mockReturnValue(mockStreamMetadata(12, 1));
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(new Int32Array([42]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata(12, 1));
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array([42]));
             const column = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -493,19 +468,16 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeInstanceOf(IntFlatVector);
             expect(result.dataBuffer).toHaveLength(1);
         });
-        it('should handle large column with many values', () => {
+        it("should handle large column with many values", () => {
             // Arrange
             const largeNumValues = 100000;
-            vi.spyOn(StreamMetadataDecoder, 'decode')
-                .mockReturnValue(mockStreamMetadata(400000, largeNumValues));
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata(400000, largeNumValues));
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
             const largeArray = new Int32Array(largeNumValues);
             for (let i = 0; i < largeNumValues; i++) {
                 largeArray[i] = i;
             }
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(largeArray);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(largeArray);
             const column = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -515,14 +487,14 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeInstanceOf(IntFlatVector);
             expect(result.dataBuffer).toHaveLength(largeNumValues);
         });
-        it('should handle zero numValues gracefully', () => {
+        it("should handle zero numValues gracefully", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode')
-                .mockReturnValue({ ...mockStreamMetadata(), numValues: 0 });
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(new Int32Array(0));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue({
+                ...mockStreamMetadata(),
+                numValues: 0,
+            });
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array(0));
             const column = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -532,14 +504,11 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeInstanceOf(IntFlatVector);
             expect(result.dataBuffer).toHaveLength(0);
         });
-        it('should handle multiple sequential columns with offset advancement', () => {
+        it("should handle multiple sequential columns with offset advancement", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode')
-                .mockReturnValue(mockStreamMetadata(12, 3));
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(new Int32Array([100, 200, 300]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata(12, 3));
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array([100, 200, 300]));
             const column1 = createColumn(ScalarType.INT_32);
             const column2 = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -554,15 +523,15 @@ describe('decodePropertyColumn', () => {
             expect(result2).toBeInstanceOf(IntFlatVector);
             expect(offsetAfterSecond).toEqual(offsetAfterFirst);
         });
-        it('should handle non-scalar column type returning null', () => {
+        it("should handle non-scalar column type returning null", () => {
             // Arrange
             const column = {
-                name: 'complex',
+                name: "complex",
                 nullable: false,
                 columnScope: null,
-                type: 'complexType',
-                complexType: { type: 'arrayType' },
-                scalarType: null
+                type: "complexType",
+                complexType: { type: "arrayType" },
+                scalarType: null,
             };
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -572,14 +541,12 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeNull();
         });
     });
-    describe('Offset Management', () => {
-        it('should handle offset at non-zero starting position', () => {
+    describe("Offset Management", () => {
+        it("should handle offset at non-zero starting position", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(new Int32Array([100, 200, 300]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array([100, 200, 300]));
             const column = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const startOffset = 50;
@@ -590,15 +557,16 @@ describe('decodePropertyColumn', () => {
             expect(result).toBeInstanceOf(IntFlatVector);
             expect(offset.get()).toEqual(startOffset);
         });
-        it('should correctly skip columns with filterList and advance offset', () => {
+        it("should correctly skip columns with filterList and advance offset", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            const skipColumnSpy = vi.spyOn(decodingUtils, 'skipColumn')
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            const skipColumnSpy = vi
+                .spyOn(decodingUtils, "skipColumn")
                 .mockImplementation((numStreams, data, offset) => {
                 offset.add(12 * numStreams); // Simulate skipping
             });
             const column = createColumn(ScalarType.INT_32);
-            const filterList = new Set(['other_column']);
+            const filterList = new Set(["other_column"]);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
             const startOffset = offset.get();
@@ -610,14 +578,12 @@ describe('decodePropertyColumn', () => {
             expect(skipColumnSpy).toHaveBeenCalledWith(3, data, offset);
         });
     });
-    describe('Type Consistency Checks', () => {
-        it('should preserve column metadata in returned vector', () => {
+    describe("Type Consistency Checks", () => {
+        it("should preserve column metadata in returned vector", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
-            vi.spyOn(IntegerStreamDecoder, 'getVectorType')
-                .mockReturnValue(VectorType.FLAT);
-            vi.spyOn(IntegerStreamDecoder, 'decodeIntStream')
-                .mockReturnValue(new Int32Array([10, 20, 30]));
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
+            vi.spyOn(IntegerStreamDecoder, "getVectorType").mockReturnValue(VectorType.FLAT);
+            vi.spyOn(IntegerStreamDecoder, "decodeIntStream").mockReturnValue(new Int32Array([10, 20, 30]));
             const column = createColumn(ScalarType.INT_32);
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -626,14 +592,11 @@ describe('decodePropertyColumn', () => {
             // Assert
             expect(result._name).toBe(column.name);
         });
-        it('should handle all signed and unsigned type combinations', () => {
+        it("should handle all signed and unsigned type combinations", () => {
             // Arrange
-            const types = [
-                ScalarType.INT_32, ScalarType.UINT_32,
-                ScalarType.INT_64, ScalarType.UINT_64
-            ];
-            types.forEach(scalarType => {
-                vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            const types = [ScalarType.INT_32, ScalarType.UINT_32, ScalarType.INT_64, ScalarType.UINT_64];
+            types.forEach((scalarType) => {
+                vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
                 mockIntegerDecoder(scalarType);
                 const column = createColumn(scalarType, false);
                 const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
@@ -642,15 +605,15 @@ describe('decodePropertyColumn', () => {
                 const result = decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
                 // Assert
                 expect(result).toBeDefined();
-                expect(result._name).toBe('age');
+                expect(result._name).toBe("age");
                 vi.restoreAllMocks();
             });
         });
     });
-    describe('Error Scenarios', () => {
-        it('should handle invalid scalar type gracefully', () => {
+    describe("Error Scenarios", () => {
+        it("should handle invalid scalar type gracefully", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             const column = createColumn(999); // Invalid type
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);
@@ -659,16 +622,16 @@ describe('decodePropertyColumn', () => {
                 decodePropertyColumn(data, offset, column, 1, TEST_DATA.NUM_VALUES);
             }).toThrow();
         });
-        it('should handle mismatched numStreams for string type', () => {
+        it("should handle mismatched numStreams for string type", () => {
             // Arrange
-            vi.spyOn(StreamMetadataDecoder, 'decode').mockReturnValue(mockStreamMetadata());
+            vi.spyOn(StreamMetadataDecoder, "decodeStreamMetadata").mockReturnValue(mockStreamMetadata());
             const column = {
-                name: 'stringCol',
+                name: "stringCol",
                 nullable: false,
                 columnScope: null,
-                type: 'stringType',
+                type: "stringType",
                 scalarType: null,
-                complexType: null
+                complexType: null,
             };
             const data = new Uint8Array(TEST_DATA.BUFFER_SIZE);
             const offset = new IntWrapper(0);