@loaders.gl/schema 3.2.12 → 3.3.0-alpha.10

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/utils/async-queue.ts"],"names":["ArrayQueue","value","push","shift","Array","Symbol","asyncIterator","AsyncQueue","_values","_settlers","_closed","length","dequeue","resolve","done","Error","settler","reject","enqueue","Promise","takeAsync","asyncIterable","count","Infinity","result","iterator","next"],"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"}
+{"version":3,"file":"async-queue.js","names":["ArrayQueue","value","push","shift","Array","Symbol","asyncIterator","AsyncQueue","_values","_settlers","_closed","length","dequeue","resolve","done","Error","settler","reject","enqueue","Promise","takeAsync","asyncIterable","count","Infinity","result","iterator","next"],"sources":["../../../../src/lib/utils/async-queue.ts"],"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"],"mappings":"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"}

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

@@ -3,24 +3,19 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.convertToObjectRow = convertToObjectRow;
 exports.convertToArrayRow = convertToArrayRow;
-
+exports.convertToObjectRow = convertToObjectRow;
 function convertToObjectRow(arrayRow, headers) {
   if (!arrayRow) {
     throw new Error('null row');
   }
-
   if (!headers) {
     throw new Error('no headers');
   }
-
   var objectRow = {};
-
   for (var i = 0; i < headers.length; i++) {
     objectRow[headers[i]] = arrayRow[i];
   }
-
   return objectRow;
 }
 
@@ -28,17 +23,13 @@ function convertToArrayRow(objectRow, headers) {
   if (!objectRow) {
     throw new Error('null row');
   }
-
   if (!headers) {
     throw new Error('no headers');
   }
-
   var arrayRow = new Array(headers.length);
-
   for (var 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

@@ -1 +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,MAAMC,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,MAAMF,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"}
+{"version":3,"file":"row-utils.js","names":["convertToObjectRow","arrayRow","headers","Error","objectRow","i","length","convertToArrayRow","Array"],"sources":["../../../../src/lib/utils/row-utils.ts"],"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"],"mappings":";;;;;;;AACO,SAASA,kBAAkB,CAChCC,QAAe,EACfC,OAAiB,EACY;EAC7B,IAAI,CAACD,QAAQ,EAAE;IACb,MAAM,IAAIE,KAAK,CAAC,UAAU,CAAC;EAC7B;EACA,IAAI,CAACD,OAAO,EAAE;IACZ,MAAM,IAAIC,KAAK,CAAC,YAAY,CAAC;EAC/B;EACA,IAAMC,SAAS,GAAG,CAAC,CAAC;EACpB,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,OAAO,CAACI,MAAM,EAAED,CAAC,EAAE,EAAE;IACvCD,SAAS,CAACF,OAAO,CAACG,CAAC,CAAC,CAAC,GAAGJ,QAAQ,CAACI,CAAC,CAAC;EACrC;EACA,OAAOD,SAAS;AAClB;;AAGO,SAASG,iBAAiB,CAC/BH,SAAsC,EACtCF,OAAiB,EACV;EACP,IAAI,CAACE,SAAS,EAAE;IACd,MAAM,IAAID,KAAK,CAAC,UAAU,CAAC;EAC7B;EACA,IAAI,CAACD,OAAO,EAAE;IACZ,MAAM,IAAIC,KAAK,CAAC,YAAY,CAAC;EAC/B;EACA,IAAMF,QAAQ,GAAG,IAAIO,KAAK,CAACN,OAAO,CAACI,MAAM,CAAC;EAC1C,KAAK,IAAID,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,OAAO,CAACI,MAAM,EAAED,CAAC,EAAE,EAAE;IACvCJ,QAAQ,CAACI,CAAC,CAAC,GAAGD,SAAS,CAACF,OAAO,CAACG,CAAC,CAAC,CAAC;EACrC;EACA,OAAOJ,QAAQ;AACjB"}

package/dist/es5/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}
+{"version":3,"file":"types.js","names":[],"sources":["../../src/types.ts"],"sourcesContent":["/** Any typed array */\nexport type TypedArray =\n  | Int8Array\n  | Uint8Array\n  | Int16Array\n  | Uint16Array\n  | Int32Array\n  | Uint32Array\n  | Uint8ClampedArray\n  | Float32Array\n  | Float64Array;\n\nexport type BigTypedArray = TypedArray | BigInt64Array | BigUint64Array;\n\n/** Any numeric array: typed array or `number[]` */\nexport type NumberArray = number[] | TypedArray;\n\n/** Any array: typed array or js array (`any[]`) */\nexport type AnyArray = any[] | TypedArray;\n"],"mappings":""}

package/dist/esm/bundle.js

@@ -1,5 +1,5 @@
-const moduleExports = require('./index');
 
+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

@@ -1 +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"}
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"mappings":";AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,OAAO,GAAGD,UAAU,CAACC,OAAO,IAAI,CAAC,CAAC;AAC7CC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,OAAO,EAAEH,aAAa,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"common.js"}
+{"version":3,"file":"common.js","names":[],"sources":["../../../src/category/common.ts"],"sourcesContent":["import type {RecordBatch} from 'apache-arrow';\n\nexport type Field = any;\n\nexport type Schema = {\n  [key: string]: Field;\n};\n\nexport type Batch = {\n  batchType: 'data' | 'metadata' | 'partial-result' | 'final-result';\n  mimeType?: string;\n  shape: string;\n  data: any;\n  recordBatch?: RecordBatch;\n  length: number;\n  schema?: Schema;\n  bytesUsed?: number;\n  count?: number;\n  cursor?: number;\n  [key: string]: any;\n};\n\n/*\nexport type Batch = {\n  bytesUsed?: number;\n  count?: number;\n  cursor?: number;\n  [key: string]: any;\n}\n*/\n"],"mappings":""}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"gis.js"}
+{"version":3,"file":"gis.js","names":[],"sources":["../../../src/category/gis.ts"],"sourcesContent":["// GIS\nimport type {TypedArray} from '../types';\nimport type {Feature, Geometry, Point, LineString, Polygon} from 'geojson';\n\n// GEOJSON FORMAT GEOMETRY\n\n// eslint-disable-next-line import/no-unresolved\nexport type {\n  GeoJSON,\n  Feature,\n  FeatureCollection,\n  Geometry,\n  Position,\n  GeoJsonProperties\n} from 'geojson';\n// eslint-disable-next-line import/no-unresolved\nexport type {\n  Point,\n  MultiPoint,\n  LineString,\n  MultiLineString,\n  Polygon,\n  MultiPolygon,\n  GeometryCollection\n} from 'geojson';\n\n// Aggregate information for converting GeoJSON into other formats\nexport type GeojsonGeometryInfo = {\n  coordLength: number;\n  pointPositionsCount: number;\n  pointFeaturesCount: number;\n  linePositionsCount: number;\n  linePathsCount: number;\n  lineFeaturesCount: number;\n  polygonPositionsCount: number;\n  polygonObjectsCount: number;\n  polygonRingsCount: number;\n  polygonFeaturesCount: number;\n};\n\n// FLAT GEOJSON FORMAT GEOMETRY\nexport type FlatGeometryType = 'Point' | 'LineString' | 'Polygon';\ntype RemoveCoordinatesField<Type> = {\n  [Property in keyof Type as Exclude<Property, 'coordinates'>]: Type[Property];\n};\n\n/**\n * Generic flat geometry data storage type\n */\nexport type FlatIndexedGeometry = {\n  data: number[];\n  indices: number[];\n};\n\n/**\n * GeoJSON (Multi)Point geometry with coordinate data flattened into `data` array and indexed by `indices`\n */\nexport type FlatPoint = RemoveCoordinatesField<Point> & FlatIndexedGeometry;\n\n/**\n * GeoJSON (Multi)LineString geometry with coordinate data flattened into `data` array and indexed by `indices`\n */\nexport type FlatLineString = RemoveCoordinatesField<LineString> & FlatIndexedGeometry;\n\n/**\n * GeoJSON (Multi)Polygon geometry with coordinate data flattened into `data` array and indexed by 2D `indices`\n */\nexport type FlatPolygon = RemoveCoordinatesField<Polygon> & {\n  data: number[];\n  indices: number[][];\n  areas: number[][];\n};\n\nexport type FlatGeometry = FlatPoint | FlatLineString | FlatPolygon;\n\ntype FlattenGeometry<Type> = {\n  [Property in keyof Type]: Type[Property] extends Geometry ? FlatGeometry : Type[Property];\n};\n\n/**\n * GeoJSON Feature with Geometry replaced by FlatGeometry\n */\nexport type FlatFeature = FlattenGeometry<Feature>;\n\n// BINARY FORMAT GEOMETRY\n\nexport type BinaryAttribute = {value: TypedArray; size: number};\nexport type BinaryGeometryType = 'Point' | 'LineString' | 'Polygon';\n\ntype NumericProps = {[key: string]: BinaryAttribute};\ntype Properties = object[];\n\n/**\n * Represent a single Geometry, similar to a GeoJSON Geometry\n */\nexport type BinaryGeometry = BinaryPointGeometry | BinaryLineGeometry | BinaryPolygonGeometry;\n\nexport type BinaryPointGeometry = {\n  type: 'Point';\n  positions: BinaryAttribute;\n};\n\nexport type BinaryLineGeometry = {\n  type: 'LineString';\n  positions: BinaryAttribute;\n  pathIndices: BinaryAttribute;\n};\n\nexport type BinaryPolygonGeometry = {\n  type: 'Polygon';\n  positions: BinaryAttribute;\n  polygonIndices: BinaryAttribute;\n  primitivePolygonIndices: BinaryAttribute;\n  triangles?: BinaryAttribute;\n};\n\nexport type BinaryProperties = {\n  featureIds: BinaryAttribute;\n  globalFeatureIds: BinaryAttribute;\n  numericProps: NumericProps;\n  properties: Properties;\n  fields?: Properties;\n};\n\nexport type BinaryPointFeatures = BinaryPointGeometry & BinaryProperties;\nexport type BinaryLineFeatures = BinaryLineGeometry & BinaryProperties;\nexport type BinaryPolygonFeatures = BinaryPolygonGeometry & BinaryProperties;\n\n/**\n * Represent a collection of Features, similar to a GeoJSON FeatureCollection\n */\nexport type BinaryFeatures = {\n  points?: BinaryPointFeatures;\n  lines?: BinaryLineFeatures;\n  polygons?: BinaryPolygonFeatures;\n};\n"],"mappings":""}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"image.js"}
+{"version":3,"file":"image.js","names":[],"sources":["../../../../src/category/image/image.ts"],"sourcesContent":["/**\n * data images\n */\nexport type ImageDataType = {\n  data: Uint8Array;\n  width: number;\n  height: number;\n  compressed?: boolean;\n};\n\n/**\n * Supported Image Types\n */\nexport type ImageType = ImageBitmap | typeof Image | ImageDataType;\n\n/**\n * Image type string used to control or determine the type of images returned from ImageLoader\n */\nexport type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';\n"],"mappings":""}

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

@@ -3,27 +3,23 @@ export function convertMesh(mesh, shape, options) {
   switch (shape || 'mesh') {
     case 'mesh':
       return mesh;
-
     case 'columnar-table':
       return convertMeshToColumnarTable(mesh);
-
     case 'arrow-table':
       return {
         shape: 'arrow-table',
         data: convertMeshToArrowTable(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,

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/category/mesh/convert-mesh.ts"],"names":["convertMeshToArrowTable","convertMesh","mesh","shape","options","convertMeshToColumnarTable","data","Error","columns","columnName","attribute","Object","entries","attributes","value","schema"],"mappings":"AAEA,SAAQA,uBAAR,QAAsC,uBAAtC;AAOA,OAAO,SAASC,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;;AACF,SAAK,aAAL;AACE,aAAO;AACLC,QAAAA,KAAK,EAAE,aADF;AAELG,QAAAA,IAAI,EAAEN,uBAAuB,CAACE,IAAD;AAFxB,OAAP;;AAIF;AACE,YAAM,IAAIK,KAAJ,6BAA+BH,OAA/B,aAA+BA,OAA/B,uBAA+BA,OAAO,CAAED,KAAxC,EAAN;AAXJ;AAaD;AAOD,OAAO,SAASE,0BAAT,CAAoCH,IAApC,EAA+D;AACpE,QAAMM,OAAO,GAAG,EAAhB;;AAEA,OAAK,MAAM,CAACC,UAAD,EAAaC,SAAb,CAAX,IAAsCC,MAAM,CAACC,OAAP,CAAeV,IAAI,CAACW,UAApB,CAAtC,EAAuE;AACrEL,IAAAA,OAAO,CAACC,UAAD,CAAP,GAAsBC,SAAS,CAACI,KAAhC;AACD;;AAED,SAAO;AACLX,IAAAA,KAAK,EAAE,gBADF;AAELY,IAAAA,MAAM,EAAEb,IAAI,CAACa,MAFR;AAGLT,IAAAA,IAAI,EAAEE;AAHD,GAAP;AAKD","sourcesContent":["import type {Mesh} from './mesh-types';\nimport type {ColumnarTable, ArrowTable} from '../table/table-types';\nimport {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"}
+{"version":3,"file":"convert-mesh.js","names":["convertMeshToArrowTable","convertMesh","mesh","shape","options","convertMeshToColumnarTable","data","Error","columns","columnName","attribute","Object","entries","attributes","value","schema"],"sources":["../../../../src/category/mesh/convert-mesh.ts"],"sourcesContent":["import type {Mesh} from './mesh-types';\nimport type {ColumnarTable, ArrowTable} from '../table/table-types';\nimport {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"],"mappings":"AAEA,SAAQA,uBAAuB,QAAO,uBAAuB;AAO7D,OAAO,SAASC,WAAW,CACzBC,IAAU,EACVC,KAAkB,EAClBC,OAAa,EACsB;EACnC,QAAQD,KAAK,IAAI,MAAM;IACrB,KAAK,MAAM;MACT,OAAOD,IAAI;IACb,KAAK,gBAAgB;MACnB,OAAOG,0BAA0B,CAACH,IAAI,CAAC;IACzC,KAAK,aAAa;MAChB,OAAO;QACLC,KAAK,EAAE,aAAa;QACpBG,IAAI,EAAEN,uBAAuB,CAACE,IAAI;MACpC,CAAC;IACH;MACE,MAAM,IAAIK,KAAK,6BAAsBH,OAAO,aAAPA,OAAO,uBAAPA,OAAO,CAAED,KAAK,EAAG;EAAC;AAE7D;;AAOA,OAAO,SAASE,0BAA0B,CAACH,IAAU,EAAiB;EACpE,MAAMM,OAAO,GAAG,CAAC,CAAC;EAElB,KAAK,MAAM,CAACC,UAAU,EAAEC,SAAS,CAAC,IAAIC,MAAM,CAACC,OAAO,CAACV,IAAI,CAACW,UAAU,CAAC,EAAE;IACrEL,OAAO,CAACC,UAAU,CAAC,GAAGC,SAAS,CAACI,KAAK;EACvC;EAEA,OAAO;IACLX,KAAK,EAAE,gBAAgB;IACvBY,MAAM,EAAEb,IAAI,CAACa,MAAM;IACnBT,IAAI,EAAEE;EACR,CAAC;AACH"}

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

@@ -1,9 +1,11 @@
 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);
@@ -13,30 +15,24 @@ export function deduceMeshField(attributeName, attribute, optionalMetadata) {
 
 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

@@ -1 +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"}
+{"version":3,"file":"deduce-mesh-schema.js","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"],"sources":["../../../../src/category/mesh/deduce-mesh-schema.ts"],"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"],"mappings":"AACA,SAAQA,MAAM,EAAEC,KAAK,EAAEC,aAAa,QAAO,yBAAyB;AACpE,SAAQC,0BAA0B,QAAO,uCAAuC;;AAQhF,OAAO,SAASC,gBAAgB,CAC9BC,UAA0B,EAC1BC,QAA8B,EACtB;EACR,MAAMC,MAAM,GAAGC,gBAAgB,CAACH,UAAU,CAAC;EAC3C,OAAO,IAAIL,MAAM,CAACO,MAAM,EAAED,QAAQ,CAAC;AACrC;;AASA,OAAO,SAASG,eAAe,CAC7BC,aAAqB,EACrBC,SAAwB,EACxBC,gBAAsC,EAC/B;EACP,MAAMC,IAAI,GAAGV,0BAA0B,CAACQ,SAAS,CAACG,KAAK,CAAC;EACxD,MAAMR,QAAQ,GAAGM,gBAAgB,GAAGA,gBAAgB,GAAGG,yBAAyB,CAACJ,SAAS,CAAC;EAC3F,MAAMK,KAAK,GAAG,IAAIf,KAAK,CACrBS,aAAa,EACb,IAAIR,aAAa,CAACS,SAAS,CAACM,IAAI,EAAE,IAAIhB,KAAK,CAAC,OAAO,EAAEY,IAAI,CAAC,CAAC,EAC3D,KAAK,EACLP,QAAQ,CACT;EACD,OAAOU,KAAK;AACd;;AAOA,SAASR,gBAAgB,CAACH,UAA0B,EAAW;EAC7D,MAAME,MAAe,GAAG,EAAE;EAC1B,KAAK,MAAMG,aAAa,IAAIL,UAAU,EAAE;IACtC,MAAMM,SAAwB,GAAGN,UAAU,CAACK,aAAa,CAAC;IAC1DH,MAAM,CAACW,IAAI,CAACT,eAAe,CAACC,aAAa,EAAEC,SAAS,CAAC,CAAC;EACxD;EACA,OAAOJ,MAAM;AACf;;AAOA,OAAO,SAASQ,yBAAyB,CAACJ,SAAwB,EAAuB;EACvF,MAAMQ,MAAM,GAAG,IAAIC,GAAG,EAAE;EACxB,IAAI,YAAY,IAAIT,SAAS,EAAE;IAC7BQ,MAAM,CAACE,GAAG,CAAC,YAAY,EAAEV,SAAS,CAACW,UAAU,CAAEC,QAAQ,CAAC,EAAE,CAAC,CAAC;EAC9D;EACA,IAAI,YAAY,IAAIZ,SAAS,EAAE;IAC7BQ,MAAM,CAACE,GAAG,CAAC,YAAY,EAAEV,SAAS,CAACa,UAAU,CAAED,QAAQ,CAAC,EAAE,CAAC,CAAC;EAC9D;EACA,IAAI,YAAY,IAAIZ,SAAS,EAAE;IAC7BQ,MAAM,CAACE,GAAG,CAAC,YAAY,EAAEV,SAAS,CAACc,UAAU,CAAEF,QAAQ,EAAE,CAAC;EAC5D;EACA,OAAOJ,MAAM;AACf"}

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

@@ -1,12 +1,11 @@
 import { Table, Schema, RecordBatch, FixedSizeList, Field, Data, FixedSizeListVector } from 'apache-arrow/Arrow.dom';
 import { getArrowType, getArrowVector } from '../../lib/arrow/arrow-type-utils';
 import { makeMeshAttributeMetadata } from './deduce-mesh-schema';
+
 export function convertMeshToArrowTable(mesh, batchSize) {
   var _mesh$schema;
-
   const vectors = [];
   const fields = [];
-
   for (const attributeKey in mesh.attributes) {
     const attribute = mesh.attributes[attributeKey];
     const {
@@ -22,7 +21,6 @@ export function convertMeshToArrowTable(mesh, batchSize) {
     vectors.push(listVector);
     fields.push(field);
   }
-
   const schema = new Schema(fields, (mesh === null || mesh === void 0 ? void 0 : (_mesh$schema = mesh.schema) === null || _mesh$schema === void 0 ? void 0 : _mesh$schema.metadata) || new Map());
   const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);
   const table = new Table(schema, recordBatch);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/category/mesh/mesh-to-arrow-table.ts"],"names":["Table","Schema","RecordBatch","FixedSizeList","Field","Data","FixedSizeListVector","getArrowType","getArrowVector","makeMeshAttributeMetadata","convertMeshToArrowTable","mesh","batchSize","vectors","fields","attributeKey","attributes","attribute","value","size","type","vector","listType","field","data","length","undefined","listVector","push","schema","metadata","Map","recordBatch","table"],"mappings":"AAAA,SACEA,KADF,EAEEC,MAFF,EAGEC,WAHF,EAIEC,aAJF,EAKEC,KALF,EAMEC,IANF,EAOEC,mBAPF,QAQO,wBARP;AAUA,SAAQC,YAAR,EAAsBC,cAAtB,QAA2C,kCAA3C;AAEA,SAAQC,yBAAR,QAAwC,sBAAxC;AASA,OAAO,SAASC,uBAAT,CAAiCC,IAAjC,EAA6CC,SAA7C,EAAwE;AAAA;;AAC7E,QAAMC,OAAyB,GAAG,EAAlC;AACA,QAAMC,MAAe,GAAG,EAAxB;;AACA,OAAK,MAAMC,YAAX,IAA2BJ,IAAI,CAACK,UAAhC,EAA4C;AAC1C,UAAMC,SAAS,GAAGN,IAAI,CAACK,UAAL,CAAgBD,YAAhB,CAAlB;AACA,UAAM;AAACG,MAAAA,KAAD;AAAQC,MAAAA,IAAI,GAAG;AAAf,QAAoBF,SAA1B;AACA,UAAMG,IAAI,GAAGb,YAAY,CAACW,KAAD,CAAzB;AACA,UAAMG,MAAM,GAAGb,cAAc,CAACU,KAAD,CAA7B;AACA,UAAMI,QAAQ,GAAG,IAAInB,aAAJ,CAAkBgB,IAAlB,EAAwB,IAAIf,KAAJ,CAAU,OAAV,EAAmBgB,IAAnB,CAAxB,CAAjB;AACA,UAAMG,KAAK,GAAG,IAAInB,KAAJ,CAAUW,YAAV,EAAwBO,QAAxB,EAAkC,KAAlC,EAAyCb,yBAAyB,CAACQ,SAAD,CAAlE,CAAd;AACA,UAAMO,IAAI,GAAG,IAAInB,IAAJ,CAASiB,QAAT,EAAmB,CAAnB,EAAsBJ,KAAK,CAACO,MAAN,GAAeN,IAArC,EAA2C,CAA3C,EAA8CO,SAA9C,EAAyD,CAACL,MAAD,CAAzD,CAAb;AACA,UAAMM,UAAU,GAAG,IAAIrB,mBAAJ,CAAwBkB,IAAxB,CAAnB;AACAX,IAAAA,OAAO,CAACe,IAAR,CAAaD,UAAb;AACAb,IAAAA,MAAM,CAACc,IAAP,CAAYL,KAAZ;AACD;;AACD,QAAMM,MAAM,GAAG,IAAI5B,MAAJ,CAAWa,MAAX,EAAmB,CAAAH,IAAI,SAAJ,IAAAA,IAAI,WAAJ,4BAAAA,IAAI,CAAEkB,MAAN,8DAAcC,QAAd,KAA0B,IAAIC,GAAJ,EAA7C,CAAf;AACA,QAAMC,WAAW,GAAG,IAAI9B,WAAJ,CAAgB2B,MAAhB,EAAwBhB,OAAO,CAAC,CAAD,CAAP,CAAWY,MAAnC,EAA2CZ,OAA3C,CAApB;AACA,QAAMoB,KAAK,GAAG,IAAIjC,KAAJ,CAAU6B,MAAV,EAAkBG,WAAlB,CAAd;AACA,SAAOC,KAAP;AACD","sourcesContent":["import {\n  Table,\n  Schema,\n  RecordBatch,\n  FixedSizeList,\n  Field,\n  Data,\n  FixedSizeListVector\n} from 'apache-arrow/Arrow.dom';\nimport {AbstractVector} from 'apache-arrow/vector';\nimport {getArrowType, getArrowVector} from '../../lib/arrow/arrow-type-utils';\nimport type {Mesh} from './mesh-types';\nimport {makeMeshAttributeMetadata} from './deduce-mesh-schema';\n\n/**\n * * Convert a loaders.gl Mesh to an Apache Arrow Table\n * @param mesh\n * @param metadata\n * @param batchSize\n * @returns\n */\nexport function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): Table {\n  const vectors: AbstractVector[] = [];\n  const fields: Field[] = [];\n  for (const attributeKey in mesh.attributes) {\n    const attribute = mesh.attributes[attributeKey];\n    const {value, size = 1} = attribute;\n    const type = getArrowType(value);\n    const vector = getArrowVector(value);\n    const listType = new FixedSizeList(size, new Field('value', type));\n    const field = new Field(attributeKey, listType, false, makeMeshAttributeMetadata(attribute));\n    const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);\n    const listVector = new FixedSizeListVector(data);\n    vectors.push(listVector);\n    fields.push(field);\n  }\n  const schema = new Schema(fields, mesh?.schema?.metadata || new Map<string, string>());\n  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);\n  const table = new Table(schema, recordBatch);\n  return table;\n}\n"],"file":"mesh-to-arrow-table.js"}
+{"version":3,"file":"mesh-to-arrow-table.js","names":["Table","Schema","RecordBatch","FixedSizeList","Field","Data","FixedSizeListVector","getArrowType","getArrowVector","makeMeshAttributeMetadata","convertMeshToArrowTable","mesh","batchSize","vectors","fields","attributeKey","attributes","attribute","value","size","type","vector","listType","field","data","length","undefined","listVector","push","schema","metadata","Map","recordBatch","table"],"sources":["../../../../src/category/mesh/mesh-to-arrow-table.ts"],"sourcesContent":["import {\n  Table,\n  Schema,\n  RecordBatch,\n  FixedSizeList,\n  Field,\n  Data,\n  FixedSizeListVector\n} from 'apache-arrow/Arrow.dom';\nimport {AbstractVector} from 'apache-arrow/vector';\nimport {getArrowType, getArrowVector} from '../../lib/arrow/arrow-type-utils';\nimport type {Mesh} from './mesh-types';\nimport {makeMeshAttributeMetadata} from './deduce-mesh-schema';\n\n/**\n * * Convert a loaders.gl Mesh to an Apache Arrow Table\n * @param mesh\n * @param metadata\n * @param batchSize\n * @returns\n */\nexport function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): Table {\n  const vectors: AbstractVector[] = [];\n  const fields: Field[] = [];\n  for (const attributeKey in mesh.attributes) {\n    const attribute = mesh.attributes[attributeKey];\n    const {value, size = 1} = attribute;\n    const type = getArrowType(value);\n    const vector = getArrowVector(value);\n    const listType = new FixedSizeList(size, new Field('value', type));\n    const field = new Field(attributeKey, listType, false, makeMeshAttributeMetadata(attribute));\n    const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);\n    const listVector = new FixedSizeListVector(data);\n    vectors.push(listVector);\n    fields.push(field);\n  }\n  const schema = new Schema(fields, mesh?.schema?.metadata || new Map<string, string>());\n  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);\n  const table = new Table(schema, recordBatch);\n  return table;\n}\n"],"mappings":"AAAA,SACEA,KAAK,EACLC,MAAM,EACNC,WAAW,EACXC,aAAa,EACbC,KAAK,EACLC,IAAI,EACJC,mBAAmB,QACd,wBAAwB;AAE/B,SAAQC,YAAY,EAAEC,cAAc,QAAO,kCAAkC;AAE7E,SAAQC,yBAAyB,QAAO,sBAAsB;;AAS9D,OAAO,SAASC,uBAAuB,CAACC,IAAU,EAAEC,SAAkB,EAAS;EAAA;EAC7E,MAAMC,OAAyB,GAAG,EAAE;EACpC,MAAMC,MAAe,GAAG,EAAE;EAC1B,KAAK,MAAMC,YAAY,IAAIJ,IAAI,CAACK,UAAU,EAAE;IAC1C,MAAMC,SAAS,GAAGN,IAAI,CAACK,UAAU,CAACD,YAAY,CAAC;IAC/C,MAAM;MAACG,KAAK;MAAEC,IAAI,GAAG;IAAC,CAAC,GAAGF,SAAS;IACnC,MAAMG,IAAI,GAAGb,YAAY,CAACW,KAAK,CAAC;IAChC,MAAMG,MAAM,GAAGb,cAAc,CAACU,KAAK,CAAC;IACpC,MAAMI,QAAQ,GAAG,IAAInB,aAAa,CAACgB,IAAI,EAAE,IAAIf,KAAK,CAAC,OAAO,EAAEgB,IAAI,CAAC,CAAC;IAClE,MAAMG,KAAK,GAAG,IAAInB,KAAK,CAACW,YAAY,EAAEO,QAAQ,EAAE,KAAK,EAAEb,yBAAyB,CAACQ,SAAS,CAAC,CAAC;IAC5F,MAAMO,IAAI,GAAG,IAAInB,IAAI,CAACiB,QAAQ,EAAE,CAAC,EAAEJ,KAAK,CAACO,MAAM,GAAGN,IAAI,EAAE,CAAC,EAAEO,SAAS,EAAE,CAACL,MAAM,CAAC,CAAC;IAC/E,MAAMM,UAAU,GAAG,IAAIrB,mBAAmB,CAACkB,IAAI,CAAC;IAChDX,OAAO,CAACe,IAAI,CAACD,UAAU,CAAC;IACxBb,MAAM,CAACc,IAAI,CAACL,KAAK,CAAC;EACpB;EACA,MAAMM,MAAM,GAAG,IAAI5B,MAAM,CAACa,MAAM,EAAE,CAAAH,IAAI,aAAJA,IAAI,uCAAJA,IAAI,CAAEkB,MAAM,iDAAZ,aAAcC,QAAQ,KAAI,IAAIC,GAAG,EAAkB,CAAC;EACtF,MAAMC,WAAW,GAAG,IAAI9B,WAAW,CAAC2B,MAAM,EAAEhB,OAAO,CAAC,CAAC,CAAC,CAACY,MAAM,EAAEZ,OAAO,CAAC;EACvE,MAAMoB,KAAK,GAAG,IAAIjC,KAAK,CAAC6B,MAAM,EAAEG,WAAW,CAAC;EAC5C,OAAOC,KAAK;AACd"}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"mesh-types.js"}
+{"version":3,"file":"mesh-types.js","names":[],"sources":["../../../../src/category/mesh/mesh-types.ts"],"sourcesContent":["import type {Schema} from '../../lib/schema/schema';\nimport type {TypedArray} from '../../types';\nimport type {ColumnarTable, ArrowTable} from '../table/table-types';\n\n/** Mesh as columnar table */\nexport interface MeshTable extends ColumnarTable {\n  // shape: 'mesh-table';\n  topology: 'point-list' | 'triangle-list' | 'triangle-strip';\n  indices?: MeshAttribute;\n}\n\n/** Mesh as arrow table */\nexport interface MeshArrowTable extends ArrowTable {\n  // shape: 'mesh-arrow-table';\n  topology: 'point-list' | 'triangle-list' | 'triangle-strip';\n  indices?: MeshAttribute;\n}\n\n/** Geometry part of a Mesh (compatible with a standard luma.gl \"mesh\") */\nexport type MeshGeometry = {\n  attributes: {[attributeName: string]: MeshAttribute};\n  indices?: MeshAttribute;\n  topology: 'point-list' | 'triangle-list' | 'triangle-strip';\n  mode: number;\n};\n\n/** Geometry and metadata for a Mesh (compatible with a standard luma.gl \"mesh\") */\nexport type Mesh = MeshGeometry & {\n  loader?: string;\n  loaderData?: {[key: string]: any};\n  header?: {\n    vertexCount: number;\n    boundingBox?: [number[], number[]];\n  };\n  schema: Schema;\n};\n\n/**\n * luma.gl compatible attribute descriptors\n * Can be mapped to any WebGL framework\n */\nexport type MeshAttribute = {\n  value: TypedArray;\n  size: number;\n  byteOffset?: number;\n  byteStride?: number;\n  normalized?: boolean;\n};\n\n/** A map of mesh attributes keyed by attribute names */\nexport type MeshAttributes = {[attributeName: string]: MeshAttribute};\n"],"mappings":""}

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

@@ -1,16 +1,16 @@
+
+
 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;
@@ -20,7 +20,6 @@ export function getMeshBoundingBox(attributes) {
   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];
@@ -32,7 +31,6 @@ export function getMeshBoundingBox(attributes) {
     maxY = y > maxY ? y : maxY;
     maxZ = z > maxZ ? z : maxZ;
   }
-
   return [[minX, minY, minZ], [maxX, maxY, maxZ]];
 }
 //# sourceMappingURL=mesh-utils.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/category/mesh/mesh-utils.ts"],"names":["getMeshSize","attributes","size","attributeName","attribute","ArrayBuffer","isView","byteLength","BYTES_PER_ELEMENT","getMeshBoundingBox","minX","Infinity","minY","minZ","maxX","maxY","maxZ","positions","POSITION","value","len","length","i","x","y","z"],"mappings":"AAiBA,OAAO,SAASA,WAAT,CAAqBC,UAArB,EAAsD;AAC3D,MAAIC,IAAI,GAAG,CAAX;;AACA,OAAK,MAAMC,aAAX,IAA4BF,UAA5B,EAAwC;AACtC,UAAMG,SAAS,GAAGH,UAAU,CAACE,aAAD,CAA5B;;AACA,QAAIE,WAAW,CAACC,MAAZ,CAAmBF,SAAnB,CAAJ,EAAmC;AAEjCF,MAAAA,IAAI,IAAIE,SAAS,CAACG,UAAV,GAAuBH,SAAS,CAACI,iBAAzC;AACD;AACF;;AACD,SAAON,IAAP;AACD;AAQD,OAAO,SAASO,kBAAT,CAA4BR,UAA5B,EAAqE;AAC1E,MAAIS,IAAI,GAAGC,QAAX;AACA,MAAIC,IAAI,GAAGD,QAAX;AACA,MAAIE,IAAI,GAAGF,QAAX;AACA,MAAIG,IAAI,GAAG,CAACH,QAAZ;AACA,MAAII,IAAI,GAAG,CAACJ,QAAZ;AACA,MAAIK,IAAI,GAAG,CAACL,QAAZ;AAEA,QAAMM,SAAS,GAAGhB,UAAU,CAACiB,QAAX,GAAsBjB,UAAU,CAACiB,QAAX,CAAoBC,KAA1C,GAAkD,EAApE;AACA,QAAMC,GAAG,GAAGH,SAAS,IAAIA,SAAS,CAACI,MAAnC;;AAEA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGF,GAApB,EAAyBE,CAAC,IAAI,CAA9B,EAAiC;AAC/B,UAAMC,CAAC,GAAGN,SAAS,CAACK,CAAD,CAAnB;AACA,UAAME,CAAC,GAAGP,SAAS,CAACK,CAAC,GAAG,CAAL,CAAnB;AACA,UAAMG,CAAC,GAAGR,SAAS,CAACK,CAAC,GAAG,CAAL,CAAnB;AAEAZ,IAAAA,IAAI,GAAGa,CAAC,GAAGb,IAAJ,GAAWa,CAAX,GAAeb,IAAtB;AACAE,IAAAA,IAAI,GAAGY,CAAC,GAAGZ,IAAJ,GAAWY,CAAX,GAAeZ,IAAtB;AACAC,IAAAA,IAAI,GAAGY,CAAC,GAAGZ,IAAJ,GAAWY,CAAX,GAAeZ,IAAtB;AAEAC,IAAAA,IAAI,GAAGS,CAAC,GAAGT,IAAJ,GAAWS,CAAX,GAAeT,IAAtB;AACAC,IAAAA,IAAI,GAAGS,CAAC,GAAGT,IAAJ,GAAWS,CAAX,GAAeT,IAAtB;AACAC,IAAAA,IAAI,GAAGS,CAAC,GAAGT,IAAJ,GAAWS,CAAX,GAAeT,IAAtB;AACD;;AACD,SAAO,CACL,CAACN,IAAD,EAAOE,IAAP,EAAaC,IAAb,CADK,EAEL,CAACC,IAAD,EAAOC,IAAP,EAAaC,IAAb,CAFK,CAAP;AAID","sourcesContent":["// Mesh category utilities\n// TODO - move to mesh category module, or to math.gl/geometry module\nimport {TypedArray} from '../../types';\nimport {MeshAttributes} from './mesh-types';\n\ntype TypedArrays = {[key: string]: TypedArray};\n\n/**\n * Holds an axis aligned bounding box\n * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)\n */\ntype BoundingBox = [[number, number, number], [number, number, number]];\n\n/**\n * Get number of vertices in mesh\n * @param attributes\n */\nexport function getMeshSize(attributes: TypedArrays): number {\n  let size = 0;\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    if (ArrayBuffer.isView(attribute)) {\n      // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT\n      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;\n    }\n  }\n  return size;\n}\n\n/**\n * Get the (axis aligned) bounding box of a mesh\n * @param attributes\n * @returns array of two vectors representing the axis aligned bounding box\n */\n// eslint-disable-next-line complexity\nexport function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox {\n  let minX = Infinity;\n  let minY = Infinity;\n  let minZ = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let maxZ = -Infinity;\n\n  const positions = attributes.POSITION ? attributes.POSITION.value : [];\n  const len = positions && positions.length;\n\n  for (let i = 0; i < len; i += 3) {\n    const x = positions[i];\n    const y = positions[i + 1];\n    const z = positions[i + 2];\n\n    minX = x < minX ? x : minX;\n    minY = y < minY ? y : minY;\n    minZ = z < minZ ? z : minZ;\n\n    maxX = x > maxX ? x : maxX;\n    maxY = y > maxY ? y : maxY;\n    maxZ = z > maxZ ? z : maxZ;\n  }\n  return [\n    [minX, minY, minZ],\n    [maxX, maxY, maxZ]\n  ];\n}\n"],"file":"mesh-utils.js"}
+{"version":3,"file":"mesh-utils.js","names":["getMeshSize","attributes","size","attributeName","attribute","ArrayBuffer","isView","byteLength","BYTES_PER_ELEMENT","getMeshBoundingBox","minX","Infinity","minY","minZ","maxX","maxY","maxZ","positions","POSITION","value","len","length","i","x","y","z"],"sources":["../../../../src/category/mesh/mesh-utils.ts"],"sourcesContent":["// Mesh category utilities\n// TODO - move to mesh category module, or to math.gl/geometry module\nimport {TypedArray} from '../../types';\nimport {MeshAttributes} from './mesh-types';\n\ntype TypedArrays = {[key: string]: TypedArray};\n\n/**\n * Holds an axis aligned bounding box\n * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)\n */\ntype BoundingBox = [[number, number, number], [number, number, number]];\n\n/**\n * Get number of vertices in mesh\n * @param attributes\n */\nexport function getMeshSize(attributes: TypedArrays): number {\n  let size = 0;\n  for (const attributeName in attributes) {\n    const attribute = attributes[attributeName];\n    if (ArrayBuffer.isView(attribute)) {\n      // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT\n      size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;\n    }\n  }\n  return size;\n}\n\n/**\n * Get the (axis aligned) bounding box of a mesh\n * @param attributes\n * @returns array of two vectors representing the axis aligned bounding box\n */\n// eslint-disable-next-line complexity\nexport function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox {\n  let minX = Infinity;\n  let minY = Infinity;\n  let minZ = Infinity;\n  let maxX = -Infinity;\n  let maxY = -Infinity;\n  let maxZ = -Infinity;\n\n  const positions = attributes.POSITION ? attributes.POSITION.value : [];\n  const len = positions && positions.length;\n\n  for (let i = 0; i < len; i += 3) {\n    const x = positions[i];\n    const y = positions[i + 1];\n    const z = positions[i + 2];\n\n    minX = x < minX ? x : minX;\n    minY = y < minY ? y : minY;\n    minZ = z < minZ ? z : minZ;\n\n    maxX = x > maxX ? x : maxX;\n    maxY = y > maxY ? y : maxY;\n    maxZ = z > maxZ ? z : maxZ;\n  }\n  return [\n    [minX, minY, minZ],\n    [maxX, maxY, maxZ]\n  ];\n}\n"],"mappings":";;AAiBA,OAAO,SAASA,WAAW,CAACC,UAAuB,EAAU;EAC3D,IAAIC,IAAI,GAAG,CAAC;EACZ,KAAK,MAAMC,aAAa,IAAIF,UAAU,EAAE;IACtC,MAAMG,SAAS,GAAGH,UAAU,CAACE,aAAa,CAAC;IAC3C,IAAIE,WAAW,CAACC,MAAM,CAACF,SAAS,CAAC,EAAE;MAEjCF,IAAI,IAAIE,SAAS,CAACG,UAAU,GAAGH,SAAS,CAACI,iBAAiB;IAC5D;EACF;EACA,OAAON,IAAI;AACb;;AAQA,OAAO,SAASO,kBAAkB,CAACR,UAA0B,EAAe;EAC1E,IAAIS,IAAI,GAAGC,QAAQ;EACnB,IAAIC,IAAI,GAAGD,QAAQ;EACnB,IAAIE,IAAI,GAAGF,QAAQ;EACnB,IAAIG,IAAI,GAAG,CAACH,QAAQ;EACpB,IAAII,IAAI,GAAG,CAACJ,QAAQ;EACpB,IAAIK,IAAI,GAAG,CAACL,QAAQ;EAEpB,MAAMM,SAAS,GAAGhB,UAAU,CAACiB,QAAQ,GAAGjB,UAAU,CAACiB,QAAQ,CAACC,KAAK,GAAG,EAAE;EACtE,MAAMC,GAAG,GAAGH,SAAS,IAAIA,SAAS,CAACI,MAAM;EAEzC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGF,GAAG,EAAEE,CAAC,IAAI,CAAC,EAAE;IAC/B,MAAMC,CAAC,GAAGN,SAAS,CAACK,CAAC,CAAC;IACtB,MAAME,CAAC,GAAGP,SAAS,CAACK,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAMG,CAAC,GAAGR,SAAS,CAACK,CAAC,GAAG,CAAC,CAAC;IAE1BZ,IAAI,GAAGa,CAAC,GAAGb,IAAI,GAAGa,CAAC,GAAGb,IAAI;IAC1BE,IAAI,GAAGY,CAAC,GAAGZ,IAAI,GAAGY,CAAC,GAAGZ,IAAI;IAC1BC,IAAI,GAAGY,CAAC,GAAGZ,IAAI,GAAGY,CAAC,GAAGZ,IAAI;IAE1BC,IAAI,GAAGS,CAAC,GAAGT,IAAI,GAAGS,CAAC,GAAGT,IAAI;IAC1BC,IAAI,GAAGS,CAAC,GAAGT,IAAI,GAAGS,CAAC,GAAGT,IAAI;IAC1BC,IAAI,GAAGS,CAAC,GAAGT,IAAI,GAAGS,CAAC,GAAGT,IAAI;EAC5B;EACA,OAAO,CACL,CAACN,IAAI,EAAEE,IAAI,EAAEC,IAAI,CAAC,EAClB,CAACC,IAAI,EAAEC,IAAI,EAAEC,IAAI,CAAC,CACnB;AACH"}

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

@@ -1,42 +1,34 @@
+
+
 export function deduceTableSchema(table, schema) {
   const deducedSchema = Array.isArray(table) ? deduceSchemaForRowTable(table) : deduceSchemaForColumnarTable(table);
   return Object.assign(deducedSchema, schema);
 }
-
 function deduceSchemaForColumnarTable(columnarTable) {
   const schema = {};
-
   for (const field in columnarTable) {
     const column = columnarTable[field];
-
     if (ArrayBuffer.isView(column)) {
       schema[field] = column.constructor;
     } else if (column.length) {
       const value = column[0];
       schema[field] = deduceTypeFromValue(value);
     }
-
     schema[field] = schema[field] || null;
   }
-
   return schema;
 }
-
 function deduceSchemaForRowTable(rowTable) {
   const schema = {};
-
   if (rowTable.length) {
     const row = rowTable[0];
-
     for (const field in row) {
       const value = row[field];
       schema[field] = deduceTypeFromValue(value);
     }
   }
-
   return schema;
 }
-
 function deduceTypeFromValue(value) {
   if (value instanceof Date) {
     return Date;
@@ -45,7 +37,6 @@ function deduceTypeFromValue(value) {
   } else if (typeof value === 'string') {
     return String;
   }
-
   return null;
 }
 //# sourceMappingURL=deduce-table-schema.js.map

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/category/table/deduce-table-schema.ts"],"names":["deduceTableSchema","table","schema","deducedSchema","Array","isArray","deduceSchemaForRowTable","deduceSchemaForColumnarTable","Object","assign","columnarTable","field","column","ArrayBuffer","isView","constructor","length","value","deduceTypeFromValue","rowTable","row","Date","Number","Float32Array","String"],"mappings":"AAyCA,OAAO,SAASA,iBAAT,CAA2BC,KAA3B,EAAkCC,MAAlC,EAAmD;AACxD,QAAMC,aAAa,GAAGC,KAAK,CAACC,OAAN,CAAcJ,KAAd,IAClBK,uBAAuB,CAACL,KAAD,CADL,GAElBM,4BAA4B,CAACN,KAAD,CAFhC;AAIA,SAAOO,MAAM,CAACC,MAAP,CAAcN,aAAd,EAA6BD,MAA7B,CAAP;AACD;;AAED,SAASK,4BAAT,CAAsCG,aAAtC,EAAqD;AACnD,QAAMR,MAAM,GAAG,EAAf;;AACA,OAAK,MAAMS,KAAX,IAAoBD,aAApB,EAAmC;AACjC,UAAME,MAAM,GAAGF,aAAa,CAACC,KAAD,CAA5B;;AAEA,QAAIE,WAAW,CAACC,MAAZ,CAAmBF,MAAnB,CAAJ,EAAgC;AAC9BV,MAAAA,MAAM,CAACS,KAAD,CAAN,GAAgBC,MAAM,CAACG,WAAvB;AAED,KAHD,MAGO,IAAIH,MAAM,CAACI,MAAX,EAAmB;AACxB,YAAMC,KAAK,GAAGL,MAAM,CAAC,CAAD,CAApB;AACAV,MAAAA,MAAM,CAACS,KAAD,CAAN,GAAgBO,mBAAmB,CAACD,KAAD,CAAnC;AAED;;AAEDf,IAAAA,MAAM,CAACS,KAAD,CAAN,GAAgBT,MAAM,CAACS,KAAD,CAAN,IAAiB,IAAjC;AACD;;AACD,SAAOT,MAAP;AACD;;AAED,SAASI,uBAAT,CAAiCa,QAAjC,EAA2C;AACzC,QAAMjB,MAAM,GAAG,EAAf;;AACA,MAAIiB,QAAQ,CAACH,MAAb,EAAqB;AACnB,UAAMI,GAAG,GAAGD,QAAQ,CAAC,CAAD,CAApB;;AAEA,SAAK,MAAMR,KAAX,IAAoBS,GAApB,EAAyB;AACvB,YAAMH,KAAK,GAAGG,GAAG,CAACT,KAAD,CAAjB;AACAT,MAAAA,MAAM,CAACS,KAAD,CAAN,GAAgBO,mBAAmB,CAACD,KAAD,CAAnC;AACD;AACF;;AACD,SAAOf,MAAP;AACD;;AAED,SAASgB,mBAAT,CAA6BD,KAA7B,EAAoC;AAClC,MAAIA,KAAK,YAAYI,IAArB,EAA2B;AACzB,WAAOA,IAAP;AACD,GAFD,MAEO,IAAIJ,KAAK,YAAYK,MAArB,EAA6B;AAClC,WAAOC,YAAP;AACD,GAFM,MAEA,IAAI,OAAON,KAAP,KAAiB,QAArB,EAA+B;AACpC,WAAOO,MAAP;AACD;;AACD,SAAO,IAAP;AACD","sourcesContent":["// Type deduction\nimport {\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 '../../lib/schema/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\n/**\n * SCHEMA SUPPORT - AUTODEDUCTION\n * @param {*} table\n * @param {*} schema\n * @returns\n */\nexport function deduceTableSchema(table, schema?: Schema) {\n  const deducedSchema = Array.isArray(table)\n    ? deduceSchemaForRowTable(table)\n    : deduceSchemaForColumnarTable(table);\n  // Deduced schema will fill in missing info from partial options.schema, if provided\n  return Object.assign(deducedSchema, schema);\n}\n\nfunction deduceSchemaForColumnarTable(columnarTable) {\n  const schema = {};\n  for (const field in columnarTable) {\n    const column = columnarTable[field];\n    // Check if column is typed, if so we are done\n    if (ArrayBuffer.isView(column)) {\n      schema[field] = column.constructor;\n      // else we need data\n    } else if (column.length) {\n      const value = column[0];\n      schema[field] = deduceTypeFromValue(value);\n      // TODO - support nested schemas?\n    }\n    // else we mark as present but unknow\n    schema[field] = schema[field] || null;\n  }\n  return schema;\n}\n\nfunction deduceSchemaForRowTable(rowTable) {\n  const schema = {};\n  if (rowTable.length) {\n    const row = rowTable[0];\n    // TODO - Could look at additional rows if nulls in first row\n    for (const field in row) {\n      const value = row[field];\n      schema[field] = deduceTypeFromValue(value);\n    }\n  }\n  return schema;\n}\n\nfunction deduceTypeFromValue(value) {\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-table-schema.js"}
+{"version":3,"file":"deduce-table-schema.js","names":["deduceTableSchema","table","schema","deducedSchema","Array","isArray","deduceSchemaForRowTable","deduceSchemaForColumnarTable","Object","assign","columnarTable","field","column","ArrayBuffer","isView","constructor","length","value","deduceTypeFromValue","rowTable","row","Date","Number","Float32Array","String"],"sources":["../../../../src/category/table/deduce-table-schema.ts"],"sourcesContent":["// Type deduction\nimport {\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 '../../lib/schema/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\n/**\n * SCHEMA SUPPORT - AUTODEDUCTION\n * @param {*} table\n * @param {*} schema\n * @returns\n */\nexport function deduceTableSchema(table, schema?: Schema) {\n  const deducedSchema = Array.isArray(table)\n    ? deduceSchemaForRowTable(table)\n    : deduceSchemaForColumnarTable(table);\n  // Deduced schema will fill in missing info from partial options.schema, if provided\n  return Object.assign(deducedSchema, schema);\n}\n\nfunction deduceSchemaForColumnarTable(columnarTable) {\n  const schema = {};\n  for (const field in columnarTable) {\n    const column = columnarTable[field];\n    // Check if column is typed, if so we are done\n    if (ArrayBuffer.isView(column)) {\n      schema[field] = column.constructor;\n      // else we need data\n    } else if (column.length) {\n      const value = column[0];\n      schema[field] = deduceTypeFromValue(value);\n      // TODO - support nested schemas?\n    }\n    // else we mark as present but unknow\n    schema[field] = schema[field] || null;\n  }\n  return schema;\n}\n\nfunction deduceSchemaForRowTable(rowTable) {\n  const schema = {};\n  if (rowTable.length) {\n    const row = rowTable[0];\n    // TODO - Could look at additional rows if nulls in first row\n    for (const field in row) {\n      const value = row[field];\n      schema[field] = deduceTypeFromValue(value);\n    }\n  }\n  return schema;\n}\n\nfunction deduceTypeFromValue(value) {\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"],"mappings":";;AAyCA,OAAO,SAASA,iBAAiB,CAACC,KAAK,EAAEC,MAAe,EAAE;EACxD,MAAMC,aAAa,GAAGC,KAAK,CAACC,OAAO,CAACJ,KAAK,CAAC,GACtCK,uBAAuB,CAACL,KAAK,CAAC,GAC9BM,4BAA4B,CAACN,KAAK,CAAC;EAEvC,OAAOO,MAAM,CAACC,MAAM,CAACN,aAAa,EAAED,MAAM,CAAC;AAC7C;AAEA,SAASK,4BAA4B,CAACG,aAAa,EAAE;EACnD,MAAMR,MAAM,GAAG,CAAC,CAAC;EACjB,KAAK,MAAMS,KAAK,IAAID,aAAa,EAAE;IACjC,MAAME,MAAM,GAAGF,aAAa,CAACC,KAAK,CAAC;IAEnC,IAAIE,WAAW,CAACC,MAAM,CAACF,MAAM,CAAC,EAAE;MAC9BV,MAAM,CAACS,KAAK,CAAC,GAAGC,MAAM,CAACG,WAAW;IAEpC,CAAC,MAAM,IAAIH,MAAM,CAACI,MAAM,EAAE;MACxB,MAAMC,KAAK,GAAGL,MAAM,CAAC,CAAC,CAAC;MACvBV,MAAM,CAACS,KAAK,CAAC,GAAGO,mBAAmB,CAACD,KAAK,CAAC;IAE5C;IAEAf,MAAM,CAACS,KAAK,CAAC,GAAGT,MAAM,CAACS,KAAK,CAAC,IAAI,IAAI;EACvC;EACA,OAAOT,MAAM;AACf;AAEA,SAASI,uBAAuB,CAACa,QAAQ,EAAE;EACzC,MAAMjB,MAAM,GAAG,CAAC,CAAC;EACjB,IAAIiB,QAAQ,CAACH,MAAM,EAAE;IACnB,MAAMI,GAAG,GAAGD,QAAQ,CAAC,CAAC,CAAC;IAEvB,KAAK,MAAMR,KAAK,IAAIS,GAAG,EAAE;MACvB,MAAMH,KAAK,GAAGG,GAAG,CAACT,KAAK,CAAC;MACxBT,MAAM,CAACS,KAAK,CAAC,GAAGO,mBAAmB,CAACD,KAAK,CAAC;IAC5C;EACF;EACA,OAAOf,MAAM;AACf;AAEA,SAASgB,mBAAmB,CAACD,KAAK,EAAE;EAClC,IAAIA,KAAK,YAAYI,IAAI,EAAE;IACzB,OAAOA,IAAI;EACb,CAAC,MAAM,IAAIJ,KAAK,YAAYK,MAAM,EAAE;IAClC,OAAOC,YAAY;EACrB,CAAC,MAAM,IAAI,OAAON,KAAK,KAAK,QAAQ,EAAE;IACpC,OAAOO,MAAM;EACf;EACA,OAAO,IAAI;AACb"}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"table-types.js"}
+{"version":3,"file":"table-types.js","names":[],"sources":["../../../../src/category/table/table-types.ts"],"sourcesContent":["import type {Schema} from '../../lib/schema/schema';\nimport type {Table as ApacheArrowTable, RecordBatch} from 'apache-arrow/Arrow.dom';\nimport type {AnyArray} from '../../types';\nimport type {Batch} from '../common';\nimport type {Feature} from '../gis';\n\n/** A general table */\nexport interface Table {\n  shape:\n    | 'row-table'\n    | 'array-row-table'\n    | 'object-row-table'\n    | 'geojson-row-table'\n    | 'columnar-table'\n    | 'arrow-table';\n  schema?: Schema;\n  schemaType?: 'explicit' | 'deduced';\n}\n\n/** A table organized as an array of rows */\nexport interface RowTable extends Table {\n  shape: 'row-table' | 'array-row-table' | 'object-row-table' | 'geojson-row-table';\n  data: any[];\n}\n\n/** A table organized as an array of rows, each row is an array of values */\nexport interface ArrayRowTable extends RowTable {\n  shape: 'array-row-table';\n  data: any[][];\n}\n\n/** A table organized as an array of rows, each row is an object mapping columns to values */\nexport interface ObjectRowTable extends RowTable {\n  shape: 'object-row-table';\n  data: {[columnName: string]: any}[];\n}\n\n/** A table organized as an array of rows, each row is a GeoJSON Feature */\nexport interface GeoJSONRowTable extends RowTable {\n  shape: 'geojson-row-table';\n  data: Feature[];\n}\n\n/** A table organized as a map of columns, each column is an array of value */\nexport interface ColumnarTable extends Table {\n  shape: 'columnar-table';\n  data: {[columnName: string]: AnyArray};\n}\n\n/** A table organized as an Apache Arrow table */\nexport interface ArrowTable extends Table {\n  shape: 'arrow-table';\n  data: ApacheArrowTable;\n}\n\n/** A collection of tables */\nexport type Tables<TableType extends Table = Table> = {\n  shape: 'tables';\n  tables: {name: string; table: TableType}[];\n};\n\n// Batches\n\n/** Batch for a general table */\nexport type TableBatch = Batch & {\n  data: any;\n  length: number;\n  schema?: Schema;\n  schemaType?: 'explicit' | 'deduced';\n};\n\n/** Batch for a table organized as an array of rows */\nexport type RowTableBatch = TableBatch & {\n  shape: 'row-table';\n  data: any[];\n};\n\n/** Batch for a table organized as an array of rows, each row is an array of values */\nexport type RowArrayTableBatch = RowTableBatch & {\n  shape: 'array-row-table';\n  data: any[][];\n};\n\n/** Batch for a table organized as an array of rows, each row is an object mapping columns to values */\nexport type RowObjectTableBatch = RowTableBatch & {\n  shape: 'object-row-table';\n  data: {[columnName: string]: any}[];\n};\n\n/** Batch for a table organized as an array of rows, each row is an array of values */\nexport type GeoJSONRowTableBatch = RowTableBatch & {\n  shape: 'geojson-row-table';\n  data: Feature[];\n};\n\n/** Batch for a table organized as a map of columns, each column is an array of value */\nexport type ColumnarTableBatch = TableBatch & {\n  shape: 'columnar-table';\n  data: {[columnName: string]: AnyArray};\n};\n\n/** Batch for a table organized as an Apache Arrow table */\nexport type ArrowTableBatch = TableBatch & {\n  shape: 'arrow-table';\n  data: RecordBatch;\n};\n"],"mappings":""}

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"texture.js"}
+{"version":3,"file":"texture.js","names":[],"sources":["../../../../src/category/texture/texture.ts"],"sourcesContent":["import type {ImageType} from '../image/image';\n\n/**\n * These represent the main compressed texture formats\n * Each format typically has a number of more specific subformats\n */\nexport type GPUTextureFormat =\n  | 'dxt'\n  | 'dxt-srgb'\n  | 'etc1'\n  | 'etc2'\n  | 'pvrtc'\n  | 'atc'\n  | 'astc'\n  | 'rgtc';\n\n/** One mip level */\nexport type TextureLevel = {\n  compressed: boolean;\n  format?: number;\n  data: Uint8Array;\n  width: number;\n  height: number;\n  levelSize?: number;\n  hasAlpha?: boolean;\n};\n\nexport type TextureOrImage = ImageType | (TextureLevel | ImageType);\n"],"mappings":""}

package/dist/esm/index.js

@@ -1,10 +1,15 @@
+
+
 export { default as TableBatchBuilder } from './lib/batches/table-batch-builder';
 export { default as RowTableBatchAggregator } from './lib/batches/row-table-batch-aggregator';
 export { default as ColumnarTableBatchAggregator } from './lib/batches/columnar-table-batch-aggregator';
 export { convertToObjectRow, convertToArrayRow } from './lib/utils/row-utils';
+
 export { getMeshSize, getMeshBoundingBox } from './category/mesh/mesh-utils';
 export { deduceMeshSchema, deduceMeshField, makeMeshAttributeMetadata } from './category/mesh/deduce-mesh-schema';
+
 export { Schema, Field, DataType, Null, Binary, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Utf8, Date, DateDay, DateMillisecond, Time, TimeMillisecond, TimeSecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Interval, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct } from './lib/schema/schema';
+
 export { deduceTypeFromColumn, deduceTypeFromValue } from './lib/schema-utils/deduce-column-type';
 export { getTypeInfo } from './lib/arrow/get-type-info';
 export { getArrowTypeFromTypedArray } from './lib/arrow/arrow-like-type-utils';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":["default","TableBatchBuilder","RowTableBatchAggregator","ColumnarTableBatchAggregator","convertToObjectRow","convertToArrayRow","getMeshSize","getMeshBoundingBox","deduceMeshSchema","deduceMeshField","makeMeshAttributeMetadata","Schema","Field","DataType","Null","Binary","Bool","Int","Int8","Int16","Int32","Int64","Uint8","Uint16","Uint32","Uint64","Float","Float16","Float32","Float64","Utf8","Date","DateDay","DateMillisecond","Time","TimeMillisecond","TimeSecond","Timestamp","TimestampSecond","TimestampMillisecond","TimestampMicrosecond","TimestampNanosecond","Interval","IntervalDayTime","IntervalYearMonth","FixedSizeList","Struct","deduceTypeFromColumn","deduceTypeFromValue","getTypeInfo","getArrowTypeFromTypedArray","AsyncQueue"],"mappings":"AAyBA,SAAQA,OAAO,IAAIC,iBAAnB,QAA2C,mCAA3C;AAEA,SAAQD,OAAO,IAAIE,uBAAnB,QAAiD,0CAAjD;AACA,SAAQF,OAAO,IAAIG,4BAAnB,QAAsD,+CAAtD;AAEA,SAAQC,kBAAR,EAA4BC,iBAA5B,QAAoD,uBAApD;AAYA,SAAQC,WAAR,EAAqBC,kBAArB,QAA8C,4BAA9C;AAGA,SACEC,gBADF,EAEEC,eAFF,EAGEC,yBAHF,QAIO,oCAJP;AA4DA,SACEC,MADF,EAEEC,KAFF,EAGEC,QAHF,EAIEC,IAJF,EAKEC,MALF,EAMEC,IANF,EAOEC,GAPF,EAQEC,IARF,EASEC,KATF,EAUEC,KAVF,EAWEC,KAXF,EAYEC,KAZF,EAaEC,MAbF,EAcEC,MAdF,EAeEC,MAfF,EAgBEC,KAhBF,EAiBEC,OAjBF,EAkBEC,OAlBF,EAmBEC,OAnBF,EAoBEC,IApBF,EAqBEC,IArBF,EAsBEC,OAtBF,EAuBEC,eAvBF,EAwBEC,IAxBF,EAyBEC,eAzBF,EA0BEC,UA1BF,EA2BEC,SA3BF,EA4BEC,eA5BF,EA6BEC,oBA7BF,EA8BEC,oBA9BF,EA+BEC,mBA/BF,EAgCEC,QAhCF,EAiCEC,eAjCF,EAkCEC,iBAlCF,EAmCEC,aAnCF,EAoCEC,MApCF,QAqCO,qBArCP;AA0CA,SAAQC,oBAAR,EAA8BC,mBAA9B,QAAwD,uCAAxD;AACA,SAAQC,WAAR,QAA0B,2BAA1B;AACA,SAAQC,0BAAR,QAAyC,mCAAzC;AAEA,SAAQlD,OAAO,IAAImD,UAAnB,QAAoC,yBAApC","sourcesContent":["// COMMON CATEGORY\nexport type {TypedArray, NumberArray, AnyArray} from './types';\n\nexport type {Batch} from './category/common';\n\n// TABLE CATEGORY TYPES\nexport type {\n  Table,\n  ArrayRowTable,\n  ObjectRowTable,\n  GeoJSONRowTable,\n  ColumnarTable,\n  ArrowTable,\n  Tables\n} from './category/table/table-types';\nexport type {\n  TableBatch,\n  RowArrayTableBatch,\n  RowObjectTableBatch,\n  GeoJSONRowTableBatch,\n  ColumnarTableBatch,\n  ArrowTableBatch\n} from './category/table/table-types';\n\n// TABLE CATEGORY UTILS\nexport {default as TableBatchBuilder} from './lib/batches/table-batch-builder';\nexport type {TableBatchAggregator} from './lib/batches/table-batch-aggregator';\nexport {default as RowTableBatchAggregator} from './lib/batches/row-table-batch-aggregator';\nexport {default as ColumnarTableBatchAggregator} from './lib/batches/columnar-table-batch-aggregator';\n\nexport {convertToObjectRow, convertToArrayRow} from './lib/utils/row-utils';\n\n// MESH CATEGORY\nexport type {\n  MeshTable,\n  MeshArrowTable,\n  Mesh,\n  MeshGeometry,\n  MeshAttribute,\n  MeshAttributes\n} from './category/mesh/mesh-types';\n\nexport {getMeshSize, getMeshBoundingBox} from './category/mesh/mesh-utils';\n// Commented out due to https://github.com/visgl/deck.gl/issues/6906 and https://github.com/visgl/loaders.gl/issues/2177\n// export {convertMesh} from './category/mesh/convert-mesh';\nexport {\n  deduceMeshSchema,\n  deduceMeshField,\n  makeMeshAttributeMetadata\n} from './category/mesh/deduce-mesh-schema';\n\n// TEXTURES\nexport type {TextureLevel, GPUTextureFormat} from './category/texture/texture';\n\n// IMAGES\nexport type {ImageDataType, ImageType, ImageTypeEnum} from './category/image/image';\n\n// TYPES\n// GIS CATEGORY - GEOJSON\nexport type {\n  GeoJSON,\n  Feature,\n  FeatureCollection,\n  Geometry,\n  Position,\n  GeoJsonProperties,\n  Point,\n  MultiPoint,\n  LineString,\n  MultiLineString,\n  Polygon,\n  MultiPolygon,\n  GeometryCollection\n} from './category/gis';\n\nexport type {GeojsonGeometryInfo} from './category/gis';\n\n// GIS CATEGORY - FLAT GEOJSON\nexport type {\n  FlatFeature,\n  FlatIndexedGeometry,\n  FlatGeometry,\n  FlatGeometryType,\n  FlatPoint,\n  FlatLineString,\n  FlatPolygon\n} from './category/gis';\n\n// GIS CATEGORY - BINARY\nexport type {\n  BinaryGeometryType,\n  BinaryGeometry,\n  BinaryPointGeometry,\n  BinaryLineGeometry,\n  BinaryPolygonGeometry,\n  BinaryAttribute\n} from './category/gis';\nexport type {\n  BinaryFeatures,\n  BinaryPointFeatures,\n  BinaryLineFeatures,\n  BinaryPolygonFeatures\n} from './category/gis';\n\n// SCHEMA\nexport {\n  Schema,\n  Field,\n  DataType,\n  Null,\n  Binary,\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  Utf8,\n  Date,\n  DateDay,\n  DateMillisecond,\n  Time,\n  TimeMillisecond,\n  TimeSecond,\n  Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  Interval,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList,\n  Struct\n} from './lib/schema/schema';\n\n// EXPERIMENTAL APIs\n\n// SCHEMA UTILS\nexport {deduceTypeFromColumn, deduceTypeFromValue} from './lib/schema-utils/deduce-column-type';\nexport {getTypeInfo} from './lib/arrow/get-type-info';\nexport {getArrowTypeFromTypedArray} from './lib/arrow/arrow-like-type-utils';\n\nexport {default as AsyncQueue} from './lib/utils/async-queue';\n"],"file":"index.js"}
+{"version":3,"file":"index.js","names":["default","TableBatchBuilder","RowTableBatchAggregator","ColumnarTableBatchAggregator","convertToObjectRow","convertToArrayRow","getMeshSize","getMeshBoundingBox","deduceMeshSchema","deduceMeshField","makeMeshAttributeMetadata","Schema","Field","DataType","Null","Binary","Bool","Int","Int8","Int16","Int32","Int64","Uint8","Uint16","Uint32","Uint64","Float","Float16","Float32","Float64","Utf8","Date","DateDay","DateMillisecond","Time","TimeMillisecond","TimeSecond","Timestamp","TimestampSecond","TimestampMillisecond","TimestampMicrosecond","TimestampNanosecond","Interval","IntervalDayTime","IntervalYearMonth","FixedSizeList","Struct","deduceTypeFromColumn","deduceTypeFromValue","getTypeInfo","getArrowTypeFromTypedArray","AsyncQueue"],"sources":["../../src/index.ts"],"sourcesContent":["// COMMON CATEGORY\nexport type {TypedArray, NumberArray, AnyArray} from './types';\n\nexport type {Batch} from './category/common';\n\n// TABLE CATEGORY TYPES\nexport type {\n  Table,\n  ArrayRowTable,\n  ObjectRowTable,\n  GeoJSONRowTable,\n  ColumnarTable,\n  ArrowTable,\n  Tables\n} from './category/table/table-types';\nexport type {\n  TableBatch,\n  RowArrayTableBatch,\n  RowObjectTableBatch,\n  GeoJSONRowTableBatch,\n  ColumnarTableBatch,\n  ArrowTableBatch\n} from './category/table/table-types';\n\n// TABLE CATEGORY UTILS\nexport {default as TableBatchBuilder} from './lib/batches/table-batch-builder';\nexport type {TableBatchAggregator} from './lib/batches/table-batch-aggregator';\nexport {default as RowTableBatchAggregator} from './lib/batches/row-table-batch-aggregator';\nexport {default as ColumnarTableBatchAggregator} from './lib/batches/columnar-table-batch-aggregator';\n\nexport {convertToObjectRow, convertToArrayRow} from './lib/utils/row-utils';\n\n// MESH CATEGORY\nexport type {\n  MeshTable,\n  MeshArrowTable,\n  Mesh,\n  MeshGeometry,\n  MeshAttribute,\n  MeshAttributes\n} from './category/mesh/mesh-types';\n\nexport {getMeshSize, getMeshBoundingBox} from './category/mesh/mesh-utils';\n// Commented out due to https://github.com/visgl/deck.gl/issues/6906 and https://github.com/visgl/loaders.gl/issues/2177\n// export {convertMesh} from './category/mesh/convert-mesh';\nexport {\n  deduceMeshSchema,\n  deduceMeshField,\n  makeMeshAttributeMetadata\n} from './category/mesh/deduce-mesh-schema';\n\n// TEXTURES\nexport type {TextureLevel, GPUTextureFormat} from './category/texture/texture';\n\n// IMAGES\nexport type {ImageDataType, ImageType, ImageTypeEnum} from './category/image/image';\n\n// TYPES\n// GIS CATEGORY - GEOJSON\nexport type {\n  GeoJSON,\n  Feature,\n  FeatureCollection,\n  Geometry,\n  Position,\n  GeoJsonProperties,\n  Point,\n  MultiPoint,\n  LineString,\n  MultiLineString,\n  Polygon,\n  MultiPolygon,\n  GeometryCollection\n} from './category/gis';\n\nexport type {GeojsonGeometryInfo} from './category/gis';\n\n// GIS CATEGORY - FLAT GEOJSON\nexport type {\n  FlatFeature,\n  FlatIndexedGeometry,\n  FlatGeometry,\n  FlatGeometryType,\n  FlatPoint,\n  FlatLineString,\n  FlatPolygon\n} from './category/gis';\n\n// GIS CATEGORY - BINARY\nexport type {\n  BinaryGeometryType,\n  BinaryGeometry,\n  BinaryPointGeometry,\n  BinaryLineGeometry,\n  BinaryPolygonGeometry,\n  BinaryAttribute\n} from './category/gis';\nexport type {\n  BinaryFeatures,\n  BinaryPointFeatures,\n  BinaryLineFeatures,\n  BinaryPolygonFeatures\n} from './category/gis';\n\n// SCHEMA\nexport {\n  Schema,\n  Field,\n  DataType,\n  Null,\n  Binary,\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  Utf8,\n  Date,\n  DateDay,\n  DateMillisecond,\n  Time,\n  TimeMillisecond,\n  TimeSecond,\n  Timestamp,\n  TimestampSecond,\n  TimestampMillisecond,\n  TimestampMicrosecond,\n  TimestampNanosecond,\n  Interval,\n  IntervalDayTime,\n  IntervalYearMonth,\n  FixedSizeList,\n  Struct\n} from './lib/schema/schema';\n\n// EXPERIMENTAL APIs\n\n// SCHEMA UTILS\nexport {deduceTypeFromColumn, deduceTypeFromValue} from './lib/schema-utils/deduce-column-type';\nexport {getTypeInfo} from './lib/arrow/get-type-info';\nexport {getArrowTypeFromTypedArray} from './lib/arrow/arrow-like-type-utils';\n\nexport {default as AsyncQueue} from './lib/utils/async-queue';\n"],"mappings":";;AAyBA,SAAQA,OAAO,IAAIC,iBAAiB,QAAO,mCAAmC;AAE9E,SAAQD,OAAO,IAAIE,uBAAuB,QAAO,0CAA0C;AAC3F,SAAQF,OAAO,IAAIG,4BAA4B,QAAO,+CAA+C;AAErG,SAAQC,kBAAkB,EAAEC,iBAAiB,QAAO,uBAAuB;;AAY3E,SAAQC,WAAW,EAAEC,kBAAkB,QAAO,4BAA4B;AAG1E,SACEC,gBAAgB,EAChBC,eAAe,EACfC,yBAAyB,QACpB,oCAAoC;;AAwD3C,SACEC,MAAM,EACNC,KAAK,EACLC,QAAQ,EACRC,IAAI,EACJC,MAAM,EACNC,IAAI,EACJC,GAAG,EACHC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,KAAK,EACLC,MAAM,EACNC,MAAM,EACNC,MAAM,EACNC,KAAK,EACLC,OAAO,EACPC,OAAO,EACPC,OAAO,EACPC,IAAI,EACJC,IAAI,EACJC,OAAO,EACPC,eAAe,EACfC,IAAI,EACJC,eAAe,EACfC,UAAU,EACVC,SAAS,EACTC,eAAe,EACfC,oBAAoB,EACpBC,oBAAoB,EACpBC,mBAAmB,EACnBC,QAAQ,EACRC,eAAe,EACfC,iBAAiB,EACjBC,aAAa,EACbC,MAAM,QACD,qBAAqB;;AAK5B,SAAQC,oBAAoB,EAAEC,mBAAmB,QAAO,uCAAuC;AAC/F,SAAQC,WAAW,QAAO,2BAA2B;AACrD,SAAQC,0BAA0B,QAAO,mCAAmC;AAE5E,SAAQlD,OAAO,IAAImD,UAAU,QAAO,yBAAyB"}

package/dist/esm/lib/arrow/arrow-like-type-utils.js

@@ -3,28 +3,20 @@ export function getArrowTypeFromTypedArray(array) {
   switch (array.constructor) {
     case Int8Array:
       return new Int8();
-
     case Uint8Array:
       return new Uint8();
-
     case Int16Array:
       return new Int16();
-
     case Uint16Array:
       return new Uint16();
-
     case Int32Array:
       return new Int32();
-
     case Uint32Array:
       return new Uint32();
-
     case Float32Array:
       return new Float32();
-
     case Float64Array:
       return new Float64();
-
     default:
       throw new Error('array type not supported');
   }

package/dist/esm/lib/arrow/arrow-like-type-utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/arrow/arrow-like-type-utils.ts"],"names":["Float32","Float64","Int16","Int32","Int8","Uint16","Uint32","Uint8","getArrowTypeFromTypedArray","array","constructor","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","Error"],"mappings":"AACA,SAEEA,OAFF,EAGEC,OAHF,EAIEC,KAJF,EAKEC,KALF,EAMEC,IANF,EAOEC,MAPF,EAQEC,MARF,EASEC,KATF,QAUO,kBAVP;AAYA,OAAO,SAASC,0BAAT,CAAoCC,KAApC,EAAiE;AACtE,UAAQA,KAAK,CAACC,WAAd;AACE,SAAKC,SAAL;AACE,aAAO,IAAIP,IAAJ,EAAP;;AACF,SAAKQ,UAAL;AACE,aAAO,IAAIL,KAAJ,EAAP;;AACF,SAAKM,UAAL;AACE,aAAO,IAAIX,KAAJ,EAAP;;AACF,SAAKY,WAAL;AACE,aAAO,IAAIT,MAAJ,EAAP;;AACF,SAAKU,UAAL;AACE,aAAO,IAAIZ,KAAJ,EAAP;;AACF,SAAKa,WAAL;AACE,aAAO,IAAIV,MAAJ,EAAP;;AACF,SAAKW,YAAL;AACE,aAAO,IAAIjB,OAAJ,EAAP;;AACF,SAAKkB,YAAL;AACE,aAAO,IAAIjB,OAAJ,EAAP;;AACF;AACE,YAAM,IAAIkB,KAAJ,CAAU,0BAAV,CAAN;AAlBJ;AAoBD","sourcesContent":["import type {TypedArray} from '../../types';\nimport {\n  DataType,\n  Float32,\n  Float64,\n  Int16,\n  Int32,\n  Int8,\n  Uint16,\n  Uint32,\n  Uint8\n} from '../schema/schema';\n\nexport function getArrowTypeFromTypedArray(array: TypedArray): DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new Int8();\n    case Uint8Array:\n      return new Uint8();\n    case Int16Array:\n      return new Int16();\n    case Uint16Array:\n      return new Uint16();\n    case Int32Array:\n      return new Int32();\n    case Uint32Array:\n      return new Uint32();\n    case Float32Array:\n      return new Float32();\n    case Float64Array:\n      return new Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n"],"file":"arrow-like-type-utils.js"}
+{"version":3,"file":"arrow-like-type-utils.js","names":["Float32","Float64","Int16","Int32","Int8","Uint16","Uint32","Uint8","getArrowTypeFromTypedArray","array","constructor","Int8Array","Uint8Array","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","Error"],"sources":["../../../../src/lib/arrow/arrow-like-type-utils.ts"],"sourcesContent":["import type {TypedArray} from '../../types';\nimport {\n  DataType,\n  Float32,\n  Float64,\n  Int16,\n  Int32,\n  Int8,\n  Uint16,\n  Uint32,\n  Uint8\n} from '../schema/schema';\n\nexport function getArrowTypeFromTypedArray(array: TypedArray): DataType {\n  switch (array.constructor) {\n    case Int8Array:\n      return new Int8();\n    case Uint8Array:\n      return new Uint8();\n    case Int16Array:\n      return new Int16();\n    case Uint16Array:\n      return new Uint16();\n    case Int32Array:\n      return new Int32();\n    case Uint32Array:\n      return new Uint32();\n    case Float32Array:\n      return new Float32();\n    case Float64Array:\n      return new Float64();\n    default:\n      throw new Error('array type not supported');\n  }\n}\n"],"mappings":"AACA,SAEEA,OAAO,EACPC,OAAO,EACPC,KAAK,EACLC,KAAK,EACLC,IAAI,EACJC,MAAM,EACNC,MAAM,EACNC,KAAK,QACA,kBAAkB;AAEzB,OAAO,SAASC,0BAA0B,CAACC,KAAiB,EAAY;EACtE,QAAQA,KAAK,CAACC,WAAW;IACvB,KAAKC,SAAS;MACZ,OAAO,IAAIP,IAAI,EAAE;IACnB,KAAKQ,UAAU;MACb,OAAO,IAAIL,KAAK,EAAE;IACpB,KAAKM,UAAU;MACb,OAAO,IAAIX,KAAK,EAAE;IACpB,KAAKY,WAAW;MACd,OAAO,IAAIT,MAAM,EAAE;IACrB,KAAKU,UAAU;MACb,OAAO,IAAIZ,KAAK,EAAE;IACpB,KAAKa,WAAW;MACd,OAAO,IAAIV,MAAM,EAAE;IACrB,KAAKW,YAAY;MACf,OAAO,IAAIjB,OAAO,EAAE;IACtB,KAAKkB,YAAY;MACf,OAAO,IAAIjB,OAAO,EAAE;IACtB;MACE,MAAM,IAAIkB,KAAK,CAAC,0BAA0B,CAAC;EAAC;AAElD"}

package/dist/esm/lib/arrow/arrow-type-utils.js

@@ -3,28 +3,20 @@ export function getArrowType(array) {
   switch (array.constructor) {
     case Int8Array:
       return new Int8();
-
     case Uint8Array:
       return new Uint8();
-
     case Int16Array:
       return new Int16();
-
     case Uint16Array:
       return new Uint16();
-
     case Int32Array:
       return new Int32();
-
     case Uint32Array:
       return new Uint32();
-
     case Float32Array:
       return new Float32();
-
     case Float64Array:
       return new Float64();
-
     default:
       throw new Error('array type not supported');
   }
@@ -33,28 +25,20 @@ export function getArrowVector(array) {
   switch (array.constructor) {
     case Int8Array:
       return Int8Vector.from(array);
-
     case Uint8Array:
       return Uint8Vector.from(array);
-
     case Int16Array:
       return Int16Vector.from(array);
-
     case Uint16Array:
       return Uint16Vector.from(array);
-
     case Int32Array:
       return Int32Vector.from(array);
-
     case Uint32Array:
       return Uint32Vector.from(array);
-
     case Float32Array:
       return Float32Vector.from(array);
-
     case Float64Array:
       return Float64Vector.from(array);
-
     default:
       throw new Error('array type not supported');
   }