@bizdoc/core 1.13.12 → 1.13.16

package/esm2020/lib/compose/trace/trace.pane.component.mjs

@@ -0,0 +1,52 @@
+import { Component, ViewChild } from '@angular/core';
+import { FlowViewComponent } from './flow.component';
+import { TraceViewComponent } from './trace.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/translate.service";
+import * as i2 from "../../core/slots/pane-ref";
+import * as i3 from "../../core/slots/router.service";
+import * as i4 from "./trace.component";
+import * as i5 from "./flow.component";
+export class TracePaneComponent {
+    constructor(translate, _pane, _router) {
+        this._pane = _pane;
+        this._router = _router;
+        _pane.title = translate.get('Trace');
+    }
+    ngOnInit() {
+        this._pane.dataChange.subscribe(d => {
+            if (this.model == d['item']) {
+                this.trace.refresh();
+                this.flow.refresh();
+            }
+            this.model = d['item'];
+            this._pane.group = `#${this.model.number}`;
+        });
+        this._pane.resize.subscribe(() => {
+            this.flow.resize();
+        });
+    }
+    version(time) {
+        this._router.navigate(['..', 'version', new Date(time).valueOf().encodeId()], {
+            relativeTo: this._pane,
+            state: {
+                item: this.model
+            }
+        });
+    }
+}
+TracePaneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TracePaneComponent, deps: [{ token: i1.TranslateService }, { token: i2.PaneRef }, { token: i3.PanesRouter }], target: i0.ɵɵFactoryTarget.Component });
+TracePaneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: TracePaneComponent, selector: "ng-component", host: { classAttribute: "pane" }, viewQueries: [{ propertyName: "trace", first: true, predicate: TraceViewComponent, descendants: true, static: true }, { propertyName: "flow", first: true, predicate: FlowViewComponent, descendants: true, static: true }], ngImport: i0, template: "<bizdoc-trace [model]=\"model\" (versionSelected)=\"version($event)\"></bizdoc-trace>\r\n\r\n<bizdoc-flow [model]=\"model\"></bizdoc-flow>\r\n", styles: [":host{padding:0 8px;display:block;min-width:400px}\n"], components: [{ type: i4.TraceViewComponent, selector: "bizdoc-trace", inputs: ["model"], outputs: ["versionSelected"] }, { type: i5.FlowViewComponent, selector: "bizdoc-flow", inputs: ["model", "connectorType"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: TracePaneComponent, decorators: [{
+            type: Component,
+            args: [{ host: {
+                        class: 'pane'
+                    }, template: "<bizdoc-trace [model]=\"model\" (versionSelected)=\"version($event)\"></bizdoc-trace>\r\n\r\n<bizdoc-flow [model]=\"model\"></bizdoc-flow>\r\n", styles: [":host{padding:0 8px;display:block;min-width:400px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.TranslateService }, { type: i2.PaneRef }, { type: i3.PanesRouter }]; }, propDecorators: { trace: [{
+                type: ViewChild,
+                args: [TraceViewComponent, { static: true }]
+            }], flow: [{
+                type: ViewChild,
+                args: [FlowViewComponent, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/compose/version-compare/version-compare.component.mjs

@@ -0,0 +1,53 @@
+import { Component, Injector, Input } from '@angular/core';
+import { DOCUMENT_MODEL } from '../../core/mailbox.service';
+import { FormRef } from '../../compose/form-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/session.service";
+import * as i2 from "../../core/component-factory-resolver";
+/** component*/
+export class VersionCompareComponent {
+    /** ctor */
+    constructor(_session, _cf, _container, _injector) {
+        this._session = _session;
+        this._cf = _cf;
+        this._container = _container;
+        this._injector = _injector;
+    }
+    get form() { return this._form; }
+    get currentVersion() { return this._currentVersion; }
+    get baseVersion() { return this._baseVersion; }
+    ngOnChanges(_) {
+        this._form = this._session.profile.forms.find(f => f.name === this.model.formId);
+        const log = this.model.log.find(l => l.type === 'ModelChange' && l.time === this.version);
+        const idx = this.model.log.indexOf(log);
+        const base = this.model.log.find((l, i) => l.type === 'ModelChange' && i > idx);
+        this._baseVersion = log.model;
+        this._currentVersion = JSON.parse(JSON.stringify(base ? base.model : this.model.model));
+        const componentFactory = this._cf.resolve(this._form.template);
+        const injector = Injector.create([
+            { provide: VersionCompareComponent, useValue: this },
+            { provide: FormRef, useValue: new FormRef() },
+            { provide: DOCUMENT_MODEL, useValue: this.model }
+        ], this._injector);
+        this._container.clear();
+        const componentRef = this._container.createComponent(componentFactory, 0, injector);
+        const instance = componentRef.instance;
+        instance.mode = 'version';
+        const newModel = Object.assign({}, this.model, { model: this._currentVersion });
+        instance.onBind(newModel, this._baseVersion);
+    }
+}
+VersionCompareComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VersionCompareComponent, deps: [{ token: i1.SessionService }, { token: i2.BizDocComponentFactoryResolver }, { token: i0.ViewContainerRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+VersionCompareComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VersionCompareComponent, selector: "bizdoc-version-compare", inputs: { model: "model", version: "version" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VersionCompareComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bizdoc-version-compare',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SessionService }, { type: i2.BizDocComponentFactoryResolver }, { type: i0.ViewContainerRef }, { type: i0.Injector }]; }, propDecorators: { model: [{
+                type: Input
+            }], version: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi1jb21wYXJlLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnJhcmllcy9jb3JlL3NyYy9saWIvY29tcG9zZS92ZXJzaW9uLWNvbXBhcmUvdmVyc2lvbi1jb21wYXJlLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFvQixRQUFRLEVBQUUsS0FBSyxFQUE0QixNQUFNLGVBQWUsQ0FBQztBQUd2RyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFHNUQsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLHdCQUF3QixDQUFDOzs7O0FBTWpELGVBQWU7QUFDZixNQUFNLE9BQU8sdUJBQXVCO0lBU2xDLFdBQVc7SUFDWCxZQUFvQixRQUF3QixFQUNsQyxHQUFtQyxFQUNuQyxVQUE0QixFQUM1QixTQUFtQjtRQUhULGFBQVEsR0FBUixRQUFRLENBQWdCO1FBQ2xDLFFBQUcsR0FBSCxHQUFHLENBQWdDO1FBQ25DLGVBQVUsR0FBVixVQUFVLENBQWtCO1FBQzVCLGNBQVMsR0FBVCxTQUFTLENBQVU7SUFDN0IsQ0FBQztJQVJELElBQVcsSUFBSSxLQUFXLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7SUFDOUMsSUFBVyxjQUFjLEtBQVUsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQztJQUNqRSxJQUFXLFdBQVcsS0FBVSxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0lBTzNELFdBQVcsQ0FBQyxDQUFnQjtRQUMxQixJQUFJLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsSUFBSSxLQUFLLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDakYsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksS0FBSyxhQUFhLElBQUksQ0FBQyxDQUFDLElBQUksS0FBSyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDMUYsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQ3hDLE1BQU0sSUFBSSxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxJQUFJLEtBQUssYUFBYSxJQUFJLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQztRQUNoRixJQUFJLENBQUMsWUFBWSxHQUFHLEdBQUcsQ0FBQyxLQUFLLENBQUM7UUFDOUIsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7UUFDeEYsTUFBTSxnQkFBZ0IsR0FBRyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQy9ELE1BQU0sUUFBUSxHQUFHLFFBQVEsQ0FBQyxNQUFNLENBQUM7WUFDL0IsRUFBRSxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsUUFBUSxFQUFFLElBQUksRUFBRTtZQUNwRCxFQUFDLE9BQU8sRUFBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLElBQUksT0FBTyxFQUFFLEVBQUU7WUFDM0MsRUFBRSxPQUFPLEVBQUUsY0FBYyxFQUFFLFFBQVEsRUFBRSxJQUFJLENBQUMsS0FBSyxFQUFFO1NBQ2xELEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1FBQ25CLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7UUFDeEIsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsZ0JBQWdCLEVBQUUsQ0FBQyxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3BGLE1BQU0sUUFBUSxHQUFHLFlBQVksQ0FBQyxRQUE4QixDQUFDO1FBQzdELFFBQVEsQ0FBQyxJQUFJLEdBQUcsU0FBUyxDQUFDO1FBQzFCLE1BQU0sUUFBUSxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQUMsRUFBRSxFQUFFLElBQUksQ0FBQyxLQUFLLEVBQUUsRUFBRSxLQUFLLEVBQUUsSUFBSSxDQUFDLGVBQWUsRUFBRSxDQUFDLENBQUM7UUFDaEYsUUFBUSxDQUFDLE1BQU0sQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQy9DLENBQUM7O29IQWxDVSx1QkFBdUI7d0dBQXZCLHVCQUF1QixtSUFIeEIsRUFBRTsyRkFHRCx1QkFBdUI7a0JBTG5DLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHdCQUF3QjtvQkFDbEMsUUFBUSxFQUFFLEVBQUU7aUJBQ2I7d01BR1UsS0FBSztzQkFBYixLQUFLO2dCQUNHLE9BQU87c0JBQWYsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgVmlld0NvbnRhaW5lclJlZiwgSW5qZWN0b3IsIElucHV0LCBPbkNoYW5nZXMsIFNpbXBsZUNoYW5nZXMgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgRm9ybSwgRG9jdW1lbnRNb2RlbCB9IGZyb20gJy4uLy4uL2NvcmUvbW9kZWxzJztcclxuaW1wb3J0IHsgRm9ybUNvbXBvbmVudCB9IGZyb20gJy4uLy4uL2NvcmUvYmFzZSc7XHJcbmltcG9ydCB7IERPQ1VNRU5UX01PREVMIH0gZnJvbSAnLi4vLi4vY29yZS9tYWlsYm94LnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBTZXNzaW9uU2VydmljZSB9IGZyb20gJy4uLy4uL2NvcmUvc2Vzc2lvbi5zZXJ2aWNlJztcclxuaW1wb3J0IHsgQml6RG9jQ29tcG9uZW50RmFjdG9yeVJlc29sdmVyIH0gZnJvbSAnLi4vLi4vY29yZS9jb21wb25lbnQtZmFjdG9yeS1yZXNvbHZlcic7XHJcbmltcG9ydCB7IEZvcm1SZWYgfSBmcm9tICcuLi8uLi9jb21wb3NlL2Zvcm0tcmVmJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHNlbGVjdG9yOiAnYml6ZG9jLXZlcnNpb24tY29tcGFyZScsXHJcbiAgdGVtcGxhdGU6ICcnXHJcbn0pXHJcbi8qKiBjb21wb25lbnQqL1xyXG5leHBvcnQgY2xhc3MgVmVyc2lvbkNvbXBhcmVDb21wb25lbnQgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xyXG4gIEBJbnB1dCgpIG1vZGVsOiBEb2N1bWVudE1vZGVsPGFueT47XHJcbiAgQElucHV0KCkgdmVyc2lvbjogRGF0ZTtcclxuICBwcml2YXRlIF9jdXJyZW50VmVyc2lvbjogYW55O1xyXG4gIHByaXZhdGUgX2Jhc2VWZXJzaW9uPzogYW55O1xyXG4gIHByaXZhdGUgX2Zvcm06IEZvcm07XHJcbiAgcHVibGljIGdldCBmb3JtKCk6IEZvcm0geyByZXR1cm4gdGhpcy5fZm9ybTsgfVxyXG4gIHB1YmxpYyBnZXQgY3VycmVudFZlcnNpb24oKTogYW55IHsgcmV0dXJuIHRoaXMuX2N1cnJlbnRWZXJzaW9uOyB9XHJcbiAgcHVibGljIGdldCBiYXNlVmVyc2lvbigpOiBhbnkgeyByZXR1cm4gdGhpcy5fYmFzZVZlcnNpb247IH1cclxuICAvKiogY3RvciAqL1xyXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgX3Nlc3Npb246IFNlc3Npb25TZXJ2aWNlLFxyXG4gICAgcHJpdmF0ZSBfY2Y6IEJpekRvY0NvbXBvbmVudEZhY3RvcnlSZXNvbHZlcixcclxuICAgIHByaXZhdGUgX2NvbnRhaW5lcjogVmlld0NvbnRhaW5lclJlZixcclxuICAgIHByaXZhdGUgX2luamVjdG9yOiBJbmplY3Rvcikge1xyXG4gIH1cclxuICBuZ09uQ2hhbmdlcyhfOiBTaW1wbGVDaGFuZ2VzKTogdm9pZCB7XHJcbiAgICB0aGlzLl9mb3JtID0gdGhpcy5fc2Vzc2lvbi5wcm9maWxlLmZvcm1zLmZpbmQoZiA9PiBmLm5hbWUgPT09IHRoaXMubW9kZWwuZm9ybUlkKTtcclxuICAgIGNvbnN0IGxvZyA9IHRoaXMubW9kZWwubG9nLmZpbmQobCA9PiBsLnR5cGUgPT09ICdNb2RlbENoYW5nZScgJiYgbC50aW1lID09PSB0aGlzLnZlcnNpb24pO1xyXG4gICAgY29uc3QgaWR4ID0gdGhpcy5tb2RlbC5sb2cuaW5kZXhPZihsb2cpO1xyXG4gICAgY29uc3QgYmFzZSA9IHRoaXMubW9kZWwubG9nLmZpbmQoKGwsIGkpID0+IGwudHlwZSA9PT0gJ01vZGVsQ2hhbmdlJyAmJiBpID4gaWR4KTtcclxuICAgIHRoaXMuX2Jhc2VWZXJzaW9uID0gbG9nLm1vZGVsO1xyXG4gICAgdGhpcy5fY3VycmVudFZlcnNpb24gPSBKU09OLnBhcnNlKEpTT04uc3RyaW5naWZ5KGJhc2UgPyBiYXNlLm1vZGVsIDogdGhpcy5tb2RlbC5tb2RlbCkpO1xyXG4gICAgY29uc3QgY29tcG9uZW50RmFjdG9yeSA9IHRoaXMuX2NmLnJlc29sdmUodGhpcy5fZm9ybS50ZW1wbGF0ZSk7XHJcbiAgICBjb25zdCBpbmplY3RvciA9IEluamVjdG9yLmNyZWF0ZShbXHJcbiAgICAgIHsgcHJvdmlkZTogVmVyc2lvbkNvbXBhcmVDb21wb25lbnQsIHVzZVZhbHVlOiB0aGlzIH0sXHJcbiAgICAgIHtwcm92aWRlOkZvcm1SZWYsIHVzZVZhbHVlOiBuZXcgRm9ybVJlZigpIH0sXHJcbiAgICAgIHsgcHJvdmlkZTogRE9DVU1FTlRfTU9ERUwsIHVzZVZhbHVlOiB0aGlzLm1vZGVsIH0gXHJcbiAgICBdLCB0aGlzLl9pbmplY3Rvcik7XHJcbiAgICB0aGlzLl9jb250YWluZXIuY2xlYXIoKTtcclxuICAgIGNvbnN0IGNvbXBvbmVudFJlZiA9IHRoaXMuX2NvbnRhaW5lci5jcmVhdGVDb21wb25lbnQoY29tcG9uZW50RmFjdG9yeSwgMCwgaW5qZWN0b3IpO1xyXG4gICAgY29uc3QgaW5zdGFuY2UgPSBjb21wb25lbnRSZWYuaW5zdGFuY2UgYXMgRm9ybUNvbXBvbmVudDxhbnk+O1xyXG4gICAgaW5zdGFuY2UubW9kZSA9ICd2ZXJzaW9uJztcclxuICAgIGNvbnN0IG5ld01vZGVsID0gT2JqZWN0LmFzc2lnbih7fSwgdGhpcy5tb2RlbCwgeyBtb2RlbDogdGhpcy5fY3VycmVudFZlcnNpb24gfSk7XHJcbiAgICBpbnN0YW5jZS5vbkJpbmQobmV3TW9kZWwsIHRoaXMuX2Jhc2VWZXJzaW9uKTtcclxuICB9XHJcbn1cclxuIl19

package/esm2020/lib/compose/version-compare/version-compare.directive.mjs

@@ -0,0 +1,344 @@
+import { Input, Directive, Optional, Host, SkipSelf } from "@angular/core";
+import { isObject } from "../../core/functions";
+import * as i0 from "@angular/core";
+import * as i1 from "./version-compare.component";
+import * as i2 from "../../core/translate.service";
+import * as i3 from "@angular/platform-browser";
+var CompareState;
+(function (CompareState) {
+    CompareState[CompareState["Removed"] = -1] = "Removed";
+    CompareState[CompareState["Unchanged"] = 0] = "Unchanged";
+    CompareState[CompareState["Added"] = 1] = "Added";
+    CompareState[CompareState["Modified"] = 2] = "Modified";
+})(CompareState || (CompareState = {}));
+export class CompareDirectiveBase {
+}
+/** */
+export class CompareGroupDirective extends CompareDirectiveBase {
+    constructor(_comparision, _context, _parent) {
+        super();
+        this._comparision = _comparision;
+        this._context = _context;
+        this._parent = _parent;
+    }
+    get structure() { return this._structure; }
+    get base() { return this._base ? this._base[this.name] : null; }
+    get version() { return this._version[this.name]; }
+    get keys() { return this._keys; }
+    ngOnInit() {
+        if (!this._comparision)
+            return;
+        if (this._context) {
+            this._structure = this._context.structure.fields.find(e => e.name === this.name);
+            this._base = this._context.base;
+            this._version = this._context.version;
+        }
+        else if (this._parent) {
+            this._structure = this._parent.structure.fields.find(e => e.name === this.name);
+            this._base = this._parent.base;
+            this._version = this._parent.version;
+        }
+        else {
+            this._structure = this._comparision.form.structure.find(e => e.name === this.name);
+            const { currentVersion, baseVersion } = this._comparision;
+            this._base = baseVersion;
+            this._version = currentVersion;
+        }
+        if (!this._structure)
+            throw `No form field with name ${this.name}`;
+        if (!this._structure.isObject)
+            throw `bizdocCompareGroup ${this.name}`;
+        this.structure.isArray && this._normalize();
+    }
+    _normalize() {
+        this._keys = this.structure.fields.filter(f => f.key).map(k => k.name);
+        this.base.forEach((b, i) => !this.version.find(v => this._keys.every(k => v[k] === b[k])) /* doesn't have a version */ &&
+            this.version.splice(i, 0, Object.assign({ _compare: CompareState.Removed }, b)));
+        this.version.forEach(v => {
+            if (v['_compare'] === undefined) {
+                const base = this.base.find(b => this._keys.every(k => b[k] === v[k]));
+                if (!base)
+                    v['_compare'] = CompareState.Added;
+                else if (JSON.stringify(v) !== JSON.stringify(base))
+                    v['_compare'] = CompareState.Modified;
+            }
+        });
+    }
+}
+CompareGroupDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareGroupDirective, deps: [{ token: i1.VersionCompareComponent, optional: true }, { token: CompareContextDirective, host: true, optional: true }, { token: CompareGroupDirective, host: true, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Directive });
+CompareGroupDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: CompareGroupDirective, selector: "[bizdocCompareGroup],[bizdocCompareArray]", inputs: { name: ["bizdocCompareGroup", "name"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareGroupDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[bizdocCompareGroup],[bizdocCompareArray]' }]
+        }], ctorParameters: function () { return [{ type: i1.VersionCompareComponent, decorators: [{
+                    type: Optional
+                }] }, { type: CompareContextDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }, { type: CompareGroupDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }, {
+                    type: SkipSelf
+                }] }]; }, propDecorators: { name: [{
+                type: Input,
+                args: ['bizdocCompareGroup']
+            }] } });
+/** */
+export class CompareNameDirective extends CompareDirectiveBase {
+    constructor(_comparision, _context, _group, _translate, _cd, _dom, _element) {
+        super();
+        this._comparision = _comparision;
+        this._context = _context;
+        this._group = _group;
+        this._translate = _translate;
+        this._cd = _cd;
+        this._dom = _dom;
+        this._element = _element;
+        this._state = CompareState.Unchanged;
+    }
+    set name(val) {
+        this._name = val.split(',');
+    }
+    get structure() { return this._structure; }
+    get base() { return this._base ? this._base[this._name[0]] : null; }
+    get version() { return this._version[this._name[0]]; }
+    get state() { return this._state; }
+    ;
+    ngOnInit() {
+        if (!this._comparision)
+            return;
+        if (this._context) {
+            this._structure = this._context.structure.fields.find(e => e.name === this._name[0]);
+            this._base = this._context.base;
+            this._version = this._context.version;
+        }
+        else if (this._group) {
+            this._structure = this._group.structure.fields.find(e => e.name === this._name[0]);
+            this._base = this._group.base;
+            this._version = this._group.version;
+        }
+        else {
+            this._structure = this._comparision.form.structure.find(e => e.name === this._name[0]);
+            const { currentVersion, baseVersion } = this._comparision;
+            this._base = baseVersion;
+            this._version = currentVersion;
+        }
+        if (!this._structure)
+            throw `No form field with name ${this._name[0]}`;
+    }
+    ngAfterViewInit() {
+        if (!this._comparision)
+            return;
+        // if object has state
+        const state = this._version['_compare'];
+        if (state !== undefined) {
+            switch (state) {
+                case CompareState.Removed:
+                    this._decorate('removed', 'Deleted');
+                    this._state = state;
+                    return;
+                case CompareState.Added:
+                    this._decorate('added', 'Added');
+                    this._state = state;
+                    return;
+            }
+        }
+        const versionData = {};
+        // iterate names
+        let name, i = 0;
+        while (i < this._name.length) {
+            name = this._name[i];
+            if (!this._base) {
+                if (this._version[name] !== undefined)
+                    this._state = CompareState.Added;
+            }
+            else if (this._version[name] !== this._base[name]) {
+                if (this._version[name] === undefined) {
+                    this._version[name] = this._base[name];
+                    versionData[name] = undefined;
+                    this._state = CompareState.Removed;
+                }
+                else if (this._base[name] === undefined)
+                    this._state = CompareState.Added;
+                else if (JSON.stringify(this._version[name]) !== JSON.stringify(this._base[name])) {
+                    // store version data
+                    versionData[name] = this._version[name];
+                    this._version[name] = this._base[name];
+                    this._state = CompareState.Modified;
+                }
+            }
+            i++;
+        }
+        if (this._state !== CompareState.Unchanged)
+            switch (this._state) {
+                case CompareState.Removed:
+                    // detect with base value(s)
+                    setTimeout(() => {
+                        this._cd.detectChanges();
+                        this._decorate('removed', 'Deleted');
+                        Object.assign(this._version, versionData);
+                    });
+                    break;
+                case CompareState.Added:
+                    this._decorate('added', 'Added');
+                    break;
+                case CompareState.Modified:
+                    {
+                        const versionHTML = this._element.nativeElement.innerHTML;
+                        //            this._cd.markForCheck();
+                        setTimeout(() => {
+                            // detect again with base value(s)
+                            this._cd.detectChanges();
+                            const originalHTML = this._element.nativeElement.innerHTML;
+                            // restore version html
+                            this._element.nativeElement.innerHTML = versionHTML;
+                            const labelEl = this._decorate('modified', 'Modified');
+                            const el = document.createElement('span');
+                            el.className = 'original';
+                            el.innerHTML = originalHTML; //this._dom.sanitize();
+                            labelEl.append(el);
+                            // restore version value(s)
+                            Object.assign(this._version, versionData);
+                        });
+                        break;
+                    }
+            }
+    }
+    _decorate(className, label) {
+        this._element.nativeElement.classList.add('compare', className);
+        const labelContainerEl = document.createElement('div');
+        labelContainerEl.className = 'label';
+        const labelEl = document.createElement('span');
+        labelEl.innerText = this._translate.get(label);
+        labelContainerEl.append(labelEl);
+        this._element.nativeElement.appendChild(labelContainerEl);
+        return labelEl;
+    }
+}
+CompareNameDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareNameDirective, deps: [{ token: i1.VersionCompareComponent, optional: true }, { token: CompareContextDirective, host: true, optional: true }, { token: CompareGroupDirective, host: true, optional: true }, { token: i2.TranslateService }, { token: i0.ChangeDetectorRef }, { token: i3.DomSanitizer }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+CompareNameDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: CompareNameDirective, selector: "[bizdocCompareName]", inputs: { name: ["bizdocCompareName", "name"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareNameDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[bizdocCompareName]' }]
+        }], ctorParameters: function () { return [{ type: i1.VersionCompareComponent, decorators: [{
+                    type: Optional
+                }] }, { type: CompareContextDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }, { type: CompareGroupDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }, { type: i2.TranslateService }, { type: i0.ChangeDetectorRef }, { type: i3.DomSanitizer }, { type: i0.ElementRef }]; }, propDecorators: { name: [{
+                type: Input,
+                args: ['bizdocCompareName']
+            }] } });
+/** */
+export class CompareContextDirective extends CompareDirectiveBase {
+    constructor(_comparision, _group, _vc, _template, _element) {
+        super();
+        this._comparision = _comparision;
+        this._group = _group;
+        this._vc = _vc;
+        this._template = _template;
+        this._element = _element;
+        this.decorate = _element.nativeElement.tagName === 'TR' ? 'table' : 'group';
+    }
+    set compareOf(val) { this._version = val; }
+    set context(val) { this._version = val; }
+    get version() { return this._version; }
+    get base() { return this._base; }
+    get structure() { return this._group.structure; }
+    ngOnInit() {
+        if (this._comparision) {
+            if (!this._group)
+                throw `Missing enclosing bizdocCompareGroup directive`;
+            if (!isObject(this.version))
+                throw `[bizdocCompareContext] syntax`;
+            this._base = this._group.base.find(b => this._group.keys.every(k => b[k] === this.version[k]));
+        }
+        if (this._template) {
+            this._vc.createEmbeddedView(this._template, {
+                $implicit: this._base
+            });
+        }
+    }
+    ngAfterViewInit() {
+        if (!this._comparision)
+            return;
+        switch (this.decorate) {
+            case 'table':
+                this._table();
+                break;
+            case 'group':
+                this._collapse();
+                break;
+        }
+    }
+    /** */
+    _table() {
+        let className;
+        switch (this._version['_compare']) {
+            case CompareState.Added:
+                className = 'added';
+                break;
+            case CompareState.Removed:
+                className = 'removed';
+                break;
+            case CompareState.Modified:
+                className = 'modified';
+                break;
+        }
+        this._element.nativeElement.classList.add('compare', className);
+    }
+    /** removes repeated added and removed tags */
+    _collapse() {
+        const els = this._element.nativeElement.parentElement.querySelectorAll('.compare');
+        let prevState = CompareState.Unchanged;
+        for (let i = els.length - 1; i >= 0; i--) {
+            const el = els[i];
+            let state;
+            if (el.classList.contains('added'))
+                state = CompareState.Added;
+            else if (el.classList.contains('removed'))
+                state = CompareState.Removed;
+            else {
+                state = CompareState.Unchanged;
+                continue;
+            }
+            if (prevState === state) {
+                const labelEl = el.querySelector('.label');
+                labelEl && labelEl.remove();
+            }
+            prevState = state;
+        }
+    }
+}
+CompareContextDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareContextDirective, deps: [{ token: i1.VersionCompareComponent, optional: true }, { token: CompareGroupDirective, host: true, optional: true }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef, optional: true }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+CompareContextDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.2", type: CompareContextDirective, selector: "[bizdocCompareContext],[bizdocCompare]", inputs: { compareOf: ["bizdocCompareOf", "compareOf"], context: ["bizdocCompareContext", "context"], decorate: ["bizdocCompareDecorate", "decorate"] }, exportAs: ["bizdocCompare"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CompareContextDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[bizdocCompareContext],[bizdocCompare]', exportAs: 'bizdocCompare' }]
+        }], ctorParameters: function () { return [{ type: i1.VersionCompareComponent, decorators: [{
+                    type: Optional
+                }] }, { type: CompareGroupDirective, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }, { type: i0.ElementRef }]; }, propDecorators: { compareOf: [{
+                type: Input,
+                args: ['bizdocCompareOf']
+            }], context: [{
+                type: Input,
+                args: ['bizdocCompareContext']
+            }], decorate: [{
+                type: Input,
+                args: ['bizdocCompareDecorate']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"version-compare.directive.js","sourceRoot":"","sources":["../../../../../../libraries/core/src/lib/compose/version-compare/version-compare.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Input, Directive, OnInit, ElementRef, Optional, Host, AfterViewInit, ChangeDetectorRef, SkipSelf, ViewContainerRef, TemplateRef } from \"@angular/core\";\r\nimport { DomSanitizer } from \"@angular/platform-browser\";\r\nimport { isObject } from \"../../core/functions\";\r\nimport { FieldInfo } from \"../../core/models\";\r\nimport { TranslateService } from \"../../core/translate.service\";\r\nimport { VersionCompareComponent } from \"./version-compare.component\";\r\n\r\nenum CompareState {\r\n  Removed = -1,\r\n  Unchanged = 0,\r\n  Added = 1,\r\n  Modified = 2\r\n}\r\n\r\nexport abstract class CompareDirectiveBase {\r\n  abstract get base(): any;\r\n  abstract get version(): any;\r\n  abstract get structure(): FieldInfo;\r\n}\r\n/** */\r\n@Directive({ selector: '[bizdocCompareGroup],[bizdocCompareArray]' })\r\nexport\r\n  class CompareGroupDirective extends CompareDirectiveBase implements OnInit {\r\n  @Input('bizdocCompareGroup') name: string;\r\n  private _keys: string[];\r\n  private _structure: FieldInfo;\r\n  private _base: any;\r\n  private _version: any;\r\n  public get structure(): FieldInfo { return this._structure; }\r\n  public get base(): any { return this._base ? this._base[this.name] : null; }\r\n  public get version(): any { return this._version[this.name]; }\r\n  public get keys(): string[] { return this._keys; }\r\n  constructor(\r\n    @Optional() private _comparision: VersionCompareComponent,\r\n    @Optional() @Host() private _context: CompareContextDirective,\r\n    @Optional() @Host() @SkipSelf() private _parent: CompareGroupDirective) {\r\n    super();\r\n  }\r\n  ngOnInit(): void {\r\n    if (!this._comparision) return;\r\n    if (this._context) {\r\n      this._structure = this._context.structure.fields.find(e => e.name === this.name);\r\n      this._base = this._context.base;\r\n      this._version = this._context.version;\r\n    }\r\n    else if (this._parent) {\r\n      this._structure = this._parent.structure.fields.find(e => e.name === this.name);\r\n      this._base = this._parent.base;\r\n      this._version = this._parent.version;\r\n    }\r\n    else {\r\n      this._structure = this._comparision.form.structure.find(e => e.name === this.name);\r\n      const { currentVersion, baseVersion } = this._comparision;\r\n      this._base = baseVersion;\r\n      this._version = currentVersion;\r\n    }\r\n    if (!this._structure) throw `No form field with name ${this.name}`;\r\n    if (!this._structure.isObject) throw `bizdocCompareGroup ${this.name}`;\r\n    this.structure.isArray && this._normalize();\r\n  }\r\n  private _normalize() {\r\n    this._keys = this.structure.fields.filter(f => f.key).map(k => k.name);\r\n    this.base.forEach((b, i) => !this.version.find(v => this._keys.every(k => v[k] === b[k])) /* doesn't have a version */ &&\r\n      this.version.splice(i, 0, Object.assign({ _compare: CompareState.Removed }, b)));\r\n    this.version.forEach(v => {\r\n      if (v['_compare'] === undefined) {\r\n        const base = this.base.find(b => this._keys.every(k => b[k] === v[k]));\r\n        if (!base)\r\n          v['_compare'] = CompareState.Added;\r\n        else if (JSON.stringify(v) !== JSON.stringify(base))\r\n          v['_compare'] = CompareState.Modified;\r\n      }\r\n    });\r\n  }\r\n}\r\n/** */\r\n@Directive({ selector: '[bizdocCompareName]' })\r\nexport\r\n  class CompareNameDirective extends CompareDirectiveBase implements OnInit, AfterViewInit {\r\n  private _name: string[];\r\n  @Input('bizdocCompareName') set name(val: string) {\r\n    this._name = val.split(',');\r\n  }\r\n  private _structure: FieldInfo;\r\n  private _base: any;\r\n  private _version: any;\r\n  private _state: CompareState = CompareState.Unchanged;\r\n  public get structure(): FieldInfo { return this._structure; }\r\n  public get base(): any { return this._base ? this._base[this._name[0]] : null; }\r\n  public get version(): any { return this._version[this._name[0]]; }\r\n  get state(): CompareState { return this._state };\r\n  constructor(\r\n    @Optional() private _comparision: VersionCompareComponent,\r\n    @Optional() @Host() private _context: CompareContextDirective,\r\n    @Optional() @Host() private _group: CompareGroupDirective,\r\n    private _translate: TranslateService,\r\n    private _cd: ChangeDetectorRef,\r\n    private _dom: DomSanitizer,\r\n    private _element: ElementRef<HTMLElement>) {\r\n    super();\r\n  }\r\n  ngOnInit(): void {\r\n    if (!this._comparision) return;\r\n    if (this._context) {\r\n      this._structure = this._context.structure.fields.find(e => e.name === this._name[0]);\r\n      this._base = this._context.base;\r\n      this._version = this._context.version;\r\n    }\r\n    else if (this._group) {\r\n      this._structure = this._group.structure.fields.find(e => e.name === this._name[0]);\r\n      this._base = this._group.base;\r\n      this._version = this._group.version;\r\n    }\r\n    else {\r\n      this._structure = this._comparision.form.structure.find(e => e.name === this._name[0]);\r\n      const { currentVersion, baseVersion } = this._comparision;\r\n      this._base = baseVersion;\r\n      this._version = currentVersion;\r\n    }\r\n    if (!this._structure) throw `No form field with name ${this._name[0]}`;\r\n  }\r\n  ngAfterViewInit(): void {\r\n    if (!this._comparision) return;\r\n    // if object has state\r\n    const state = this._version['_compare'];\r\n    if (state !== undefined) {\r\n      switch (state) {\r\n        case CompareState.Removed:\r\n          this._decorate('removed', 'Deleted');\r\n          this._state = state;\r\n          return;\r\n        case CompareState.Added:\r\n          this._decorate('added', 'Added');\r\n          this._state = state;\r\n          return;\r\n      }\r\n    }\r\n    const versionData: { [field: string]: any } = {};\r\n    // iterate names\r\n    let name: string, i = 0;\r\n    while (i < this._name.length) {\r\n      name = this._name[i];\r\n      if (!this._base) {\r\n        if (this._version[name] !== undefined)\r\n          this._state = CompareState.Added;\r\n      }\r\n      else if (this._version[name] !== this._base[name]) {\r\n        if (this._version[name] === undefined) {\r\n          this._version[name] = this._base[name];\r\n          versionData[name] = undefined;\r\n          this._state = CompareState.Removed;\r\n        }\r\n        else if (this._base[name] === undefined)\r\n          this._state = CompareState.Added;\r\n        else if (JSON.stringify(this._version[name]) !== JSON.stringify(this._base[name])) {\r\n          // store version data\r\n          versionData[name] = this._version[name];\r\n          this._version[name] = this._base[name];\r\n          this._state = CompareState.Modified;\r\n        }\r\n      }\r\n      i++;\r\n    }\r\n    if (this._state !== CompareState.Unchanged)\r\n      switch (this._state) {\r\n        case CompareState.Removed:\r\n          // detect with base value(s)\r\n          setTimeout(() => {\r\n            this._cd.detectChanges();\r\n            this._decorate('removed', 'Deleted');\r\n            Object.assign(this._version, versionData);\r\n          });\r\n          break;\r\n        case CompareState.Added:\r\n          this._decorate('added', 'Added');\r\n          break;\r\n        case CompareState.Modified:\r\n          {\r\n            const versionHTML = this._element.nativeElement.innerHTML;\r\n//            this._cd.markForCheck();\r\n            setTimeout(() => {\r\n              // detect again with base value(s)\r\n              this._cd.detectChanges();\r\n              const originalHTML = this._element.nativeElement.innerHTML;\r\n              // restore version html\r\n              this._element.nativeElement.innerHTML = versionHTML;\r\n              const labelEl = this._decorate('modified', 'Modified');\r\n              const el = document.createElement('span');\r\n              el.className = 'original';\r\n              el.innerHTML = originalHTML; //this._dom.sanitize();\r\n              labelEl.append(el);\r\n              // restore version value(s)\r\n              Object.assign(this._version, versionData);\r\n            });\r\n            break;\r\n          }\r\n      }\r\n  }\r\n  private _decorate(className: string, label: string): HTMLElement {\r\n    this._element.nativeElement.classList.add('compare', className);\r\n    const labelContainerEl = document.createElement('div');\r\n    labelContainerEl.className = 'label';\r\n    const labelEl = document.createElement('span');\r\n    labelEl.innerText = this._translate.get(label);\r\n    labelContainerEl.append(labelEl);\r\n    this._element.nativeElement.appendChild(labelContainerEl);\r\n    return labelEl;\r\n  }\r\n}\r\n/** */\r\n@Directive({ selector: '[bizdocCompareContext],[bizdocCompare]', exportAs: 'bizdocCompare' })\r\nexport\r\n  class CompareContextDirective extends CompareDirectiveBase implements OnInit, AfterViewInit {\r\n  private _version: {};\r\n  @Input('bizdocCompareOf') set compareOf(val: {}) { this._version = val; }\r\n  @Input('bizdocCompareContext') set context(val: {}) { this._version = val; }\r\n  get version(): {} { return this._version; }\r\n  @Input('bizdocCompareDecorate') decorate: 'group' | 'single' | 'table';\r\n  private _base: {};\r\n  public get base(): {} { return this._base; }\r\n  public get structure(): FieldInfo { return this._group.structure; }\r\n  constructor(\r\n    @Optional() private _comparision: VersionCompareComponent,\r\n    @Optional() @Host() private _group: CompareGroupDirective,\r\n    private _vc: ViewContainerRef,\r\n    @Optional() private _template: TemplateRef<any>,\r\n    private _element: ElementRef<HTMLElement>) {\r\n    super();\r\n    this.decorate = _element.nativeElement.tagName === 'TR' ? 'table' : 'group';\r\n  }\r\n  ngOnInit(): void {\r\n    if (this._comparision) {\r\n      if (!this._group) throw `Missing enclosing bizdocCompareGroup directive`;\r\n      if (!isObject(this.version)) throw `[bizdocCompareContext] syntax`;\r\n      this._base = this._group.base.find(b => this._group.keys.every(k => b[k] === this.version[k]));\r\n    }\r\n    if (this._template) {\r\n      this._vc.createEmbeddedView(this._template, {\r\n        $implicit: this._base\r\n      });\r\n    }\r\n  }\r\n  ngAfterViewInit(): void {\r\n    if (!this._comparision) return;\r\n    switch (this.decorate) {\r\n      case 'table':\r\n        this._table();\r\n        break;\r\n      case 'group':\r\n        this._collapse();\r\n        break;\r\n    }\r\n  }\r\n  /** */\r\n  private _table() {\r\n    let className: string;\r\n    switch (this._version['_compare'] as CompareState) {\r\n      case CompareState.Added:\r\n        className = 'added';\r\n        break;\r\n      case CompareState.Removed:\r\n        className = 'removed';\r\n        break;\r\n      case CompareState.Modified:\r\n        className = 'modified';\r\n        break;\r\n    }\r\n    this._element.nativeElement.classList.add('compare', className);\r\n  }\r\n  /** removes repeated added and removed tags */\r\n  private _collapse() {\r\n    const els = this._element.nativeElement.parentElement.querySelectorAll('.compare');\r\n    let prevState: CompareState = CompareState.Unchanged;\r\n    for (let i = els.length - 1; i >= 0; i--) {\r\n      const el = els[i];\r\n      let state: CompareState;\r\n      if (el.classList.contains('added'))\r\n        state = CompareState.Added;\r\n      else if (el.classList.contains('removed'))\r\n        state = CompareState.Removed;\r\n      else {\r\n        state = CompareState.Unchanged;\r\n        continue;\r\n      }\r\n      if (prevState === state) {\r\n        const labelEl = el.querySelector('.label');\r\n        labelEl && labelEl.remove();\r\n      }\r\n      prevState = state;\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2020/lib/compose/version-compare/version.pane.component.mjs

@@ -0,0 +1,56 @@
+import { Component } from '@angular/core';
+import { OpenPolicy } from '../../core/configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/slots/pane-ref";
+import * as i2 from "../../core/translate.service";
+import * as i3 from "../../core/slots/router.service";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+import * as i6 from "@angular/material/menu";
+import * as i7 from "../../core/identity/identity.component";
+import * as i8 from "./version-compare.component";
+import * as i9 from "@angular/common";
+import * as i10 from "../../core/pipes/translate.pipe";
+import * as i11 from "../../core/pipes/calendar.pipe";
+export class VersionPaneComponent {
+    constructor(_pane, _translate, _router) {
+        this._pane = _pane;
+        this._translate = _translate;
+        this._router = _router;
+        this.CALENDAR_SPEC = {
+            lastDay: `[${this._translate.get('Yesterday')}] HH:mm`,
+            lastWeek: 'dddd HH:mm',
+            sameDay: `[${this._translate.get('Today')}] HH:mm`,
+            sameElse: 'MMM Do HH:mm'
+        };
+        _pane.title = _translate.get('Version');
+    }
+    ngOnInit() {
+        this._pane.dataChange.subscribe(d => {
+            this.model = d['item'];
+            this._pane.group = `#${this.model.number}`;
+        });
+        this._pane.paramsChange.subscribe(p => {
+            const v = p['version'];
+            if (v) {
+                const version = v.decodeId();
+                this.log = this.model.log.find(l => l.type === 'ModelChange' && new Date(l.time).valueOf() === version);
+                this.versions = this.model.log.filter(l => l.type === 'ModelChange' && l !== this.log);
+            }
+            else
+                this._pane.close();
+        });
+    }
+    switch(time) {
+        this._router.navigate(['../', 'version', new Date(time).valueOf().encodeId()], { policy: OpenPolicy.Tab });
+    }
+}
+VersionPaneComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VersionPaneComponent, deps: [{ token: i1.PaneRef }, { token: i2.TranslateService }, { token: i3.PanesRouter }], target: i0.ɵɵFactoryTarget.Component });
+VersionPaneComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.2", type: VersionPaneComponent, selector: "bizdoc-version.pane", host: { classAttribute: "pane" }, ngImport: i0, template: "<div class=\"row\">\r\n  <span class=\"divider\"></span>\r\n  <button mat-icon-button *ngIf=\"versions.length\" [matMenuTriggerFor]=\"menu\" [attr.aria-label]=\"'Version' | translate\">\r\n    <mat-icon>filter_list</mat-icon>\r\n  </button>\r\n  <mat-menu #menu>\r\n    <button mat-menu-item (click)=\"switch(l.time)\" *ngFor=\"let l of versions\">\r\n      <bizdoc-identity-name [identity]=\"l.userId\" [by]=\"l.byId\" chating=\"none\"></bizdoc-identity-name>\r\n      {{l.time | amCalendar : null : CALENDAR_SPEC}}\r\n    </button>\r\n  </mat-menu>\r\n</div>\r\n<div class=\"info mat-body-1\">\r\n  <bizdoc-identity-name [identity]=\"log.userId\" [by]=\"log.byId\"></bizdoc-identity-name>\r\n  | <span>{{log.time | amCalendar : null : CALENDAR_SPEC }}</span>\r\n</div>\r\n<div>\r\n  <bizdoc-version-compare [model]=\"model\" [version]=\"log.time\"></bizdoc-version-compare>\r\n</div>\r\n", styles: [":host{padding:0 8px;display:block;min-width:350px}\n"], components: [{ type: i4.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: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i6.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { type: i6.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }, { type: i7.IdentityName, selector: "bizdoc-identity-name", inputs: ["identity", "by", "chating"] }, { type: i8.VersionCompareComponent, selector: "bizdoc-version-compare", inputs: ["model", "version"] }], directives: [{ type: i9.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { type: i9.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "translate": i10.TranslatePipe, "amCalendar": i11.CalendarPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: VersionPaneComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bizdoc-version.pane', host: {
+                        class: 'pane'
+                    }, template: "<div class=\"row\">\r\n  <span class=\"divider\"></span>\r\n  <button mat-icon-button *ngIf=\"versions.length\" [matMenuTriggerFor]=\"menu\" [attr.aria-label]=\"'Version' | translate\">\r\n    <mat-icon>filter_list</mat-icon>\r\n  </button>\r\n  <mat-menu #menu>\r\n    <button mat-menu-item (click)=\"switch(l.time)\" *ngFor=\"let l of versions\">\r\n      <bizdoc-identity-name [identity]=\"l.userId\" [by]=\"l.byId\" chating=\"none\"></bizdoc-identity-name>\r\n      {{l.time | amCalendar : null : CALENDAR_SPEC}}\r\n    </button>\r\n  </mat-menu>\r\n</div>\r\n<div class=\"info mat-body-1\">\r\n  <bizdoc-identity-name [identity]=\"log.userId\" [by]=\"log.byId\"></bizdoc-identity-name>\r\n  | <span>{{log.time | amCalendar : null : CALENDAR_SPEC }}</span>\r\n</div>\r\n<div>\r\n  <bizdoc-version-compare [model]=\"model\" [version]=\"log.time\"></bizdoc-version-compare>\r\n</div>\r\n", styles: [":host{padding:0 8px;display:block;min-width:350px}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PaneRef }, { type: i2.TranslateService }, { type: i3.PanesRouter }]; } });
+//# sourceMappingURL=data:application/json;base64,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