@bizdoc/core 1.13.12 → 1.13.16

package/esm2020/lib/admin/diff/configuration-diff.component.mjs

@@ -0,0 +1,558 @@
+import { __decorate } from "tslib";
+import { Component, Inject, ViewChild } from '@angular/core';
+import { Subject } from 'rxjs';
+import { debounceTime, takeUntil } from 'rxjs/operators';
+import { BizDoc } from '../../core/decorators';
+import { isArray, isObject, isString } from '../../core/functions';
+import { UtilityRef } from '../utility-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/prompt.service";
+import * as i2 from "../../core/translate.service";
+import * as i3 from "../../core/datasource.service";
+import * as i4 from "../../core/account.service";
+import * as i5 from "@angular/material/toolbar";
+import * as i6 from "@angular/material/button";
+import * as i7 from "@angular/material/icon";
+import * as i8 from "@angular/material/sidenav";
+import * as i9 from "@angular/material/progress-bar";
+import * as i10 from "@angular/material/list";
+import * as i11 from "../../core/popup/tooltip.directive";
+import * as i12 from "@angular/flex-layout/flex";
+import * as i13 from "@angular/common";
+import * as i14 from "@angular/material/core";
+import * as i15 from "../../core/pipes/translate.pipe";
+import * as i16 from "../../core/pipes/sanitize-html.pipe";
+import * as i17 from "../../core/pipes/user-name.pipe";
+import * as i18 from "../../core/pipes/calendar.pipe";
+import * as i19 from "../utility-ref";
+const IGNORE_NODE = ['author', 'history', 'targetDecorator', 'sourceDecorator', 'offsetX', 'offsetY', 'rotateAngle', 'width', 'height',
+    'style', 'segments', 'offset', 'targetPortID', 'sourcePortID', 'horizontalAlignment', 'verticalAlignment', 'workflow.timestamp',
+    'connectors.constraints', 'nodes.constraints', 'annotations.constraints', 'annotations.id'], SVG_PATH_REGEX = /^[mM].+[zZ]$/, INDEX_PROPERTY = ['name', 'id'], DATA_TYPE = 'dataType', ORIGINAL_VALUE = '_', STATE = '__';
+let SystemDiffComponent = class SystemDiffComponent {
+    /** ctor */
+    constructor(_sb, _utilityRef, _translate, _ds, _accounts) {
+        this._sb = _sb;
+        this._utilityRef = _utilityRef;
+        this._translate = _translate;
+        this._ds = _ds;
+        this._accounts = _accounts;
+        this.html = '';
+        this.progress = 0;
+        this._working = new Subject();
+        this.CALENDAR_SPEC = {
+            lastDay: `[${this._translate.get('Yesterday')}] HH:mm`,
+            lastWeek: 'ddd HH:mm',
+            sameDay: 'HH:mm',
+            sameElse: 'MMM D HH:mm'
+        };
+        this._destroy = new Subject();
+    }
+    ngOnInit() {
+        // delay progress
+        this._working.pipe(takeUntil(this._destroy), debounceTime(100)).subscribe(v => v && (this.progress = v));
+        this._working.next(50);
+        // populate versions
+        this._utilityRef.populate().subscribe(e => {
+            this.versions = e;
+            this._working.next(100);
+            e.length > 1 &&
+                this.compare(0);
+        }, () => this._sb.error());
+    }
+    /**
+     *
+     * @param index
+     */
+    compare(index) {
+        const { time: date1, file } = this.versions[index], version = this.versions.slice(index + 1).find(v => v.file === file);
+        if (!version)
+            return;
+        const { time: date2 } = version;
+        this._working.next(25);
+        this._utilityRef.execute({ date1, date2 }).subscribe(r => {
+            this.html = '';
+            this._working.next(50);
+            this.activeDate = date1;
+            const results = this._compare(r[0], r[1]);
+            if (results)
+                results.then(d => {
+                    this._working.next(75);
+                    this.html = this._generate(d);
+                    this._scrollTop();
+                    this._working.next(100);
+                    this.none = false;
+                });
+            else {
+                this._working.next(100);
+                this.none = true;
+            }
+        }, () => this._sb.error());
+    }
+    _scrollTop() {
+        setTimeout(() => this.contents.nativeElement.parentElement.scroll({ top: 0, behavior: 'smooth' }));
+    }
+    /**
+     *
+     * @param a
+     * @param b
+     * @param diff
+     * @param scope
+     */
+    _compare(a, b, diff = {}, scope = { nodes: [] }) {
+        const promises = [];
+        if (isArray(a)) {
+            a.forEach((e, i) => {
+                const bVal = b[i];
+                if (e === bVal)
+                    return;
+                else if (isObject(e)) {
+                    const aJson = JSON.stringify(e), bJson = JSON.stringify(bVal);
+                    if (aJson === bJson)
+                        return;
+                    if (bVal && this._match(bVal, e)) {
+                        const obj = {};
+                        const promise = this._compare(e, bVal, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });
+                        if (!promise)
+                            return;
+                        diff.push(this._rekey(e, obj, scope.nodes));
+                        promises.push(promise);
+                    }
+                    else if (b.find(b => JSON.stringify(b) === aJson))
+                        return;
+                    else {
+                        const bObj = b.find(b => this._match(b, e));
+                        if (bObj) {
+                            const obj = {};
+                            const promise = this._compare(e, bObj, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });
+                            if (!promise)
+                                return;
+                            diff.push(this._rekey(e, obj, scope.nodes));
+                            promises.push(promise);
+                        }
+                        else {
+                            const obj = isArray(e) ? [] : {};
+                            const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });
+                            if (!promise)
+                                return;
+                            const length = diff.push(obj);
+                            diff[STATE + (length - 1).toString()] = ChangeState.Added;
+                            promises.push(promise);
+                        }
+                    }
+                }
+                else if (!b.find(b => b == e)) {
+                    const length = diff.push(e);
+                    if (scope.nodes.indexOf('positions') > -1) {
+                        const promise = this._accounts.get(e).toPromise().then(v => diff[length - 1] = v.name);
+                        promises.push(promise);
+                    }
+                    diff[STATE + (length - 1).toString()] = ChangeState.Added;
+                }
+            });
+            b.forEach((e, i) => {
+                if (e !== a[i]) {
+                    if (isObject(e)) {
+                        const bJson = JSON.stringify(e);
+                        if (bJson === JSON.stringify(a[i]) || a.find(a => JSON.stringify(a) === bJson ||
+                            this._match(a, e)))
+                            return;
+                        const obj = isArray(e) ? [] : {};
+                        const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });
+                        if (!promise)
+                            return;
+                        const length = diff.push(obj);
+                        diff[STATE + (length - 1).toString()] = ChangeState.Removed;
+                        promises.push(promise);
+                    }
+                    else if (!a.find(a => a == e)) {
+                        const length = diff.push(e);
+                        if (scope.nodes.indexOf('positions') > -1) {
+                            const promise = this._accounts.get(e).toPromise().then(v => diff[length - 1] = v.name);
+                            promises.push(promise);
+                        }
+                        diff[STATE + (length - 1).toString()] = ChangeState.Removed;
+                    }
+                }
+            });
+            if (!diff.length)
+                return false;
+        }
+        else {
+            Object.keys(a).forEach(k => {
+                if (this._ignore(k, scope.nodes))
+                    return;
+                const aVal = a[k], bVal = b[k];
+                if (aVal === bVal)
+                    return;
+                else if (isObject(aVal)) {
+                    if (JSON.stringify(aVal) === JSON.stringify(bVal))
+                        return;
+                    if (bVal !== undefined && isArray(bVal) !== isArray(aVal)) {
+                        diff[k] = aVal;
+                        diff[ORIGINAL_VALUE + k] = isArray(bVal) ? bVal.join(', ') : bVal;
+                        diff[STATE + k] = ChangeState.Modified;
+                    }
+                    else {
+                        let obj = isArray(aVal) ? [] : {}, extra = { type: aVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] };
+                        if (bVal !== undefined) {
+                            const promise = this._compare(aVal, bVal, obj, extra);
+                            if (!promise)
+                                return;
+                            if (!isArray(aVal))
+                                obj = this._rekey(aVal, obj, scope.nodes);
+                            promises.push(promise);
+                        }
+                        else {
+                            const promise = this._branch(aVal, obj, extra);
+                            if (!promise)
+                                return;
+                            promises.push(promise);
+                        }
+                        if (scope.nodes.indexOf('positions') > -1) {
+                            diff[ORIGINAL_VALUE + k] = aVal;
+                            const promise = this._ds.get(scope.type, k).toPromise().then(v => {
+                                const name = isString(v) ? v : v[Object.keys(v)[0]];
+                                diff[name] = obj;
+                                if (bVal === undefined)
+                                    diff[STATE + name] = ChangeState.Added;
+                            });
+                            promises.push(promise);
+                        }
+                        else {
+                            diff[k] = obj;
+                            if (bVal === undefined)
+                                diff[STATE + k] = ChangeState.Added;
+                        }
+                    }
+                }
+                else {
+                    diff[k] = aVal;
+                    if (k === 'userId') {
+                        const promise = this._accounts.get(aVal).toPromise().then(v => diff[k] = v.name);
+                        promises.push(promise);
+                    }
+                    if (bVal !== undefined) {
+                        if (k === 'userId') {
+                            const promise = this._accounts.get(bVal).toPromise().then(v => diff[ORIGINAL_VALUE + k] = v.name);
+                            promises.push(promise);
+                        }
+                        else
+                            diff[ORIGINAL_VALUE + k] = bVal;
+                        diff[STATE + k] = ChangeState.Modified;
+                    }
+                    else
+                        diff[STATE + k] = ChangeState.Added;
+                }
+            });
+            Object.keys(b).forEach(k => {
+                if (a[k] !== undefined || this._ignore(k, scope.nodes))
+                    return;
+                const bVal = b[k];
+                if (scope.nodes.indexOf('positions') > -1) {
+                    const obj = [];
+                    diff[ORIGINAL_VALUE + k] = bVal;
+                    const promise = this._ds.get(scope.type, k).toPromise().then(v => {
+                        const name = isString(v) ? v : v[Object.keys(v)[0]];
+                        diff[name] = obj;
+                        diff[STATE + name] = ChangeState.Removed;
+                    });
+                    promises.push(promise);
+                    bVal && bVal.forEach((e, i) => {
+                        const promise = this._accounts.get(e).toPromise().then(v => obj[i] = v.name);
+                        promises.push(promise);
+                    });
+                }
+                else {
+                    if (isObject(bVal)) {
+                        const obj = isArray(bVal) ? [] : {};
+                        const promise = this._branch(bVal, obj, { type: bVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] });
+                        if (!promise)
+                            return;
+                        diff[k] = obj;
+                        promise && promises.push(promise);
+                    }
+                    else {
+                        diff[k] = bVal;
+                        if (k === 'userId') {
+                            const promise = this._accounts.get(bVal).toPromise().then(v => diff[k] = v.name);
+                            promises.push(promise);
+                        }
+                    }
+                    diff[STATE + k] = ChangeState.Removed;
+                }
+            });
+            if (!Object.keys(diff).length)
+                return false;
+        }
+        return promises.length ? Promise.all(promises).then(() => diff) : Promise.resolve(diff);
+    }
+    /**
+     *
+     * @param obj1
+     * @param obj2
+     */
+    _match(obj1, obj2) {
+        return INDEX_PROPERTY.findIndex(k => obj1[k] && obj1[k] === obj2[k]) > -1;
+    }
+    /**
+     *
+     * @param base
+     * @param obj
+     * @param nodes
+     */
+    _rekey(base, obj, nodes) {
+        const newObj = {};
+        let ok = false;
+        INDEX_PROPERTY.forEach(k => {
+            if (this._ignore(k, nodes))
+                return;
+            if (base[k]) {
+                newObj[k] = base[k];
+                ok = true;
+            }
+        });
+        return ok ? Object.assign(newObj, obj) : obj;
+    }
+    /**
+     *
+     * @param name
+     * @param nodes
+     */
+    _ignore(name, nodes) {
+        return IGNORE_NODE.indexOf(name) > -1 || IGNORE_NODE.indexOf(nodes[nodes.length - 1] + '.' + name) > -1;
+    }
+    /**
+     *
+     * @param base
+     * @param prestine
+     * @param scope
+     */
+    _branch(base, prestine, scope) {
+        const promises = [];
+        if (isArray(base)) {
+            base.forEach(e => {
+                if (isObject(e)) {
+                    const obj = isArray(e) ? [] : {};
+                    const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });
+                    if (!promise)
+                        return;
+                    promises.push(promise);
+                    prestine.push(obj);
+                }
+                else {
+                    const length = prestine.push(e);
+                    if (scope.nodes.indexOf('positions') > -1) {
+                        const promise = this._accounts.get(e).toPromise().then(v => prestine[length - 1] = v.name);
+                        promises.push(promise);
+                    }
+                }
+            });
+            if (!prestine.length)
+                return false;
+        }
+        else {
+            Object.keys(base).forEach(k => {
+                if (this._ignore(k, scope.nodes))
+                    return;
+                const aVal = base[k];
+                if (isObject(aVal)) {
+                    const obj = isArray(aVal) ? [] : {};
+                    const promise = this._branch(aVal, obj, { type: aVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] });
+                    if (!promise)
+                        return;
+                    promises.push(promise);
+                    if (scope.nodes.indexOf('positions') > -1) {
+                        const promise = this._ds.get(scope.type, k).toPromise().then(v => prestine[isString(v) ? v : v[Object.keys(v)[0]]] = obj);
+                        promises.push(promise);
+                    }
+                    else
+                        prestine[k] = obj;
+                }
+                else {
+                    prestine[k] = aVal;
+                    if (k === 'userId') {
+                        const promise = this._accounts.get(aVal).toPromise().then(v => prestine[k] = v.name);
+                        promises.push(promise);
+                    }
+                }
+            });
+            if (!Object.keys(prestine).length)
+                return false;
+        }
+        return promises.length ? Promise.all(promises) : Promise.resolve();
+    }
+    /**
+     * return html from diff tree
+     * @param diff
+     * @param objstate
+     * @param propertyName
+     * @param sibling array entry
+     */
+    _generate(diff, objstate = ChangeState.Unchanged, propertyName = undefined, sibling = false) {
+        let h = '';
+        if (isArray(diff)) {
+            h += this._write(objstate, TokenKind.ArrayStart, false, false, propertyName);
+            const n = diff.length;
+            diff.forEach((e, i) => {
+                const state = diff[STATE + i.toString()];
+                if (isObject(e))
+                    h += this._generate(e, state, undefined, i < n - 1);
+                else
+                    h += this._write(state, TokenKind.Value, i === n - 1 || diff[STATE + (i + 1).toString()] !== state, i < n - 1, undefined, e);
+            });
+            h += this._write(objstate, TokenKind.ArrayEnd, true, sibling);
+        }
+        else {
+            h += this._write(objstate, TokenKind.ObjectStart, false, false, propertyName);
+            const keys = Object.keys(diff).filter(k => !k.startsWith(ORIGINAL_VALUE));
+            keys.forEach((k, i) => {
+                const val = diff[k], state = diff[STATE + k], n = keys.length;
+                if (isObject(val))
+                    h += this._generate(val, state, k, i < n - 1);
+                else
+                    h += this._write(state, TokenKind.Value, state !== objstate, i < n - 1, k, val, diff[ORIGINAL_VALUE + k]);
+            });
+            h += this._write(objstate, TokenKind.ObjectEnd, true, sibling);
+        }
+        return h;
+    }
+    /**
+     * write html line
+     * @param state
+     * @param annotate
+     * @param token
+     * @param sibling array entry
+     * @param propertyName
+     * @param value
+     * @param originalValue
+     */
+    _write(state, token, annotate, sibling, propertyName, value, originalValue) {
+        let h = '', brackets, cls;
+        switch (state) {
+            case ChangeState.Removed:
+                cls = 'compare removed';
+                break;
+            case ChangeState.Added:
+                cls = 'compare added';
+                break;
+            case ChangeState.Modified:
+                cls = 'compare modified';
+                break;
+            default:
+                cls = '';
+        }
+        switch (token) {
+            case TokenKind.ArrayStart:
+                brackets = '[';
+                break;
+            case TokenKind.ObjectStart:
+                brackets = '{';
+                break;
+            case TokenKind.ArrayEnd:
+                brackets = ']';
+                break;
+            case TokenKind.ObjectEnd:
+                brackets = '}';
+                break;
+        }
+        if (token == TokenKind.ObjectStart || token == TokenKind.ArrayStart)
+            h = `<div class="scope ${cls}">`;
+        if (propertyName)
+            h += `<span class="structure ${cls}">${propertyName}: </span>`;
+        if (brackets) {
+            if (token == TokenKind.ObjectEnd || token == TokenKind.ArrayEnd)
+                h += '</div>';
+            h += `<span class="brackets">${brackets}</span>`;
+            if (token == TokenKind.ObjectStart || token == TokenKind.ArrayStart)
+                h += '<span class="alternate">...</span><div class="scope-content">';
+        }
+        if (token == TokenKind.Value) {
+            if (propertyName === 'color')
+                h += `<div class="color" style="background-color:${value}"></div>&nbsp;`;
+            else if ((propertyName === 'shape' || propertyName === 'data') && SVG_PATH_REGEX.test(value))
+                h += `<svg width=12 height=12 viewBox="0 0 35 35" preserveAspectRatio="none"><path d="${value}"></path></svg>&nbsp;`;
+            h += `<span class="value ${cls}">${value}</span>`;
+        }
+        if (sibling)
+            h += '<span class="structure">,</span>';
+        if (state && annotate) {
+            const resource = state === ChangeState.Removed ? 'Deleted' : state === ChangeState.Added ? 'Added' : 'Modified';
+            h += `<div class="${cls}"> <div class="label"><span>${this._translate.get(resource)}`;
+            if (originalValue)
+                h += `&nbsp;<span class="original">${originalValue}</span>`;
+            h += '</span></div></div>';
+        }
+        else if (token === TokenKind.Value)
+            h += '<br/>';
+        if (token == TokenKind.ObjectEnd || token == TokenKind.ArrayEnd)
+            h += '</div>';
+        return h;
+    }
+    /**
+     * toggle
+     * @param evt
+     */
+    collapse(evt) {
+        let el = evt.srcElement;
+        while (el && !el.classList.contains('scope'))
+            el = el.parentElement;
+        el && el.classList.toggle('collapse') && el.classList.remove('focus');
+        evt.stopPropagation();
+    }
+    /**
+     * remove cls
+     */
+    focusOut() {
+        this.contents.nativeElement.querySelectorAll('.scope.focus').forEach(e => e.classList.remove('focus'));
+    }
+    /**
+     *
+     * @param evt
+     */
+    focusIn(evt) {
+        this.focusOut();
+        let el = evt.srcElement;
+        while (el && !el.classList.contains('scope'))
+            el = el.parentElement;
+        el && !el.classList.contains('collapse') && el.classList.add('focus');
+    }
+    ngOnDestroy() {
+        this._destroy.next();
+        this._destroy.complete();
+    }
+};
+SystemDiffComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: SystemDiffComponent, deps: [{ token: i1.PromptService }, { token: UtilityRef }, { token: i2.TranslateService }, { token: i3.DatasourceService }, { token: i4.AccountService }], target: i0.ɵɵFactoryTarget.Component });
+SystemDiffComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: SystemDiffComponent, selector: "ng-component", host: { classAttribute: "pane" }, viewQueries: [{ propertyName: "contents", first: true, predicate: ["contents"], descendants: true }], ngImport: i0, template: "<mat-toolbar>\r\n  <button mat-icon-button (click)=\"properties.toggle()\" [bizdocTooltip]=\"'Collapse' | translate\"><mat-icon>view_sidebar</mat-icon></button>\r\n  <span class=\"divider\"></span>\r\n</mat-toolbar>\r\n<mat-sidenav-container autosize fxFlex>\r\n  <mat-sidenav-content>\r\n    <mat-progress-bar mode=\"buffer\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > 0 && progress < 100 ? 'visible':'hidden'\"></mat-progress-bar>\r\n    <div [innerHTML]=\"html | sanitizeHtml\" (mouseleave)=\"focusOut()\" (mousemove)=\"focusIn($event)\" class=\"configuration-diff\" (click)=\"collapse($event)\" #contents></div>\r\n  </mat-sidenav-content>\r\n  <mat-sidenav mode=\"side\" opened #properties class=\"timeline\">\r\n    <mat-nav-list *ngIf=\"versions\">\r\n      <ng-container *ngFor=\"let v of versions; let index = index; let last = last\">\r\n        <mat-list-item (click)=\"compare(index)\" [class.active]=\"v.time === activeDate\" *ngIf=\"!last\">\r\n          <h3 matLine>\r\n            {{(v.author || 'System') | userName | async }}\r\n          </h3>\r\n          <p class=\"time\" matLine>\r\n            {{v.time | amCalendar: null: CALENDAR_SPEC }}\r\n          </p>\r\n        </mat-list-item>\r\n      </ng-container>\r\n    </mat-nav-list>\r\n  </mat-sidenav>\r\n</mat-sidenav-container>\r\n", styles: [":host{flex:1 1 auto}.timeline{border:none;width:150px}.timeline .time{font-size:12px!important}:host ::ng-deep .mat-drawer-inner-container{overflow:auto}\n"], components: [{ type: i5.MatToolbar, selector: "mat-toolbar", inputs: ["color"], exportAs: ["matToolbar"] }, { type: i6.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i7.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i8.MatSidenavContainer, selector: "mat-sidenav-container", exportAs: ["matSidenavContainer"] }, { type: i8.MatSidenavContent, selector: "mat-sidenav-content" }, { type: i9.MatProgressBar, selector: "mat-progress-bar", inputs: ["color", "value", "bufferValue", "mode"], outputs: ["animationEnd"], exportAs: ["matProgressBar"] }, { type: i8.MatSidenav, selector: "mat-sidenav", inputs: ["fixedInViewport", "fixedTopGap", "fixedBottomGap"], exportAs: ["matSidenav"] }, { type: i10.MatNavList, selector: "mat-nav-list", inputs: ["disableRipple", "disabled"], exportAs: ["matNavList"] }, { type: i10.MatListItem, selector: "mat-list-item, a[mat-list-item], button[mat-list-item]", inputs: ["disableRipple", "disabled"], exportAs: ["matListItem"] }], directives: [{ type: i11.TooltipDirective, selector: "[bizdocTooltip]", inputs: ["bizdocTooltip", "bizdocTooltipTemplate", "bizdocTooltipContext", "bizdocTooltipPosition", "bizdocTooltipDuration", "bizdocTooltipDisabled"] }, { type: i12.DefaultFlexDirective, selector: "  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],  [fxFlex.gt-md], [fxFlex.gt-lg]", inputs: ["fxFlex", "fxFlex.xs", "fxFlex.sm", "fxFlex.md", "fxFlex.lg", "fxFlex.xl", "fxFlex.lt-sm", "fxFlex.lt-md", "fxFlex.lt-lg", "fxFlex.lt-xl", "fxFlex.gt-xs", "fxFlex.gt-sm", "fxFlex.gt-md", "fxFlex.gt-lg"] }, { type: i13.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i13.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i14.MatLine, selector: "[mat-line], [matLine]" }], pipes: { "translate": i15.TranslatePipe, "sanitizeHtml": i16.SanitizeHtmlPipe, "async": i13.AsyncPipe, "userName": i17.UserNamePipe, "amCalendar": i18.CalendarPipe } });
+SystemDiffComponent = __decorate([
+    BizDoc({ selector: 'bizdoc-configuration-diff' })
+    /** component*/
+], SystemDiffComponent);
+export { SystemDiffComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: SystemDiffComponent, decorators: [{
+            type: Component,
+            args: [{ host: {
+                        class: 'pane'
+                    }, template: "<mat-toolbar>\r\n  <button mat-icon-button (click)=\"properties.toggle()\" [bizdocTooltip]=\"'Collapse' | translate\"><mat-icon>view_sidebar</mat-icon></button>\r\n  <span class=\"divider\"></span>\r\n</mat-toolbar>\r\n<mat-sidenav-container autosize fxFlex>\r\n  <mat-sidenav-content>\r\n    <mat-progress-bar mode=\"buffer\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > 0 && progress < 100 ? 'visible':'hidden'\"></mat-progress-bar>\r\n    <div [innerHTML]=\"html | sanitizeHtml\" (mouseleave)=\"focusOut()\" (mousemove)=\"focusIn($event)\" class=\"configuration-diff\" (click)=\"collapse($event)\" #contents></div>\r\n  </mat-sidenav-content>\r\n  <mat-sidenav mode=\"side\" opened #properties class=\"timeline\">\r\n    <mat-nav-list *ngIf=\"versions\">\r\n      <ng-container *ngFor=\"let v of versions; let index = index; let last = last\">\r\n        <mat-list-item (click)=\"compare(index)\" [class.active]=\"v.time === activeDate\" *ngIf=\"!last\">\r\n          <h3 matLine>\r\n            {{(v.author || 'System') | userName | async }}\r\n          </h3>\r\n          <p class=\"time\" matLine>\r\n            {{v.time | amCalendar: null: CALENDAR_SPEC }}\r\n          </p>\r\n        </mat-list-item>\r\n      </ng-container>\r\n    </mat-nav-list>\r\n  </mat-sidenav>\r\n</mat-sidenav-container>\r\n", styles: [":host{flex:1 1 auto}.timeline{border:none;width:150px}.timeline .time{font-size:12px!important}:host ::ng-deep .mat-drawer-inner-container{overflow:auto}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PromptService }, { type: i19.UtilityRef, decorators: [{
+                    type: Inject,
+                    args: [UtilityRef]
+                }] }, { type: i2.TranslateService }, { type: i3.DatasourceService }, { type: i4.AccountService }]; }, propDecorators: { contents: [{
+                type: ViewChild,
+                args: ['contents']
+            }] } });
+var ChangeState;
+(function (ChangeState) {
+    ChangeState[ChangeState["Unchanged"] = 0] = "Unchanged";
+    ChangeState[ChangeState["Added"] = 1] = "Added";
+    ChangeState[ChangeState["Modified"] = 2] = "Modified";
+    ChangeState[ChangeState["Removed"] = 3] = "Removed";
+})(ChangeState || (ChangeState = {}));
+var TokenKind;
+(function (TokenKind) {
+    TokenKind[TokenKind["Value"] = 0] = "Value";
+    TokenKind[TokenKind["ArrayStart"] = 1] = "ArrayStart";
+    TokenKind[TokenKind["ArrayEnd"] = 2] = "ArrayEnd";
+    TokenKind[TokenKind["ObjectStart"] = 3] = "ObjectStart";
+    TokenKind[TokenKind["ObjectEnd"] = 4] = "ObjectEnd";
+})(TokenKind || (TokenKind = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration-diff.component.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/admin/diff/configuration-diff.component.ts","../../../../../../libraries/core/src/lib/admin/diff/configuration-diff.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnDestroy, Inject, ViewChild, ElementRef } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { debounceTime, takeUntil } from 'rxjs/operators';\r\nimport { CalendarSpec } from \"../../core/pipes/calendar.pipe\";\r\nimport { BizDoc } from '../../core/decorators';\r\nimport { isArray, isObject, isString } from '../../core/functions';\r\nimport { UtilityComponent } from '../../core/base';\r\nimport { UtilityRef } from '../utility-ref';\r\nimport { PromptService } from '../../core/prompt.service'; \r\nimport { AccountService } from '../../core/account.service';\r\nimport { TranslateService } from '../../core/translate.service';\r\nimport { DatasourceService } from '../../core/datasource.service';\r\n\r\nconst IGNORE_NODE = ['author', 'history', 'targetDecorator', 'sourceDecorator', 'offsetX', 'offsetY', 'rotateAngle', 'width', 'height',\r\n  'style', 'segments', 'offset', 'targetPortID', 'sourcePortID', 'horizontalAlignment', 'verticalAlignment', 'workflow.timestamp',\r\n  'connectors.constraints', 'nodes.constraints', 'annotations.constraints', 'annotations.id'],\r\n  SVG_PATH_REGEX = /^[mM].+[zZ]$/,\r\n  INDEX_PROPERTY = ['name', 'id'], DATA_TYPE = 'dataType', ORIGINAL_VALUE = '_', STATE = '__';\r\n\r\n\r\n@Component({\r\n  templateUrl: './configuration-diff.component.html',\r\n  styleUrls: ['./configuration-diff.component.scss'],\r\n  host: {\r\n    class: 'pane'\r\n  }\r\n})\r\n@BizDoc({ selector: 'bizdoc-configuration-diff' })\r\n/** component*/\r\nexport class SystemDiffComponent implements OnInit, OnDestroy, UtilityComponent {\r\n  @ViewChild('contents') contents: ElementRef<HTMLDivElement>;\r\n  html = '';\r\n  versions: VersionInfo[];\r\n  activeDate: Date;\r\n  progress = 0;\r\n  none: boolean;\r\n  private _working = new Subject<number>();\r\n  readonly CALENDAR_SPEC: CalendarSpec = {\r\n    lastDay: `[${this._translate.get('Yesterday')}] HH:mm`,\r\n    lastWeek: 'ddd HH:mm',\r\n    sameDay: 'HH:mm',\r\n    sameElse: 'MMM D HH:mm'\r\n  };\r\n  private readonly _destroy = new Subject<void>();\r\n  /** ctor */\r\n  constructor(private _sb: PromptService,\r\n    @Inject(UtilityRef) private _utilityRef: UtilityRef<ConfigurtionInfo[], CompareModel, VersionInfo[], number>,\r\n    private _translate: TranslateService,\r\n    private _ds: DatasourceService,\r\n    private _accounts: AccountService) {\r\n  }\r\n  ngOnInit(): void {\r\n    // delay progress\r\n    this._working.pipe(takeUntil(this._destroy), debounceTime(100)).subscribe(v => v && (this.progress = v));\r\n    this._working.next(50);\r\n    // populate versions\r\n    this._utilityRef.populate().subscribe(e => {\r\n      this.versions = e;\r\n      this._working.next(100);\r\n      e.length > 1 &&\r\n        this.compare(0);\r\n    }, () => this._sb.error());\r\n  }\r\n  /**\r\n   * \r\n   * @param index\r\n   */\r\n  compare(index: number) {\r\n    const { time: date1, file } = this.versions[index],\r\n      version = this.versions.slice(index + 1).find(v => v.file === file);\r\n    if (!version) return;\r\n    const { time: date2 } = version;\r\n    this._working.next(25);\r\n    this._utilityRef.execute({ date1, date2 }).subscribe(r => {\r\n      this.html = '';\r\n      this._working.next(50);\r\n      this.activeDate = date1;\r\n      const results = this._compare(r[0], r[1]);\r\n      if (results) results.then(d => {\r\n        this._working.next(75);\r\n        this.html = this._generate(d);\r\n        this._scrollTop();\r\n        this._working.next(100);\r\n        this.none = false;\r\n      });\r\n      else {\r\n        this._working.next(100);\r\n        this.none = true;\r\n      }\r\n    }, () => this._sb.error());\r\n  }\r\n  private _scrollTop() {\r\n    setTimeout(() => this.contents.nativeElement.parentElement.scroll({ top: 0, behavior: 'smooth' }));\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @param a\r\n   * @param b\r\n   * @param diff\r\n   * @param scope\r\n   */\r\n  private _compare(a: {} | [], b: {} | [], diff: {} | [] = {}, scope: Scope = { nodes: [] }): Promise<{} | []> | false {\r\n    const promises: Promise<any>[] = [];\r\n    if (isArray(a)) {\r\n      a.forEach((e, i) => {\r\n        const bVal = b[i];\r\n        if (e === bVal) return;\r\n        else if (isObject(e)) {\r\n          const aJson = JSON.stringify(e), bJson = JSON.stringify(bVal);\r\n          if (aJson === bJson) return;\r\n          if (bVal && this._match(bVal, e)) {\r\n            const obj = {};\r\n            const promise = this._compare(e, bVal, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });\r\n            if (!promise) return;\r\n            (diff as any[]).push(this._rekey(e, obj, scope.nodes));\r\n            promises.push(promise);\r\n          }\r\n          else if ((b as []).find(b => JSON.stringify(b) === aJson)) return;\r\n          else {\r\n            const bObj = (b as []).find(b => this._match(b, e));\r\n            if (bObj) {\r\n              const obj = {};\r\n              const promise = this._compare(e, bObj, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });\r\n              if (!promise) return;\r\n              (diff as any[]).push(this._rekey(e, obj, scope.nodes));\r\n              promises.push(promise);\r\n            }\r\n            else {\r\n              const obj = isArray(e) ? [] : {};\r\n              const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });\r\n              if (!promise) return;\r\n              const length = (diff as any[]).push(obj);\r\n              diff[STATE + (length - 1).toString()] = ChangeState.Added;\r\n              promises.push(promise);\r\n            }\r\n          }\r\n        }\r\n        else if (!(b as []).find(b => b == e)) {\r\n          const length = (diff as any[]).push(e);\r\n          if (scope.nodes.indexOf('positions') > -1) {\r\n            const promise = this._accounts.get(e).toPromise().then(v =>\r\n              diff[length - 1] = v.name);\r\n            promises.push(promise);\r\n          }\r\n          diff[STATE + (length - 1).toString()] = ChangeState.Added;\r\n        }\r\n      });\r\n      (b as []).forEach((e, i) => {\r\n        if (e !== a[i]) {\r\n          if (isObject(e)) {\r\n            const bJson = JSON.stringify(e);\r\n            if (bJson === JSON.stringify(a[i]) || (a as []).find(a => JSON.stringify(a) === bJson ||\r\n              this._match(a, e))) return;\r\n            const obj = isArray(e) ? [] : {};\r\n            const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });\r\n            if (!promise) return;\r\n            const length = (diff as any[]).push(obj);\r\n            diff[STATE + (length - 1).toString()] = ChangeState.Removed;\r\n            promises.push(promise);\r\n          }\r\n          else if (!(a as []).find(a => a == e)) {\r\n            const length = (diff as []).push(e);\r\n            if (scope.nodes.indexOf('positions') > -1) {\r\n              const promise = this._accounts.get(e).toPromise().then(v =>\r\n                diff[length - 1] = v.name);\r\n              promises.push(promise);\r\n            }\r\n            diff[STATE + (length - 1).toString()] = ChangeState.Removed;\r\n          }\r\n        }\r\n      });\r\n      if (!(diff as any[]).length) return false;\r\n    }\r\n    else {\r\n      Object.keys(a).forEach(k => {\r\n        if (this._ignore(k, scope.nodes)) return;\r\n        const aVal = a[k], bVal = b[k];\r\n        if (aVal === bVal) return;\r\n        else if (isObject(aVal)) {\r\n          if (JSON.stringify(aVal) === JSON.stringify(bVal)) return;\r\n          if (bVal !== undefined && isArray(bVal) !== isArray(aVal)) {\r\n            diff[k] = aVal;\r\n            diff[ORIGINAL_VALUE + k] = isArray(bVal) ? bVal.join(', ') : bVal;\r\n            diff[STATE + k] = ChangeState.Modified;\r\n          }\r\n          else {\r\n            let obj = isArray(aVal) ? [] : {},\r\n              extra = { type: aVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] } as Scope;\r\n            if (bVal !== undefined) {\r\n              const promise = this._compare(aVal, bVal, obj, extra);\r\n              if (!promise) return;\r\n              if (!isArray(aVal))\r\n                obj = this._rekey(aVal, obj, scope.nodes);\r\n              promises.push(promise);\r\n            }\r\n            else {\r\n              const promise = this._branch(aVal, obj, extra);\r\n              if (!promise) return;\r\n              promises.push(promise);\r\n            }\r\n\r\n            if (scope.nodes.indexOf('positions') > -1) {\r\n              diff[ORIGINAL_VALUE + k] = aVal;\r\n              const promise = this._ds.get(scope.type, k).toPromise().then(v => {\r\n                const name = isString(v) ? v : v[Object.keys(v)[0]];\r\n                diff[name] = obj\r\n                if (bVal === undefined) diff[STATE + name] = ChangeState.Added;\r\n              });\r\n              promises.push(promise);\r\n            }\r\n            else {\r\n              diff[k] = obj;\r\n              if (bVal === undefined) diff[STATE + k] = ChangeState.Added;\r\n            }\r\n          }\r\n        }\r\n        else {\r\n          diff[k] = aVal;\r\n          if (k === 'userId') {\r\n            const promise = this._accounts.get(aVal).toPromise().then(v =>\r\n              diff[k] = v.name);\r\n            promises.push(promise);\r\n          }\r\n          if (bVal !== undefined) {\r\n            if (k === 'userId') {\r\n              const promise = this._accounts.get(bVal).toPromise().then(v =>\r\n                diff[ORIGINAL_VALUE + k] = v.name);\r\n              promises.push(promise);\r\n            }\r\n            else\r\n              diff[ORIGINAL_VALUE + k] = bVal;\r\n            diff[STATE + k] = ChangeState.Modified;\r\n          }\r\n          else\r\n            diff[STATE + k] = ChangeState.Added;\r\n        }\r\n      });\r\n      Object.keys(b).forEach(k => {\r\n        if (a[k] !== undefined || this._ignore(k, scope.nodes)) return;\r\n        const bVal = b[k];\r\n        if (scope.nodes.indexOf('positions') > -1) {\r\n          const obj = [];\r\n          diff[ORIGINAL_VALUE + k] = bVal;\r\n          const promise = this._ds.get(scope.type, k).toPromise().then(v => {\r\n            const name = isString(v) ? v : v[Object.keys(v)[0]];\r\n            diff[name] = obj;\r\n            diff[STATE + name] = ChangeState.Removed;\r\n          });\r\n          promises.push(promise);\r\n          bVal && (bVal as any[]).forEach((e, i) => {\r\n            const promise = this._accounts.get(e).toPromise().then(v =>\r\n              obj[i] = v.name);\r\n            promises.push(promise);\r\n          });\r\n        }\r\n        else {\r\n          if (isObject(bVal)) {\r\n            const obj = isArray(bVal) ? [] : {};\r\n            const promise = this._branch(bVal, obj, { type: bVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] });\r\n            if (!promise) return;\r\n            diff[k] = obj;\r\n            promise && promises.push(promise);\r\n          }\r\n          else {\r\n            diff[k] = bVal;\r\n            if (k === 'userId') {\r\n              const promise = this._accounts.get(bVal).toPromise().then(v =>\r\n                diff[k] = v.name);\r\n              promises.push(promise);\r\n            }\r\n          }\r\n          diff[STATE + k] = ChangeState.Removed;\r\n        }\r\n      });\r\n      if (!Object.keys(diff).length) return false;\r\n    }\r\n    return promises.length ? Promise.all(promises).then(() => diff) : Promise.resolve(diff);\r\n  }\r\n  /**\r\n   * \r\n   * @param obj1\r\n   * @param obj2\r\n   */\r\n  private _match(obj1: any, obj2: any) {\r\n    return INDEX_PROPERTY.findIndex(k => obj1[k] && obj1[k] === obj2[k]) > -1;\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @param base\r\n   * @param obj\r\n   * @param nodes\r\n   */\r\n  private _rekey(base: {}, obj: {}, nodes: string[]) {\r\n    const newObj = {};\r\n    let ok = false;\r\n    INDEX_PROPERTY.forEach(k => {\r\n      if (this._ignore(k, nodes)) return;\r\n      if (base[k]) {\r\n        newObj[k] = base[k];\r\n        ok = true;\r\n      }\r\n    });\r\n    return ok ? Object.assign(newObj, obj) : obj;\r\n  }\r\n\r\n  /**\r\n   * \r\n   * @param name\r\n   * @param nodes\r\n   */\r\n  private _ignore(name: string, nodes: string[]) {\r\n    return IGNORE_NODE.indexOf(name) > -1 || IGNORE_NODE.indexOf(nodes[nodes.length - 1] + '.' + name) > -1;\r\n  }\r\n  /**\r\n   * \r\n   * @param base\r\n   * @param prestine\r\n   * @param scope\r\n   */\r\n  private _branch(base: {} | [], prestine: {} | [], scope: Scope): Promise<any> | false {\r\n    const promises: Promise<any>[] = [];\r\n    if (isArray(base)) {\r\n      base.forEach(e => {\r\n        if (isObject(e)) {\r\n          const obj = isArray(e) ? [] : {};\r\n          const promise = this._branch(e, obj, { nodes: scope.nodes, type: e[DATA_TYPE] || scope.type });\r\n          if (!promise)\r\n            return;\r\n          promises.push(promise);\r\n          (prestine as any[]).push(obj);\r\n        }\r\n        else {\r\n          const length = (prestine as any[]).push(e);\r\n          if (scope.nodes.indexOf('positions') > -1) {\r\n            const promise = this._accounts.get(e).toPromise().then(v =>\r\n              prestine[length - 1] = v.name);\r\n            promises.push(promise);\r\n          }\r\n        }\r\n      });\r\n      if (!(prestine as any[]).length) return false;\r\n    } else {\r\n      Object.keys(base).forEach(k => {\r\n        if (this._ignore(k, scope.nodes)) return;\r\n        const aVal = base[k];\r\n        if (isObject(aVal)) {\r\n          const obj = isArray(aVal) ? [] : {};\r\n          const promise = this._branch(aVal, obj, { type: aVal[DATA_TYPE] || scope.type, nodes: [...scope.nodes, k] });\r\n          if (!promise)\r\n            return;\r\n          promises.push(promise);\r\n          if (scope.nodes.indexOf('positions') > -1) {\r\n            const promise = this._ds.get(scope.type, k).toPromise().then(v =>\r\n              prestine[isString(v) ? v : v[Object.keys(v)[0]]] = obj\r\n            );\r\n            promises.push(promise);\r\n          }\r\n          else\r\n            prestine[k] = obj;\r\n        }\r\n        else {\r\n          prestine[k] = aVal;\r\n          if (k === 'userId') {\r\n            const promise = this._accounts.get(aVal).toPromise().then(v =>\r\n              prestine[k] = v.name);\r\n            promises.push(promise);\r\n          }\r\n        }\r\n      });\r\n      if (!Object.keys(prestine).length) return false;\r\n    }\r\n    return promises.length ? Promise.all(promises) : Promise.resolve();\r\n  }\r\n  /**\r\n   * return html from diff tree\r\n   * @param diff\r\n   * @param objstate\r\n   * @param propertyName\r\n   * @param sibling array entry\r\n   */\r\n  private _generate(diff: {} | [], objstate: ChangeState = ChangeState.Unchanged,\r\n    propertyName = undefined, sibling = false) {\r\n    let h = '';\r\n    if (isArray(diff)) {\r\n      h += this._write(objstate, TokenKind.ArrayStart, false, false, propertyName);\r\n      const n = diff.length;\r\n      diff.forEach((e, i) => {\r\n        const state = diff[STATE + i.toString()];\r\n        if (isObject(e))\r\n          h += this._generate(e, state, undefined, i < n - 1);\r\n        else\r\n          h += this._write(state, TokenKind.Value,\r\n            i === n - 1 || diff[STATE + (i + 1).toString()] !== state,\r\n            i < n - 1, undefined, e);\r\n      });\r\n      h += this._write(objstate, TokenKind.ArrayEnd, true, sibling);\r\n    }\r\n    else {\r\n      h += this._write(objstate, TokenKind.ObjectStart, false, false, propertyName);\r\n      const keys = Object.keys(diff).filter(k => !k.startsWith(ORIGINAL_VALUE));\r\n      keys.forEach((k, i) => {\r\n        const val = diff[k], state = diff[STATE + k], n = keys.length;\r\n        if (isObject(val))\r\n          h += this._generate(val, state, k, i < n - 1);\r\n        else\r\n          h += this._write(state, TokenKind.Value, state !== objstate, i < n - 1, k, val, diff[ORIGINAL_VALUE + k]);\r\n      });\r\n      h += this._write(objstate, TokenKind.ObjectEnd, true, sibling);\r\n    }\r\n    return h;\r\n  }\r\n  /**\r\n   * write html line\r\n   * @param state\r\n   * @param annotate\r\n   * @param token\r\n   * @param sibling array entry\r\n   * @param propertyName\r\n   * @param value\r\n   * @param originalValue\r\n   */\r\n  private _write(state: ChangeState,\r\n    token: TokenKind,\r\n    annotate: boolean,\r\n    sibling?: boolean,\r\n    propertyName?: string,\r\n    value?: string | number | boolean,\r\n    originalValue?: string | number | boolean\r\n  ) {\r\n    let h = '', brackets: string, cls: string;\r\n    switch (state) {\r\n      case ChangeState.Removed:\r\n        cls = 'compare removed';\r\n        break;\r\n      case ChangeState.Added:\r\n        cls = 'compare added';\r\n        break;\r\n      case ChangeState.Modified:\r\n        cls = 'compare modified';\r\n        break;\r\n      default:\r\n        cls = '';\r\n    }\r\n    switch (token) {\r\n      case TokenKind.ArrayStart:\r\n        brackets = '[';\r\n        break;\r\n      case TokenKind.ObjectStart:\r\n        brackets = '{';\r\n        break;\r\n      case TokenKind.ArrayEnd:\r\n        brackets = ']';\r\n        break;\r\n      case TokenKind.ObjectEnd:\r\n        brackets = '}';\r\n        break;\r\n    }\r\n    if (token == TokenKind.ObjectStart || token == TokenKind.ArrayStart)\r\n      h = `<div class=\"scope ${cls}\">`;\r\n    if (propertyName)\r\n      h += `<span class=\"structure ${cls}\">${propertyName}: </span>`;\r\n    if (brackets) {\r\n      if (token == TokenKind.ObjectEnd || token == TokenKind.ArrayEnd)\r\n        h += '</div>';\r\n      h += `<span class=\"brackets\">${brackets}</span>`\r\n      if (token == TokenKind.ObjectStart || token == TokenKind.ArrayStart)\r\n        h += '<span class=\"alternate\">...</span><div class=\"scope-content\">';\r\n    }\r\n    if (token == TokenKind.Value) {\r\n      if (propertyName === 'color') h += `<div class=\"color\" style=\"background-color:${value}\"></div>&nbsp;`;\r\n      else if ((propertyName === 'shape' || propertyName === 'data') && SVG_PATH_REGEX.test(value as string)) h += `<svg width=12 height=12 viewBox=\"0 0 35 35\" preserveAspectRatio=\"none\"><path d=\"${value}\"></path></svg>&nbsp;`;\r\n      h += `<span class=\"value ${cls}\">${value}</span>`;\r\n    }\r\n    if (sibling) h += '<span class=\"structure\">,</span>';\r\n    if (state && annotate) {\r\n      const resource = state === ChangeState.Removed ? 'Deleted' : state === ChangeState.Added ? 'Added' : 'Modified';\r\n      h += `<div class=\"${cls}\"> <div class=\"label\"><span>${this._translate.get(resource)}`;\r\n      if (originalValue)\r\n        h += `&nbsp;<span class=\"original\">${originalValue}</span>`;\r\n      h += '</span></div></div>';\r\n    }\r\n    else if (token === TokenKind.Value)\r\n      h += '<br/>';\r\n    if (token == TokenKind.ObjectEnd || token == TokenKind.ArrayEnd)\r\n      h += '</div>';\r\n    return h;\r\n  }\r\n  /**\r\n   * toggle\r\n   * @param evt\r\n   */\r\n  collapse(evt: MouseEvent) {\r\n    let el = evt.srcElement as HTMLElement;\r\n    while (el && !el.classList.contains('scope'))\r\n      el = el.parentElement;\r\n    el && el.classList.toggle('collapse') && el.classList.remove('focus');\r\n    evt.stopPropagation();\r\n  }\r\n  /**\r\n   * remove cls\r\n   */\r\n  focusOut() {\r\n    this.contents.nativeElement.querySelectorAll('.scope.focus').forEach(e =>\r\n      e.classList.remove('focus')\r\n    );\r\n  }\r\n  /**\r\n   * \r\n   * @param evt\r\n   */\r\n  focusIn(evt: MouseEvent) {\r\n    this.focusOut();\r\n    let el = evt.srcElement as HTMLElement;\r\n    while (el && !el.classList.contains('scope'))\r\n      el = el.parentElement;\r\n    el && !el.classList.contains('collapse') && el.classList.add('focus');\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy.next();\r\n    this._destroy.complete();\r\n  }\r\n}\r\ninterface VersionInfo {\r\n  time: Date;\r\n  author: string;\r\n  file?: string;\r\n}\r\ninterface ConfigurtionInfo {\r\n}\r\ninterface CompareModel {\r\n  date1: Date;\r\n  date2: Date;\r\n}\r\ninterface Scope {\r\n  type?: string;\r\n  nodes: string[];\r\n}\r\nenum ChangeState {\r\n  Unchanged,\r\n  Added,\r\n  Modified,\r\n  Removed\r\n}\r\nenum TokenKind {\r\n  Value,\r\n  ArrayStart,\r\n  ArrayEnd,\r\n  ObjectStart,\r\n  ObjectEnd\r\n}\r\n","<mat-toolbar>\r\n  <button mat-icon-button (click)=\"properties.toggle()\" [bizdocTooltip]=\"'Collapse' | translate\"><mat-icon>view_sidebar</mat-icon></button>\r\n  <span class=\"divider\"></span>\r\n</mat-toolbar>\r\n<mat-sidenav-container autosize fxFlex>\r\n  <mat-sidenav-content>\r\n    <mat-progress-bar mode=\"buffer\" [value]=progress [bufferValue]=0 [style.visibility]=\"progress > 0 && progress < 100 ? 'visible':'hidden'\"></mat-progress-bar>\r\n    <div [innerHTML]=\"html | sanitizeHtml\" (mouseleave)=\"focusOut()\" (mousemove)=\"focusIn($event)\" class=\"configuration-diff\" (click)=\"collapse($event)\" #contents></div>\r\n  </mat-sidenav-content>\r\n  <mat-sidenav mode=\"side\" opened #properties class=\"timeline\">\r\n    <mat-nav-list *ngIf=\"versions\">\r\n      <ng-container *ngFor=\"let v of versions; let index = index; let last = last\">\r\n        <mat-list-item (click)=\"compare(index)\" [class.active]=\"v.time === activeDate\" *ngIf=\"!last\">\r\n          <h3 matLine>\r\n            {{(v.author || 'System') | userName | async }}\r\n          </h3>\r\n          <p class=\"time\" matLine>\r\n            {{v.time | amCalendar: null: CALENDAR_SPEC }}\r\n          </p>\r\n        </mat-list-item>\r\n      </ng-container>\r\n    </mat-nav-list>\r\n  </mat-sidenav>\r\n</mat-sidenav-container>\r\n"]}