Remove commented out code

Author: domoritz

js/src/Arrow.dom.ts

@@ -56,39 +56,16 @@ export {
     FixedSizeList,
     Map_, MapRow,
     Table,
-    // Column,
     Schema, Field,
     Visitor,
     Vector, makeVector, vectorFromArray,
-    // BaseVector,
-    // BinaryVector,
-    // BoolVector,
-    // Chunked,
-    // DateVector, DateDayVector, DateMillisecondVector,
-    // DecimalVector,
-    // DictionaryVector,
-    // FixedSizeBinaryVector,
-    // FixedSizeListVector,
-    // FloatVector, Float16Vector, Float32Vector, Float64Vector,
-    // IntervalVector, IntervalDayTimeVector, IntervalYearMonthVector,
-    // IntVector, Int8Vector, Int16Vector, Int32Vector, Int64Vector, Uint8Vector, Uint16Vector, Uint32Vector, Uint64Vector,
-    // ListVector,
-    // MapVector,
-    // NullVector,
-    // StructVector,
-    // TimestampVector, TimestampSecondVector, TimestampMillisecondVector, TimestampMicrosecondVector, TimestampNanosecondVector,
-    // TimeVector, TimeSecondVector, TimeMillisecondVector, TimeMicrosecondVector, TimeNanosecondVector,
-    // UnionVector, DenseUnionVector, SparseUnionVector,
-    // Utf8Vector,
     ByteStream, AsyncByteStream, AsyncByteQueue, ReadableSource, WritableSink,
     RecordBatchReader, RecordBatchFileReader, RecordBatchStreamReader, AsyncRecordBatchFileReader, AsyncRecordBatchStreamReader,
     RecordBatchWriter, RecordBatchFileWriter, RecordBatchStreamWriter, RecordBatchJSONWriter,
     MessageReader, AsyncMessageReader, JSONMessageReader,
     Message,
     RecordBatch,
     ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions,
-    // DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc,
-    // predicate,
     util,
     Builder,
     BinaryBuilder,

js/src/Arrow.ts

@@ -88,18 +88,15 @@ export { MessageReader, AsyncMessageReader, JSONMessageReader } from './ipc/mess
 export { Message } from './ipc/metadata/message';
 export { RecordBatch } from './recordbatch';
 export { ArrowJSONLike, FileHandle, Readable, Writable, ReadableWritable, ReadableDOMStreamOptions } from './io/interfaces';
-// export { DataFrame, FilteredDataFrame, CountByResult, BindFunc, NextFunc } from './compute/dataframe';
 
 import * as util_bn_ from './util/bn';
 import * as util_int_ from './util/int';
 import * as util_bit_ from './util/bit';
 import * as util_math_ from './util/math';
 import * as util_buffer_ from './util/buffer';
 import * as util_vector_ from './util/vector';
-// import * as predicate from './compute/predicate';
 import { compareSchemas, compareFields, compareTypes } from './visitor/typecomparator';
 
-// export { predicate };
 /** @ignore */
 export const util = {
     ...util_bn_,

js/src/util/bn.ts

@@ -36,10 +36,10 @@ function BigNum(this: any, x: any, ...xs: any) {
 }
 
 BigNum.prototype[isArrowBigNumSymbol] = true;
-BigNum.prototype.toJSON = function<T extends BN<BigNumArray>>(this: T) { return `"${bignumToString(this)}"`; };
-BigNum.prototype.valueOf = function<T extends BN<BigNumArray>>(this: T) { return bignumToNumber(this); };
-BigNum.prototype.toString = function<T extends BN<BigNumArray>>(this: T) { return bignumToString(this); };
-BigNum.prototype[Symbol.toPrimitive] = function<T extends BN<BigNumArray>>(this: T, hint: 'string' | 'number' | 'default' = 'default') {
+BigNum.prototype.toJSON = function <T extends BN<BigNumArray>>(this: T) { return `"${bignumToString(this)}"`; };
+BigNum.prototype.valueOf = function <T extends BN<BigNumArray>>(this: T) { return bignumToNumber(this); };
+BigNum.prototype.toString = function <T extends BN<BigNumArray>>(this: T) { return bignumToString(this); };
+BigNum.prototype[Symbol.toPrimitive] = function <T extends BN<BigNumArray>>(this: T, hint: 'string' | 'number' | 'default' = 'default') {
     switch (hint) {
         case 'number': return bignumToNumber(this);
         case 'string': return bignumToString(this);
@@ -53,7 +53,7 @@ BigNum.prototype[Symbol.toPrimitive] = function<T extends BN<BigNumArray>>(this:
 type TypedArrayConstructorArgs =
     [number | void] |
     [Iterable<number> | Iterable<bigint>] |
-    [ArrayBufferLike, number | void, number | void] ;
+    [ArrayBufferLike, number | void, number | void];
 
 /** @ignore */
 function SignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }
@@ -62,12 +62,12 @@ function UnsignedBigNum(this: any, ...args: TypedArrayConstructorArgs) { return
 /** @ignore */
 function DecimalBigNum(this: any, ...args: TypedArrayConstructorArgs) { return BigNum.apply(this, args); }
 
-Object.setPrototypeOf(SignedBigNum.prototype,   Object.create(Int32Array.prototype));
+Object.setPrototypeOf(SignedBigNum.prototype, Object.create(Int32Array.prototype));
 Object.setPrototypeOf(UnsignedBigNum.prototype, Object.create(Uint32Array.prototype));
-Object.setPrototypeOf(DecimalBigNum.prototype,  Object.create(Uint32Array.prototype));
-Object.assign(SignedBigNum.prototype,   BigNum.prototype, { 'constructor': SignedBigNum,   'signed': true,  'TypedArray': Int32Array,  'BigIntArray': BigInt64Array  });
+Object.setPrototypeOf(DecimalBigNum.prototype, Object.create(Uint32Array.prototype));
+Object.assign(SignedBigNum.prototype, BigNum.prototype, { 'constructor': SignedBigNum, 'signed': true, 'TypedArray': Int32Array, 'BigIntArray': BigInt64Array });
 Object.assign(UnsignedBigNum.prototype, BigNum.prototype, { 'constructor': UnsignedBigNum, 'signed': false, 'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });
-Object.assign(DecimalBigNum.prototype,  BigNum.prototype, { 'constructor': DecimalBigNum,  'signed': true,  'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });
+Object.assign(DecimalBigNum.prototype, BigNum.prototype, { 'constructor': DecimalBigNum, 'signed': true, 'TypedArray': Uint32Array, 'BigIntArray': BigUint64Array });
 
 /** @ignore */
 function bignumToNumber<T extends BN<BigNumArray>>(bn: T) {
@@ -92,7 +92,7 @@ export let bignumToBigInt: { <T extends BN<BigNumArray>>(a: T): bigint };
 
 if (!BigIntAvailable) {
     bignumToString = decimalToString;
-    bignumToBigInt = <any> bignumToString;
+    bignumToBigInt = <any>bignumToString;
 } else {
     bignumToBigInt = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0] : <any>decimalToString(a));
     bignumToString = (<T extends BN<BigNumArray>>(a: T) => a.byteLength === 8 ? `${new a['BigIntArray'](a.buffer, a.byteOffset, 1)[0]}` : decimalToString(a));
@@ -123,32 +123,32 @@ export class BN<T extends BigNumArray> {
     /** @nocollapse */
     public static new<T extends BigNumArray>(num: T, isSigned?: boolean): (T & BN<T>) {
         switch (isSigned) {
-            case true: return new (<any> SignedBigNum)(num) as (T & BN<T>);
-            case false: return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
+            case true: return new (<any>SignedBigNum)(num) as (T & BN<T>);
+            case false: return new (<any>UnsignedBigNum)(num) as (T & BN<T>);
         }
         switch (num.constructor) {
             case Int8Array:
             case Int16Array:
             case Int32Array:
             case BigInt64Array:
-                return new (<any> SignedBigNum)(num) as (T & BN<T>);
+                return new (<any>SignedBigNum)(num) as (T & BN<T>);
         }
         if (num.byteLength === 16) {
-            return new (<any> DecimalBigNum)(num) as (T & BN<T>);
+            return new (<any>DecimalBigNum)(num) as (T & BN<T>);
         }
-        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
+        return new (<any>UnsignedBigNum)(num) as (T & BN<T>);
     }
     /** @nocollapse */
     public static signed<T extends IntArray>(num: T): (T & BN<T>) {
-        return new (<any> SignedBigNum)(num) as (T & BN<T>);
+        return new (<any>SignedBigNum)(num) as (T & BN<T>);
     }
     /** @nocollapse */
     public static unsigned<T extends UintArray>(num: T): (T & BN<T>) {
-        return new (<any> UnsignedBigNum)(num) as (T & BN<T>);
+        return new (<any>UnsignedBigNum)(num) as (T & BN<T>);
     }
     /** @nocollapse */
     public static decimal<T extends UintArray>(num: T): (T & BN<T>) {
-        return new (<any> DecimalBigNum)(num) as (T & BN<T>);
+        return new (<any>DecimalBigNum)(num) as (T & BN<T>);
     }
     constructor(num: T, isSigned?: boolean) {
         return BN.new(num, isSigned) as any;
@@ -158,20 +158,20 @@ export class BN<T extends BigNumArray> {
 /** @ignore */
 export interface BN<T extends BigNumArray> extends TypedArrayLike<T> {
 
-    new<T extends ArrayBufferViewInput>(buffer: T, signed?: boolean): T;
+    new <T extends ArrayBufferViewInput>(buffer: T, signed?: boolean): T;
 
     readonly signed: boolean;
     readonly TypedArray: TypedArrayConstructor<TypedArray>;
     readonly BigIntArray: BigIntArrayConstructor<BigIntArray>;
 
     [Symbol.toStringTag]:
-        'Int8Array'         |
-        'Int16Array'        |
-        'Int32Array'        |
-        'Uint8Array'        |
-        'Uint16Array'       |
-        'Uint32Array'       |
-        'Uint8ClampedArray';
+    'Int8Array' |
+    'Int16Array' |
+    'Int32Array' |
+    'Uint8Array' |
+    'Uint16Array' |
+    'Uint32Array' |
+    'Uint8ClampedArray';
 
     /**
      * Convert the bytes to their (positive) decimal representation for printing