From b3cd5b2c6afe27a39266c3d81d373fb9c6a18eeb Mon Sep 17 00:00:00 2001
From: Dominik Moritz <domoritz@gmail.com>
Date: Sat, 2 Dec 2023 13:36:15 -0500
Subject: [PATCH] Get rid of toNumber

---
 js/src/builder/binary.ts    |  4 ++--
 js/src/builder/buffer.ts    |  9 +--------
 js/src/builder/largeutf8.ts | 20 ++++++++++++++++++--
 js/src/type.ts              | 10 +++++-----
 4 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/js/src/builder/binary.ts b/js/src/builder/binary.ts
index bcdefab9d3e66..3c12ddf34abb0 100644
--- a/js/src/builder/binary.ts
+++ b/js/src/builder/binary.ts
@@ -42,11 +42,11 @@ export class BinaryBuilder<TNull = any> extends VariableWidthBuilder<Binary, TNu
         let offset = 0;
         for (const [index, value] of pending) {
             if (value === undefined) {
-                offsets.set(index, offsets.toNumber(0));
+                offsets.set(index, 0);
             } else {
                 const length = value.length;
                 data.set(value, offset);
-                offsets.set(index, offsets.toNumber(length));
+                offsets.set(index, length);
                 offset += length;
             }
         }
diff --git a/js/src/builder/buffer.ts b/js/src/builder/buffer.ts
index c0226c2168786..bd0c3b3c53fa2 100644
--- a/js/src/builder/buffer.ts
+++ b/js/src/builder/buffer.ts
@@ -18,7 +18,6 @@
 import { memcpy } from '../util/buffer.js';
 import { TypedArray, BigIntArray, ArrayCtor } from '../interfaces.js';
 import { DataType } from '../type.js';
-import { bigIntToNumber } from '../util/bigint.js';
 
 /** @ignore */
 const roundLengthUpToNearest64Bytes = (len: number, BPE: number) => ((((Math.ceil(len) * BPE) + 63) & ~63) || 64) / BPE;
@@ -129,14 +128,8 @@ export class BitmapBufferBuilder extends DataBufferBuilder<Uint8Array> {
 export class OffsetsBufferBuilder<T extends DataType> extends DataBufferBuilder<T['TOffsetArray']> {
     constructor(type: T) {
         super(new type.OffsetArrayType(1), 1);
-        this.toNumber = type.OffsetArrayType === BigInt64Array ? BigInt : bigIntToNumber as any;
     }
 
-    /**
-     * The correct number constructor for the buffer type.
-     */
-    public toNumber: ((number: number | bigint) => T['TOffsetArray'] extends BigInt64Array ? bigint : number);
-
     public append(value: T['TOffsetArray'][0]) {
         return this.set(this.length - 1, value);
     }
@@ -151,7 +144,7 @@ export class OffsetsBufferBuilder<T extends DataType> extends DataBufferBuilder<
     }
     public flush(length = this.length - 1) {
         if (length > this.length) {
-            this.set(length - 1, this.toNumber(0));
+            this.set(length - 1, this.BYTES_PER_ELEMENT > 4 ? 0n : 0);
         }
         return super.flush(length + 1);
     }
diff --git a/js/src/builder/largeutf8.ts b/js/src/builder/largeutf8.ts
index 002bb8265a73d..0de97a4586e6e 100644
--- a/js/src/builder/largeutf8.ts
+++ b/js/src/builder/largeutf8.ts
@@ -38,7 +38,23 @@ export class LargeUtf8Builder<TNull = any> extends VariableWidthBuilder<LargeUtf
         return super.setValue(index, encodeUtf8(value) as any);
     }
     // @ts-ignore
-    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number): void { }
+    // TODO: move to largeBinaryBuilder when implemented
+    // protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number): void { }
+    protected _flushPending(pending: Map<number, Uint8Array | undefined>, pendingLength: number) {
+        const offsets = this._offsets;
+        const data = this._values.reserve(pendingLength).buffer;
+        let offset = 0;
+        for (const [index, value] of pending) {
+            if (value === undefined) {
+                offsets.set(index, 0n);
+            } else {
+                const length = value.length;
+                data.set(value, offset);
+                offsets.set(index, BigInt(length));
+                offset += length;
+            }
+        }
+    }
 }
 
-(LargeUtf8Builder.prototype as any)._flushPending = (BinaryBuilder.prototype as any)._flushPending;
+// (LargeUtf8Builder.prototype as any)._flushPending = (LargeBinaryBuilder.prototype as any)._flushPending;
diff --git a/js/src/type.ts b/js/src/type.ts
index b66b277a19d0c..6223d0316f17a 100644
--- a/js/src/type.ts
+++ b/js/src/type.ts
@@ -236,7 +236,7 @@ Object.defineProperty(Float32.prototype, 'ArrayType', { value: Float32Array });
 Object.defineProperty(Float64.prototype, 'ArrayType', { value: Float64Array });
 
 /** @ignore */
-export interface Binary extends DataType<Type.Binary> { TArray: Uint8Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array> }
+export interface Binary extends DataType<Type.Binary> { TArray: Uint8Array; TOffsetArray: Int32Array; TValue: Uint8Array; ArrayType: TypedArrayConstructor<Uint8Array>; OffsetArrayType: TypedArrayConstructor<Int32Array> }
 /** @ignore */
 export class Binary extends DataType<Type.Binary> {
     constructor() {
@@ -478,13 +478,13 @@ export class Duration<T extends Durations = Durations> extends DataType<T> {
 }
 
 /** @ignore */
-export class DurationSecond extends Duration<Type.DurationSecond> { constructor() { super(TimeUnit.SECOND); }}
+export class DurationSecond extends Duration<Type.DurationSecond> { constructor() { super(TimeUnit.SECOND); } }
 /** @ignore */
-export class DurationMillisecond extends Duration<Type.DurationMillisecond> { constructor() { super(TimeUnit.MILLISECOND); }}
+export class DurationMillisecond extends Duration<Type.DurationMillisecond> { constructor() { super(TimeUnit.MILLISECOND); } }
 /** @ignore */
-export class DurationMicrosecond extends Duration<Type.DurationMicrosecond> { constructor() { super(TimeUnit.MICROSECOND); }}
+export class DurationMicrosecond extends Duration<Type.DurationMicrosecond> { constructor() { super(TimeUnit.MICROSECOND); } }
 /** @ignore */
-export class DurationNanosecond extends Duration<Type.DurationNanosecond> { constructor() { super(TimeUnit.NANOSECOND); }}
+export class DurationNanosecond extends Duration<Type.DurationNanosecond> { constructor() { super(TimeUnit.NANOSECOND); } }
 
 
 /** @ignore */