@versatiledatakit/shared
Version:
Versatile Data Kit Shared library enables reusability of shared features like: NgRx Redux, Error Handlers, Utils, Generic Components, etc.
297 lines • 39.2 kB
JavaScript
/*
* Copyright 2023-2025 Broadcom
* SPDX-License-Identifier: Apache-2.0
*/
/* eslint-disable @angular-eslint/directive-class-suffix */
import { Directive } from '@angular/core';
import { CollectionsUtil } from '../../../../utils';
import { RouteStateFactory } from '../../../router/factory';
import { ComponentModel, FAILED } from '../../model';
import { TaurusErrorBaseComponent } from '../error-base';
import * as i0 from "@angular/core";
import * as i1 from "../../services";
import * as i2 from "../../../navigation";
import * as i3 from "@angular/router";
/**
* ** Superclass Component for all other Components that want to use NgRx Store and all lifecycle hooks from Taurus.
*/
export class TaurusBaseComponent extends TaurusErrorBaseComponent {
/**
* ** Constructor.
*/
constructor(componentService, navigationService, activatedRoute, className = null) {
super(className ?? TaurusBaseComponent.CLASS_NAME);
this.componentService = componentService;
this.navigationService = navigationService;
this.activatedRoute = activatedRoute;
/**
* ** Feature flag to enforce Route reuse in native way provided from Taurus NgRx.
*
* - Introduced for backward compatibility.
* - Default value is false, and continues to operate like previous major version.
* - If set to true will enforce Route reuse strategy and will re-initialize Component with new Model for the new params.
*/
this.enforceRouteReuse = false;
}
/**
* ** Navigate to page using {@link NavigationService.navigateTo}.
*/
navigateTo(replaceValues) {
return this.navigationService.navigateTo(replaceValues);
}
/**
* ** Navigate back to previous page using {@link NavigationService.navigateBack}.
*/
navigateBack(replaceValues) {
return this.navigationService.navigateBack(replaceValues);
}
/**
* @inheritDoc
*/
ngOnInit() {
this.bindModel();
this.initializeRouteReuse();
}
/**
* @inheritDoc
*/
ngOnDestroy() {
this.setStateIdle();
super.ngOnDestroy();
}
/**
* ** Invoking method register subscriber for Taurus NgRx Redux Store mutation in context of {@link ComponentState.routePathSegments},
* which binds {@link ComponentModel} to {@link TaurusBaseComponent.model}
* and start invocation of Taurus NgRx Redux Component lifecycle hooks.
*
* <b>Invocation order:</b>
*
* 1. {@link OnTaurusModelInit}
* 2. {@link OnTaurusModelInitialLoad} or {@link OnTaurusModelFirstLoad} - only one could be invoke,
* where deprecated shouldn't be implemented anymore.
* 3. {@link OnTaurusModelLoad}
* 4. {@link OnTaurusModelChange} when status is {@link LOADED}
* 5. {@link OnTaurusModelError} or {@link OnTaurusModelFail} when status is {@link FAILED} - only one could be invoke,
* where deprecated shouldn't be implemented anymore.
*
* <p>
* <br>
* Override it if you want to change default behavior.
* </p>
*
* @protected
*/
bindModel() {
let isOnModelInitialLoadExecuted = false;
if (!TaurusBaseComponent._routeStateFactory) {
TaurusBaseComponent._routeStateFactory = new RouteStateFactory();
}
const routeState = TaurusBaseComponent._routeStateFactory.create(this.activatedRoute.snapshot, null);
this.componentService.init(this.uuid, routeState).subscribe((model) => {
this.model = model;
TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelInit', model);
});
this._modelSubscription = this.componentService.getModel(this.uuid, routeState.routePathSegments).subscribe((model) => {
if (!isOnModelInitialLoadExecuted) {
isOnModelInitialLoadExecuted = true;
if (!TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelInitialLoad', model)) {
TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelFirstLoad', model);
}
}
this.evaluateTaurusComponentLifecycleHooks(model);
});
this.subscriptions.push(this._modelSubscription);
}
/**
* ** Evaluates Taurus NgRx Redux Component lifecycle hooks
* ({@link OnTaurusModelLoad} and {@link OnTaurusModelChange} and ({@link OnTaurusModelFail} or {@link OnTaurusModelError})).
*
* - Override it if you want to change default behavior.
*
* @protected
*/
evaluateTaurusComponentLifecycleHooks(model) {
TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelLoad', model);
if (!this.isModelModified(model)) {
return;
}
const previousModel = this.model;
this.refreshModel(model);
if (model.status === FAILED) {
const previousErrorRecords = previousModel instanceof ComponentModel ? previousModel.getComponentState().errors.records : [];
const distinctErrorRecordsFromPreviousCycle = model.getComponentState().errors.distinctErrorRecords(previousErrorRecords);
if (!TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelError', model, distinctErrorRecordsFromPreviousCycle)) {
TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelFail', model);
}
}
else {
TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelChange', model);
}
try {
this.normalizeModelState(model);
}
catch (e) {
console.error(`Taurus NgRx Redux failed to normalize ComponentModel!`, e);
}
}
/**
* ** Refresh model field {@link TaurusBaseComponent.model} with new one,
* and assigns previous model reference to field {@link ComponentModel.previousModel} in the new model,
* to the max depth 3.
*
* - All assignments are by reference.
* - Override it if you want to change default behavior.
* - <b>Be cautious about your changes and intents!</b> It could affect features thar depend on this method Impl.
*
* @protected
*/
refreshModel(model) {
// purge component ErrorStore with data from ComponentModel ErrorStore
this.errors.purge(model.getComponentState().errors);
// assign current model as previous to the new one
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
model['previousModel'] = this.model; // eslint-disable-line @typescript-eslint/dot-notation
// clean previous models that exceed max depth 3
try {
let depthLevel = 1;
let previousModel = model.previousModel;
while (previousModel instanceof ComponentModel) {
if (++depthLevel <= 3) {
previousModel = previousModel.previousModel;
}
else {
if (previousModel.previousModel) {
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
delete previousModel['previousModel']; // eslint-disable-line @typescript-eslint/dot-notation
}
break;
}
}
}
catch (e) {
console.error('Failed to clean previous ComponentModel', e);
}
// assign model as current
this.model = model;
}
/**
* ** Normalize Model state, by default it clear Task field in {@link ComponentState.task} and update model in Taurus NgRx Redux Store.
*
* - It is invoked only if {@link ComponentModel} is modified and after invocation of all Taurus components lifecycle hooks.
* - Override it if you want to change default behavior.
*
* @protected
*/
normalizeModelState(model) {
this.componentService.update(model.clearTask().getComponentState());
}
/**
* ** Set Model state in IDLE to stop listening on Events from Store.
*
* - It is invoked by default before Component is destroyed, in Angular lifecycle hook {@link OnDestroy}.
* - Override it if you want to change default behavior.
*
* @protected
*/
setStateIdle() {
this.componentService.idle(this.model.prepareForDestroy().getComponentState());
}
/**
* ** Evaluation of this method acknowledge that new {@link ComponentModel} is modified or not.
*
* - Comparison is evaluated between provided Model and assigned Component's Model {@link TaurusBaseComponent.model}.
* - Default implementation use {@link ComponentModel.isModified} for deep Comparison of specific fields.
* - Override it if you want to change default behavior.
*
* <p>
* <b>Be cautious about your changes and intents!</b>
* Examples what can wrong comparison do?
* </p>
*
* 1. Infinite lifecycle hooks invocation, where consequences are: performance deterioration or application freeze.
* 2. Prevent lifecycle hooks invocation, where consequences are: your Data never arrive to your Component fields.
*
* @protected
*/
isModelModified(model) {
return model.isModified(this.model);
}
/**
* ** Initialize Route reuse strategy for Component in context of Taurus NgRx.
* - Turns on listener for Activated params change and if detects mutation
* sets current model in current RoutePathSegment to idle,
* and bind for new model stream to the new RoutePathSegment.
* - New feature this is completely backward compatible,
* and it can be turned on with feature flag per Component Class.
*
* @protected
*/
initializeRouteReuse() {
if (!this.enforceRouteReuse) {
return;
}
let previousParams;
this.subscriptions.push(this.activatedRoute.params.subscribe((params) => {
if (CollectionsUtil.isNil(previousParams)) {
previousParams = params;
return;
}
if (!CollectionsUtil.isEqual(previousParams, params)) {
previousParams = params;
const isRemoveSuccessful = this.removeSubscriptionRef(this._modelSubscription);
if (isRemoveSuccessful) {
// set current RoutePathSegment model state to idle
this.setStateIdle();
// bind new model stream to new RoutePathSegment
this.bindModel();
}
}
}));
}
/**
* ** Invoke Taurus NgRx Redux Component lifecycle hook.
*
* - Lifecycle hooks are invoked only if implementation they are found as implemented in subclasses.
* - Returns true if method is found and executed, otherwise false.
*
* @private
*/
// eslint-disable-next-line @typescript-eslint/member-ordering
static _executeTaurusComponentHook(instance, method, model, ...additionalParams) {
// eslint-disable-line @typescript-eslint/no-explicit-any
if (CollectionsUtil.isFunction(instance[method])) {
const currentTask = model.getTask();
try {
if (CollectionsUtil.isString(currentTask)) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-call
instance[method](model, currentTask, ...additionalParams);
}
else {
// eslint-disable-next-line @typescript-eslint/no-unsafe-call
instance[method](model, undefined, ...additionalParams);
}
}
catch (e) {
console.error(`Taurus NgRx Redux failed to execute lifecycle hook "${method}"!`, e);
}
return true;
}
return false;
}
}
/**
* @inheritDoc
*/
TaurusBaseComponent.CLASS_NAME = 'TaurusBaseComponent';
/**
* @inheritDoc
*/
TaurusBaseComponent.PUBLIC_NAME = 'Taurus-Base-Component';
TaurusBaseComponent.ɵfac = function TaurusBaseComponent_Factory(t) { i0.ɵɵinvalidFactory(); };
TaurusBaseComponent.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: TaurusBaseComponent, features: [i0.ɵɵInheritDefinitionFeature] });
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TaurusBaseComponent, [{
type: Directive
}], function () { return [{ type: i1.ComponentService }, { type: i2.NavigationService }, { type: i3.ActivatedRoute }, { type: undefined }]; }, null); })();
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"taurus-base.component.js","sourceRoot":"","sources":["../../../../../../../../projects/shared/src/lib/core/component/components/redux-base/taurus-base.component.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2023-2025 Broadcom\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/* eslint-disable @angular-eslint/directive-class-suffix */\n\nimport { Directive, OnDestroy, OnInit } from '@angular/core';\nimport { ActivatedRoute, Params } from '@angular/router';\n\nimport { Subscription } from 'rxjs';\n\nimport { ArrayElement, CollectionsUtil } from '../../../../utils';\n\nimport { ErrorRecord, TaurusNavigateAction } from '../../../../common';\n\nimport { NavigationService } from '../../../navigation';\nimport { RouteStateFactory } from '../../../router/factory';\n\nimport { ComponentModel, FAILED } from '../../model';\nimport { ComponentService } from '../../services';\n\nimport { TaurusErrorBaseComponent } from '../error-base';\n\nimport { TaurusComponentHooks } from './interfaces';\n\n/**\n * ** Superclass Component for all other Components that want to use NgRx Store and all lifecycle hooks from Taurus.\n */\n@Directive()\nexport abstract class TaurusBaseComponent extends TaurusErrorBaseComponent implements OnInit, OnDestroy {\n    /**\n     * @inheritDoc\n     */\n    static override readonly CLASS_NAME: string = 'TaurusBaseComponent';\n\n    /**\n     * @inheritDoc\n     */\n    static override readonly PUBLIC_NAME: string = 'Taurus-Base-Component';\n\n    private static _routeStateFactory: RouteStateFactory;\n\n    /**\n     * ** Field that hold Component Model.\n     */\n    model: ComponentModel;\n\n    /**\n     * ** UUID is identifier for every Subclass in Components state Store.\n     */\n    abstract readonly uuid: string;\n\n    /**\n     * ** Feature flag to enforce Route reuse in native way provided from Taurus NgRx.\n     *\n     *      - Introduced for backward compatibility.\n     *      - Default value is false, and continues to operate like previous major version.\n     *      - If set to true will enforce Route reuse strategy and will re-initialize Component with new Model for the new params.\n     */\n    enforceRouteReuse = false;\n\n    /**\n     * ** Model subscription ref.\n     * @private\n     */\n    private _modelSubscription: Subscription;\n\n    /**\n     * ** Constructor.\n     */\n    protected constructor(\n        protected readonly componentService: ComponentService,\n        protected readonly navigationService: NavigationService,\n        protected readonly activatedRoute: ActivatedRoute,\n        className: string = null\n    ) {\n        super(className ?? TaurusBaseComponent.CLASS_NAME);\n    }\n\n    /**\n     * ** Navigate to page using {@link NavigationService.navigateTo}.\n     */\n    navigateTo(replaceValues?: { [key: string]: ArrayElement<TaurusNavigateAction['replacers']>['replaceValue'] }): Promise<boolean> {\n        return this.navigationService.navigateTo(replaceValues);\n    }\n\n    /**\n     * ** Navigate back to previous page using {@link NavigationService.navigateBack}.\n     */\n    navigateBack(replaceValues?: { [key: string]: ArrayElement<TaurusNavigateAction['replacers']>['replaceValue'] }): Promise<boolean> {\n        return this.navigationService.navigateBack(replaceValues);\n    }\n\n    /**\n     * @inheritDoc\n     */\n    ngOnInit() {\n        this.bindModel();\n\n        this.initializeRouteReuse();\n    }\n\n    /**\n     * @inheritDoc\n     */\n    override ngOnDestroy() {\n        this.setStateIdle();\n\n        super.ngOnDestroy();\n    }\n\n    /**\n     * ** Invoking method register subscriber for Taurus NgRx Redux Store mutation in context of {@link ComponentState.routePathSegments},\n     *      which binds {@link ComponentModel} to {@link TaurusBaseComponent.model}\n     *      and start invocation of Taurus NgRx Redux Component lifecycle hooks.\n     *\n     *      <b>Invocation order:</b>\n     *\n     *      1. {@link OnTaurusModelInit}\n     *      2. {@link OnTaurusModelInitialLoad} or {@link OnTaurusModelFirstLoad} - only one could be invoke,\n     *              where deprecated shouldn't be implemented anymore.\n     *      3. {@link OnTaurusModelLoad}\n     *      4. {@link OnTaurusModelChange} when status is {@link LOADED}\n     *      5. {@link OnTaurusModelError} or {@link OnTaurusModelFail} when status is {@link FAILED} - only one could be invoke,\n     *              where deprecated shouldn't be implemented anymore.\n     *\n     *      <p>\n     *          <br>\n     *          Override it if you want to change default behavior.\n     *      </p>\n     *\n     * @protected\n     */\n    protected bindModel(): void {\n        let isOnModelInitialLoadExecuted = false;\n\n        if (!TaurusBaseComponent._routeStateFactory) {\n            TaurusBaseComponent._routeStateFactory = new RouteStateFactory();\n        }\n\n        const routeState = TaurusBaseComponent._routeStateFactory.create(this.activatedRoute.snapshot, null);\n\n        this.componentService.init(this.uuid, routeState).subscribe((model) => {\n            this.model = model;\n\n            TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelInit', model);\n        });\n\n        this._modelSubscription = this.componentService.getModel(this.uuid, routeState.routePathSegments).subscribe((model) => {\n            if (!isOnModelInitialLoadExecuted) {\n                isOnModelInitialLoadExecuted = true;\n                if (!TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelInitialLoad', model)) {\n                    TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelFirstLoad', model);\n                }\n            }\n\n            this.evaluateTaurusComponentLifecycleHooks(model);\n        });\n\n        this.subscriptions.push(this._modelSubscription);\n    }\n\n    /**\n     * ** Evaluates Taurus NgRx Redux Component lifecycle hooks\n     *      ({@link OnTaurusModelLoad} and {@link OnTaurusModelChange} and ({@link OnTaurusModelFail} or {@link OnTaurusModelError})).\n     *\n     *      - Override it if you want to change default behavior.\n     *\n     * @protected\n     */\n    protected evaluateTaurusComponentLifecycleHooks(model: ComponentModel): void {\n        TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelLoad', model);\n\n        if (!this.isModelModified(model)) {\n            return;\n        }\n\n        const previousModel = this.model;\n\n        this.refreshModel(model);\n\n        if (model.status === FAILED) {\n            const previousErrorRecords: ErrorRecord[] =\n                previousModel instanceof ComponentModel ? previousModel.getComponentState().errors.records : [];\n            const distinctErrorRecordsFromPreviousCycle = model.getComponentState().errors.distinctErrorRecords(previousErrorRecords);\n\n            if (!TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelError', model, distinctErrorRecordsFromPreviousCycle)) {\n                TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelFail', model);\n            }\n        } else {\n            TaurusBaseComponent._executeTaurusComponentHook(this, 'onModelChange', model);\n        }\n\n        try {\n            this.normalizeModelState(model);\n        } catch (e) {\n            console.error(`Taurus NgRx Redux failed to normalize ComponentModel!`, e);\n        }\n    }\n\n    /**\n     * ** Refresh model field {@link TaurusBaseComponent.model} with new one,\n     *      and assigns previous model reference to field {@link ComponentModel.previousModel} in the new model,\n     *      to the max depth 3.\n     *\n     *      - All assignments are by reference.\n     *      - Override it if you want to change default behavior.\n     *      - <b>Be cautious about your changes and intents!</b> It could affect features thar depend on this method Impl.\n     *\n     * @protected\n     */\n    protected refreshModel(model: ComponentModel): void {\n        // purge component ErrorStore with data from ComponentModel ErrorStore\n        this.errors.purge(model.getComponentState().errors);\n\n        // assign current model as previous to the new one\n        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n        // @ts-ignore\n        model['previousModel'] = this.model; // eslint-disable-line @typescript-eslint/dot-notation\n\n        // clean previous models that exceed max depth 3\n        try {\n            let depthLevel = 1;\n            let previousModel = model.previousModel;\n\n            while (previousModel instanceof ComponentModel) {\n                if (++depthLevel <= 3) {\n                    previousModel = previousModel.previousModel;\n                } else {\n                    if (previousModel.previousModel) {\n                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n                        // @ts-ignore\n                        delete previousModel['previousModel']; // eslint-disable-line @typescript-eslint/dot-notation\n                    }\n\n                    break;\n                }\n            }\n        } catch (e) {\n            console.error('Failed to clean previous ComponentModel', e);\n        }\n\n        // assign model as current\n        this.model = model;\n    }\n\n    /**\n     * ** Normalize Model state, by default it clear Task field in {@link ComponentState.task} and update model in Taurus NgRx Redux Store.\n     *\n     *      - It is invoked only if {@link ComponentModel} is modified and after invocation of all Taurus components lifecycle hooks.\n     *      - Override it if you want to change default behavior.\n     *\n     * @protected\n     */\n    protected normalizeModelState(model: ComponentModel): void {\n        this.componentService.update(model.clearTask().getComponentState());\n    }\n\n    /**\n     * ** Set Model state in IDLE to stop listening on Events from Store.\n     *\n     *      - It is invoked by default before Component is destroyed, in Angular lifecycle hook {@link OnDestroy}.\n     *      - Override it if you want to change default behavior.\n     *\n     * @protected\n     */\n    protected setStateIdle(): void {\n        this.componentService.idle(this.model.prepareForDestroy().getComponentState());\n    }\n\n    /**\n     * ** Evaluation of this method acknowledge that new {@link ComponentModel} is modified or not.\n     *\n     *      - Comparison is evaluated between provided Model and assigned Component's Model {@link TaurusBaseComponent.model}.\n     *      - Default implementation use {@link ComponentModel.isModified} for deep Comparison of specific fields.\n     *      - Override it if you want to change default behavior.\n     *\n     * <p>\n     *      <b>Be cautious about your changes and intents!</b>\n     *      Examples what can wrong comparison do?\n     * </p>\n     *\n     *      1. Infinite lifecycle hooks invocation, where consequences are: performance deterioration or application freeze.\n     *      2. Prevent lifecycle hooks invocation, where consequences are: your Data never arrive to your Component fields.\n     *\n     * @protected\n     */\n    protected isModelModified(model: ComponentModel): boolean {\n        return model.isModified(this.model);\n    }\n\n    /**\n     * ** Initialize Route reuse strategy for Component in context of Taurus NgRx.\n     *      - Turns on listener for Activated params change and if detects mutation\n     *              sets current model in current RoutePathSegment to idle,\n     *              and bind for new model stream to the new RoutePathSegment.\n     *      - New feature this is completely backward compatible,\n     *              and it can be turned on with feature flag per Component Class.\n     *\n     * @protected\n     */\n    protected initializeRouteReuse(): void {\n        if (!this.enforceRouteReuse) {\n            return;\n        }\n\n        let previousParams: Params;\n\n        this.subscriptions.push(\n            this.activatedRoute.params.subscribe((params) => {\n                if (CollectionsUtil.isNil(previousParams)) {\n                    previousParams = params;\n\n                    return;\n                }\n\n                if (!CollectionsUtil.isEqual(previousParams, params)) {\n                    previousParams = params;\n\n                    const isRemoveSuccessful = this.removeSubscriptionRef(this._modelSubscription);\n                    if (isRemoveSuccessful) {\n                        // set current RoutePathSegment model state to idle\n                        this.setStateIdle();\n                        // bind new model stream to new RoutePathSegment\n                        this.bindModel();\n                    }\n                }\n            })\n        );\n    }\n\n    /**\n     * ** Invoke Taurus NgRx Redux Component lifecycle hook.\n     *\n     *      - Lifecycle hooks are invoked only if implementation they are found as implemented in subclasses.\n     *      - Returns true if method is found and executed, otherwise false.\n     *\n     * @private\n     */\n    // eslint-disable-next-line @typescript-eslint/member-ordering\n    private static _executeTaurusComponentHook(\n        instance: TaurusBaseComponent,\n        method: keyof TaurusComponentHooks,\n        model: ComponentModel,\n        ...additionalParams: any[]\n    ): boolean {\n        // eslint-disable-line @typescript-eslint/no-explicit-any\n\n        if (CollectionsUtil.isFunction(instance[method])) {\n            const currentTask = model.getTask();\n\n            try {\n                if (CollectionsUtil.isString(currentTask)) {\n                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n                    instance[method](model, currentTask, ...additionalParams);\n                } else {\n                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call\n                    instance[method](model, undefined, ...additionalParams);\n                }\n            } catch (e) {\n                console.error(`Taurus NgRx Redux failed to execute lifecycle hook \"${method}\"!`, e);\n            }\n\n            return true;\n        }\n\n        return false;\n    }\n}\n"]}