osm2geojson-lite 0.8.13 → 0.9.0

package/ts/src/typings.d.ts

@@ -1,4 +1,4 @@
-declare module "*.json" {
+declare module '*.json' {
     const value: any;
     export default value;
 }

package/ts/src/utils.ts

@@ -1,198 +1,235 @@
-import {Way} from "./osmobjs";
-
-export function purgeProps(obj: object, blacklist: string[]): object {
-	if (obj) {
-		let rs = Object.assign({}, obj);
-		if (blacklist)
-			for (let prop of blacklist) delete rs[prop];
-		return rs;
-	}
-	return {};
+import {Way} from './osmobjs';
+
+export function purgeProps(obj: {[k: string]: any}, blacklist: string[]): {[k: string]: any} {
+    if (obj) {
+        const rs = Object.assign({}, obj);
+        if (blacklist) {
+            for (const prop of blacklist) {
+                delete rs[prop];
+            }
+        }
+        return rs;
+    }
+    return {};
 }
 
-export function mergeProps(obj1: object, obj2: object): object {
-	obj1 = obj1? obj1 : {};
-	obj2 = obj2? obj2 : {};
-	return Object.assign(obj1, obj2);
+export function mergeProps(obj1: {[k: string]: any}, obj2: {[k: string]: any}): {[k: string]: any} {
+    obj1 = obj1 ? obj1 : {};
+    obj2 = obj2 ? obj2 : {};
+    return Object.assign(obj1, obj2);
 }
 
-export function addPropToFeature(f: any, k: string, v: string) {
-	if (f.properties && k && v) f.properties[k] = v;
+export function addPropToFeature(f: {[k: string]: any}, k: string, v: any) {
+    if (f.properties && k && v) {
+        f.properties[k] = v;
+    }
 }
 
-export function addPropToFeatures(fs: any[], k: string, v: string) {
-	for (let f of fs) addPropToFeature(f, k, v);
+export function addPropToFeatures(fs: Array<{[k: string]: any}>, k: string, v: any) {
+    for (const f of fs) {
+        addPropToFeature(f, k, v);
+    }
 }
 
-export const first = a => a[0];
-export const last = a => a[a.length - 1];
-export const coordsToKey = a => a.join(',');
-
-export function addToMap(m: object, k: string, v: any) {
-	let a = m[k];
-	if (a) a.push(v);
-	else m[k] = [v];
+export const first = <T>(a: T[]): T => a[0];
+export const last = <T>(a: T[]): T => a[a.length - 1];
+export const coordsToKey = <T>(a: T[]): string => a.join(',');
+
+export function addToMap<T>(m: {[k: string]: T[]}, k: string, v: T): void {
+    const a = m[k];
+    if (a) {
+        a.push(v);
+    } else {
+        m[k] = [v];
+    }
 }
 
-export function removeFromMap(m: object, k: string, v: any) {
-	let a = m[k];
-	let idx = null;
-	if (a && (idx = a.indexOf(v)) >= 0)
-		a.splice(idx, 1);
+export function removeFromMap<T>(m: {[k: string]: T[]}, k: string, v: T): void {
+    const a = m[k];
+    let idx = -1;
+    if (a) {
+        idx = a.indexOf(v);
+    }
+    if (idx >= 0) {
+        a.splice(idx, 1);
+    }
 }
 
-export function getFirstFromMap(m: object, k: string): any {
-	let a = m[k];
-	if (a && a.length > 0) return a[0];
-	return null;
+export function getFirstFromMap<T>(m: {[k: string]: T[]}, k: string): T | undefined {
+    const a = m[k];
+    if (a && a.length > 0) {
+        return a[0];
+    }
+    return undefined;
 }
 
 // need 3+ different points to form a ring, here using > 3 is 'coz a the first and the last points are actually the same
-export const isRing = a => a.length > 3 && coordsToKey(first(a)) === coordsToKey(last(a));
-
-export const ringDirection = (a, xIdx?, yIdx?) => {
-	xIdx = xIdx || 0, yIdx = yIdx || 1;
-	// get the index of the point which has the maximum x value
-	let m = a.reduce((maxxIdx, v, idx) => a[maxxIdx][xIdx] > v[xIdx] ? 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;
-	let l = m <= 0? a.length - 2 : m - 1, r = m >= a.length - 1? 1 : m + 1;
-	let xa = a[l][xIdx], xb = a[m][xIdx], xc = a[r][xIdx];
-	let ya = a[l][yIdx], yb = a[m][yIdx], yc = a[r][yIdx];
-	let det = (xb - xa) * (yc - ya) - (xc - xa) * (yb - ya);
-	return det < 0 ? 'clockwise' : 'counterclockwise';
-}
-
-export const ptInsidePolygon = (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;
-}
-
-export const strToFloat = el => el instanceof Array? el.map(strToFloat) : parseFloat(el);
+export const isRing = (a: number[][]): boolean => a.length > 3 && coordsToKey(first(a)) === coordsToKey(last(a));
+
+export const ringDirection = (a: number[][], xIdx?: number, yIdx?: number): string => {
+    xIdx = xIdx || 0, yIdx = yIdx || 1;
+    // get the index of the point which has the maximum x value
+    const m = a.reduce((maxxIdx: number, v: number[], idx: number): number => 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';
+};
+
+export const ptInsidePolygon = (pt: number[], polygon: number[][], xIdx?: number, yIdx?: number): boolean => {
+    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;
+};
+
+export const strToFloat = (el: any[] | string): any => el instanceof Array ? el.map(strToFloat) : parseFloat(el);
 
 export class LateBinder {
-	container: Object;
-	valueFunc: Function;
-	ctx: Object;
-	args: Object[];
-
-	constructor(container: Object, valueFunc: Function, ctx: Object, args: Object[]) {
-		this.container = container;
-		this.valueFunc = valueFunc;
-		this.ctx = ctx;
-		this.args = args;
-	}
-
-	bind() {
-		let v = this.valueFunc.apply(this.ctx, this.args);
-		if (this.container instanceof Array) {
-			let idx = this.container.indexOf(this);
-			if (idx >= 0) {
-				let args = [idx, 1];
-				if (v) args.push(v);
-				[].splice.apply(this.container, args);
-			}
-		} else if (typeof this.container === 'object') {
-			let k = Object.keys(this.container).find(v => this.container[v] === this);
-			if (k)
-				if (v) this.container[k] = v;
-				else delete this.container[k];
-		}
-	}
+    private container: any[] | {[k: string]: any};
+    private valueFunc: (...args) => any;
+    private ctx: any;
+    private args: any[];
+
+    constructor(container: any[] | {[k: string]: any}, valueFunc: (...args) => any, ctx: any, args: any[]) {
+        this.container = container;
+        this.valueFunc = valueFunc;
+        this.ctx = ctx;
+        this.args = args;
+    }
+
+    public bind() {
+        const v = this.valueFunc.apply(this.ctx, this.args);
+        if (this.container instanceof Array) {
+            const idx = this.container.indexOf(this);
+            if (idx >= 0) {
+                const args = [idx, 1];
+                if (v) {
+                    args.push(v);
+                }
+                [].splice.apply(this.container, args);
+            }
+        } else if (typeof this.container === 'object') {
+            const k = Object.keys(this.container).find((nv) => this.container[nv] === this);
+            if (k) {
+                if (v) {
+                    this.container[k] = v;
+                } else {
+                    delete this.container[k];
+                }
+            }
+        }
+    }
 }
 
 export class RefElements extends Map {
-	binders: LateBinder[];
+    private binders: LateBinder[];
 
-	constructor() {
-		super();
-		this.binders = [];
-	}
+    constructor() {
+        super();
+        this.binders = [];
+    }
 
-	add(k: String, v: Object) {
-		this.set(k, v);
-	}
+    public add(k: string, v: any) {
+        this.set(k, v);
+    }
 
-	addBinder(binder: LateBinder) {
-		this.binders.push(binder);
-	}
+    public addBinder(binder: LateBinder) {
+        this.binders.push(binder);
+    }
 
-	bindAll() {
-		this.binders.forEach(binder => binder.bind());
-	}
+    public bindAll() {
+        this.binders.forEach((binder) => binder.bind());
+    }
 }
 
 export class WayCollection extends Array {
-	firstMap: Object;
-	lastMap: Object;
-
-	constructor() {
-		super();
-		this.firstMap = {};
-		this.lastMap = {};
-	}
-
-	addWay(way: Way) {
-		let w = way.toCoordsArray();
-		if (w.length > 0) {
-			this.push(way);
-			addToMap(this.firstMap, coordsToKey(first(w)), w);
-			addToMap(this.lastMap, coordsToKey(last(w)), w);
-		}
-	}
-
-	toStrings(): any[] {
-		let strings: any[] = [], way = null;
-		while (way = this.shift()) {
-			removeFromMap(this.firstMap, coordsToKey(first(way)), way);
-			removeFromMap(this.lastMap, coordsToKey(last(way)), way);
-			let current: any[] = way, next: any[];
-			do {
-				let key = coordsToKey(last(current)), shouldReverse = false;
-
-				next = getFirstFromMap(this.firstMap, key);										
-				if (!next) {
-					next = getFirstFromMap(this.lastMap, key);
-					shouldReverse = true;
-				}
-				
-				if (next) {
-					this.splice(this.indexOf(next), 1);
-					removeFromMap(this.firstMap, coordsToKey(first(next)), next);
-					removeFromMap(this.lastMap, coordsToKey(last(next)), next);
-					if (shouldReverse) {
-						// always reverse shorter one to save time
-						if (next.length > current.length)
-							[current, next] = [next, current];
-						next.reverse();
-					}
-
-					current = current.concat(next.slice(1));
-				}
-			} while (next);
-			strings.push(strToFloat(current));
-		}
-
-		return strings;
-	}
-
-	toRings(direction: String): any[] {
-		let strings = this.toStrings();
-		let rings: any[] = [], string: any[];
-		while (string = strings.shift()) {
-			if (isRing(string)) {
-				if (ringDirection(string) !== direction) string.reverse();
-				rings.push(string);
-			}	
-		}
-		return rings;
-	}
+    private firstMap: {[k: string]: any};
+    private lastMap: {[k: string]: any};
+
+    constructor() {
+        super();
+        this.firstMap = {};
+        this.lastMap = {};
+    }
+
+    public addWay(way: Way) {
+        const w = way.toCoordsArray();
+        if (w.length > 0) {
+            this.push(way);
+            addToMap(this.firstMap, coordsToKey(first(w)), w);
+            addToMap(this.lastMap, coordsToKey(last(w)), w);
+        }
+    }
+
+    public toStrings(): number[][][] {
+        const strings: any[] = [];
+        let way = this.shift();
+        while (way) {
+            removeFromMap(this.firstMap, coordsToKey(first(way)), way);
+            removeFromMap(this.lastMap, coordsToKey(last(way)), way);
+            let current: any[] = way;
+            let next: any[] | undefined;
+            do {
+                const key = coordsToKey(last(current));
+                let shouldReverse = false;
+
+                next = getFirstFromMap(this.firstMap, key);
+                if (!next) {
+                    next = getFirstFromMap(this.lastMap, key);
+                    shouldReverse = true;
+                }
+
+                if (next) {
+                    this.splice(this.indexOf(next), 1);
+                    removeFromMap(this.firstMap, coordsToKey(first(next)), next);
+                    removeFromMap(this.lastMap, coordsToKey(last(next)), next);
+                    if (shouldReverse) {
+                        // always reverse shorter one to save time
+                        if (next.length > current.length) {
+                            [current, next] = [next, current];
+                        }
+                        next.reverse();
+                    }
+
+                    current = current.concat(next.slice(1));
+                }
+            } while (next);
+            strings.push(strToFloat(current));
+            way = this.shift();
+        }
+
+        return strings;
+    }
+
+    public toRings(direction: string): number[][][] {
+        const strings = this.toStrings();
+        const rings: number[][][] = [];
+        let str = strings.shift();
+        while (str) {
+            if (isRing(str)) {
+                if (ringDirection(str) !== direction) {
+                    str.reverse();
+                }
+                rings.push(str);
+            }
+            str = strings.shift();
+        }
+        return rings;
+    }
 }