@loaders.gl/arrow 4.3.2 → 4.4.0-alpha.1

package/dist/lib/geoarrow/convert-geoarrow-to-binary-geometry.js

@@ -1,377 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { earcut } from '@math.gl/polygon';
-import { updateBoundsFromGeoArrowSamples } from "./get-arrow-bounds.js";
-/**
- * Binary geometry type
- */
-var BinaryGeometryType;
-(function (BinaryGeometryType) {
-    BinaryGeometryType["points"] = "points";
-    BinaryGeometryType["lines"] = "lines";
-    BinaryGeometryType["polygons"] = "polygons";
-})(BinaryGeometryType || (BinaryGeometryType = {}));
-/**
- * binary geometry template, see deck.gl BinaryGeometry
- */
-export function getBinaryGeometryTemplate() {
-    return {
-        globalFeatureIds: { value: new Uint32Array(0), size: 1 },
-        positions: { value: new Float32Array(0), size: 2 },
-        properties: [],
-        numericProps: {},
-        featureIds: { value: new Uint32Array(0), size: 1 }
-    };
-}
-/**
- * get binary geometries from geoarrow column
- *
- * @param geoColumn the geoarrow column, e.g. arrowTable.getChildAt(geoColumnIndex)
- * @param geoEncoding the geo encoding of the geoarrow column, e.g. getGeoArrowEncoding(arrowTable.schema, geoColumnName)
- * @param options options for getting binary geometries {meanCenter: boolean}
- * @returns BinaryDataFromGeoArrow
- */
-export function getBinaryGeometriesFromArrow(geoColumn, geoEncoding, options) {
-    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 = options?.chunkIndex !== undefined && options?.chunkIndex >= 0
-        ? [geoColumn.data[options?.chunkIndex]]
-        : geoColumn.data;
-    let bounds = [Infinity, Infinity, -Infinity, -Infinity];
-    let globalFeatureIdOffset = options?.chunkOffset || 0;
-    const binaryGeometries = [];
-    chunks.forEach((chunk) => {
-        const { featureIds, flatCoordinateArray, nDim, geomOffset, triangles } = getBinaryGeometriesFromChunk(chunk, geoEncoding, options);
-        const globalFeatureIds = new Uint32Array(featureIds.length);
-        for (let i = 0; i < featureIds.length; 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(chunk.length).keys()].map((i) => ({
-                index: i + globalFeatureIdOffset
-            }))
-        };
-        // TODO: check if chunks are sequentially accessed
-        globalFeatureIdOffset += chunk.length;
-        // NOTE: deck.gl defines the BinaryFeatures structure must have points, lines, polygons even if they are empty
-        binaryGeometries.push({
-            shape: 'binary-feature-collection',
-            points: {
-                type: 'Point',
-                ...getBinaryGeometryTemplate(),
-                ...(featureTypes.point ? binaryContent : {})
-            },
-            lines: {
-                type: 'LineString',
-                ...getBinaryGeometryTemplate(),
-                ...(featureTypes.line ? binaryContent : {}),
-                pathIndices: { value: featureTypes.line ? geomOffset : new Uint16Array(0), size: 1 }
-            },
-            polygons: {
-                type: 'Polygon',
-                ...getBinaryGeometryTemplate(),
-                ...(featureTypes.polygon ? binaryContent : {}),
-                polygonIndices: {
-                    // use geomOffset as polygonIndices same as primitivePolygonIndices since we are using earcut to get triangule indices
-                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
-                    size: 1
-                },
-                primitivePolygonIndices: {
-                    value: featureTypes.polygon ? geomOffset : new Uint16Array(0),
-                    size: 1
-                },
-                ...(triangles ? { triangles: { value: triangles, size: 1 } } : {})
-            }
-        });
-        bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-    });
-    return {
-        binaryGeometries,
-        bounds,
-        featureTypes,
-        ...(options?.calculateMeanCenters
-            ? { meanCenters: getMeanCentersFromBinaryGeometries(binaryGeometries) }
-            : {})
-    };
-}
-/**
- * Get mean centers from binary geometries
- * @param binaryGeometries binary geometries from geoarrow column, an array of BinaryFeatureCollection
- * @returns mean centers of the binary geometries
- */
-export function getMeanCentersFromBinaryGeometries(binaryGeometries) {
-    const globalMeanCenters = [];
-    binaryGeometries.forEach((binaryGeometry) => {
-        let binaryGeometryType = null;
-        if (binaryGeometry.points && binaryGeometry.points.positions.value.length > 0) {
-            binaryGeometryType = BinaryGeometryType.points;
-        }
-        else if (binaryGeometry.lines && binaryGeometry.lines.positions.value.length > 0) {
-            binaryGeometryType = BinaryGeometryType.lines;
-        }
-        else if (binaryGeometry.polygons && binaryGeometry.polygons.positions.value.length > 0) {
-            binaryGeometryType = BinaryGeometryType.polygons;
-        }
-        const binaryContent = binaryGeometryType ? binaryGeometry[binaryGeometryType] : null;
-        if (binaryContent && binaryGeometryType !== null) {
-            const featureIds = binaryContent.featureIds.value;
-            const flatCoordinateArray = binaryContent.positions.value;
-            const nDim = binaryContent.positions.size;
-            const primitivePolygonIndices = binaryContent.type === 'Polygon' ? binaryContent.primitivePolygonIndices?.value : undefined;
-            const meanCenters = getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, binaryGeometryType, primitivePolygonIndices);
-            meanCenters.forEach((center) => {
-                globalMeanCenters.push(center);
-            });
-        }
-    });
-    return globalMeanCenters;
-}
-/**
- * Get mean centers from raw coordinates and feature ids
- * @param featureIds Array of feature ids indexes by vertex
- * @param flatCoordinateArray  Array of vertex, e.g. x, y or x, y, z, positions
- * @param nDim number of dimensions per position
- * @returns - mean centers of each polygon
- */
-function getMeanCentersFromGeometry(featureIds, flatCoordinateArray, nDim, geometryType, primitivePolygonIndices) {
-    const meanCenters = [];
-    const vertexCount = flatCoordinateArray.length;
-    let vertexIndex = 0;
-    let coordIdx = 0;
-    let primitiveIdx = 0;
-    while (vertexIndex < vertexCount) {
-        const featureId = featureIds[vertexIndex / nDim];
-        const center = [0, 0];
-        let vertexCountInFeature = 0;
-        while (vertexIndex < vertexCount && featureIds[coordIdx] === featureId) {
-            if (geometryType === BinaryGeometryType.polygons &&
-                primitivePolygonIndices?.[primitiveIdx] === coordIdx) {
-                // skip the first point since it is the same as the last point in each ring for polygons
-                vertexIndex += nDim;
-                primitiveIdx++;
-            }
-            else {
-                center[0] += flatCoordinateArray[vertexIndex];
-                center[1] += flatCoordinateArray[vertexIndex + 1];
-                vertexIndex += nDim;
-                vertexCountInFeature++;
-            }
-            coordIdx += 1;
-        }
-        center[0] /= vertexCountInFeature;
-        center[1] /= vertexCountInFeature;
-        meanCenters.push(center);
-    }
-    return meanCenters;
-}
-/**
- * get binary geometries from geoarrow column
- * @param chunk one chunk/batch of geoarrow column
- * @param geoEncoding geo encoding of the geoarrow column
- * @param options options for getting binary geometries
- * @returns BinaryGeometryContent
- */
-function getBinaryGeometriesFromChunk(chunk, geoEncoding, options) {
-    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, options);
-        default:
-            throw Error('invalid geoarrow encoding');
-    }
-}
-/**
- * get triangle indices. Allows deck.gl to skip performing costly triangulation on main thread.
- * @param polygonIndices Indices within positions of the start of each simple Polygon
- * @param primitivePolygonIndices Indices within positions of the start of each primitive Polygon/ring
- * @param flatCoordinateArray Array of x, y or x, y, z positions
- * @param nDim - number of dimensions per position
- * @returns triangle indices or null if invalid polygon and earcut fails
- */
-export function getTriangleIndices(polygonIndices, primitivePolygonIndices, flatCoordinateArray, nDim) {
-    try {
-        let primitiveIndex = 0;
-        const triangles = [];
-        // loop polygonIndices to get triangles
-        for (let i = 0; i < polygonIndices.length - 1; i++) {
-            const startIdx = polygonIndices[i];
-            const endIdx = polygonIndices[i + 1];
-            // get subarray of flatCoordinateArray
-            const slicedFlatCoords = flatCoordinateArray.subarray(startIdx * nDim, endIdx * nDim);
-            // get holeIndices for earcut
-            const holeIndices = [];
-            while (primitivePolygonIndices[primitiveIndex] < endIdx) {
-                if (primitivePolygonIndices[primitiveIndex] > startIdx) {
-                    holeIndices.push(primitivePolygonIndices[primitiveIndex] - startIdx);
-                }
-                primitiveIndex++;
-            }
-            // TODO check if each ring is closed
-            const triangleIndices = earcut(slicedFlatCoords, holeIndices.length > 0 ? holeIndices : undefined, nDim);
-            if (triangleIndices.length === 0) {
-                throw Error('earcut failed e.g. invalid polygon');
-            }
-            for (let j = 0; j < triangleIndices.length; j++) {
-                triangles.push(triangleIndices[j] + startIdx);
-            }
-        }
-        // convert traingles to Uint32Array
-        const trianglesUint32 = new Uint32Array(triangles.length);
-        for (let i = 0; i < triangles.length; i++) {
-            trianglesUint32[i] = triangles[i];
-        }
-        return trianglesUint32;
-    }
-    catch (error) {
-        // if earcut fails, return null
-        return null;
-    }
-}
-/**
- * get binary polygons from geoarrow polygon column
- * @param chunk one chunk of geoarrow polygon column
- * @param geoEncoding the geo encoding of the geoarrow polygon column
- * @param options options for getting binary geometries
- * @returns BinaryGeometryContent
- */
-function getBinaryPolygonsFromChunk(chunk, geoEncoding, options) {
-    const isMultiPolygon = geoEncoding === 'geoarrow.multipolygon';
-    const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
-    const polygonOffset = polygonData.valueOffsets;
-    const partData = isMultiPolygon
-        ? chunk.valueOffsets.map((i) => polygonOffset.at(i) || i)
-        : chunk.valueOffsets;
-    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(polygonOffset.length);
-    for (let i = 0; i < polygonOffset.length; i++) {
-        geometryIndicies[i] = geomOffset[polygonOffset[i]];
-    }
-    const numOfVertices = flatCoordinateArray.length / nDim;
-    const featureIds = new Uint32Array(numOfVertices);
-    for (let i = 0; i < partData.length - 1; i++) {
-        const startIdx = geomOffset[partData[i]];
-        const endIdx = geomOffset[partData[i + 1]];
-        for (let j = startIdx; j < endIdx; j++) {
-            featureIds[j] = i;
-        }
-    }
-    const triangles = options?.triangulate
-        ? getTriangleIndices(geometryIndicies, geomOffset, flatCoordinateArray, nDim)
-        : null;
-    return {
-        featureIds,
-        nDim,
-        flatCoordinateArray,
-        geomOffset,
-        geometryIndicies,
-        ...(options?.triangulate && triangles ? { triangles } : {})
-    };
-}
-/**
- * get binary lines from geoarrow line column
- * @param chunk one chunk/batch of geoarrow column
- * @param geoEncoding the geo encoding of the geoarrow column
- * @returns BinaryGeometryContent
- */
-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;
-    // geometryIndicies is not needed for line string
-    const geometryIndicies = new Uint16Array(0);
-    const numOfVertices = flatCoordinateArray.length / nDim;
-    const featureIds = new Uint32Array(numOfVertices);
-    if (isMultiLineString) {
-        const partData = chunk.valueOffsets;
-        for (let i = 0; i < partData.length - 1; i++) {
-            const startIdx = geomOffset[partData[i]];
-            const endIdx = geomOffset[partData[i + 1]];
-            for (let j = startIdx; j < endIdx; j++) {
-                featureIds[j] = i;
-            }
-        }
-    }
-    else {
-        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
-    };
-}
-/**
- * get binary points from geoarrow point column
- * @param chunk one chunk/batch of geoarrow column
- * @param geoEncoding  geo encoding of the geoarrow column
- * @returns BinaryGeometryContent
- */
-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;
-    // geometryIndices is not needed for point
-    const geometryIndicies = new Uint16Array(0);
-    // geomOffset is not needed for point
-    const geomOffset = new Int32Array(0);
-    const numOfVertices = flatCoordinateArray.length / nDim;
-    const featureIds = new Uint32Array(numOfVertices);
-    if (isMultiPoint) {
-        const partData = chunk.valueOffsets;
-        for (let i = 0; i < partData.length - 1; i++) {
-            const startIdx = partData[i];
-            const endIdx = partData[i + 1];
-            for (let j = startIdx; j < endIdx; j++) {
-                featureIds[j] = i;
-            }
-        }
-    }
-    else {
-        for (let i = 0; i < chunk.length; i++) {
-            featureIds[i] = i;
-        }
-    }
-    return {
-        featureIds,
-        flatCoordinateArray,
-        nDim,
-        geomOffset,
-        geometryIndicies
-    };
-}

package/dist/lib/geoarrow/convert-geoarrow-to-geojson-geometry.d.ts

@@ -1,13 +0,0 @@
-import { Geometry } from '@loaders.gl/schema';
-import { type GeoArrowEncoding } from '@loaders.gl/gis';
-/**
- * parse geometry from arrow data that is returned from processArrowData()
- * NOTE: this function could be deduplicated with the binaryToFeature() in deck.gl,
- * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
- *
- * @param data data extraced from arrow vector representing a geometry
- * @param encoding the geoarrow encoding of the geometry column
- * @returns Feature or null
- */
-export declare function parseGeometryFromArrow(arrowCellValue: any, encoding?: GeoArrowEncoding): Geometry | null;
-//# sourceMappingURL=convert-geoarrow-to-geojson-geometry.d.ts.map

package/dist/lib/geoarrow/convert-geoarrow-to-geojson-geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-geoarrow-to-geojson-geometry.d.ts","sourceRoot":"","sources":["../../../src/lib/geoarrow/convert-geoarrow-to-geojson-geometry.ts"],"names":[],"mappings":"AAKA,OAAO,EAQL,QAAQ,EAET,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAmB,KAAK,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAGxE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,GAAG,EACnB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,QAAQ,GAAG,IAAI,CAwCjB"}

package/dist/lib/geoarrow/convert-geoarrow-to-geojson-geometry.js

@@ -1,176 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { binaryToGeometry } from '@loaders.gl/gis';
-import { WKBLoader, WKTLoader } from '@loaders.gl/wkt';
-/**
- * parse geometry from arrow data that is returned from processArrowData()
- * NOTE: this function could be deduplicated with the binaryToFeature() in deck.gl,
- * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
- *
- * @param data data extraced from arrow vector representing a geometry
- * @param encoding the geoarrow encoding of the geometry column
- * @returns Feature or null
- */
-export function parseGeometryFromArrow(arrowCellValue, encoding) {
-    // sanity
-    encoding = encoding?.toLowerCase();
-    if (!encoding || !arrowCellValue) {
-        return null;
-    }
-    let geometry;
-    switch (encoding) {
-        case 'geoarrow.multipolygon':
-            geometry = arrowMultiPolygonToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.polygon':
-            geometry = arrowPolygonToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.multipoint':
-            geometry = arrowMultiPointToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.point':
-            geometry = arrowPointToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.multilinestring':
-            geometry = arrowMultiLineStringToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.linestring':
-            geometry = arrowLineStringToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.wkb':
-            geometry = arrowWKBToFeature(arrowCellValue);
-            break;
-        case 'geoarrow.wkt':
-            geometry = arrowWKTToFeature(arrowCellValue);
-            break;
-        default: {
-            throw Error(`GeoArrow encoding not supported ${encoding}`);
-        }
-    }
-    return geometry;
-}
-function arrowWKBToFeature(arrowCellValue) {
-    // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength
-    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
-    const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);
-    const geometry = binaryToGeometry(binaryGeometry);
-    return geometry;
-}
-function arrowWKTToFeature(arrowCellValue) {
-    const string = arrowCellValue;
-    return WKTLoader.parseTextSync?.(string);
-}
-/**
- * convert Arrow MultiPolygon to geojson Feature
- */
-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?.length; i++) {
-            const arrowRing = 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;
-}
-/**
- * convert Arrow Polygon to geojson Feature
- */
-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;
-}
-/**
- * convert Arrow MultiPoint to geojson MultiPoint
- */
-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);
-        }
-    }
-    return {
-        type: 'MultiPoint',
-        coordinates: multiPoint
-    };
-}
-/**
- * convert Arrow Point to geojson Point
- */
-function arrowPointToFeature(arrowPoint) {
-    const point = Array.from(arrowPoint);
-    return {
-        type: 'Point',
-        coordinates: point
-    };
-}
-/**
- * convert Arrow MultiLineString to geojson MultiLineString
- */
-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);
-    }
-    return {
-        type: 'MultiLineString',
-        coordinates: multiLineString
-    };
-}
-/**
- * convert Arrow LineString to geojson LineString
- */
-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);
-        }
-    }
-    return {
-        type: 'LineString',
-        coordinates: lineString
-    };
-}

package/dist/lib/geoarrow/get-arrow-bounds.d.ts

@@ -1,11 +0,0 @@
-/**
- *  Update bounds from geoarrow sample data
- *
- * @param flatCoords the flattend coordinates array from one chunk of geoarrow column
- * @param nDim the number of dimensions of the coordinates
- * @param bounds the bounds to be updated
- * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk
- * @returns the updated bounds
- */
-export declare function updateBoundsFromGeoArrowSamples(flatCoords: Float64Array, nDim: number, bounds: [number, number, number, number], sampleSize?: number): [number, number, number, number];
-//# sourceMappingURL=get-arrow-bounds.d.ts.map

package/dist/lib/geoarrow/get-arrow-bounds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-arrow-bounds.d.ts","sourceRoot":"","sources":["../../../src/lib/geoarrow/get-arrow-bounds.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,UAAU,GAAE,MAAY,GACvB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAsBlC"}

package/dist/lib/geoarrow/get-arrow-bounds.js

@@ -1,34 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/**
- *  Update bounds from geoarrow sample data
- *
- * @param flatCoords the flattend coordinates array from one chunk of geoarrow column
- * @param nDim the number of dimensions of the coordinates
- * @param bounds the bounds to be updated
- * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk
- * @returns the updated bounds
- */
-export 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 < newBounds[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;
-}

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

@@ -1,23 +0,0 @@
-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/tables/convert-arrow-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-arrow-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/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"}