@theseam/ui-common 0.3.5 → 0.3.8

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

@@ -810,6 +810,86 @@
         }
     }
 
+    function notNullOrUndefined(value) {
+        return value !== null && value !== undefined;
+    }
+
+    var MIN_MAX_POINTS_VALIDATOR_NAME = 'min-max-points';
+    function minMaxPointsValidator(min, max) {
+        if (min === void 0) { min = 3; }
+        return function (control) {
+            var _a;
+            // Don't need to validate if there isn't a value. Use `Validators.required` for that.
+            if (isEmptyInputValue(control.value)) {
+                return null; // don't validate empty values to allow optional controls
+            }
+            var value = coerceFeatureCollection(control.value);
+            if (value === null) {
+                return null;
+            }
+            if (collectionViolatesMinMax(value, min, max)) {
+                var reason = notNullOrUndefined(max) ?
+                    "A polygon must have between " + min + " and " + max + " points." :
+                    "A polygon must have at least " + min + " points.";
+                return _a = {},
+                    _a[MIN_MAX_POINTS_VALIDATOR_NAME] = {
+                        reason: reason
+                    },
+                    _a;
+            }
+            return null;
+        };
+    }
+    /**
+     * Checks if a FeatureCollection contains any geometries with an incomplete polygon.
+     *
+     * NOTE: Does not consider GeometryCollection.
+     */
+    function collectionViolatesMinMax(featureCollection, min, max) {
+        var e_1, _a, e_2, _b;
+        try {
+            for (var _c = __values(featureCollection.features), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var f = _d.value;
+                if (f.geometry.type === 'Polygon') {
+                    if (polygonViolatesMinMax(f.geometry.coordinates[0].length, min, max)) {
+                        return true;
+                    }
+                }
+                else if (f.geometry.type === 'MultiPolygon') {
+                    try {
+                        for (var _e = (e_2 = void 0, __values(f.geometry.coordinates)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var coords = _f.value;
+                            if (polygonViolatesMinMax(coords[0].length, min, max)) {
+                                return true;
+                            }
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return false;
+    }
+    function polygonViolatesMinMax(coordinateLength, min, max) {
+        if (coordinateLength < min || (notNullOrUndefined(max) && max > min && coordinateLength > max)) {
+            return true;
+        }
+        return false;
+    }
+
     var NO_INNER_RINGS_VALIDATOR_NAME = 'no-inner-rings';
     /**
      * Validates that a FeatureCollection does not contain any Polygon with inner
@@ -931,7 +1011,7 @@
             if (kinksFound.length > 0) {
                 return _b = {},
                     _b[NO_KINKS_VALIDATOR_NAME] = {
-                        reason: 'Paths should not intersect themself.',
+                        reason: 'Paths should not intersect themselves.',
                         featuresWithKink: kinksFound,
                     },
                     _b;
@@ -1359,10 +1439,6 @@
         });
     }
 
-    function notNullOrUndefined(value) {
-        return value !== null && value !== undefined;
-    }
-
     function waitOnConditionAsync(condition, timeoutDuration, throwOnTimeout) {
         if (timeoutDuration === void 0) { timeoutDuration = -1; }
         if (throwOnTimeout === void 0) { throwOnTimeout = true; }
@@ -1738,6 +1814,7 @@
 
     exports.IS_FEATURE_COLLECTION_VALIDATOR_NAME = IS_FEATURE_COLLECTION_VALIDATOR_NAME;
     exports.IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME = IS_ONLY_GEOMETRY_TYPES_VALIDATOR_NAME;
+    exports.MIN_MAX_POINTS_VALIDATOR_NAME = MIN_MAX_POINTS_VALIDATOR_NAME;
     exports.NO_INNER_RINGS_VALIDATOR_NAME = NO_INNER_RINGS_VALIDATOR_NAME;
     exports.NO_KINKS_VALIDATOR_NAME = NO_KINKS_VALIDATOR_NAME;
     exports.PollingTickerOptions = PollingTickerOptions;
@@ -1775,6 +1852,7 @@
     exports.loadStyleSheet = loadStyleSheet;
     exports.mapEach = mapEach;
     exports.mergePolygons = mergePolygons;
+    exports.minMaxPointsValidator = minMaxPointsValidator;
     exports.noInnerRingsValidator = noInnerRingsValidator;
     exports.noKinksValidator = noKinksValidator;
     exports.notNullOrUndefined = notNullOrUndefined;