@loaders.gl/arrow 4.0.0-beta.8 → 4.0.1

package/dist/index.cjs

@@ -24,7 +24,17 @@ __export(src_exports, {
   ArrowWorkerLoader: () => ArrowLoader,
   ArrowWriter: () => ArrowWriter,
   VECTOR_TYPES: () => VECTOR_TYPES,
-  getArrowType: () => getArrowType
+  deserializeArrowField: () => deserializeArrowField,
+  deserializeArrowMetadata: () => deserializeArrowMetadata,
+  deserializeArrowSchema: () => deserializeArrowSchema,
+  deserializeArrowType: () => deserializeArrowType,
+  getArrowType: () => getArrowType,
+  getBinaryGeometriesFromArrow: () => getBinaryGeometriesFromArrow,
+  parseGeometryFromArrow: () => parseGeometryFromArrow,
+  serializeArrowField: () => serializeArrowField,
+  serializeArrowMetadata: () => serializeArrowMetadata,
+  serializeArrowSchema: () => serializeArrowSchema,
+  serializeArrowType: () => serializeArrowType
 });
 module.exports = __toCommonJS(src_exports);
 var import_schema3 = require("@loaders.gl/schema");
@@ -57,7 +67,7 @@ var ArrowLoader = {
 var import_schema = require("@loaders.gl/schema");
 var import_apache_arrow = require("apache-arrow");
 
-// src/lib/convert-table.ts
+// src/tables/convert-arrow-to-table.ts
 function convertApacheArrowToArrowTable(arrowTable) {
   return {
     shape: "arrow-table",
@@ -203,6 +213,247 @@ function getArrowType(array) {
   }
 }
 
+// src/schema/convert-arrow-schema.ts
+var import_apache_arrow5 = require("apache-arrow");
+function serializeArrowSchema(arrowSchema) {
+  return {
+    fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+    metadata: serializeArrowMetadata(arrowSchema.metadata)
+  };
+}
+function deserializeArrowSchema(schema) {
+  return new import_apache_arrow5.Schema(
+    schema.fields.map((field) => deserializeArrowField(field)),
+    deserializeArrowMetadata(schema.metadata)
+  );
+}
+function serializeArrowMetadata(arrowMetadata) {
+  return Object.fromEntries(arrowMetadata);
+}
+function deserializeArrowMetadata(metadata) {
+  return metadata ? new Map(Object.entries(metadata)) : /* @__PURE__ */ new Map();
+}
+function serializeArrowField(field) {
+  return {
+    name: field.name,
+    type: serializeArrowType(field.type),
+    nullable: field.nullable,
+    metadata: serializeArrowMetadata(field.metadata)
+  };
+}
+function deserializeArrowField(field) {
+  return new import_apache_arrow5.Field(
+    field.name,
+    deserializeArrowType(field.type),
+    field.nullable,
+    deserializeArrowMetadata(field.metadata)
+  );
+}
+function serializeArrowType(arrowType) {
+  switch (arrowType.constructor) {
+    case import_apache_arrow5.Null:
+      return "null";
+    case import_apache_arrow5.Binary:
+      return "binary";
+    case import_apache_arrow5.Bool:
+      return "bool";
+    case import_apache_arrow5.Int:
+      const intType = arrowType;
+      return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+    case import_apache_arrow5.Int8:
+      return "int8";
+    case import_apache_arrow5.Int16:
+      return "int16";
+    case import_apache_arrow5.Int32:
+      return "int32";
+    case import_apache_arrow5.Int64:
+      return "int64";
+    case import_apache_arrow5.Uint8:
+      return "uint8";
+    case import_apache_arrow5.Uint16:
+      return "uint16";
+    case import_apache_arrow5.Uint32:
+      return "uint32";
+    case import_apache_arrow5.Uint64:
+      return "uint64";
+    case import_apache_arrow5.Float:
+      const precision = arrowType.precision;
+      switch (precision) {
+        case import_apache_arrow5.Precision.HALF:
+          return "float16";
+        case import_apache_arrow5.Precision.SINGLE:
+          return "float32";
+        case import_apache_arrow5.Precision.DOUBLE:
+          return "float64";
+        default:
+          return "float16";
+      }
+    case import_apache_arrow5.Float16:
+      return "float16";
+    case import_apache_arrow5.Float32:
+      return "float32";
+    case import_apache_arrow5.Float64:
+      return "float64";
+    case import_apache_arrow5.Utf8:
+      return "utf8";
+    case Date:
+      const dateUnit = arrowType.unit;
+      return dateUnit === import_apache_arrow5.DateUnit.DAY ? "date-day" : "date-millisecond";
+    case import_apache_arrow5.DateDay:
+      return "date-day";
+    case import_apache_arrow5.DateMillisecond:
+      return "date-millisecond";
+    case import_apache_arrow5.Time:
+      const timeUnit = arrowType.unit;
+      switch (timeUnit) {
+        case import_apache_arrow5.TimeUnit.SECOND:
+          return "time-second";
+        case import_apache_arrow5.TimeUnit.MILLISECOND:
+          return "time-millisecond";
+        case import_apache_arrow5.TimeUnit.MICROSECOND:
+          return "time-microsecond";
+        case import_apache_arrow5.TimeUnit.NANOSECOND:
+          return "time-nanosecond";
+        default:
+          return "time-second";
+      }
+    case import_apache_arrow5.TimeMillisecond:
+      return "time-millisecond";
+    case import_apache_arrow5.TimeSecond:
+      return "time-second";
+    case import_apache_arrow5.TimeMicrosecond:
+      return "time-microsecond";
+    case import_apache_arrow5.TimeNanosecond:
+      return "time-nanosecond";
+    case import_apache_arrow5.Timestamp:
+      const timeStampUnit = arrowType.unit;
+      switch (timeStampUnit) {
+        case import_apache_arrow5.TimeUnit.SECOND:
+          return "timestamp-second";
+        case import_apache_arrow5.TimeUnit.MILLISECOND:
+          return "timestamp-millisecond";
+        case import_apache_arrow5.TimeUnit.MICROSECOND:
+          return "timestamp-microsecond";
+        case import_apache_arrow5.TimeUnit.NANOSECOND:
+          return "timestamp-nanosecond";
+        default:
+          return "timestamp-second";
+      }
+    case import_apache_arrow5.TimestampSecond:
+      return "timestamp-second";
+    case import_apache_arrow5.TimestampMillisecond:
+      return "timestamp-millisecond";
+    case import_apache_arrow5.TimestampMicrosecond:
+      return "timestamp-microsecond";
+    case import_apache_arrow5.TimestampNanosecond:
+      return "timestamp-nanosecond";
+    case import_apache_arrow5.Interval:
+      const intervalUnit = arrowType.unit;
+      switch (intervalUnit) {
+        case import_apache_arrow5.IntervalUnit.DAY_TIME:
+          return "interval-daytime";
+        case import_apache_arrow5.IntervalUnit.YEAR_MONTH:
+          return "interval-yearmonth";
+        default:
+          return "interval-daytime";
+      }
+    case import_apache_arrow5.IntervalDayTime:
+      return "interval-daytime";
+    case import_apache_arrow5.IntervalYearMonth:
+      return "interval-yearmonth";
+    case import_apache_arrow5.List:
+      const listType = arrowType;
+      const listField = listType.valueField;
+      return {
+        type: "list",
+        children: [serializeArrowField(listField)]
+      };
+    case import_apache_arrow5.FixedSizeList:
+      return {
+        type: "fixed-size-list",
+        listSize: arrowType.listSize,
+        children: [serializeArrowField(arrowType.children[0])]
+      };
+    default:
+      throw new Error("array type not supported");
+  }
+}
+function deserializeArrowType(dataType) {
+  if (typeof dataType === "object") {
+    switch (dataType.type) {
+      case "list":
+        const field = deserializeArrowField(dataType.children[0]);
+        return new import_apache_arrow5.List(field);
+      case "fixed-size-list":
+        const child = deserializeArrowField(dataType.children[0]);
+        return new import_apache_arrow5.FixedSizeList(dataType.listSize, child);
+      case "struct":
+        const children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+        return new import_apache_arrow5.Struct(children);
+      default:
+        throw new Error("array type not supported");
+    }
+  }
+  switch (dataType) {
+    case "null":
+      return new import_apache_arrow5.Null();
+    case "binary":
+      return new import_apache_arrow5.Binary();
+    case "bool":
+      return new import_apache_arrow5.Bool();
+    case "int8":
+      return new import_apache_arrow5.Int8();
+    case "int16":
+      return new import_apache_arrow5.Int16();
+    case "int32":
+      return new import_apache_arrow5.Int32();
+    case "int64":
+      return new import_apache_arrow5.Int64();
+    case "uint8":
+      return new import_apache_arrow5.Uint8();
+    case "uint16":
+      return new import_apache_arrow5.Uint16();
+    case "uint32":
+      return new import_apache_arrow5.Uint32();
+    case "uint64":
+      return new import_apache_arrow5.Uint64();
+    case "float16":
+      return new import_apache_arrow5.Float16();
+    case "float32":
+      return new import_apache_arrow5.Float32();
+    case "float64":
+      return new import_apache_arrow5.Float64();
+    case "utf8":
+      return new import_apache_arrow5.Utf8();
+    case "date-day":
+      return new import_apache_arrow5.DateDay();
+    case "date-millisecond":
+      return new import_apache_arrow5.DateMillisecond();
+    case "time-second":
+      return new import_apache_arrow5.TimeSecond();
+    case "time-millisecond":
+      return new import_apache_arrow5.TimeMillisecond();
+    case "time-microsecond":
+      return new import_apache_arrow5.TimeMicrosecond();
+    case "time-nanosecond":
+      return new import_apache_arrow5.TimeNanosecond();
+    case "timestamp-second":
+      return new import_apache_arrow5.TimestampSecond();
+    case "timestamp-millisecond":
+      return new import_apache_arrow5.TimestampMillisecond();
+    case "timestamp-microsecond":
+      return new import_apache_arrow5.TimestampMicrosecond();
+    case "timestamp-nanosecond":
+      return new import_apache_arrow5.TimestampNanosecond();
+    case "interval-daytime":
+      return new import_apache_arrow5.IntervalDayTime();
+    case "interval-yearmonth":
+      return new import_apache_arrow5.IntervalYearMonth();
+    default:
+      throw new Error("array type not supported");
+  }
+}
+
 // src/types.ts
 var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
   VECTOR_TYPES2[VECTOR_TYPES2["FLOAT"] = 0] = "FLOAT";
@@ -211,24 +462,24 @@ var VECTOR_TYPES = /* @__PURE__ */ ((VECTOR_TYPES2) => {
 })(VECTOR_TYPES || {});
 
 // src/lib/encode-arrow.ts
-var import_apache_arrow5 = require("apache-arrow");
+var import_apache_arrow6 = require("apache-arrow");
 function encodeArrowSync(data) {
   const vectors = {};
   for (const arrayData of data) {
     const arrayVector = createVector(arrayData.array, arrayData.type);
     vectors[arrayData.name] = arrayVector;
   }
-  const table = new import_apache_arrow5.Table(vectors);
-  const arrowBuffer = (0, import_apache_arrow5.tableToIPC)(table);
+  const table = new import_apache_arrow6.Table(vectors);
+  const arrowBuffer = (0, import_apache_arrow6.tableToIPC)(table);
   return arrowBuffer;
 }
 function createVector(array, type) {
   switch (type) {
     case 1 /* DATE */:
-      return (0, import_apache_arrow5.vectorFromArray)(array);
+      return (0, import_apache_arrow6.vectorFromArray)(array);
     case 0 /* FLOAT */:
     default:
-      return (0, import_apache_arrow5.vectorFromArray)(array);
+      return (0, import_apache_arrow6.vectorFromArray)(array);
   }
 }
 
@@ -252,6 +503,337 @@ var ArrowWriter = {
   options: {}
 };
 
+// src/geoarrow/get-arrow-bounds.ts
+function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+  const numberOfFeatures = flatCoords.length / nDim;
+  const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+  const newBounds = [...bounds];
+  for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+    const lng = flatCoords[i * nDim];
+    const lat = flatCoords[i * nDim + 1];
+    if (lng < bounds[0]) {
+      newBounds[0] = lng;
+    }
+    if (lat < newBounds[1]) {
+      newBounds[1] = lat;
+    }
+    if (lng > newBounds[2]) {
+      newBounds[2] = lng;
+    }
+    if (lat > newBounds[3]) {
+      newBounds[3] = lat;
+    }
+  }
+  return newBounds;
+}
+
+// src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+var BINARY_GEOMETRY_TEMPLATE = {
+  globalFeatureIds: { value: new Uint32Array(0), size: 1 },
+  positions: { value: new Float32Array(0), size: 2 },
+  properties: [],
+  numericProps: {},
+  featureIds: { value: new Uint32Array(0), size: 1 }
+};
+function getBinaryGeometriesFromArrow(geoColumn, geoEncoding) {
+  const featureTypes = {
+    polygon: geoEncoding === "geoarrow.multipolygon" || geoEncoding === "geoarrow.polygon",
+    point: geoEncoding === "geoarrow.multipoint" || geoEncoding === "geoarrow.point",
+    line: geoEncoding === "geoarrow.multilinestring" || geoEncoding === "geoarrow.linestring"
+  };
+  const chunks = geoColumn.data;
+  const bounds = [Infinity, Infinity, -Infinity, -Infinity];
+  let globalFeatureIdOffset = 0;
+  const binaryGeometries = [];
+  for (let c = 0; c < chunks.length; c++) {
+    const geometries = chunks[c];
+    const { featureIds, flatCoordinateArray, nDim, geomOffset } = getBinaryGeometriesFromChunk(
+      geometries,
+      geoEncoding
+    );
+    const numOfVertices = flatCoordinateArray.length / nDim;
+    const globalFeatureIds = new Uint32Array(numOfVertices);
+    for (let i = 0; i < numOfVertices; i++) {
+      globalFeatureIds[i] = featureIds[i] + globalFeatureIdOffset;
+    }
+    const binaryContent = {
+      globalFeatureIds: { value: globalFeatureIds, size: 1 },
+      positions: {
+        value: flatCoordinateArray,
+        size: nDim
+      },
+      featureIds: { value: featureIds, size: 1 },
+      // eslint-disable-next-line no-loop-func
+      properties: [...Array(geometries.length).keys()].map((i) => ({
+        index: i + globalFeatureIdOffset
+      }))
+    };
+    globalFeatureIdOffset += geometries.length;
+    binaryGeometries.push({
+      shape: "binary-feature-collection",
+      points: {
+        type: "Point",
+        ...BINARY_GEOMETRY_TEMPLATE,
+        ...featureTypes.point ? binaryContent : {}
+      },
+      lines: {
+        type: "LineString",
+        ...BINARY_GEOMETRY_TEMPLATE,
+        ...featureTypes.line ? binaryContent : {},
+        pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
+      },
+      polygons: {
+        type: "Polygon",
+        ...BINARY_GEOMETRY_TEMPLATE,
+        ...featureTypes.polygon ? binaryContent : {},
+        polygonIndices: {
+          // TODO why deck.gl's tessellatePolygon performance is not good when using geometryIndicies
+          // even when there is no hole in any polygon
+          value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+          size: 1
+        },
+        primitivePolygonIndices: {
+          value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
+          size: 1
+        }
+      }
+    });
+    updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+  }
+  return { binaryGeometries, bounds, featureTypes };
+}
+function getBinaryGeometriesFromChunk(chunk, geoEncoding) {
+  switch (geoEncoding) {
+    case "geoarrow.point":
+    case "geoarrow.multipoint":
+      return getBinaryPointsFromChunk(chunk, geoEncoding);
+    case "geoarrow.linestring":
+    case "geoarrow.multilinestring":
+      return getBinaryLinesFromChunk(chunk, geoEncoding);
+    case "geoarrow.polygon":
+    case "geoarrow.multipolygon":
+      return getBinaryPolygonsFromChunk(chunk, geoEncoding);
+    default:
+      throw Error("invalid geoarrow encoding");
+  }
+}
+function getBinaryPolygonsFromChunk(chunk, geoEncoding) {
+  const isMultiPolygon = geoEncoding === "geoarrow.multipolygon";
+  const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
+  const ringData = polygonData.children[0];
+  const pointData = ringData.children[0];
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const geomOffset = ringData.valueOffsets;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(chunk.length + 1);
+  for (let i = 0; i < chunk.length; i++) {
+    geometryIndicies[i] = geomOffset[chunk.valueOffsets[i]];
+  }
+  geometryIndicies[chunk.length] = flatCoordinateArray.length / nDim;
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  for (let i = 0; i < chunk.length - 1; i++) {
+    const startIdx = geomOffset[chunk.valueOffsets[i]];
+    const endIdx = geomOffset[chunk.valueOffsets[i + 1]];
+    for (let j = startIdx; j < endIdx; j++) {
+      featureIds[j] = i;
+    }
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+function getBinaryLinesFromChunk(chunk, geoEncoding) {
+  const isMultiLineString = geoEncoding === "geoarrow.multilinestring";
+  const lineData = isMultiLineString ? chunk.children[0] : chunk;
+  const pointData = lineData.children[0];
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const geomOffset = lineData.valueOffsets;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(0);
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  for (let i = 0; i < chunk.length; i++) {
+    const startIdx = geomOffset[i];
+    const endIdx = geomOffset[i + 1];
+    for (let j = startIdx; j < endIdx; j++) {
+      featureIds[j] = i;
+    }
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+function getBinaryPointsFromChunk(chunk, geoEncoding) {
+  const isMultiPoint = geoEncoding === "geoarrow.multipoint";
+  const pointData = isMultiPoint ? chunk.children[0] : chunk;
+  const coordData = pointData.children[0];
+  const nDim = pointData.stride;
+  const flatCoordinateArray = coordData.values;
+  const geometryIndicies = new Uint16Array(0);
+  const geomOffset = new Int32Array(0);
+  const numOfVertices = flatCoordinateArray.length / nDim;
+  const featureIds = new Uint32Array(numOfVertices);
+  for (let i = 0; i < chunk.length; i++) {
+    featureIds[i] = i;
+  }
+  return {
+    featureIds,
+    flatCoordinateArray,
+    nDim,
+    geomOffset,
+    geometryIndicies
+  };
+}
+
+// src/geoarrow/convert-geoarrow-to-geojson.ts
+function parseGeometryFromArrow(rawData) {
+  var _a;
+  const encoding = (_a = rawData.encoding) == null ? void 0 : _a.toLowerCase();
+  const data = rawData.data;
+  if (!encoding || !data) {
+    return null;
+  }
+  let geometry;
+  switch (encoding) {
+    case "geoarrow.multipolygon":
+      geometry = arrowMultiPolygonToFeature(data);
+      break;
+    case "geoarrow.polygon":
+      geometry = arrowPolygonToFeature(data);
+      break;
+    case "geoarrow.multipoint":
+      geometry = arrowMultiPointToFeature(data);
+      break;
+    case "geoarrow.point":
+      geometry = arrowPointToFeature(data);
+      break;
+    case "geoarrow.multilinestring":
+      geometry = arrowMultiLineStringToFeature(data);
+      break;
+    case "geoarrow.linestring":
+      geometry = arrowLineStringToFeature(data);
+      break;
+    default: {
+      throw Error(`GeoArrow encoding not supported ${encoding}`);
+    }
+  }
+  return {
+    type: "Feature",
+    geometry,
+    properties: {}
+  };
+}
+function arrowMultiPolygonToFeature(arrowMultiPolygon) {
+  const multiPolygon = [];
+  for (let m = 0; m < arrowMultiPolygon.length; m++) {
+    const arrowPolygon = arrowMultiPolygon.get(m);
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < (arrowPolygon == null ? void 0 : arrowPolygon.length); i++) {
+      const arrowRing = arrowPolygon == null ? void 0 : arrowPolygon.get(i);
+      const ring = [];
+      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+        const arrowCoord = arrowRing.get(j);
+        const coord = Array.from(arrowCoord);
+        ring.push(coord);
+      }
+      polygon.push(ring);
+    }
+    multiPolygon.push(polygon);
+  }
+  const geometry = {
+    type: "MultiPolygon",
+    coordinates: multiPolygon
+  };
+  return geometry;
+}
+function arrowPolygonToFeature(arrowPolygon) {
+  const polygon = [];
+  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+    const arrowRing = arrowPolygon.get(i);
+    const ring = [];
+    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+      const arrowCoord = arrowRing.get(j);
+      const coords = Array.from(arrowCoord);
+      ring.push(coords);
+    }
+    polygon.push(ring);
+  }
+  const geometry = {
+    type: "Polygon",
+    coordinates: polygon
+  };
+  return geometry;
+}
+function arrowMultiPointToFeature(arrowMultiPoint) {
+  const multiPoint = [];
+  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+    const arrowPoint = arrowMultiPoint.get(i);
+    if (arrowPoint) {
+      const coord = Array.from(arrowPoint);
+      multiPoint.push(coord);
+    }
+  }
+  const geometry = {
+    type: "MultiPoint",
+    coordinates: multiPoint
+  };
+  return geometry;
+}
+function arrowPointToFeature(arrowPoint) {
+  const point = Array.from(arrowPoint);
+  const geometry = {
+    type: "Point",
+    coordinates: point
+  };
+  return geometry;
+}
+function arrowMultiLineStringToFeature(arrowMultiLineString) {
+  const multiLineString = [];
+  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+    const arrowLineString = arrowMultiLineString.get(i);
+    const lineString = [];
+    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+      const arrowCoord = arrowLineString.get(j);
+      if (arrowCoord) {
+        const coords = Array.from(arrowCoord);
+        lineString.push(coords);
+      }
+    }
+    multiLineString.push(lineString);
+  }
+  const geometry = {
+    type: "MultiLineString",
+    coordinates: multiLineString
+  };
+  return geometry;
+}
+function arrowLineStringToFeature(arrowLineString) {
+  const lineString = [];
+  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+    const arrowCoord = arrowLineString.get(i);
+    if (arrowCoord) {
+      const coords = Array.from(arrowCoord);
+      lineString.push(coords);
+    }
+  }
+  const geometry = {
+    type: "LineString",
+    coordinates: lineString
+  };
+  return geometry;
+}
+
 // src/index.ts
 import_schema3.TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
 var ArrowLoader2 = {

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import type { ArrowTableBatch, ColumnarTable, ObjectRowTable } from '@loaders.gl
 import type { ArrowTable } from './lib/arrow-table';
 import { ArrowLoader as ArrowWorkerLoader } from './arrow-loader';
 export { getArrowType } from './schema/arrow-type-utils';
+export { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from './schema/convert-arrow-schema';
 export type { ArrowTable, ArrowTableBatch } from './lib/arrow-table';
 export { VECTOR_TYPES } from './types';
 export { ArrowWriter } from './arrow-writer';
@@ -11,4 +12,8 @@ export type { ArrowLoaderOptions };
 export { ArrowWorkerLoader };
 /** ArrowJS table loader */
 export declare const ArrowLoader: LoaderWithParser<ArrowTable | ColumnarTable | ObjectRowTable, ArrowTableBatch, ArrowLoaderOptions>;
+export type { GeoArrowEncoding } from '@loaders.gl/gis';
+export type { BinaryDataFromGeoArrow } from './geoarrow/convert-geoarrow-to-binary-geometry';
+export { getBinaryGeometriesFromArrow } from './geoarrow/convert-geoarrow-to-binary-geometry';
+export { parseGeometryFromArrow } from './geoarrow/convert-geoarrow-to-geojson';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAQhE,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAMvD,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAC,eAAe,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACvF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,mBAAmB,CAAC;AAGlD,OAAO,EAAC,WAAW,IAAI,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAWhE,OAAO,EAAC,YAAY,EAAC,MAAM,2BAA2B,CAAC;AAIvD,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,oBAAoB,EACrB,MAAM,+BAA+B,CAAC;AAGvC,YAAY,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAIrC,OAAO,EAAC,WAAW,EAAC,MAAM,gBAAgB,CAAC;AAI3C,YAAY,EAAC,kBAAkB,EAAC,CAAC;AACjC,OAAO,EAAC,iBAAiB,EAAC,CAAC;AAE3B,2BAA2B;AAC3B,eAAO,MAAM,WAAW,EAAE,gBAAgB,CACxC,UAAU,GAAG,aAAa,GAAG,cAAc,EAC3C,eAAe,EACf,kBAAkB,CAOnB,CAAC;AAGF,YAAY,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAItD,YAAY,EAAC,sBAAsB,EAAC,MAAM,gDAAgD,CAAC;AAC3F,OAAO,EAAC,4BAA4B,EAAC,MAAM,gDAAgD,CAAC;AAE5F,OAAO,EAAC,sBAAsB,EAAC,MAAM,wCAAwC,CAAC"}

package/dist/index.js

@@ -3,8 +3,9 @@ import { ArrowLoader as ArrowWorkerLoader } from "./arrow-loader.js";
 import parseSync from "./lib/parse-arrow-sync.js";
 import { parseArrowInBatches } from "./lib/parse-arrow-in-batches.js";
 import { ArrowTableBatchAggregator } from "./lib/arrow-table-batch.js";
-export { getArrowType } from "./schema/arrow-type-utils.js";
 TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
+export { getArrowType } from "./schema/arrow-type-utils.js";
+export { serializeArrowSchema, deserializeArrowSchema, serializeArrowMetadata, deserializeArrowMetadata, serializeArrowField, deserializeArrowField, serializeArrowType, deserializeArrowType } from "./schema/convert-arrow-schema.js";
 export { VECTOR_TYPES } from "./types.js";
 export { ArrowWriter } from "./arrow-writer.js";
 export { ArrowWorkerLoader };
@@ -14,4 +15,6 @@ export const ArrowLoader = {
   parseSync,
   parseInBatches: parseArrowInBatches
 };
+export { getBinaryGeometriesFromArrow } from "./geoarrow/convert-geoarrow-to-binary-geometry.js";
+export { parseGeometryFromArrow } from "./geoarrow/convert-geoarrow-to-geojson.js";
 //# sourceMappingURL=index.js.map