@ngxs/store 3.7.3-dev.master-5175b98 → 3.7.3

package/esm5/src/actions-stream.js

@@ -1,184 +1,186 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-import * as tslib_1 from "tslib";
-import { Injectable } from '@angular/core';
-import { Subject, Observable } from 'rxjs';
-import { leaveNgxs } from './operators/leave-ngxs';
-import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
-/** @enum {string} */
-var ActionStatus = {
-    Dispatched: 'DISPATCHED',
-    Successful: 'SUCCESSFUL',
-    Canceled: 'CANCELED',
-    Errored: 'ERRORED',
-};
-export { ActionStatus };
-/**
- * @record
- * @template T
- */
-export function ActionContext() { }
-if (false) {
-    /** @type {?} */
-    ActionContext.prototype.status;
-    /** @type {?} */
-    ActionContext.prototype.action;
-    /** @type {?|undefined} */
-    ActionContext.prototype.error;
-}
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
- */
-var /**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
- */
-OrderedSubject = /** @class */ (function (_super) {
-    tslib_1.__extends(OrderedSubject, _super);
-    function OrderedSubject() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this._itemQueue = [];
-        _this._busyPushingNext = false;
-        return _this;
-    }
-    /**
-     * @param {?=} value
-     * @return {?}
-     */
-    OrderedSubject.prototype.next = /**
-     * @param {?=} value
-     * @return {?}
-     */
-    function (value) {
-        if (this._busyPushingNext) {
-            this._itemQueue.unshift((/** @type {?} */ (value)));
-            return;
-        }
-        this._busyPushingNext = true;
-        _super.prototype.next.call(this, value);
-        while (this._itemQueue.length > 0) {
-            /** @type {?} */
-            var nextValue = this._itemQueue.pop();
-            _super.prototype.next.call(this, nextValue);
-        }
-        this._busyPushingNext = false;
-    };
-    return OrderedSubject;
-}(Subject));
-/**
- * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
- * A standard Subject does not have this guarantee.
- * For example, given the following code:
- * ```typescript
- *   const subject = new Subject<string>();
- * subject.subscribe(value => {
- * if (value === 'start') subject.next('end');
- * });
- * subject.subscribe(value => { });
- * subject.next('start');
- * ```
- * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
- * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
- * @template T
- */
-export { OrderedSubject };
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._itemQueue;
-    /**
-     * @type {?}
-     * @private
-     */
-    OrderedSubject.prototype._busyPushingNext;
-}
-/**
- * Internal Action stream that is emitted anytime an action is dispatched.
- */
-var InternalActions = /** @class */ (function (_super) {
-    tslib_1.__extends(InternalActions, _super);
-    function InternalActions() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    InternalActions.decorators = [
-        { type: Injectable }
-    ];
-    return InternalActions;
-}(OrderedSubject));
-export { InternalActions };
-/**
- * Action stream that is emitted anytime an action is dispatched.
- *
- * You can listen to this in services to react without stores.
- */
-var Actions = /** @class */ (function (_super) {
-    tslib_1.__extends(Actions, _super);
-    function Actions(internalActions$, internalExecutionStrategy) {
-        return _super.call(this, (/**
-         * @param {?} observer
-         * @return {?}
-         */
-        function (observer) {
-            /** @type {?} */
-            var childSubscription = internalActions$
-                .pipe(leaveNgxs(internalExecutionStrategy))
-                .subscribe({
-                next: (/**
-                 * @param {?} ctx
-                 * @return {?}
-                 */
-                function (ctx) { return observer.next(ctx); }),
-                error: (/**
-                 * @param {?} error
-                 * @return {?}
-                 */
-                function (error) { return observer.error(error); }),
-                complete: (/**
-                 * @return {?}
-                 */
-                function () { return observer.complete(); })
-            });
-            observer.add(childSubscription);
-        })) || this;
-    }
-    Actions.decorators = [
-        { type: Injectable }
-    ];
-    /** @nocollapse */
-    Actions.ctorParameters = function () { return [
-        { type: InternalActions },
-        { type: InternalNgxsExecutionStrategy }
-    ]; };
-    return Actions;
-}(Observable));
-export { Actions };
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+import * as tslib_1 from "tslib";
+import { Injectable } from '@angular/core';
+import { Subject, Observable } from 'rxjs';
+import { leaveNgxs } from './operators/leave-ngxs';
+import { InternalNgxsExecutionStrategy } from './execution/internal-ngxs-execution-strategy';
+/** @enum {string} */
+var ActionStatus = {
+    Dispatched: 'DISPATCHED',
+    Successful: 'SUCCESSFUL',
+    Canceled: 'CANCELED',
+    Errored: 'ERRORED',
+};
+export { ActionStatus };
+/**
+ * @record
+ * @template T
+ */
+export function ActionContext() { }
+if (false) {
+    /** @type {?} */
+    ActionContext.prototype.status;
+    /** @type {?} */
+    ActionContext.prototype.action;
+    /** @type {?|undefined} */
+    ActionContext.prototype.error;
+}
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+ * subject.subscribe(value => {
+ * if (value === 'start') subject.next('end');
+ * });
+ * subject.subscribe(value => { });
+ * subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ * @template T
+ */
+var /**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+ * subject.subscribe(value => {
+ * if (value === 'start') subject.next('end');
+ * });
+ * subject.subscribe(value => { });
+ * subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ * @template T
+ */
+OrderedSubject = /** @class */ (function (_super) {
+    tslib_1.__extends(OrderedSubject, _super);
+    function OrderedSubject() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        _this._itemQueue = [];
+        _this._busyPushingNext = false;
+        return _this;
+    }
+    /**
+     * @param {?=} value
+     * @return {?}
+     */
+    OrderedSubject.prototype.next = /**
+     * @param {?=} value
+     * @return {?}
+     */
+    function (value) {
+        if (this._busyPushingNext) {
+            this._itemQueue.unshift((/** @type {?} */ (value)));
+            return;
+        }
+        this._busyPushingNext = true;
+        _super.prototype.next.call(this, value);
+        while (this._itemQueue.length > 0) {
+            /** @type {?} */
+            var nextValue = this._itemQueue.pop();
+            _super.prototype.next.call(this, nextValue);
+        }
+        this._busyPushingNext = false;
+    };
+    return OrderedSubject;
+}(Subject));
+/**
+ * Custom Subject that ensures that subscribers are notified of values in the order that they arrived.
+ * A standard Subject does not have this guarantee.
+ * For example, given the following code:
+ * ```typescript
+ *   const subject = new Subject<string>();
+ * subject.subscribe(value => {
+ * if (value === 'start') subject.next('end');
+ * });
+ * subject.subscribe(value => { });
+ * subject.next('start');
+ * ```
+ * When `subject` is a standard `Subject<T>` the second subscriber would recieve `end` and then `start`.
+ * When `subject` is a `OrderedSubject<T>` the second subscriber would recieve `start` and then `end`.
+ * @template T
+ */
+export { OrderedSubject };
+if (false) {
+    /**
+     * @type {?}
+     * @private
+     */
+    OrderedSubject.prototype._itemQueue;
+    /**
+     * @type {?}
+     * @private
+     */
+    OrderedSubject.prototype._busyPushingNext;
+}
+/**
+ * Internal Action stream that is emitted anytime an action is dispatched.
+ */
+var InternalActions = /** @class */ (function (_super) {
+    tslib_1.__extends(InternalActions, _super);
+    function InternalActions() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    InternalActions.decorators = [
+        { type: Injectable }
+    ];
+    return InternalActions;
+}(OrderedSubject));
+export { InternalActions };
+/**
+ * Action stream that is emitted anytime an action is dispatched.
+ *
+ * You can listen to this in services to react without stores.
+ */
+var Actions = /** @class */ (function (_super) {
+    tslib_1.__extends(Actions, _super);
+    // This has to be `Observable<ActionContext>` in the v4. Because `InternalActions`
+    // is a `Subject<ActionContext>`. Leave it as `any` to avoid breaking changes
+    function Actions(internalActions$, internalExecutionStrategy) {
+        return _super.call(this, (/**
+         * @param {?} observer
+         * @return {?}
+         */
+        function (observer) {
+            /** @type {?} */
+            var childSubscription = internalActions$
+                .pipe(leaveNgxs(internalExecutionStrategy))
+                .subscribe({
+                next: (/**
+                 * @param {?} ctx
+                 * @return {?}
+                 */
+                function (ctx) { return observer.next(ctx); }),
+                error: (/**
+                 * @param {?} error
+                 * @return {?}
+                 */
+                function (error) { return observer.error(error); }),
+                complete: (/**
+                 * @return {?}
+                 */
+                function () { return observer.complete(); })
+            });
+            observer.add(childSubscription);
+        })) || this;
+    }
+    Actions.decorators = [
+        { type: Injectable }
+    ];
+    /** @nocollapse */
+    Actions.ctorParameters = function () { return [
+        { type: InternalActions },
+        { type: InternalNgxsExecutionStrategy }
+    ]; };
+    return Actions;
+}(Observable));
+export { Actions };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/src/configs/messages.config.js

@@ -1,79 +1,104 @@
-/**
- * @fileoverview added by tsickle
- * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @param {?} name
- * @return {?}
- */
-export function throwStateNameError(name) {
-    throw new Error(name + " is not a valid state name. It needs to be a valid object property name.");
-}
-/**
- * @return {?}
- */
-export function throwStateNamePropertyError() {
-    throw new Error("States must register a 'name' property.");
-}
-/**
- * @param {?} current
- * @param {?} newName
- * @param {?} oldName
- * @return {?}
- */
-export function throwStateUniqueError(current, newName, oldName) {
-    throw new Error("State name '" + current + "' from " + newName + " already exists in " + oldName + ".");
-}
-/**
- * @param {?} name
- * @return {?}
- */
-export function throwStateDecoratorError(name) {
-    throw new Error("States must be decorated with @State() decorator, but \"" + name + "\" isn't.");
-}
-/**
- * @return {?}
- */
-export function throwActionDecoratorError() {
-    throw new Error('@Action() decorator cannot be used with static methods.');
-}
-/**
- * @return {?}
- */
-export function throwSelectorDecoratorError() {
-    throw new Error('Selectors only work on methods.');
-}
-/**
- * @return {?}
- */
-export function getZoneWarningMessage() {
-    return ('Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
-        'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
-        'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })');
-}
-/**
- * @param {?} name
- * @return {?}
- */
-export function getUndecoratedStateInIvyWarningMessage(name) {
-    return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
-}
-/**
- * @return {?}
- */
-export function throwSelectFactoryNotConnectedError() {
-    throw new Error('You have forgotten to import the NGXS module!');
-}
-/**
- * @return {?}
- */
-export function throwPatchingArrayError() {
-    throw new Error('Patching arrays is not supported.');
-}
-/**
- * @return {?}
- */
-export function throwPatchingPrimitiveError() {
-    throw new Error('Patching primitives is not supported.');
-}
-//# sourceMappingURL=data:application/json;base64,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
+var _a;
+/**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ */
+/** @enum {string} */
+var VALIDATION_CODE = {
+    STATE_NAME: 'STATE_NAME',
+    STATE_UNIQUE: 'STATE_UNIQUE',
+    STATE_NAME_PROPERTY: 'STATE_NAME_PROPERTY',
+    STATE_DECORATOR: 'STATE_DECORATOR',
+    INCORRECT_PRODUCTION: 'INCORRECT_PRODUCTION',
+    INCORRECT_DEVELOPMENT: 'INCORRECT_DEVELOPMENT',
+    SELECT_FACTORY_NOT_CONNECTED: 'SELECT_FACTORY_NOT_CONNECTED',
+    ACTION_DECORATOR: 'ACTION_DECORATOR',
+    SELECTOR_DECORATOR: 'SELECTOR_DECORATOR',
+    ZONE_WARNING: 'ZONE_WARNING',
+    PATCHING_ARRAY: 'PATCHING_ARRAY',
+    PATCHING_PRIMITIVE: 'PATCHING_PRIMITIVE',
+    UNDECORATED_STATE_IN_IVY: 'UNDECORATED_STATE_IN_IVY',
+};
+export { VALIDATION_CODE };
+/** @type {?} */
+export var CONFIG_MESSAGES = (_a = {},
+    _a[VALIDATION_CODE.STATE_NAME] = (/**
+     * @param {?} name
+     * @return {?}
+     */
+    function (name) {
+        return name + " is not a valid state name. It needs to be a valid object property name.";
+    }),
+    _a[VALIDATION_CODE.STATE_NAME_PROPERTY] = (/**
+     * @return {?}
+     */
+    function () { return "States must register a 'name' property"; }),
+    _a[VALIDATION_CODE.STATE_UNIQUE] = (/**
+     * @param {?} current
+     * @param {?} newName
+     * @param {?} oldName
+     * @return {?}
+     */
+    function (current, newName, oldName) {
+        return "State name '" + current + "' from " + newName + " already exists in " + oldName;
+    }),
+    _a[VALIDATION_CODE.STATE_DECORATOR] = (/**
+     * @return {?}
+     */
+    function () { return 'States must be decorated with @State() decorator'; }),
+    _a[VALIDATION_CODE.INCORRECT_PRODUCTION] = (/**
+     * @return {?}
+     */
+    function () {
+        return 'Angular is running in production mode but NGXS is still running in the development mode!\n' +
+            'Please set developmentMode to false on the NgxsModule options when in production mode.\n' +
+            'NgxsModule.forRoot(states, { developmentMode: !environment.production })';
+    }),
+    _a[VALIDATION_CODE.INCORRECT_DEVELOPMENT] = (/**
+     * @return {?}
+     */
+    function () {
+        return 'RECOMMENDATION: Set developmentMode to true on the NgxsModule when Angular is running in development mode.\n' +
+            'NgxsModule.forRoot(states, { developmentMode: !environment.production })';
+    }),
+    _a[VALIDATION_CODE.SELECT_FACTORY_NOT_CONNECTED] = (/**
+     * @return {?}
+     */
+    function () {
+        return 'You have forgotten to import the NGXS module!';
+    }),
+    _a[VALIDATION_CODE.ACTION_DECORATOR] = (/**
+     * @return {?}
+     */
+    function () {
+        return '@Action() decorator cannot be used with static methods';
+    }),
+    _a[VALIDATION_CODE.SELECTOR_DECORATOR] = (/**
+     * @return {?}
+     */
+    function () { return 'Selectors only work on methods'; }),
+    _a[VALIDATION_CODE.ZONE_WARNING] = (/**
+     * @return {?}
+     */
+    function () {
+        return 'Your application was bootstrapped with nooped zone and your execution strategy requires an actual NgZone!\n' +
+            'Please set the value of the executionStrategy property to NoopNgxsExecutionStrategy.\n' +
+            'NgxsModule.forRoot(states, { executionStrategy: NoopNgxsExecutionStrategy })';
+    }),
+    _a[VALIDATION_CODE.PATCHING_ARRAY] = (/**
+     * @return {?}
+     */
+    function () { return 'Patching arrays is not supported.'; }),
+    _a[VALIDATION_CODE.PATCHING_PRIMITIVE] = (/**
+     * @return {?}
+     */
+    function () { return 'Patching primitives is not supported.'; }),
+    _a[VALIDATION_CODE.UNDECORATED_STATE_IN_IVY] = (/**
+     * @param {?} name
+     * @return {?}
+     */
+    function (name) {
+        return "'" + name + "' class should be decorated with @Injectable() right after the @State() decorator";
+    }),
+    _a);
+//# sourceMappingURL=data:application/json;base64,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