@loaders.gl/schema 3.1.0-alpha.5 → 3.1.0-beta.1

package/dist/lib/utils/async-queue.js

@@ -0,0 +1,92 @@
+"use strict";
+// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
+// http://2ality.com/2016/10/asynchronous-iteration.html
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeAsync = void 0;
+class ArrayQueue extends Array {
+    enqueue(value) {
+        // Add at the end
+        return this.push(value);
+    }
+    dequeue() {
+        // Remove first element
+        return this.shift();
+    }
+}
+class AsyncQueue {
+    constructor() {
+        // enqueues > dequeues
+        this._values = new ArrayQueue();
+        // dequeues > enqueues
+        this._settlers = new ArrayQueue();
+        this._closed = false;
+    }
+    close() {
+        while (this._settlers.length > 0) {
+            this._settlers.dequeue().resolve({ done: true });
+        }
+        this._closed = true;
+    }
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    enqueue(value) {
+        if (this._closed) {
+            throw new Error('Closed');
+        }
+        if (this._settlers.length > 0) {
+            if (this._values.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            const settler = this._settlers.dequeue();
+            if (value instanceof Error) {
+                settler.reject(value);
+            }
+            else {
+                settler.resolve({ value });
+            }
+        }
+        else {
+            this._values.enqueue(value);
+        }
+    }
+    /**
+     * @returns a Promise for an IteratorResult
+     */
+    next() {
+        if (this._values.length > 0) {
+            const value = this._values.dequeue();
+            if (value instanceof Error) {
+                return Promise.reject(value);
+            }
+            return Promise.resolve({ value });
+        }
+        if (this._closed) {
+            if (this._settlers.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            return Promise.resolve({ done: true });
+        }
+        // Wait for new values to be enqueued
+        return new Promise((resolve, reject) => {
+            this._settlers.enqueue({ resolve, reject });
+        });
+    }
+}
+exports.default = AsyncQueue;
+/**
+ * @returns a Promise for an Array with the elements in `asyncIterable`
+ */
+async function takeAsync(asyncIterable, count = Infinity) {
+    const result = [];
+    const iterator = asyncIterable[Symbol.asyncIterator]();
+    while (result.length < count) {
+        const { value, done } = await iterator.next();
+        if (done) {
+            break;
+        }
+        result.push(value);
+    }
+    return result;
+}
+exports.takeAsync = takeAsync;

package/dist/lib/utils/row-utils.d.ts

@@ -6,3 +6,4 @@ export declare function convertToObjectRow(arrayRow: any[], headers: string[]):
 export declare function convertToArrayRow(objectRow: {
     [columnName: string]: any;
 }, headers: string[]): any[];
+//# sourceMappingURL=row-utils.d.ts.map

package/dist/lib/utils/row-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"row-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/row-utils.ts"],"names":[],"mappings":"AAAA,4CAA4C;AAC5C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,GAAG,EAAE,EACf,OAAO,EAAE,MAAM,EAAE,GAChB;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,CAY7B;AAED,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE;IAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,EACtC,OAAO,EAAE,MAAM,EAAE,GAChB,GAAG,EAAE,CAYP"}

package/dist/lib/utils/row-utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToArrayRow = exports.convertToObjectRow = void 0;
+/** Convert an object row to an array row */
+function convertToObjectRow(arrayRow, headers) {
+    if (!arrayRow) {
+        throw new Error('null row');
+    }
+    if (!headers) {
+        throw new Error('no headers');
+    }
+    const objectRow = {};
+    for (let i = 0; i < headers.length; i++) {
+        objectRow[headers[i]] = arrayRow[i];
+    }
+    return objectRow;
+}
+exports.convertToObjectRow = convertToObjectRow;
+/** Convert an object row to an array row */
+function convertToArrayRow(objectRow, headers) {
+    if (!objectRow) {
+        throw new Error('null row');
+    }
+    if (!headers) {
+        throw new Error('no headers');
+    }
+    const arrayRow = new Array(headers.length);
+    for (let i = 0; i < headers.length; i++) {
+        arrayRow[i] = objectRow[headers[i]];
+    }
+    return arrayRow;
+}
+exports.convertToArrayRow = convertToArrayRow;

package/dist/types.d.ts

@@ -5,3 +5,4 @@ export declare type BigTypedArray = TypedArray | BigInt64Array | BigUint64Array;
 export declare type NumberArray = number[] | TypedArray;
 /** Any array: typed array or js array (`any[]`) */
 export declare type AnyArray = any[] | TypedArray;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,sBAAsB;AACtB,oBAAY,UAAU,GAClB,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,GACX,UAAU,GACV,WAAW,GACX,iBAAiB,GACjB,YAAY,GACZ,YAAY,CAAC;AAEjB,oBAAY,aAAa,GAAG,UAAU,GAAG,aAAa,GAAG,cAAc,CAAC;AAExE,mDAAmD;AACnD,oBAAY,WAAW,GAAG,MAAM,EAAE,GAAG,UAAU,CAAC;AAEhD,mDAAmD;AACnD,oBAAY,QAAQ,GAAG,GAAG,EAAE,GAAG,UAAU,CAAC"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/schema",
-  "version": "3.1.0-alpha.5",
+  "version": "3.1.0-beta.1",
   "description": "Table format APIs for JSON, CSV, etc...",
   "license": "MIT",
   "publishConfig": {
@@ -29,12 +29,11 @@
   ],
   "scripts": {
     "pre-build": "npm run build-bundle",
-    "post-build": "tsc",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js"
   },
   "dependencies": {
     "@types/geojson": "^7946.0.7",
     "apache-arrow": "^4.0.0"
   },
-  "gitHead": "352241dd910a8c6307a235dadbe154ca915b885b"
+  "gitHead": "980cdefb4e8ec9ef9c951d20c78cf77777707f49"
 }

package/src/category/gis.ts

@@ -55,7 +55,6 @@ export type BinaryPolygonFeatures = BinaryPolygonGeometry & BinaryProperties;
  * Represent a collection of Features, similar to a GeoJSON FeatureCollection
  */
 export type BinaryFeatures = {
-  type?: BinaryGeometryType;
   points?: BinaryPointFeatures;
   lines?: BinaryLineFeatures;
   polygons?: BinaryPolygonFeatures;

package/src/category/mesh/deduce-mesh-schema.ts

@@ -1,5 +1,5 @@
 import {MeshAttribute, MeshAttributes} from './mesh-types';
-import {Schema, Field, FixedSizeList} from '../../lib/schema';
+import {Schema, Field, FixedSizeList} from '../../lib/schema/schema';
 import {getArrowTypeFromTypedArray} from '../../lib/arrow/arrow-like-type-utils';
 
 /**

package/src/category/mesh/mesh-types.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../../lib/schema';
+import type {Schema} from '../../lib/schema/schema';
 import type {TypedArray} from '../../types';
 import type {ColumnarTable, ArrowTable} from '../table/table-types';
 

package/src/category/table/deduce-table-schema.ts

@@ -14,7 +14,7 @@ import {
   // Utf8,
   // TimestampMillisecond,
   // Null
-} from '../../lib/schema';
+} from '../../lib/schema/schema';
 
 // const TYPED_ARRAY_TO_TYPE = {
 //   Int8Array: new Int8(),

package/src/category/table/table-types.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../../lib/schema';
+import type {Schema} from '../../lib/schema/schema';
 import type {Table as ApacheArrowTable, RecordBatch} from 'apache-arrow/Arrow.dom';
 import type {AnyArray} from '../../types';
 import type {Batch} from '../common';

package/src/index.ts

@@ -112,7 +112,7 @@ export {
   IntervalYearMonth,
   FixedSizeList,
   Struct
-} from './lib/schema';
+} from './lib/schema/schema';
 
 // EXPERIMENTAL APIs
 

package/src/lib/arrow/arrow-like-type-utils.ts

@@ -1,5 +1,15 @@
 import type {TypedArray} from '../../types';
-import {DataType, Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8} from '../schema';
+import {
+  DataType,
+  Float32,
+  Float64,
+  Int16,
+  Int32,
+  Int8,
+  Uint16,
+  Uint32,
+  Uint8
+} from '../schema/schema';
 
 export function getArrowTypeFromTypedArray(array: TypedArray): DataType {
   switch (array.constructor) {

package/src/lib/arrow/get-type-info.ts

@@ -1,4 +1,4 @@
-import {Type} from '../schema';
+import {Type} from '../schema/schema';
 import {AnyArray} from '../../types';
 
 /**

package/src/lib/batches/base-table-batch-aggregator.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../schema';
+import type {Schema} from '../schema/schema';
 import type {TableBatch} from '../../category/table/table-types';
 import {TableBatchAggregator, TableBatchOptions} from './table-batch-aggregator';
 

package/src/lib/batches/columnar-table-batch-aggregator.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../schema';
+import type {Schema} from '../schema/schema';
 import type {ColumnarTableBatch, ArrowTableBatch} from '../../category/table/table-types';
 import {TableBatchAggregator} from './table-batch-aggregator';
 

package/src/lib/batches/row-table-batch-aggregator.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../schema';
+import type {Schema} from '../schema/schema';
 import type {TableBatch} from '../../category/table/table-types';
 // import type {ArrayRowTableBatch, ObjectRowTableBatch} from '../../category/table';
 import {convertToArrayRow, convertToObjectRow} from '../utils/row-utils';

package/src/lib/batches/table-batch-aggregator.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../schema';
+import type {Schema} from '../schema/schema';
 import type {TableBatch} from '../../category/table/table-types';
 
 export interface TableBatchOptions {

package/src/lib/batches/table-batch-builder.ts

@@ -1,4 +1,4 @@
-import type {Schema} from '../schema';
+import type {Schema} from '../schema/schema';
 import type {TableBatch} from '../../category/table/table-types';
 import type {TableBatchAggregator, TableBatchConstructor} from './table-batch-aggregator';
 import BaseTableBatchAggregator from './base-table-batch-aggregator';
@@ -114,7 +114,7 @@ export default class TableBatchBuilder {
 
   // INTERNAL
 
-  _estimateRowMB(row) {
+  _estimateRowMB(row: any[] | object): number {
     return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
   }
 

package/src/lib/schema/impl/schema.ts

@@ -82,8 +82,8 @@ export default class Schema {
 }
 
 // Warn if any duplicated field names
-function checkNames(fields) {
-  const usedNames = {};
+function checkNames(fields: Field[]): void {
+  const usedNames: Record<string, boolean> = {};
   for (const field of fields) {
     if (usedNames[field.name]) {
       // eslint-disable-next-line

package/src/lib/schema/impl/type.ts

@@ -333,10 +333,10 @@ const TimeUnit = {
 };
 
 export class Time extends DataType {
-  readonly unit: number;
+  readonly unit: any;
   readonly bitWidth: number;
 
-  constructor(unit, bitWidth) {
+  constructor(unit: any, bitWidth: number) {
     super();
     this.unit = unit;
     this.bitWidth = bitWidth;

package/src/lib/schema-utils/deduce-column-type.ts

@@ -33,7 +33,9 @@
 //   TYPED_ARRAY_TO_TYPE.BigUint64Array = new Uint64();
 // }
 
-export function deduceTypeFromColumn(value) {
+export function deduceTypeFromColumn(
+  value: unknown
+): StringConstructor | DateConstructor | Float32ArrayConstructor | null {
   if (value instanceof Date) {
     return Date;
   } else if (value instanceof Number) {
@@ -44,7 +46,9 @@ export function deduceTypeFromColumn(value) {
   return null;
 }
 
-export function deduceTypeFromValue(value) {
+export function deduceTypeFromValue(
+  value: unknown
+): StringConstructor | DateConstructor | Float32ArrayConstructor | null {
   if (value instanceof Date) {
     return Date;
   } else if (value instanceof Number) {

package/src/lib/utils/async-queue.ts

@@ -2,7 +2,7 @@
 // http://2ality.com/2016/10/asynchronous-iteration.html
 
 class ArrayQueue<T> extends Array<T> {
-  enqueue(value) {
+  enqueue(value: T) {
     // Add at the end
     return this.push(value);
   }
@@ -13,15 +13,18 @@ class ArrayQueue<T> extends Array<T> {
 }
 
 export default class AsyncQueue<T> {
-  private _values: ArrayQueue<T>;
-  private _settlers: ArrayQueue<{resolve; reject}>;
+  private _values: ArrayQueue<T | Error>;
+  private _settlers: ArrayQueue<{resolve: (value: any) => void; reject: (reason?: any) => void}>;
   private _closed: boolean;
 
   constructor() {
     // enqueues > dequeues
     this._values = new ArrayQueue<T>();
     // dequeues > enqueues
-    this._settlers = new ArrayQueue<{resolve; reject}>();
+    this._settlers = new ArrayQueue<{
+      resolve: (value: any) => void;
+      reject: (reason?: any) => void;
+    }>();
     this._closed = false;
   }