igniteui-angular
Version:
Ignite UI for Angular is a dependency-free Angular toolkit for building modern web apps
392 lines • 41.5 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { TransactionType } from './transaction';
import { IgxBaseTransactionService } from './base-transaction';
import { EventEmitter, Injectable } from '@angular/core';
import { isObject, mergeObjects, cloneValue } from '../../core/utils';
/**
* @template T, S
*/
export class IgxTransactionService extends IgxBaseTransactionService {
constructor() {
super(...arguments);
this._transactions = [];
this._redoStack = [];
this._undoStack = [];
this._states = new Map();
/**
* \@inheritdoc
*/
this.onStateUpdate = new EventEmitter();
}
/**
* \@inheritdoc
* @return {?}
*/
get canUndo() {
return this._undoStack.length > 0;
}
/**
* \@inheritdoc
* @return {?}
*/
get canRedo() {
return this._redoStack.length > 0;
}
/**
* \@inheritdoc
* @param {?} transaction
* @param {?=} recordRef
* @return {?}
*/
add(transaction, recordRef) {
/** @type {?} */
const states = this._isPending ? this._pendingStates : this._states;
this.verifyAddedTransaction(states, transaction, recordRef);
this.addTransaction(transaction, states, recordRef);
}
/**
* @protected
* @param {?} transaction
* @param {?} states
* @param {?=} recordRef
* @return {?}
*/
addTransaction(transaction, states, recordRef) {
this.updateState(states, transaction, recordRef);
/** @type {?} */
const transactions = this._isPending ? this._pendingTransactions : this._transactions;
transactions.push(transaction);
if (!this._isPending) {
this._undoStack.push([{ transaction, recordRef }]);
this._redoStack = [];
this.onStateUpdate.emit();
}
}
/**
* \@inheritdoc
* @param {?=} id
* @return {?}
*/
getTransactionLog(id) {
if (id) {
return this._transactions.filter(t => t.id === id);
}
return [...this._transactions];
}
/**
* \@inheritdoc
* @param {?} mergeChanges
* @return {?}
*/
getAggregatedChanges(mergeChanges) {
/** @type {?} */
const result = [];
this._states.forEach((state, key) => {
/** @type {?} */
const value = mergeChanges ? this.mergeValues(state.recordRef, state.value) : state.value;
result.push((/** @type {?} */ ({ id: key, newValue: value, type: state.type })));
});
return result;
}
/**
* \@inheritdoc
* @param {?} id
* @return {?}
*/
getState(id) {
return this._states.get(id);
}
/**
* \@inheritdoc
* @return {?}
*/
get enabled() {
return true;
}
/**
* \@inheritdoc
* @param {?} id
* @param {?} mergeChanges
* @return {?}
*/
getAggregatedValue(id, mergeChanges) {
/** @type {?} */
const state = this._states.get(id);
/** @type {?} */
const pendingState = super.getState(id);
// if there is no state and there is no pending state return null
if (!state && !pendingState) {
return null;
}
/** @type {?} */
const pendingChange = super.getAggregatedValue(id, false);
/** @type {?} */
const change = state && state.value;
/** @type {?} */
let aggregatedValue = this.mergeValues(change, pendingChange);
if (mergeChanges) {
/** @type {?} */
const originalValue = state ? state.recordRef : pendingState.recordRef;
aggregatedValue = this.mergeValues(originalValue, aggregatedValue);
}
return aggregatedValue;
}
/**
* \@inheritdoc
* @param {?} commit
* @return {?}
*/
endPending(commit) {
this._isPending = false;
if (commit) {
/** @type {?} */
const actions = [];
// don't use addTransaction due to custom undo handling
for (const transaction of this._pendingTransactions) {
/** @type {?} */
const pendingState = this._pendingStates.get(transaction.id);
this._transactions.push(transaction);
this.updateState(this._states, transaction, pendingState.recordRef);
actions.push({ transaction, recordRef: pendingState.recordRef });
}
this._undoStack.push(actions);
this._redoStack = [];
this.onStateUpdate.emit();
}
super.endPending(commit);
}
/**
* \@inheritdoc
* @param {?} data
* @return {?}
*/
commit(data) {
this._states.forEach((s) => {
/** @type {?} */
const index = data.findIndex(i => JSON.stringify(i) === JSON.stringify(s.recordRef));
switch (s.type) {
case TransactionType.ADD:
data.push(s.value);
break;
case TransactionType.DELETE:
if (0 <= index && index < data.length) {
data.splice(index, 1);
}
break;
case TransactionType.UPDATE:
if (0 <= index && index < data.length) {
data[index] = this.updateValue(s);
}
break;
}
});
this.clear();
}
/**
* \@inheritdoc
* @return {?}
*/
clear() {
this._transactions = [];
this._states.clear();
this._redoStack = [];
this._undoStack = [];
this.onStateUpdate.emit();
}
/**
* \@inheritdoc
* @return {?}
*/
undo() {
if (this._undoStack.length <= 0) {
return;
}
/** @type {?} */
const lastActions = this._undoStack.pop();
this._transactions.splice(this._transactions.length - lastActions.length);
this._redoStack.push(lastActions);
this._states.clear();
for (const currentActions of this._undoStack) {
for (const transaction of currentActions) {
this.updateState(this._states, transaction.transaction, transaction.recordRef);
}
}
this.onStateUpdate.emit();
}
/**
* \@inheritdoc
* @return {?}
*/
redo() {
if (this._redoStack.length > 0) {
/** @type {?} */
let actions;
actions = this._redoStack.pop();
for (const action of actions) {
this.updateState(this._states, action.transaction, action.recordRef);
this._transactions.push(action.transaction);
}
this._undoStack.push(actions);
this.onStateUpdate.emit();
}
}
/**
* Verifies if the passed transaction is correct. If not throws an exception.
* @protected
* @param {?} states
* @param {?} transaction Transaction to be verified
* @param {?=} recordRef
* @return {?}
*/
verifyAddedTransaction(states, transaction, recordRef) {
/** @type {?} */
const state = states.get(transaction.id);
switch (transaction.type) {
case TransactionType.ADD:
if (state) {
// cannot add same item twice
throw new Error(`Cannot add this transaction. Transaction with id: ${transaction.id} has been already added.`);
}
break;
case TransactionType.DELETE:
case TransactionType.UPDATE:
if (state && state.type === TransactionType.DELETE) {
// cannot delete or update deleted items
throw new Error(`Cannot add this transaction. Transaction with id: ${transaction.id} has been already deleted.`);
}
if (!state && !recordRef && !this._isPending) {
// cannot initially add transaction or delete item with no recordRef
throw new Error(`Cannot add this transaction. This is first transaction of type ${transaction.type} ` +
`for id ${transaction.id}. For first transaction of this type recordRef is mandatory.`);
}
break;
}
}
/**
* Updates the provided states collection according to passed transaction and recordRef
* @protected
* @param {?} states States collection to apply the update to
* @param {?} transaction Transaction to apply to the current state
* @param {?=} recordRef Reference to the value of the record in data source, if any, where transaction should be applied
* @return {?}
*/
updateState(states, transaction, recordRef) {
/** @type {?} */
let state = states.get(transaction.id);
// if TransactionType is ADD simply add transaction to states;
// if TransactionType is DELETE:
// - if there is state with this id of type ADD remove it from the states;
// - if there is state with this id of type UPDATE change its type to DELETE;
// - if there is no state with this id add transaction to states;
// if TransactionType is UPDATE:
// - if there is state with this id of type ADD merge new value and state recordRef into state new value
// - if there is state with this id of type UPDATE merge new value into state new value
// - if there is state with this id and state type is DELETE change its type to UPDATE
// - if there is no state with this id add transaction to states;
if (state) {
switch (transaction.type) {
case TransactionType.DELETE:
if (state.type === TransactionType.ADD) {
states.delete(transaction.id);
}
else if (state.type === TransactionType.UPDATE) {
state.value = transaction.newValue;
state.type = TransactionType.DELETE;
}
break;
case TransactionType.UPDATE:
if (isObject(state.value)) {
if (state.type === TransactionType.ADD) {
state.value = this.mergeValues(state.value, transaction.newValue);
}
if (state.type === TransactionType.UPDATE) {
mergeObjects(state.value, transaction.newValue);
}
}
else {
state.value = transaction.newValue;
}
}
}
else {
state = (/** @type {?} */ ({ value: cloneValue(transaction.newValue), recordRef: recordRef, type: transaction.type }));
states.set(transaction.id, state);
}
// should not clean pending state. This will happen automatically on endPending call
if (!this._isPending) {
this.cleanState(transaction.id, states);
}
}
/**
* Compares the state with recordRef and clears all duplicated values. If any state ends as
* empty object removes it from states.
* @protected
* @param {?} id
* @param {?} states
* @return {?}
*/
cleanState(id, states) {
/** @type {?} */
const state = states.get(id);
// do nothing if
// there is no state, or
// there is no state value (e.g. DELETED transaction), or
// there is no recordRef (e.g. ADDED transaction)
if (state && state.value && state.recordRef) {
// if state's value is object compare each key with the ones in recordRef
// if values in any key are the same delete it from state's value
// if state's value is not object, simply compare with recordRef and remove
// the state if they are equal
if (isObject(state.recordRef)) {
for (const key of Object.keys(state.value)) {
if (JSON.stringify(state.recordRef[key]) === JSON.stringify(state.value[key])) {
delete state.value[key];
}
}
// if state's value is empty remove the state from the states, only if state is not DELETE type
if (state.type !== TransactionType.DELETE && Object.keys(state.value).length === 0) {
states.delete(id);
}
}
else {
if (state.recordRef === state.value) {
states.delete(id);
}
}
}
}
}
IgxTransactionService.decorators = [
{ type: Injectable }
];
if (false) {
/**
* @type {?}
* @protected
*/
IgxTransactionService.prototype._transactions;
/**
* @type {?}
* @protected
*/
IgxTransactionService.prototype._redoStack;
/**
* @type {?}
* @protected
*/
IgxTransactionService.prototype._undoStack;
/**
* @type {?}
* @protected
*/
IgxTransactionService.prototype._states;
/**
* \@inheritdoc
* @type {?}
*/
IgxTransactionService.prototype.onStateUpdate;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"igx-transaction.js","sourceRoot":"ng://igniteui-angular/","sources":["lib/services/transaction/igx-transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction, State, TransactionType } from './transaction';\nimport { IgxBaseTransactionService } from './base-transaction';\nimport { EventEmitter, Injectable } from '@angular/core';\nimport { isObject, mergeObjects, cloneValue } from '../../core/utils';\n\n@Injectable()\nexport class IgxTransactionService<T extends Transaction, S extends State> extends IgxBaseTransactionService<T, S> {\n    protected _transactions: T[] = [];\n    protected _redoStack: { transaction: T, recordRef: any }[][] = [];\n    protected _undoStack: { transaction: T, recordRef: any }[][] = [];\n    protected _states: Map<any, S> = new Map();\n\n    /**\n     * @inheritdoc\n     */\n    get canUndo(): boolean {\n        return this._undoStack.length > 0;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    get canRedo(): boolean {\n        return this._redoStack.length > 0;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public onStateUpdate = new EventEmitter<void>();\n\n    /**\n     * @inheritdoc\n     */\n    public add(transaction: T, recordRef?: any): void {\n        const states = this._isPending ? this._pendingStates : this._states;\n        this.verifyAddedTransaction(states, transaction, recordRef);\n        this.addTransaction(transaction, states, recordRef);\n    }\n\n    protected addTransaction(transaction: T, states: Map<any, S>, recordRef?: any) {\n        this.updateState(states, transaction, recordRef);\n\n        const transactions = this._isPending ? this._pendingTransactions : this._transactions;\n        transactions.push(transaction);\n\n        if (!this._isPending) {\n            this._undoStack.push([{ transaction, recordRef }]);\n            this._redoStack = [];\n            this.onStateUpdate.emit();\n        }\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public getTransactionLog(id?: any): T[] {\n        if (id) {\n            return this._transactions.filter(t => t.id === id);\n        }\n        return [...this._transactions];\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public getAggregatedChanges(mergeChanges: boolean): T[] {\n        const result: T[] = [];\n        this._states.forEach((state: S, key: any) => {\n            const value = mergeChanges ? this.mergeValues(state.recordRef, state.value) : state.value;\n            result.push({ id: key, newValue: value, type: state.type } as T);\n        });\n        return result;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public getState(id: any): S {\n        return this._states.get(id);\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public get enabled(): boolean {\n        return true;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public getAggregatedValue(id: any, mergeChanges: boolean): any {\n        const state = this._states.get(id);\n        const pendingState = super.getState(id);\n\n        //  if there is no state and there is no pending state return null\n        if (!state && !pendingState) {\n            return null;\n        }\n\n        const pendingChange = super.getAggregatedValue(id, false);\n        const change = state && state.value;\n        let aggregatedValue = this.mergeValues(change, pendingChange);\n        if (mergeChanges) {\n            const originalValue = state ? state.recordRef : pendingState.recordRef;\n            aggregatedValue = this.mergeValues(originalValue, aggregatedValue);\n        }\n        return aggregatedValue;\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public endPending(commit: boolean): void {\n        this._isPending = false;\n        if (commit) {\n            const actions: { transaction: T, recordRef: any }[] = [];\n            // don't use addTransaction due to custom undo handling\n            for (const transaction of this._pendingTransactions) {\n                const pendingState = this._pendingStates.get(transaction.id);\n                this._transactions.push(transaction);\n                this.updateState(this._states, transaction, pendingState.recordRef);\n                actions.push({ transaction, recordRef: pendingState.recordRef });\n            }\n\n            this._undoStack.push(actions);\n            this._redoStack = [];\n\n            this.onStateUpdate.emit();\n        }\n        super.endPending(commit);\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public commit(data: any[]): void {\n        this._states.forEach((s: S) => {\n            const index = data.findIndex(i => JSON.stringify(i) === JSON.stringify(s.recordRef));\n            switch (s.type) {\n                case TransactionType.ADD:\n                    data.push(s.value);\n                    break;\n                case TransactionType.DELETE:\n                    if (0 <= index && index < data.length) {\n                        data.splice(index, 1);\n                    }\n                    break;\n                case TransactionType.UPDATE:\n                    if (0 <= index && index < data.length) {\n                        data[index] = this.updateValue(s);\n                    }\n                    break;\n            }\n        });\n        this.clear();\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public clear(): void {\n        this._transactions = [];\n        this._states.clear();\n        this._redoStack = [];\n        this._undoStack = [];\n        this.onStateUpdate.emit();\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public undo(): void {\n        if (this._undoStack.length <= 0) {\n            return;\n        }\n\n        const lastActions: { transaction: T, recordRef: any }[] = this._undoStack.pop();\n        this._transactions.splice(this._transactions.length - lastActions.length);\n        this._redoStack.push(lastActions);\n\n        this._states.clear();\n        for (const currentActions of this._undoStack) {\n            for (const transaction of currentActions) {\n                this.updateState(this._states, transaction.transaction, transaction.recordRef);\n            }\n        }\n\n        this.onStateUpdate.emit();\n    }\n\n    /**\n     * @inheritdoc\n     */\n    public redo(): void {\n        if (this._redoStack.length > 0) {\n            let actions: { transaction: T, recordRef: any, useInUndo?: boolean }[];\n            actions = this._redoStack.pop();\n            for (const action of actions) {\n                this.updateState(this._states, action.transaction, action.recordRef);\n                this._transactions.push(action.transaction);\n            }\n\n            this._undoStack.push(actions);\n            this.onStateUpdate.emit();\n        }\n    }\n\n    /**\n     * Verifies if the passed transaction is correct. If not throws an exception.\n     * @param transaction Transaction to be verified\n     */\n    protected verifyAddedTransaction(states: Map<any, S>, transaction: T, recordRef?: any): void {\n        const state = states.get(transaction.id);\n        switch (transaction.type) {\n            case TransactionType.ADD:\n                if (state) {\n                    //  cannot add same item twice\n                    throw new Error(`Cannot add this transaction. Transaction with id: ${transaction.id} has been already added.`);\n                }\n                break;\n            case TransactionType.DELETE:\n            case TransactionType.UPDATE:\n                if (state && state.type === TransactionType.DELETE) {\n                    //  cannot delete or update deleted items\n                    throw new Error(`Cannot add this transaction. Transaction with id: ${transaction.id} has been already deleted.`);\n                }\n                if (!state && !recordRef && !this._isPending) {\n                    //  cannot initially add transaction or delete item with no recordRef\n                    throw new Error(`Cannot add this transaction. This is first transaction of type ${transaction.type} ` +\n                        `for id ${transaction.id}. For first transaction of this type recordRef is mandatory.`);\n                }\n                break;\n        }\n    }\n\n    /**\n     * Updates the provided states collection according to passed transaction and recordRef\n     * @param states States collection to apply the update to\n     * @param transaction Transaction to apply to the current state\n     * @param recordRef Reference to the value of the record in data source, if any, where transaction should be applied\n     */\n    protected updateState(states: Map<any, S>, transaction: T, recordRef?: any): void {\n        let state = states.get(transaction.id);\n        //  if TransactionType is ADD simply add transaction to states;\n        //  if TransactionType is DELETE:\n        //    - if there is state with this id of type ADD remove it from the states;\n        //    - if there is state with this id of type UPDATE change its type to DELETE;\n        //    - if there is no state with this id add transaction to states;\n        //  if TransactionType is UPDATE:\n        //    - if there is state with this id of type ADD merge new value and state recordRef into state new value\n        //    - if there is state with this id of type UPDATE merge new value into state new value\n        //    - if there is state with this id and state type is DELETE change its type to UPDATE\n        //    - if there is no state with this id add transaction to states;\n        if (state) {\n            switch (transaction.type) {\n                case TransactionType.DELETE:\n                    if (state.type === TransactionType.ADD) {\n                        states.delete(transaction.id);\n                    } else if (state.type === TransactionType.UPDATE) {\n                        state.value = transaction.newValue;\n                        state.type = TransactionType.DELETE;\n                    }\n                    break;\n                case TransactionType.UPDATE:\n                    if (isObject(state.value)) {\n                        if (state.type === TransactionType.ADD) {\n                            state.value = this.mergeValues(state.value, transaction.newValue);\n                        }\n                        if (state.type === TransactionType.UPDATE) {\n                            mergeObjects(state.value, transaction.newValue);\n                        }\n                    } else {\n                        state.value = transaction.newValue;\n                    }\n            }\n        } else {\n            state = { value: cloneValue(transaction.newValue), recordRef: recordRef, type: transaction.type } as S;\n            states.set(transaction.id, state);\n        }\n\n        //  should not clean pending state. This will happen automatically on endPending call\n        if (!this._isPending) {\n            this.cleanState(transaction.id, states);\n        }\n    }\n\n    /**\n     * Compares the state with recordRef and clears all duplicated values. If any state ends as\n     * empty object removes it from states.\n     * @param state State to clean\n     */\n    protected cleanState(id: any, states: Map<any, S>): void {\n        const state = states.get(id);\n        //  do nothing if\n        //  there is no state, or\n        //  there is no state value (e.g. DELETED transaction), or\n        //  there is no recordRef (e.g. ADDED transaction)\n        if (state && state.value && state.recordRef) {\n            //  if state's value is object compare each key with the ones in recordRef\n            //  if values in any key are the same delete it from state's value\n            //  if state's value is not object, simply compare with recordRef and remove\n            //  the state if they are equal\n            if (isObject(state.recordRef)) {\n                for (const key of Object.keys(state.value)) {\n                    if (JSON.stringify(state.recordRef[key]) === JSON.stringify(state.value[key])) {\n                        delete state.value[key];\n                    }\n                }\n\n                //  if state's value is empty remove the state from the states, only if state is not DELETE type\n                if (state.type !== TransactionType.DELETE && Object.keys(state.value).length === 0) {\n                    states.delete(id);\n                }\n            } else {\n                if (state.recordRef === state.value) {\n                    states.delete(id);\n                }\n            }\n        }\n    }\n}\n"]}