@theseam/ui-common 0.3.1 → 0.3.2

package/bundles/theseam-ui-common-utils.umd.js

@@ -1,12 +1,15 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/operators'), require('rxjs'), require('@marklb/file-type')) :
-    typeof define === 'function' && define.amd ? define('@theseam/ui-common/utils', ['exports', 'rxjs/operators', 'rxjs', '@marklb/file-type'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.theseam = global.theseam || {}, global.theseam["ui-common"] = global.theseam["ui-common"] || {}, global.theseam["ui-common"].utils = {}), global.rxjs.operators, global.rxjs, global.fileType));
-})(this, (function (exports, operators, rxjs, fileType) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('rxjs/operators'), require('rxjs'), require('@turf/area'), require('@turf/helpers'), require('@turf/kinks'), require('@angular/core'), require('@marklb/file-type'), require('shpjs')) :
+    typeof define === 'function' && define.amd ? define('@theseam/ui-common/utils', ['exports', 'rxjs/operators', 'rxjs', '@turf/area', '@turf/helpers', '@turf/kinks', '@angular/core', '@marklb/file-type', 'shpjs'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.theseam = global.theseam || {}, global.theseam["ui-common"] = global.theseam["ui-common"] || {}, global.theseam["ui-common"].utils = {}), global.rxjs.operators, global.rxjs, global.area, global.helpers, global.kinks, global.ng.core, global.fileType, global.shp));
+})(this, (function (exports, operators, rxjs, area, helpers, kinks, core, fileType, shp) { 'use strict';
 
     function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+    var area__default = /*#__PURE__*/_interopDefaultLegacy(area);
+    var kinks__default = /*#__PURE__*/_interopDefaultLegacy(kinks);
     var fileType__default = /*#__PURE__*/_interopDefaultLegacy(fileType);
+    var shp__default = /*#__PURE__*/_interopDefaultLegacy(shp);
 
     /**
      *
@@ -315,6 +318,80 @@
         return activatedRoute.snapshot.url.length === 0;
     }
 
+    // TODO: Make this more thorough and maybe error on unrecognized.
+    function coerceFeatureCollection(value) {
+        return parseValue(value);
+    }
+    /**
+     * Parses the value to a FeatureCollection object or null if it is not a
+     * FeatureCollection.
+     */
+    function parseValue(value) {
+        var _value = parseStringValue(value);
+        if (isFeatureCollectionValue(_value)) {
+            return _value;
+        }
+        return null;
+    }
+    /**
+     * Tries to parse the value to an object, in case the value is a stringified
+     * json.
+     */
+    function parseStringValue(value) {
+        if (typeof value === 'string') {
+            try {
+                return JSON.parse(value);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        return value;
+    }
+    /**
+     * Checks if the value is a FeatureCollection.
+     *
+     * NOTE: This is not a thorough FeatureCollection check. It only checks that the
+     * value is an object resembling a GeoJSON.FeatureCollection, enough for the
+     * validator.
+     */
+    function isFeatureCollectionValue(value) {
+        if (value === undefined || value === null) {
+            return false;
+        }
+        return value.type === 'FeatureCollection' && Array.isArray(value.features);
+    }
+
+    /**
+     *
+     */
+    function geoJsonToArea(geoJson, units) {
+        if (units === void 0) { units = 'acres'; }
+        var area_mSqr = area__default["default"](geoJson);
+        var acres = helpers.convertArea(area_mSqr, 'meters', units);
+        return acres;
+    }
+
+    var IS_FEATURE_COLLECTION_VALIDATOR_NAME = 'is-feature-collection';
+    function isFeatureCollectionValidator() {
+        return function (control) {
+            var _a;
+            // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+            if (isEmptyInputValue(control.value)) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            var value = coerceFeatureCollection(control.value);
+            if (value === null) {
+                return _a = {},
+                    _a[IS_FEATURE_COLLECTION_VALIDATOR_NAME] = {
+                        reason: "Must be a FeatureCollection.",
+                    },
+                    _a;
+            }
+            return null;
+        };
+    }
+
     /*! *****************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -633,6 +710,521 @@
         return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
     }
 
+    /**
+     * Returns true if the GeoJSON is only specifies geometries.
+     */
+    function isOnlyGeometryTypes(featureCollection, types) {
+        var e_1, _a;
+        if (types.length === 0) {
+            if (featureCollection.features.length > 0) {
+                // If no types are specified then there can't be any specified types found.
+                return false;
+            }
+            else {
+                // If no types are specified and there are no features then there is
+                // nothing to say a specified type isn't found.
+                return true;
+            }
+        }
+        try {
+            for (var _b = __values(featureCollection.features), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var f = _c.value;
+                if (types.indexOf(f.geometry.type) === -1) {
+                    return false;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return true;
+    }
+
+    var IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = 'is-only-geometry-types';
+    function isOnlyGeometryTypesValidator(types) {
+        return function (control) {
+            var _a;
+            // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+            if (isEmptyInputValue(control.value)) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            var value = coerceFeatureCollection(control.value);
+            if (value === null) {
+                // If there isn't a FeatureCollection then there is nothing to validate.
+                // Use 'isFeatureCollection' to validate the value is a FeatureCollection.
+                return null;
+            }
+            if (!isOnlyGeometryTypes(value, types)) {
+                var typesNotAllowed = value.features
+                    .map(function (f) { return f.geometry.type; })
+                    .filter(function (t) { return types.indexOf(t) === -1; });
+                var distinctTypesNotAllowed = Array.from(new Set(typesNotAllowed));
+                return _a = {},
+                    _a[IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME] = {
+                        reason: "Only geometry type" + (types.length === 1 ? '' : 's') + " " + types.join(', ') + " allowed.",
+                        notAllowedGeometryTypesFound: distinctTypesNotAllowed,
+                    },
+                    _a;
+            }
+            return null;
+        };
+    }
+
+    /**
+     * Merge Polygon and MultiPolygon geometries into a single MultiPolygon. Any
+     * properties, other than 'coordinates', of the Polygons and MultiPolygons will
+     * be lost.
+     *
+     * NOTE: Polygons and MultPolygons in a GeometryCollection will not be merged.
+     */
+    function mergePolygons(featureCollection) {
+        var _a;
+        var multiPolygon = {
+            type: 'MultiPolygon',
+            coordinates: [],
+        };
+        for (var i = 0; i < featureCollection.features.length; i++) {
+            var f = featureCollection.features[i];
+            if (f.geometry.type === 'Polygon') {
+                multiPolygon.coordinates.push(f.geometry.coordinates);
+                featureCollection.features.splice(i, 1);
+                i--;
+            }
+            else if (f.geometry.type === 'MultiPolygon') {
+                (_a = multiPolygon.coordinates).push.apply(_a, __spreadArray([], __read(f.geometry.coordinates)));
+                featureCollection.features.splice(i, 1);
+                i--;
+            }
+        }
+        if (multiPolygon.coordinates.length > 0) {
+            var feature = {
+                type: 'Feature',
+                geometry: multiPolygon,
+                properties: {},
+            };
+            featureCollection.features.push(feature);
+        }
+    }
+
+    var NO_INNER_RINGS_VALIDATOR_NAME = 'no-inner-rings';
+    /**
+     * Validates that a FeatureCollection does not contain any Polygon with inner
+     * rings("holes").
+     *
+     * NOTE: Only considers Polygon and MultiPolygon. Does not consider
+     * GeometryCollection.
+     */
+    function noInnerRingsValidator() {
+        return function (control) {
+            var _a;
+            // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+            if (isEmptyInputValue(control.value)) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            var value = coerceFeatureCollection(control.value);
+            if (value === null) {
+                // If there isn't a FeatureCollection then there is nothing to validate.
+                // Use 'isFeatureCollection' to validate the value is a FeatureCollection.
+                return null;
+            }
+            if (hasInnerRing(value)) {
+                return _a = {},
+                    _a[NO_INNER_RINGS_VALIDATOR_NAME] = {
+                        reason: "A shape cannot have an inner ring."
+                    },
+                    _a;
+            }
+            return null;
+        };
+    }
+    /**
+     * Checks if a FeatureCollection contains any geometries with an inner
+     * ring("hole").
+     *
+     * NOTE: Does not consider GeometryCollection.
+     */
+    function hasInnerRing(featureCollection) {
+        var e_1, _a, e_2, _b;
+        try {
+            for (var _c = __values(featureCollection.features), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var f = _d.value;
+                // The spec says the right-hand rule must be followed, but also specifies
+                // that tools should not reject polygons that do not follow the right-hand
+                // rule. It does specify that the first ring must be the exterior ring and
+                // the others must be the interior. So, this should be safe to just check
+                // if there are multiple rings, instead of checking their winding orders.
+                //
+                // Polygon spec: https://datatracker.ietf.org/doc/html/rfc7946#section-3.1.6
+                if (f.geometry.type === 'Polygon') {
+                    if (f.geometry.coordinates.length > 1) {
+                        return true;
+                    }
+                }
+                else if (f.geometry.type === 'MultiPolygon') {
+                    try {
+                        for (var _e = (e_2 = void 0, __values(f.geometry.coordinates)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var coords = _f.value;
+                            if (coords.length > 1) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    }
+
+    var kinkableGeometryTypes = ['LineString', 'MultiLineString', 'MultiPolygon', 'Polygon'];
+    var NO_KINKS_VALIDATOR_NAME = 'no-kinks';
+    function noKinksValidator() {
+        return function (control) {
+            var e_1, _a, _b;
+            // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+            if (isEmptyInputValue(control.value)) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            var value = coerceFeatureCollection(control.value);
+            if (value === null) {
+                return null;
+            }
+            var kinksFound = [];
+            try {
+                for (var _c = __values(value.features), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var f = _d.value;
+                    if (kinkableGeometryTypes.indexOf(f.geometry.type) !== -1) {
+                        var _kinks = kinks__default["default"](f);
+                        if (_kinks.features.length > 0) {
+                            kinksFound.push({
+                                feature: f,
+                                kinks: _kinks,
+                            });
+                        }
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (kinksFound.length > 0) {
+                return _b = {},
+                    _b[NO_KINKS_VALIDATOR_NAME] = {
+                        reason: 'Paths should not intersect themself.',
+                        featuresWithKink: kinksFound,
+                    },
+                    _b;
+            }
+            return null;
+        };
+    }
+
+    // import { Buffer } from 'buffer/'
+    var Buffer$1 = require('buffer/').Buffer;
+    function readFileAsync(file) {
+        return new Promise(function (resolve, reject) {
+            var reader = new FileReader();
+            reader.onload = function () {
+                resolve(reader.result);
+            };
+            reader.readAsArrayBuffer(file);
+        });
+    }
+    function readFileAsDataUrlAsync(file) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, new Promise(function (resolve, reject) {
+                        var reader = new FileReader();
+                        reader.onload = function () {
+                            resolve(reader.result);
+                        };
+                        reader.readAsDataURL(file);
+                    })];
+            });
+        });
+    }
+    function fileBufferToBlob(fileBuffer, defaultMime) {
+        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var fType, mime, blob;
+            return __generator(this, function (_a) {
+                fType = fileType__default["default"](fileBuffer);
+                mime = (fType) ? fType.mime : defaultMime;
+                blob = new Blob([fileBuffer], { type: mime });
+                return [2 /*return*/, blob];
+            });
+        });
+    }
+    function fileBufferToObjectUrl(fileBuffer, defaultMime) {
+        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var file, fileURL;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, fileBufferToBlob(fileBuffer, defaultMime)];
+                    case 1:
+                        file = _a.sent();
+                        fileURL = URL.createObjectURL(file);
+                        return [2 /*return*/, fileURL];
+                }
+            });
+        });
+    }
+    function fileDataFromBuffer(fileBuffer, defaultMime) {
+        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var _fileBuffer, fType, ext, mime, blob, fileData;
+            return __generator(this, function (_a) {
+                _fileBuffer = Buffer$1.from(fileBuffer);
+                fType = fileType__default["default"](_fileBuffer);
+                ext = fType && fType.ext || undefined;
+                mime = fType ? fType.mime : defaultMime;
+                blob = new Blob([_fileBuffer], { type: mime });
+                fileData = { ext: ext, mime: mime, blob: blob };
+                return [2 /*return*/, fileData];
+            });
+        });
+    }
+    function openBlob(blob, target, filename) {
+        // NOTE: IE and MSEdge do not allow Blob resources as a source for
+        // tabs or iframes. msSaveOrOpenBlob is used as a workaround. I
+        // haven't been able to find a way to just open the Blob file in
+        // another tab yet for IE or MSEdge.
+        if (window.navigator.msSaveOrOpenBlob) {
+            window.navigator.msSaveOrOpenBlob(blob, filename);
+        }
+        else {
+            var url = URL.createObjectURL(blob);
+            var win = window.open(url, target);
+            // TODO: Consider if always setting opener to null is to restrictive
+            // if (win && target && target.toLowerCase() === '_blank') {
+            //   win.opener = null
+            // }
+        }
+    }
+
+    /** Returns object without property */
+    function withoutProperty(obj, propName) {
+        var _a = obj, _b = propName, _ = _a[_b], without = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+        return without;
+    }
+    /** Returns object without properties */
+    function withoutProperties(obj, propNames) {
+        var e_1, _c;
+        var without = obj;
+        try {
+            for (var propNames_1 = __values(propNames), propNames_1_1 = propNames_1.next(); !propNames_1_1.done; propNames_1_1 = propNames_1.next()) {
+                var propName = propNames_1_1.value;
+                without = withoutProperty(without, propName);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (propNames_1_1 && !propNames_1_1.done && (_c = propNames_1.return)) _c.call(propNames_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return without;
+    }
+    /** Delete property of object */
+    function deleteProperty(obj, propName) {
+        if (obj.hasOwnProperty(propName)) {
+            delete obj[propName];
+        }
+    }
+    /** Delete properties of object */
+    function deleteProperties(obj, propNames) {
+        var e_2, _c;
+        try {
+            for (var propNames_2 = __values(propNames), propNames_2_1 = propNames_2.next(); !propNames_2_1.done; propNames_2_1 = propNames_2.next()) {
+                var propName = propNames_2_1.value;
+                deleteProperty(obj, propName);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (propNames_2_1 && !propNames_2_1.done && (_c = propNames_2.return)) _c.call(propNames_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+
+    var Buffer = require('buffer/').Buffer;
+    /**
+     * Reads a File, or buffer of file content, in GeoJSON or ESRI Shapefile format
+     * and returns a GeoJSON `FeatureCollection`.
+     */
+    function readGeoFile(fileOrBuffer) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var buffer, e_1;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, coerceFileOrBufferToBuffer(fileOrBuffer)];
+                    case 1:
+                        buffer = _b.sent();
+                        if (!isShpFile(buffer)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, parseShpFile(buffer)];
+                    case 2: return [2 /*return*/, _b.sent()];
+                    case 3:
+                        if (!(((_a = fileType__default["default"](buffer)) === null || _a === void 0 ? void 0 : _a.mime) === 'application/zip')) return [3 /*break*/, 7];
+                        _b.label = 4;
+                    case 4:
+                        _b.trys.push([4, 6, , 7]);
+                        return [4 /*yield*/, parseShpZip(buffer)];
+                    case 5: return [2 /*return*/, _b.sent()];
+                    case 6:
+                        e_1 = _b.sent();
+                        // NOTE: If 'shpjs' updates or we switch to a fork, where it doesn't use
+                        // node buffers, then we can remove this rethrow.
+                        if (core.isDevMode()) {
+                            if (e_1.message === 'nodebuffer is not supported by this platform') {
+                                console.warn('Try adding Buffer polyfill.\n' +
+                                    'Install: npm install buffer\n' +
+                                    'Add `global.Buffer = global.Buffer || require(\'buffer\').Buffer` to "src/polyfills.ts"');
+                            }
+                        }
+                        throw e_1;
+                    case 7: return [2 /*return*/, parseGeoJson(buffer)];
+                }
+            });
+        });
+    }
+    function coerceFileOrBufferToBuffer(fileOrBuffer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var arrBuf;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(fileOrBuffer instanceof File)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, readFileAsync(fileOrBuffer)];
+                    case 1:
+                        arrBuf = _b.sent();
+                        return [2 /*return*/, Buffer.from(arrBuf)];
+                    case 2: return [2 /*return*/, Buffer.from(fileOrBuffer)];
+                }
+            });
+        });
+    }
+    // NOTE: Our current version of file-type does not detect shp files. We can
+    // remove this function when file-types is upgraded.
+    function isShpFile(buffer) {
+        var header = [0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+        var offset = 2;
+        if (buffer.length < (header.length + offset)) {
+            return false;
+        }
+        for (var i = 0; i < header.length; i++) {
+            if (header[i] !== buffer[i + offset]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    function parseShpFile(buffer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var geometries, featCollection;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, shp__default["default"].parseShp(buffer, undefined)];
+                    case 1:
+                        geometries = _b.sent();
+                        featCollection = {
+                            type: 'FeatureCollection',
+                            features: geometries.map(function (geom) { return ({
+                                type: 'Feature',
+                                geometry: geom,
+                                properties: {}
+                            }); })
+                        };
+                        return [2 /*return*/, featCollection];
+                }
+            });
+        });
+    }
+    function parseShpZip(buffer) {
+        return __awaiter(this, void 0, void 0, function () {
+            var featCollection;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, shp__default["default"].parseZip(buffer, undefined)];
+                    case 1:
+                        featCollection = _b.sent();
+                        if (Array.isArray(featCollection)) {
+                            if (featCollection.length === 0) {
+                                throw Error("Shape data not found.");
+                            }
+                            else if (featCollection.length > 1) {
+                                throw Error("Multiple shape files not supported.");
+                            }
+                            featCollection = featCollection[0];
+                        }
+                        return [2 /*return*/, withoutProperty(featCollection, 'fileName')];
+                }
+            });
+        });
+    }
+    function parseGeoJson(buffer) {
+        var json = JSON.parse(buffer.toString());
+        if ((json === null || json === void 0 ? void 0 : json.type) === 'FeatureCollection' && Array.isArray(json === null || json === void 0 ? void 0 : json.features)) {
+            return json;
+        }
+        throw Error("Unable to parse as GeoJSON.");
+    }
+
+    /**
+     * Split all MultiPolygon into Polygon. Any properties, other than
+     * 'coordinates', of the MultiPolygons will be lost.
+     *
+     * NOTE: MultiPolygons in a GeometryCollection will not be split.
+     */
+    function splitMultiPolygons(featureCollection) {
+        var _a;
+        for (var i = 0; i < featureCollection.features.length; i++) {
+            if (featureCollection.features[i]) {
+                var geometry = featureCollection.features[i].geometry;
+                if (geometry.type === 'MultiPolygon') {
+                    var features = splitMultPolygon(geometry).map(function (p) { return ({
+                        type: 'Feature',
+                        geometry: p,
+                        properties: {},
+                    }); });
+                    (_a = featureCollection.features).splice.apply(_a, __spreadArray([i, 1], __read(features)));
+                    i += Math.max(features.length - 1, 0);
+                }
+            }
+        }
+    }
+    function splitMultPolygon(multiPolygon) {
+        return multiPolygon.coordinates.map(function (c) { return ({
+            type: 'Polygon',
+            coordinates: c,
+        }); });
+    }
+
     // Based on source: https://github.com/sindresorhus/array-move/blob/main/index.js
     /**
       Moves the item to the new position in the input array. Useful for huge arrays
@@ -767,138 +1359,6 @@
         });
     }
 
-    /** Returns object without property */
-    function withoutProperty(obj, propName) {
-        var _a = obj, _b = propName, _ = _a[_b], without = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-        return without;
-    }
-    /** Returns object without properties */
-    function withoutProperties(obj, propNames) {
-        var e_1, _c;
-        var without = obj;
-        try {
-            for (var propNames_1 = __values(propNames), propNames_1_1 = propNames_1.next(); !propNames_1_1.done; propNames_1_1 = propNames_1.next()) {
-                var propName = propNames_1_1.value;
-                without = withoutProperty(without, propName);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (propNames_1_1 && !propNames_1_1.done && (_c = propNames_1.return)) _c.call(propNames_1);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return without;
-    }
-    /** Delete property of object */
-    function deleteProperty(obj, propName) {
-        if (obj.hasOwnProperty(propName)) {
-            delete obj[propName];
-        }
-    }
-    /** Delete properties of object */
-    function deleteProperties(obj, propNames) {
-        var e_2, _c;
-        try {
-            for (var propNames_2 = __values(propNames), propNames_2_1 = propNames_2.next(); !propNames_2_1.done; propNames_2_1 = propNames_2.next()) {
-                var propName = propNames_2_1.value;
-                deleteProperty(obj, propName);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (propNames_2_1 && !propNames_2_1.done && (_c = propNames_2.return)) _c.call(propNames_2);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-    }
-
-    // import { Buffer } from 'buffer/'
-    var Buffer = require('buffer/').Buffer;
-    function readFileAsync(file) {
-        return new Promise(function (resolve, reject) {
-            var reader = new FileReader();
-            reader.onload = function () {
-                resolve(reader.result);
-            };
-            reader.readAsArrayBuffer(file);
-        });
-    }
-    function readFileAsDataUrlAsync(file) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        var reader = new FileReader();
-                        reader.onload = function () {
-                            resolve(reader.result);
-                        };
-                        reader.readAsDataURL(file);
-                    })];
-            });
-        });
-    }
-    function fileBufferToBlob(fileBuffer, defaultMime) {
-        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var fType, mime, blob;
-            return __generator(this, function (_a) {
-                fType = fileType__default["default"](fileBuffer);
-                mime = (fType) ? fType.mime : defaultMime;
-                blob = new Blob([fileBuffer], { type: mime });
-                return [2 /*return*/, blob];
-            });
-        });
-    }
-    function fileBufferToObjectUrl(fileBuffer, defaultMime) {
-        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var file, fileURL;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, fileBufferToBlob(fileBuffer, defaultMime)];
-                    case 1:
-                        file = _a.sent();
-                        fileURL = URL.createObjectURL(file);
-                        return [2 /*return*/, fileURL];
-                }
-            });
-        });
-    }
-    function fileDataFromBuffer(fileBuffer, defaultMime) {
-        if (defaultMime === void 0) { defaultMime = 'application/octet-stream'; }
-        return __awaiter(this, void 0, void 0, function () {
-            var _fileBuffer, fType, ext, mime, blob, fileData;
-            return __generator(this, function (_a) {
-                _fileBuffer = Buffer.from(fileBuffer);
-                fType = fileType__default["default"](_fileBuffer);
-                ext = fType && fType.ext || undefined;
-                mime = fType ? fType.mime : defaultMime;
-                blob = new Blob([_fileBuffer], { type: mime });
-                fileData = { ext: ext, mime: mime, blob: blob };
-                return [2 /*return*/, fileData];
-            });
-        });
-    }
-    function openBlob(blob, target, filename) {
-        // NOTE: IE and MSEdge do not allow Blob resources as a source for
-        // tabs or iframes. msSaveOrOpenBlob is used as a workaround. I
-        // haven't been able to find a way to just open the Blob file in
-        // another tab yet for IE or MSEdge.
-        if (window.navigator.msSaveOrOpenBlob) {
-            window.navigator.msSaveOrOpenBlob(blob, filename);
-        }
-        else {
-            var url = URL.createObjectURL(blob);
-            var win = window.open(url, target);
-            // TODO: Consider if always setting opener to null is to restrictive
-            // if (win && target && target.toLowerCase() === '_blank') {
-            //   win.opener = null
-            // }
-        }
-    }
-
     function notNullOrUndefined(value) {
         return value !== null && value !== undefined;
     }
@@ -1276,12 +1736,17 @@
      * Generated bundle index. Do not edit.
      */
 
+    exports.IS_FEATURE_COLLECTION_VALIDATOR_NAME = IS_FEATURE_COLLECTION_VALIDATOR_NAME;
+    exports.IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME;
+    exports.NO_INNER_RINGS_VALIDATOR_NAME = NO_INNER_RINGS_VALIDATOR_NAME;
+    exports.NO_KINKS_VALIDATOR_NAME = NO_KINKS_VALIDATOR_NAME;
     exports.PollingTickerOptions = PollingTickerOptions;
     exports.Refreshable = Refreshable;
     exports.activatedRoutesWithDataProperty = activatedRoutesWithDataProperty;
     exports.arrayMoveImmutable = arrayMoveImmutable;
     exports.arrayMoveMutable = arrayMoveMutable;
     exports.calcPercentage = calcPercentage;
+    exports.coerceFeatureCollection = coerceFeatureCollection;
     exports.createPadding = createPadding;
     exports.deleteProperties = deleteProperties;
     exports.deleteProperty = deleteProperty;
@@ -1289,6 +1754,7 @@
     exports.fileBufferToObjectUrl = fileBufferToObjectUrl;
     exports.fileDataFromBuffer = fileDataFromBuffer;
     exports.fractionalDigitsCount = fractionalDigitsCount;
+    exports.geoJsonToArea = geoJsonToArea;
     exports.getAttribute = getAttribute;
     exports.getClosestWidgetCdkDrag = getClosestWidgetCdkDrag;
     exports.getControlName = getControlName;
@@ -1299,12 +1765,18 @@
     exports.isAbsoluteUrl = isAbsoluteUrl;
     exports.isEmptyInputValue = isEmptyInputValue;
     exports.isEmptyUrlRoute = isEmptyUrlRoute;
+    exports.isFeatureCollectionValidator = isFeatureCollectionValidator;
     exports.isNullOrUndefined = isNullOrUndefined;
     exports.isNumeric = isNumeric;
+    exports.isOnlyGeometryTypes = isOnlyGeometryTypes;
+    exports.isOnlyGeometryTypesValidator = isOnlyGeometryTypesValidator;
     exports.leafChildRoute = leafChildRoute;
     exports.loadStyle = loadStyle;
     exports.loadStyleSheet = loadStyleSheet;
     exports.mapEach = mapEach;
+    exports.mergePolygons = mergePolygons;
+    exports.noInnerRingsValidator = noInnerRingsValidator;
+    exports.noKinksValidator = noKinksValidator;
     exports.notNullOrUndefined = notNullOrUndefined;
     exports.observeControlIsDifferent = observeControlIsDifferent;
     exports.observeControlStatus = observeControlStatus;
@@ -1319,8 +1791,10 @@
     exports.pollingTicker = pollingTicker;
     exports.readFileAsDataUrlAsync = readFileAsDataUrlAsync;
     exports.readFileAsync = readFileAsync;
+    exports.readGeoFile = readGeoFile;
     exports.routeSnapshotPathFull = routeSnapshotPathFull;
     exports.routeSnapshotPathRelative = routeSnapshotPathRelative;
+    exports.splitMultiPolygons = splitMultiPolygons;
     exports.subscriberCount = subscriberCount;
     exports.tapFirst = tapFirst;
     exports.toggleAttribute = toggleAttribute;