@loaders.gl/shapefile 4.0.0-alpha.22 → 4.0.0-alpha.24

package/dist/lib/parsers/parse-shapefile.js

@@ -1,240 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceExtension = exports.loadShapefileSidecarFiles = exports.parseShapefile = exports.parseShapefileInBatches = void 0;
-// import type {Feature} from '@loaders.gl/gis';
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const gis_1 = require("@loaders.gl/gis");
-const proj4_1 = require("@math.gl/proj4");
-const parse_shx_1 = require("./parse-shx");
-const zip_batch_iterators_1 = require("../streaming/zip-batch-iterators");
-const shp_loader_1 = require("../../shp-loader");
-const dbf_loader_1 = require("../../dbf-loader");
-/**
- * Parsing of file in batches
- */
-// eslint-disable-next-line max-statements, complexity
-async function* parseShapefileInBatches(asyncIterator, options, context) {
-    const { reproject = false, _targetCrs = 'WGS84' } = options?.gis || {};
-    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);
-    // parse geometries
-    const shapeIterable = await (0, loader_utils_1.parseInBatchesFromContext)(asyncIterator, shp_loader_1.SHPLoader, options, context);
-    // parse properties
-    let propertyIterable;
-    const dbfResponse = await context?.fetch(replaceExtension(context?.url || '', 'dbf'));
-    if (dbfResponse?.ok) {
-        propertyIterable = await (0, loader_utils_1.parseInBatchesFromContext)(dbfResponse, dbf_loader_1.DBFLoader, {
-            ...options,
-            dbf: { encoding: cpg || 'latin1' }
-        }, context);
-    }
-    // When `options.metadata` is `true`, there's an extra initial `metadata`
-    // object before the iterator starts. zipBatchIterators expects to receive
-    // batches of Array objects, and will fail with non-iterable batches, so it's
-    // important to skip over the first batch.
-    let shapeHeader = (await shapeIterable.next()).value;
-    if (shapeHeader && shapeHeader.batchType === 'metadata') {
-        shapeHeader = (await shapeIterable.next()).value;
-    }
-    let dbfHeader = {};
-    if (propertyIterable) {
-        dbfHeader = (await propertyIterable.next()).value;
-        if (dbfHeader && dbfHeader.batchType === 'metadata') {
-            dbfHeader = (await propertyIterable.next()).value;
-        }
-    }
-    let iterator;
-    if (propertyIterable) {
-        iterator = (0, zip_batch_iterators_1.zipBatchIterators)(shapeIterable, propertyIterable);
-    }
-    else {
-        iterator = shapeIterable;
-    }
-    for await (const item of iterator) {
-        let geometries;
-        let properties;
-        if (!propertyIterable) {
-            geometries = item;
-        }
-        else {
-            [geometries, properties] = item;
-        }
-        const geojsonGeometries = parseGeometries(geometries);
-        let features = joinProperties(geojsonGeometries, properties);
-        if (reproject) {
-            // @ts-ignore
-            features = reprojectFeatures(features, prj, _targetCrs);
-        }
-        yield {
-            encoding: cpg,
-            prj,
-            shx,
-            header: shapeHeader,
-            data: features
-        };
-    }
-}
-exports.parseShapefileInBatches = parseShapefileInBatches;
-/**
- * Parse shapefile
- *
- * @param arrayBuffer
- * @param options
- * @param context
- * @returns output of shapefile
- */
-async function parseShapefile(arrayBuffer, options, context) {
-    const { reproject = false, _targetCrs = 'WGS84' } = options?.gis || {};
-    const { shx, cpg, prj } = await loadShapefileSidecarFiles(options, context);
-    // parse geometries
-    const { header, geometries } = await (0, loader_utils_1.parseFromContext)(arrayBuffer, shp_loader_1.SHPLoader, options, context); // {shp: shx}
-    const geojsonGeometries = parseGeometries(geometries);
-    // parse properties
-    let properties = [];
-    const dbfResponse = await context?.fetch(replaceExtension(context?.url, 'dbf'));
-    if (dbfResponse?.ok) {
-        properties = await (0, loader_utils_1.parseFromContext)(dbfResponse, dbf_loader_1.DBFLoader, { dbf: { encoding: cpg || 'latin1' } }, context);
-    }
-    let features = joinProperties(geojsonGeometries, properties);
-    if (reproject) {
-        features = reprojectFeatures(features, prj, _targetCrs);
-    }
-    return {
-        encoding: cpg,
-        prj,
-        shx,
-        header,
-        data: features
-    };
-}
-exports.parseShapefile = parseShapefile;
-/**
- * Parse geometries
- *
- * @param geometries
- * @returns geometries as an array
- */
-function parseGeometries(geometries) {
-    const geojsonGeometries = [];
-    for (const geom of geometries) {
-        geojsonGeometries.push((0, gis_1.binaryToGeometry)(geom));
-    }
-    return geojsonGeometries;
-}
-/**
- * Join properties and geometries into features
- *
- * @param geometries [description]
- * @param  properties [description]
- * @return [description]
- */
-function joinProperties(geometries, properties) {
-    const features = [];
-    for (let i = 0; i < geometries.length; i++) {
-        const geometry = geometries[i];
-        const feature = {
-            type: 'Feature',
-            geometry,
-            // properties can be undefined if dbfResponse above was empty
-            properties: (properties && properties[i]) || {}
-        };
-        features.push(feature);
-    }
-    return features;
-}
-/**
- * Reproject GeoJSON features to output CRS
- *
- * @param features parsed GeoJSON features
- * @param sourceCrs source coordinate reference system
- * @param targetCrs †arget coordinate reference system
- * @return Reprojected Features
- */
-function reprojectFeatures(features, sourceCrs, targetCrs) {
-    if (!sourceCrs && !targetCrs) {
-        return features;
-    }
-    const projection = new proj4_1.Proj4Projection({ from: sourceCrs || 'WGS84', to: targetCrs || 'WGS84' });
-    return (0, gis_1.transformGeoJsonCoords)(features, (coord) => projection.project(coord));
-}
-/**
- *
- * @param options
- * @param context
- * @returns Promise
- */
-// eslint-disable-next-line max-statements
-async function loadShapefileSidecarFiles(options, context) {
-    // Attempt a parallel load of the small sidecar files
-    // @ts-ignore context must be defined
-    const { url, fetch } = context;
-    const shxPromise = fetch(replaceExtension(url, 'shx'));
-    const cpgPromise = fetch(replaceExtension(url, 'cpg'));
-    const prjPromise = fetch(replaceExtension(url, 'prj'));
-    await Promise.all([shxPromise, cpgPromise, prjPromise]);
-    let shx;
-    let cpg;
-    let prj;
-    const shxResponse = await shxPromise;
-    if (shxResponse.ok) {
-        const arrayBuffer = await shxResponse.arrayBuffer();
-        shx = (0, parse_shx_1.parseShx)(arrayBuffer);
-    }
-    const cpgResponse = await cpgPromise;
-    if (cpgResponse.ok) {
-        cpg = await cpgResponse.text();
-    }
-    const prjResponse = await prjPromise;
-    if (prjResponse.ok) {
-        prj = await prjResponse.text();
-    }
-    return {
-        shx,
-        cpg,
-        prj
-    };
-}
-exports.loadShapefileSidecarFiles = loadShapefileSidecarFiles;
-/**
- * Replace the extension at the end of a path.
- *
- * Matches the case of new extension with the case of the original file extension,
- * to increase the chance of finding files without firing off a request storm looking for various case combinations
- *
- * NOTE: Extensions can be both lower and uppercase
- * per spec, extensions should be lower case, but that doesn't mean they always are. See:
- * calvinmetcalf/shapefile-js#64, mapserver/mapserver#4712
- * https://trac.osgeo.org/mapserver/ticket/166
- */
-function replaceExtension(url, newExtension) {
-    const baseName = basename(url);
-    const extension = extname(url);
-    const isUpperCase = extension === extension.toUpperCase();
-    if (isUpperCase) {
-        newExtension = newExtension.toUpperCase();
-    }
-    return `${baseName}.${newExtension}`;
-}
-exports.replaceExtension = replaceExtension;
-// NOTE - this gives the entire path minus extension (i.e. NOT same as path.basename)
-/**
- * @param url
- * @returns string
- */
-function basename(url) {
-    const extIndex = url && url.lastIndexOf('.');
-    if (typeof extIndex === 'number') {
-        return extIndex >= 0 ? url.substr(0, extIndex) : '';
-    }
-    return extIndex;
-}
-/**
- * @param url
- * @returns string
- */
-function extname(url) {
-    const extIndex = url && url.lastIndexOf('.');
-    if (typeof extIndex === 'number') {
-        return extIndex >= 0 ? url.substr(extIndex + 1) : '';
-    }
-    return extIndex;
-}

package/dist/lib/parsers/parse-shp-geometry.js

@@ -1,287 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRecord = void 0;
-const LITTLE_ENDIAN = true;
-/**
- * Parse individual record
- *
- * @param view Record data
- * @return Binary Geometry Object
- */
-// eslint-disable-next-line complexity
-function parseRecord(view, options) {
-    const { _maxDimensions = 4 } = options?.shp || {};
-    let offset = 0;
-    const type = view.getInt32(offset, LITTLE_ENDIAN);
-    offset += Int32Array.BYTES_PER_ELEMENT;
-    switch (type) {
-        case 0:
-            // Null Shape
-            return parseNull();
-        case 1:
-            // Point
-            return parsePoint(view, offset, Math.min(2, _maxDimensions));
-        case 3:
-            // PolyLine
-            return parsePoly(view, offset, Math.min(2, _maxDimensions), 'LineString');
-        case 5:
-            // Polygon
-            return parsePoly(view, offset, Math.min(2, _maxDimensions), 'Polygon');
-        case 8:
-            // MultiPoint
-            return parseMultiPoint(view, offset, Math.min(2, _maxDimensions));
-        // GeometryZ can have 3 or 4 dimensions, since the M is not required to
-        // exist
-        case 11:
-            // PointZ
-            return parsePoint(view, offset, Math.min(4, _maxDimensions));
-        case 13:
-            // PolyLineZ
-            return parsePoly(view, offset, Math.min(4, _maxDimensions), 'LineString');
-        case 15:
-            // PolygonZ
-            return parsePoly(view, offset, Math.min(4, _maxDimensions), 'Polygon');
-        case 18:
-            // MultiPointZ
-            return parseMultiPoint(view, offset, Math.min(4, _maxDimensions));
-        case 21:
-            // PointM
-            return parsePoint(view, offset, Math.min(3, _maxDimensions));
-        case 23:
-            // PolyLineM
-            return parsePoly(view, offset, Math.min(3, _maxDimensions), 'LineString');
-        case 25:
-            // PolygonM
-            return parsePoly(view, offset, Math.min(3, _maxDimensions), 'Polygon');
-        case 28:
-            // MultiPointM
-            return parseMultiPoint(view, offset, Math.min(3, _maxDimensions));
-        default:
-            throw new Error(`unsupported shape type: ${type}`);
-    }
-}
-exports.parseRecord = parseRecord;
-// TODO handle null
-/**
- * Parse Null geometry
- *
- * @return null
- */
-function parseNull() {
-    return null;
-}
-/**
- * Parse point geometry
- *
- * @param view Geometry data
- * @param offset Offset in view
- * @param dim Dimension size
- */
-function parsePoint(view, offset, dim) {
-    let positions;
-    [positions, offset] = parsePositions(view, offset, 1, dim);
-    return {
-        positions: { value: positions, size: dim },
-        type: 'Point'
-    };
-}
-/**
- * Parse MultiPoint geometry
- *
- * @param view Geometry data
- * @param offset Offset in view
- * @param dim Input dimension
- * @return Binary geometry object
- */
-function parseMultiPoint(view, offset, dim) {
-    // skip parsing box
-    offset += 4 * Float64Array.BYTES_PER_ELEMENT;
-    const nPoints = view.getInt32(offset, LITTLE_ENDIAN);
-    offset += Int32Array.BYTES_PER_ELEMENT;
-    let xyPositions = null;
-    let mPositions = null;
-    let zPositions = null;
-    [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);
-    // Parse Z coordinates
-    if (dim === 4) {
-        // skip parsing range
-        offset += 2 * Float64Array.BYTES_PER_ELEMENT;
-        [zPositions, offset] = parsePositions(view, offset, nPoints, 1);
-    }
-    // Parse M coordinates
-    if (dim >= 3) {
-        // skip parsing range
-        offset += 2 * Float64Array.BYTES_PER_ELEMENT;
-        [mPositions, offset] = parsePositions(view, offset, nPoints, 1);
-    }
-    const positions = concatPositions(xyPositions, mPositions, zPositions);
-    return {
-        positions: { value: positions, size: dim },
-        type: 'Point'
-    };
-}
-/**
- * Polygon and PolyLine parsing
- *
- * @param view Geometry data
- * @param offset Offset in view
- * @param dim Input dimension
- * @param type Either 'Polygon' or 'Polyline'
- * @return Binary geometry object
- */
-// eslint-disable-next-line max-statements
-function parsePoly(view, offset, dim, type) {
-    // skip parsing bounding box
-    offset += 4 * Float64Array.BYTES_PER_ELEMENT;
-    const nParts = view.getInt32(offset, LITTLE_ENDIAN);
-    offset += Int32Array.BYTES_PER_ELEMENT;
-    const nPoints = view.getInt32(offset, LITTLE_ENDIAN);
-    offset += Int32Array.BYTES_PER_ELEMENT;
-    // Create longer indices array by 1 because output format is expected to
-    // include the last index as the total number of positions
-    const bufferOffset = view.byteOffset + offset;
-    const bufferLength = nParts * Int32Array.BYTES_PER_ELEMENT;
-    const ringIndices = new Int32Array(nParts + 1);
-    ringIndices.set(new Int32Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)));
-    ringIndices[nParts] = nPoints;
-    offset += nParts * Int32Array.BYTES_PER_ELEMENT;
-    let xyPositions = null;
-    let mPositions = null;
-    let zPositions = null;
-    [xyPositions, offset] = parsePositions(view, offset, nPoints, 2);
-    // Parse Z coordinates
-    if (dim === 4) {
-        // skip parsing range
-        offset += 2 * Float64Array.BYTES_PER_ELEMENT;
-        [zPositions, offset] = parsePositions(view, offset, nPoints, 1);
-    }
-    // Parse M coordinates
-    if (dim >= 3) {
-        // skip parsing range
-        offset += 2 * Float64Array.BYTES_PER_ELEMENT;
-        [mPositions, offset] = parsePositions(view, offset, nPoints, 1);
-    }
-    const positions = concatPositions(xyPositions, mPositions, zPositions);
-    // parsePoly only accepts type = LineString or Polygon
-    if (type === 'LineString') {
-        return {
-            type,
-            positions: { value: positions, size: dim },
-            pathIndices: { value: ringIndices, size: 1 }
-        };
-    }
-    // for every ring, determine sign of polygon
-    // Use only 2D positions for ring calc
-    const polygonIndices = [];
-    for (let i = 1; i < ringIndices.length; i++) {
-        const startRingIndex = ringIndices[i - 1];
-        const endRingIndex = ringIndices[i];
-        // @ts-ignore
-        const ring = xyPositions.subarray(startRingIndex * 2, endRingIndex * 2);
-        const sign = getWindingDirection(ring);
-        // A positive sign implies clockwise
-        // A clockwise ring is a filled ring
-        if (sign > 0) {
-            polygonIndices.push(startRingIndex);
-        }
-    }
-    polygonIndices.push(nPoints);
-    return {
-        type,
-        positions: { value: positions, size: dim },
-        primitivePolygonIndices: { value: ringIndices, size: 1 },
-        // TODO: Dynamically choose Uint32Array over Uint16Array only when
-        // necessary. I believe the implementation requires nPoints to be the
-        // largest value in the array, so you should be able to use Uint32Array only
-        // when nPoints > 65535.
-        polygonIndices: { value: new Uint32Array(polygonIndices), size: 1 }
-    };
-}
-/**
- * Parse a contiguous block of positions into a Float64Array
- *
- * @param view  Geometry data
- * @param offset  Offset in view
- * @param nPoints Number of points
- * @param dim     Input dimension
- * @return Data and offset
- */
-function parsePositions(view, offset, nPoints, dim) {
-    const bufferOffset = view.byteOffset + offset;
-    const bufferLength = nPoints * dim * Float64Array.BYTES_PER_ELEMENT;
-    return [
-        new Float64Array(view.buffer.slice(bufferOffset, bufferOffset + bufferLength)),
-        offset + bufferLength
-    ];
-}
-/**
- * Concatenate and interleave positions arrays
- * xy positions are interleaved; mPositions, zPositions are their own arrays
- *
- * @param xyPositions 2d positions
- * @param mPositions  M positions
- * @param zPositions  Z positions
- * @return Combined interleaved positions
- */
-// eslint-disable-next-line complexity
-function concatPositions(xyPositions, mPositions, zPositions) {
-    if (!(mPositions || zPositions)) {
-        return xyPositions;
-    }
-    let arrayLength = xyPositions.length;
-    let nDim = 2;
-    if (zPositions && zPositions.length) {
-        arrayLength += zPositions.length;
-        nDim++;
-    }
-    if (mPositions && mPositions.length) {
-        arrayLength += mPositions.length;
-        nDim++;
-    }
-    const positions = new Float64Array(arrayLength);
-    for (let i = 0; i < xyPositions.length / 2; i++) {
-        positions[nDim * i] = xyPositions[i * 2];
-        positions[nDim * i + 1] = xyPositions[i * 2 + 1];
-    }
-    if (zPositions && zPositions.length) {
-        for (let i = 0; i < zPositions.length; i++) {
-            // If Z coordinates exist; used as third coord in positions array
-            positions[nDim * i + 2] = zPositions[i];
-        }
-    }
-    if (mPositions && mPositions.length) {
-        for (let i = 0; i < mPositions.length; i++) {
-            // M is always last, either 3rd or 4th depending on if Z exists
-            positions[nDim * i + (nDim - 1)] = mPositions[i];
-        }
-    }
-    return positions;
-}
-/**
- * Returns the direction of the polygon path
- * A positive number is clockwise.
- * A negative number is counter clockwise.
- *
- * @param positions
- * @return Sign of polygon ring
- */
-function getWindingDirection(positions) {
-    return Math.sign(getSignedArea(positions));
-}
-/**
- * Get signed area of flat typed array of 2d positions
- *
- * @param positions
- * @return Signed area of polygon ring
- */
-function getSignedArea(positions) {
-    let area = 0;
-    // Rings are closed according to shapefile spec
-    const nCoords = positions.length / 2 - 1;
-    for (let i = 0; i < nCoords; i++) {
-        area +=
-            (positions[i * 2] + positions[(i + 1) * 2]) *
-                (positions[i * 2 + 1] - positions[(i + 1) * 2 + 1]);
-    }
-    return area / 2;
-}

package/dist/lib/parsers/parse-shp-header.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSHPHeader = void 0;
-const LITTLE_ENDIAN = true;
-const BIG_ENDIAN = false;
-const SHP_MAGIC_NUMBER = 0x0000270a;
-/**
- * Extract the binary header
- * Note: Also used by SHX
- * @param headerView
- * @returns SHPHeader
- */
-function parseSHPHeader(headerView) {
-    // Note: The SHP format switches endianness between fields!
-    // https://www.esri.com/library/whitepapers/pdfs/shapefile.pdf
-    const header = {
-        magic: headerView.getInt32(0, BIG_ENDIAN),
-        // Length is stored as # of 2-byte words; multiply by 2 to get # of bytes
-        length: headerView.getInt32(24, BIG_ENDIAN) * 2,
-        version: headerView.getInt32(28, LITTLE_ENDIAN),
-        type: headerView.getInt32(32, LITTLE_ENDIAN),
-        bbox: {
-            minX: headerView.getFloat64(36, LITTLE_ENDIAN),
-            minY: headerView.getFloat64(44, LITTLE_ENDIAN),
-            minZ: headerView.getFloat64(68, LITTLE_ENDIAN),
-            minM: headerView.getFloat64(84, LITTLE_ENDIAN),
-            maxX: headerView.getFloat64(52, LITTLE_ENDIAN),
-            maxY: headerView.getFloat64(60, LITTLE_ENDIAN),
-            maxZ: headerView.getFloat64(76, LITTLE_ENDIAN),
-            maxM: headerView.getFloat64(92, LITTLE_ENDIAN)
-        }
-    };
-    if (header.magic !== SHP_MAGIC_NUMBER) {
-        // eslint-disable-next-line
-        console.error(`SHP file: bad magic number ${header.magic}`);
-    }
-    if (header.version !== 1000) {
-        // eslint-disable-next-line
-        console.error(`SHP file: bad version ${header.version}`);
-    }
-    return header;
-}
-exports.parseSHPHeader = parseSHPHeader;