@theseam/ui-common 0.4.30 → 1.0.0-beta.0

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

@@ -1,1364 +0,0 @@
-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 { isDevMode } from '@angular/core';
-import fileType from '@marklb/file-type';
-import { Buffer } from 'buffer/';
-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 = '') {
-    let _path = 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 Object.prototype.hasOwnProperty.call(style, 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 && Object.prototype.hasOwnProperty.call(route.routeConfig.data, prop));
-}
-function hasRouteConfigResolveProp(route, prop) {
-    return !!(route && route.routeConfig && route.routeConfig.resolve && Object.prototype.hasOwnProperty.call(route.routeConfig.resolve, 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 => Object.prototype.hasOwnProperty.call(_v.data, 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 {
-            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 areaMSqr = area(geoJson);
-    const acres = convertArea(areaMSqr, '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
-                }
-            };
-        }
-        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_EMPTY_FEATURE_COLLECTION_VALIDATOR_NAME = 'no-empty-feature-collection';
-function noEmptyFeatureCollectionValidator() {
-    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 (value.features.length === 0) {
-            return {
-                [NO_EMPTY_FEATURE_COLLECTION_VALIDATOR_NAME]: {
-                    reason: `FeatureCollection must have a value.`,
-                }
-            };
-        }
-        return null;
-    };
-}
-
-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;
-    };
-}
-
-function readFileAsync(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            resolve(reader.result);
-        };
-        reader.readAsArrayBuffer(file);
-    });
-}
-async function readFileAsDataUrlAsync(file) {
-    return new Promise((resolve, reject) => {
-        const reader = new FileReader();
-        reader.onload = () => {
-            resolve(reader.result);
-        };
-        reader.readAsDataURL(file);
-    });
-}
-async function fileBufferToBlob(fileBuffer, defaultMime = 'application/octet-stream') {
-    const fType = fileType(fileBuffer);
-    const mime = (fType) ? fType.mime : defaultMime;
-    const blob = new Blob([fileBuffer], { type: mime });
-    return blob;
-}
-async function fileBufferToObjectUrl(fileBuffer, defaultMime = 'application/octet-stream') {
-    const file = await fileBufferToBlob(fileBuffer, defaultMime);
-    const fileURL = URL.createObjectURL(file);
-    return fileURL;
-}
-async function fileDataFromBuffer(fileBuffer, defaultMime = 'application/octet-stream') {
-    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) {
-    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 { [propName]: _, ...without } = obj;
-    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 (Object.prototype.hasOwnProperty.call(obj, propName)) {
-        delete obj[propName];
-    }
-}
-/** Delete properties of object */
-function deleteProperties(obj, propNames) {
-    for (const propName of propNames) {
-        deleteProperty(obj, propName);
-    }
-}
-
-/**
- * Reads a File, or buffer of file content, in GeoJSON or ESRI Shapefile format
- * and returns a GeoJSON `FeatureCollection`.
- */
-async function readGeoFile(fileOrBuffer) {
-    const buffer = await coerceFileOrBufferToBuffer(fileOrBuffer);
-    if (isShpFile(buffer)) {
-        return parseShpFile(buffer);
-    }
-    else if (fileType(buffer)?.mime === 'application/zip') {
-        try {
-            return await 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') {
-                    // eslint-disable-next-line no-console
-                    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);
-}
-async function coerceFileOrBufferToBuffer(fileOrBuffer) {
-    if (fileOrBuffer instanceof File) {
-        const arrBuf = await readFileAsync(fileOrBuffer);
-        if (arrBuf === null) {
-            throw new Error('Could not read file.');
-        }
-        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;
-}
-async function parseShpFile(buffer) {
-    const geometries = await shp.parseShp(buffer, undefined);
-    const featCollection = {
-        type: 'FeatureCollection',
-        features: geometries.map(geom => ({
-            type: 'Feature',
-            geometry: geom,
-            properties: {}
-        }))
-    };
-    return featCollection;
-}
-async function parseShpZip(buffer) {
-    let featCollection = await 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?.type === 'FeatureCollection' && Array.isArray(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,
-    }));
-}
-
-/**
- * Close all polygons in the GeoJSON.
- *
- * Google Maps requires that polygons be closed, but not all libraries have that
- * requirement. This may add redundent points to the GeoJSON, but it will ensure
- * that the GeoJSON is valid for Google Maps.
- */
-function closePolygons(geoJson) {
-    if (geoJson.type === 'FeatureCollection') {
-        for (const f of geoJson.features) {
-            closePolygonsFeature(f);
-        }
-    }
-    else if (geoJson.type === 'Feature') {
-        closePolygonsFeature(geoJson);
-    }
-}
-function closePolygonsFeature(feature) {
-    if (feature.geometry.type === 'Polygon') {
-        closePolygon(feature.geometry);
-    }
-    else if (feature.geometry.type === 'MultiPolygon') {
-        closeMultiPolygon(feature.geometry);
-    }
-}
-function closePolygon(polygon) {
-    for (const c of polygon.coordinates) {
-        c.push(c[0]);
-    }
-}
-function closeMultiPolygon(multiPolygon) {
-    for (const p of multiPolygon.coordinates) {
-        for (const c of p) {
-            c.push(c[0]);
-        }
-    }
-}
-
-// 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) {
-    let _force = 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 isNullOrUndefinedOrEmpty(value, trim = true) {
-    return value === undefined || value === null || (trim ? value.trim() : value).length === 0;
-}
-
-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 notNullOrUndefinedOrEmpty(value, trim = true) {
-    return value !== null && value !== undefined && (trim ? value.trim() : value).length > 0;
-}
-
-async function waitOnConditionAsync(condition, timeoutDuration = -1, throwOnTimeout = true) {
-    const timeStart = new Date();
-    const _waitFunc = (callbackFn) => {
-        let conditionSuccess = false;
-        if (condition()) {
-            callbackFn(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 {
-                    callbackFn(false);
-                }
-            }
-            setTimeout(() => { _waitFunc(callbackFn); }, 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 = { ...(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) => {
-    // eslint-disable-next-line no-console
-    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_EMPTY_FEATURE_COLLECTION_VALIDATOR_NAME, NO_INNER_RINGS_VALIDATOR_NAME, NO_KINKS_VALIDATOR_NAME, PollingTickerOptions, Refreshable, activatedRoutesWithDataProperty, arrayMoveImmutable, arrayMoveMutable, calcPercentage, closePolygons, coerceFeatureCollection, createPadding, deleteProperties, deleteProperty, fileBufferToBlob, fileBufferToObjectUrl, fileDataFromBuffer, fractionalDigitsCount, geoJsonToArea, getAttribute, getClosestWidgetCdkDrag, getControlName, getControlPath, hasAttribute, hasProperty, hasRequiredControl, isAbsoluteUrl, isEmptyInputValue, isEmptyUrlRoute, isFeatureCollectionValidator, isNullOrUndefined, isNullOrUndefinedOrEmpty, isNumeric, isOnlyGeometryTypes, isOnlyGeometryTypesValidator, leafChildRoute, loadStyle, loadStyleSheet, mapEach, mergePolygons, minMaxPointsValidator, noEmptyFeatureCollectionValidator, noInnerRingsValidator, noKinksValidator, notNullOrUndefined, notNullOrUndefinedOrEmpty, 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