@zodiac-ui/ng-observable
Version:
Create powerful reactive components with Angular. AoT compatible and Ivy ready.
243 lines • 18.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { ChangeDetectorRef, Inject, Injectable, isDevMode, Optional } from "@angular/core";
import { asapScheduler, BehaviorSubject } from "rxjs";
import { Stream } from "./stream";
import { STATE_CHANGE_STRATEGY, StateChangeStrategy } from "./constants";
import { debounceTime } from "rxjs/operators";
import { InvokeSubject } from "./invoke-subject";
/**
* State object for bound `valueRef`. State changes mutate the original object in-place and notifies any observers
* with a new object reference.
*
* @see {\@link StateFactory}
*
* \@usageNotes
*
* \@publicApi
* @template T
*/
export class State extends BehaviorSubject {
/**
* Creates a new State `instance`.
*
* @param {?} valueRef The mutable value object reference to apply state changes to.
* @param {?} markForCheck Notifier that schedules change detection to run on the next microtask.
*/
constructor(valueRef, markForCheck) {
super(Object.create(valueRef));
this.valueRef = valueRef;
this.next = (/**
* @param {?=} partialState
* @return {?}
*/
(partialState) => {
this.patchValue(partialState);
markForCheck();
});
this.patchValue = (/**
* @param {?=} partialState
* @return {?}
*/
(partialState) => {
Object.assign(valueRef, partialState);
super.next(Object.create(valueRef));
});
}
}
if (false) {
/**
* Mutate the state, notify observers and queue change detection.
*
* \@param partialState A plain object containing values to mutate the existing state with.
* @type {?}
*/
State.prototype.next;
/**
*
* Mutate the state and notify observers without running change detection.
*
* \@param partialState A plain object containing values to mutate the existing state with.
* @type {?}
*/
State.prototype.patchValue;
/**
* The value object reference to be mutated.
* @type {?}
* @private
*/
State.prototype.valueRef;
}
/**
* Reactive state management for Angular components and directives.
*
* @see {\@link State}
*
* \@usageNotes
*
* Create a `State<T>` instance by passing the component instance as an argument. All mutations to
* the internal component state should be handled with this service so that observers can be notified
* of changes.
*
* ```typescript
* export interface MyProps {
* title: string
* }
*
* export interface MyState extends MyProps {
* model: string
* }
*
* \@Component({
* viewProviders: [StateFactory, Stream] // or providers
* })
* export class MyComponent implements MyState {
* \@Input()
* title: string
* model: string
*
* constructor(\@Self() stateFactory: StateFactory<MyState>, \@Self() stream: Stream) {
* const state = stateFactory.create(this)
*
* // Imperative usage
* state.next({
* model: "app"
* })
*
* // Reactive usage
* stream(state)(of({ model: "app" }))
* }
* }
* ```
*
* ### Connecting `\@Input()` properties
*
* Changes received from `\@Input()` properties can be mapped onto the state to keep state observers up to date:
*
* ```ts
* \@Component()
* export class MyComponent extends NgObservable implements MyState {
* \@Input()
* value: any
* mappedValue: any
*
* constructor(\@Self() stateFactory: StateFactory<MyState>, \@Self() stream: Stream) {
* const state = stateFactory.create(this)
*
* // assuming 1:1 map between inputs and state
* stream(state)(mapInputsToState(this))
*
* // map inputs to some other value
* stream(state)(mapInputsToState(this).pipe(
* map((props) => ({
* mappedValue: props.value
* }))
* )
* }
* }
* ```
*
* \@publicApi
* @template T
*/
export class StateFactory {
/**
* Creates an instance of `StateFactory`
*
* @param {?} strategy The {\@link StateChangeStrategy} to be used. It will wither detach or reattach
* the `ChangeDetectorRef` if one is provided.
*
* @param {?=} cdr The `ChangeDetectorRef` for the current view.
*
*/
constructor(strategy, cdr) {
this.stream = new Stream();
this.cdr = cdr;
this.strategy = strategy;
this.checkNoChanges = isDevMode();
}
/**
* Creates an instance of {\@link State} bound to the given `valueRef`. Performs change detection when notified
* by `markForCheck`.
*
* @param {?} valueRef The mutable value object reference to apply state changes to.
* @return {?}
*/
create(valueRef) {
const { cdr, strategy, stream, checkNoChanges } = this;
/** @type {?} */
const markForCheck = new InvokeSubject();
/** @type {?} */
const state = new State(valueRef, markForCheck);
/** @type {?} */
const shouldDetach = strategy === StateChangeStrategy.DETACH;
if (cdr) {
/** @type {?} */
const detectChanges = (/**
* @return {?}
*/
() => {
cdr.detectChanges();
if (checkNoChanges) {
cdr.checkNoChanges();
}
});
if (shouldDetach) {
cdr.detach();
}
else {
cdr.reattach();
}
Promise.resolve().then((/**
* @return {?}
*/
() => {
if (shouldDetach) {
detectChanges();
}
stream(detectChanges)(debounceTime(0, asapScheduler)(markForCheck));
}));
}
return state;
}
/**
* Cleanup when the injector is destroyed
* @return {?}
*/
ngOnDestroy() {
this.stream.complete();
}
}
StateFactory.decorators = [
{ type: Injectable }
];
/** @nocollapse */
StateFactory.ctorParameters = () => [
{ type: StateChangeStrategy, decorators: [{ type: Inject, args: [STATE_CHANGE_STRATEGY,] }] },
{ type: ChangeDetectorRef, decorators: [{ type: Optional }] }
];
if (false) {
/**
* @type {?}
* @private
*/
StateFactory.prototype.stream;
/**
* @type {?}
* @private
*/
StateFactory.prototype.strategy;
/**
* @type {?}
* @private
*/
StateFactory.prototype.cdr;
/**
* @type {?}
* @private
*/
StateFactory.prototype.checkNoChanges;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"state.js","sourceRoot":"ng://@zodiac-ui/ng-observable/","sources":["lib/state.ts"],"names":[],"mappings":"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","sourcesContent":["import { ChangeDetectorRef, Inject, Injectable, isDevMode, OnDestroy, Optional } from \"@angular/core\"\r\nimport { asapScheduler, BehaviorSubject } from \"rxjs\"\r\nimport { Stream } from \"./stream\"\r\nimport { STATE_CHANGE_STRATEGY, StateChangeStrategy } from \"./constants\"\r\nimport { debounceTime } from \"rxjs/operators\"\r\nimport { InvokeSubject } from \"./invoke-subject\"\r\n\r\n/**\r\n * State object for bound `valueRef`. State changes mutate the original object in-place and notifies any observers\r\n * with a new object reference.\r\n *\r\n * @see {@link StateFactory}\r\n *\r\n * @usageNotes\r\n *\r\n * @publicApi\r\n */\r\nexport class State<T extends object> extends BehaviorSubject<T> {\r\n    /**\r\n     * Mutate the state, notify observers and queue change detection.\r\n     *\r\n     * @param partialState A plain object containing values to mutate the existing state with.\r\n     */\r\n    public readonly next: (partialState?: Partial<T>) => void\r\n\r\n    /**\r\n     *\r\n     * Mutate the state and notify observers without running change detection.\r\n     *\r\n     * @param partialState A plain object containing values to mutate the existing state with.\r\n     */\r\n    public readonly patchValue: (partialState?: Partial<T>) => void\r\n\r\n    /**\r\n     * The value object reference to be mutated.\r\n     */\r\n    private readonly valueRef: T\r\n\r\n    /**\r\n     * Creates a new State `instance`.\r\n     *\r\n     * @param valueRef The mutable value object reference to apply state changes to.\r\n     * @param markForCheck Notifier that schedules change detection to run on the next microtask.\r\n     */\r\n    constructor(valueRef: T, markForCheck: Function) {\r\n        super(Object.create(valueRef))\r\n\r\n        this.valueRef = valueRef\r\n\r\n        this.next = (partialState?: Partial<T>) => {\r\n            this.patchValue(partialState)\r\n            markForCheck()\r\n        }\r\n\r\n        this.patchValue = (partialState?: Partial<T>) => {\r\n            Object.assign(valueRef, partialState)\r\n            super.next(Object.create(valueRef))\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Reactive state management for Angular components and directives.\r\n *\r\n * @see {@link State}\r\n *\r\n * @usageNotes\r\n *\r\n * Create a `State<T>` instance by passing the component instance as an argument. All mutations to\r\n * the internal component state should be handled with this service so that observers can be notified\r\n * of changes.\r\n *\r\n * ```typescript\r\n * export interface MyProps {\r\n *     title: string\r\n * }\r\n *\r\n * export interface MyState extends MyProps {\r\n *     model: string\r\n * }\r\n *\r\n * @Component({\r\n *     viewProviders: [StateFactory, Stream] // or providers\r\n * })\r\n * export class MyComponent implements MyState {\r\n *     @Input()\r\n *     title: string\r\n *     model: string\r\n *\r\n *     constructor(@Self() stateFactory: StateFactory<MyState>, @Self() stream: Stream) {\r\n *         const state = stateFactory.create(this)\r\n *\r\n *         // Imperative usage\r\n *         state.next({\r\n *             model: \"app\"\r\n *         })\r\n *\r\n *         // Reactive usage\r\n *         stream(state)(of({ model: \"app\" }))\r\n *     }\r\n * }\r\n * ```\r\n *\r\n * ### Connecting `@Input()` properties\r\n *\r\n * Changes received from `@Input()` properties can be mapped onto the state to keep state observers up to date:\r\n *\r\n * ```ts\r\n * @Component()\r\n * export class MyComponent extends NgObservable implements MyState {\r\n *     @Input()\r\n *     value: any\r\n *     mappedValue: any\r\n *\r\n *     constructor(@Self() stateFactory: StateFactory<MyState>, @Self() stream: Stream) {\r\n *         const state = stateFactory.create(this)\r\n *\r\n *         // assuming 1:1 map between inputs and state\r\n *         stream(state)(mapInputsToState(this))\r\n *\r\n *         // map inputs to some other value\r\n *         stream(state)(mapInputsToState(this).pipe(\r\n *             map((props) => ({\r\n *                 mappedValue: props.value\r\n *             }))\r\n *         )\r\n *     }\r\n * }\r\n * ```\r\n *\r\n * @publicApi\r\n */\r\n@Injectable()\r\nexport class StateFactory<T extends Object> implements OnDestroy {\r\n    private readonly stream: Stream\r\n    private readonly strategy: StateChangeStrategy\r\n    private readonly cdr?: ChangeDetectorRef\r\n    private readonly checkNoChanges: boolean\r\n\r\n    /**\r\n     * Creates an instance of `StateFactory`\r\n     *\r\n     * @param strategy The {@link StateChangeStrategy} to be used. It will wither detach or reattach\r\n     * the `ChangeDetectorRef` if one is provided.\r\n     *\r\n     * @param cdr The `ChangeDetectorRef` for the current view.\r\n     *\r\n     */\r\n    constructor(\r\n        @Inject(STATE_CHANGE_STRATEGY) strategy: StateChangeStrategy,\r\n        @Optional() cdr?: ChangeDetectorRef,\r\n    ) {\r\n        this.stream = new Stream()\r\n        this.cdr = cdr\r\n        this.strategy = strategy\r\n        this.checkNoChanges = isDevMode()\r\n    }\r\n\r\n    /**\r\n     * Creates an instance of {@link State} bound to the given `valueRef`. Performs change detection when notified\r\n     * by `markForCheck`.\r\n     *\r\n     * @param valueRef The mutable value object reference to apply state changes to.\r\n     */\r\n    public create(valueRef: T): State<T> {\r\n        const { cdr, strategy, stream, checkNoChanges } = this\r\n        const markForCheck = new InvokeSubject<any>()\r\n        const state = new State(valueRef, markForCheck)\r\n        const shouldDetach = strategy === StateChangeStrategy.DETACH\r\n\r\n        if (cdr) {\r\n            const detectChanges = () => {\r\n                cdr.detectChanges()\r\n                if (checkNoChanges) {\r\n                    cdr.checkNoChanges()\r\n                }\r\n            }\r\n            if (shouldDetach) {\r\n                cdr.detach()\r\n            }\r\n            else {\r\n                cdr.reattach()\r\n            }\r\n            Promise.resolve().then(() => {\r\n                if (shouldDetach) {\r\n                    detectChanges()\r\n                }\r\n                stream(detectChanges)(debounceTime(0, asapScheduler)(markForCheck))\r\n            })\r\n        }\r\n\r\n        return state\r\n    }\r\n\r\n    /**\r\n     * Cleanup when the injector is destroyed\r\n     */\r\n    public ngOnDestroy() {\r\n        this.stream.complete()\r\n    }\r\n}\r\n"]}