@colijnit/configurator 260.1.2 → 261.1.1

package/esm2015/lib/components/answer-card/answer-card.component.js

@@ -0,0 +1,313 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { IconEnum } from '../../enum/icon.enum';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/settings.service";
+import * as i2 from "../../services/icon-cache.service";
+import * as i3 from "../../services/configurator-connector.service";
+import * as i4 from "@colijnit/corecomponents_v12";
+import * as i5 from "../answer-info-dialog/answer-info-dialog.component";
+import * as i6 from "@angular/common";
+import * as i7 from "../../pipes/google-translate.pipe";
+import * as i8 from "../../pipes/localize.pipe";
+export class AnswerCardComponent {
+    constructor(settingsService, iconService, _configuratorConnectorService) {
+        this.settingsService = settingsService;
+        this.iconService = iconService;
+        this._configuratorConnectorService = _configuratorConnectorService;
+        // TODO check why co-card is missing these two in v12.
+        // [showImageLoader]="true"
+        // [valutaSymbol]="valutaSymbol"
+        this.icons = IconEnum;
+        this.valutaSymbol = '€';
+        this.freeInputChange = new EventEmitter();
+        this.inqNumberChange = new EventEmitter();
+        this.select = new EventEmitter();
+        this.selectWithInq = new EventEmitter();
+        this.magnifierClick = new EventEmitter();
+        this.answerInfoToggle = new EventEmitter();
+        this.dialogPosition = null;
+        this.inqNumberError = false;
+        this.showAnswerInfo = false;
+        this._waitForInput = false;
+        this._waitForInqValue = false;
+    }
+    showClass() {
+        return true;
+    }
+    get activeInfoClass() {
+        return this.showAnswerInfo;
+    }
+    set showing(value) {
+        if (value) {
+            this._getThumbnailImage();
+        }
+    }
+    ngOnInit() {
+        var _a, _b, _c;
+        this.inqNumberModel = this.model.defaultNumber;
+        // If we work with ingNumbers, we should also change the this.model.ingNumber value here
+        // so we change the default 1 value to the default value
+        if (((_a = this.model) === null || _a === void 0 ? void 0 : _a.inquireNbrMode) && ((_b = this.model) === null || _b === void 0 ? void 0 : _b.minNumber) && ((_c = this.model) === null || _c === void 0 ? void 0 : _c.maxNumber)) {
+            this.model.inqNumber = this.model.defaultNumber;
+        }
+    }
+    onContentClick() {
+        if (!this._waitForInput && (this.model.inquireNbrMode === 'F' || this.model.inquireNbrMode === undefined)) {
+            this.select.emit(this.freeInput);
+        }
+        if (!this._waitForInqValue && this.model.inquireNbrMode === 'T') {
+            this.model.inqNumber = Number(this.inqNumberModel);
+            this.select.next(this.inqNumberModel);
+        }
+    }
+    handleClick(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+    }
+    onInfoButtonClick(event) {
+        var _a;
+        event.preventDefault();
+        event.stopPropagation();
+        event.stopImmediatePropagation();
+        this.showAnswerInfo = !this.showAnswerInfo;
+        this.answerInfoToggle.emit({ open: this.showAnswerInfo, id: (_a = this.model) === null || _a === void 0 ? void 0 : _a.nodeId });
+        if (this.showAnswerInfo) {
+            const button = event.currentTarget;
+            const rect = button.getBoundingClientRect();
+            this.dialogPosition = {
+                top: rect.top + 10,
+                right: window.innerWidth - rect.right - 10 // distance from right edge
+            };
+        }
+        else {
+            this.dialogPosition = null;
+        }
+    }
+    closeInfo(silent = true) {
+        var _a;
+        if (!this.showAnswerInfo) {
+            return;
+        }
+        this.showAnswerInfo = false;
+        this.dialogPosition = null;
+        if (!silent) {
+            this.answerInfoToggle.emit({ open: false, id: (_a = this.model) === null || _a === void 0 ? void 0 : _a.nodeId });
+        }
+    }
+    handleFocusFreeInput(event) {
+        this._waitForInput = true;
+    }
+    handleBlurFreeInput(event) {
+        this._waitForInput = false;
+    }
+    handleKeyDownFreeInput(event) {
+        if (event.keyCode === 13) {
+            this._waitForInput = false;
+            this.select.next(this.freeInput);
+        }
+    }
+    handleFocusInqNumber(event) {
+        this._waitForInqValue = true;
+    }
+    handleBlurInqNumber(event) {
+        this._waitForInqValue = !this.validateInqNumber(event);
+    }
+    handleKeyDownInqNumber(event) {
+        if (event.keyCode === 13) {
+            this._waitForInqValue = false;
+            this.model.inqNumber = this.inqNumberModel;
+        }
+    }
+    onZoomImage() {
+        this.magnifierClick.next(this.model);
+    }
+    validateInqNumber(event) {
+        const currentValue = Number(this.inqNumberModel);
+        const minValue = this.model.minNumber;
+        const maxValue = this.model.maxNumber;
+        if (currentValue < minValue) {
+            this.inqNumberError = true;
+            return false;
+        }
+        else if (currentValue > maxValue) {
+            this.inqNumberError = true;
+            return false;
+        }
+        else {
+            this.inqNumberError = false;
+            return false;
+        }
+    }
+    replaceTranslationValues(translation, min, max) {
+        const parts = translation.split('(|~)');
+        // We are doing this the dirtyway
+        return parts[0] + ' ' + min + ' ' + parts[1] + ' ' + max + ' ' + parts[2];
+    }
+    _checkVisibility(entries) {
+        this._configuratorConnectorService.extendWithAnswerTextAndImage(this.model, false);
+    }
+    _getThumbnailImage() {
+        if (!this.model.imageData) {
+            this._configuratorConnectorService.extendWithAnswerTextAndImage(this.model, false);
+        }
+    }
+}
+AnswerCardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardComponent, deps: [{ token: i1.SettingsService }, { token: i2.IconCacheService }, { token: i3.ConfiguratorConnectorService }], target: i0.ɵɵFactoryTarget.Component });
+AnswerCardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: AnswerCardComponent, selector: "co-answer-card", inputs: { model: "model", valutaSymbol: "valutaSymbol", showing: "showing", isSelected: "isSelected", isSmallModus: "isSmallModus", freeInput: "freeInput" }, outputs: { freeInputChange: "freeInputChange", inqNumberChange: "inqNumberChange", select: "select", selectWithInq: "selectWithInq", magnifierClick: "magnifierClick", answerInfoToggle: "answerInfoToggle" }, host: { properties: { "class.co-answer-card": "this.showClass", "class.active-info": "this.activeInfoClass", "class.small-mode": "this.isSmallModus" } }, ngImport: i0, template: `
+    <co-card
+      [imageData]="model?.imageData"
+      [description]="(model?.userInput ? '' : (model?.commercialAnswer || model?.answer)) | googleTranslate | async"
+      [hasInfoButton]="model?.infoAvailable"
+      [hasMagnifierButton]="model?.imageData ? settingsService.settings.options.showZoomButton : false"
+      [isSelected]="isSelected"
+      [price]="model?.price"
+      [level]="!settingsService.settings.options.showStockStatus ? false : model?.stock"
+      (contentClick)="onContentClick()"
+      (click)="handleClick($event)"
+      (infoButtonClick)="onInfoButtonClick($event)"
+      (magnifierButtonClick)="onZoomImage()">
+      <div *ngIf="model?.userInput" class="free-answer">
+        <co-input-text
+          [label]="(model?.commercialAnswer ? model?.commercialAnswer : model?.answer) | googleTranslate | async"
+          [model]="freeInput"
+          (modelChange)="freeInput = $event; freeInputChange.emit($event)"
+          (focus)="handleFocusFreeInput($event)"
+          (blur)="handleBlurFreeInput($event)"
+          (keydown)="handleKeyDownFreeInput($event)">
+        </co-input-text>
+
+        <button (click)="freeInputChange.emit(freeInput)" title="{{'SAVE' | localize}}">
+          <co-icon [iconData]="iconService.getIcon(icons.CheckSolid)"></co-icon>
+        </button>
+      </div>
+      <co-answer-info-dialog
+        *ngIf="showAnswerInfo"
+        [answer]="model"
+        [fixedPosition]="dialogPosition"
+        (click)="onInfoButtonClick($event)"
+        (nothingToShow)="closeInfo(false)">
+      </co-answer-info-dialog>
+      <div *ngIf="model?.inquireNbrMode && model?.minNumber && model?.maxNumber" class="free-answer">
+        <co-input-text
+          [noValidation]="true"
+          [label]="'AMOUNT' | localize"
+          [model]="inqNumberModel"
+          (modelChange)="inqNumberModel = $event; inqNumberChange.emit($event)"
+          (focus)="handleFocusInqNumber($event)"
+          (blur)="handleBlurInqNumber($event)"
+          (keydown)="handleKeyDownInqNumber($event)">
+        </co-input-text>
+        
+        <button (click)="inqNumberChange.emit(inqNumberModel)" title="{{'SAVE' | localize}}">
+          <co-icon [iconData]="iconService.getIcon(icons.CheckSolid)"></co-icon>
+        </button>
+        
+        <span 
+          class="amount-validation-error" 
+          *ngIf="inqNumberError"
+          [textContent]="replaceTranslationValues('AMOUNT_ERROR' | localize, this.model.minNumber, this.model.maxNumber)">
+        </span>
+      </div>
+
+    </co-card>
+  `, isInline: true, components: [{ type: i4.CardComponent, selector: "co-card", inputs: ["isSelected", "isSmallModus", "hasMagnifierButton", "hasInfoButton", "imageData", "description", "price", "level"], outputs: ["contentClick", "infoButtonClick", "magnifierButtonClick"] }, { type: i4.InputTextComponent, selector: "co-input-text", inputs: ["useContent", "placeholder", "align", "type", "pattern", "digitsOnly", "excludePlusMinus", "showClearButton", "showPlaceholderOnFocus", "selectOnFocus", "emptyPlace", "firstDayOfWeek", "noStyle", "hideArrowButtons", "model", "formatPipe", "min", "max", "keyDownWhiteList", "leftIcon", "rightIcon", "leftIconData", "rightIconData"], outputs: ["leftIconClick", "leftIconMouseDown", "leftIconMouseUp", "rightIconClick", "rightIconMouseDown", "rightIconMouseUp", "clearIconClick", "isFocused"] }, { type: i4.IconComponent, selector: "co-icon", inputs: ["icon", "iconData"] }, { type: i5.AnswersInfoDialogComponent, selector: "co-answer-info-dialog", inputs: ["answer", "structure", "fixedPosition"], outputs: ["nothingToShow"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i6.AsyncPipe, "googleTranslate": i7.GoogleTranslatePipe, "localize": i8.LocalizePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'co-answer-card',
+                    template: `
+    <co-card
+      [imageData]="model?.imageData"
+      [description]="(model?.userInput ? '' : (model?.commercialAnswer || model?.answer)) | googleTranslate | async"
+      [hasInfoButton]="model?.infoAvailable"
+      [hasMagnifierButton]="model?.imageData ? settingsService.settings.options.showZoomButton : false"
+      [isSelected]="isSelected"
+      [price]="model?.price"
+      [level]="!settingsService.settings.options.showStockStatus ? false : model?.stock"
+      (contentClick)="onContentClick()"
+      (click)="handleClick($event)"
+      (infoButtonClick)="onInfoButtonClick($event)"
+      (magnifierButtonClick)="onZoomImage()">
+      <div *ngIf="model?.userInput" class="free-answer">
+        <co-input-text
+          [label]="(model?.commercialAnswer ? model?.commercialAnswer : model?.answer) | googleTranslate | async"
+          [model]="freeInput"
+          (modelChange)="freeInput = $event; freeInputChange.emit($event)"
+          (focus)="handleFocusFreeInput($event)"
+          (blur)="handleBlurFreeInput($event)"
+          (keydown)="handleKeyDownFreeInput($event)">
+        </co-input-text>
+
+        <button (click)="freeInputChange.emit(freeInput)" title="{{'SAVE' | localize}}">
+          <co-icon [iconData]="iconService.getIcon(icons.CheckSolid)"></co-icon>
+        </button>
+      </div>
+      <co-answer-info-dialog
+        *ngIf="showAnswerInfo"
+        [answer]="model"
+        [fixedPosition]="dialogPosition"
+        (click)="onInfoButtonClick($event)"
+        (nothingToShow)="closeInfo(false)">
+      </co-answer-info-dialog>
+      <div *ngIf="model?.inquireNbrMode && model?.minNumber && model?.maxNumber" class="free-answer">
+        <co-input-text
+          [noValidation]="true"
+          [label]="'AMOUNT' | localize"
+          [model]="inqNumberModel"
+          (modelChange)="inqNumberModel = $event; inqNumberChange.emit($event)"
+          (focus)="handleFocusInqNumber($event)"
+          (blur)="handleBlurInqNumber($event)"
+          (keydown)="handleKeyDownInqNumber($event)">
+        </co-input-text>
+        
+        <button (click)="inqNumberChange.emit(inqNumberModel)" title="{{'SAVE' | localize}}">
+          <co-icon [iconData]="iconService.getIcon(icons.CheckSolid)"></co-icon>
+        </button>
+        
+        <span 
+          class="amount-validation-error" 
+          *ngIf="inqNumberError"
+          [textContent]="replaceTranslationValues('AMOUNT_ERROR' | localize, this.model.minNumber, this.model.maxNumber)">
+        </span>
+      </div>
+
+    </co-card>
+  `,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.SettingsService }, { type: i2.IconCacheService }, { type: i3.ConfiguratorConnectorService }]; }, propDecorators: { showClass: [{
+                type: HostBinding,
+                args: ['class.co-answer-card']
+            }], activeInfoClass: [{
+                type: HostBinding,
+                args: ['class.active-info']
+            }], model: [{
+                type: Input
+            }], valutaSymbol: [{
+                type: Input
+            }], showing: [{
+                type: Input
+            }], isSelected: [{
+                type: Input
+            }], isSmallModus: [{
+                type: Input
+            }, {
+                type: HostBinding,
+                args: ['class.small-mode']
+            }], freeInput: [{
+                type: Input
+            }], freeInputChange: [{
+                type: Output
+            }], inqNumberChange: [{
+                type: Output
+            }], select: [{
+                type: Output
+            }], selectWithInq: [{
+                type: Output
+            }], magnifierClick: [{
+                type: Output
+            }], answerInfoToggle: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"answer-card.component.js","sourceRoot":"","sources":["../../../../../../projects/configurator/src/lib/components/answer-card/answer-card.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from '@angular/core';\r\nimport {Answer} from '@colijnit/configuratorapi/build/model/answer';\r\nimport {ConfiguratorConnectorService} from '../../services/configurator-connector.service';\r\nimport {SettingsService} from '../../services/settings.service';\r\nimport {IconCacheService} from '../../services/icon-cache.service';\r\nimport {IconEnum} from '../../enum/icon.enum';\r\n\r\n@Component({\r\n  selector: 'co-answer-card',\r\n  template: `\r\n    <co-card\r\n      [imageData]=\"model?.imageData\"\r\n      [description]=\"(model?.userInput ? '' : (model?.commercialAnswer || model?.answer)) | googleTranslate | async\"\r\n      [hasInfoButton]=\"model?.infoAvailable\"\r\n      [hasMagnifierButton]=\"model?.imageData ? settingsService.settings.options.showZoomButton : false\"\r\n      [isSelected]=\"isSelected\"\r\n      [price]=\"model?.price\"\r\n      [level]=\"!settingsService.settings.options.showStockStatus ? false : model?.stock\"\r\n      (contentClick)=\"onContentClick()\"\r\n      (click)=\"handleClick($event)\"\r\n      (infoButtonClick)=\"onInfoButtonClick($event)\"\r\n      (magnifierButtonClick)=\"onZoomImage()\">\r\n      <div *ngIf=\"model?.userInput\" class=\"free-answer\">\r\n        <co-input-text\r\n          [label]=\"(model?.commercialAnswer ? model?.commercialAnswer : model?.answer) | googleTranslate | async\"\r\n          [model]=\"freeInput\"\r\n          (modelChange)=\"freeInput = $event; freeInputChange.emit($event)\"\r\n          (focus)=\"handleFocusFreeInput($event)\"\r\n          (blur)=\"handleBlurFreeInput($event)\"\r\n          (keydown)=\"handleKeyDownFreeInput($event)\">\r\n        </co-input-text>\r\n\r\n        <button (click)=\"freeInputChange.emit(freeInput)\" title=\"{{'SAVE' | localize}}\">\r\n          <co-icon [iconData]=\"iconService.getIcon(icons.CheckSolid)\"></co-icon>\r\n        </button>\r\n      </div>\r\n      <co-answer-info-dialog\r\n        *ngIf=\"showAnswerInfo\"\r\n        [answer]=\"model\"\r\n        [fixedPosition]=\"dialogPosition\"\r\n        (click)=\"onInfoButtonClick($event)\"\r\n        (nothingToShow)=\"closeInfo(false)\">\r\n      </co-answer-info-dialog>\r\n      <div *ngIf=\"model?.inquireNbrMode && model?.minNumber && model?.maxNumber\" class=\"free-answer\">\r\n        <co-input-text\r\n          [noValidation]=\"true\"\r\n          [label]=\"'AMOUNT' | localize\"\r\n          [model]=\"inqNumberModel\"\r\n          (modelChange)=\"inqNumberModel = $event; inqNumberChange.emit($event)\"\r\n          (focus)=\"handleFocusInqNumber($event)\"\r\n          (blur)=\"handleBlurInqNumber($event)\"\r\n          (keydown)=\"handleKeyDownInqNumber($event)\">\r\n        </co-input-text>\r\n        \r\n        <button (click)=\"inqNumberChange.emit(inqNumberModel)\" title=\"{{'SAVE' | localize}}\">\r\n          <co-icon [iconData]=\"iconService.getIcon(icons.CheckSolid)\"></co-icon>\r\n        </button>\r\n        \r\n        <span \r\n          class=\"amount-validation-error\" \r\n          *ngIf=\"inqNumberError\"\r\n          [textContent]=\"replaceTranslationValues('AMOUNT_ERROR' | localize, this.model.minNumber, this.model.maxNumber)\">\r\n        </span>\r\n      </div>\r\n\r\n    </co-card>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class AnswerCardComponent implements OnInit {\r\n\r\n  // TODO check why co-card is missing these two in v12.\r\n  // [showImageLoader]=\"true\"\r\n  // [valutaSymbol]=\"valutaSymbol\"\r\n  public readonly icons: typeof IconEnum = IconEnum;\r\n\r\n  @HostBinding('class.co-answer-card')\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  @HostBinding('class.active-info')\r\n  get activeInfoClass(): boolean {\r\n    return this.showAnswerInfo;\r\n  }\r\n\r\n  // todo introduce AnswerViewModel extends Answer which has priceForDisplay and stock props to avoid ' | any' in this type declaration\r\n  @Input()\r\n  public model: Answer | any;\r\n\r\n  @Input()\r\n  public valutaSymbol: string = '€';\r\n\r\n  @Input()\r\n  public set showing(value: boolean) {\r\n    if (value) {\r\n      this._getThumbnailImage();\r\n    }\r\n  }\r\n\r\n  @Input()\r\n  public isSelected: boolean;\r\n\r\n  @Input()\r\n  @HostBinding('class.small-mode')\r\n  public isSmallModus: boolean;\r\n\r\n  @Input()\r\n  public freeInput: string;\r\n\r\n  @Output()\r\n  public readonly freeInputChange: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  @Output()\r\n  public readonly inqNumberChange: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  @Output()\r\n  public readonly select: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  @Output()\r\n  public readonly selectWithInq: EventEmitter<string> = new EventEmitter<string>();\r\n\r\n  @Output()\r\n  public readonly magnifierClick: EventEmitter<Answer> = new EventEmitter<Answer>();\r\n\r\n  @Output()\r\n  public readonly answerInfoToggle = new EventEmitter<{ open: boolean; id: string }>();\r\n\r\n  public dialogPosition: { top: number, right: number } | null = null;\r\n\r\n  public inqNumberModel: string;\r\n  public inqNumberError: boolean = false;\r\n  public showAnswerInfo: boolean = false;\r\n  private _waitForInput: boolean = false;\r\n  private _waitForInqValue: boolean = false;\r\n\r\n  constructor(\r\n    public settingsService: SettingsService,\r\n    public iconService: IconCacheService,\r\n    private _configuratorConnectorService: ConfiguratorConnectorService\r\n  ) {\r\n  }\r\n\r\n  ngOnInit() {\r\n    this.inqNumberModel = this.model.defaultNumber;\r\n    // If we work with ingNumbers, we should also change the this.model.ingNumber value here\r\n    // so we change the default 1 value to the default value\r\n    if (this.model?.inquireNbrMode && this.model?.minNumber && this.model?.maxNumber) {\r\n      this.model.inqNumber = this.model.defaultNumber;\r\n    }\r\n  }\r\n\r\n  public onContentClick(): void {\r\n    if (!this._waitForInput && (this.model.inquireNbrMode === 'F' || this.model.inquireNbrMode === undefined)) {\r\n      this.select.emit(this.freeInput);\r\n    }\r\n    if (!this._waitForInqValue && this.model.inquireNbrMode === 'T') {\r\n      this.model.inqNumber = Number(this.inqNumberModel);\r\n      this.select.next(this.inqNumberModel);\r\n    }\r\n  }\r\n\r\n  public handleClick(event: MouseEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    event.stopImmediatePropagation();\r\n  }\r\n\r\n  public onInfoButtonClick(event: MouseEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    event.stopImmediatePropagation();\r\n\r\n    this.showAnswerInfo = !this.showAnswerInfo;\r\n    this.answerInfoToggle.emit({open: this.showAnswerInfo, id: this.model?.nodeId});\r\n\r\n    if (this.showAnswerInfo) {\r\n      const button = event.currentTarget as HTMLElement;\r\n      const rect = button.getBoundingClientRect();\r\n      this.dialogPosition = {\r\n        top: rect.top + 10,\r\n        right: window.innerWidth - rect.right - 10 // distance from right edge\r\n      };\r\n    } else {\r\n      this.dialogPosition = null;\r\n    }\r\n\r\n  }\r\n\r\n  public closeInfo(silent = true): void {\r\n    if (!this.showAnswerInfo) {\r\n      return;\r\n    }\r\n    this.showAnswerInfo = false;\r\n    this.dialogPosition = null;\r\n    if (!silent) {\r\n      this.answerInfoToggle.emit({open: false, id: this.model?.nodeId});\r\n    }\r\n  }\r\n\r\n  public handleFocusFreeInput(event: MouseEvent): void {\r\n    this._waitForInput = true;\r\n  }\r\n\r\n  public handleBlurFreeInput(event: MouseEvent): void {\r\n    this._waitForInput = false;\r\n  }\r\n\r\n  public handleKeyDownFreeInput(event: KeyboardEvent): void {\r\n    if (event.keyCode === 13) {\r\n      this._waitForInput = false;\r\n      this.select.next(this.freeInput);\r\n    }\r\n  }\r\n\r\n  public handleFocusInqNumber(event: MouseEvent): void {\r\n    this._waitForInqValue = true;\r\n  }\r\n\r\n  public handleBlurInqNumber(event: MouseEvent): void {\r\n    this._waitForInqValue = !this.validateInqNumber(event);\r\n  }\r\n\r\n  public handleKeyDownInqNumber(event: KeyboardEvent): void {\r\n    if (event.keyCode === 13) {\r\n      this._waitForInqValue = false;\r\n      this.model.inqNumber = this.inqNumberModel;\r\n    }\r\n  }\r\n\r\n  public onZoomImage(): void {\r\n    this.magnifierClick.next(this.model);\r\n  }\r\n\r\n  public validateInqNumber(event: MouseEvent): boolean {\r\n    const currentValue: number = Number(this.inqNumberModel);\r\n    const minValue: number = this.model.minNumber;\r\n    const maxValue: number = this.model.maxNumber;\r\n\r\n    if (currentValue < minValue) {\r\n      this.inqNumberError = true;\r\n      return false;\r\n    } else if (currentValue > maxValue) {\r\n      this.inqNumberError = true;\r\n      return false;\r\n    } else {\r\n      this.inqNumberError = false;\r\n      return false;\r\n    }\r\n  }\r\n\r\n  public replaceTranslationValues(translation: string, min: number, max: number): string {\r\n    const parts = translation.split('(|~)');\r\n    // We are doing this the dirtyway\r\n    return parts[0] + ' ' + min + ' ' + parts[1] + ' ' + max + ' ' + parts[2];\r\n  }\r\n\r\n\r\n  private _checkVisibility(entries): void {\r\n    this._configuratorConnectorService.extendWithAnswerTextAndImage(this.model, false);\r\n  }\r\n\r\n  private _getThumbnailImage(): void {\r\n    if (!this.model.imageData) {\r\n      this._configuratorConnectorService.extendWithAnswerTextAndImage(this.model, false);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/answer-card/answer-card.module.js

@@ -0,0 +1,50 @@
+import { NgModule } from '@angular/core';
+import { AnswerCardComponent } from './answer-card.component';
+import { CardModule, IconModule, InputTextModule } from '@colijnit/corecomponents_v12';
+import { PipesModule } from '../../pipes/pipes.module';
+import { BrowserModule } from '@angular/platform-browser';
+import { AnswersInfoDialogModule } from '../answer-info-dialog/answer-info-dialog.module';
+import * as i0 from "@angular/core";
+export class AnswerCardModule {
+}
+AnswerCardModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AnswerCardModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardModule, declarations: [AnswerCardComponent], imports: [CardModule,
+        PipesModule,
+        CardModule,
+        InputTextModule,
+        BrowserModule,
+        IconModule,
+        AnswersInfoDialogModule,
+        CardModule], exports: [AnswerCardComponent] });
+AnswerCardModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardModule, imports: [[
+            CardModule,
+            PipesModule,
+            CardModule,
+            InputTextModule,
+            BrowserModule,
+            IconModule,
+            AnswersInfoDialogModule,
+            CardModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswerCardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CardModule,
+                        PipesModule,
+                        CardModule,
+                        InputTextModule,
+                        BrowserModule,
+                        IconModule,
+                        AnswersInfoDialogModule,
+                        CardModule
+                    ],
+                    declarations: [
+                        AnswerCardComponent,
+                    ],
+                    exports: [
+                        AnswerCardComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/answer-info-dialog/answer-info-dialog.component.js

@@ -0,0 +1,182 @@
+import { __awaiter } from "tslib";
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { IconEnum } from '../../enum/icon.enum';
+import { isNill } from '@colijnit/configuratorapi/build/utils/function/is-nill.function';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/icon-cache.service";
+import * as i2 from "../../services/settings.service";
+import * as i3 from "../../services/configurator-connector.service";
+import * as i4 from "@angular/platform-browser";
+import * as i5 from "@colijnit/corecomponents_v12";
+import * as i6 from "@angular/common";
+import * as i7 from "../../pipes/localize.pipe";
+export class AnswersInfoDialogComponent {
+    constructor(iconService, _settingsService, _configuratorConnectorService, _sanitizer) {
+        this.iconService = iconService;
+        this._settingsService = _settingsService;
+        this._configuratorConnectorService = _configuratorConnectorService;
+        this._sanitizer = _sanitizer;
+        this.icons = IconEnum;
+        this.fixedPosition = null;
+        this.nothingToShow = new EventEmitter();
+        this.answerText = '';
+        this.answerImage = '';
+        this.answerHtml = '';
+        this.textLoading = false;
+        this.textError = '';
+        this.showTooltip = false;
+        this.showPopup = false;
+        this.hasEmbed = false;
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.textLoading = true;
+            try {
+                yield this._loadInfo();
+            }
+            catch (e) {
+                this.textError = e ? e.message : 'Failed to load info.';
+            }
+            finally {
+                this.textLoading = false;
+            }
+        });
+    }
+    _loadInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let items = [];
+            if (this.answer) {
+                // Case 1: called with Answer
+                items = yield this._configuratorConnectorService.getAnswerInfo(this.answer);
+                this.answerImage = yield this._configuratorConnectorService.getMoodImageForInfoDialog(this.answer);
+            }
+            else if (this.structure) {
+                // Case 2: called with SelectorStructure
+                items = yield this._configuratorConnectorService.getStructureInfo(this.structure);
+            }
+            // Common content building logic
+            const formatted = this._formatAnswerInfo(items);
+            this.answerText = /<[^>]+>/.test(formatted)
+                ? formatted
+                : formatted.replace(/\n/g, '<br>');
+            if (/<iframe|<embed/i.test(this.answerText)) {
+                this.answerImage = '';
+                this.hasEmbed = true;
+            }
+            this.answerHtml = this._sanitizer.bypassSecurityTrustHtml(this.answerText);
+        });
+    }
+    _formatAnswerInfo(items) {
+        if (!items || items.length === 0) {
+            return '';
+        }
+        const textParts = [];
+        let includesShort = false;
+        let includesLong = false;
+        for (const articleText of items) {
+            if (!articleText.text) {
+                continue;
+            }
+            if (isNill(articleText.publication) || ((articleText.publication & this._settingsService.settings.infoPublicationCode) > 0)) {
+                const body = articleText.text.trim();
+                const label = articleText.description ? articleText.description.trim() : '';
+                const textPublication = articleText.textType;
+                const bodyHasHtml = /<[^>]+>/.test(body);
+                if ((textPublication & 1 /* ShortDescription */) > 0) {
+                    includesShort = true;
+                    textParts.push(body || label);
+                }
+                if ((textPublication & 2 /* Description */) > 0) {
+                    includesLong = true;
+                    if (label && body) {
+                        textParts.push(bodyHasHtml ? `<p class="info-heading">${label}</p>${body}` : `${label}\n${body}`);
+                    }
+                    else {
+                        textParts.push(body || label);
+                    }
+                }
+            }
+        }
+        if (includesShort) {
+            this.showTooltip = true;
+            this.showPopup = false;
+            return textParts.join('\n\n---\n\n');
+        }
+        if (includesLong) {
+            this.showPopup = true;
+            this.showTooltip = false;
+            return textParts.join('\n\n---\n\n');
+        }
+        this.showTooltip = false;
+        this.showPopup = false;
+        this.nothingToShow.emit();
+        return '';
+    }
+}
+AnswersInfoDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswersInfoDialogComponent, deps: [{ token: i1.IconCacheService }, { token: i2.SettingsService }, { token: i3.ConfiguratorConnectorService }, { token: i4.DomSanitizer }], target: i0.ɵɵFactoryTarget.Component });
+AnswersInfoDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: AnswersInfoDialogComponent, selector: "co-answer-info-dialog", inputs: { answer: "answer", structure: "structure", fixedPosition: "fixedPosition" }, outputs: { nothingToShow: "nothingToShow" }, host: { properties: { "class.co-answer-info-dialog": "this.showClass" } }, ngImport: i0, template: `
+    <div *ngIf="showTooltip" [ngStyle]="{ top: fixedPosition.top + 'px', right: fixedPosition.right + 'px' }" class="answer-info-tooltip">
+      <div class="info-text" *ngIf="answerText" [innerHTML]="answerHtml"></div>
+      <div class="loading" *ngIf="textLoading" [textContent]="'LOADING' | localize"></div>
+      <div class="error" *ngIf="textError" [textContent]="textError"></div>
+    </div>
+    <div *ngIf="showPopup" class="answer-info-popup">
+      <div class="inner-info">
+        <div class="info-content">
+          <div class="close-button-wrapper">
+            <co-icon class="close-button" [iconData]="iconService.getIcon(icons.Cross)" (click)="showPopup = false"></co-icon>
+          </div>
+          <div class="info-image" *ngIf="answerImage"><img alt="" src="{{answerImage}}"/></div>
+          <div class="text-content" [class.has-embed]="hasEmbed">
+            <div class="info-text" *ngIf="answerText" [innerHTML]="answerHtml"></div>
+          </div>
+          <div class="loading" *ngIf="textLoading" [textContent]="'LOADING' | localize"></div>
+          <div class="error" *ngIf="textError" [textContent]="textError"></div>
+        </div>
+      </div>
+    </div>
+  `, isInline: true, components: [{ type: i5.IconComponent, selector: "co-icon", inputs: ["icon", "iconData"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i6.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }], pipes: { "localize": i7.LocalizePipe }, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: AnswersInfoDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'co-answer-info-dialog',
+                    template: `
+    <div *ngIf="showTooltip" [ngStyle]="{ top: fixedPosition.top + 'px', right: fixedPosition.right + 'px' }" class="answer-info-tooltip">
+      <div class="info-text" *ngIf="answerText" [innerHTML]="answerHtml"></div>
+      <div class="loading" *ngIf="textLoading" [textContent]="'LOADING' | localize"></div>
+      <div class="error" *ngIf="textError" [textContent]="textError"></div>
+    </div>
+    <div *ngIf="showPopup" class="answer-info-popup">
+      <div class="inner-info">
+        <div class="info-content">
+          <div class="close-button-wrapper">
+            <co-icon class="close-button" [iconData]="iconService.getIcon(icons.Cross)" (click)="showPopup = false"></co-icon>
+          </div>
+          <div class="info-image" *ngIf="answerImage"><img alt="" src="{{answerImage}}"/></div>
+          <div class="text-content" [class.has-embed]="hasEmbed">
+            <div class="info-text" *ngIf="answerText" [innerHTML]="answerHtml"></div>
+          </div>
+          <div class="loading" *ngIf="textLoading" [textContent]="'LOADING' | localize"></div>
+          <div class="error" *ngIf="textError" [textContent]="textError"></div>
+        </div>
+      </div>
+    </div>
+  `,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i1.IconCacheService }, { type: i2.SettingsService }, { type: i3.ConfiguratorConnectorService }, { type: i4.DomSanitizer }]; }, propDecorators: { showClass: [{
+                type: HostBinding,
+                args: ['class.co-answer-info-dialog']
+            }], answer: [{
+                type: Input
+            }], structure: [{
+                type: Input
+            }], fixedPosition: [{
+                type: Input
+            }], nothingToShow: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"answer-info-dialog.component.js","sourceRoot":"","sources":["../../../../../../projects/configurator/src/lib/components/answer-info-dialog/answer-info-dialog.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {Component, EventEmitter, HostBinding, Input, OnInit, Output, ViewEncapsulation} from '@angular/core';\r\nimport {Answer} from '@colijnit/configuratorapi/build/model/answer';\r\nimport {ArticleText} from '@colijnit/configuratorapi/build/model/article-text.bo';\r\nimport {DomSanitizer, SafeHtml} from '@angular/platform-browser';\r\nimport {SelectorStructure} from '@colijnit/configuratorapi/build/model/selector-structure.bo';\r\nimport {ConfiguratorConnectorService} from '../../services/configurator-connector.service';\r\nimport {IconCacheService} from '../../services/icon-cache.service';\r\nimport {IconEnum} from '../../enum/icon.enum';\r\nimport {SettingsService} from '../../services/settings.service';\r\nimport {isNill} from '@colijnit/configuratorapi/build/utils/function/is-nill.function';\r\n\r\nconst enum Publication {\r\n  ShortDescription = 1,\r\n  Description = 2,\r\n  MetaTitle = 4,\r\n  MetaDescription = 8,\r\n  LongTitle = 16\r\n}\r\n\r\n@Component({\r\n  selector: 'co-answer-info-dialog',\r\n  template: `\r\n    <div *ngIf=\"showTooltip\" [ngStyle]=\"{ top: fixedPosition.top + 'px', right: fixedPosition.right + 'px' }\" class=\"answer-info-tooltip\">\r\n      <div class=\"info-text\" *ngIf=\"answerText\" [innerHTML]=\"answerHtml\"></div>\r\n      <div class=\"loading\" *ngIf=\"textLoading\" [textContent]=\"'LOADING' | localize\"></div>\r\n      <div class=\"error\" *ngIf=\"textError\" [textContent]=\"textError\"></div>\r\n    </div>\r\n    <div *ngIf=\"showPopup\" class=\"answer-info-popup\">\r\n      <div class=\"inner-info\">\r\n        <div class=\"info-content\">\r\n          <div class=\"close-button-wrapper\">\r\n            <co-icon class=\"close-button\" [iconData]=\"iconService.getIcon(icons.Cross)\" (click)=\"showPopup = false\"></co-icon>\r\n          </div>\r\n          <div class=\"info-image\" *ngIf=\"answerImage\"><img alt=\"\" src=\"{{answerImage}}\"/></div>\r\n          <div class=\"text-content\" [class.has-embed]=\"hasEmbed\">\r\n            <div class=\"info-text\" *ngIf=\"answerText\" [innerHTML]=\"answerHtml\"></div>\r\n          </div>\r\n          <div class=\"loading\" *ngIf=\"textLoading\" [textContent]=\"'LOADING' | localize\"></div>\r\n          <div class=\"error\" *ngIf=\"textError\" [textContent]=\"textError\"></div>\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  encapsulation: ViewEncapsulation.None\r\n})\r\nexport class AnswersInfoDialogComponent implements OnInit {\r\n  public readonly icons: typeof IconEnum = IconEnum;\r\n\r\n  @HostBinding('class.co-answer-info-dialog')\r\n  public showClass(): boolean {\r\n    return true;\r\n  }\r\n\r\n  @Input()\r\n  public answer: Answer;\r\n\r\n  @Input()\r\n  public structure: SelectorStructure;\r\n\r\n  @Input()\r\n  public fixedPosition: { top: number, right: number } | null = null;\r\n\r\n  @Output()\r\n  public nothingToShow: EventEmitter<void> = new EventEmitter<void>();\r\n\r\n  public answerText: string = '';\r\n  public answerImage: string = '';\r\n  public answerHtml: SafeHtml = '';\r\n  public textLoading: boolean = false;\r\n  public textError: string = '';\r\n  public showTooltip: boolean = false;\r\n  public showPopup: boolean = false;\r\n  public hasEmbed: boolean = false;\r\n\r\n  constructor(\r\n    public iconService: IconCacheService,\r\n    private _settingsService: SettingsService,\r\n    private _configuratorConnectorService: ConfiguratorConnectorService,\r\n    private _sanitizer: DomSanitizer\r\n  ) {\r\n  }\r\n\r\n  async ngOnInit(): Promise<void> {\r\n    this.textLoading = true;\r\n\r\n    try {\r\n      await this._loadInfo();\r\n    } catch (e: any) {\r\n      this.textError = e ? e.message : 'Failed to load info.';\r\n    } finally {\r\n      this.textLoading = false;\r\n    }\r\n  }\r\n\r\n  private async _loadInfo(): Promise<void> {\r\n    let items: ArticleText[] = [];\r\n    if (this.answer) {\r\n      // Case 1: called with Answer\r\n      items = await this._configuratorConnectorService.getAnswerInfo(this.answer);\r\n      this.answerImage = await this._configuratorConnectorService.getMoodImageForInfoDialog(this.answer);\r\n    } else if (this.structure) {\r\n      // Case 2: called with SelectorStructure\r\n      items = await this._configuratorConnectorService.getStructureInfo(this.structure);\r\n    }\r\n\r\n    // Common content building logic\r\n    const formatted: string = this._formatAnswerInfo(items);\r\n    this.answerText = /<[^>]+>/.test(formatted)\r\n      ? formatted\r\n      : formatted.replace(/\\n/g, '<br>');\r\n\r\n    if (/<iframe|<embed/i.test(this.answerText)) {\r\n      this.answerImage = '';\r\n      this.hasEmbed = true;\r\n    }\r\n\r\n    this.answerHtml = this._sanitizer.bypassSecurityTrustHtml(this.answerText);\r\n  }\r\n\r\n  private _formatAnswerInfo(items: ArticleText[]): string {\r\n    if (!items || items.length === 0) {\r\n      return '';\r\n    }\r\n    const textParts: string[] = [];\r\n    let includesShort: boolean = false;\r\n    let includesLong: boolean = false;\r\n    for (const articleText of items) {\r\n      if (!articleText.text) {\r\n        continue;\r\n      }\r\n      if (isNill(articleText.publication) || ((articleText.publication & this._settingsService.settings.infoPublicationCode) > 0)) {\r\n        const body: string = articleText.text.trim();\r\n        const label: string = articleText.description ? articleText.description.trim() : '';\r\n        const textPublication: number = articleText.textType;\r\n        const bodyHasHtml: boolean = /<[^>]+>/.test(body);\r\n        if ((textPublication & Publication.ShortDescription) > 0) {\r\n          includesShort = true;\r\n          textParts.push(body || label);\r\n        }\r\n        if ((textPublication & Publication.Description) > 0) {\r\n          includesLong = true;\r\n          if (label && body) {\r\n            textParts.push(\r\n              bodyHasHtml ? `<p class=\"info-heading\">${label}</p>${body}` : `${label}\\n${body}`\r\n            );\r\n          } else {\r\n            textParts.push(body || label);\r\n          }\r\n        }\r\n      }\r\n    }\r\n    if (includesShort) {\r\n      this.showTooltip = true;\r\n      this.showPopup = false;\r\n      return textParts.join('\\n\\n---\\n\\n');\r\n    }\r\n    if (includesLong) {\r\n      this.showPopup = true;\r\n      this.showTooltip = false;\r\n      return textParts.join('\\n\\n---\\n\\n');\r\n    }\r\n    this.showTooltip = false;\r\n    this.showPopup = false;\r\n    this.nothingToShow.emit();\r\n    return '';\r\n  }\r\n}\r\n"]}