@ngxs/store 3.7.3 → 3.7.4-dev.master-43177a9

package/bundles/ngxs-store-operators.umd.js

@@ -223,330 +223,331 @@
         return value;
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} items - Specific items to append to the end of an array
-     * @return {?}
-     */
-    function append(items) {
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function appendOperator(existing) {
-            // If `items` is `undefined` or `null` or `[]` but `existing` is provided
-            // just return `existing`
-            /** @type {?} */
-            var itemsNotProvidedButExistingIs = (!items || !items.length) && existing;
-            if (itemsNotProvidedButExistingIs) {
-                return (/** @type {?} */ (existing));
-            }
-            if (Array.isArray(existing)) {
-                return existing.concat((/** @type {?} */ (items)));
-            }
-            // For example if some property is added dynamically
-            // and didn't exist before thus it's not `ArrayLike`
-            return (/** @type {?} */ (items));
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} items - Specific items to append to the end of an array
+     * @return {?}
+     */
+    function append(items) {
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function appendOperator(existing) {
+            // If `items` is `undefined` or `null` or `[]` but `existing` is provided
+            // just return `existing`
+            /** @type {?} */
+            var itemsNotProvidedButExistingIs = (!items || !items.length) && existing;
+            if (itemsNotProvidedButExistingIs) {
+                return (/** @type {?} */ (existing));
+            }
+            if (Array.isArray(existing)) {
+                return existing.concat((/** @type {?} */ (((/** @type {?} */ (items))))));
+            }
+            // For example if some property is added dynamically
+            // and didn't exist before thus it's not `ArrayLike`
+            return (/** @type {?} */ (((/** @type {?} */ (items)))));
+        });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {...?} operators
-     * @return {?}
-     */
-    function compose() {
-        var operators = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            operators[_i] = arguments[_i];
-        }
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function composeOperator(existing) {
-            return operators.reduce((/**
-             * @param {?} accumulator
-             * @param {?} operator
-             * @return {?}
-             */
-            function (accumulator, operator) { return operator(accumulator); }), existing);
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {...?} operators
+     * @return {?}
+     */
+    function compose() {
+        var operators = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            operators[_i] = arguments[_i];
+        }
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function composeOperator(existing) {
+            return operators.reduce((/**
+             * @param {?} accumulator
+             * @param {?} operator
+             * @return {?}
+             */
+            function (accumulator, operator) { return operator(accumulator); }), existing);
+        });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} value
-     * @return {?}
-     */
-    function isStateOperator(value) {
-        return typeof value === 'function';
-    }
-    /**
-     * @param {?} value
-     * @return {?}
-     */
-    function isUndefined(value) {
-        return typeof value === 'undefined';
-    }
-    /**
-     * @template T
-     * @param {?} value
-     * @return {?}
-     */
-    function isPredicate(value) {
-        return typeof value === 'function';
-    }
-    /**
-     * @param {?} value
-     * @return {?}
-     */
-    function isNumber(value) {
-        return typeof value === 'number';
-    }
-    /**
-     * @param {?} index
-     * @return {?}
-     */
-    function invalidIndex(index) {
-        return Number.isNaN(index) || index === -1;
-    }
-    /**
-     * @template T
-     * @param {?} value
-     * @return {?}
-     */
-    function isNil(value) {
-        return value === null || isUndefined(value);
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} value
+     * @return {?}
+     */
+    function isStateOperator(value) {
+        return typeof value === 'function';
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function isUndefined(value) {
+        return typeof value === 'undefined';
+    }
+    /**
+     * @template T
+     * @param {?} value
+     * @return {?}
+     */
+    function isPredicate(value) {
+        return typeof value === 'function';
+    }
+    /**
+     * @param {?} value
+     * @return {?}
+     */
+    function isNumber(value) {
+        return typeof value === 'number';
+    }
+    /**
+     * @param {?} index
+     * @return {?}
+     */
+    function invalidIndex(index) {
+        return Number.isNaN(index) || index === -1;
+    }
+    /**
+     * @template T
+     * @param {?} value
+     * @return {?}
+     */
+    function isNil(value) {
+        return value === null || isUndefined(value);
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} operatorOrValue
-     * @param {?=} existing
-     * @return {?}
-     */
-    function retrieveValue(operatorOrValue, existing) {
-        // If state operator is a function
-        // then call it with an original value
-        if (isStateOperator(operatorOrValue)) {
-            /** @type {?} */
-            var value = operatorOrValue((/** @type {?} */ ((/** @type {?} */ (existing)))));
-            return (/** @type {?} */ (value));
-        }
-        // If operator or value was not provided
-        // e.g. `elseOperatorOrValue` is `undefined`
-        // then we just return an original value
-        if (isUndefined(operatorOrValue)) {
-            return (/** @type {?} */ ((/** @type {?} */ (((/** @type {?} */ (existing)))))));
-        }
-        return (/** @type {?} */ (operatorOrValue));
-    }
-    /**
-     * @template T
-     * @param {?} condition - Condition can be a plain boolean value or a function,
-     * that returns boolean, also this function can take a value as an argument
-     * to which this state operator applies
-     * @param {?} trueOperatorOrValue - Any value or a state operator
-     * @param {?=} elseOperatorOrValue - Any value or a state operator
-     * @return {?}
-     */
-    function iif(condition, trueOperatorOrValue, elseOperatorOrValue) {
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function iifOperator(existing) {
-            // Convert the value to a boolean
-            /** @type {?} */
-            var result = !!condition;
-            // but if it is a function then run it to get the result
-            if (isPredicate(condition)) {
-                result = condition(existing);
-            }
-            if (result) {
-                return retrieveValue(trueOperatorOrValue, (/** @type {?} */ (existing)));
-            }
-            return retrieveValue((/** @type {?} */ (elseOperatorOrValue)), (/** @type {?} */ (existing)));
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} operatorOrValue
+     * @param {?=} existing
+     * @return {?}
+     */
+    function retrieveValue(operatorOrValue, existing) {
+        // If state operator is a function
+        // then call it with an original value
+        if (isStateOperator(operatorOrValue)) {
+            /** @type {?} */
+            var value = operatorOrValue((/** @type {?} */ ((/** @type {?} */ (existing)))));
+            return (/** @type {?} */ (value));
+        }
+        // If operator or value was not provided
+        // e.g. `elseOperatorOrValue` is `undefined`
+        // then we just return an original value
+        if (isUndefined(operatorOrValue)) {
+            return (/** @type {?} */ ((/** @type {?} */ (((/** @type {?} */ (existing)))))));
+        }
+        return (/** @type {?} */ (operatorOrValue));
+    }
+    /**
+     * @template T
+     * @param {?} condition - Condition can be a plain boolean value or a function,
+     * that returns boolean, also this function can take a value as an argument
+     * to which this state operator applies
+     * @param {?} trueOperatorOrValue - Any value or a state operator
+     * @param {?=} elseOperatorOrValue - Any value or a state operator
+     * @return {?}
+     */
+    function iif(condition, trueOperatorOrValue, elseOperatorOrValue) {
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function iifOperator(existing) {
+            // Convert the value to a boolean
+            /** @type {?} */
+            var result = !!condition;
+            // but if it is a function then run it to get the result
+            if (isPredicate(condition)) {
+                result = condition(existing);
+            }
+            if (result) {
+                return retrieveValue(trueOperatorOrValue, (/** @type {?} */ (existing)));
+            }
+            return retrieveValue((/** @type {?} */ (elseOperatorOrValue)), (/** @type {?} */ (existing)));
+        });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} value - Value to insert
-     * @param {?=} beforePosition
-     * @return {?}
-     */
-    function insertItem(value, beforePosition) {
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function insertItemOperator(existing) {
-            // Have to check explicitly for `null` and `undefined`
-            // because `value` can be `0`, thus `!value` will return `true`
-            if (isNil(value) && existing) {
-                return (/** @type {?} */ (existing));
-            }
-            // Property may be dynamic and might not existed before
-            if (!Array.isArray(existing)) {
-                return [(/** @type {?} */ (value))];
-            }
-            /** @type {?} */
-            var clone = existing.slice();
-            /** @type {?} */
-            var index = 0;
-            // No need to call `isNumber`
-            // as we are checking `> 0` not `>= 0`
-            // everything except number will return false here
-            if ((/** @type {?} */ (beforePosition)) > 0) {
-                index = (/** @type {?} */ (beforePosition));
-            }
-            clone.splice(index, 0, (/** @type {?} */ (value)));
-            return clone;
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} value - Value to insert
+     * @param {?=} beforePosition
+     * @return {?}
+     */
+    function insertItem(value, beforePosition) {
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function insertItemOperator(existing) {
+            // Have to check explicitly for `null` and `undefined`
+            // because `value` can be `0`, thus `!value` will return `true`
+            if (isNil(value) && existing) {
+                return (/** @type {?} */ (existing));
+            }
+            // Property may be dynamic and might not existed before
+            if (!Array.isArray(existing)) {
+                return [(/** @type {?} */ (((/** @type {?} */ (value)))))];
+            }
+            /** @type {?} */
+            var clone = existing.slice();
+            /** @type {?} */
+            var index = 0;
+            // No need to call `isNumber`
+            // as we are checking `> 0` not `>= 0`
+            // everything except number will return false here
+            if ((/** @type {?} */ (beforePosition)) > 0) {
+                index = (/** @type {?} */ (beforePosition));
+            }
+            clone.splice(index, 0, (/** @type {?} */ (((/** @type {?} */ (value))))));
+            return clone;
+        });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} patchObject
-     * @return {?}
-     */
-    function patch(patchObject) {
-        return (/**
-         * @template U
-         * @param {?} existing
-         * @return {?}
-         */
-        function patchStateOperator(existing) {
-            /** @type {?} */
-            var clone = null;
-            for (var k in patchObject) {
-                /** @type {?} */
-                var newValue = patchObject[k];
-                /** @type {?} */
-                var existingPropValue = existing[k];
-                /** @type {?} */
-                var newPropValue = isStateOperator(newValue)
-                    ? newValue((/** @type {?} */ (existingPropValue)))
-                    : newValue;
-                if (newPropValue !== existingPropValue) {
-                    if (!clone) {
-                        clone = __assign({}, ((/** @type {?} */ (existing))));
-                    }
-                    clone[k] = newPropValue;
-                }
-            }
-            return clone || existing;
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} patchObject
+     * @return {?}
+     */
+    function patch(patchObject) {
+        return (/** @type {?} */ (((/** @type {?} */ ((/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function patchStateOperator(existing) {
+            /** @type {?} */
+            var clone = null;
+            for (var k in patchObject) {
+                /** @type {?} */
+                var newValue = patchObject[k];
+                /** @type {?} */
+                var existingPropValue = existing[(/** @type {?} */ (k))];
+                /** @type {?} */
+                var newPropValue = isStateOperator(newValue)
+                    ? newValue((/** @type {?} */ (existingPropValue)))
+                    : newValue;
+                if (newPropValue !== existingPropValue) {
+                    if (!clone) {
+                        clone = __assign({}, ((/** @type {?} */ (existing))));
+                    }
+                    clone[k] = newPropValue;
+                }
+            }
+            return clone || existing;
+        }))))));
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} selector - Index of item in the array or a predicate function
-     * that can be provided in `Array.prototype.findIndex`
-     * @param {?} operatorOrValue - New value under the `selector` index or a
-     * function that can be applied to an existing value
-     * @return {?}
-     */
-    function updateItem(selector, operatorOrValue) {
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function updateItemOperator(existing) {
-            /** @type {?} */
-            var index = -1;
-            if (isPredicate(selector)) {
-                index = existing.findIndex(selector);
-            }
-            else if (isNumber(selector)) {
-                index = selector;
-            }
-            if (invalidIndex(index)) {
-                return (/** @type {?} */ (existing));
-            }
-            /** @type {?} */
-            var value = (/** @type {?} */ (null));
-            // Need to check if the new item value will change the existing item value
-            // then, only if it will change it then clone the array and set the item
-            if (isStateOperator(operatorOrValue)) {
-                value = operatorOrValue((/** @type {?} */ (existing[index])));
-            }
-            else {
-                value = operatorOrValue;
-            }
-            // If the value hasn't been mutated
-            // then we just return `existing` array
-            if (value === existing[index]) {
-                return (/** @type {?} */ (existing));
-            }
-            /** @type {?} */
-            var clone = existing.slice();
-            clone[index] = (/** @type {?} */ (value));
-            return clone;
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} selector - Index of item in the array or a predicate function
+     * that can be provided in `Array.prototype.findIndex`
+     * @param {?} operatorOrValue - New value under the `selector` index or a
+     * function that can be applied to an existing value
+     * @return {?}
+     */
+    function updateItem(selector, operatorOrValue) {
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function updateItemOperator(existing) {
+            /** @type {?} */
+            var index = -1;
+            if (isPredicate(selector)) {
+                index = existing.findIndex((/** @type {?} */ (selector)));
+            }
+            else if (isNumber(selector)) {
+                index = selector;
+            }
+            if (invalidIndex(index)) {
+                return (/** @type {?} */ (existing));
+            }
+            /** @type {?} */
+            var value = (/** @type {?} */ (null));
+            // Need to check if the new item value will change the existing item value
+            // then, only if it will change it then clone the array and set the item
+            /** @type {?} */
+            var theOperatorOrValue = (/** @type {?} */ (operatorOrValue));
+            if (isStateOperator(theOperatorOrValue)) {
+                value = theOperatorOrValue((/** @type {?} */ (existing[index])));
+            }
+            else {
+                value = theOperatorOrValue;
+            }
+            // If the value hasn't been mutated
+            // then we just return `existing` array
+            if (value === existing[index]) {
+                return (/** @type {?} */ (existing));
+            }
+            /** @type {?} */
+            var clone = existing.slice();
+            clone[index] = (/** @type {?} */ (value));
+            return clone;
+        });
     }
 
-    /**
-     * @fileoverview added by tsickle
-     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
-     */
-    /**
-     * @template T
-     * @param {?} selector - index or predicate to remove an item from an array by
-     * @return {?}
-     */
-    function removeItem(selector) {
-        return (/**
-         * @param {?} existing
-         * @return {?}
-         */
-        function removeItemOperator(existing) {
-            /** @type {?} */
-            var index = -1;
-            if (isPredicate(selector)) {
-                index = existing.findIndex(selector);
-            }
-            else if (isNumber(selector)) {
-                index = selector;
-            }
-            if (invalidIndex(index)) {
-                return (/** @type {?} */ (existing));
-            }
-            /** @type {?} */
-            var clone = existing.slice();
-            clone.splice(index, 1);
-            return clone;
-        });
+    /**
+     * @fileoverview added by tsickle
+     * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+     */
+    /**
+     * @template T
+     * @param {?} selector - index or predicate to remove an item from an array by
+     * @return {?}
+     */
+    function removeItem(selector) {
+        return (/**
+         * @param {?} existing
+         * @return {?}
+         */
+        function removeItemOperator(existing) {
+            /** @type {?} */
+            var index = -1;
+            if (isPredicate(selector)) {
+                index = existing.findIndex(selector);
+            }
+            else if (isNumber(selector)) {
+                index = selector;
+            }
+            if (invalidIndex(index)) {
+                return (/** @type {?} */ (existing));
+            }
+            /** @type {?} */
+            var clone = existing.slice();
+            clone.splice(index, 1);
+            return clone;
+        });
     }
 
     exports.append = append;