@maplibre/mlt 0.0.1-alpha.6

package/dist/vector/geometry/constGpuVector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constGpuVector.js","sourceRoot":"","sources":["../../../src/vector/geometry/constGpuVector.ts"],"names":[],"mappings":";;;AACA,uEAAkE;AAClE,2CAAsC;AAKtC,mEAAmE;AACnE,MAAa,cAAe,SAAQ,qBAAS;IACzC,YACqB,cAAsB,EACtB,aAAqB,EACtC,eAA2B,EAC3B,WAAuB,EACvB,YAAwB,EACxB,cAAsC;QAEtC,KAAK,CAAC,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;QAPjD,mBAAc,GAAd,cAAc,CAAQ;QACtB,kBAAa,GAAb,aAAa,CAAQ;IAO1C,CAAC;IAED,MAAM,CAAC,MAAM,CACT,aAAqB,EACrB,YAAoB,EACpB,eAA2B,EAC3B,WAAuB,EACvB,YAAwB,EACxB,cAAsC;QAEtC,OAAO,IAAI,cAAc,CACrB,aAAa,EACb,YAAY,EACZ,eAAe,EACf,WAAW,EACX,YAAY,EACZ,cAAc,CACjB,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IAEH,YAAY,CAAC,KAAa;QACtB,OAAO,IAAI,CAAC,aAAa,CAAC;IAC9B,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC;IAC/B,CAAC;IAED,mGAAmG;IACnG,iEAAiE;IACjE,MAAM,CAAC,YAAuC;QAC1C,IAAG,YAAY,KAAK,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,aAAa,EAAC,CAAC;YACjF,OAAO,IAAI,yCAAmB,CAAC,EAAE,CAAC,CAAC;QACvC,CAAC;QAED,gCAAgC;QAChC,MAAM,eAAe,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACtD,KAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,EAAC,CAAC;YACxC,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,IAAI,yCAAmB,CAAC,eAAe,CAAC,CAAC;IACpD,CAAC;IAED,cAAc,CAAC,YAAuC,EAAE,eAAgC;QACpF,IAAG,YAAY,KAAK,IAAI,CAAC,aAAa,IAAI,CAAC,YAAY,GAAG,CAAC,CAAC,KAAK,IAAI,CAAC,aAAa,EAAC,CAAC;YACjF,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QAChC,CAAC;IACL,CAAC;IAED,0BAA0B;QACtB,OAAO,IAAI,CAAC;IAChB,CAAC;CAEJ;AArFD,wCAqFC"}

package/dist/vector/geometry/flatGeometryVector.d.ts

@@ -0,0 +1,16 @@
+import { GeometryVector, MortonSettings, VertexBufferType } from "./geometryVector";
+import TopologyVector from "../../vector/geometry/topologyVector";
+import { SelectionVector } from "../filter/selectionVector";
+import { SINGLE_PART_GEOMETRY_TYPE } from "./geometryType";
+export declare class FlatGeometryVector extends GeometryVector {
+    private readonly _geometryTypes;
+    constructor(vertexBufferType: VertexBufferType, _geometryTypes: Int32Array, topologyVector: TopologyVector, vertexOffsets: Int32Array, vertexBuffer: Int32Array, mortonSettings?: MortonSettings);
+    static createMortonEncoded(geometryTypes: Int32Array, topologyVector: TopologyVector, vertexOffsets: Int32Array, vertexBuffer: Int32Array, mortonInfo: MortonSettings): FlatGeometryVector;
+    static create(geometryTypes: Int32Array, topologyVector: TopologyVector, vertexOffsets: Int32Array, vertexBuffer: Int32Array): FlatGeometryVector;
+    geometryType(index: number): number;
+    get numGeometries(): number;
+    containsPolygonGeometry(): boolean;
+    filter(geometryType: SINGLE_PART_GEOMETRY_TYPE): SelectionVector;
+    filterSelected(predicateGeometryType: SINGLE_PART_GEOMETRY_TYPE, selectionVector: SelectionVector): void;
+    containsSingleGeometryType(): boolean;
+}

package/dist/vector/geometry/flatGeometryVector.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlatGeometryVector = void 0;
+const geometryVector_1 = require("./geometryVector");
+const flatSelectionVector_1 = require("../filter/flatSelectionVector");
+const geometryType_1 = require("./geometryType");
+class FlatGeometryVector extends geometryVector_1.GeometryVector {
+    constructor(vertexBufferType, 
+    //TODO: refactor -> use UInt8Array
+    _geometryTypes, topologyVector, vertexOffsets, vertexBuffer, mortonSettings) {
+        super(vertexBufferType, topologyVector, vertexOffsets, vertexBuffer, mortonSettings);
+        this._geometryTypes = _geometryTypes;
+    }
+    static createMortonEncoded(geometryTypes, topologyVector, vertexOffsets, vertexBuffer, mortonInfo) {
+        //TODO: refactor to use unsigned integers
+        return new FlatGeometryVector(geometryVector_1.VertexBufferType.MORTON, geometryTypes, topologyVector, vertexOffsets, vertexBuffer, mortonInfo);
+    }
+    static create(geometryTypes, topologyVector, vertexOffsets, vertexBuffer) {
+        return new FlatGeometryVector(geometryVector_1.VertexBufferType.VEC_2, geometryTypes, topologyVector, vertexOffsets, vertexBuffer);
+    }
+    geometryType(index) {
+        return this._geometryTypes[index];
+    }
+    get numGeometries() {
+        return this._geometryTypes.length;
+    }
+    containsPolygonGeometry() {
+        for (let i = 0; i < this.numGeometries; i++) {
+            if (this.geometryType(i) === geometryType_1.GEOMETRY_TYPE.POLYGON ||
+                this.geometryType(i) === geometryType_1.GEOMETRY_TYPE.MULTIPOLYGON) {
+                return true;
+            }
+        }
+        return false;
+    }
+    //TODO: refactor -> quick and dirty -> let a multi part geometry be equal to a single part geometry
+    //to produce the same results as with MVT and the existing styles
+    filter(geometryType) {
+        const selectionVector = [];
+        for (let i = 0; i < this.numGeometries; i++) {
+            if (this.geometryType(i) === geometryType || this.geometryType(i) === (geometryType + 3)) {
+                selectionVector.push(i);
+            }
+        }
+        return new flatSelectionVector_1.FlatSelectionVector(selectionVector);
+    }
+    filterSelected(predicateGeometryType, selectionVector) {
+        let limit = 0;
+        const vector = selectionVector.selectionValues();
+        for (let i = 0; i < selectionVector.limit; i++) {
+            const index = vector[i];
+            const geometryType = this.geometryType(index);
+            if (predicateGeometryType === geometryType || (predicateGeometryType + 3) === geometryType) {
+                vector[limit++] = index;
+            }
+        }
+        selectionVector.setLimit(limit);
+    }
+    containsSingleGeometryType() {
+        return false;
+    }
+}
+exports.FlatGeometryVector = FlatGeometryVector;
+//# sourceMappingURL=flatGeometryVector.js.map

package/dist/vector/geometry/flatGeometryVector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatGeometryVector.js","sourceRoot":"","sources":["../../../src/vector/geometry/flatGeometryVector.ts"],"names":[],"mappings":"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"}

package/dist/vector/geometry/flatGpuVector.d.ts

@@ -0,0 +1,14 @@
+import { SelectionVector } from "../filter/selectionVector";
+import { GpuVector } from "./gpuVector";
+import { SINGLE_PART_GEOMETRY_TYPE } from "./geometryType";
+import TopologyVector from "./topologyVector";
+export declare class FlatGpuVector extends GpuVector {
+    private readonly _geometryTypes;
+    constructor(_geometryTypes: Int32Array, triangleOffsets: Int32Array, indexBuffer: Int32Array, vertexBuffer: Int32Array, topologyVector: TopologyVector | null);
+    static create(geometryTypes: Int32Array, triangleOffsets: Int32Array, indexBuffer: Int32Array, vertexBuffer: Int32Array, topologyVector?: TopologyVector | null): GpuVector;
+    geometryType(index: number): number;
+    get numGeometries(): number;
+    filter(geometryType: SINGLE_PART_GEOMETRY_TYPE): SelectionVector;
+    filterSelected(geometryType: SINGLE_PART_GEOMETRY_TYPE, selectionVector: SelectionVector): void;
+    containsSingleGeometryType(): boolean;
+}

package/dist/vector/geometry/flatGpuVector.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlatGpuVector = void 0;
+const flatSelectionVector_1 = require("../filter/flatSelectionVector");
+const gpuVector_1 = require("./gpuVector");
+//TODO: extend from GeometryVector -> make topology vector optional
+class FlatGpuVector extends gpuVector_1.GpuVector {
+    constructor(_geometryTypes, triangleOffsets, indexBuffer, vertexBuffer, topologyVector) {
+        super(triangleOffsets, indexBuffer, vertexBuffer, topologyVector);
+        this._geometryTypes = _geometryTypes;
+    }
+    static create(geometryTypes, triangleOffsets, indexBuffer, vertexBuffer, topologyVector) {
+        return new FlatGpuVector(geometryTypes, triangleOffsets, indexBuffer, vertexBuffer, topologyVector);
+    }
+    /*static createMortonEncoded(
+        geometryTypes: Int32Array,
+        triangleOffsets: Int32Array,
+        indexBuffer: Int32Array,
+        vertexOffsets: Int32Array,
+        vertexBuffer: Int32Array,
+        mortonInfo: MortonSettings
+    ): GpuVector {
+        //TODO: refactor to use unsigned integers
+        return new FlatGpuVector(
+            VertexBufferType.MORTON,
+            geometryTypes,
+            triangleOffsets,
+            indexBuffer,
+            vertexOffsets,
+            vertexBuffer,
+            mortonInfo
+        );
+    }*/
+    geometryType(index) {
+        return this._geometryTypes[index];
+    }
+    get numGeometries() {
+        return this._geometryTypes.length;
+    }
+    //TODO: refactor -> quick and dirty -> let a multi part geometry be equal to a single part geometry
+    //to produce the same results as with MVT and the existing styles
+    filter(geometryType) {
+        const selectionVector = [];
+        for (let i = 0; i < this.numGeometries; i++) {
+            if (this.geometryType(i) === geometryType || this.geometryType(i) === (geometryType + 3)) {
+                selectionVector.push(i);
+            }
+        }
+        return new flatSelectionVector_1.FlatSelectionVector(selectionVector);
+    }
+    filterSelected(geometryType, selectionVector) {
+        let limit = 0;
+        const vector = selectionVector.selectionValues();
+        for (let i = 0; i < selectionVector.limit; i++) {
+            const index = selectionVector[i];
+            if (this.geometryType(index) === geometryType || this.geometryType(index) === (geometryType + 3)) {
+                vector[limit++] = index;
+            }
+        }
+        selectionVector.setLimit(limit);
+    }
+    containsSingleGeometryType() {
+        return false;
+    }
+}
+exports.FlatGpuVector = FlatGpuVector;
+//# sourceMappingURL=flatGpuVector.js.map

package/dist/vector/geometry/flatGpuVector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatGpuVector.js","sourceRoot":"","sources":["../../../src/vector/geometry/flatGpuVector.ts"],"names":[],"mappings":";;;AACA,uEAAkE;AAClE,2CAAsC;AAKtC,mEAAmE;AACnE,MAAa,aAAc,SAAQ,qBAAS;IACxC,YACqB,cAA0B,EAC3C,eAA2B,EAC3B,WAAuB,EACvB,YAAwB,EACxB,cAAqC;QAErC,KAAK,CAAC,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,CAAC,CAAC;QANjD,mBAAc,GAAd,cAAc,CAAY;IAO/C,CAAC;IAED,MAAM,CAAC,MAAM,CACT,aAAyB,EACzB,eAA2B,EAC3B,WAAuB,EACvB,YAAwB,EACxB,cAAsC;QAEtC,OAAO,IAAI,aAAa,CACpB,aAAa,EACb,eAAe,EACf,WAAW,EACX,YAAY,EACZ,cAAc,CACjB,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IAEH,YAAY,CAAC,KAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,IAAI,aAAa;QACb,OAAO,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC;IACtC,CAAC;IAED,mGAAmG;IACnG,iEAAiE;IACjE,MAAM,CAAC,YAAuC;QAC1C,MAAM,eAAe,GAAG,EAAE,CAAC;QAC3B,KAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC,EAAE,EAAC,CAAC;YACxC,IAAG,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,EAAC,CAAC;gBACrF,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC5B,CAAC;QACL,CAAC;QACD,OAAO,IAAI,yCAAmB,CAAC,eAAe,CAAC,CAAC;IACpD,CAAC;IAED,cAAc,CAAC,YAAuC,EAAE,eAAgC;QACpF,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,MAAM,MAAM,GAAG,eAAe,CAAC,eAAe,EAAE,CAAC;QACjD,KAAI,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,eAAe,CAAC,KAAK,EAAE,CAAC,EAAE,EAAC,CAAC;YAC3C,MAAM,KAAK,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;YACjC,IAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,YAAY,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,EAAC,CAAC;gBAC7F,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC;YAC5B,CAAC;QACL,CAAC;QAED,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACpC,CAAC;IAGD,0BAA0B;QACtB,OAAO,KAAK,CAAC;IACjB,CAAC;CAEJ;AArFD,sCAqFC"}

package/dist/vector/geometry/geometryType.d.ts

@@ -0,0 +1,13 @@
+export declare enum GEOMETRY_TYPE {
+    POINT = 0,
+    LINESTRING = 1,
+    POLYGON = 2,
+    MULTIPOINT = 3,
+    MULTILINESTRING = 4,
+    MULTIPOLYGON = 5
+}
+export declare enum SINGLE_PART_GEOMETRY_TYPE {
+    POINT = 0,
+    LINESTRING = 1,
+    POLYGON = 2
+}

package/dist/vector/geometry/geometryType.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SINGLE_PART_GEOMETRY_TYPE = exports.GEOMETRY_TYPE = void 0;
+var GEOMETRY_TYPE;
+(function (GEOMETRY_TYPE) {
+    GEOMETRY_TYPE[GEOMETRY_TYPE["POINT"] = 0] = "POINT";
+    GEOMETRY_TYPE[GEOMETRY_TYPE["LINESTRING"] = 1] = "LINESTRING";
+    GEOMETRY_TYPE[GEOMETRY_TYPE["POLYGON"] = 2] = "POLYGON";
+    GEOMETRY_TYPE[GEOMETRY_TYPE["MULTIPOINT"] = 3] = "MULTIPOINT";
+    GEOMETRY_TYPE[GEOMETRY_TYPE["MULTILINESTRING"] = 4] = "MULTILINESTRING";
+    GEOMETRY_TYPE[GEOMETRY_TYPE["MULTIPOLYGON"] = 5] = "MULTIPOLYGON";
+})(GEOMETRY_TYPE || (exports.GEOMETRY_TYPE = GEOMETRY_TYPE = {}));
+var SINGLE_PART_GEOMETRY_TYPE;
+(function (SINGLE_PART_GEOMETRY_TYPE) {
+    SINGLE_PART_GEOMETRY_TYPE[SINGLE_PART_GEOMETRY_TYPE["POINT"] = 0] = "POINT";
+    SINGLE_PART_GEOMETRY_TYPE[SINGLE_PART_GEOMETRY_TYPE["LINESTRING"] = 1] = "LINESTRING";
+    SINGLE_PART_GEOMETRY_TYPE[SINGLE_PART_GEOMETRY_TYPE["POLYGON"] = 2] = "POLYGON";
+})(SINGLE_PART_GEOMETRY_TYPE || (exports.SINGLE_PART_GEOMETRY_TYPE = SINGLE_PART_GEOMETRY_TYPE = {}));
+//# sourceMappingURL=geometryType.js.map

package/dist/vector/geometry/geometryType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryType.js","sourceRoot":"","sources":["../../../src/vector/geometry/geometryType.ts"],"names":[],"mappings":";;;AAAA,IAAY,aAOX;AAPD,WAAY,aAAa;IACrB,mDAAK,CAAA;IACL,6DAAU,CAAA;IACV,uDAAO,CAAA;IACP,6DAAU,CAAA;IACV,uEAAe,CAAA;IACf,iEAAY,CAAA;AAChB,CAAC,EAPW,aAAa,6BAAb,aAAa,QAOxB;AAED,IAAY,yBAIX;AAJD,WAAY,yBAAyB;IACjC,2EAAK,CAAA;IACL,qFAAU,CAAA;IACV,+EAAO,CAAA;AACX,CAAC,EAJW,yBAAyB,yCAAzB,yBAAyB,QAIpC"}

package/dist/vector/geometry/geometryVector.d.ts

@@ -0,0 +1,37 @@
+import TopologyVector from "../../vector/geometry/topologyVector";
+import { SelectionVector } from "../filter/selectionVector";
+import Point from "./point";
+import { SINGLE_PART_GEOMETRY_TYPE } from "./geometryType";
+export type Geometry = Array<Array<Point>>;
+export interface MortonSettings {
+    numBits: number;
+    coordinateShift: number;
+}
+export declare enum VertexBufferType {
+    MORTON = 0,
+    VEC_2 = 1,
+    VEC_3 = 2
+}
+export declare abstract class GeometryVector implements Iterable<Geometry> {
+    private readonly _vertexBufferType;
+    private readonly _topologyVector;
+    private readonly _vertexOffsets;
+    private readonly _vertexBuffer;
+    private readonly _mortonSettings?;
+    protected constructor(_vertexBufferType: VertexBufferType, _topologyVector: TopologyVector, _vertexOffsets: Int32Array, _vertexBuffer: Int32Array, _mortonSettings?: MortonSettings);
+    get vertexBufferType(): VertexBufferType;
+    get topologyVector(): TopologyVector;
+    get vertexOffsets(): Int32Array;
+    get vertexBuffer(): Int32Array;
+    [Symbol.iterator](): Iterator<Geometry>;
+    getSimpleEncodedVertex(index: number): [number, number];
+    getVertex(index: number): [number, number];
+    getGeometries(): Geometry[];
+    get mortonSettings(): MortonSettings | undefined;
+    abstract containsPolygonGeometry(): boolean;
+    abstract geometryType(index: number): number;
+    abstract get numGeometries(): number;
+    abstract filter(geometryType: SINGLE_PART_GEOMETRY_TYPE): SelectionVector;
+    abstract filterSelected(geometryType: SINGLE_PART_GEOMETRY_TYPE, selectionVector: SelectionVector): any;
+    abstract containsSingleGeometryType(): boolean;
+}

package/dist/vector/geometry/geometryVector.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeometryVector = exports.VertexBufferType = void 0;
+const geometryVectorConverter_1 = require("./geometryVectorConverter");
+const zOrderCurve_1 = __importDefault(require("./zOrderCurve"));
+var VertexBufferType;
+(function (VertexBufferType) {
+    VertexBufferType[VertexBufferType["MORTON"] = 0] = "MORTON";
+    VertexBufferType[VertexBufferType["VEC_2"] = 1] = "VEC_2";
+    VertexBufferType[VertexBufferType["VEC_3"] = 2] = "VEC_3";
+})(VertexBufferType || (exports.VertexBufferType = VertexBufferType = {}));
+class GeometryVector {
+    constructor(_vertexBufferType, _topologyVector, _vertexOffsets, _vertexBuffer, _mortonSettings) {
+        this._vertexBufferType = _vertexBufferType;
+        this._topologyVector = _topologyVector;
+        this._vertexOffsets = _vertexOffsets;
+        this._vertexBuffer = _vertexBuffer;
+        this._mortonSettings = _mortonSettings;
+    }
+    get vertexBufferType() {
+        return this._vertexBufferType;
+    }
+    get topologyVector() {
+        return this._topologyVector;
+    }
+    get vertexOffsets() {
+        return this._vertexOffsets;
+    }
+    get vertexBuffer() {
+        return this._vertexBuffer;
+    }
+    *[Symbol.iterator]() {
+        const geometries = (0, geometryVectorConverter_1.convertGeometryVector)(this);
+        let index = 0;
+        while (index < this.numGeometries) {
+            yield geometries[index++];
+        }
+    }
+    /* Allows faster access to the vertices since morton encoding is currently not used in the POC. Morton encoding
+       will be used after adapting the shader to decode the morton codes on the GPU. */
+    getSimpleEncodedVertex(index) {
+        const offset = this.vertexOffsets ? this.vertexOffsets[index] * 2 : index * 2;
+        const x = this.vertexBuffer[offset];
+        const y = this.vertexBuffer[offset + 1];
+        return [x, y];
+    }
+    //TODO: add scaling information to the constructor
+    getVertex(index) {
+        if (this.vertexOffsets && this.mortonSettings) {
+            //TODO: move decoding of the morton codes on the GPU in the vertex shader
+            const vertexOffset = this.vertexOffsets[index];
+            const mortonEncodedVertex = this.vertexBuffer[vertexOffset];
+            //TODO: improve performance -> inline calculation and move to decoding of VertexBuffer
+            const vertex = zOrderCurve_1.default.decode(mortonEncodedVertex, this.mortonSettings.numBits, this.mortonSettings.coordinateShift);
+            return [vertex.x, vertex.y];
+        }
+        const offset = this.vertexOffsets ? this.vertexOffsets[index] * 2 : index * 2;
+        const x = this.vertexBuffer[offset];
+        const y = this.vertexBuffer[offset + 1];
+        return [x, y];
+    }
+    getGeometries() {
+        return (0, geometryVectorConverter_1.convertGeometryVector)(this);
+    }
+    get mortonSettings() {
+        return this._mortonSettings;
+    }
+}
+exports.GeometryVector = GeometryVector;
+//# sourceMappingURL=geometryVector.js.map

package/dist/vector/geometry/geometryVector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometryVector.js","sourceRoot":"","sources":["../../../src/vector/geometry/geometryVector.ts"],"names":[],"mappings":"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"}

package/dist/vector/geometry/geometryVectorConverter.d.ts

@@ -0,0 +1,2 @@
+import { GeometryVector, Geometry } from './geometryVector';
+export declare function convertGeometryVector(geometryVector: GeometryVector): Geometry[];

package/dist/vector/geometry/geometryVectorConverter.js

@@ -0,0 +1,302 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertGeometryVector = convertGeometryVector;
+const geometryVector_1 = require("./geometryVector");
+const zOrderCurve_1 = __importDefault(require("./zOrderCurve"));
+const point_1 = __importDefault(require("./point"));
+const geometryType_1 = require("./geometryType");
+class MvtGeometryFactory {
+    createPoint(coordinate) {
+        return [[coordinate]];
+    }
+    createMultiPoint(points) {
+        return points.map(point => [point]);
+    }
+    createLineString(vertices) {
+        return [vertices];
+    }
+    createMultiLineString(lineStrings) {
+        return lineStrings;
+    }
+    createPolygon(shell, rings) {
+        return [shell, ...rings];
+    }
+    createMultiPolygon(polygons) {
+        //TODO: check winding order of shell and holes
+        return polygons.flat();
+    }
+}
+function convertGeometryVector(geometryVector) {
+    const geometries = new Array(geometryVector.numGeometries);
+    let partOffsetCounter = 1;
+    let ringOffsetsCounter = 1;
+    let geometryOffsetsCounter = 1;
+    let geometryCounter = 0;
+    const geometryFactory = new MvtGeometryFactory();
+    let vertexBufferOffset = 0;
+    let vertexOffsetsOffset = 0;
+    const mortonSettings = geometryVector.mortonSettings;
+    const topologyVector = geometryVector.topologyVector;
+    const geometryOffsets = topologyVector.geometryOffsets;
+    const partOffsets = topologyVector.partOffsets;
+    const ringOffsets = topologyVector.ringOffsets;
+    const vertexOffsets = geometryVector.vertexOffsets;
+    const containsPolygon = geometryVector.containsPolygonGeometry();
+    const vertexBuffer = geometryVector.vertexBuffer;
+    for (let i = 0; i < geometryVector.numGeometries; i++) {
+        const geometryType = geometryVector.geometryType(i);
+        if (geometryType === geometryType_1.GEOMETRY_TYPE.POINT) {
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                const x = vertexBuffer[vertexBufferOffset++];
+                const y = vertexBuffer[vertexBufferOffset++];
+                const coordinate = new point_1.default(x, y);
+                geometries[geometryCounter++] = geometryFactory.createPoint(coordinate);
+            }
+            else if (geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2) {
+                const offset = vertexOffsets[vertexOffsetsOffset++] * 2;
+                const x = vertexBuffer[offset];
+                const y = vertexBuffer[offset + 1];
+                const coordinate = new point_1.default(x, y);
+                geometries[geometryCounter++] = geometryFactory.createPoint(coordinate);
+            }
+            else {
+                const offset = vertexOffsets[vertexOffsetsOffset++];
+                const mortonCode = vertexBuffer[offset];
+                const vertex = zOrderCurve_1.default.decode(mortonCode, mortonSettings.numBits, mortonSettings.coordinateShift);
+                const coordinate = new point_1.default(vertex.x, vertex.y);
+                geometries[geometryCounter++] = geometryFactory.createPoint(coordinate);
+            }
+            if (geometryOffsets)
+                geometryOffsetsCounter++;
+            if (partOffsets)
+                partOffsetCounter++;
+            if (ringOffsets)
+                ringOffsetsCounter++;
+        }
+        else if (geometryType === geometryType_1.GEOMETRY_TYPE.MULTIPOINT) {
+            const numPoints = geometryOffsets[geometryOffsetsCounter] - geometryOffsets[geometryOffsetsCounter - 1];
+            geometryOffsetsCounter++;
+            const points = new Array(numPoints);
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                for (let j = 0; j < numPoints; j++) {
+                    const x = vertexBuffer[vertexBufferOffset++];
+                    const y = vertexBuffer[vertexBufferOffset++];
+                    points[j] = new point_1.default(x, y);
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiPoint(points);
+            }
+            else {
+                for (let j = 0; j < numPoints; j++) {
+                    const offset = vertexOffsets[vertexOffsetsOffset++] * 2;
+                    const x = vertexBuffer[offset];
+                    const y = vertexBuffer[offset + 1];
+                    points[j] = new point_1.default(x, y);
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiPoint(points);
+            }
+        }
+        else if (geometryType === geometryType_1.GEOMETRY_TYPE.LINESTRING) {
+            let numVertices = 0;
+            if (containsPolygon) {
+                numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                ringOffsetsCounter++;
+            }
+            else {
+                numVertices = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+            }
+            partOffsetCounter++;
+            let vertices;
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                vertices = getLineString(vertexBuffer, vertexBufferOffset, numVertices, false);
+                vertexBufferOffset += numVertices * 2;
+            }
+            else {
+                vertices = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                    ? decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false)
+                    : decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
+                vertexOffsetsOffset += numVertices;
+            }
+            geometries[geometryCounter++] = geometryFactory.createLineString(vertices);
+            if (geometryOffsets)
+                geometryOffsetsCounter++;
+        }
+        else if (geometryType === geometryType_1.GEOMETRY_TYPE.POLYGON) {
+            const numRings = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+            partOffsetCounter++;
+            const rings = new Array(numRings - 1);
+            let numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+            ringOffsetsCounter++;
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                const shell = getLinearRing(vertexBuffer, vertexBufferOffset, numVertices);
+                vertexBufferOffset += numVertices * 2;
+                for (let j = 0; j < rings.length; j++) {
+                    numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                    ringOffsetsCounter++;
+                    rings[j] = getLinearRing(vertexBuffer, vertexBufferOffset, numVertices);
+                    vertexBufferOffset += numVertices * 2;
+                }
+                geometries[geometryCounter++] = geometryFactory.createPolygon(shell, rings);
+            }
+            else {
+                const shell = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                    ? decodeDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices)
+                    : decodeMortonDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, geometryFactory, mortonSettings);
+                vertexOffsetsOffset += numVertices;
+                for (let j = 0; j < rings.length; j++) {
+                    numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                    ringOffsetsCounter++;
+                    rings[j] = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                        ? decodeDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices)
+                        : decodeMortonDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, geometryFactory, mortonSettings);
+                    vertexOffsetsOffset += numVertices;
+                }
+                geometries[geometryCounter++] = geometryFactory.createPolygon(shell, rings);
+            }
+            if (geometryOffsets)
+                geometryOffsetsCounter++;
+        }
+        else if (geometryType === geometryType_1.GEOMETRY_TYPE.MULTILINESTRING) {
+            const numLineStrings = geometryOffsets[geometryOffsetsCounter] - geometryOffsets[geometryOffsetsCounter - 1];
+            geometryOffsetsCounter++;
+            const lineStrings = new Array(numLineStrings);
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                for (let j = 0; j < numLineStrings; j++) {
+                    let numVertices = 0;
+                    if (containsPolygon) {
+                        numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                        ringOffsetsCounter++;
+                    }
+                    else {
+                        numVertices = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+                    }
+                    partOffsetCounter++;
+                    lineStrings[j] = getLineString(vertexBuffer, vertexBufferOffset, numVertices, false);
+                    vertexBufferOffset += numVertices * 2;
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiLineString(lineStrings);
+            }
+            else {
+                for (let j = 0; j < numLineStrings; j++) {
+                    let numVertices = 0;
+                    if (containsPolygon) {
+                        numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                        ringOffsetsCounter++;
+                    }
+                    else {
+                        numVertices = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+                    }
+                    partOffsetCounter++;
+                    const vertices = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                        ? decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false)
+                        : decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, false, mortonSettings);
+                    lineStrings[j] = vertices;
+                    vertexOffsetsOffset += numVertices;
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiLineString(lineStrings);
+            }
+        }
+        else if (geometryType === geometryType_1.GEOMETRY_TYPE.MULTIPOLYGON) {
+            const numPolygons = geometryOffsets[geometryOffsetsCounter] - geometryOffsets[geometryOffsetsCounter - 1];
+            geometryOffsetsCounter++;
+            const polygons = new Array(numPolygons);
+            let numVertices = 0;
+            if (!vertexOffsets || vertexOffsets.length === 0) {
+                for (let j = 0; j < numPolygons; j++) {
+                    const numRings = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+                    partOffsetCounter++;
+                    const rings = new Array(numRings - 1);
+                    numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                    ringOffsetsCounter++;
+                    const shell = getLinearRing(vertexBuffer, vertexBufferOffset, numVertices);
+                    vertexBufferOffset += numVertices * 2;
+                    for (let k = 0; k < rings.length; k++) {
+                        const numRingVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                        ringOffsetsCounter++;
+                        rings[k] = getLinearRing(vertexBuffer, vertexBufferOffset, numRingVertices);
+                        vertexBufferOffset += numRingVertices * 2;
+                    }
+                    polygons[j] = geometryFactory.createPolygon(shell, rings);
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiPolygon(polygons);
+            }
+            else {
+                for (let j = 0; j < numPolygons; j++) {
+                    const numRings = partOffsets[partOffsetCounter] - partOffsets[partOffsetCounter - 1];
+                    partOffsetCounter++;
+                    const rings = new Array(numRings - 1);
+                    numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                    ringOffsetsCounter++;
+                    const shell = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                        ? decodeDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices)
+                        : decodeMortonDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, geometryFactory, mortonSettings);
+                    vertexOffsetsOffset += numVertices;
+                    for (let k = 0; k < rings.length; k++) {
+                        numVertices = ringOffsets[ringOffsetsCounter] - ringOffsets[ringOffsetsCounter - 1];
+                        ringOffsetsCounter++;
+                        rings[k] = geometryVector.vertexBufferType === geometryVector_1.VertexBufferType.VEC_2
+                            ? decodeDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices)
+                            : decodeMortonDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffsetsOffset, numVertices, geometryFactory, mortonSettings);
+                        vertexOffsetsOffset += numVertices;
+                    }
+                    polygons[j] = geometryFactory.createPolygon(shell, rings);
+                }
+                geometries[geometryCounter++] = geometryFactory.createMultiPolygon(polygons);
+            }
+        }
+        else {
+            throw new Error("The specified geometry type is currently not supported.");
+        }
+    }
+    return geometries;
+}
+function getLinearRing(vertexBuffer, startIndex, numVertices) {
+    return getLineString(vertexBuffer, startIndex, numVertices, true);
+}
+function decodeDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffset, numVertices) {
+    return decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, true);
+}
+function decodeMortonDictionaryEncodedLinearRing(vertexBuffer, vertexOffsets, vertexOffset, numVertices, geometryFactory, mortonSettings) {
+    return decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, true, mortonSettings);
+}
+function getLineString(vertexBuffer, startIndex, numVertices, closeLineString) {
+    const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+    for (let i = 0; i < numVertices * 2; i += 2) {
+        const x = vertexBuffer[startIndex + i];
+        const y = vertexBuffer[startIndex + i + 1];
+        vertices[i / 2] = new point_1.default(x, y);
+    }
+    if (closeLineString) {
+        vertices[vertices.length - 1] = vertices[0];
+    }
+    return vertices;
+}
+function decodeDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString) {
+    const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+    for (let i = 0; i < numVertices * 2; i += 2) {
+        const offset = vertexOffsets[vertexOffset + i / 2] * 2;
+        const x = vertexBuffer[offset];
+        const y = vertexBuffer[offset + 1];
+        vertices[i / 2] = new point_1.default(x, y);
+    }
+    if (closeLineString) {
+        vertices[vertices.length - 1] = vertices[0];
+    }
+    return vertices;
+}
+function decodeMortonDictionaryEncodedLineString(vertexBuffer, vertexOffsets, vertexOffset, numVertices, closeLineString, mortonSettings) {
+    const vertices = new Array(closeLineString ? numVertices + 1 : numVertices);
+    for (let i = 0; i < numVertices; i++) {
+        const offset = vertexOffsets[vertexOffset + i];
+        const mortonEncodedVertex = vertexBuffer[offset];
+        const vertex = zOrderCurve_1.default.decode(mortonEncodedVertex, mortonSettings.numBits, mortonSettings.coordinateShift);
+        vertices[i] = new point_1.default(vertex.x, vertex.y);
+    }
+    if (closeLineString) {
+        vertices[vertices.length - 1] = vertices[0];
+    }
+    return vertices;
+}
+//# sourceMappingURL=geometryVectorConverter.js.map