@loaders.gl/schema 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/esm/types/schema.js

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

package/dist/esm/types/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","names":[],"sources":["../../../src/types/schema.ts"],"sourcesContent":["// loaders.gl, MIT license\n\nimport type {RecordBatch} from 'apache-arrow';\n\n/** For dictionary type */\nexport type KeyType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32';\n\n/** ArrowLike DataType class */\nexport type DataType =\n  | 'null'\n  // Primitive types\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-day'\n  | 'date-millisecond'\n  | 'time-second'\n  | 'time-millisecond'\n  | 'time-microsecond'\n  | 'time-nanosecond'\n  | 'timestamp-second'\n  | 'timestamp-millisecond'\n  | 'timestamp-microsecond'\n  | 'timestamp-nanosecond'\n  | 'interval-daytime'\n  | 'interval-yearmonth'\n  // Composite types\n  | {type: 'list'; children: Field[]} // one child only\n  | {type: 'struct'; children: Field[]}\n  | {\n      type: 'sparse-union';\n      typeIds: Int32Array;\n      children: Field[];\n      typeIdToChildIndex: {[key: number]: number};\n    }\n  | {\n      type: 'dense-union';\n      typeIds: Int32Array;\n      children: Field[];\n      typeIdToChildIndex: {[key: number]: number};\n    }\n  | {type: 'fixed-size-binary'; byteWidth: number}\n  | {type: 'fixed-size-list'; listSize: number; children: Field[]}\n  | {type: 'map'; keysSorted: boolean; children: Field[]} // Field is \"struct\"\n  | {type: 'dictionary'; id: number; indices: KeyType; dictionary: DataType; isOrdered: boolean};\n// TODO - unions etc\n\n/**\n * SchemaMetadata\n */\nexport type SchemaMetadata = Record<string, string>;\nexport type FieldMetadata = Record<string, string>;\n\nexport type Field = {\n  name: string;\n  type: DataType;\n  nullable?: boolean;\n  metadata?: FieldMetadata;\n};\n\n/**\n * `Schema` type that that can hold all data required by an Arrow Schema\n * but is fully serializable. Helper functions make it easy to convert to and from arrow schemas\n * https://loaders.gl/arrowjs/docs/api-reference/schema\n */\nexport type Schema = {\n  fields: Field[];\n  metadata: SchemaMetadata;\n};\n\nexport type Batch = {\n  batchType: 'data' | 'metadata' | 'partial-result' | 'final-result';\n  batch?: number;\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"],"mappings":""}

package/dist/esm/types/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/types/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\nexport type TypedArrayConstructor =\n  | Int8ArrayConstructor\n  | Uint8ArrayConstructor\n  | Int16ArrayConstructor\n  | Uint16ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Int32ArrayConstructor\n  | Uint32ArrayConstructor\n  | Float32ArrayConstructor\n  | Float64ArrayConstructor;\n\nexport type BigTypedArrayConstructor =\n  | TypedArrayConstructor\n  | BigInt64ArrayConstructor\n  | BigUint64ArrayConstructor;\n\n/** Any numeric array: typed array or `number[]` */\nexport type NumberArray = number[] | TypedArray;\n\nexport type NumericArray = number[] | TypedArray;\n\nexport interface ArrayType<T = unknown> {\n  readonly length: number;\n  [n: number]: T;\n}\n\n/** Any array: typed array or js array (`any[]`) */\nexport type AnyArray = any[] | TypedArray;\n"],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,29 @@
+export type { TypedArray, TypedArrayConstructor, NumberArray, ArrayType, AnyArray } from './types/types';
+export type { Schema, Field, DataType, Batch, SchemaMetadata, FieldMetadata } from './types/schema';
+export type { Table, RowTable, ArrayRowTable, ObjectRowTable, GeoJSONRowTable, ColumnarTable, ArrowTable, Tables } from './types/category-table';
+export type { TableBatch, ArrayRowTableBatch, ObjectRowTableBatch, GeoJSONRowTableBatch, ColumnarTableBatch, ArrowTableBatch } from './types/category-table';
+export { TableBatchBuilder } from './lib/table/batches/table-batch-builder';
+export type { TableBatchAggregator } from './lib/table/batches/table-batch-aggregator';
+export { RowTableBatchAggregator } from './lib/table/batches/row-table-batch-aggregator';
+export { ColumnarTableBatchAggregator } from './lib/table/batches/columnar-table-batch-aggregator';
+export { getTableLength, getTableNumCols, getTableCell, getTableRowShape, getTableColumnIndex, getTableColumnName, getTableRowAsObject, getTableRowAsArray, makeRowIterator, makeArrayRowIterator, makeObjectRowIterator } from './lib/table/simple-table/table-accessors';
+export { ArrowLikeTable } from './lib/table/arrow-api/arrow-like-table';
+export { makeTableFromData } from './lib/table/simple-table/make-table';
+export { deduceTableSchema } from './lib/table/simple-table/table-schema';
+export { convertToObjectRow, convertToArrayRow } from './lib/table/simple-table/row-utils';
+export { getDataTypeFromArray } from './lib/table/simple-table/data-type';
+export type { MeshTable, MeshArrowTable, Mesh, MeshGeometry, MeshAttribute, MeshAttributes } from './types/category-mesh';
+export { getMeshSize, getMeshBoundingBox } from './lib/mesh/mesh-utils';
+export { deduceMeshSchema, deduceMeshField, makeMeshAttributeMetadata } from './lib/mesh/deduce-mesh-schema';
+export type { TextureLevel, GPUTextureFormat } from './types/category-texture';
+export type { ImageDataType, ImageType, ImageTypeEnum } from './types/category-image';
+export type { GeoJSON, Feature, FeatureCollection, Geometry, Position, GeoJsonProperties, Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon, GeometryCollection } from './types/category-gis';
+export type { GeojsonGeometryInfo } from './types/category-gis';
+export type { FlatFeature, FlatIndexedGeometry, FlatGeometry, FlatGeometryType, FlatPoint, FlatLineString, FlatPolygon } from './types/category-gis';
+export type { BinaryGeometryType, BinaryGeometry, BinaryPointGeometry, BinaryLineGeometry, BinaryPolygonGeometry, BinaryAttribute } from './types/category-gis';
+export type { BinaryFeatures, BinaryPointFeatures, BinaryLineFeatures, BinaryPolygonFeatures } from './types/category-gis';
+export { Schema as ArrowLikeSchema, Field as ArrowLikeField, DataType as ArrowLikeDataType, 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/table/arrow-api';
+export { getTypeInfo } from './lib/table/arrow-api/get-type-info';
+export { getArrowType } from './lib/table/arrow/arrow-type-utils';
+export { default as AsyncQueue } from './lib/utils/async-queue';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -1,13 +1,92 @@
-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 { convertMesh } from './category/mesh/convert-mesh';
-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';
-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';
-export { default as AsyncQueue } from './lib/utils/async-queue';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeMillisecond = exports.Time = exports.DateMillisecond = exports.DateDay = exports.Date = exports.Utf8 = exports.Float64 = exports.Float32 = exports.Float16 = exports.Float = exports.Uint64 = exports.Uint32 = exports.Uint16 = exports.Uint8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Int = exports.Bool = exports.Binary = exports.Null = exports.ArrowLikeDataType = exports.ArrowLikeField = exports.ArrowLikeSchema = exports.makeMeshAttributeMetadata = exports.deduceMeshField = exports.deduceMeshSchema = exports.getMeshBoundingBox = exports.getMeshSize = exports.getDataTypeFromArray = exports.convertToArrayRow = exports.convertToObjectRow = exports.deduceTableSchema = exports.makeTableFromData = exports.ArrowLikeTable = exports.makeObjectRowIterator = exports.makeArrayRowIterator = exports.makeRowIterator = exports.getTableRowAsArray = exports.getTableRowAsObject = exports.getTableColumnName = exports.getTableColumnIndex = exports.getTableRowShape = exports.getTableCell = exports.getTableNumCols = exports.getTableLength = exports.ColumnarTableBatchAggregator = exports.RowTableBatchAggregator = exports.TableBatchBuilder = void 0;
+exports.AsyncQueue = exports.getArrowType = exports.getTypeInfo = exports.Struct = exports.FixedSizeList = exports.IntervalYearMonth = exports.IntervalDayTime = exports.Interval = exports.TimestampNanosecond = exports.TimestampMicrosecond = exports.TimestampMillisecond = exports.TimestampSecond = exports.Timestamp = exports.TimeSecond = void 0;
+// TABLE CATEGORY UTILS
+var table_batch_builder_1 = require("./lib/table/batches/table-batch-builder");
+Object.defineProperty(exports, "TableBatchBuilder", { enumerable: true, get: function () { return table_batch_builder_1.TableBatchBuilder; } });
+var row_table_batch_aggregator_1 = require("./lib/table/batches/row-table-batch-aggregator");
+Object.defineProperty(exports, "RowTableBatchAggregator", { enumerable: true, get: function () { return row_table_batch_aggregator_1.RowTableBatchAggregator; } });
+var columnar_table_batch_aggregator_1 = require("./lib/table/batches/columnar-table-batch-aggregator");
+Object.defineProperty(exports, "ColumnarTableBatchAggregator", { enumerable: true, get: function () { return columnar_table_batch_aggregator_1.ColumnarTableBatchAggregator; } });
+var table_accessors_1 = require("./lib/table/simple-table/table-accessors");
+Object.defineProperty(exports, "getTableLength", { enumerable: true, get: function () { return table_accessors_1.getTableLength; } });
+Object.defineProperty(exports, "getTableNumCols", { enumerable: true, get: function () { return table_accessors_1.getTableNumCols; } });
+Object.defineProperty(exports, "getTableCell", { enumerable: true, get: function () { return table_accessors_1.getTableCell; } });
+Object.defineProperty(exports, "getTableRowShape", { enumerable: true, get: function () { return table_accessors_1.getTableRowShape; } });
+Object.defineProperty(exports, "getTableColumnIndex", { enumerable: true, get: function () { return table_accessors_1.getTableColumnIndex; } });
+Object.defineProperty(exports, "getTableColumnName", { enumerable: true, get: function () { return table_accessors_1.getTableColumnName; } });
+Object.defineProperty(exports, "getTableRowAsObject", { enumerable: true, get: function () { return table_accessors_1.getTableRowAsObject; } });
+Object.defineProperty(exports, "getTableRowAsArray", { enumerable: true, get: function () { return table_accessors_1.getTableRowAsArray; } });
+Object.defineProperty(exports, "makeRowIterator", { enumerable: true, get: function () { return table_accessors_1.makeRowIterator; } });
+Object.defineProperty(exports, "makeArrayRowIterator", { enumerable: true, get: function () { return table_accessors_1.makeArrayRowIterator; } });
+Object.defineProperty(exports, "makeObjectRowIterator", { enumerable: true, get: function () { return table_accessors_1.makeObjectRowIterator; } });
+var arrow_like_table_1 = require("./lib/table/arrow-api/arrow-like-table");
+Object.defineProperty(exports, "ArrowLikeTable", { enumerable: true, get: function () { return arrow_like_table_1.ArrowLikeTable; } });
+var make_table_1 = require("./lib/table/simple-table/make-table");
+Object.defineProperty(exports, "makeTableFromData", { enumerable: true, get: function () { return make_table_1.makeTableFromData; } });
+var table_schema_1 = require("./lib/table/simple-table/table-schema");
+Object.defineProperty(exports, "deduceTableSchema", { enumerable: true, get: function () { return table_schema_1.deduceTableSchema; } });
+var row_utils_1 = require("./lib/table/simple-table/row-utils");
+Object.defineProperty(exports, "convertToObjectRow", { enumerable: true, get: function () { return row_utils_1.convertToObjectRow; } });
+Object.defineProperty(exports, "convertToArrayRow", { enumerable: true, get: function () { return row_utils_1.convertToArrayRow; } });
+var data_type_1 = require("./lib/table/simple-table/data-type");
+Object.defineProperty(exports, "getDataTypeFromArray", { enumerable: true, get: function () { return data_type_1.getDataTypeFromArray; } });
+var mesh_utils_1 = require("./lib/mesh/mesh-utils");
+Object.defineProperty(exports, "getMeshSize", { enumerable: true, get: function () { return mesh_utils_1.getMeshSize; } });
+Object.defineProperty(exports, "getMeshBoundingBox", { enumerable: true, get: function () { return mesh_utils_1.getMeshBoundingBox; } });
+// Commented out due to https://github.com/visgl/deck.gl/issues/6906 and https://github.com/visgl/loaders.gl/issues/2177
+// export {convertMesh} from './category/mesh/convert-mesh.js';
+var deduce_mesh_schema_1 = require("./lib/mesh/deduce-mesh-schema");
+Object.defineProperty(exports, "deduceMeshSchema", { enumerable: true, get: function () { return deduce_mesh_schema_1.deduceMeshSchema; } });
+Object.defineProperty(exports, "deduceMeshField", { enumerable: true, get: function () { return deduce_mesh_schema_1.deduceMeshField; } });
+Object.defineProperty(exports, "makeMeshAttributeMetadata", { enumerable: true, get: function () { return deduce_mesh_schema_1.makeMeshAttributeMetadata; } });
+// SCHEMA
+var arrow_api_1 = require("./lib/table/arrow-api");
+Object.defineProperty(exports, "ArrowLikeSchema", { enumerable: true, get: function () { return arrow_api_1.Schema; } });
+Object.defineProperty(exports, "ArrowLikeField", { enumerable: true, get: function () { return arrow_api_1.Field; } });
+Object.defineProperty(exports, "ArrowLikeDataType", { enumerable: true, get: function () { return arrow_api_1.DataType; } });
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return arrow_api_1.Null; } });
+Object.defineProperty(exports, "Binary", { enumerable: true, get: function () { return arrow_api_1.Binary; } });
+Object.defineProperty(exports, "Bool", { enumerable: true, get: function () { return arrow_api_1.Bool; } });
+Object.defineProperty(exports, "Int", { enumerable: true, get: function () { return arrow_api_1.Int; } });
+Object.defineProperty(exports, "Int8", { enumerable: true, get: function () { return arrow_api_1.Int8; } });
+Object.defineProperty(exports, "Int16", { enumerable: true, get: function () { return arrow_api_1.Int16; } });
+Object.defineProperty(exports, "Int32", { enumerable: true, get: function () { return arrow_api_1.Int32; } });
+Object.defineProperty(exports, "Int64", { enumerable: true, get: function () { return arrow_api_1.Int64; } });
+Object.defineProperty(exports, "Uint8", { enumerable: true, get: function () { return arrow_api_1.Uint8; } });
+Object.defineProperty(exports, "Uint16", { enumerable: true, get: function () { return arrow_api_1.Uint16; } });
+Object.defineProperty(exports, "Uint32", { enumerable: true, get: function () { return arrow_api_1.Uint32; } });
+Object.defineProperty(exports, "Uint64", { enumerable: true, get: function () { return arrow_api_1.Uint64; } });
+Object.defineProperty(exports, "Float", { enumerable: true, get: function () { return arrow_api_1.Float; } });
+Object.defineProperty(exports, "Float16", { enumerable: true, get: function () { return arrow_api_1.Float16; } });
+Object.defineProperty(exports, "Float32", { enumerable: true, get: function () { return arrow_api_1.Float32; } });
+Object.defineProperty(exports, "Float64", { enumerable: true, get: function () { return arrow_api_1.Float64; } });
+Object.defineProperty(exports, "Utf8", { enumerable: true, get: function () { return arrow_api_1.Utf8; } });
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return arrow_api_1.Date; } });
+Object.defineProperty(exports, "DateDay", { enumerable: true, get: function () { return arrow_api_1.DateDay; } });
+Object.defineProperty(exports, "DateMillisecond", { enumerable: true, get: function () { return arrow_api_1.DateMillisecond; } });
+Object.defineProperty(exports, "Time", { enumerable: true, get: function () { return arrow_api_1.Time; } });
+Object.defineProperty(exports, "TimeMillisecond", { enumerable: true, get: function () { return arrow_api_1.TimeMillisecond; } });
+Object.defineProperty(exports, "TimeSecond", { enumerable: true, get: function () { return arrow_api_1.TimeSecond; } });
+Object.defineProperty(exports, "Timestamp", { enumerable: true, get: function () { return arrow_api_1.Timestamp; } });
+Object.defineProperty(exports, "TimestampSecond", { enumerable: true, get: function () { return arrow_api_1.TimestampSecond; } });
+Object.defineProperty(exports, "TimestampMillisecond", { enumerable: true, get: function () { return arrow_api_1.TimestampMillisecond; } });
+Object.defineProperty(exports, "TimestampMicrosecond", { enumerable: true, get: function () { return arrow_api_1.TimestampMicrosecond; } });
+Object.defineProperty(exports, "TimestampNanosecond", { enumerable: true, get: function () { return arrow_api_1.TimestampNanosecond; } });
+Object.defineProperty(exports, "Interval", { enumerable: true, get: function () { return arrow_api_1.Interval; } });
+Object.defineProperty(exports, "IntervalDayTime", { enumerable: true, get: function () { return arrow_api_1.IntervalDayTime; } });
+Object.defineProperty(exports, "IntervalYearMonth", { enumerable: true, get: function () { return arrow_api_1.IntervalYearMonth; } });
+Object.defineProperty(exports, "FixedSizeList", { enumerable: true, get: function () { return arrow_api_1.FixedSizeList; } });
+Object.defineProperty(exports, "Struct", { enumerable: true, get: function () { return arrow_api_1.Struct; } });
+// EXPERIMENTAL APIs
+// SCHEMA UTILS
+var get_type_info_1 = require("./lib/table/arrow-api/get-type-info");
+Object.defineProperty(exports, "getTypeInfo", { enumerable: true, get: function () { return get_type_info_1.getTypeInfo; } });
+var arrow_type_utils_1 = require("./lib/table/arrow/arrow-type-utils");
+Object.defineProperty(exports, "getArrowType", { enumerable: true, get: function () { return arrow_type_utils_1.getArrowType; } });
+var async_queue_1 = require("./lib/utils/async-queue");
+Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return __importDefault(async_queue_1).default; } });

package/dist/lib/mesh/convert-mesh.d.ts

@@ -0,0 +1,15 @@
+import type { Mesh } from '../../types/category-mesh';
+import type { ColumnarTable, ArrowTable } from '../../types/category-table';
+type TargetShape = 'mesh' | 'columnar-table' | 'arrow-table';
+/**
+ * Convert a mesh to a specific shape
+ */
+export declare function convertMesh(mesh: Mesh, shape: TargetShape, options?: any): Mesh | ColumnarTable | ArrowTable;
+/**
+ * Convert a loaders.gl Mesh to a Columnar Table
+ * @param mesh
+ * @returns
+ */
+export declare function convertMeshToColumnarTable(mesh: Mesh): ColumnarTable;
+export {};
+//# sourceMappingURL=convert-mesh.d.ts.map

package/dist/lib/mesh/convert-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-mesh.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/convert-mesh.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,2BAA2B,CAAC;AACpD,OAAO,KAAK,EAAC,aAAa,EAAE,UAAU,EAAC,MAAM,4BAA4B,CAAC;AAG1E,KAAK,WAAW,GAAG,MAAM,GAAG,gBAAgB,GAAG,aAAa,CAAC;AAE7D;;GAEG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,GAAG,GACZ,IAAI,GAAG,aAAa,GAAG,UAAU,CAcnC;AAED;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAYpE"}

package/dist/lib/mesh/convert-mesh.js

@@ -0,0 +1,40 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertMeshToColumnarTable = exports.convertMesh = void 0;
+/**
+ * Convert a mesh to a specific shape
+ */
+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 ${options?.shape}`);
+    }
+}
+exports.convertMesh = convertMesh;
+/**
+ * Convert a loaders.gl Mesh to a Columnar Table
+ * @param mesh
+ * @returns
+ */
+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
+    };
+}
+exports.convertMeshToColumnarTable = convertMeshToColumnarTable;

package/dist/lib/mesh/deduce-mesh-schema.d.ts

@@ -0,0 +1,24 @@
+import { MeshAttribute, MeshAttributes } from '../../types/category-mesh';
+import { Schema, Field } from '../../types/schema';
+/**
+ * Create a schema for mesh attributes data
+ * @param attributes
+ * @param metadata
+ * @returns
+ */
+export declare function deduceMeshSchema(attributes: MeshAttributes, metadata?: Record<string, string>): Schema;
+/**
+ * Create arrow-like schema field for mesh attribute
+ * @param attributeName
+ * @param attribute
+ * @param optionalMetadata
+ * @returns
+ */
+export declare function deduceMeshField(name: string, attribute: MeshAttribute, optionalMetadata?: Record<string, string>): Field;
+/**
+ * Make metadata by mesh attribute properties
+ * @param attribute
+ * @returns
+ */
+export declare function makeMeshAttributeMetadata(attribute: MeshAttribute): Record<string, string>;
+//# sourceMappingURL=deduce-mesh-schema.d.ts.map

package/dist/lib/mesh/deduce-mesh-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deduce-mesh-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/deduce-mesh-schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,2BAA2B,CAAC;AACxE,OAAO,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAGjD;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,cAAc,EAC1B,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACpC,MAAM,CAGR;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,aAAa,EACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,KAAK,CASP;AAgBD;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAY1F"}

package/dist/lib/mesh/deduce-mesh-schema.js

@@ -0,0 +1,66 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMeshAttributeMetadata = exports.deduceMeshField = exports.deduceMeshSchema = void 0;
+const data_type_1 = require("../table/simple-table/data-type");
+/**
+ * Create a schema for mesh attributes data
+ * @param attributes
+ * @param metadata
+ * @returns
+ */
+function deduceMeshSchema(attributes, metadata = {}) {
+    const fields = deduceMeshFields(attributes);
+    return { fields, metadata };
+}
+exports.deduceMeshSchema = deduceMeshSchema;
+/**
+ * Create arrow-like schema field for mesh attribute
+ * @param attributeName
+ * @param attribute
+ * @param optionalMetadata
+ * @returns
+ */
+function deduceMeshField(name, attribute, optionalMetadata) {
+    const type = (0, data_type_1.getDataTypeFromTypedArray)(attribute.value);
+    const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
+    return {
+        name,
+        type: { type: 'fixed-size-list', listSize: attribute.size, children: [{ name: 'value', type }] },
+        nullable: false,
+        metadata
+    };
+}
+exports.deduceMeshField = deduceMeshField;
+/**
+ * Create fields array for mesh attributes
+ * @param attributes
+ * @returns
+ */
+function deduceMeshFields(attributes) {
+    const fields = [];
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        fields.push(deduceMeshField(attributeName, attribute));
+    }
+    return fields;
+}
+/**
+ * Make metadata by mesh attribute properties
+ * @param attribute
+ * @returns
+ */
+function makeMeshAttributeMetadata(attribute) {
+    const result = {};
+    if ('byteOffset' in attribute) {
+        result.byteOffset = attribute.byteOffset.toString(10);
+    }
+    if ('byteStride' in attribute) {
+        result.byteStride = attribute.byteStride.toString(10);
+    }
+    if ('normalized' in attribute) {
+        result.normalized = attribute.normalized.toString();
+    }
+    return result;
+}
+exports.makeMeshAttributeMetadata = makeMeshAttributeMetadata;

package/dist/lib/mesh/mesh-to-arrow-table.d.ts

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

package/dist/lib/mesh/mesh-to-arrow-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-to-arrow-table.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/mesh-to-arrow-table.ts"],"names":[],"mappings":""}

package/dist/lib/mesh/mesh-to-arrow-table.js

@@ -0,0 +1,44 @@
+"use strict";
+/* Problem with arrow dependency...
+import {
+  Table,
+  Schema,
+  RecordBatch,
+  FixedSizeList,
+  Field,
+  Data,
+  FixedSizeListVector
+} from 'apache-arrow';
+import {AbstractVector} from 'apache-arrow/vector';
+import {getArrowType, getArrowVector} from '../table/arrow/arrow-type-utils.js';
+import type {Mesh} from './mesh-types.js';
+import {makeMeshAttributeMetadata} from './deduce-mesh-schema.js';
+
+/**
+ * * Convert a loaders.gl Mesh to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ *
+export function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): Table {
+  const vectors: AbstractVector[] = [];
+  const fields: Field[] = [];
+  for (const attributeKey in mesh.attributes) {
+    const attribute = mesh.attributes[attributeKey];
+    const {value, size = 1} = attribute;
+    const type = getArrowType(value);
+    const vector = getArrowVector(value);
+    const listType = new FixedSizeList(size, new Field('value', type));
+    const field = new Field(attributeKey, listType, false, makeMeshAttributeMetadata(attribute));
+    const data = new Data(listType, 0, value.length / size, 0, undefined, [vector]);
+    const listVector = new FixedSizeListVector(data);
+    vectors.push(listVector);
+    fields.push(field);
+  }
+  const schema = new Schema(fields, mesh?.schema?.metadata || new Map<string, string>());
+  const recordBatch = new RecordBatch(schema, vectors[0].length, vectors);
+  const table = new Table(schema, recordBatch);
+  return table;
+}
+*/

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

@@ -0,0 +1,23 @@
+import { TypedArray } from '../../types/types';
+import { MeshAttributes } from '../../types/category-mesh';
+type TypedArrays = {
+    [key: string]: TypedArray;
+};
+/**
+ * Holds an axis aligned bounding box
+ * TODO - make sure AxisAlignedBoundingBox in math.gl/culling understands this format (or change this format)
+ */
+type BoundingBox = [[number, number, number], [number, number, number]];
+/**
+ * Get number of vertices in mesh
+ * @param attributes
+ */
+export declare function getMeshSize(attributes: TypedArrays): number;
+/**
+ * Get the (axis aligned) bounding box of a mesh
+ * @param attributes
+ * @returns array of two vectors representing the axis aligned bounding box
+ */
+export declare function getMeshBoundingBox(attributes: MeshAttributes): BoundingBox;
+export {};
+//# sourceMappingURL=mesh-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/mesh-utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAC7C,OAAO,EAAC,cAAc,EAAC,MAAM,2BAA2B,CAAC;AAEzD,KAAK,WAAW,GAAG;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;CAAC,CAAC;AAE/C;;;GAGG;AACH,KAAK,WAAW,GAAG,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;AAExE;;;GAGG;AACH,wBAAgB,WAAW,CAAC,UAAU,EAAE,WAAW,GAAG,MAAM,CAU3D;AAED;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,cAAc,GAAG,WAAW,CA4B1E"}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMeshBoundingBox = exports.getMeshSize = void 0;
+/**
+ * Get number of vertices in mesh
+ * @param attributes
+ */
+function getMeshSize(attributes) {
+    let size = 0;
+    for (const attributeName in attributes) {
+        const attribute = attributes[attributeName];
+        if (ArrayBuffer.isView(attribute)) {
+            // @ts-ignore DataView doesn't have BYTES_PER_ELEMENT
+            size += attribute.byteLength * attribute.BYTES_PER_ELEMENT;
+        }
+    }
+    return size;
+}
+exports.getMeshSize = getMeshSize;
+/**
+ * Get the (axis aligned) bounding box of a mesh
+ * @param attributes
+ * @returns array of two vectors representing the axis aligned bounding box
+ */
+// eslint-disable-next-line complexity
+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]
+    ];
+}
+exports.getMeshBoundingBox = getMeshBoundingBox;

package/dist/lib/table/arrow/arrow-type-utils.d.ts

@@ -0,0 +1,4 @@
+import type { TypedArray } from '../../../types/types';
+import { DataType } from 'apache-arrow';
+export declare function getArrowType(array: TypedArray): DataType;
+//# sourceMappingURL=arrow-type-utils.d.ts.map

package/dist/lib/table/arrow/arrow-type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-type-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow/arrow-type-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,sBAAsB,CAAC;AACrD,OAAO,EACL,QAAQ,EAiBT,MAAM,cAAc,CAAC;AAGtB,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAqBxD"}

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

@@ -0,0 +1,53 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrowType = void 0;
+const apache_arrow_1 = require("apache-arrow");
+// import {AbstractVector} from 'apache-arrow/vector';
+function getArrowType(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return new apache_arrow_1.Int8();
+        case Uint8Array:
+            return new apache_arrow_1.Uint8();
+        case Int16Array:
+            return new apache_arrow_1.Int16();
+        case Uint16Array:
+            return new apache_arrow_1.Uint16();
+        case Int32Array:
+            return new apache_arrow_1.Int32();
+        case Uint32Array:
+            return new apache_arrow_1.Uint32();
+        case Float32Array:
+            return new apache_arrow_1.Float32();
+        case Float64Array:
+            return new apache_arrow_1.Float64();
+        default:
+            throw new Error('array type not supported');
+    }
+}
+exports.getArrowType = getArrowType;
+/*
+export function getArrowVector(array: TypedArray): AbstractVector {
+  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');
+  }
+}
+*/

package/dist/lib/table/arrow/convert-schema-arrow.d.ts

@@ -0,0 +1,13 @@
+import type { DataType, Field, Schema, SchemaMetadata } from '../../../types/schema';
+import { Field as ArrowField, Schema as ArrowSchema, DataType as ArrowDataType } from 'apache-arrow/Arrow.dom';
+export declare function serializeArrowSchema(arrowSchema: ArrowSchema): Schema;
+export declare function deserializeArrowSchema(schema: Schema): ArrowSchema;
+export declare function serializeArrowMetadata(arrowMetadata: Map<string, string>): SchemaMetadata;
+export declare function deserializeArrowMetadata(metadata?: SchemaMetadata): Map<string, string>;
+export declare function serializeArrowField(field: ArrowField): Field;
+export declare function deserializeArrowField(field: Field): ArrowField;
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+export declare function serializeArrowType(arrowType: ArrowDataType): DataType;
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+export declare function deserializeArrowType(dataType: DataType): ArrowDataType;
+//# sourceMappingURL=convert-schema-arrow.d.ts.map

package/dist/lib/table/arrow/convert-schema-arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-schema-arrow.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow/convert-schema-arrow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACnF,OAAO,EACL,KAAK,IAAI,UAAU,EACnB,MAAM,IAAI,WAAW,EACrB,QAAQ,IAAI,aAAa,EAkC1B,MAAM,wBAAwB,CAAC;AAEhC,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,CAKrE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAKlE;AAED,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAO5D;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,UAAU,CAO9D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,aAAa,GAAG,QAAQ,CAqErE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,aAAa,CA0EtE"}