@theseam/ui-common 0.3.1 → 0.3.2

package/fesm2015/theseam-ui-common-utils.js

@@ -1,7 +1,12 @@
 import { switchMap, startWith, map, distinctUntilChanged, mapTo, filter, take, pairwise, toArray, tap, shareReplay, publishReplay, refCount, skip } from 'rxjs/operators';
 import { of, merge, interval, from, combineLatest, Observable, isObservable, BehaviorSubject, Subject } from 'rxjs';
-import { __rest, __awaiter } from 'tslib';
+import area from '@turf/area';
+import { convertArea } from '@turf/helpers';
+import kinks from '@turf/kinks';
+import { __awaiter, __rest } from 'tslib';
+import { isDevMode } from '@angular/core';
 import fileType from '@marklb/file-type';
+import shp from 'shpjs';
 
 /**
  *
@@ -307,6 +312,476 @@ function isEmptyUrlRoute(activatedRoute) {
     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) {
+    const _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 = 'acres') {
+    const area_mSqr = area(geoJson);
+    const acres = convertArea(area_mSqr, 'meters', units);
+    return acres;
+}
+
+const IS_FEATURE_COLLECTION_VALIDATOR_NAME = 'is-feature-collection';
+function isFeatureCollectionValidator() {
+    return (control) => {
+        // 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
+        }
+        const value = coerceFeatureCollection(control.value);
+        if (value === null) {
+            return {
+                [IS_FEATURE_COLLECTION_VALIDATOR_NAME]: {
+                    reason: `Must be a FeatureCollection.`,
+                }
+            };
+        }
+        return null;
+    };
+}
+
+/**
+ * Returns true if the GeoJSON is only specifies geometries.
+ */
+function isOnlyGeometryTypes(featureCollection, types) {
+    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;
+        }
+    }
+    for (const f of featureCollection.features) {
+        if (types.indexOf(f.geometry.type) === -1) {
+            return false;
+        }
+    }
+    return true;
+}
+
+const IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = 'is-only-geometry-types';
+function isOnlyGeometryTypesValidator(types) {
+    return (control) => {
+        // 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
+        }
+        const 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)) {
+            const typesNotAllowed = value.features
+                .map(f => f.geometry.type)
+                .filter(t => types.indexOf(t) === -1);
+            const distinctTypesNotAllowed = Array.from(new Set(typesNotAllowed));
+            return {
+                [IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME]: {
+                    reason: `Only geometry type${(types.length === 1 ? '' : 's')} ${types.join(', ')} allowed.`,
+                    notAllowedGeometryTypesFound: distinctTypesNotAllowed,
+                }
+            };
+        }
+        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) {
+    const multiPolygon = {
+        type: 'MultiPolygon',
+        coordinates: [],
+    };
+    for (let i = 0; i < featureCollection.features.length; i++) {
+        const 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') {
+            multiPolygon.coordinates.push(...f.geometry.coordinates);
+            featureCollection.features.splice(i, 1);
+            i--;
+        }
+    }
+    if (multiPolygon.coordinates.length > 0) {
+        const feature = {
+            type: 'Feature',
+            geometry: multiPolygon,
+            properties: {},
+        };
+        featureCollection.features.push(feature);
+    }
+}
+
+const 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 (control) => {
+        // 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
+        }
+        const 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 {
+                [NO_INNER_RINGS_VALIDATOR_NAME]: {
+                    reason: `A shape cannot have an inner ring.`
+                }
+            };
+        }
+        return null;
+    };
+}
+/**
+ * Checks if a FeatureCollection contains any geometries with an inner
+ * ring("hole").
+ *
+ * NOTE: Does not consider GeometryCollection.
+ */
+function hasInnerRing(featureCollection) {
+    for (const f of featureCollection.features) {
+        // 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') {
+            for (const coords of f.geometry.coordinates) {
+                if (coords.length > 1) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+const kinkableGeometryTypes = ['LineString', 'MultiLineString', 'MultiPolygon', 'Polygon'];
+const NO_KINKS_VALIDATOR_NAME = 'no-kinks';
+function noKinksValidator() {
+    return (control) => {
+        // 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
+        }
+        const value = coerceFeatureCollection(control.value);
+        if (value === null) {
+            return null;
+        }
+        const kinksFound = [];
+        for (const f of value.features) {
+            if (kinkableGeometryTypes.indexOf(f.geometry.type) !== -1) {
+                const _kinks = kinks(f);
+                if (_kinks.features.length > 0) {
+                    kinksFound.push({
+                        feature: f,
+                        kinks: _kinks,
+                    });
+                }
+            }
+        }
+        if (kinksFound.length > 0) {
+            return {
+                [NO_KINKS_VALIDATOR_NAME]: {
+                    reason: 'Paths should not intersect themself.',
+                    featuresWithKink: kinksFound,
+                }
+            };
+        }
+        return null;
+    };
+}
+
+// import { Buffer } from 'buffer/'
+const Buffer$1 = require('buffer/').Buffer;
+function readFileAsync(file) {
+    return new Promise((resolve, reject) => {
+        const reader = new FileReader();
+        reader.onload = () => {
+            resolve(reader.result);
+        };
+        reader.readAsArrayBuffer(file);
+    });
+}
+function readFileAsDataUrlAsync(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onload = () => {
+                resolve(reader.result);
+            };
+            reader.readAsDataURL(file);
+        });
+    });
+}
+function fileBufferToBlob(fileBuffer, defaultMime = 'application/octet-stream') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fType = fileType(fileBuffer);
+        const mime = (fType) ? fType.mime : defaultMime;
+        const blob = new Blob([fileBuffer], { type: mime });
+        return blob;
+    });
+}
+function fileBufferToObjectUrl(fileBuffer, defaultMime = 'application/octet-stream') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const file = yield fileBufferToBlob(fileBuffer, defaultMime);
+        const fileURL = URL.createObjectURL(file);
+        return fileURL;
+    });
+}
+function fileDataFromBuffer(fileBuffer, defaultMime = 'application/octet-stream') {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _fileBuffer = Buffer$1.from(fileBuffer);
+        const fType = fileType(_fileBuffer);
+        const ext = fType && fType.ext || undefined;
+        const mime = fType ? fType.mime : defaultMime;
+        const blob = new Blob([_fileBuffer], { type: mime });
+        const fileData = { ext, mime, blob };
+        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 {
+        const url = URL.createObjectURL(blob);
+        const 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) {
+    const _a = obj, _b = propName, _ = _a[_b], without = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    return without;
+}
+/** Returns object without properties */
+function withoutProperties(obj, propNames) {
+    let without = obj;
+    for (const propName of propNames) {
+        without = withoutProperty(without, propName);
+    }
+    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) {
+    for (const propName of propNames) {
+        deleteProperty(obj, propName);
+    }
+}
+
+const 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* () {
+        const buffer = yield coerceFileOrBufferToBuffer(fileOrBuffer);
+        if (isShpFile(buffer)) {
+            return yield parseShpFile(buffer);
+        }
+        else if (((_a = fileType(buffer)) === null || _a === void 0 ? void 0 : _a.mime) === 'application/zip') {
+            try {
+                return yield parseShpZip(buffer);
+            }
+            catch (e) {
+                // NOTE: If 'shpjs' updates or we switch to a fork, where it doesn't use
+                // node buffers, then we can remove this rethrow.
+                if (isDevMode()) {
+                    if (e.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;
+            }
+        }
+        return parseGeoJson(buffer);
+    });
+}
+function coerceFileOrBufferToBuffer(fileOrBuffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (fileOrBuffer instanceof File) {
+            const arrBuf = yield readFileAsync(fileOrBuffer);
+            return Buffer.from(arrBuf);
+        }
+        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) {
+    const header = [0x27, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00];
+    const offset = 2;
+    if (buffer.length < (header.length + offset)) {
+        return false;
+    }
+    for (let 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* () {
+        const geometries = yield shp.parseShp(buffer, undefined);
+        const featCollection = {
+            type: 'FeatureCollection',
+            features: geometries.map(geom => ({
+                type: 'Feature',
+                geometry: geom,
+                properties: {}
+            }))
+        };
+        return featCollection;
+    });
+}
+function parseShpZip(buffer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let featCollection = yield shp.parseZip(buffer, undefined);
+        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 withoutProperty(featCollection, 'fileName');
+    });
+}
+function parseGeoJson(buffer) {
+    const 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) {
+    for (let i = 0; i < featureCollection.features.length; i++) {
+        if (featureCollection.features[i]) {
+            const geometry = featureCollection.features[i].geometry;
+            if (geometry.type === 'MultiPolygon') {
+                const features = splitMultPolygon(geometry).map(p => ({
+                    type: 'Feature',
+                    geometry: p,
+                    properties: {},
+                }));
+                featureCollection.features.splice(i, 1, ...features);
+                i += Math.max(features.length - 1, 0);
+            }
+        }
+    }
+}
+function splitMultPolygon(multiPolygon) {
+    return multiPolygon.coordinates.map(c => ({
+        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
@@ -441,98 +916,6 @@ function loadStyleSheet(path) {
     });
 }
 
-/** Returns object without property */
-function withoutProperty(obj, propName) {
-    const _a = obj, _b = propName, _ = _a[_b], without = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-    return without;
-}
-/** Returns object without properties */
-function withoutProperties(obj, propNames) {
-    let without = obj;
-    for (const propName of propNames) {
-        without = withoutProperty(without, propName);
-    }
-    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) {
-    for (const propName of propNames) {
-        deleteProperty(obj, propName);
-    }
-}
-
-// import { Buffer } from 'buffer/'
-const Buffer = require('buffer/').Buffer;
-function readFileAsync(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            resolve(reader.result);
-        };
-        reader.readAsArrayBuffer(file);
-    });
-}
-function readFileAsDataUrlAsync(file) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return new Promise((resolve, reject) => {
-            const reader = new FileReader();
-            reader.onload = () => {
-                resolve(reader.result);
-            };
-            reader.readAsDataURL(file);
-        });
-    });
-}
-function fileBufferToBlob(fileBuffer, defaultMime = 'application/octet-stream') {
-    return __awaiter(this, void 0, void 0, function* () {
-        const fType = fileType(fileBuffer);
-        const mime = (fType) ? fType.mime : defaultMime;
-        const blob = new Blob([fileBuffer], { type: mime });
-        return blob;
-    });
-}
-function fileBufferToObjectUrl(fileBuffer, defaultMime = 'application/octet-stream') {
-    return __awaiter(this, void 0, void 0, function* () {
-        const file = yield fileBufferToBlob(fileBuffer, defaultMime);
-        const fileURL = URL.createObjectURL(file);
-        return fileURL;
-    });
-}
-function fileDataFromBuffer(fileBuffer, defaultMime = 'application/octet-stream') {
-    return __awaiter(this, void 0, void 0, function* () {
-        const _fileBuffer = Buffer.from(fileBuffer);
-        const fType = fileType(_fileBuffer);
-        const ext = fType && fType.ext || undefined;
-        const mime = fType ? fType.mime : defaultMime;
-        const blob = new Blob([_fileBuffer], { type: mime });
-        const fileData = { ext, mime, blob };
-        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 {
-        const url = URL.createObjectURL(blob);
-        const 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;
 }
@@ -881,5 +1264,5 @@ function fractionalDigitsCount(value) {
  * Generated bundle index. Do not edit.
  */
 
-export { PollingTickerOptions, Refreshable, activatedRoutesWithDataProperty, arrayMoveImmutable, arrayMoveMutable, calcPercentage, createPadding, deleteProperties, deleteProperty, fileBufferToBlob, fileBufferToObjectUrl, fileDataFromBuffer, fractionalDigitsCount, getAttribute, getClosestWidgetCdkDrag, getControlName, getControlPath, hasAttribute, hasProperty, hasRequiredControl, isAbsoluteUrl, isEmptyInputValue, isEmptyUrlRoute, isNullOrUndefined, isNumeric, leafChildRoute, loadStyle, loadStyleSheet, mapEach, notNullOrUndefined, observeControlIsDifferent, observeControlStatus, observeControlValid, observeControlValue, observeControlValueChange, observeQueryList, openBlob, padEnd, padStart, phoneNumberMask, pollingTicker, readFileAsDataUrlAsync, readFileAsync, routeSnapshotPathFull, routeSnapshotPathRelative, subscriberCount, tapFirst, toggleAttribute, waitOnConditionAsync, waitOnNonPendingStatus, willHaveDataProp, withoutProperties, withoutProperty, wrapIntoObservable, ɵ0 };
+export { IS_FEATURE_COLLECTION_VALIDATOR_NAME, IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME, NO_INNER_RINGS_VALIDATOR_NAME, NO_KINKS_VALIDATOR_NAME, PollingTickerOptions, Refreshable, activatedRoutesWithDataProperty, arrayMoveImmutable, arrayMoveMutable, calcPercentage, coerceFeatureCollection, createPadding, deleteProperties, deleteProperty, fileBufferToBlob, fileBufferToObjectUrl, fileDataFromBuffer, fractionalDigitsCount, geoJsonToArea, getAttribute, getClosestWidgetCdkDrag, getControlName, getControlPath, hasAttribute, hasProperty, hasRequiredControl, isAbsoluteUrl, isEmptyInputValue, isEmptyUrlRoute, isFeatureCollectionValidator, isNullOrUndefined, isNumeric, isOnlyGeometryTypes, isOnlyGeometryTypesValidator, leafChildRoute, loadStyle, loadStyleSheet, mapEach, mergePolygons, noInnerRingsValidator, noKinksValidator, notNullOrUndefined, observeControlIsDifferent, observeControlStatus, observeControlValid, observeControlValue, observeControlValueChange, observeQueryList, openBlob, padEnd, padStart, phoneNumberMask, pollingTicker, readFileAsDataUrlAsync, readFileAsync, readGeoFile, routeSnapshotPathFull, routeSnapshotPathRelative, splitMultiPolygons, subscriberCount, tapFirst, toggleAttribute, waitOnConditionAsync, waitOnNonPendingStatus, willHaveDataProp, withoutProperties, withoutProperty, wrapIntoObservable, ɵ0 };
 //# sourceMappingURL=theseam-ui-common-utils.js.map