@colijnit/transaction 12.1.26 → 12.1.28

package/esm2015/lib/component/relation/relation-address/relation-address.component.js

@@ -0,0 +1,129 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { Address } from "@colijnit/transactionapi/build/model/address.bo";
+import { isNill } from "@colijnit/transactionapi/build/utils/function/is-nill.function";
+import { TransactionConnectorService } from "../../../service/transaction-connector.service";
+import { StringUtils } from "../../../utils/string-utils";
+import { DictionaryService } from "../../../service/dictionary.service";
+import { FormMasterService } from "@colijnit/corecomponents_v12";
+import { RelationBaseComponent } from "../relation-base.component";
+export class RelationAddressComponent extends RelationBaseComponent {
+    constructor(_dictionary, _connector, _formMasterService) {
+        super();
+        this._dictionary = _dictionary;
+        this._connector = _connector;
+        this._formMasterService = _formMasterService;
+        this.address = new Address();
+        this.showButtons = true;
+        this.saveClick = new EventEmitter();
+        this.cancelClick = new EventEmitter();
+        this.countries = [];
+        this.fields = { text: "description", value: "code" };
+        this.postalCodeCheckErrorMessage = "";
+        this._prevPostalCodeForCheck = "";
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._connector.getCountries().then((countries) => {
+                this.countries = countries;
+            });
+        });
+    }
+    submitForm() {
+        if (this._formMasterService.submitSlaves()) {
+            this.saveClick.next(this.address);
+        }
+    }
+    checkForPostalCodeCheckError() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.address.postalCode || isNill(this.address.houseNo)) {
+                this.postalCodeCheckErrorMessage = "";
+                return;
+            }
+            if (this._prevPostalCodeForCheck !== this.address.postalCode || this._prevHouseNoForCheck !== this.address.houseNo) {
+                this._prevPostalCodeForCheck = this.address.postalCode;
+                this._prevHouseNoForCheck = this.address.houseNo;
+                const postalCodeResponse = yield this._connector.getPostalCodeRetrieval((this.address.postalCode ? this.address.postalCode : ""), StringUtils.ParseString(this.address.houseNo));
+                if (postalCodeResponse && postalCodeResponse.isBadAddress) {
+                    this.postalCodeCheckErrorMessage = this._dictionary.get("UNKNOWN_ADDRESS_CHECK_IT");
+                }
+                else {
+                    this.postalCodeCheckErrorMessage = "";
+                    this.address.streetName = postalCodeResponse.street;
+                    this.address.city = postalCodeResponse.city;
+                }
+            }
+        });
+    }
+    changeHouseNo() {
+        this.address.houseNo = Number(this.address.houseNo);
+    }
+}
+RelationAddressComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-relation-address",
+                template: `
+    <label *ngIf=label [textContent]="label | localize"
+           class="checkout-label-h3"
+    ></label>
+    <co-form>
+      <div class="relation-address-data-row default">
+        <co-input-combo-box [(model)]="address.countryId"
+                            [collection]="countries"
+                            [fields]="fields"
+                            [placeholder]="'COUNTRY'| localize"
+                            [required]="true"
+        ></co-input-combo-box>
+      </div>
+      <div class="relation-address-data-row default">
+        <co-input-text [(model)]="address.postalCode"
+                       [placeholder]="'POSTAL_CODE' | localize"
+                       (blur)="checkForPostalCodeCheckError()"
+                       required
+        ></co-input-text>
+        <co-input-text class="default-width"
+                       [(model)]="address.houseNo"
+                       [placeholder]="'HOUSE_NO' | localize"
+                       (blur)="checkForPostalCodeCheckError()"
+                       (modelChange)="changeHouseNo()"
+                       required
+        ></co-input-text>
+        <co-input-text [(model)]="address.houseNoAddition"
+                       [placeholder]="'HOUSE_NO_ADDITION' | localize"
+        ></co-input-text>
+      </div>
+      <div class="relation-address-data-row default">
+        <co-input-text [(model)]="address.streetName" [placeholder]="'STREET' | localize" required></co-input-text>
+      </div>
+      <div class="relation-address-data-row default">
+        <co-input-text [(model)]="address.city" [placeholder]="'CITY' | localize" required></co-input-text>
+      </div>
+      <div class="relation-address-button-wrapper" *ngIf="showButtons">
+        <co-button [label]="'SAVE' | localize" (click)="submitForm()"></co-button>
+        <co-button [label]="'CANCEL' | localize" (click)="cancelClick.emit()"></co-button>
+      </div>
+    </co-form>
+  `,
+                providers: [
+                    FormMasterService
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+RelationAddressComponent.ctorParameters = () => [
+    { type: DictionaryService },
+    { type: TransactionConnectorService },
+    { type: FormMasterService }
+];
+RelationAddressComponent.propDecorators = {
+    address: [{ type: Input }],
+    label: [{ type: Input }],
+    showButtons: [{ type: Input }],
+    saveClick: [{ type: Output }],
+    cancelClick: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-relation-address",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-address.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-address/relation-address.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from \"@angular/core\";\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\nimport {Country} from \"@colijnit/transactionapi/build/model/country.bo\";\nimport {isNill} from \"@colijnit/transactionapi/build/utils/function/is-nill.function\";\nimport {TransactionConnectorService} from \"../../../service/transaction-connector.service\";\nimport {GetPostalCodeRetrievalOutputParams} from \"@colijnit/transactionapi/build/model/get-postal-code-retrieval-output-params\";\nimport {StringUtils} from \"../../../utils/string-utils\";\nimport {DictionaryService} from \"../../../service/dictionary.service\";\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\nimport {RelationBaseComponent} from \"../relation-base.component\";\nimport {RelationAnyType} from \"@colijnit/transactionapi/build/model/relation-any-type\";\nimport {AddressType} from \"@colijnit/transactionapi/build/enum/address-type.enum\";\n\n@Component({\n  selector: \"co-relation-address\",\n  template: `\n    <label *ngIf=label [textContent]=\"label | localize\"\n           class=\"checkout-label-h3\"\n    ></label>\n    <co-form>\n      <div class=\"relation-address-data-row default\">\n        <co-input-combo-box [(model)]=\"address.countryId\"\n                            [collection]=\"countries\"\n                            [fields]=\"fields\"\n                            [placeholder]=\"'COUNTRY'| localize\"\n                            [required]=\"true\"\n        ></co-input-combo-box>\n      </div>\n      <div class=\"relation-address-data-row default\">\n        <co-input-text [(model)]=\"address.postalCode\"\n                       [placeholder]=\"'POSTAL_CODE' | localize\"\n                       (blur)=\"checkForPostalCodeCheckError()\"\n                       required\n        ></co-input-text>\n        <co-input-text class=\"default-width\"\n                       [(model)]=\"address.houseNo\"\n                       [placeholder]=\"'HOUSE_NO' | localize\"\n                       (blur)=\"checkForPostalCodeCheckError()\"\n                       (modelChange)=\"changeHouseNo()\"\n                       required\n        ></co-input-text>\n        <co-input-text [(model)]=\"address.houseNoAddition\"\n                       [placeholder]=\"'HOUSE_NO_ADDITION' | localize\"\n        ></co-input-text>\n      </div>\n      <div class=\"relation-address-data-row default\">\n        <co-input-text [(model)]=\"address.streetName\" [placeholder]=\"'STREET' | localize\" required></co-input-text>\n      </div>\n      <div class=\"relation-address-data-row default\">\n        <co-input-text [(model)]=\"address.city\" [placeholder]=\"'CITY' | localize\" required></co-input-text>\n      </div>\n      <div class=\"relation-address-button-wrapper\" *ngIf=\"showButtons\">\n        <co-button [label]=\"'SAVE' | localize\" (click)=\"submitForm()\"></co-button>\n        <co-button [label]=\"'CANCEL' | localize\" (click)=\"cancelClick.emit()\"></co-button>\n      </div>\n    </co-form>\n  `,\n  providers: [\n    FormMasterService\n  ],\n  encapsulation: ViewEncapsulation.None\n})\nexport class RelationAddressComponent extends RelationBaseComponent implements OnInit {\n  @Input()\n  public address: Address = new Address();\n\n  @Input()\n  public label: string;\n\n  @Input()\n  public showButtons: boolean = true;\n\n  @Output()\n  public saveClick: EventEmitter<Address> = new EventEmitter<Address>();\n\n  @Output()\n  public cancelClick: EventEmitter<void> = new EventEmitter<void>();\n\n  @HostBinding(\"class.co-relation-address\")\n  public showClass(): boolean {\n    return true;\n  }\n\n  public countries: Country[] = [];\n  public fields: Object = {text: \"description\", value: \"code\"};\n\n  public postalCodeCheckErrorMessage: string = \"\";\n  private _prevPostalCodeForCheck: string = \"\";\n  private _prevHouseNoForCheck: number;\n\n  public constructor(\n    private _dictionary: DictionaryService,\n    private _connector: TransactionConnectorService,\n    private _formMasterService: FormMasterService\n  ) {\n    super();\n  }\n\n  async ngOnInit(): Promise<void> {\n    this._connector.getCountries().then((countries: Country[]) => {\n      this.countries = countries;\n    });\n  }\n\n  public submitForm(): void {\n    if (this._formMasterService.submitSlaves()) {\n      this.saveClick.next(this.address);\n    }\n  }\n\n  public async checkForPostalCodeCheckError(): Promise<void> {\n    if (!this.address.postalCode || isNill(this.address.houseNo)) {\n      this.postalCodeCheckErrorMessage = \"\";\n      return;\n    }\n\n    if (this._prevPostalCodeForCheck !== this.address.postalCode || this._prevHouseNoForCheck !== this.address.houseNo) {\n      this._prevPostalCodeForCheck = this.address.postalCode;\n      this._prevHouseNoForCheck = this.address.houseNo;\n      const postalCodeResponse: GetPostalCodeRetrievalOutputParams = await this._connector.getPostalCodeRetrieval((this.address.postalCode ? this.address.postalCode : \"\"),\n      StringUtils.ParseString(this.address.houseNo));\n      if (postalCodeResponse && postalCodeResponse.isBadAddress) {\n        this.postalCodeCheckErrorMessage = this._dictionary.get(\"UNKNOWN_ADDRESS_CHECK_IT\");\n      } else {\n        this.postalCodeCheckErrorMessage = \"\";\n        this.address.streetName = postalCodeResponse.street;\n        this.address.city = postalCodeResponse.city;\n      }\n    }\n  }\n\n  public changeHouseNo(): void {\n    this.address.houseNo = Number(this.address.houseNo);\n  }\n\n}\n"]}

package/esm2015/lib/component/relation/relation-address/relation-address.module.js

@@ -0,0 +1,29 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { RelationAddressComponent } from "./relation-address.component";
+import { ButtonModule, FormModule, InputComboBoxModule, InputTextModule } from "@colijnit/corecomponents_v12";
+import { CoreModule } from "../../core/core.module";
+import { PipeModule } from "../../../pipe/pipe.module";
+export class RelationAddressModule {
+}
+RelationAddressModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    InputComboBoxModule,
+                    InputTextModule,
+                    CoreModule,
+                    FormModule,
+                    ButtonModule,
+                    PipeModule,
+                    PipeModule
+                ],
+                declarations: [
+                    RelationAddressComponent
+                ],
+                exports: [
+                    RelationAddressComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/relation/relation-address-select/relation-address-select.component.js

@@ -0,0 +1,148 @@
+import { Component, ElementRef, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation } from "@angular/core";
+import { Address } from "@colijnit/transactionapi/build/model/address.bo";
+import { Icon } from "../../../enum/icon.enum";
+import { FormMasterService } from "@colijnit/corecomponents_v12";
+import { BusinessObjectFactory } from "../../../factory/business-object-factory";
+import { AddressType } from "@colijnit/transactionapi/build/enum/address-type.enum";
+import { animate, state, style, transition, trigger } from "@angular/animations";
+import { RelationBaseComponent } from "../relation-base.component";
+export class RelationAddressSelectComponent extends RelationBaseComponent {
+    constructor(_formMasterService, _boFactory) {
+        super();
+        this._formMasterService = _formMasterService;
+        this._boFactory = _boFactory;
+        this.icons = Icon;
+        this.collection = [];
+        this.showAdd = true;
+        this.addressAdded = new EventEmitter();
+        this.addressUpdated = new EventEmitter();
+        this.addressSelected = new EventEmitter();
+        this.cancelClick = new EventEmitter();
+        this.selectedIdx = 0;
+        this.showDialog = false;
+        this.showNavigateLeft = true;
+        this.showNavigateRight = true;
+        this._intersectionCallback = (entries, observer) => {
+            const entry = entries[0];
+            if (entry.intersectionRatio < 1) {
+                this.showNavigateRight = true;
+            }
+            else {
+                this._hideButtons();
+            }
+        };
+    }
+    set content(content) {
+        if (content) {
+            this.scrollContainer = content;
+            this._initObserver();
+        }
+    }
+    showClass() {
+        return true;
+    }
+    selectAddress() {
+        this.addressSelected.next(this.collection[this.selectedIdx]);
+    }
+    createAddress() {
+        this.addressToEdit = new Address();
+        this.addressToEdit.addressType = AddressType.DeliveryAddress;
+        this.showDialog = true;
+    }
+    saveAddress(address) {
+        if (this._formMasterService.submitSlaves()) {
+            if (address.getId()) {
+                this.collection[this.selectedIdx] = this._boFactory.makeWithRawBackendData(Address, address);
+            }
+            else {
+                this.collection.push(address);
+            }
+            this.showDialog = false;
+        }
+    }
+    editAddress() {
+        const address = this.collection[this.selectedIdx];
+        if (address) {
+            this.addressToEdit = this._boFactory.makeWithRawBackendData(Address, address);
+            this.showDialog = true;
+        }
+    }
+    _initObserver() {
+        if (this.scrollContainer && this.scrollContainer.nativeElement) {
+            const intersectionOptions = {
+                root: null,
+                rootMargin: '0px',
+                threshold: 1.0
+            };
+            this.observer = new IntersectionObserver(this._intersectionCallback, intersectionOptions);
+            this.observer.observe(this.scrollContainer.nativeElement);
+        }
+    }
+    _hideButtons() {
+        this.showNavigateLeft = false;
+        this.showNavigateRight = false;
+    }
+}
+RelationAddressSelectComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-relation-address-select",
+                template: `
+    <div class="relation-address-content" #scrollContainer>
+      <co-relation-address-tile *ngFor="let address of collection; let index = index"
+                                [address]="address"
+                                [selected]="index === selectedIdx"
+                                (click)="selectedIdx = index">
+      </co-relation-address-tile>
+      <co-relation-address-tile *ngIf="showAdd" [actAsAddTile]="true" (addAddressClicked)="createAddress()"></co-relation-address-tile>
+      <div class="relation-address-navigate left" *ngIf="showNavigateLeft" @showHideNavigationButton>
+        <icon [icon]="icons.ArrowPointLeft"></icon>
+      </div>
+      <div class="relation-address-navigate right" *ngIf="showNavigateRight" @showHideNavigationButton>
+        <icon [icon]="icons.ArrowPointRight"></icon>
+      </div>
+    </div>
+    <div class="relation-address-change">
+      <icon class="relation-address-icon" [icon]="icons.ArrowPointRight"></icon>
+      <div [textContent]="'Wijzig adres'" (click)="editAddress()"></div>
+    </div>
+    <div class="relation-address-select-button-wrapper">
+      <co-button [label]="'SAVE' | localize" (click)="selectAddress()"></co-button>
+      <co-button [label]="'CANCEL' | localize" (click)="cancelClick.emit()"></co-button>
+    </div>
+    <co-dialog *ngIf="showDialog">
+      <co-relation-address
+        [relation]="relation"
+        (saveClick)="saveAddress($event)"
+        (cancelClick)="showDialog = false"
+      ></co-relation-address>
+    </co-dialog>
+  `,
+                providers: [
+                    FormMasterService
+                ],
+                animations: [
+                    trigger("showHideNavigationButton", [
+                        state("void", style({ opacity: 0 })),
+                        state("*", style({ opacity: 1 })),
+                        transition("void => *", animate("200ms ease-in-out")),
+                        transition("* => void", animate("200ms ease-out"))
+                    ])
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+RelationAddressSelectComponent.ctorParameters = () => [
+    { type: FormMasterService },
+    { type: BusinessObjectFactory }
+];
+RelationAddressSelectComponent.propDecorators = {
+    content: [{ type: ViewChild, args: ['scrollContainer', { read: ElementRef },] }],
+    showClass: [{ type: HostBinding, args: ["class.co-relation-address-select",] }],
+    collection: [{ type: Input }],
+    showAdd: [{ type: Input }],
+    addressAdded: [{ type: Output }],
+    addressUpdated: [{ type: Output }],
+    addressSelected: [{ type: Output }],
+    cancelClick: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-address-select.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-address-select/relation-address-select.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, ElementRef, EventEmitter, HostBinding, Input, Output, ViewChild, ViewEncapsulation} from \"@angular/core\";\r\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {FormMasterService} from \"@colijnit/corecomponents_v12\";\r\nimport {BusinessObjectFactory} from \"../../../factory/business-object-factory\";\r\nimport {AddressType} from \"@colijnit/transactionapi/build/enum/address-type.enum\";\r\nimport {animate, state, style, transition, trigger} from \"@angular/animations\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\n\r\n@Component({\r\n  selector: \"co-relation-address-select\",\r\n  template: `\r\n    <div class=\"relation-address-content\" #scrollContainer>\r\n      <co-relation-address-tile *ngFor=\"let address of collection; let index = index\"\r\n                                [address]=\"address\"\r\n                                [selected]=\"index === selectedIdx\"\r\n                                (click)=\"selectedIdx = index\">\r\n      </co-relation-address-tile>\r\n      <co-relation-address-tile *ngIf=\"showAdd\" [actAsAddTile]=\"true\" (addAddressClicked)=\"createAddress()\"></co-relation-address-tile>\r\n      <div class=\"relation-address-navigate left\" *ngIf=\"showNavigateLeft\" @showHideNavigationButton>\r\n        <icon [icon]=\"icons.ArrowPointLeft\"></icon>\r\n      </div>\r\n      <div class=\"relation-address-navigate right\" *ngIf=\"showNavigateRight\" @showHideNavigationButton>\r\n        <icon [icon]=\"icons.ArrowPointRight\"></icon>\r\n      </div>\r\n    </div>\r\n    <div class=\"relation-address-change\">\r\n      <icon class=\"relation-address-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n      <div [textContent]=\"'Wijzig adres'\" (click)=\"editAddress()\"></div>\r\n    </div>\r\n    <div class=\"relation-address-select-button-wrapper\">\r\n      <co-button [label]=\"'SAVE' | localize\" (click)=\"selectAddress()\"></co-button>\r\n      <co-button [label]=\"'CANCEL' | localize\" (click)=\"cancelClick.emit()\"></co-button>\r\n    </div>\r\n    <co-dialog *ngIf=\"showDialog\">\r\n      <co-relation-address\r\n        [relation]=\"relation\"\r\n        (saveClick)=\"saveAddress($event)\"\r\n        (cancelClick)=\"showDialog = false\"\r\n      ></co-relation-address>\r\n    </co-dialog>\r\n  `,\r\n  providers: [\r\n    FormMasterService\r\n  ],\r\n  animations: [\r\n    trigger(\"showHideNavigationButton\", [\r\n      state(\"void\", style({opacity: 0})),\r\n      state(\"*\", style({opacity: 1})),\r\n      transition(\"void => *\", animate(\"200ms ease-in-out\")),\r\n      transition(\"* => void\", animate(\"200ms ease-out\"))\r\n    ])\r\n  ],\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationAddressSelectComponent extends RelationBaseComponent {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @ViewChild('scrollContainer', { read: ElementRef }) set content(content) {\r\n    if (content) {\r\n      this.scrollContainer = content;\r\n      this._initObserver();\r\n    }\r\n  }\r\n\r\n  @HostBinding(\"class.co-relation-address-select\")\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  @Input()\r\n  public collection: Address[] = [];\r\n\r\n  @Input()\r\n  public showAdd: boolean = true;\r\n\r\n  @Output()\r\n  public addressAdded: EventEmitter<Address> = new EventEmitter<Address>();\r\n\r\n  @Output()\r\n  public addressUpdated: EventEmitter<Address> = new EventEmitter<Address>();\r\n\r\n  @Output()\r\n  public addressSelected: EventEmitter<Address> = new EventEmitter<Address>();\r\n\r\n  @Output()\r\n  public cancelClick: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  public selectedIdx: number = 0;\r\n\r\n  public addressToEdit: Address;\r\n  public showDialog: boolean = false;\r\n  public scrollContainer: ElementRef;\r\n  public observer: IntersectionObserver;\r\n  public showNavigateLeft: boolean = true;\r\n  public showNavigateRight: boolean = true;\r\n\r\n  constructor(\r\n    private _formMasterService: FormMasterService,\r\n    private _boFactory: BusinessObjectFactory\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  public selectAddress(): void {\r\n    this.addressSelected.next(this.collection[this.selectedIdx]);\r\n  }\r\n\r\n  public createAddress(): void {\r\n    this.addressToEdit = new Address();\r\n    this.addressToEdit.addressType = AddressType.DeliveryAddress;\r\n    this.showDialog = true;\r\n  }\r\n\r\n  public saveAddress(address: Address): void {\r\n    if (this._formMasterService.submitSlaves()) {\r\n      if (address.getId()) {\r\n        this.collection[this.selectedIdx] = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, address);\r\n      } else {\r\n        this.collection.push(address);\r\n      }\r\n      this.showDialog = false;\r\n    }\r\n  }\r\n\r\n  public editAddress(): void {\r\n    const address: Address = this.collection[this.selectedIdx];\r\n    if (address) {\r\n      this.addressToEdit = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, address);\r\n      this.showDialog = true;\r\n    }\r\n  }\r\n\r\n  private _initObserver(): void {\r\n    if (this.scrollContainer && this.scrollContainer.nativeElement) {\r\n      const intersectionOptions = {\r\n        root: null,\r\n        rootMargin: '0px',\r\n        threshold: 1.0\r\n      };\r\n      this.observer = new IntersectionObserver(this._intersectionCallback, intersectionOptions);\r\n      this.observer.observe(this.scrollContainer.nativeElement);\r\n    }\r\n  }\r\n\r\n  private _intersectionCallback = (entries, observer) => {\r\n    const entry = entries[0];\r\n    if (entry.intersectionRatio < 1) {\r\n      this.showNavigateRight = true;\r\n    } else {\r\n      this._hideButtons();\r\n    }\r\n  }\r\n\r\n  private _hideButtons(): void {\r\n    this.showNavigateLeft = false;\r\n    this.showNavigateRight = false;\r\n  }\r\n}\r\n"]}

package/esm2015/lib/component/relation/relation-address-select/relation-address-select.module.js

@@ -0,0 +1,33 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { RelationAddressSelectComponent } from "./relation-address-select.component";
+import { CoreModule } from "../../core/core.module";
+import { ButtonModule, CoDialogModule, FormModule, IconModule, InputRadioButtonModule } from "@colijnit/corecomponents_v12";
+import { RelationAddressModule } from "../relation-address/relation-address.module";
+import { RelationAddressTileModule } from "../relation-address-tile/relation-address-tile.module";
+import { PipeModule } from "../../../pipe/pipe.module";
+export class RelationAddressSelectModule {
+}
+RelationAddressSelectModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    CoreModule,
+                    InputRadioButtonModule,
+                    IconModule,
+                    CoDialogModule,
+                    RelationAddressModule,
+                    FormModule,
+                    ButtonModule,
+                    RelationAddressTileModule,
+                    PipeModule
+                ],
+                declarations: [
+                    RelationAddressSelectComponent
+                ],
+                exports: [
+                    RelationAddressSelectComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/relation/relation-address-tile/relation-address-tile.component.js

@@ -0,0 +1,61 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { Icon } from "../../../enum/icon.enum";
+export class RelationAddressTileComponent {
+    constructor() {
+        this.icons = Icon;
+        this.actAsAddTile = false;
+        this.selected = false;
+        this.selectedChange = new EventEmitter();
+        this.addAddressClicked = new EventEmitter();
+        this.editAddressClicked = new EventEmitter();
+    }
+    showClass() {
+        return true;
+    }
+    handleEditAddressClick(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+        this.editAddressClicked.next(this.address);
+    }
+}
+RelationAddressTileComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-relation-address-tile",
+                template: `
+    <ng-container *ngIf="!actAsAddTile">
+      <co-tile [selected]="selected" (selectedChange)="selectedChange.emit($event)">
+        <div class="relation-content-wrapper">
+          <span class="relation-address-type" [textContent]="address.displayType | localize"></span>
+          <span class="relation-address-name" [textContent]="address.addressName"></span>
+          <span class="relation-address-address" [textContent]="address.displayAddress"></span>
+          <span class="relation-address-postal" [textContent]="address.displayPostal"></span>
+          <span class="relation-address-country" [textContent]="address.displayCountry"></span>
+        </div>
+        <div class="relation-address-edit" (click)="handleEditAddressClick($event)">
+          <icon class="relation-address-edit-icon" [icon]="icons.EditPencil"></icon>
+        </div>
+      </co-tile>
+    </ng-container>
+    <ng-container *ngIf="actAsAddTile">
+      <co-tile (click)="addAddressClicked.emit()">
+        <div class="relation-content-wrapper">
+          <icon class="relation-address-icon" [icon]="icons.PlusRound"></icon>
+          <span [textContent]="'ADDRESS_ADD' | localize"></span>
+        </div>
+      </co-tile>
+    </ng-container>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+RelationAddressTileComponent.propDecorators = {
+    showClass: [{ type: HostBinding, args: ["class.co-relation-address-tile",] }],
+    address: [{ type: Input }],
+    actAsAddTile: [{ type: Input }],
+    selected: [{ type: Input }],
+    selectedChange: [{ type: Output }],
+    addAddressClicked: [{ type: Output }],
+    editAddressClicked: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/relation/relation-address-tile/relation-address-tile.module.js

@@ -0,0 +1,32 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { RelationAddressTileComponent } from "./relation-address-tile.component";
+import { ButtonModule, CoDialogModule, FormModule, InputRadioButtonModule } from "@colijnit/corecomponents_v12";
+import { CoreModule } from "../../core/core.module";
+import { RelationAddressModule } from "../relation-address/relation-address.module";
+import { PipeModule } from "../../../pipe/pipe.module";
+import { TileModule } from "../../tile/tile.module";
+export class RelationAddressTileModule {
+}
+RelationAddressTileModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    InputRadioButtonModule,
+                    CoreModule,
+                    CoDialogModule,
+                    RelationAddressModule,
+                    ButtonModule,
+                    FormModule,
+                    PipeModule,
+                    TileModule
+                ],
+                declarations: [
+                    RelationAddressTileComponent
+                ],
+                exports: [
+                    RelationAddressTileComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/component/relation/relation-addresses/relation-addresses.component.js

@@ -0,0 +1,95 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from "@angular/core";
+import { Address } from "@colijnit/transactionapi/build/model/address.bo";
+import { Icon } from "../../../enum/icon.enum";
+import { AddressType } from "@colijnit/transactionapi/build/enum/address-type.enum";
+import { BusinessObjectFactory } from "../../../factory/business-object-factory";
+import { RelationBaseComponent } from "../relation-base.component";
+export class RelationAddressesComponent extends RelationBaseComponent {
+    constructor(_boFactory) {
+        super();
+        this._boFactory = _boFactory;
+        this.icons = Icon;
+        this.addresses = [];
+        this.type = AddressType.DeliveryAddress;
+        this.selectedAddressIdx = 0;
+        this.selectedAddressChange = new EventEmitter();
+        this.selectedAddressNawNrChange = new EventEmitter();
+        this.showEditAddressDialog = false;
+    }
+    showClass() {
+        return true;
+    }
+    saveAddress(address) {
+        if (!this.addressToEdit) { // new address
+            address.addressType = this.type;
+            this.addresses.push(address);
+        }
+        else {
+            const idx = this.addresses.findIndex(a => a.nawNr === address.nawNr);
+            if (idx > -1) {
+                this.addresses[idx] = this._boFactory.makeWithRawBackendData(Address, address);
+            }
+        }
+        this.showEditAddressDialog = false;
+    }
+    showNewAddressDialog() {
+        this.addressToEdit = undefined;
+        this.showEditAddressDialog = true;
+    }
+    setIndexAddress(idx) {
+        this.selectedAddressIdx = idx;
+        this.selectedAddressChange.emit(idx);
+        const nawNr = this.addresses[this.selectedAddressIdx].nawNr;
+        this.selectedAddressNawNrChange.emit(nawNr);
+    }
+    editAddress(addr) {
+        this.addressToEdit = this._boFactory.makeWithRawBackendData(Address, addr);
+        this.showEditAddressDialog = true;
+    }
+}
+RelationAddressesComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-relation-addresses",
+                template: `
+    <div class="default-data-row">
+      <co-carousel-3d *ngIf="addresses && addresses.length > 1"
+                      [tileWidth]="200"
+                      [tileHeight]="100"
+                      [selectedIndex]="selectedAddressIdx"
+                      (indexSelected)="setIndexAddress($event)">
+        <co-relation-address-tile #carouselItem *ngFor="let address of addresses; let index = index"
+                                  [address]="address"
+                                  [selected]="selectedAddressIdx === index"
+                                  (editAddressClicked)="editAddress($event)"
+        ></co-relation-address-tile>
+      </co-carousel-3d>
+    </div>
+    <div class="default-data-row">
+      <div class="relation-address-new">
+        <icon class="relation-address-icon" [icon]="icons.ArrowPointRight"></icon>
+        <div [textContent]="'ADDRESS_ADD' | localize" (click)="showNewAddressDialog()"></div>
+      </div>
+    </div>
+    <co-dialog *ngIf="showEditAddressDialog">
+      <co-relation-address
+        [relation]="relation"
+        (saveClick)="saveAddress($event)"
+        (cancelClick)="showEditAddressDialog = false"
+      ></co-relation-address>
+    </co-dialog>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+RelationAddressesComponent.ctorParameters = () => [
+    { type: BusinessObjectFactory }
+];
+RelationAddressesComponent.propDecorators = {
+    addresses: [{ type: Input }],
+    type: [{ type: Input }],
+    selectedAddressIdx: [{ type: Input }],
+    selectedAddressChange: [{ type: Output }],
+    selectedAddressNawNrChange: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ["class.co-relation-addresses",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"relation-addresses.component.js","sourceRoot":"","sources":["../../../../../../../projects/transaction/src/lib/component/relation/relation-addresses/relation-addresses.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,EAAC,MAAM,eAAe,CAAC;AACrG,OAAO,EAAC,OAAO,EAAC,MAAM,iDAAiD,CAAC;AACxE,OAAO,EAAC,IAAI,EAAC,MAAM,yBAAyB,CAAC;AAC7C,OAAO,EAAC,WAAW,EAAC,MAAM,uDAAuD,CAAC;AAClF,OAAO,EAAC,qBAAqB,EAAC,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAC,qBAAqB,EAAC,MAAM,4BAA4B,CAAC;AAkCjE,MAAM,OAAO,0BAA2B,SAAQ,qBAAqB;IA0BnE,YAAoB,UAAiC;QACnD,KAAK,EAAE,CAAC;QADU,eAAU,GAAV,UAAU,CAAuB;QAzBrC,UAAK,GAAgB,IAAI,CAAC;QAGnC,cAAS,GAAc,EAAE,CAAC;QAG1B,SAAI,GAAgB,WAAW,CAAC,eAAe,CAAC;QAGhD,uBAAkB,GAAW,CAAC,CAAC;QAG/B,0BAAqB,GAAyB,IAAI,YAAY,EAAU,CAAC;QAGzE,+BAA0B,GAAyB,IAAI,YAAY,EAAU,CAAC;QAO9E,0BAAqB,GAAY,KAAK,CAAC;IAK9C,CAAC;IATM,SAAS;QACd,OAAO,IAAI,CAAC;IACd,CAAC;IASM,WAAW,CAAC,OAAgB;QACjC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,cAAc;YACvC,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC;YAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;SAC9B;aAAM;YACL,MAAM,GAAG,GAAW,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;YAC7E,IAAI,GAAG,GAAG,CAAC,CAAC,EAAE;gBACZ,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAqB,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;aAClG;SACF;QACD,IAAI,CAAC,qBAAqB,GAAG,KAAK,CAAC;IACrC,CAAC;IAEM,oBAAoB;QACzB,IAAI,CAAC,aAAa,GAAG,SAAS,CAAC;QAC/B,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACpC,CAAC;IAEM,eAAe,CAAC,GAAW;QAChC,IAAI,CAAC,kBAAkB,GAAG,GAAG,CAAC;QAC9B,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,KAAK,GAAW,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,KAAK,CAAC;QACpE,IAAI,CAAC,0BAA0B,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAEM,WAAW,CAAC,IAAa;QAC9B,IAAI,CAAC,aAAa,GAAqB,IAAI,CAAC,UAAU,CAAC,sBAAsB,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QAC7F,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;IACpC,CAAC;;;YA1FF,SAAS,SAAC;gBACT,QAAQ,EAAE,uBAAuB;gBACjC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BT;gBACD,aAAa,EAAE,iBAAiB,CAAC,IAAI;aACtC;;;YAlCO,qBAAqB;;;wBAsC1B,KAAK;mBAGL,KAAK;iCAGL,KAAK;oCAGL,MAAM;yCAGN,MAAM;wBAGN,WAAW,SAAC,6BAA6B","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation} from \"@angular/core\";\r\nimport {Address} from \"@colijnit/transactionapi/build/model/address.bo\";\r\nimport {Icon} from \"../../../enum/icon.enum\";\r\nimport {AddressType} from \"@colijnit/transactionapi/build/enum/address-type.enum\";\r\nimport {BusinessObjectFactory} from \"../../../factory/business-object-factory\";\r\nimport {RelationBaseComponent} from \"../relation-base.component\";\r\n\r\n@Component({\r\n  selector: \"co-relation-addresses\",\r\n  template: `\r\n    <div class=\"default-data-row\">\r\n      <co-carousel-3d *ngIf=\"addresses && addresses.length > 1\"\r\n                      [tileWidth]=\"200\"\r\n                      [tileHeight]=\"100\"\r\n                      [selectedIndex]=\"selectedAddressIdx\"\r\n                      (indexSelected)=\"setIndexAddress($event)\">\r\n        <co-relation-address-tile #carouselItem *ngFor=\"let address of addresses; let index = index\"\r\n                                  [address]=\"address\"\r\n                                  [selected]=\"selectedAddressIdx === index\"\r\n                                  (editAddressClicked)=\"editAddress($event)\"\r\n        ></co-relation-address-tile>\r\n      </co-carousel-3d>\r\n    </div>\r\n    <div class=\"default-data-row\">\r\n      <div class=\"relation-address-new\">\r\n        <icon class=\"relation-address-icon\" [icon]=\"icons.ArrowPointRight\"></icon>\r\n        <div [textContent]=\"'ADDRESS_ADD' | localize\" (click)=\"showNewAddressDialog()\"></div>\r\n      </div>\r\n    </div>\r\n    <co-dialog *ngIf=\"showEditAddressDialog\">\r\n      <co-relation-address\r\n        [relation]=\"relation\"\r\n        (saveClick)=\"saveAddress($event)\"\r\n        (cancelClick)=\"showEditAddressDialog = false\"\r\n      ></co-relation-address>\r\n    </co-dialog>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class RelationAddressesComponent extends RelationBaseComponent {\r\n  public readonly icons: typeof Icon = Icon;\r\n\r\n  @Input()\r\n  public addresses: Address[] = [];\r\n\r\n  @Input()\r\n  public type: AddressType = AddressType.DeliveryAddress;\r\n\r\n  @Input()\r\n  public selectedAddressIdx: number = 0;\r\n\r\n  @Output()\r\n  public selectedAddressChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @Output()\r\n  public selectedAddressNawNrChange: EventEmitter<number> = new EventEmitter<number>();\r\n\r\n  @HostBinding(\"class.co-relation-addresses\")\r\n  public showClass() {\r\n    return true;\r\n  }\r\n\r\n  public showEditAddressDialog: boolean = false;\r\n  public addressToEdit: Address;\r\n\r\n  constructor(private _boFactory: BusinessObjectFactory) {\r\n    super();\r\n  }\r\n\r\n  public saveAddress(address: Address): void {\r\n    if (!this.addressToEdit) { // new address\r\n      address.addressType = this.type;\r\n      this.addresses.push(address);\r\n    } else {\r\n      const idx: number = this.addresses.findIndex(a => a.nawNr === address.nawNr);\r\n      if (idx > -1) {\r\n        this.addresses[idx] = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, address);\r\n      }\r\n    }\r\n    this.showEditAddressDialog = false;\r\n  }\r\n\r\n  public showNewAddressDialog(): void {\r\n    this.addressToEdit = undefined;\r\n    this.showEditAddressDialog = true;\r\n  }\r\n\r\n  public setIndexAddress(idx: number): void {\r\n    this.selectedAddressIdx = idx;\r\n    this.selectedAddressChange.emit(idx);\r\n    const nawNr: number = this.addresses[this.selectedAddressIdx].nawNr;\r\n    this.selectedAddressNawNrChange.emit(nawNr);\r\n  }\r\n\r\n  public editAddress(addr: Address): void {\r\n    this.addressToEdit = <Address><unknown>this._boFactory.makeWithRawBackendData(Address, addr);\r\n    this.showEditAddressDialog = true;\r\n  }\r\n}\r\n"]}