osm2geojson-lite 1.2.0 → 2.1.0

package/dist/node/relation.d.ts

@@ -1,21 +0,0 @@
-import { OsmObject } from "./osm-object";
-import { Way } from "./way";
-import { LateBinder } from "./late-binder";
-import type { RefElements } from "./ref-elements";
-import type { Feature } from "geojson";
-export declare class Relation extends OsmObject {
-    private relations;
-    private nodes;
-    private bounds;
-    ways: (LateBinder<Way> | Way)[];
-    roles: string[];
-    constructor(id: string, refElems: RefElements);
-    setBounds(bounds: any[]): void;
-    addMember(member: {
-        [k: string]: any;
-    }): void;
-    private constructStringGeometry;
-    private constructPolygonGeometry;
-    private collectAllWaysForRelation;
-    toFeatureArray(): Array<Feature<any, any>>;
-}

package/dist/node/relation.js

@@ -1,220 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Relation = void 0;
-const osm_object_1 = require("./osm-object");
-const way_1 = require("./way");
-const node_1 = require("./node");
-const way_collection_1 = require("./way-collection");
-const late_binder_1 = require("./late-binder");
-const utils_1 = require("./utils");
-class Relation extends osm_object_1.OsmObject {
-    constructor(id, refElems) {
-        super('relation', id, refElems);
-        this.relations = [];
-        this.nodes = [];
-        this.bounds = undefined;
-        this.ways = [];
-        this.roles = [];
-    }
-    setBounds(bounds) {
-        this.bounds = bounds;
-    }
-    addMember(member) {
-        switch (member.type) {
-            // super relation, need to do combination
-            case 'relation':
-                let binder = new late_binder_1.LateBinder(this.relations, (id) => {
-                    const relation = this.refElems.get(`relation/${id}`);
-                    if (relation) {
-                        relation.refCount++;
-                        return relation;
-                    }
-                }, this, [member.ref]);
-                this.relations.push(binder);
-                this.refElems.addBinder(binder);
-                break;
-            case 'way':
-                if (!member.role) {
-                    member.role = '';
-                }
-                if (member.geometry) {
-                    const way = new way_1.Way(member.ref, this.refElems);
-                    way.setLatLngArray(member.geometry);
-                    way.refCount++;
-                    this.ways.push(way);
-                    this.roles.push(member.role);
-                }
-                else if (member.nodes) {
-                    const way = new way_1.Way(member.ref, this.refElems);
-                    for (const nid of member.nodes) {
-                        way.addNodeRef(nid);
-                    }
-                    way.refCount++;
-                    this.ways.push(way);
-                    this.roles.push(member.role);
-                }
-                else {
-                    let binder = new late_binder_1.LateBinder(this.ways, (nid) => {
-                        const way = this.refElems.get(`way/${nid}`);
-                        if (way) {
-                            way.refCount++;
-                            return way;
-                        }
-                    }, this, [member.ref]);
-                    this.ways.push(binder);
-                    this.roles.push(member.role);
-                    this.refElems.addBinder(binder);
-                }
-                break;
-            case 'node':
-                let node = null;
-                if (member.lat && member.lon) {
-                    node = new node_1.Node(member.ref, this.refElems);
-                    node.setLatLng({ lon: member.lon, lat: member.lat });
-                    if (member.tags) {
-                        node.addTags(member.tags);
-                    }
-                    for (const [k, v] of Object.entries(member)) {
-                        if (['id', 'type', 'lat', 'lon'].indexOf(k) < 0) {
-                            node.addProp(k, v);
-                        }
-                    }
-                    node.refCount++;
-                    this.nodes.push(node);
-                }
-                else {
-                    let binder = new late_binder_1.LateBinder(this.nodes, (id) => {
-                        const nn = this.refElems.get(`node/${id}`);
-                        if (nn) {
-                            nn.refCount++;
-                            return nn;
-                        }
-                    }, this, [member.ref]);
-                    this.nodes.push(binder);
-                    this.refElems.addBinder(binder);
-                }
-                break;
-        }
-    }
-    constructStringGeometry(ws) {
-        const strings = ws ? ws.mergeWays() : [];
-        if (strings.length === 0) {
-            return null;
-        }
-        return {
-            type: 'MultiLineString',
-            coordinates: strings,
-        };
-    }
-    constructPolygonGeometry(ows, iws) {
-        const outerRings = ows ? ows.toRings('counterclockwise') : [];
-        const innerRings = iws ? iws.toRings('clockwise') : [];
-        if (outerRings.length > 0) {
-            const compositPolyons = [];
-            let ring;
-            for (ring of outerRings) {
-                compositPolyons.push([ring]);
-            }
-            // link inner polygons to outer containers
-            ring = innerRings.shift();
-            while (ring) {
-                for (const idx in outerRings) {
-                    if ((0, utils_1.pointInsidePolygon)((0, utils_1.first)(ring), outerRings[idx])) {
-                        compositPolyons[idx].push(ring);
-                        break;
-                    }
-                }
-                ring = innerRings.shift();
-            }
-            // construct the Polygon/MultiPolygon geometry
-            if (compositPolyons.length === 1) {
-                return {
-                    type: 'Polygon',
-                    coordinates: compositPolyons[0],
-                };
-            }
-            return {
-                type: 'MultiPolygon',
-                coordinates: compositPolyons,
-            };
-        }
-        return null;
-    }
-    collectAllWaysForRelation(relation, relationToWaysMap) {
-        const ways = [...relation.ways];
-        const roles = [...relation.roles];
-        if (relation.relations.length === 0) {
-            relationToWaysMap.set(relation.id, { ways, roles });
-            return { ways, roles };
-        }
-        for (const subRelation of relation.relations) {
-            if (!subRelation) {
-                continue;
-            }
-            if (!relationToWaysMap.has(subRelation.id)) {
-                this.collectAllWaysForRelation(subRelation, relationToWaysMap);
-            }
-            const entry = relationToWaysMap.get(subRelation.id);
-            for (let i = 0; i < entry.ways.length; i++) {
-                ways.push(entry.ways[i]);
-                roles.push(entry.roles[i]);
-            }
-        }
-        relationToWaysMap.set(relation.id, { ways, roles });
-        return { ways, roles };
-    }
-    toFeatureArray() {
-        const polygonFeatures = [];
-        const stringFeatures = [];
-        let pointFeatures = [];
-        const relationToWaysMap = new Map();
-        const waysAndRoles = this.collectAllWaysForRelation(this, relationToWaysMap);
-        let templateFeature = {
-            type: 'Feature',
-            id: this.getCompositeId(),
-            bbox: this.bounds,
-            properties: this.getProps(),
-            geometry: null
-        };
-        if (!this.bounds) {
-            delete templateFeature.bbox;
-        }
-        if (this.roles.some((r) => r === 'outer')) {
-            const outerWayCollection = new way_collection_1.WayCollection();
-            const innerWayCollection = new way_collection_1.WayCollection();
-            for (let i = 0; i < waysAndRoles.ways.length; i++) {
-                const way = waysAndRoles.ways[i];
-                const role = waysAndRoles.roles[i];
-                if (role === 'outer') {
-                    outerWayCollection.addWay(way);
-                }
-                else if (role === 'inner') {
-                    innerWayCollection.addWay(way);
-                }
-            }
-            let feature = Object.assign({}, templateFeature);
-            let geometry = this.constructPolygonGeometry(outerWayCollection, innerWayCollection);
-            if (geometry) {
-                feature.geometry = geometry;
-                polygonFeatures.push(feature);
-            }
-        }
-        else {
-            const wayCollection = new way_collection_1.WayCollection();
-            for (let way of waysAndRoles.ways) {
-                wayCollection.addWay(way);
-            }
-            let geometry = this.constructStringGeometry(wayCollection);
-            if (geometry) {
-                let feature = Object.assign({}, templateFeature);
-                feature.geometry = geometry;
-                stringFeatures.push(feature);
-            }
-        }
-        for (let node of this.nodes) {
-            pointFeatures = pointFeatures.concat(node.toFeatureArray());
-        }
-        return [...polygonFeatures, ...stringFeatures, ...pointFeatures];
-    }
-}
-exports.Relation = Relation;

package/dist/node/utils.d.ts

@@ -1,22 +0,0 @@
-export declare function purgeProps(obj: {
-    [k: string]: any;
-}, blacklist: string[]): {
-    [k: string]: any;
-};
-export declare function first<T>(a: T[]): T;
-export declare function last<T>(a: T[]): T;
-export declare function coordsToKey<T>(a: T[]): string;
-export declare function addToMap<T>(m: {
-    [k: string]: T[];
-}, k: string, v: T): void;
-export declare function removeFromMap<T>(m: {
-    [k: string]: T[];
-}, k: string, v: T): void;
-export declare function getFirstFromMap<T>(m: {
-    [k: string]: T[];
-}, k: string): T | null;
-export declare function isRing(a: number[][]): boolean;
-export declare function ringDirection(a: number[][], xIdx?: number, yIdx?: number): string;
-export declare function pointInsidePolygon(pt: number[], polygon: number[][], xIdx?: number, yIdx?: number): boolean;
-export declare function strArrayArrayToFloat(el: string[][]): number[][];
-export declare function strArrayToFloat(el: string[]): number[];

package/dist/node/utils.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.purgeProps = purgeProps;
-exports.first = first;
-exports.last = last;
-exports.coordsToKey = coordsToKey;
-exports.addToMap = addToMap;
-exports.removeFromMap = removeFromMap;
-exports.getFirstFromMap = getFirstFromMap;
-exports.isRing = isRing;
-exports.ringDirection = ringDirection;
-exports.pointInsidePolygon = pointInsidePolygon;
-exports.strArrayArrayToFloat = strArrayArrayToFloat;
-exports.strArrayToFloat = strArrayToFloat;
-function purgeProps(obj, blacklist) {
-    if (obj) {
-        const rs = Object.assign({}, obj);
-        if (blacklist) {
-            for (const prop of blacklist) {
-                delete rs[prop];
-            }
-        }
-        return rs;
-    }
-    return {};
-}
-function first(a) { return a[0]; }
-function last(a) { return a[a.length - 1]; }
-function coordsToKey(a) { return a.join(','); }
-function addToMap(m, k, v) {
-    const a = m[k];
-    if (a) {
-        a.push(v);
-    }
-    else {
-        m[k] = [v];
-    }
-}
-function removeFromMap(m, k, v) {
-    const a = m[k];
-    let idx = -1;
-    if (a) {
-        idx = a.indexOf(v);
-    }
-    if (idx >= 0) {
-        a.splice(idx, 1);
-    }
-}
-function getFirstFromMap(m, k) {
-    const a = m[k];
-    if (a && a.length > 0) {
-        return a[0];
-    }
-    return null;
-}
-// need 3+ different points to form a ring, here using > 3 is 'coz a the first and the last points are actually the same
-function isRing(a) {
-    return a.length > 3 && coordsToKey(first(a)) === coordsToKey(last(a));
-}
-function ringDirection(a, xIdx, yIdx) {
-    xIdx = xIdx || 0, yIdx = yIdx || 1;
-    // get the index of the point which has the maximum x value
-    const m = a.reduce((maxxIdx, v, idx) => a[maxxIdx][xIdx || 0] > v[xIdx || 0] ? maxxIdx : idx, 0);
-    // 'coz the first point is virtually the same one as the last point,
-    // we need to skip a.length - 1 for left when m = 0,
-    // and skip 0 for right when m = a.length - 1;
-    const l = m <= 0 ? a.length - 2 : m - 1;
-    const r = m >= a.length - 1 ? 1 : m + 1;
-    const xa = a[l][xIdx];
-    const xb = a[m][xIdx];
-    const xc = a[r][xIdx];
-    const ya = a[l][yIdx];
-    const yb = a[m][yIdx];
-    const yc = a[r][yIdx];
-    const det = (xb - xa) * (yc - ya) - (xc - xa) * (yb - ya);
-    return det < 0 ? 'clockwise' : 'counterclockwise';
-}
-;
-function pointInsidePolygon(pt, polygon, xIdx, yIdx) {
-    xIdx = xIdx || 0, yIdx = yIdx || 1;
-    let result = false;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        if ((polygon[i][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[j][xIdx] ||
-            polygon[j][xIdx] <= pt[xIdx] && pt[xIdx] < polygon[i][xIdx]) &&
-            pt[yIdx] < (polygon[j][yIdx] - polygon[i][yIdx]) * (pt[xIdx] - polygon[i][xIdx]) / (polygon[j][xIdx] - polygon[i][xIdx]) + polygon[i][yIdx]) {
-            result = !result;
-        }
-    }
-    return result;
-}
-;
-function strArrayArrayToFloat(el) {
-    return el.map(strArrayToFloat);
-}
-function strArrayToFloat(el) {
-    return el.map(parseFloat);
-}

package/dist/node/way-collection.d.ts

@@ -1,14 +0,0 @@
-import type { Way } from "./way";
-export declare class WayCollection extends Array {
-    private firstMap;
-    private lastMap;
-    constructor();
-    addWay(way: Way): void;
-    mergeWays(): number[][][];
-    /**
-     * Try to find the next way to add to the current way.
-     * It first tries the next way in the array, and if this doesn't work, try any other way.
-     */
-    private getNextWay;
-    toRings(direction: string): number[][][];
-}

package/dist/node/way-collection.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WayCollection = void 0;
-const utils_1 = require("./utils");
-class WayCollection extends Array {
-    constructor() {
-        super();
-        this.firstMap = {};
-        this.lastMap = {};
-    }
-    addWay(way) {
-        const w = way.toCoordsArray();
-        if (w.length > 0) {
-            this.push(w);
-            (0, utils_1.addToMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(w)), w);
-            (0, utils_1.addToMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(w)), w);
-        }
-    }
-    mergeWays() {
-        const strings = [];
-        let way = this.shift();
-        while (way) {
-            (0, utils_1.removeFromMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(way)), way);
-            (0, utils_1.removeFromMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(way)), way);
-            let current = way;
-            let next;
-            do {
-                let nextWay = this.getNextWay(current);
-                next = nextWay.next;
-                let mergeType = nextWay.mergeType;
-                if (!next) {
-                    continue;
-                }
-                this.splice(this.indexOf(next), 1);
-                (0, utils_1.removeFromMap)(this.firstMap, (0, utils_1.coordsToKey)((0, utils_1.first)(next)), next);
-                (0, utils_1.removeFromMap)(this.lastMap, (0, utils_1.coordsToKey)((0, utils_1.last)(next)), next);
-                switch (mergeType) {
-                    case 0 /* MergeType.EndStart */:
-                        current = current.concat(next.slice(1));
-                        break;
-                    case 1 /* MergeType.EndEnd */:
-                        next.reverse();
-                        current = current.concat(next.slice(1));
-                        break;
-                    case 2 /* MergeType.StartStart */:
-                        current.reverse();
-                        current = current.concat(next.slice(1));
-                        break;
-                    case 3 /* MergeType.StartEnd */:
-                        current = next.concat(current.slice(1));
-                        current.reverse();
-                        break;
-                }
-            } while (next);
-            strings.push((0, utils_1.strArrayArrayToFloat)(current));
-            way = this.shift();
-        }
-        return strings;
-    }
-    /**
-     * Try to find the next way to add to the current way.
-     * It first tries the next way in the array, and if this doesn't work, try any other way.
-     */
-    getNextWay(current) {
-        const lastKey = (0, utils_1.coordsToKey)((0, utils_1.last)(current));
-        const firstKey = (0, utils_1.coordsToKey)((0, utils_1.first)(current));
-        // Step 1: Prefer the next way in the array if it connects
-        let next = this.length > 0 ? this[0] : null;
-        if (next) {
-            const nextFirstKey = (0, utils_1.coordsToKey)((0, utils_1.first)(next));
-            const nextLastKey = (0, utils_1.coordsToKey)((0, utils_1.last)(next));
-            if (lastKey === nextFirstKey) {
-                return { next, mergeType: 0 /* MergeType.EndStart */ };
-            }
-            if (lastKey === nextLastKey) {
-                return { next, mergeType: 1 /* MergeType.EndEnd */ };
-            }
-            if (firstKey === nextFirstKey) {
-                return { next, mergeType: 2 /* MergeType.StartStart */ };
-            }
-            if (firstKey === nextLastKey) {
-                return { next, mergeType: 3 /* MergeType.StartEnd */ };
-            }
-        }
-        // Step 2: Fallback to map-based lookup if no sequential match
-        next = (0, utils_1.getFirstFromMap)(this.firstMap, lastKey);
-        if (next) {
-            return { next, mergeType: 0 /* MergeType.EndStart */ };
-        }
-        next = (0, utils_1.getFirstFromMap)(this.lastMap, lastKey);
-        return { next, mergeType: 1 /* MergeType.EndEnd */ };
-    }
-    toRings(direction) {
-        const strings = this.mergeWays();
-        const rings = [];
-        let str = strings.shift();
-        while (str) {
-            if ((0, utils_1.isRing)(str)) {
-                if ((0, utils_1.ringDirection)(str) !== direction) {
-                    str.reverse();
-                }
-                rings.push(str);
-            }
-            str = strings.shift();
-        }
-        return rings;
-    }
-}
-exports.WayCollection = WayCollection;

package/dist/node/way.d.ts

@@ -1,21 +0,0 @@
-import { Feature } from "geojson";
-import { OsmObject } from "./osm-object";
-import { LatLon } from "./node";
-import type { RefElements } from "./ref-elements";
-export declare class Way extends OsmObject {
-    private latLngArray;
-    private isPolygon;
-    constructor(id: string, refElems: RefElements);
-    addLatLng(latLng: LatLon): void;
-    setLatLngArray(latLngArray: Array<LatLon & {
-        [k: string]: any;
-    }>): void;
-    addNodeRef(ref: string): void;
-    addTags(tags: {
-        [k: string]: string;
-    }): void;
-    addTag(k: string, v: string): void;
-    toCoordsArray(): string[][];
-    toFeatureArray(): Array<Feature<any, any>>;
-    private analyzeTag;
-}

package/dist/node/way.js

@@ -1,87 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Way = void 0;
-const osm_object_1 = require("./osm-object");
-const late_binder_1 = require("./late-binder");
-const utils_1 = require("./utils");
-const polytags_json_1 = __importDefault(require("./polytags.json"));
-class Way extends osm_object_1.OsmObject {
-    constructor(id, refElems) {
-        super('way', id, refElems);
-        this.latLngArray = [];
-        this.isPolygon = false;
-    }
-    addLatLng(latLng) {
-        this.latLngArray.push(latLng);
-    }
-    setLatLngArray(latLngArray) {
-        this.latLngArray = latLngArray;
-    }
-    addNodeRef(ref) {
-        const binder = new late_binder_1.LateBinder(this.latLngArray, (id) => {
-            const node = this.refElems.get(`node/${id}`);
-            if (node) {
-                node.refCount++;
-                return node.getLatLng();
-            }
-        }, this, [ref]);
-        this.latLngArray.push(binder);
-        this.refElems.addBinder(binder);
-    }
-    addTags(tags) {
-        super.addTags(tags);
-        for (const [k, v] of Object.entries(tags)) {
-            this.analyzeTag(k, v);
-        }
-    }
-    addTag(k, v) {
-        super.addTag(k, v);
-        this.analyzeTag(k, v);
-    }
-    toCoordsArray() {
-        return this.latLngArray.map((latLng) => [latLng.lon, latLng.lat]);
-    }
-    toFeatureArray() {
-        let coordsArrayString = this.toCoordsArray();
-        if (coordsArrayString.length > 1) {
-            const coordsArray = (0, utils_1.strArrayArrayToFloat)(coordsArrayString);
-            const feature = {
-                type: 'Feature',
-                id: this.getCompositeId(),
-                properties: this.getProps(),
-                geometry: {
-                    type: 'LineString',
-                    coordinates: coordsArray,
-                },
-            };
-            if (this.isPolygon && (0, utils_1.isRing)(coordsArray)) {
-                if ((0, utils_1.ringDirection)(coordsArray) !== 'counterclockwise') {
-                    coordsArray.reverse();
-                }
-                feature.geometry = {
-                    type: 'Polygon',
-                    coordinates: [coordsArray],
-                };
-                return [feature];
-            }
-            return [feature];
-        }
-        return [];
-    }
-    analyzeTag(k, v) {
-        const o = polytags_json_1.default[k];
-        if (o) {
-            this.isPolygon = true;
-            if (o.whitelist) {
-                this.isPolygon = o.whitelist.indexOf(v) >= 0 ? true : false;
-            }
-            else if (o.blacklist) {
-                this.isPolygon = o.blacklist.indexOf(v) >= 0 ? false : true;
-            }
-        }
-    }
-}
-exports.Way = Way;

package/dist/node/xmlparser.d.ts

@@ -1,32 +0,0 @@
-export declare class XmlParser {
-    private queryParent;
-    private progressive;
-    private parentMap;
-    private evtListeners;
-    constructor(opts: any);
-    parse(xml: string, parent?: any, dir?: string): any[];
-    getParent(node: any): any;
-    addListener(evt: string, func: (node: {
-        [k: string]: any;
-    }, parent?: {
-        [k: string]: any;
-    }) => void): void;
-    removeListener(evt: string, func: (node: {
-        [k: string]: any;
-    }, parent?: {
-        [k: string]: any;
-    }) => void): void;
-    on(evt: string, func: (node: {
-        [k: string]: any;
-    }, parent?: {
-        [k: string]: any;
-    }) => void): void;
-    off(evt: string, func: (node: {
-        [k: string]: any;
-    }, parent?: {
-        [k: string]: any;
-    }) => void): void;
-    private $addListener;
-    private $removeListener;
-    private emit;
-}