@toba/map/cjs/geojson.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tools_1 = require("@toba/tools");
const xmldom_1 = require("xmldom");
const index_1 = require("./index");
var Type;
(function (Type) {
    Type["Feature"] = "Feature";
    Type["Collection"] = "FeatureCollection";
    Type["Point"] = "Point";
    Type["Line"] = "LineString";
    Type["MultiLine"] = "MultiLineString";
})(Type = exports.Type || (exports.Type = {}));
const features = () => ({
    type: Type.Collection,
    features: []
});
const geometry = (type, coordinates) => ({
    type,
    coordinates
});
function trackFromGPX(node, maxPossibleSpeed = 0) {
    let count = 0;
    let topSpeed = 0;
    let totalTime = 0;
    let totalSpeed = 0;
    let totalDistance = 0;
    const points = Array.from(node.getElementsByTagName('trkseg'))
        .map(segment => index_1.gpx.line(segment, 'trkpt'))
        .filter(line => line !== null && line[0].length > 0);
    const track = points.map(line => {
        totalTime += index_1.measure.duration(line);
        totalDistance += index_1.measure.length(line);
        return index_1.measure.simplify(line.map(point => {
            const speed = point[4];
            if (maxPossibleSpeed === 0 || speed < maxPossibleSpeed) {
                count++;
                totalSpeed += speed;
                if (speed > topSpeed) {
                    topSpeed = parseFloat(speed.toFixed(1));
                }
            }
            return point.slice(0, 3);
        }));
    });
    return track.length === 0 || track[0].length === 0
        ? null
        : {
            type: Type.Feature,
            properties: Object.assign(index_1.gpx.properties(node), {
                topSpeed,
                avgSpeed: parseFloat((totalSpeed / count).toFixed(1)),
                duration: totalTime,
                distance: parseFloat(totalDistance.toFixed(2))
            }),
            geometry: track.length === 1
                ? geometry(Type.Line, track[0])
                : geometry(Type.MultiLine, track)
        };
}
const routeFromGPX = (node) => ({
    type: Type.Feature,
    properties: index_1.gpx.properties(node),
    geometry: geometry(Type.Line, index_1.gpx.line(node, 'rtept'))
});
const pointFromGPX = (node) => ({
    type: Type.Feature,
    properties: index_1.gpx.properties(node, ['sym']),
    geometry: geometry(Type.Point, index_1.gpx.location(node))
});
function pointFromKML(node) {
    const location = index_1.kml.location(node);
    return location == null
        ? null
        : {
            type: Type.Feature,
            properties: index_1.kml.properties(node, ['sym']),
            geometry: geometry(Type.Point, location)
        };
}
const lineFeature = (type, node, lines) => ({
    type: Type.Feature,
    properties: index_1.kml.properties(node),
    geometry: geometry(type, lines)
});
function lineFromKML(node) {
    const lines = index_1.kml.line(node);
    return lines != null
        ? lines.length > 1
            ? lineFeature(Type.MultiLine, node, lines)
            : lineFeature(Type.Line, node, lines[0])
        : null;
}
const parseNodes = (doc, name, parser) => Array.from(doc.getElementsByTagName(name))
    .map(parser)
    .filter(f => tools_1.is.value(f));
function featuresFromGPX(gpxString) {
    const geo = features();
    let gpx = null;
    try {
        gpx = new xmldom_1.DOMParser().parseFromString(gpxString);
    }
    catch (err) {
        console.error(err);
        return null;
    }
    const tracks = parseNodes(gpx, 'trk', trackFromGPX);
    const routes = parseNodes(gpx, 'rte', routeFromGPX);
    const points = parseNodes(gpx, 'wpt', pointFromGPX);
    geo.features = geo.features.concat(tracks, routes, points);
    return geo;
}
function postProcess(features, transformer = null) {
    if (transformer !== null) {
        features.forEach(f => {
            f.properties = transformer(f.properties);
        });
    }
    return features;
}
const featuresFromKML = (kml, transformer = null) => {
    const geo = features();
    let doc = null;
    if (tools_1.is.text(kml)) {
        kml = kml.replace(/[\r\n]/g, '').replace(/>\s+</g, '><');
        try {
            doc = new xmldom_1.DOMParser().parseFromString(kml);
        }
        catch (err) {
            console.error(err);
            return null;
        }
    }
    else {
        doc = kml;
    }
    if (doc !== null) {
        const lines = parseNodes(doc, 'Placemark', lineFromKML);
        const points = parseNodes(doc, 'Placemark', pointFromKML);
        geo.features = postProcess(geo.features.concat(lines, points), transformer);
    }
    return geo;
};
exports.geoJSON = {
    Type,
    features,
    geometry,
    featuresFromGPX,
    featuresFromKML
};