@loaders.gl/schema-utils 4.4.0-alpha.1

package/dist/lib/arrow-utils/arrow-list-of-fixed-size-list-utils.js

@@ -0,0 +1,32 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { getDataTypeFromArray } from "../schema/data-type.js";
+import { deserializeArrowType } from "../schema/convert-arrow-schema.js";
+export function isListFixedSizeList(vector) {
+    return vector.type instanceof arrow.FixedSizeList;
+}
+export function getListFixedSizeListSize(vector) {
+    return vector.type instanceof arrow.FixedSizeList ? vector.type.listSize : 1;
+}
+/** Get Arrow FixedSizeList vector from a typed array */
+export function getListFixedSizeListVector(indexes, typedArray, stride) {
+    const data = getFixedSizeListData(typedArray, stride);
+    return new arrow.Vector([data]);
+}
+/** Get Arrow FixedSizeList vector from a typed array */
+export function getFixedSizeListData(typedArray, stride) {
+    const listType = getFixedSizeListType(typedArray, stride);
+    const data = new arrow.Data(listType, 0, typedArray.length / stride, 0, [
+        typedArray
+    ]);
+    return data;
+}
+/** Get Arrow FixedSizeList vector from a typed array */
+export function getFixedSizeListType(typedArray, stride) {
+    const { type } = getDataTypeFromArray(typedArray);
+    const arrowType = deserializeArrowType(type);
+    const listType = new arrow.FixedSizeList(stride, new arrow.Field('value', arrowType));
+    return listType;
+}

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

@@ -0,0 +1,18 @@
+import type { Mesh, ArrowTable, ColumnarTable } from '@loaders.gl/schema';
+export declare function convertMeshToTable(mesh: Mesh, shape: 'columnar-table'): ColumnarTable;
+export declare function convertMeshToTable(mesh: Mesh, shape: 'arrow-table'): ArrowTable;
+/**
+ * Convert a loaders.gl Mesh to a Columnar Table
+ * @param mesh
+ * @returns
+ */
+export declare function convertMeshToColumnarTable(mesh: Mesh): ColumnarTable;
+/**
+ * * Convert a loaders.gl Mesh to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export declare function convertMeshToArrowTable(mesh: Mesh, batchSize?: number): ArrowTable;
+//# sourceMappingURL=convert-mesh-to-table.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-mesh-to-table.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/convert-mesh-to-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAE,UAAU,EAAE,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAKxE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AACvF,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC;AAmBjF;;;;GAIG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,IAAI,GAAG,aAAa,CAYpE;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,UAAU,CAqBlF"}

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

@@ -0,0 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { getFixedSizeListData } from "../arrow-utils/arrow-fixed-size-list-utils.js";
+import { deserializeArrowSchema } from "../schema/convert-arrow-schema.js";
+/**
+ * Convert a mesh to a specific shape
+ */
+export function convertMeshToTable(mesh, shape) {
+    switch (shape) {
+        case 'columnar-table':
+            return convertMeshToColumnarTable(mesh);
+        case 'arrow-table':
+            return convertMeshToArrowTable(mesh);
+        default:
+            throw new Error(shape);
+    }
+}
+/**
+ * Convert a loaders.gl Mesh to a Columnar Table
+ * @param mesh
+ * @returns
+ */
+export function convertMeshToColumnarTable(mesh) {
+    const columns = {};
+    for (const [columnName, attribute] of Object.entries(mesh.attributes)) {
+        columns[columnName] = attribute.value;
+    }
+    return {
+        shape: 'columnar-table',
+        schema: mesh.schema,
+        data: columns
+    };
+}
+/**
+ * * Convert a loaders.gl Mesh to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export function convertMeshToArrowTable(mesh, batchSize) {
+    const { schema } = mesh;
+    const arrowSchema = deserializeArrowSchema(schema);
+    const arrowDatas = [];
+    for (const attributeKey in mesh.attributes) {
+        const attribute = mesh.attributes[attributeKey];
+        const { value, size = 1 } = attribute;
+        const listData = getFixedSizeListData(value, size);
+        arrowDatas.push(listData);
+        // fields.push(field);
+    }
+    const structField = new arrow.Struct(arrowSchema.fields);
+    const length = arrowDatas[0].length;
+    const structData = new arrow.Data(structField, 0, length, 0, undefined, arrowDatas);
+    const recordBatch = new arrow.RecordBatch(arrowSchema, structData);
+    const table = new arrow.Table([recordBatch]);
+    return { shape: 'arrow-table', schema, data: table };
+}

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

@@ -0,0 +1,7 @@
+import type { Mesh, ColumnarTable, ArrowTable } from '@loaders.gl/schema';
+/**
+ * Convert a mesh to a specific shape
+ */
+export declare function convertTableToMesh(table: ColumnarTable | ArrowTable): Mesh;
+export declare function convertArrowTableToMesh(table: ArrowTable): Mesh;
+//# sourceMappingURL=convert-table-to-mesh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table-to-mesh.d.ts","sourceRoot":"","sources":["../../../src/lib/mesh/convert-table-to-mesh.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAS,MAAM,oBAAoB,CAAC;AAKhF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,aAAa,GAAG,UAAU,GAAG,IAAI,CAS1E;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAmB/D"}

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

@@ -0,0 +1,40 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getFixedSizeListSize } from "../arrow-utils/arrow-fixed-size-list-utils.js";
+import { serializeArrowSchema } from "../schema/convert-arrow-schema.js";
+// import {makeMeshAttributeMetadata} from './deduce-mesh-schema';
+/**
+ * Convert a mesh to a specific shape
+ */
+export function convertTableToMesh(table) {
+    switch (table.shape) {
+        // case 'columnar-table':
+        //   return convertColumnarTableToMesh(table);
+        case 'arrow-table':
+            return convertArrowTableToMesh(table);
+        default:
+            throw new Error(table.shape);
+    }
+}
+export function convertArrowTableToMesh(table) {
+    const arrowTable = table.data;
+    const schema = serializeArrowSchema(arrowTable.schema);
+    const fields = schema.fields;
+    const attributes = {};
+    for (const field of fields) {
+        const { name } = field;
+        const attributeData = arrowTable.getChild(name);
+        const size = getFixedSizeListSize(attributeData);
+        const typedArray = attributeData?.toArray();
+        attributes[name] = { value: typedArray, size };
+    }
+    fixMetadata(schema);
+    const topology = schema.metadata.topology;
+    return { schema, attributes, topology, mode: 0 };
+}
+function fixMetadata(schema) {
+    schema.metadata ||= {};
+    schema.metadata.topology ||= 'point-list';
+    schema.metadata.mode ||= '0';
+}

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

@@ -0,0 +1,23 @@
+import { MeshAttribute, MeshAttributes, Schema, Field } from '@loaders.gl/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":"AAIA,OAAO,EAAC,aAAa,EAAE,cAAc,EAAE,MAAM,EAAE,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAGhF;;;;;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,62 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { getDataTypeFromTypedArray } from "../schema/data-type.js";
+/**
+ * Create a schema for mesh attributes data
+ * @param attributes
+ * @param metadata
+ * @returns
+ */
+export function deduceMeshSchema(attributes, metadata = {}) {
+    const fields = deduceMeshFields(attributes);
+    return { fields, metadata };
+}
+/**
+ * Create arrow-like schema field for mesh attribute
+ * @param attributeName
+ * @param attribute
+ * @param optionalMetadata
+ * @returns
+ */
+export function deduceMeshField(name, attribute, optionalMetadata) {
+    const type = 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
+    };
+}
+/**
+ * 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
+ */
+export 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;
+}

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

@@ -0,0 +1,23 @@
+import { MeshAttributes } from '@loaders.gl/schema';
+import { TypedArray } from "../../types/types.js";
+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,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAC,UAAU,EAAC,6BAA0B;AAE7C,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,46 @@
+/**
+ * Get number of vertices in mesh
+ * @param attributes
+ */
+export 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;
+}
+/**
+ * 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
+export function getMeshBoundingBox(attributes) {
+    let minX = Infinity;
+    let minY = Infinity;
+    let minZ = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    let maxZ = -Infinity;
+    const positions = attributes.POSITION ? attributes.POSITION.value : [];
+    const len = positions && positions.length;
+    for (let i = 0; i < len; i += 3) {
+        const x = positions[i];
+        const y = positions[i + 1];
+        const z = positions[i + 2];
+        minX = x < minX ? x : minX;
+        minY = y < minY ? y : minY;
+        minZ = z < minZ ? z : minZ;
+        maxX = x > maxX ? x : maxX;
+        maxY = y > maxY ? y : maxY;
+        maxZ = z > maxZ ? z : maxZ;
+    }
+    return [
+        [minX, minY, minZ],
+        [maxX, maxY, maxZ]
+    ];
+}

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

@@ -0,0 +1,23 @@
+import type { DataType, Field, Schema, SchemaMetadata } from '@loaders.gl/schema';
+import * as arrow from 'apache-arrow';
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export declare function convertArrowToSchema(arrowSchema: arrow.Schema): Schema;
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export declare function convertSchemaToArrow(schema: Schema): arrow.Schema;
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export declare function serializeArrowSchema(arrowSchema: arrow.Schema): Schema;
+/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
+export declare function deserializeArrowSchema(schema: Schema): arrow.Schema;
+/** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */
+export declare function serializeArrowMetadata(arrowMetadata: Map<string, string>): SchemaMetadata;
+/** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */
+export declare function deserializeArrowMetadata(metadata?: SchemaMetadata): Map<string, string>;
+/** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */
+export declare function serializeArrowField(field: arrow.Field): Field;
+/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/
+export declare function deserializeArrowField(field: Field): arrow.Field;
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+export declare function serializeArrowType(arrowType: arrow.DataType): DataType;
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+export declare function deserializeArrowType(dataType: DataType): arrow.DataType;
+//# sourceMappingURL=convert-arrow-schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/convert-arrow-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAEtE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAEjE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAKtE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAKnE;AAED,gHAAgH;AAChH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,mHAAmH;AACnH,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAO7D;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAO/D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAuJtE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAgFvE"}

package/dist/lib/schema/convert-arrow-schema.js

@@ -0,0 +1,280 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertArrowToSchema(arrowSchema) {
+    return serializeArrowSchema(arrowSchema);
+}
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertSchemaToArrow(schema) {
+    return deserializeArrowSchema(schema);
+}
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function serializeArrowSchema(arrowSchema) {
+    return {
+        fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+        metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
+}
+/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
+export function deserializeArrowSchema(schema) {
+    return new arrow.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+}
+/** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */
+export function serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
+}
+/** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */
+export function deserializeArrowMetadata(metadata) {
+    return metadata ? new Map(Object.entries(metadata)) : new Map();
+}
+/** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */
+export function serializeArrowField(field) {
+    return {
+        name: field.name,
+        type: serializeArrowType(field.type),
+        nullable: field.nullable,
+        metadata: serializeArrowMetadata(field.metadata)
+    };
+}
+/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/
+export function deserializeArrowField(field) {
+    return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+}
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+// eslint-disable-next-line complexity
+export function serializeArrowType(arrowType) {
+    switch (arrowType.constructor) {
+        case arrow.Null:
+            return 'null';
+        case arrow.Binary:
+            return 'binary';
+        case arrow.Bool:
+            return 'bool';
+        case arrow.Int:
+            const intType = arrowType;
+            return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
+        case arrow.Int8:
+            return 'int8';
+        case arrow.Int16:
+            return 'int16';
+        case arrow.Int32:
+            return 'int32';
+        case arrow.Int64:
+            return 'int64';
+        case arrow.Uint8:
+            return 'uint8';
+        case arrow.Uint16:
+            return 'uint16';
+        case arrow.Uint32:
+            return 'uint32';
+        case arrow.Uint64:
+            return 'uint64';
+        case arrow.Float:
+            const precision = arrowType.precision;
+            // return `float(precision + 1) * 16`;
+            switch (precision) {
+                case arrow.Precision.HALF:
+                    return 'float16';
+                case arrow.Precision.SINGLE:
+                    return 'float32';
+                case arrow.Precision.DOUBLE:
+                    return 'float64';
+                default:
+                    return 'float16';
+            }
+        case arrow.Float16:
+            return 'float16';
+        case arrow.Float32:
+            return 'float32';
+        case arrow.Float64:
+            return 'float64';
+        case arrow.Utf8:
+            return 'utf8';
+        case arrow.Decimal:
+            const decimal = arrowType;
+            return {
+                type: 'decimal',
+                bitWidth: decimal.bitWidth,
+                precision: decimal.precision,
+                scale: decimal.scale
+            };
+        case arrow.Date_:
+            const dateUnit = arrowType.unit;
+            return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';
+        case arrow.DateDay:
+            return 'date-day';
+        case arrow.DateMillisecond:
+            return 'date-millisecond';
+        case arrow.Time:
+            const timeUnit = arrowType.unit;
+            switch (timeUnit) {
+                case arrow.TimeUnit.SECOND:
+                    return 'time-second';
+                case arrow.TimeUnit.MILLISECOND:
+                    return 'time-millisecond';
+                case arrow.TimeUnit.MICROSECOND:
+                    return 'time-microsecond';
+                case arrow.TimeUnit.NANOSECOND:
+                    return 'time-nanosecond';
+                default:
+                    return 'time-second';
+            }
+        case arrow.TimeMillisecond:
+            return 'time-millisecond';
+        case arrow.TimeSecond:
+            return 'time-second';
+        case arrow.TimeMicrosecond:
+            return 'time-microsecond';
+        case arrow.TimeNanosecond:
+            return 'time-nanosecond';
+        case arrow.Timestamp:
+            const timeStampUnit = arrowType.unit;
+            switch (timeStampUnit) {
+                case arrow.TimeUnit.SECOND:
+                    return 'timestamp-second';
+                case arrow.TimeUnit.MILLISECOND:
+                    return 'timestamp-millisecond';
+                case arrow.TimeUnit.MICROSECOND:
+                    return 'timestamp-microsecond';
+                case arrow.TimeUnit.NANOSECOND:
+                    return 'timestamp-nanosecond';
+                default:
+                    return 'timestamp-second';
+            }
+        case arrow.TimestampSecond:
+            return 'timestamp-second';
+        case arrow.TimestampMillisecond:
+            return 'timestamp-millisecond';
+        case arrow.TimestampMicrosecond:
+            return 'timestamp-microsecond';
+        case arrow.TimestampNanosecond:
+            return 'timestamp-nanosecond';
+        case arrow.Interval:
+            const intervalUnit = arrowType.unit;
+            switch (intervalUnit) {
+                case arrow.IntervalUnit.DAY_TIME:
+                    return 'interval-daytime';
+                case arrow.IntervalUnit.YEAR_MONTH:
+                    return 'interval-yearmonth';
+                default:
+                    return 'interval-daytime';
+            }
+        case arrow.IntervalDayTime:
+            return 'interval-daytime';
+        case arrow.IntervalYearMonth:
+            return 'interval-yearmonth';
+        case arrow.Map_:
+            const mapType = arrowType;
+            return {
+                type: 'map',
+                keysSorted: mapType.keysSorted,
+                children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+            };
+        case arrow.List:
+            const listType = arrowType;
+            const listField = listType.valueField;
+            return {
+                type: 'list',
+                children: [serializeArrowField(listField)]
+            };
+        case arrow.FixedSizeList:
+            const fixedSizeList = arrowType;
+            return {
+                type: 'fixed-size-list',
+                listSize: fixedSizeList.listSize,
+                children: [serializeArrowField(fixedSizeList.children[0])]
+            };
+        case arrow.Struct:
+            const structType = arrowType;
+            return {
+                type: 'struct',
+                children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+            };
+        default:
+            throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
+}
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+// eslint-disable-next-line complexity
+export function deserializeArrowType(dataType) {
+    if (typeof dataType === 'object') {
+        switch (dataType.type) {
+            case 'decimal':
+                return new arrow.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+            case 'map':
+                let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+                return new arrow.Map_(children, dataType.keysSorted);
+            case 'list':
+                const field = deserializeArrowField(dataType.children[0]);
+                return new arrow.List(field);
+            case 'fixed-size-list':
+                const child = deserializeArrowField(dataType.children[0]);
+                return new arrow.FixedSizeList(dataType.listSize, child);
+            case 'struct':
+                children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+                return new arrow.Struct(children);
+            default:
+                throw new Error('array type not supported');
+        }
+    }
+    switch (dataType) {
+        case 'null':
+            return new arrow.Null();
+        case 'binary':
+            return new arrow.Binary();
+        case 'bool':
+            return new arrow.Bool();
+        case 'int8':
+            return new arrow.Int8();
+        case 'int16':
+            return new arrow.Int16();
+        case 'int32':
+            return new arrow.Int32();
+        case 'int64':
+            return new arrow.Int64();
+        case 'uint8':
+            return new arrow.Uint8();
+        case 'uint16':
+            return new arrow.Uint16();
+        case 'uint32':
+            return new arrow.Uint32();
+        case 'uint64':
+            return new arrow.Uint64();
+        case 'float16':
+            return new arrow.Float16();
+        case 'float32':
+            return new arrow.Float32();
+        case 'float64':
+            return new arrow.Float64();
+        case 'utf8':
+            return new arrow.Utf8();
+        case 'date-day':
+            return new arrow.DateDay();
+        case 'date-millisecond':
+            return new arrow.DateMillisecond();
+        case 'time-second':
+            return new arrow.TimeSecond();
+        case 'time-millisecond':
+            return new arrow.TimeMillisecond();
+        case 'time-microsecond':
+            return new arrow.TimeMicrosecond();
+        case 'time-nanosecond':
+            return new arrow.TimeNanosecond();
+        case 'timestamp-second':
+            return new arrow.TimestampSecond();
+        case 'timestamp-millisecond':
+            return new arrow.TimestampMillisecond();
+        case 'timestamp-microsecond':
+            return new arrow.TimestampMicrosecond();
+        case 'timestamp-nanosecond':
+            return new arrow.TimestampNanosecond();
+        case 'interval-daytime':
+            return new arrow.IntervalDayTime();
+        case 'interval-yearmonth':
+            return new arrow.IntervalYearMonth();
+        default:
+            throw new Error('array type not supported');
+    }
+}

package/dist/lib/schema/data-type.d.ts

@@ -0,0 +1,16 @@
+import { DataType, TypedArray, TypedArrayConstructor, ArrayType } from '@loaders.gl/schema';
+/** Deduce column types from values */
+export declare function getDataTypeFromValue(value: unknown, defaultNumberType?: 'float32'): DataType;
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export declare function getDataTypeFromArray(array: ArrayType): {
+    type: DataType;
+    nullable: boolean;
+};
+/**
+ * Deduces a simple data type "descriptor from a typed array instance
+ */
+export declare function getDataTypeFromTypedArray(array: TypedArray): DataType;
+export declare function getArrayTypeFromDataType(type: DataType, nullable: boolean | undefined): TypedArrayConstructor | ArrayConstructor;
+//# sourceMappingURL=data-type.d.ts.map

package/dist/lib/schema/data-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type.d.ts","sourceRoot":"","sources":["../../../src/lib/schema/data-type.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,QAAQ,EAAE,UAAU,EAAE,qBAAqB,EAAE,SAAS,EAAC,MAAM,oBAAoB,CAAC;AAE1F,sCAAsC;AACtC,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,EACd,iBAAiB,GAAE,SAAqB,GACvC,QAAQ,CAcV;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,GAAG;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAC,CAW1F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAsBrE;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,OAAO,GAAG,SAAS,GAC5B,qBAAqB,GAAG,gBAAgB,CA8B1C"}