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

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
+import { parseFlatGeobuf, parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
+export { FlatGeobufWorkerLoader };
+export declare const FlatGeobufLoader: {
+    parse: (arrayBuffer: any, options: any) => Promise<any[] | import("@loaders.gl/schema").GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
+        shape: string;
+        data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
+    }>;
+    parseSync: typeof parseFlatGeobuf;
+    parseInBatchesFromStream: typeof parseFlatGeobufInBatches;
+    binary: boolean;
+    id: string;
+    name: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    extensions: string[];
+    mimeTypes: string[];
+    category: string;
+    options: {
+        flatgeobuf: {
+            shape: string;
+        };
+    };
+};
+export declare const _typecheckFlatGeobufLoader: LoaderWithParser;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAC,gBAAgB,IAAI,sBAAsB,EAAC,MAAM,qBAAqB,CAAC;AAC/E,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,MAAM,wBAAwB,CAAC;AAEjF,OAAO,EAAC,sBAAsB,EAAC,CAAC;AAEhC,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;CAM5B,CAAC;AAEF,eAAO,MAAM,0BAA0B,EAAE,gBAAmC,CAAC"}

package/dist/index.js

@@ -1,11 +1,14 @@
-import { FlatGeobufLoader as FlatGeobufWorkerLoader } from './flatgeobuf-loader';
-import parseFlatGeobuf, { parseFlatGeobufInBatches } from './lib/parse-flatgeobuf';
-export { FlatGeobufWorkerLoader };
-export const FlatGeobufLoader = { ...FlatGeobufWorkerLoader,
-  parse: async (arrayBuffer, options) => parseFlatGeobuf(arrayBuffer, options),
-  parseSync: parseFlatGeobuf,
-  parseInBatchesFromStream: parseFlatGeobufInBatches,
-  binary: true
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader = exports.FlatGeobufWorkerLoader = void 0;
+const flatgeobuf_loader_1 = require("./flatgeobuf-loader");
+Object.defineProperty(exports, "FlatGeobufWorkerLoader", { enumerable: true, get: function () { return flatgeobuf_loader_1.FlatGeobufLoader; } });
+const parse_flatgeobuf_1 = require("./lib/parse-flatgeobuf");
+exports.FlatGeobufLoader = {
+    ...flatgeobuf_loader_1.FlatGeobufLoader,
+    parse: async (arrayBuffer, options) => (0, parse_flatgeobuf_1.parseFlatGeobuf)(arrayBuffer, options),
+    parseSync: parse_flatgeobuf_1.parseFlatGeobuf,
+    parseInBatchesFromStream: parse_flatgeobuf_1.parseFlatGeobufInBatches,
+    binary: true
 };
-export const _typecheckFlatGeobufLoader = FlatGeobufLoader;
-//# sourceMappingURL=index.js.map
+exports._typecheckFlatGeobufLoader = exports.FlatGeobufLoader;

package/dist/lib/binary-geometries.d.ts

@@ -0,0 +1,20 @@
+export declare function fromGeometry(geometry: any, type: any): {
+    positions: {
+        value: any;
+        size: number;
+    };
+} | {
+    positions: {
+        value: Float64Array;
+        size: any;
+    };
+    primitivePolygonIndices: {
+        value: Uint32Array;
+        size: number;
+    };
+    polygonIndices: {
+        value: Uint32Array;
+        size: number;
+    };
+};
+//# sourceMappingURL=binary-geometries.d.ts.map

package/dist/lib/binary-geometries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-geometries.d.ts","sourceRoot":"","sources":["../../src/lib/binary-geometries.ts"],"names":[],"mappings":"AAgIA,wBAAgB,YAAY,CAAC,QAAQ,KAAA,EAAE,IAAI,KAAA;;;;;;;;;;;;;;;;;;EAe1C"}

package/dist/lib/binary-geometries.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromGeometry = void 0;
+const header_generated_1 = require("flatgeobuf/lib/cjs/header_generated");
+// Parse Point to flat array
+function parsePoint(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    return { positions };
+}
+function parseLines(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    // If endsArray is null, a single LineString. Otherwise, contains the end
+    // indices of each part of the MultiLineString. geometry.endsArray() omits the
+    // initial 0 that we have in our internal format.
+    const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+    ends.unshift(0);
+    const pathIndices = { value: new Uint16Array(ends), size: 1 };
+    return {
+        positions,
+        pathIndices
+    };
+}
+function parsePolygons(geometry) {
+    const xy = geometry.xyArray();
+    const z = geometry.zArray();
+    const positions = blitArrays(xy, z);
+    // If endsArray is null, a simple Polygon with no inner rings. Otherwise,
+    // contains the end indices of each ring of the Polygon. geometry.endsArray()
+    // omits the initial 0 that we have in our internal format.
+    const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+    ends.unshift(0);
+    const primitivePolygonIndices = { value: new Uint16Array(ends), size: 1 };
+    const polygonIndices = { value: new Uint16Array([0, xy.length / 2]), size: 1 };
+    return {
+        positions,
+        primitivePolygonIndices,
+        polygonIndices
+    };
+}
+// eslint-disable-next-line max-statements
+function parseMultiPolygons(geometry) {
+    // Create arrays for each geometry part, then concatenate
+    const parsedParts = [];
+    let nPositions = 0;
+    let nPrimitivePolygonIndices = 1;
+    let nPolygonIndices = 1;
+    for (let i = 0; i < geometry.partsLength(); i++) {
+        const part = geometry.parts(i);
+        const polygon = parsePolygons(part);
+        nPositions += polygon.positions.value.length;
+        nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+        nPolygonIndices += polygon.polygonIndices.value.length - 1;
+        parsedParts.push(polygon);
+    }
+    const concatPositions = new Float64Array(nPositions);
+    const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+    const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+    let positionCounter = 0;
+    let primitivePolygonIndicesCounter = 1;
+    let polygonIndicesCounter = 1;
+    // Assumes all parts of the multipolygon have the same size
+    const positionSize = parsedParts[0].positions.size;
+    for (const parsedPart of parsedParts) {
+        concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+        // For indices, need to add positionCounter so that position indices are
+        // correct in the concatenated positions
+        concatPrimitivePolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter), primitivePolygonIndicesCounter);
+        concatPolygonIndices.set(
+        // eslint-disable-next-line
+        parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter), polygonIndicesCounter);
+        positionCounter += parsedPart.positions.value.length / positionSize;
+        primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+        polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+    }
+    return {
+        positions: { value: concatPositions, size: positionSize },
+        primitivePolygonIndices: { value: concatPrimitivePolygonIndices, size: 1 },
+        polygonIndices: { value: concatPolygonIndices, size: 1 }
+    };
+}
+// Combine xy and z arrays
+function blitArrays(xy, z) {
+    if (!z) {
+        return { value: xy, size: 2 };
+    }
+    if (z.length * 2 !== xy.length) {
+        throw new Error('Z array must be half XY array\'s length');
+    }
+    const totalLength = xy.length + z.length;
+    const xyz = new Float64Array(totalLength);
+    for (let i = 0; i < xy.length / 2; i++) {
+        xyz[i * 3 + 0] = xy[i * 2 + 0];
+        xyz[i * 3 + 1] = xy[i * 2 + 1];
+        xyz[i * 3 + 2] = z[i];
+    }
+    return { value: xyz, size: 3 };
+}
+function fromGeometry(geometry, type) {
+    switch (type) {
+        case header_generated_1.GeometryType.Point:
+        case header_generated_1.GeometryType.MultiPoint:
+            return parsePoint(geometry);
+        case header_generated_1.GeometryType.LineString:
+        case header_generated_1.GeometryType.MultiLineString:
+            return parseLines(geometry);
+        case header_generated_1.GeometryType.Polygon:
+            return parsePolygons(geometry);
+        case header_generated_1.GeometryType.MultiPolygon:
+            return parseMultiPolygons(geometry);
+        default:
+            throw new Error(`Unimplemented geometry type: ${type}`);
+    }
+}
+exports.fromGeometry = fromGeometry;

package/dist/lib/parse-flatgeobuf.d.ts

@@ -0,0 +1,8 @@
+import { FlatGeobufLoaderOptions } from './types';
+import { GeoJSONRowTable } from '@loaders.gl/schema';
+export declare function parseFlatGeobuf(arrayBuffer: ArrayBuffer, options?: FlatGeobufLoaderOptions): any[] | GeoJSONRowTable | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | {
+    shape: string;
+    data: any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown>;
+};
+export declare function parseFlatGeobufInBatches(stream: any, options: FlatGeobufLoaderOptions): any[] | AsyncGenerator<import("flatgeobuf/lib/cjs/generic/feature").IFeature, any, unknown> | AsyncGenerator<any, void, unknown>;
+//# sourceMappingURL=parse-flatgeobuf.d.ts.map

package/dist/lib/parse-flatgeobuf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-flatgeobuf.d.ts","sourceRoot":"","sources":["../../src/lib/parse-flatgeobuf.ts"],"names":[],"mappings":"AASA,OAAO,EAAC,uBAAuB,EAAC,MAAM,SAAS,CAAC;AAChD,OAAO,EAAC,eAAe,EAAU,MAAM,oBAAoB,CAAC;AAwB5D,wBAAgB,eAAe,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,uBAAuB;;;EAoB1F;AAoDD,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,EAAE,OAAO,EAAE,uBAAuB,oIAMhF"}

package/dist/lib/parse-flatgeobuf.js

@@ -1,17 +1,128 @@
-import { deserialize, deserializeStream } from 'flatgeobuf/dist/flatgeobuf-geojson.min';
-export default function parseFlatGeobuf(input, options) {
-  if (input.byteLength === 0) {
-    return [];
-  }
-
-  const arr = new Uint8Array(input);
-  const {
-    features
-  } = deserialize(arr);
-  return features;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFlatGeobufInBatches = exports.parseFlatGeobuf = void 0;
+// @ts-nocheck
+const proj4_1 = require("@math.gl/proj4");
+const gis_1 = require("@loaders.gl/gis");
+const geojson_1 = require("flatgeobuf/lib/cjs/geojson");
+const generic_1 = require("flatgeobuf/lib/cjs/generic");
+const feature_1 = require("flatgeobuf/lib/cjs/generic/feature");
+const binary_geometries_1 = require("./binary-geometries");
+// TODO: reproject binary features
+function binaryFromFeature(feature, header) {
+    const geometry = feature.geometry();
+    // FlatGeobuf files can only hold a single geometry type per file, otherwise
+    // GeometryType is GeometryCollection
+    // I believe geometry.type() is null (0) except when the geometry type isn't
+    // known in the header?
+    const geometryType = header.geometryType || geometry.type();
+    const parsedGeometry = (0, binary_geometries_1.fromGeometry)(geometry, geometryType);
+    parsedGeometry.properties = (0, feature_1.parseProperties)(feature, header.columns);
+    // TODO: wrap binary data either in points, lines, or polygons key
+    return parsedGeometry;
 }
-export function parseFlatGeobufInBatches(stream, options) {
-  const iterator = deserializeStream(stream);
-  return iterator;
+/*
+ * Parse FlatGeobuf arrayBuffer and return GeoJSON.
+ *
+ * @param arrayBuffer  A FlatGeobuf arrayBuffer
+ * @return A GeoJSON geometry object
+ */
+function parseFlatGeobuf(arrayBuffer, options) {
+    const shape = options?.gis?.format || options?.flatgeobuf?.shape;
+    switch (shape) {
+        case 'geojson-row-table': {
+            const table = {
+                shape: 'geojson-row-table',
+                data: parseFlatGeobufToGeoJSON(arrayBuffer, options)
+            };
+            return table;
+        }
+        case 'columnar-table': // binary + some JS arrays
+            return { shape: 'columnar-table', data: parseFlatGeobufToBinary(arrayBuffer, options) };
+        case 'geojson':
+            return parseFlatGeobufToGeoJSON(arrayBuffer, options);
+        case 'binary':
+            return parseFlatGeobufToBinary(arrayBuffer, options);
+        default:
+            throw new Error(shape);
+    }
+}
+exports.parseFlatGeobuf = parseFlatGeobuf;
+function parseFlatGeobufToBinary(arrayBuffer, options) {
+    // TODO: reproject binary features
+    // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+    const array = new Uint8Array(arrayBuffer);
+    return (0, generic_1.deserialize)(array, binaryFromFeature);
+}
+function parseFlatGeobufToGeoJSON(arrayBuffer, options) {
+    if (arrayBuffer.byteLength === 0) {
+        return [];
+    }
+    const { reproject = false, _targetCrs = 'WGS84' } = (options && options.gis) || {};
+    const arr = new Uint8Array(arrayBuffer);
+    let headerMeta;
+    const { features } = (0, geojson_1.deserialize)(arr, false, (header) => {
+        headerMeta = header;
+    });
+    const crs = headerMeta && headerMeta.crs;
+    let projection;
+    if (reproject && crs) {
+        // Constructing the projection may fail for some invalid WKT strings
+        try {
+            projection = new proj4_1.Proj4Projection({ from: crs.wkt, to: _targetCrs });
+        }
+        catch (e) {
+            // no op
+        }
+    }
+    if (projection) {
+        return (0, gis_1.transformGeoJsonCoords)(features, (coords) => projection.project(coords));
+    }
+    return features;
+}
+/*
+ * Parse FlatGeobuf arrayBuffer and return GeoJSON.
+ *
+ * @param {ReadableStream} _ A FlatGeobuf arrayBuffer
+ * @return  A GeoJSON geometry object iterator
+ */
+// eslint-disable-next-line complexity
+function parseFlatGeobufInBatches(stream, options) {
+    if (options && options.gis && options.gis.format === 'binary') {
+        return parseFlatGeobufInBatchesToBinary(stream, options);
+    }
+    return parseFlatGeobufInBatchesToGeoJSON(stream, options);
+}
+exports.parseFlatGeobufInBatches = parseFlatGeobufInBatches;
+function parseFlatGeobufInBatchesToBinary(stream, options) {
+    // TODO: reproject binary streaming features
+    // const {reproject = false, _targetCrs = 'WGS84'} = (options && options.gis) || {};
+    const iterator = (0, generic_1.deserialize)(stream, binaryFromFeature);
+    return iterator;
+}
+// eslint-disable-next-line complexity
+async function* parseFlatGeobufInBatchesToGeoJSON(stream, options) {
+    const { reproject = false, _targetCrs = 'WGS84' } = (options && options.gis) || {};
+    let headerMeta;
+    const iterator = (0, geojson_1.deserialize)(stream, false, (header) => {
+        headerMeta = header;
+    });
+    let projection;
+    let firstRecord = true;
+    for await (const feature of iterator) {
+        if (firstRecord) {
+            const crs = headerMeta && headerMeta.crs;
+            if (reproject && crs) {
+                projection = new proj4_1.Proj4Projection({ from: crs.wkt, to: _targetCrs });
+            }
+            firstRecord = false;
+        }
+        if (reproject && projection) {
+            // eslint-disable-next-line
+            yield (0, gis_1.transformGeoJsonCoords)([feature], (coords) => projection.project(coords));
+        }
+        else {
+            yield feature;
+        }
+    }
 }
-//# sourceMappingURL=parse-flatgeobuf.js.map

package/dist/lib/types.d.ts

@@ -0,0 +1,13 @@
+import type { LoaderOptions } from '@loaders.gl/loader-utils';
+export type FlatGeobufLoaderOptions = LoaderOptions & {
+    flatgeobuf?: {
+        shape?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';
+    };
+    gis?: {
+        reproject?: boolean;
+        _targetCrs?: string;
+        /** @deprecated Use options.flatgeobuf.shape */
+        format?: 'geojson-row-table' | 'columnar-table' | 'geojson' | 'binary';
+    };
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAE5D,MAAM,MAAM,uBAAuB,GAAG,aAAa,GAAG;IACpD,UAAU,CAAC,EAAE;QACX,KAAK,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,CAAC;KACvE,CAAC;IACF,GAAG,CAAC,EAAE;QACJ,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,+CAA+C;QAC/C,MAAM,CAAC,EAAE,mBAAmB,GAAG,gBAAgB,GAAG,SAAS,GAAG,QAAQ,CAAC;KACxE,CAAC;CACH,CAAC"}

package/dist/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/workers/flatgeobuf-worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=flatgeobuf-worker.d.ts.map

package/dist/workers/flatgeobuf-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatgeobuf-worker.d.ts","sourceRoot":"","sources":["../../src/workers/flatgeobuf-worker.ts"],"names":[],"mappings":""}

package/dist/workers/flatgeobuf-worker.js

@@ -1,4 +1,5 @@
-import { createLoaderWorker } from '@loaders.gl/loader-utils';
-import { FlatGeobufLoader } from '../index';
-createLoaderWorker(FlatGeobufLoader);
-//# sourceMappingURL=flatgeobuf-worker.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const index_1 = require("../index");
+(0, loader_utils_1.createLoaderWorker)(index_1.FlatGeobufLoader);

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@loaders.gl/flatgeobuf",
   "description": "Loader for FlatGeobuf",
-  "version": "4.0.0-alpha.4",
+  "version": "4.0.0-alpha.6",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/uber-web/loaders.gl"
+    "url": "https://github.com/visgl/loaders.gl"
   },
   "keywords": [
     "geometry",
@@ -17,9 +17,9 @@
     "MVT",
     "Mapbox Vector Tiles"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -28,15 +28,14 @@
   ],
   "scripts": {
     "pre-build": "npm run build-worker && npm run build-worker --env.dev && npm run build-bundle",
-    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/bundle.js",
-    "build-worker": "esbuild src/workers/flatgeobuf-worker.ts --bundle --outfile=dist/flatgeobuf-worker.js"
+    "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js",
+    "build-worker": "esbuild src/workers/flatgeobuf-worker.ts --bundle --outfile=dist/flatgeobuf-worker.js --define:__VERSION__=\\\"$npm_package_version\\\""
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.4",
-    "flatgeobuf": "~3.1.0"
+    "@loaders.gl/gis": "4.0.0-alpha.6",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
+    "@math.gl/proj4": "^3.3.1",
+    "flatgeobuf": "3.6.5"
   },
-  "devDependencies": {
-    "esm": "^3.2.25"
-  },
-  "gitHead": "53026061b3c8871f7e96d3a5826125cc6613bddc"
+  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
 }

package/src/flatgeobuf-loader.ts

@@ -14,7 +14,10 @@ export const FlatGeobufLoader = {
   mimeTypes: ['application/octet-stream'],
   category: 'geometry',
   options: {
-    flatgeobuf: {}
+    flatgeobuf: {
+      // Set to GeoJSON for backwards compatibility
+      shape: 'geojson'
+    }
   }
 };
 

package/src/index.ts

@@ -1,6 +1,6 @@
 import type {LoaderWithParser} from '@loaders.gl/loader-utils';
 import {FlatGeobufLoader as FlatGeobufWorkerLoader} from './flatgeobuf-loader';
-import parseFlatGeobuf, {parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
+import {parseFlatGeobuf, parseFlatGeobufInBatches} from './lib/parse-flatgeobuf';
 
 export {FlatGeobufWorkerLoader};
 

package/src/lib/binary-geometries.ts

@@ -0,0 +1,144 @@
+import {GeometryType} from 'flatgeobuf/lib/cjs/header_generated';
+
+// Parse Point to flat array
+function parsePoint(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+  return {positions};
+}
+
+function parseLines(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+
+  // If endsArray is null, a single LineString. Otherwise, contains the end
+  // indices of each part of the MultiLineString. geometry.endsArray() omits the
+  // initial 0 that we have in our internal format.
+  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+  ends.unshift(0);
+
+  const pathIndices = {value: new Uint16Array(ends), size: 1};
+
+  return {
+    positions,
+    pathIndices
+  };
+}
+
+function parsePolygons(geometry) {
+  const xy = geometry.xyArray();
+  const z = geometry.zArray();
+  const positions = blitArrays(xy, z);
+
+  // If endsArray is null, a simple Polygon with no inner rings. Otherwise,
+  // contains the end indices of each ring of the Polygon. geometry.endsArray()
+  // omits the initial 0 that we have in our internal format.
+  const ends = (geometry.endsArray() && Array.from(geometry.endsArray())) || [xy.length / 2];
+  ends.unshift(0);
+
+  const primitivePolygonIndices = {value: new Uint16Array(ends), size: 1};
+  const polygonIndices = {value: new Uint16Array([0, xy.length / 2]), size: 1};
+
+  return {
+    positions,
+    primitivePolygonIndices,
+    polygonIndices
+  };
+}
+
+// eslint-disable-next-line max-statements
+function parseMultiPolygons(geometry) {
+  // Create arrays for each geometry part, then concatenate
+  const parsedParts: any[] = [];
+  let nPositions = 0;
+  let nPrimitivePolygonIndices = 1;
+  let nPolygonIndices = 1;
+
+  for (let i = 0; i < geometry.partsLength(); i++) {
+    const part = geometry.parts(i);
+    const polygon = parsePolygons(part);
+
+    nPositions += polygon.positions.value.length;
+    nPrimitivePolygonIndices += polygon.primitivePolygonIndices.value.length - 1;
+    nPolygonIndices += polygon.polygonIndices.value.length - 1;
+
+    parsedParts.push(polygon);
+  }
+
+  const concatPositions = new Float64Array(nPositions);
+  const concatPrimitivePolygonIndices = new Uint32Array(nPrimitivePolygonIndices);
+  const concatPolygonIndices = new Uint32Array(nPolygonIndices);
+
+  let positionCounter = 0;
+  let primitivePolygonIndicesCounter = 1;
+  let polygonIndicesCounter = 1;
+
+  // Assumes all parts of the multipolygon have the same size
+  const positionSize = parsedParts[0].positions.size;
+
+  for (const parsedPart of parsedParts) {
+    concatPositions.set(parsedPart.positions.value, positionCounter * positionSize);
+
+    // For indices, need to add positionCounter so that position indices are
+    // correct in the concatenated positions
+    concatPrimitivePolygonIndices.set(
+      // eslint-disable-next-line
+      parsedPart.primitivePolygonIndices.value.subarray(1).map((x) => x + positionCounter),
+      primitivePolygonIndicesCounter
+    );
+    concatPolygonIndices.set(
+      // eslint-disable-next-line
+      parsedPart.polygonIndices.value.subarray(1).map((x) => x + positionCounter),
+      polygonIndicesCounter
+    );
+
+    positionCounter += parsedPart.positions.value.length / positionSize;
+    primitivePolygonIndicesCounter += parsedPart.primitivePolygonIndices.value.length - 1;
+    polygonIndicesCounter += parsedPart.polygonIndices.value.length - 1;
+  }
+
+  return {
+    positions: {value: concatPositions, size: positionSize},
+    primitivePolygonIndices: {value: concatPrimitivePolygonIndices, size: 1},
+    polygonIndices: {value: concatPolygonIndices, size: 1}
+  };
+}
+
+// Combine xy and z arrays
+function blitArrays(xy, z) {
+  if (!z) {
+    return {value: xy, size: 2};
+  }
+
+  if (z.length * 2 !== xy.length) {
+    throw new Error('Z array must be half XY array\'s length');
+  }
+  const totalLength = xy.length + z.length;
+
+  const xyz = new Float64Array(totalLength);
+  for (let i = 0; i < xy.length / 2; i++) {
+    xyz[i * 3 + 0] = xy[i * 2 + 0];
+    xyz[i * 3 + 1] = xy[i * 2 + 1];
+    xyz[i * 3 + 2] = z[i];
+  }
+  return {value: xyz, size: 3};
+}
+
+export function fromGeometry(geometry, type) {
+  switch (type) {
+    case GeometryType.Point:
+    case GeometryType.MultiPoint:
+      return parsePoint(geometry);
+    case GeometryType.LineString:
+    case GeometryType.MultiLineString:
+      return parseLines(geometry);
+    case GeometryType.Polygon:
+      return parsePolygons(geometry);
+    case GeometryType.MultiPolygon:
+      return parseMultiPolygons(geometry);
+    default:
+      throw new Error(`Unimplemented geometry type: ${type}`);
+  }
+}