@loaders.gl/schema 3.1.0-alpha.3 → 3.1.0-beta.2

package/dist/es5/lib/schema/schema.js

@@ -0,0 +1,236 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Schema", {
+  enumerable: true,
+  get: function () {
+    return _schema.default;
+  }
+});
+Object.defineProperty(exports, "Field", {
+  enumerable: true,
+  get: function () {
+    return _field.default;
+  }
+});
+Object.defineProperty(exports, "Type", {
+  enumerable: true,
+  get: function () {
+    return _type.Type;
+  }
+});
+Object.defineProperty(exports, "DataType", {
+  enumerable: true,
+  get: function () {
+    return _type.DataType;
+  }
+});
+Object.defineProperty(exports, "Null", {
+  enumerable: true,
+  get: function () {
+    return _type.Null;
+  }
+});
+Object.defineProperty(exports, "Bool", {
+  enumerable: true,
+  get: function () {
+    return _type.Bool;
+  }
+});
+Object.defineProperty(exports, "Int", {
+  enumerable: true,
+  get: function () {
+    return _type.Int;
+  }
+});
+Object.defineProperty(exports, "Int8", {
+  enumerable: true,
+  get: function () {
+    return _type.Int8;
+  }
+});
+Object.defineProperty(exports, "Int16", {
+  enumerable: true,
+  get: function () {
+    return _type.Int16;
+  }
+});
+Object.defineProperty(exports, "Int32", {
+  enumerable: true,
+  get: function () {
+    return _type.Int32;
+  }
+});
+Object.defineProperty(exports, "Int64", {
+  enumerable: true,
+  get: function () {
+    return _type.Int64;
+  }
+});
+Object.defineProperty(exports, "Uint8", {
+  enumerable: true,
+  get: function () {
+    return _type.Uint8;
+  }
+});
+Object.defineProperty(exports, "Uint16", {
+  enumerable: true,
+  get: function () {
+    return _type.Uint16;
+  }
+});
+Object.defineProperty(exports, "Uint32", {
+  enumerable: true,
+  get: function () {
+    return _type.Uint32;
+  }
+});
+Object.defineProperty(exports, "Uint64", {
+  enumerable: true,
+  get: function () {
+    return _type.Uint64;
+  }
+});
+Object.defineProperty(exports, "Float", {
+  enumerable: true,
+  get: function () {
+    return _type.Float;
+  }
+});
+Object.defineProperty(exports, "Float16", {
+  enumerable: true,
+  get: function () {
+    return _type.Float16;
+  }
+});
+Object.defineProperty(exports, "Float32", {
+  enumerable: true,
+  get: function () {
+    return _type.Float32;
+  }
+});
+Object.defineProperty(exports, "Float64", {
+  enumerable: true,
+  get: function () {
+    return _type.Float64;
+  }
+});
+Object.defineProperty(exports, "Binary", {
+  enumerable: true,
+  get: function () {
+    return _type.Binary;
+  }
+});
+Object.defineProperty(exports, "Utf8", {
+  enumerable: true,
+  get: function () {
+    return _type.Utf8;
+  }
+});
+Object.defineProperty(exports, "Date", {
+  enumerable: true,
+  get: function () {
+    return _type.Date;
+  }
+});
+Object.defineProperty(exports, "DateDay", {
+  enumerable: true,
+  get: function () {
+    return _type.DateDay;
+  }
+});
+Object.defineProperty(exports, "DateMillisecond", {
+  enumerable: true,
+  get: function () {
+    return _type.DateMillisecond;
+  }
+});
+Object.defineProperty(exports, "Time", {
+  enumerable: true,
+  get: function () {
+    return _type.Time;
+  }
+});
+Object.defineProperty(exports, "TimeSecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimeSecond;
+  }
+});
+Object.defineProperty(exports, "TimeMillisecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimeMillisecond;
+  }
+});
+Object.defineProperty(exports, "Timestamp", {
+  enumerable: true,
+  get: function () {
+    return _type.Timestamp;
+  }
+});
+Object.defineProperty(exports, "TimestampSecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimestampSecond;
+  }
+});
+Object.defineProperty(exports, "TimestampMillisecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimestampMillisecond;
+  }
+});
+Object.defineProperty(exports, "TimestampMicrosecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimestampMicrosecond;
+  }
+});
+Object.defineProperty(exports, "TimestampNanosecond", {
+  enumerable: true,
+  get: function () {
+    return _type.TimestampNanosecond;
+  }
+});
+Object.defineProperty(exports, "Interval", {
+  enumerable: true,
+  get: function () {
+    return _type.Interval;
+  }
+});
+Object.defineProperty(exports, "IntervalDayTime", {
+  enumerable: true,
+  get: function () {
+    return _type.IntervalDayTime;
+  }
+});
+Object.defineProperty(exports, "IntervalYearMonth", {
+  enumerable: true,
+  get: function () {
+    return _type.IntervalYearMonth;
+  }
+});
+Object.defineProperty(exports, "FixedSizeList", {
+  enumerable: true,
+  get: function () {
+    return _type.FixedSizeList;
+  }
+});
+Object.defineProperty(exports, "Struct", {
+  enumerable: true,
+  get: function () {
+    return _type.Struct;
+  }
+});
+
+var _schema = _interopRequireDefault(require("./impl/schema"));
+
+var _field = _interopRequireDefault(require("./impl/field"));
+
+var _type = require("./impl/type");
+//# sourceMappingURL=schema.js.map

package/dist/es5/lib/schema/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/schema/schema.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA;;AACA;;AACA","sourcesContent":["/*\nexport {\n  Schema,\n  Field,\n  DataType,\n  Null,\n  Bool,\n  Int,\n  Int8,\n  Int16,\n  Int32,\n  Int64,\n  Uint8,\n  Uint16,\n  Uint32,\n  Uint64,\n  Float,\n  Float16,\n  Float32,\n  Float64,\n  Binary,\n  Utf8,\n  Date,\n  DateDay,\n  DateMillisecond,\n  Time,\n  TimeSecond,\n  TimeMillisecond,\n  TimeMicrosecond,\n  TimeNanosecond,\n  Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  Interval,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList\n} from 'apache-arrow';\n*/\nexport {default as Schema} from './impl/schema';\nexport {default as Field} from './impl/field';\nexport {Type} from './impl/type';\nexport {\n  DataType,\n  Null,\n  Bool,\n  Int,\n  Int8,\n  Int16,\n  Int32,\n  Int64,\n  Uint8,\n  Uint16,\n  Uint32,\n  Uint64,\n  Float,\n  Float16,\n  Float32,\n  Float64,\n  Binary,\n  Utf8,\n  Date,\n  DateDay,\n  DateMillisecond,\n  Time,\n  TimeSecond,\n  TimeMillisecond,\n  // TimeMicrosecond,\n  // TimeNanosecond,\n  Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  Interval,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList,\n  Struct\n} from './impl/type';\n"],"file":"schema.js"}

package/dist/es5/lib/schema-utils/deduce-column-type.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deduceTypeFromColumn = deduceTypeFromColumn;
+exports.deduceTypeFromValue = deduceTypeFromValue;
+
+function deduceTypeFromColumn(value) {
+  if (value instanceof Date) {
+    return Date;
+  } else if (value instanceof Number) {
+    return Float32Array;
+  } else if (typeof value === 'string') {
+    return String;
+  }
+
+  return null;
+}
+
+function deduceTypeFromValue(value) {
+  if (value instanceof Date) {
+    return Date;
+  } else if (value instanceof Number) {
+    return Float32Array;
+  } else if (typeof value === 'string') {
+    return String;
+  }
+
+  return null;
+}
+//# sourceMappingURL=deduce-column-type.js.map

package/dist/es5/lib/schema-utils/deduce-column-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/schema-utils/deduce-column-type.ts"],"names":["deduceTypeFromColumn","value","Date","Number","Float32Array","String","deduceTypeFromValue"],"mappings":";;;;;;;;AAmCO,SAASA,oBAAT,CACLC,KADK,EAEiE;AACtE,MAAIA,KAAK,YAAYC,IAArB,EAA2B;AACzB,WAAOA,IAAP;AACD,GAFD,MAEO,IAAID,KAAK,YAAYE,MAArB,EAA6B;AAClC,WAAOC,YAAP;AACD,GAFM,MAEA,IAAI,OAAOH,KAAP,KAAiB,QAArB,EAA+B;AACpC,WAAOI,MAAP;AACD;;AACD,SAAO,IAAP;AACD;;AAEM,SAASC,mBAAT,CACLL,KADK,EAEiE;AACtE,MAAIA,KAAK,YAAYC,IAArB,EAA2B;AACzB,WAAOA,IAAP;AACD,GAFD,MAEO,IAAID,KAAK,YAAYE,MAArB,EAA6B;AAClC,WAAOC,YAAP;AACD,GAFM,MAEA,IAAI,OAAOH,KAAP,KAAiB,QAArB,EAA+B;AACpC,WAAOI,MAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["// Type deduction\n// import {\n//   Schema\n//   Int,\n//   Int8,\n//   Int16,\n//   Int32,\n//   Uint8,\n//   Uint16,\n//   Uint32,\n//   Float32,\n//   Float64\n//   Bool,\n//   Utf8,\n//   TimestampMillisecond,\n//   Null\n// } from '../schema';\n\n// const TYPED_ARRAY_TO_TYPE = {\n//   Int8Array: new Int8(),\n//   Int16Array: new Int16(),\n//   Int32Array: new Int32(),\n//   Uint8Array: new Uint8(),\n//   Uint8ClampedArray: new Uint8(),\n//   Uint16Array: new Uint16(),\n//   Uint32Array: new Uint32(),\n//   Float32Array: new Float32(),\n//   Float64Array: new Float64()\n// };\n\n// if (typeof BigInt64Array !== 'undefined') {\n//   TYPED_ARRAY_TO_TYPE.BigInt64Array = new Int64();\n//   TYPED_ARRAY_TO_TYPE.BigUint64Array = new Uint64();\n// }\n\nexport function deduceTypeFromColumn(\n  value: unknown\n): StringConstructor | DateConstructor | Float32ArrayConstructor | null {\n  if (value instanceof Date) {\n    return Date;\n  } else if (value instanceof Number) {\n    return Float32Array;\n  } else if (typeof value === 'string') {\n    return String;\n  }\n  return null;\n}\n\nexport function deduceTypeFromValue(\n  value: unknown\n): StringConstructor | DateConstructor | Float32ArrayConstructor | null {\n  if (value instanceof Date) {\n    return Date;\n  } else if (value instanceof Number) {\n    return Float32Array;\n  } else if (typeof value === 'string') {\n    return String;\n  }\n  return null;\n}\n\n/*\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction deduceSchema(rows) {\n  const row = rows[0];\n\n  const schema = {};\n  let i = 0;\n  for (const columnName in row) {\n    const value = row[columnName];\n    switch (typeof value) {\n      case 'number':\n      case 'boolean':\n        // TODO - booleans could be handled differently...\n        schema[columnName] = {name: String(columnName), index: i, type: Float32Array};\n        break;\n\n      case 'object':\n        schema[columnName] = {name: String(columnName), index: i, type: Array};\n        break;\n\n      case 'string':\n      default:\n        schema[columnName] = {name: String(columnName), index: i, type: Array};\n      // We currently only handle numeric rows\n      // TODO we could offer a function to map strings to numbers?\n    }\n    i++;\n  }\n  return schema;\n}\n*/\n"],"file":"deduce-column-type.js"}

package/dist/es5/lib/utils/assert.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loader assertion failed.');
+  }
+}
+//# sourceMappingURL=assert.js.map

package/dist/es5/lib/utils/assert.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/assert.ts"],"names":["assert","condition","message","Error"],"mappings":";;;;;;;AAGO,SAASA,MAAT,CAAgBC,SAAhB,EAAoCC,OAApC,EAAsD;AAC3D,MAAI,CAACD,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAUD,OAAO,IAAI,0BAArB,CAAN;AACD;AACF","sourcesContent":["// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\nexport function assert(condition: boolean, message?: string) {\n  if (!condition) {\n    throw new Error(message || 'loader assertion failed.');\n  }\n}\n"],"file":"assert.js"}

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

@@ -0,0 +1,130 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.takeAsync = takeAsync;
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+let _Symbol$asyncIterator;
+
+class ArrayQueue extends Array {
+  enqueue(value) {
+    return this.push(value);
+  }
+
+  dequeue() {
+    return this.shift();
+  }
+
+}
+
+_Symbol$asyncIterator = Symbol.asyncIterator;
+
+class AsyncQueue {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_values", void 0);
+    (0, _defineProperty2.default)(this, "_settlers", void 0);
+    (0, _defineProperty2.default)(this, "_closed", void 0);
+    this._values = new ArrayQueue();
+    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);
+    }
+  }
+
+  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
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      this._settlers.enqueue({
+        resolve,
+        reject
+      });
+    });
+  }
+
+}
+
+exports.default = AsyncQueue;
+
+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;
+}
+//# sourceMappingURL=async-queue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/async-queue.ts"],"names":["ArrayQueue","Array","enqueue","value","push","dequeue","shift","Symbol","asyncIterator","AsyncQueue","constructor","_values","_settlers","_closed","close","length","resolve","done","Error","settler","reject","next","Promise","takeAsync","asyncIterable","count","Infinity","result","iterator"],"mappings":"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","sourcesContent":["// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\nclass ArrayQueue<T> extends Array<T> {\n  enqueue(value: T) {\n    // Add at the end\n    return this.push(value);\n  }\n  dequeue(): T {\n    // Remove first element\n    return this.shift() as T;\n  }\n}\n\nexport default class AsyncQueue<T> {\n  private _values: ArrayQueue<T | Error>;\n  private _settlers: ArrayQueue<{resolve: (value: any) => void; reject: (reason?: any) => void}>;\n  private _closed: boolean;\n\n  constructor() {\n    // enqueues > dequeues\n    this._values = new ArrayQueue<T>();\n    // dequeues > enqueues\n    this._settlers = new ArrayQueue<{\n      resolve: (value: any) => void;\n      reject: (reason?: any) => void;\n    }>();\n    this._closed = false;\n  }\n\n  close(): void {\n    while (this._settlers.length > 0) {\n      this._settlers.dequeue().resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.dequeue();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.enqueue(value);\n    }\n  }\n\n  /**\n   * @returns a Promise for an IteratorResult\n   */\n  next(): Promise<any> {\n    if (this._values.length > 0) {\n      const value = this._values.dequeue();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({value});\n    }\n\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true});\n    }\n    // Wait for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.enqueue({resolve, reject});\n    });\n  }\n}\n\n/**\n * @returns a Promise for an Array with the elements in `asyncIterable`\n */\nexport async function takeAsync(\n  asyncIterable: AsyncIterable<any>,\n  count = Infinity\n): Promise<any[]> {\n  const result: Array<any> = [];\n  const iterator = asyncIterable[Symbol.asyncIterator]();\n  while (result.length < count) {\n    const {value, done} = await iterator.next();\n    if (done) {\n      break;\n    }\n    result.push(value);\n  }\n  return result;\n}\n"],"file":"async-queue.js"}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.convertToObjectRow = convertToObjectRow;
+exports.convertToArrayRow = convertToArrayRow;
+
+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;
+}
+
+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;
+}
+//# sourceMappingURL=row-utils.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/row-utils.ts"],"names":["convertToObjectRow","arrayRow","headers","Error","objectRow","i","length","convertToArrayRow","Array"],"mappings":";;;;;;;;AACO,SAASA,kBAAT,CACLC,QADK,EAELC,OAFK,EAGwB;AAC7B,MAAI,CAACD,QAAL,EAAe;AACb,UAAM,IAAIE,KAAJ,CAAU,UAAV,CAAN;AACD;;AACD,MAAI,CAACD,OAAL,EAAc;AACZ,UAAM,IAAIC,KAAJ,CAAU,YAAV,CAAN;AACD;;AACD,QAAMC,SAAS,GAAG,EAAlB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,OAAO,CAACI,MAA5B,EAAoCD,CAAC,EAArC,EAAyC;AACvCD,IAAAA,SAAS,CAACF,OAAO,CAACG,CAAD,CAAR,CAAT,GAAwBJ,QAAQ,CAACI,CAAD,CAAhC;AACD;;AACD,SAAOD,SAAP;AACD;;AAGM,SAASG,iBAAT,CACLH,SADK,EAELF,OAFK,EAGE;AACP,MAAI,CAACE,SAAL,EAAgB;AACd,UAAM,IAAID,KAAJ,CAAU,UAAV,CAAN;AACD;;AACD,MAAI,CAACD,OAAL,EAAc;AACZ,UAAM,IAAIC,KAAJ,CAAU,YAAV,CAAN;AACD;;AACD,QAAMF,QAAQ,GAAG,IAAIO,KAAJ,CAAUN,OAAO,CAACI,MAAlB,CAAjB;;AACA,OAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,OAAO,CAACI,MAA5B,EAAoCD,CAAC,EAArC,EAAyC;AACvCJ,IAAAA,QAAQ,CAACI,CAAD,CAAR,GAAcD,SAAS,CAACF,OAAO,CAACG,CAAD,CAAR,CAAvB;AACD;;AACD,SAAOJ,QAAP;AACD","sourcesContent":["/** Convert an object row to an array row */\nexport function convertToObjectRow(\n  arrayRow: any[],\n  headers: string[]\n): {[columnName: string]: any} {\n  if (!arrayRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const objectRow = {};\n  for (let i = 0; i < headers.length; i++) {\n    objectRow[headers[i]] = arrayRow[i];\n  }\n  return objectRow;\n}\n\n/** Convert an object row to an array row */\nexport function convertToArrayRow(\n  objectRow: {[columnName: string]: any},\n  headers: string[]\n): any[] {\n  if (!objectRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const arrayRow = new Array(headers.length);\n  for (let i = 0; i < headers.length; i++) {\n    arrayRow[i] = objectRow[headers[i]];\n  }\n  return arrayRow;\n}\n"],"file":"row-utils.js"}

package/dist/es5/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

package/dist/esm/bundle.js

@@ -0,0 +1,5 @@
+const moduleExports = require('./index');
+
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/esm/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/esm/category/common.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=common.js.map

package/dist/esm/category/common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"common.js"}

package/dist/esm/category/gis.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=gis.js.map

package/dist/esm/category/gis.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"gis.js"}

package/dist/esm/category/mesh/convert-mesh.js

@@ -0,0 +1,26 @@
+export function convertMesh(mesh, shape, options) {
+  switch (shape || 'mesh') {
+    case 'mesh':
+      return mesh;
+
+    case 'columnar-table':
+      return convertMeshToColumnarTable(mesh);
+
+    default:
+      throw new Error("Unsupported shape ".concat(options === null || options === void 0 ? void 0 : options.shape));
+  }
+}
+export function convertMeshToColumnarTable(mesh) {
+  const columns = {};
+
+  for (const [columnName, attribute] of Object.entries(mesh.attributes)) {
+    columns[columnName] = attribute.value;
+  }
+
+  return {
+    shape: 'columnar-table',
+    schema: mesh.schema,
+    data: columns
+  };
+}
+//# sourceMappingURL=convert-mesh.js.map

package/dist/esm/category/mesh/convert-mesh.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/category/mesh/convert-mesh.ts"],"names":["convertMesh","mesh","shape","options","convertMeshToColumnarTable","Error","columns","columnName","attribute","Object","entries","attributes","value","schema","data"],"mappings":"AASA,OAAO,SAASA,WAAT,CACLC,IADK,EAELC,KAFK,EAGLC,OAHK,EAI8B;AACnC,UAAQD,KAAK,IAAI,MAAjB;AACE,SAAK,MAAL;AACE,aAAOD,IAAP;;AACF,SAAK,gBAAL;AACE,aAAOG,0BAA0B,CAACH,IAAD,CAAjC;;AAMF;AACE,YAAM,IAAII,KAAJ,6BAA+BF,OAA/B,aAA+BA,OAA/B,uBAA+BA,OAAO,CAAED,KAAxC,EAAN;AAXJ;AAaD;AAOD,OAAO,SAASE,0BAAT,CAAoCH,IAApC,EAA+D;AACpE,QAAMK,OAAO,GAAG,EAAhB;;AAEA,OAAK,MAAM,CAACC,UAAD,EAAaC,SAAb,CAAX,IAAsCC,MAAM,CAACC,OAAP,CAAeT,IAAI,CAACU,UAApB,CAAtC,EAAuE;AACrEL,IAAAA,OAAO,CAACC,UAAD,CAAP,GAAsBC,SAAS,CAACI,KAAhC;AACD;;AAED,SAAO;AACLV,IAAAA,KAAK,EAAE,gBADF;AAELW,IAAAA,MAAM,EAAEZ,IAAI,CAACY,MAFR;AAGLC,IAAAA,IAAI,EAAER;AAHD,GAAP;AAKD","sourcesContent":["import type {Mesh} from './mesh-types';\nimport type {ColumnarTable, ArrowTable} from '../table/table-types';\n// import {convertMeshToArrowTable} from './mesh-to-arrow-table';\n\ntype TargetShape = 'mesh' | 'columnar-table' | 'arrow-table';\n\n/**\n * Convert a mesh to a specific shape\n */\nexport function convertMesh(\n  mesh: Mesh,\n  shape: TargetShape,\n  options?: any\n): Mesh | ColumnarTable | ArrowTable {\n  switch (shape || 'mesh') {\n    case 'mesh':\n      return mesh;\n    case 'columnar-table':\n      return convertMeshToColumnarTable(mesh);\n    // case 'arrow-table':\n    //   return {\n    //     shape: 'arrow-table',\n    //     data: convertMeshToArrowTable(mesh)\n    //   };\n    default:\n      throw new Error(`Unsupported shape ${options?.shape}`);\n  }\n}\n\n/**\n * Convert a loaders.gl Mesh to a Columnar Table\n * @param mesh\n * @returns\n */\nexport function convertMeshToColumnarTable(mesh: Mesh): ColumnarTable {\n  const columns = {};\n\n  for (const [columnName, attribute] of Object.entries(mesh.attributes)) {\n    columns[columnName] = attribute.value;\n  }\n\n  return {\n    shape: 'columnar-table',\n    schema: mesh.schema,\n    data: columns\n  };\n}\n"],"file":"convert-mesh.js"}

package/dist/esm/category/mesh/deduce-mesh-schema.js

@@ -0,0 +1,42 @@
+import { Schema, Field, FixedSizeList } from '../../lib/schema/schema';
+import { getArrowTypeFromTypedArray } from '../../lib/arrow/arrow-like-type-utils';
+export function deduceMeshSchema(attributes, metadata) {
+  const fields = deduceMeshFields(attributes);
+  return new Schema(fields, metadata);
+}
+export function deduceMeshField(attributeName, attribute, optionalMetadata) {
+  const type = getArrowTypeFromTypedArray(attribute.value);
+  const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
+  const field = new Field(attributeName, new FixedSizeList(attribute.size, new Field('value', type)), false, metadata);
+  return field;
+}
+
+function deduceMeshFields(attributes) {
+  const fields = [];
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+    fields.push(deduceMeshField(attributeName, attribute));
+  }
+
+  return fields;
+}
+
+export function makeMeshAttributeMetadata(attribute) {
+  const result = new Map();
+
+  if ('byteOffset' in attribute) {
+    result.set('byteOffset', attribute.byteOffset.toString(10));
+  }
+
+  if ('byteStride' in attribute) {
+    result.set('byteStride', attribute.byteStride.toString(10));
+  }
+
+  if ('normalized' in attribute) {
+    result.set('normalized', attribute.normalized.toString());
+  }
+
+  return result;
+}
+//# sourceMappingURL=deduce-mesh-schema.js.map

package/dist/esm/category/mesh/deduce-mesh-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/category/mesh/deduce-mesh-schema.ts"],"names":["Schema","Field","FixedSizeList","getArrowTypeFromTypedArray","deduceMeshSchema","attributes","metadata","fields","deduceMeshFields","deduceMeshField","attributeName","attribute","optionalMetadata","type","value","makeMeshAttributeMetadata","field","size","push","result","Map","set","byteOffset","toString","byteStride","normalized"],"mappings":"AACA,SAAQA,MAAR,EAAgBC,KAAhB,EAAuBC,aAAvB,QAA2C,yBAA3C;AACA,SAAQC,0BAAR,QAAyC,uCAAzC;AAQA,OAAO,SAASC,gBAAT,CACLC,UADK,EAELC,QAFK,EAGG;AACR,QAAMC,MAAM,GAAGC,gBAAgB,CAACH,UAAD,CAA/B;AACA,SAAO,IAAIL,MAAJ,CAAWO,MAAX,EAAmBD,QAAnB,CAAP;AACD;AASD,OAAO,SAASG,eAAT,CACLC,aADK,EAELC,SAFK,EAGLC,gBAHK,EAIE;AACP,QAAMC,IAAI,GAAGV,0BAA0B,CAACQ,SAAS,CAACG,KAAX,CAAvC;AACA,QAAMR,QAAQ,GAAGM,gBAAgB,GAAGA,gBAAH,GAAsBG,yBAAyB,CAACJ,SAAD,CAAhF;AACA,QAAMK,KAAK,GAAG,IAAIf,KAAJ,CACZS,aADY,EAEZ,IAAIR,aAAJ,CAAkBS,SAAS,CAACM,IAA5B,EAAkC,IAAIhB,KAAJ,CAAU,OAAV,EAAmBY,IAAnB,CAAlC,CAFY,EAGZ,KAHY,EAIZP,QAJY,CAAd;AAMA,SAAOU,KAAP;AACD;;AAOD,SAASR,gBAAT,CAA0BH,UAA1B,EAA+D;AAC7D,QAAME,MAAe,GAAG,EAAxB;;AACA,OAAK,MAAMG,aAAX,IAA4BL,UAA5B,EAAwC;AACtC,UAAMM,SAAwB,GAAGN,UAAU,CAACK,aAAD,CAA3C;AACAH,IAAAA,MAAM,CAACW,IAAP,CAAYT,eAAe,CAACC,aAAD,EAAgBC,SAAhB,CAA3B;AACD;;AACD,SAAOJ,MAAP;AACD;;AAOD,OAAO,SAASQ,yBAAT,CAAmCJ,SAAnC,EAAkF;AACvF,QAAMQ,MAAM,GAAG,IAAIC,GAAJ,EAAf;;AACA,MAAI,gBAAgBT,SAApB,EAA+B;AAC7BQ,IAAAA,MAAM,CAACE,GAAP,CAAW,YAAX,EAAyBV,SAAS,CAACW,UAAV,CAAsBC,QAAtB,CAA+B,EAA/B,CAAzB;AACD;;AACD,MAAI,gBAAgBZ,SAApB,EAA+B;AAC7BQ,IAAAA,MAAM,CAACE,GAAP,CAAW,YAAX,EAAyBV,SAAS,CAACa,UAAV,CAAsBD,QAAtB,CAA+B,EAA/B,CAAzB;AACD;;AACD,MAAI,gBAAgBZ,SAApB,EAA+B;AAC7BQ,IAAAA,MAAM,CAACE,GAAP,CAAW,YAAX,EAAyBV,SAAS,CAACc,UAAV,CAAsBF,QAAtB,EAAzB;AACD;;AACD,SAAOJ,MAAP;AACD","sourcesContent":["import {MeshAttribute, MeshAttributes} from './mesh-types';\nimport {Schema, Field, FixedSizeList} from '../../lib/schema/schema';\nimport {getArrowTypeFromTypedArray} from '../../lib/arrow/arrow-like-type-utils';\n\n/**\n * Create a schema for mesh attributes data\n * @param attributes\n * @param metadata\n * @returns\n */\nexport function deduceMeshSchema(\n  attributes: MeshAttributes,\n  metadata?: Map<string, string>\n): Schema {\n  const fields = deduceMeshFields(attributes);\n  return new Schema(fields, metadata);\n}\n\n/**\n * Create arrow-like schema field for mesh attribute\n * @param attributeName\n * @param attribute\n * @param optionalMetadata\n * @returns\n */\nexport function deduceMeshField(\n  attributeName: string,\n  attribute: MeshAttribute,\n  optionalMetadata?: Map<string, string>\n): Field {\n  const type = getArrowTypeFromTypedArray(attribute.value);\n  const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);\n  const field = new Field(\n    attributeName,\n    new FixedSizeList(attribute.size, new Field('value', type)),\n    false,\n    metadata\n  );\n  return field;\n}\n\n/**\n * Create fields array for mesh attributes\n * @param attributes\n * @returns\n */\nfunction deduceMeshFields(attributes: MeshAttributes): Field[] {\n  const fields: Field[] = [];\n  for (const attributeName in attributes) {\n    const attribute: MeshAttribute = attributes[attributeName];\n    fields.push(deduceMeshField(attributeName, attribute));\n  }\n  return fields;\n}\n\n/**\n * Make metadata by mesh attribute properties\n * @param attribute\n * @returns\n */\nexport function makeMeshAttributeMetadata(attribute: MeshAttribute): Map<string, string> {\n  const result = new Map();\n  if ('byteOffset' in attribute) {\n    result.set('byteOffset', attribute.byteOffset!.toString(10));\n  }\n  if ('byteStride' in attribute) {\n    result.set('byteStride', attribute.byteStride!.toString(10));\n  }\n  if ('normalized' in attribute) {\n    result.set('normalized', attribute.normalized!.toString());\n  }\n  return result;\n}\n"],"file":"deduce-mesh-schema.js"}

package/dist/esm/category/mesh/mesh-to-arrow-table.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=mesh-to-arrow-table.js.map

package/dist/esm/category/mesh/mesh-to-arrow-table.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"mesh-to-arrow-table.js"}

package/dist/esm/category/mesh/mesh-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mesh-types.js.map

package/dist/esm/category/mesh/mesh-types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"mesh-types.js"}

package/dist/esm/category/mesh/mesh-utils.js

@@ -0,0 +1,38 @@
+export function getMeshSize(attributes) {
+  let size = 0;
+
+  for (const attributeName in attributes) {
+    const attribute = attributes[attributeName];
+
+    if (ArrayBuffer.isView(attribute)) {
+      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;
+    }
+  }
+
+  return size;
+}
+export function getMeshBoundingBox(attributes) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let minZ = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  let maxZ = -Infinity;
+  const positions = attributes.POSITION ? attributes.POSITION.value : [];
+  const len = positions && positions.length;
+
+  for (let i = 0; i < len; i += 3) {
+    const x = positions[i];
+    const y = positions[i + 1];
+    const z = positions[i + 2];
+    minX = x < minX ? x : minX;
+    minY = y < minY ? y : minY;
+    minZ = z < minZ ? z : minZ;
+    maxX = x > maxX ? x : maxX;
+    maxY = y > maxY ? y : maxY;
+    maxZ = z > maxZ ? z : maxZ;
+  }
+
+  return [[minX, minY, minZ], [maxX, maxY, maxZ]];
+}
+//# sourceMappingURL=mesh-utils.js.map