@theseam/ui-common 0.3.10 → 0.4.0-beta.0

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

@@ -0,0 +1,1314 @@
+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 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';
+
+/**
+ *
+ */
+function getAttribute(element, name) {
+    return element.getAttribute(name);
+}
+
+/**
+ *
+ */
+function hasAttribute(element, name) {
+    return element.hasAttribute(name);
+}
+
+/**
+ * Finds the closest CdkDrag to an element by looking at the DOM.
+ * @param element Element relative to which to look for a cdkDrag.
+ * @param openDialogs References to the currently available cdkDrag.
+ */
+function getClosestWidgetCdkDrag(element, dragDirectives) {
+    let parent = element.nativeElement.parentElement;
+    while (parent && !(parent.classList.contains('cdk-drag') && hasAttribute(parent, 'data-widget-id'))) {
+        parent = parent.parentElement;
+    }
+    const parentId = parent ? getAttribute(parent, 'data-widget-id') : null;
+    return parentId ?
+        dragDirectives.find(drag => getAttribute(drag.getRootElement(), 'data-widget-id') === parentId)
+        : null;
+}
+
+/**
+ * Get the name of the control.
+ *
+ * Example:
+ *
+ * ```js
+ * const group = new FormGroup({
+ *  name: new Control(),
+ *  age: new Control()
+ * })
+ *
+ * for (const c of group.controls) {
+ *   console.log(getControlName(c))
+ * }
+ *
+ * // Output:
+ * // >> 'name'
+ * // >> 'age'
+ * ```
+ */
+function getControlName(c) {
+    if (!c.parent) {
+        return null;
+    }
+    // NOTE: Typed as 'any' because using string for array index is not valid for
+    // array index type, but it works and we actually want the index as a string
+    // anyway.
+    const controls = c.parent.controls;
+    return Object.keys(controls).find(name => c === controls[name]) || null;
+}
+
+/**
+ * Get the path to a control.
+ *
+ * The path is built by walking back the `parent` properties until `parent` is
+ * `null`.
+ *
+ * Example:
+ *
+ * ```js
+ * const group = new FormGroup({
+ *   name: new FormControl(),
+ *   address: new FormGroup({
+ *     city: new FormControl(),
+ *     state: new FormControl()
+ *   })
+ * })
+ *
+ * const control = group.get('address.city')
+ * console.log(getControlPath(control))
+ *
+ * // Output:
+ * >> 'address.city'
+ * ```
+ *
+ */
+function getControlPath(c, path = '') {
+    path = getControlName(c) + path;
+    if (c.parent && getControlName(c.parent)) {
+        path = '.' + path;
+        return getControlPath(c.parent, path);
+    }
+    else {
+        return path;
+    }
+}
+
+/**
+ * Observe the value of a control.
+ */
+function observeControlValue(control) {
+    return of(control)
+        .pipe(switchMap(_control => _control.valueChanges
+        .pipe(startWith(_control.value))));
+}
+
+/**
+ * Observe the changed state of the input value from the time this function is
+ * called.
+ *
+ * When this function is called the value is stored. Each time the control's
+ * value changes the value is compared with the initial value. Currenly the
+ * values are compared as stringified objects using `JSON.stringify`.
+ *
+ * TODO: Allow the value compare implementation to be optionally changed.
+ */
+function observeControlIsDifferent(control) {
+    const _initial = JSON.stringify(control.value);
+    return observeControlValue(control)
+        .pipe(map(value => JSON.stringify(value) !== _initial), distinctUntilChanged());
+}
+
+/**
+ * Wait on the status of a form control to not be `'PENDING'`.
+ *
+ * NOTE: This function is mainly just a work around for an issue where
+ *  `statusChanges` sometimes emits `'Pending'` without emitting another state
+ *  when complete. Seems to happen with async validators if the value changes
+ *  before completing, even if the validator completes(subscription `complete`
+ *  if observable).
+ */
+function waitOnNonPendingStatus(control) {
+    return merge(control.statusChanges, interval(30).pipe(mapTo(control), map(c => c.status)))
+        .pipe(startWith(control.status))
+        .pipe(filter(v => v !== 'PENDING'))
+        .pipe(take(1));
+}
+
+/**
+ * Observe the status of a control using a work around for status not changing
+ * after pending.
+ */
+function observeControlStatus(control) {
+    return of(control)
+        .pipe(switchMap(_control => _control.statusChanges
+        .pipe(startWith(_control.status))
+        .pipe(switchMap(status => status === 'PENDING'
+        ? waitOnNonPendingStatus(control)
+            .pipe(startWith(status))
+        : of(status)))));
+}
+
+/**
+ * Observe the valid state of a control.
+ *
+ * By default `waitOnPending` is false and the control states map to:
+ *  'VALID' => true
+ *  'INVALID' => false
+ *  'PENDING' => false
+ *
+ * If `waitOnPending` is true the valid result when 'PENDING' remains the same
+ *  as it was before 'PENDING' until it is no longer 'PENDING'.
+ */
+function observeControlValid(control, waitOnPending = false) {
+    if (waitOnPending) {
+        return observeControlStatus(control)
+            .pipe(distinctUntilChanged())
+            .pipe(startWith(undefined))
+            .pipe(pairwise())
+            .pipe(map(v => ({ previous: v[0], current: v[1] })))
+            .pipe(map(v => v.current === 'PENDING' ? v.previous : v.current))
+            .pipe(map(status => status === 'VALID'));
+    }
+    else {
+        return observeControlStatus(control)
+            .pipe(distinctUntilChanged())
+            .pipe(map(status => status === 'VALID'));
+    }
+}
+
+/**
+ * Observe the value of a control with the previous.
+ */
+function observeControlValueChange(control) {
+    return observeControlValue(control)
+        .pipe(startWith(undefined), pairwise(), map(v => ({ previous: v[0], current: v[1] })));
+}
+
+// Source: https://stackoverflow.com/a/59361497/7926298
+function hasProperty(style, prop
+// ): style is T & { [P in K]-?: Exclude<T[K], undefined> } {
+) {
+    return style.hasOwnProperty(prop) && style[prop] !== undefined;
+}
+
+/**
+ * Check if control has a required control.
+ *
+ * ----------------------------------------------------------------------------
+ * NOTE: I am not sure about if this should be used or not.
+ *
+ * From my understanding this assumes that all the validators do not have some
+ * unexpected side-effect from being called like this. It could be argued that
+ * the validator is flawed and should be fixed if that is the case, but I am not
+ * convinced that is correct yet.
+ *
+ * An example that I think is valid for this argument: A FormControl configured
+ * to only check validators when a specific condition happens, because of a
+ * reason that it has to do a long process. In that situation should this
+ * function be smart enough to consider that or is it up to the validator to
+ * consider this function possibly being used.
+ *
+ * This seems to assume the required validator will always be a synchronous
+ * validator. That is a valid assumption if thinking about showing a required
+ * state in the UI, but a FormControl does not neccessarily have to be used in
+ * UI. So, I think it could be valid to have an async validator that uses the
+ * name `required` for it error, but I do not have a good example, so I could be
+ * wrong.
+ * ----------------------------------------------------------------------------
+ *
+ * Source: https://gist.github.com/jsdevtom/5589af349a395b37e699b67417ef025b
+ * @experimental
+ * @ignore
+ */
+function hasRequiredControl(abstractControl) {
+    if (abstractControl.validator) {
+        const validator = abstractControl.validator({});
+        if (validator && validator.required) {
+            return true;
+        }
+    }
+    const _abstractControl = abstractControl;
+    if (hasProperty(_abstractControl, 'controls')) {
+        for (const controlName in _abstractControl.controls) {
+            if (_abstractControl.controls[controlName]) {
+                if (hasRequiredControl(_abstractControl.controls[controlName])) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+// Source: https://github.com/angular/angular/blob/master/packages/forms/src/validators.ts#L16
+function isEmptyInputValue(value) {
+    // we don't check for string here so it also works with arrays
+    return value == null || value.length === 0;
+}
+
+function mapEach(predicate) {
+    return (source$) => source$.pipe(switchMap(v => from(v).pipe(map(m => predicate(m)), toArray())));
+}
+
+/**
+ * Like tap, but only calls predicate on first emission.
+ */
+function tapFirst(predicate) {
+    let _initialized = false;
+    return (source$) => source$.pipe(tap(v => {
+        if (!_initialized) {
+            predicate(v);
+            _initialized = true;
+        }
+    }));
+}
+
+function leafChildRoute(activatedRoute) {
+    let route = activatedRoute;
+    while (route.firstChild) {
+        route = route.firstChild;
+    }
+    return route;
+}
+
+function hasRouteConfigDataProp(route, prop) {
+    return !!(route && route.routeConfig && route.routeConfig.data && route.routeConfig.data.hasOwnProperty(prop));
+}
+function hasRouteConfigResolveProp(route, prop) {
+    return !!(route && route.routeConfig && route.routeConfig.resolve && route.routeConfig.resolve.hasOwnProperty(prop));
+}
+function willHaveDataProp(route, prop) {
+    return hasRouteConfigDataProp(route, prop) || hasRouteConfigResolveProp(route, prop);
+}
+
+function activatedRoutesWithDataProperty(prop, mustHaveDefined = false) {
+    const _data = (r) => r.data.pipe(map(_d => ({ route: r, data: _d })));
+    return (source$) => source$.pipe(map(route => leafChildRoute(route)), map(route => route.pathFromRoot), switchMap(routes => combineLatest(routes.map(r => _data(r)))), map(v => v.filter(_v => _v.data.hasOwnProperty(prop))), map(v => mustHaveDefined
+        ? v.filter(_v => willHaveDataProp(_v.route, prop))
+        : v));
+}
+
+function routeSnapshotPathRelative(route) {
+    return route.url.reduce((path, urlSegment) => path += '/' + urlSegment.path, '');
+}
+
+function routeSnapshotPathFull(route) {
+    return route.pathFromRoot.reduce((path, _route) => path += routeSnapshotPathRelative(_route), '');
+}
+
+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);
+    }
+}
+
+function notNullOrUndefined(value) {
+    return value !== null && value !== undefined;
+}
+
+const MIN_MAX_POINTS_VALIDATOR_NAME = 'min-max-points';
+function minMaxPointsValidator(min = 3, max) {
+    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;
+        }
+        if (collectionViolatesMinMax(value, min, max)) {
+            const reason = notNullOrUndefined(max) ?
+                `A polygon must have between ${min} and ${max} points.` :
+                `A polygon must have at least ${min} points.`;
+            return {
+                [MIN_MAX_POINTS_VALIDATOR_NAME]: {
+                    reason: reason
+                }
+            };
+        }
+        return null;
+    };
+}
+/**
+ * Checks if a FeatureCollection contains any geometries with an incomplete polygon.
+ *
+ * NOTE: Does not consider GeometryCollection.
+ */
+function collectionViolatesMinMax(featureCollection, min, max) {
+    for (const f of featureCollection.features) {
+        if (f.geometry.type === 'Polygon') {
+            if (polygonViolatesMinMax(f.geometry.coordinates[0].length, min, max)) {
+                return true;
+            }
+        }
+        else if (f.geometry.type === 'MultiPolygon') {
+            for (const coords of f.geometry.coordinates) {
+                if (polygonViolatesMinMax(coords[0].length, min, max)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+function polygonViolatesMinMax(coordinateLength, min, max) {
+    if (coordinateLength < min || (notNullOrUndefined(max) && max > min && coordinateLength > max)) {
+        return true;
+    }
+    return false;
+}
+
+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 themselves.',
+                    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) {
+    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
+  where absolute performance is needed.
+
+  @param array - The array to modify.
+  @param fromIndex - The index of item to move. If negative, it will begin that
+  many elements from the end.
+  @param toIndex - The index of where to move the item. If negative, it will
+  begin that many elements from the end.
+  @example
+  ```
+  import { arrayMoveMutable } from '@theseam/ui-common/utils';
+
+  const input = ['a', 'b', 'c'];
+  arrayMoveMutable(input, 1, 2);
+  console.log(input);
+  //=> ['a', 'c', 'b']
+  ```
+*/
+function arrayMoveMutable(array, fromIndex, toIndex) {
+    const startIndex = fromIndex < 0 ? array.length + fromIndex : fromIndex;
+    if (startIndex >= 0 && startIndex < array.length) {
+        const endIndex = toIndex < 0 ? array.length + toIndex : toIndex;
+        const [item] = array.splice(fromIndex, 1);
+        array.splice(endIndex, 0, item);
+    }
+}
+/**
+  Clones the given `array`, moves the item to a new position in the new array,
+  and then returns the new array. The given `array` is not mutated.
+
+  @param array - The array with the item to move.
+  @param fromIndex - The index of item to move. If negative, it will begin that
+  many elements from the end.
+  @param toIndex - The index of where to move the item. If negative, it will
+  begin that many elements from the end.
+  @returns A new array with the item moved to the new position.
+  @example
+  ```
+  import { arrayMoveImmutable } from '@theseam/ui-common/utils';
+
+  const input = ['a', 'b', 'c'];
+  const array1 = arrayMoveImmutable(input, 1, 2);
+  console.log(array1);
+  //=> ['a', 'c', 'b']
+
+  const array2 = arrayMoveImmutable(input, -1, 0);
+  console.log(array2);
+  //=> ['c', 'a', 'b']
+
+  const array3 = arrayMoveImmutable(input, -2, -3);
+  console.log(array3);
+  //=> ['b', 'a', 'c']
+  ```
+*/
+function arrayMoveImmutable(array, fromIndex, toIndex) {
+    const newArray = [...array];
+    arrayMoveMutable(newArray, fromIndex, toIndex);
+    return newArray;
+}
+
+function calcPercentage(total, n) {
+    return total && total > 0 ? (n / total) * 100 : 0;
+}
+
+/**
+ * Polyfil for `Element.toggleAttribute`
+ *
+ * Toggles a value without a value. Useful for attributes, such as `disabled`,
+ * `readonly`, and `hidden`, that only needs to exist on the `Element` without
+ * requiring a value.
+ *
+ * Most browsers natively support this feature, but IE, which we still try to
+ * support for at least the main parts of the app, has "Unknown" support of this
+ * feature. Until IE support is dropped this polyfil should be used to toggle an
+ * attribute.
+ *
+ * Source:
+ * https://developer.mozilla.org/en-US/docs/Web/API/Element/toggleAttribute#Polyfill
+ */
+function toggleAttribute(element, name, force) {
+    if (force !== void 0) {
+        force = !!force;
+    }
+    if (element.getAttribute(name) !== null) {
+        if (force) {
+            return true;
+        }
+        element.removeAttribute(name);
+        return false;
+    }
+    else {
+        if (force === false) {
+            return false;
+        }
+        element.setAttribute(name, '');
+        return true;
+    }
+}
+
+const phoneNumberMask = ['(', /[1-9]/, /\d/, /\d/, ')', ' ', /\d/, /\d/, /\d/, '-', /\d/, /\d/, /\d/, /\d/];
+
+function isNullOrUndefined(value) {
+    return value === undefined || value === null;
+}
+
+function loadStyle(content) {
+    return new Promise((resolve, reject) => {
+        const s = document.createElement('style');
+        s.onload = () => resolve(s);
+        s.onerror = (e) => {
+            document.head.removeChild(s);
+            reject(e);
+        };
+        s.innerHTML = content;
+        document.head.appendChild(s);
+    });
+}
+
+function loadStyleSheet(path) {
+    return new Promise((resolve, reject) => {
+        const s = document.createElement('link');
+        s.onload = () => resolve(s);
+        s.onerror = (e) => {
+            document.head.removeChild(s);
+            reject(e);
+        };
+        s.rel = 'stylesheet';
+        s.href = path;
+        document.head.appendChild(s);
+    });
+}
+
+function waitOnConditionAsync(condition, timeoutDuration = -1, throwOnTimeout = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeStart = new Date();
+        const _waitFunc = (callback) => {
+            let conditionSuccess = false;
+            if (condition()) {
+                callback(true);
+                conditionSuccess = true;
+            }
+            if (!conditionSuccess) {
+                const timeNow = new Date();
+                const duration = timeNow - timeStart;
+                if (timeoutDuration > -1 && duration > timeoutDuration) {
+                    if (throwOnTimeout) {
+                        throw new Error('Timed out waiting on condition.');
+                    }
+                    else {
+                        callback(false);
+                    }
+                }
+                setTimeout(() => { _waitFunc(callback); }, 30);
+            }
+        };
+        return new Promise((resolve, reject) => {
+            const fn = (b) => {
+                resolve(b);
+            };
+            _waitFunc(fn);
+        });
+    });
+}
+
+class IntervalTimer {
+    constructor(_callback, intervalTime, startOnInit = true) {
+        this._callback = _callback;
+        this._intervalId = null;
+        this._intervalTime = intervalTime;
+        if (startOnInit) {
+            this.start();
+        }
+    }
+    set intervalTime(time) {
+        this._intervalTime = time;
+    }
+    start() {
+        if (this._intervalId === null) {
+            this._intervalId = window.setInterval(() => {
+                this._callback();
+            }, this._intervalTime);
+        }
+    }
+    stop() {
+        if (this._intervalId !== null) {
+            clearInterval(this._intervalId);
+            this._intervalId = null;
+        }
+    }
+    reset(newIntervalTime) {
+        if (newIntervalTime) {
+            this.intervalTime = newIntervalTime;
+        }
+        this.stop();
+        this.start();
+    }
+}
+// tslint:disable:no-inferrable-types
+class PollingTickerOptions {
+    constructor() {
+        this.emitOnInit = true;
+    }
+}
+// tslint:enable:no-inferrable-types
+// TODO: Simplify complexity.
+/**
+ * Call an action and emits the result to its subscriber on an interval or when
+ * ticker emits. When the ticker emits, the interval time will reset.
+ *
+ * When subscribed to, the action will be called and emitted right away unless
+ * the `emitOnInit` option is set to false.
+ */
+function pollingTicker(action, pollingInterval, ticker, options) {
+    return new Observable((subscriber) => {
+        const _opts = Object.assign(Object.assign({}, (new PollingTickerOptions())), (options || {}));
+        let timer = null;
+        let actionSub = null;
+        let tickerSub = null;
+        try {
+            const handleAction = () => {
+                if (timer) {
+                    timer.stop();
+                }
+                const actionResult = action();
+                if (isObservable(actionResult)) {
+                    if (actionSub) {
+                        actionSub.unsubscribe();
+                    }
+                    actionSub = actionResult.subscribe((v) => {
+                        subscriber.next(v);
+                        if (timer) {
+                            timer.reset();
+                        }
+                    }, (err) => { subscriber.error(err); }, () => {
+                        actionSub = null;
+                        if (timer) {
+                            timer.start();
+                        }
+                    });
+                }
+                else {
+                    subscriber.next(actionResult);
+                }
+                if (timer) {
+                    timer.start();
+                }
+            };
+            if (_opts.emitOnInit) {
+                handleAction();
+            }
+            if (pollingInterval) {
+                timer = new IntervalTimer(() => {
+                    handleAction();
+                }, pollingInterval);
+            }
+            if (ticker) {
+                tickerSub = ticker.subscribe(newPollingInterval => {
+                    if (newPollingInterval && timer) {
+                        timer.stop();
+                        if (newPollingInterval) {
+                            timer.intervalTime = newPollingInterval;
+                        }
+                    }
+                    handleAction();
+                    if (timer) {
+                        timer.reset();
+                    }
+                });
+            }
+        }
+        catch (err) {
+            subscriber.error(err);
+        }
+        return () => {
+            if (timer) {
+                timer.stop();
+            }
+            if (actionSub) {
+                actionSub.unsubscribe();
+            }
+            if (tickerSub) {
+                tickerSub.unsubscribe();
+            }
+        };
+    });
+}
+
+class Refreshable {
+    constructor(action, pollingInterval) {
+        this._initialized = false;
+        this._pollingInterval = new BehaviorSubject(0);
+        this._ticker = new Subject();
+        this._pending = new BehaviorSubject(false);
+        /**
+         * Intercepts the action call to monitor pending state
+         */
+        this._actionHandler = (action) => {
+            return () => {
+                this._pending.next(true);
+                const actionResult = action();
+                if (isObservable(actionResult)) {
+                    return actionResult.pipe(tap(() => { this._pending.next(false); }));
+                }
+                else {
+                    this._pending.next(true);
+                    return actionResult;
+                }
+            };
+        };
+        if (pollingInterval !== null && pollingInterval !== undefined) {
+            this._pollingInterval.next(pollingInterval);
+        }
+        this.pending$ = this._pending.asObservable()
+            .pipe(distinctUntilChanged(), shareReplay(1));
+        this.data$ = pollingTicker(this._actionHandler(action), pollingInterval, this._ticker)
+            .pipe(tapFirst(() => this._initialized = true), publishReplay(), refCount());
+    }
+    get initialized() { return this._initialized; }
+    /**
+     * Selects the data observable
+     */
+    select(refresh) {
+        if (refresh && this._initialized && !this._pending.value) {
+            this._ticker.next();
+        }
+        return this.data$;
+    }
+    refresh() {
+        let result$;
+        if (this._initialized) {
+            // TODO: Add a test and maybe refactor this to be more clear. It worked in
+            //  my manual tests, but there may be some situations where this doesn't
+            //  work, since the ticker isn't the only way to trigger a refresh. Right
+            //  now it should be fine, but if an async operator is added to be run
+            //  each time `data$` is subscribed to, then this could fail if the data
+            //  emits one extra time before the ticker is triggered.
+            let _polled = false;
+            result$ = this.data$
+                .pipe(tap(_ => !_polled && (_polled = true) && this._ticker.next()), skip(1));
+        }
+        else {
+            result$ = this.data$;
+        }
+        return result$
+            .pipe(take(1), mapTo(undefined));
+    }
+}
+
+function wrapIntoObservable(value) {
+    if (isObservable(value)) {
+        return value;
+    }
+    return from(Promise.resolve(value));
+}
+
+/**
+ * Explaination:
+ *  ^       - beginning of the string
+ *  (?:     - beginning of a non-captured group
+ *  [a-z]+  - any character of 'a' to 'z' 1 or more times
+ *  :       - string (colon character)
+ *  )?      - end of the non-captured group. Group appearing 0 or 1 times
+ *  //      - string (two forward slash characters)
+ *  'i'     - non case-sensitive flag
+ *
+ * source: https://stackoverflow.com/a/19709846
+ */
+const IS_ABSOLUTE_URL_REGEX = new RegExp('^(?:[a-z]+:)?//', 'i');
+function isAbsoluteUrl(url) {
+    return IS_ABSOLUTE_URL_REGEX.test(url);
+}
+
+/**
+ * This is just for helping debug observables that aren't being unsubscribed
+ * from correctly.
+ *
+ * If description is 'foo' then you can check the how many observers are
+ * subscribed with the expression `__subscriberCounts['foo']`. In a debugger you
+ * can add the expression to the "Watch" expressions or in Chrome Devtools
+ * Console you can add it to the live expressions(Add live expressions by
+ * clicking the eye the the left of the Console filter input).
+ */
+function subscriberCount(sourceObservable, description, countChangedFn = logOnChange) {
+    let counter = 0;
+    return new Observable((subscriber) => {
+        const subscription = sourceObservable.subscribe(subscriber);
+        counter++;
+        if (countChangedFn !== undefined && countChangedFn !== null) {
+            countChangedFn(description, counter, 'subscribed');
+        }
+        setGlobalSubscriberCount(description, counter);
+        return () => {
+            subscription.unsubscribe();
+            counter--;
+            if (countChangedFn !== undefined && countChangedFn !== null) {
+                countChangedFn(description, counter, 'unsubscribed');
+            }
+            setGlobalSubscriberCount(description, counter);
+        };
+    });
+}
+const logOnChange = (description, count, reason) => {
+    console.log(`${description} subscriptions: ${count}  [${reason}]`);
+};
+function getGlobalSubscriberCounts() {
+    const w = window;
+    if (w.__subscriberCounts === undefined || w.__subscriberCounts === null) {
+        w.__subscriberCounts = {};
+    }
+    return w.__subscriberCounts;
+}
+function setGlobalSubscriberCount(description, count) {
+    getGlobalSubscriberCounts()[description] = count;
+}
+
+function observeQueryList(queryList, emitCurrentValue = true) {
+    return queryList.changes.pipe(startWith(queryList), map(v => v.toArray()));
+}
+
+function createPadding(len, chars) {
+    // if (chars.length <= len) {
+    //   return chars
+    // }
+    if (chars.length === 0) {
+        throw Error(`Padding characters must be at least 1 char length.`);
+    }
+    let str = chars;
+    while (str.length < len) {
+        str += chars;
+    }
+    if (str.length > len) {
+        str = str.slice(0, len);
+    }
+    return str;
+}
+
+function padEnd(stringToPad, paddingLength = 0, paddingChars = ' ') {
+    const strLength = paddingLength ? stringToPad.length : 0;
+    if (!paddingLength || strLength >= paddingLength) {
+        return stringToPad;
+    }
+    return stringToPad + createPadding(paddingLength - strLength, paddingChars);
+}
+
+function padStart(stringToPad, paddingLength = 0, paddingChars = ' ') {
+    const strLength = paddingLength ? stringToPad.length : 0;
+    if (!paddingLength || strLength >= paddingLength) {
+        return stringToPad;
+    }
+    return createPadding(paddingLength - strLength, paddingChars) + stringToPad;
+}
+
+function isNumeric(value) {
+    return !isNaN(Number(value) - parseFloat(value));
+}
+
+/**
+ * Returns the number of fractional digits.
+ *
+ * NOTE: This is intended for input validation, so trailing 0's will be included
+ * in the total. Also, localization is not considered, so '.' is assumed to be
+ * the fractional separator.
+ */
+function fractionalDigitsCount(value) {
+    if (!isNumeric(value)) {
+        return null;
+    }
+    const a = value.split('.');
+    if (a.length !== 2) {
+        return null;
+    }
+    return a[1].length;
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { IS_FEATURE_COLLECTION_VALIDATOR_NAME, IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME, MIN_MAX_POINTS_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, minMaxPointsValidator, 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 };
+//# sourceMappingURL=theseam-ui-common-utils.mjs.map