@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/smart-form/widgets/components/smart-voice-recorder/smart-voice-recorder.component.mjs

@@ -0,0 +1,151 @@
+import { Component, EventEmitter, forwardRef, Inject, Input, Optional, Output, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { RecordingUploaderPropertiesOpenDirectionEnum } from '../../../api';
+import { COMPONENT_LIBRARY, } from '../../../../view-context/utility/componentLibrary';
+import { UploadWidgetUtils } from '../../../../view-context/smart-ui-action/components/upload-widget/upload-widget.utils';
+import { SmartStyleUtility } from '../../../../view-context/utility/smart-style-utility';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../../view-context/smart-ui-action/components/upload-widget/voice-record-widget/voice-record-widget.component";
+import * as i2 from "../../../../view-context/utility/componentLibrary";
+export class SmartVoiceRecorderComponent {
+    get widgetInstance() {
+        return this._widgetInstance;
+    }
+    set widgetInstance(value) {
+        if (value) {
+            this.clone(value);
+        }
+    }
+    constructor(cdr, compLib) {
+        this.cdr = cdr;
+        this.compLib = compLib;
+        this.uploadFilesEvent = new EventEmitter();
+        this.onChange = (value) => { };
+        this.onTouched = () => { };
+        this.isDisabled = false;
+    }
+    clone(value) {
+        this._widgetInstance =
+            typeof structuredClone === 'function'
+                ? structuredClone(value)
+                : JSON.parse(JSON.stringify(value));
+        this.cdr.markForCheck();
+    }
+    upload(event) {
+        if (!event.files || event.files.length == 0) {
+            return;
+        }
+        const props = this._widgetInstance.recordingUploaderProperties;
+        const uiAction = props.uploadAction;
+        this.uploadFilesEvent.emit({
+            files: event.files,
+            uiAction: uiAction,
+            uploadDescriptor: event.uploadDescriptor,
+        });
+        this.onChange(this._widgetInstance.value);
+        this.fileToChange = undefined;
+    }
+    isTypeSupported(value) {
+        return !!(value && !Array.isArray(value) && 'dataUri' in value);
+    }
+    formatSize(bytes) {
+        return UploadWidgetUtils.formatSize(bytes);
+    }
+    getLabelNgClass() {
+        return this._widgetInstance?.labelStyle
+            ? SmartStyleUtility.getNgClasses(this._widgetInstance.labelStyle)
+            : {};
+    }
+    getLabelStyle() {
+        return this._widgetInstance?.labelStyle
+            ? SmartStyleUtility.getNgStyles(this._widgetInstance.labelStyle)
+            : {};
+    }
+    getNgClass() {
+        return SmartStyleUtility.getNgClasses(this._widgetInstance?.style);
+    }
+    getStyle() {
+        if (!this._widgetInstance.style) {
+            this._widgetInstance.style = {
+                classesToAdd: [],
+                classesToRemove: [],
+                style: {},
+            };
+        }
+        return SmartStyleUtility.getNgStyles(this._widgetInstance.style);
+    }
+    writeValue(value) {
+        if (value !== undefined && this._widgetInstance) {
+            this._widgetInstance.value = value;
+            this.cdr.markForCheck();
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.isDisabled = isDisabled;
+    }
+    get toolbarComponent() {
+        return this.toolbar;
+    }
+    get openDirection() {
+        const dir = this._widgetInstance?.recordingUploaderProperties?.openDirection;
+        return dir === RecordingUploaderPropertiesOpenDirectionEnum.LEFT ? 'LEFT' : 'RIGHT';
+    }
+    uploadRecording(file) {
+        if (!file) {
+            return;
+        }
+        const props = this._widgetInstance?.recordingUploaderProperties;
+        const action = props?.uploadAction;
+        if (!action) {
+            return;
+        }
+        const uiAction = {
+            ...action,
+            path: action.path ?? this._widgetInstance?.key,
+            identifier: action.identifier ?? this._widgetInstance?.type,
+        };
+        this.uploadFilesEvent.emit({
+            files: [file],
+            uiAction,
+        });
+        this.onChange(this._widgetInstance?.value);
+        this.fileToChange = undefined;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartVoiceRecorderComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: COMPONENT_LIBRARY, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.11", type: SmartVoiceRecorderComponent, selector: "smart-voice-recorder", inputs: { widgetInstance: "widgetInstance" }, outputs: { uploadFilesEvent: "uploadFilesEvent" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => SmartVoiceRecorderComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "toolbar", first: true, predicate: ["toolbar"], descendants: true }], ngImport: i0, template: "<voice-record-widget [openDirection]=\"openDirection\" (recordingSaved)=\"uploadRecording($event)\">\n</voice-record-widget>\n", styles: [":host{display:block;width:100%;min-width:0}\n"], dependencies: [{ kind: "component", type: i1.VoiceRecordWidgetComponent, selector: "voice-record-widget", inputs: ["openDirection"], outputs: ["recordingSaved"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: SmartVoiceRecorderComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-voice-recorder', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => SmartVoiceRecorderComponent),
+                            multi: true,
+                        },
+                    ], template: "<voice-record-widget [openDirection]=\"openDirection\" (recordingSaved)=\"uploadRecording($event)\">\n</voice-record-widget>\n", styles: [":host{display:block;width:100%;min-width:0}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i2.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }, {
+                    type: Optional
+                }] }], propDecorators: { toolbar: [{
+                type: ViewChild,
+                args: ['toolbar']
+            }], widgetInstance: [{
+                type: Input
+            }], uploadFilesEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smart-voice-recorder.component.js","sourceRoot":"","sources":["../../../../../../../../projects/smart-ng-client/src/lib/smart-form/widgets/components/smart-voice-recorder/smart-voice-recorder.component.ts","../../../../../../../../projects/smart-ng-client/src/lib/smart-form/widgets/components/smart-voice-recorder/smart-voice-recorder.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  Input,\n  Optional,\n  Output,\n  ViewChild,\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { SmartRecordingUploader } from '../../../smartform.form-model';\nimport { RecordingUploaderPropertiesOpenDirectionEnum } from '../../../api';\nimport { UiAction, UiActionUploadDescriptor } from '../../../../view-context/api/model/models';\nimport {\n  COMPONENT_LIBRARY,\n  ComponentLibrary,\n} from '../../../../view-context/utility/componentLibrary';\nimport { UiActionToolbarComponent } from '../../../../view-context/smart-ui-action/ui-action-toolbar.component';\nimport { UploadWidgetUtils } from '../../../../view-context/smart-ui-action/components/upload-widget/upload-widget.utils';\nimport { SmartStyleUtility } from '../../../../view-context/utility/smart-style-utility';\n\n@Component({\n  selector: 'smart-voice-recorder',\n  templateUrl: './smart-voice-recorder.component.html',\n  styleUrl: './smart-voice-recorder.component.css',\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => SmartVoiceRecorderComponent),\n      multi: true,\n    },\n  ],\n})\nexport class SmartVoiceRecorderComponent implements ControlValueAccessor {\n  @ViewChild('toolbar') toolbar!: UiActionToolbarComponent;\n\n  private _widgetInstance!: SmartRecordingUploader;\n\n  @Input()\n  get widgetInstance(): SmartRecordingUploader {\n    return this._widgetInstance;\n  }\n  set widgetInstance(value: SmartRecordingUploader) {\n    if (value) {\n      this.clone(value);\n    }\n  }\n\n  @Output() uploadFilesEvent = new EventEmitter<{\n    files: any[];\n    uiAction: UiAction;\n    uploadDescriptor?: UiActionUploadDescriptor;\n  }>();\n\n  fileToChange?: any;\n\n  constructor(\n    private cdr: ChangeDetectorRef,\n    @Inject(COMPONENT_LIBRARY) @Optional() public compLib?: ComponentLibrary\n  ) {}\n\n  private clone(value: SmartRecordingUploader) {\n    this._widgetInstance =\n      typeof structuredClone === 'function'\n        ? structuredClone(value)\n        : JSON.parse(JSON.stringify(value));\n\n    this.cdr.markForCheck();\n  }\n\n  upload(event: any): void {\n    if (!event.files || event.files.length == 0) {\n      return;\n    }\n\n    const props = this._widgetInstance.recordingUploaderProperties!;\n    const uiAction = props.uploadAction;\n\n    this.uploadFilesEvent.emit({\n      files: event.files,\n      uiAction: uiAction!,\n      uploadDescriptor: event.uploadDescriptor,\n    });\n\n    this.onChange(this._widgetInstance.value);\n    this.fileToChange = undefined;\n  }\n\n  isTypeSupported(value: any): boolean {\n    return !!(value && !Array.isArray(value) && 'dataUri' in value);\n  }\n\n  formatSize(bytes: number): string {\n    return UploadWidgetUtils.formatSize(bytes);\n  }\n\n  getLabelNgClass(): { [className: string]: boolean } {\n    return this._widgetInstance?.labelStyle\n      ? SmartStyleUtility.getNgClasses(this._widgetInstance.labelStyle)\n      : {};\n  }\n\n  getLabelStyle(): { [key: string]: string | number } {\n    return this._widgetInstance?.labelStyle\n      ? SmartStyleUtility.getNgStyles(this._widgetInstance.labelStyle)\n      : {};\n  }\n\n  getNgClass(): { [className: string]: boolean } {\n    return SmartStyleUtility.getNgClasses(this._widgetInstance?.style);\n  }\n\n  getStyle(): { [key: string]: string | number } {\n    if (!this._widgetInstance.style) {\n      this._widgetInstance.style = {\n        classesToAdd: [],\n        classesToRemove: [],\n        style: {},\n      };\n    }\n    return SmartStyleUtility.getNgStyles(this._widgetInstance.style);\n  }\n\n  onChange = (value: any) => {};\n  onTouched = () => {};\n  isDisabled = false;\n\n  writeValue(value: any): void {\n    if (value !== undefined && this._widgetInstance) {\n      this._widgetInstance.value = value;\n      this.cdr.markForCheck();\n    }\n  }\n\n  registerOnChange(fn: any): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: any): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState?(isDisabled: boolean): void {\n    this.isDisabled = isDisabled;\n  }\n\n  get toolbarComponent(): UiActionToolbarComponent {\n    return this.toolbar;\n  }\n\n  get openDirection(): 'LEFT' | 'RIGHT' {\n    const dir = this._widgetInstance?.recordingUploaderProperties?.openDirection;\n    return dir === RecordingUploaderPropertiesOpenDirectionEnum.LEFT ? 'LEFT' : 'RIGHT';\n  }\n\n  uploadRecording(file: any) {\n    if (!file) {\n      return;\n    }\n\n    const props = this._widgetInstance?.recordingUploaderProperties;\n    const action = props?.uploadAction;\n\n    if (!action) {\n      return;\n    }\n\n    const uiAction: UiAction = {\n      ...action,\n      path: action.path ?? this._widgetInstance?.key,\n      identifier: action.identifier ?? this._widgetInstance?.type,\n    };\n\n    this.uploadFilesEvent.emit({\n      files: [file],\n      uiAction,\n    });\n\n    this.onChange(this._widgetInstance?.value);\n    this.fileToChange = undefined;\n  }\n}\n","<voice-record-widget [openDirection]=\"openDirection\" (recordingSaved)=\"uploadRecording($event)\">\n</voice-record-widget>\n"]}

package/esm2022/lib/smart-form/widgets/directives/comparable-dropdown.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, Input } from '@angular/core';
+import { ObjectUtils } from 'primeng/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/dropdown";
+const EQUALITY_METHOD_NAME = 'isOptionValueEqualsModelValue';
+export class ComparableDropdownDirective {
+    set compareWith(fn) {
+        if (fn) {
+            this.dropdown[EQUALITY_METHOD_NAME] = (option) => {
+                return (fn(this.dropdown.modelValue(), this.dropdown.getOptionValue(option)) ||
+                    ObjectUtils.equals(this.dropdown.modelValue(), this.dropdown.getOptionValue(option), this.dropdown.equalityKey()));
+            };
+        }
+        else {
+            this.dropdown[EQUALITY_METHOD_NAME] = (option) => {
+                return ObjectUtils.equals(this.dropdown.modelValue(), this.dropdown.getOptionValue(option), this.dropdown.equalityKey());
+            };
+        }
+    }
+    constructor(dropdown) {
+        this.dropdown = dropdown;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ComparableDropdownDirective, deps: [{ token: i1.Dropdown }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.11", type: ComparableDropdownDirective, selector: "p-dropdown", inputs: { compareWith: "compareWith" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ComparableDropdownDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'p-dropdown',
+                    inputs: ['compareWith'],
+                }]
+        }], ctorParameters: () => [{ type: i1.Dropdown }], propDecorators: { compareWith: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29tcGFyYWJsZS1kcm9wZG93bi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zbWFydC1uZy1jbGllbnQvc3JjL2xpYi9zbWFydC1mb3JtL3dpZGdldHMvZGlyZWN0aXZlcy9jb21wYXJhYmxlLWRyb3Bkb3duLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUVqRCxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZUFBZSxDQUFDOzs7QUFJNUMsTUFBTSxvQkFBb0IsR0FBRywrQkFBK0IsQ0FBQztBQU03RCxNQUFNLE9BQU8sMkJBQTJCO0lBQ3RDLElBQWEsV0FBVyxDQUFDLEVBQXlCO1FBQ2hELElBQUksRUFBRSxFQUFFLENBQUM7WUFDUCxJQUFJLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxNQUFXLEVBQUUsRUFBRTtnQkFDcEQsT0FBTyxDQUNMLEVBQUUsQ0FBQyxJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxFQUFFLElBQUksQ0FBQyxRQUFRLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDO29CQUNwRSxXQUFXLENBQUMsTUFBTSxDQUNoQixJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxFQUMxQixJQUFJLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsRUFDcEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FDNUIsQ0FDRixDQUFDO1lBQ0osQ0FBQyxDQUFDO1FBQ0osQ0FBQzthQUFNLENBQUM7WUFDTixJQUFJLENBQUMsUUFBUSxDQUFDLG9CQUFvQixDQUFDLEdBQUcsQ0FBQyxNQUFXLEVBQUUsRUFBRTtnQkFDcEQsT0FBTyxXQUFXLENBQUMsTUFBTSxDQUN2QixJQUFJLENBQUMsUUFBUSxDQUFDLFVBQVUsRUFBRSxFQUMxQixJQUFJLENBQUMsUUFBUSxDQUFDLGNBQWMsQ0FBQyxNQUFNLENBQUMsRUFDcEMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxXQUFXLEVBQUUsQ0FDNUIsQ0FBQztZQUNKLENBQUMsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0lBRUQsWUFBb0IsUUFBa0I7UUFBbEIsYUFBUSxHQUFSLFFBQVEsQ0FBVTtJQUFHLENBQUM7K0dBeEIvQiwyQkFBMkI7bUdBQTNCLDJCQUEyQjs7NEZBQTNCLDJCQUEyQjtrQkFKdkMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsWUFBWTtvQkFDdEIsTUFBTSxFQUFFLENBQUMsYUFBYSxDQUFDO2lCQUN4Qjs2RUFFYyxXQUFXO3NCQUF2QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRHJvcGRvd24gfSBmcm9tICdwcmltZW5nL2Ryb3Bkb3duJztcbmltcG9ydCB7IE9iamVjdFV0aWxzIH0gZnJvbSAncHJpbWVuZy91dGlscyc7XG5cbmV4cG9ydCB0eXBlIENvbXBhcmVGbiA9IChhOiBhbnksIGI6IGFueSkgPT4gYm9vbGVhbjtcblxuY29uc3QgRVFVQUxJVFlfTUVUSE9EX05BTUUgPSAnaXNPcHRpb25WYWx1ZUVxdWFsc01vZGVsVmFsdWUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdwLWRyb3Bkb3duJyxcbiAgaW5wdXRzOiBbJ2NvbXBhcmVXaXRoJ10sXG59KVxuZXhwb3J0IGNsYXNzIENvbXBhcmFibGVEcm9wZG93bkRpcmVjdGl2ZSB7XG4gIEBJbnB1dCgpIHNldCBjb21wYXJlV2l0aChmbjogQ29tcGFyZUZuIHwgdW5kZWZpbmVkKSB7XG4gICAgaWYgKGZuKSB7XG4gICAgICB0aGlzLmRyb3Bkb3duW0VRVUFMSVRZX01FVEhPRF9OQU1FXSA9IChvcHRpb246IGFueSkgPT4ge1xuICAgICAgICByZXR1cm4gKFxuICAgICAgICAgIGZuKHRoaXMuZHJvcGRvd24ubW9kZWxWYWx1ZSgpLCB0aGlzLmRyb3Bkb3duLmdldE9wdGlvblZhbHVlKG9wdGlvbikpIHx8XG4gICAgICAgICAgT2JqZWN0VXRpbHMuZXF1YWxzKFxuICAgICAgICAgICAgdGhpcy5kcm9wZG93bi5tb2RlbFZhbHVlKCksXG4gICAgICAgICAgICB0aGlzLmRyb3Bkb3duLmdldE9wdGlvblZhbHVlKG9wdGlvbiksXG4gICAgICAgICAgICB0aGlzLmRyb3Bkb3duLmVxdWFsaXR5S2V5KClcbiAgICAgICAgICApXG4gICAgICAgICk7XG4gICAgICB9O1xuICAgIH0gZWxzZSB7XG4gICAgICB0aGlzLmRyb3Bkb3duW0VRVUFMSVRZX01FVEhPRF9OQU1FXSA9IChvcHRpb246IGFueSkgPT4ge1xuICAgICAgICByZXR1cm4gT2JqZWN0VXRpbHMuZXF1YWxzKFxuICAgICAgICAgIHRoaXMuZHJvcGRvd24ubW9kZWxWYWx1ZSgpLFxuICAgICAgICAgIHRoaXMuZHJvcGRvd24uZ2V0T3B0aW9uVmFsdWUob3B0aW9uKSxcbiAgICAgICAgICB0aGlzLmRyb3Bkb3duLmVxdWFsaXR5S2V5KClcbiAgICAgICAgKTtcbiAgICAgIH07XG4gICAgfVxuICB9XG5cbiAgY29uc3RydWN0b3IocHJpdmF0ZSBkcm9wZG93bjogRHJvcGRvd24pIHt9XG59XG4iXX0=

package/esm2022/lib/smart-form/widgets/directives/comparable-multiselect.directive.mjs

@@ -0,0 +1,79 @@
+import { Directive, Input } from '@angular/core';
+import { ObjectUtils } from 'primeng/utils';
+import { DomHandler } from 'primeng/dom';
+import * as i0 from "@angular/core";
+import * as i1 from "primeng/multiselect";
+export class ComparableMultiselectDirective {
+    // Because the equality check between the selected and possible option values are peppered
+    // throughout the component everywhere, we must override four(!) methods on it.
+    set compareWith(fn) {
+        const eq = !!fn
+            ? fn
+            : (a, b) => ObjectUtils.equals(a, b, this.multiSelect.equalityKey());
+        this.multiSelect.onOptionSelect = (event, isFocus = false, index = -1) => {
+            const { originalEvent, option } = event;
+            if (this.multiSelect.disabled || this.multiSelect.isOptionDisabled(option)) {
+                return;
+            }
+            let selected = this.multiSelect.isSelected(option);
+            let value = null;
+            if (selected) {
+                value = this.multiSelect
+                    .modelValue()
+                    .filter((val) => !eq(val, this.multiSelect.getOptionValue(option)));
+                this.multiSelect.onRemove.emit({
+                    newValue: this.multiSelect.value,
+                    removed: this.multiSelect.getOptionValue(option),
+                });
+            }
+            else {
+                value = [...(this.multiSelect.modelValue() || []), this.multiSelect.getOptionValue(option)];
+            }
+            this.multiSelect.updateModel(value, originalEvent);
+            index !== -1 && this.multiSelect.focusedOptionIndex.set(index);
+            isFocus && DomHandler.focus(this.multiSelect.focusInputViewChild?.nativeElement);
+            this.multiSelect.onChange.emit({
+                originalEvent: { ...event, selected: !event.selected },
+                value: value,
+                itemValue: option,
+            });
+        };
+        this.multiSelect.isSelected = (option) => {
+            const optionValue = this.multiSelect.getOptionValue(option);
+            return (this.multiSelect.modelValue() || []).some((value) => eq(value, optionValue));
+        };
+        this.multiSelect.getLabelByValue = (value) => {
+            const options = this.multiSelect.group
+                ? this.multiSelect.flatOptions(this.multiSelect._options())
+                : this.multiSelect._options() || [];
+            const matchedOption = options.find((option) => !this.multiSelect.isOptionGroup(option) &&
+                eq(this.multiSelect.getOptionValue(option), value));
+            return matchedOption ? this.multiSelect.getOptionLabel(matchedOption) : null;
+        };
+        this.multiSelect.removeOption = (optionValue, event) => {
+            let value = this.multiSelect.modelValue().filter((val) => !eq(val, optionValue));
+            this.multiSelect.updateModel(value, event);
+            this.multiSelect.onChange.emit({
+                originalEvent: event,
+                value: value,
+                itemValue: optionValue,
+            });
+            event && event.stopPropagation();
+        };
+    }
+    constructor(multiSelect) {
+        this.multiSelect = multiSelect;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ComparableMultiselectDirective, deps: [{ token: i1.MultiSelect }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.11", type: ComparableMultiselectDirective, selector: "p-multiSelect", inputs: { compareWith: "compareWith" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: ComparableMultiselectDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'p-multiSelect',
+                    inputs: ['compareWith'],
+                }]
+        }], ctorParameters: () => [{ type: i1.MultiSelect }], propDecorators: { compareWith: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"comparable-multiselect.directive.js","sourceRoot":"","sources":["../../../../../../../projects/smart-ng-client/src/lib/smart-form/widgets/directives/comparable-multiselect.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, Input } from '@angular/core';\nimport { MultiSelect } from 'primeng/multiselect';\nimport { CompareFn } from './comparable-dropdown.directive';\nimport { ObjectUtils } from 'primeng/utils';\nimport { DomHandler } from 'primeng/dom';\n\n@Directive({\n  selector: 'p-multiSelect',\n  inputs: ['compareWith'],\n})\nexport class ComparableMultiselectDirective {\n  // Because the equality check between the selected and possible option values are peppered\n  // throughout the component everywhere, we must override four(!) methods on it.\n  @Input() set compareWith(fn: CompareFn | undefined) {\n    const eq = !!fn\n      ? fn\n      : (a: any, b: any) => ObjectUtils.equals(a, b, this.multiSelect.equalityKey());\n    this.multiSelect.onOptionSelect = (event: any, isFocus = false, index = -1) => {\n      const { originalEvent, option } = event;\n      if (this.multiSelect.disabled || this.multiSelect.isOptionDisabled(option)) {\n        return;\n      }\n\n      let selected = this.multiSelect.isSelected(option);\n      let value = null;\n      if (selected) {\n        value = this.multiSelect\n          .modelValue()\n          .filter((val: any) => !eq(val, this.multiSelect.getOptionValue(option)));\n        this.multiSelect.onRemove.emit({\n          newValue: this.multiSelect.value,\n          removed: this.multiSelect.getOptionValue(option),\n        });\n      } else {\n        value = [...(this.multiSelect.modelValue() || []), this.multiSelect.getOptionValue(option)];\n      }\n\n      this.multiSelect.updateModel(value, originalEvent);\n      index !== -1 && this.multiSelect.focusedOptionIndex.set(index);\n\n      isFocus && DomHandler.focus(this.multiSelect.focusInputViewChild?.nativeElement);\n\n      this.multiSelect.onChange.emit({\n        originalEvent: { ...event, selected: !event.selected },\n        value: value,\n        itemValue: option,\n      });\n    };\n\n    this.multiSelect.isSelected = (option: any) => {\n      const optionValue = this.multiSelect.getOptionValue(option);\n      return (this.multiSelect.modelValue() || []).some((value: any) => eq(value, optionValue));\n    };\n\n    this.multiSelect.getLabelByValue = (value: any) => {\n      const options = this.multiSelect.group\n        ? this.multiSelect.flatOptions(this.multiSelect._options())\n        : this.multiSelect._options() || [];\n      const matchedOption = options.find(\n        (option: any) =>\n          !this.multiSelect.isOptionGroup(option) &&\n          eq(this.multiSelect.getOptionValue(option), value)\n      );\n      return matchedOption ? this.multiSelect.getOptionLabel(matchedOption) : null;\n    };\n\n    this.multiSelect.removeOption = (optionValue: any, event: any) => {\n      let value = this.multiSelect.modelValue().filter((val: any) => !eq(val, optionValue));\n\n      this.multiSelect.updateModel(value, event);\n      this.multiSelect.onChange.emit({\n        originalEvent: event,\n        value: value,\n        itemValue: optionValue,\n      });\n\n      event && event.stopPropagation();\n    };\n  }\n\n  constructor(private multiSelect: MultiSelect) {}\n}\n"]}