@activejs/core
Version:
Pragmatic, Reactive State Management for JavaScript Apps
59 lines • 7.71 kB
JavaScript
import { Base } from './abstract-base';
import { Configuration } from './configuration';
import { Stream } from './stream';
import { deepFreeze, makeNonEnumerable } from '../utils/funcs';
/**
* An Action is nothing, but an elaborate form of an RxJS Subject. \
* Or in other words, a simplified form of Unit.
*
* Unlike Units, it doesn't perform any checks on dispatch. \
* All values pass through, just like a Subject.
*
* See {@link https://docs.activejs.dev/fundamentals/action} for more details.
*
* @category 4. Utility
*/
export class Action extends Base {
constructor(config) {
super(Object.assign(Object.assign({ replay: false }, Configuration.ACTION), config));
this.dispatch(this.config.initialValue);
makeNonEnumerable(this);
}
// tslint:enable:variable-name
/**
* Current value of the Action, the last dispatched value.
*
* @default `undefined`
* @category Access Value
*/
value() {
return this._value;
}
/**
* A helper method that creates a stream by subscribing to the Observable returned by the param `observableProducer` callback.
*
* Ideally the callback function creates an Observable by applying `Observable.pipe`.
*
* Just know that you should catch the error in a sub-pipe (ie: do not let it propagate to the main-pipe), otherwise
* as usual the stream will stop working, and will not react on any further emissions.
*
* @param observableProducer A callback function that should return an Observable.
*
* @category Common
*/
createStream(observableProducer) {
const observable = observableProducer(this);
return new Stream(observable);
}
dispatch(valueOrProducer) {
this._value =
typeof valueOrProducer === 'function'
? valueOrProducer(this.value())
: valueOrProducer;
if (Configuration.ENVIRONMENT.checkImmutability === true) {
deepFreeze(this._value);
}
this.emit();
}
}
//# sourceMappingURL=data:application/json;base64,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