@yuuvis/client-framework 0.6.5

package/esm2022/common/lib/components/token-input/token-input.component.mjs

@@ -0,0 +1,324 @@
+import { Component, ElementRef, HostListener, NgZone, contentChild, inject, input, output, viewChild } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { YvcOverlayService } from '@yuuvis/components/overlay';
+import { YvcAutocompleteModule } from '@yuuvis/components/autocomplete';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@yuuvis/components/autocomplete";
+// TODO: Move to @yuuvis/components
+export class TokenInputComponent {
+    constructor() {
+        this.elRef = inject(ElementRef);
+        this.overlay = inject(YvcOverlayService);
+        this.ngZone = inject(NgZone);
+        this.optionsTemplate = viewChild.required('options');
+        /**
+         * Template to be used for rendering selected tokens
+         */
+        this.tokenTemplate = contentChild('tokenTemplate');
+        /**
+         * Template to be used for rendering autocomplete suggestion entries
+         */
+        this.optionTemplate = contentChild('optionTemplate');
+        this.TEXT_TOKEN_TYPE = 'txt';
+        this.tokens = input([]);
+        this.caseSensitive = input(false);
+        this.change = output();
+        this._cleanFormTokens = [this._newTextToken()];
+        this.formTokens = structuredClone(this._cleanFormTokens);
+        this.autocompleteValues = [];
+        this.autocompleteSelectedIndex = -1;
+        this.focusedTokenIndex = -1;
+    }
+    onArrowUpKey(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (this.autocompleteSelectedIndex > 0)
+            this.autocompleteSelectedIndex--;
+    }
+    onArrowDownKey(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (this.autocompleteValues && this.autocompleteSelectedIndex < this.autocompleteValues.length - 1)
+            this.autocompleteSelectedIndex++;
+    }
+    onEnterKey(event) {
+        if (this.autocompleteValues.length && this.autocompleteSelectedIndex >= 0) {
+            event.preventDefault();
+            event.stopPropagation();
+            this.onOptionSelect(this.autocompleteValues[this.autocompleteSelectedIndex]);
+        }
+    }
+    clear() {
+        this.formTokens = structuredClone(this._cleanFormTokens);
+        this._inputElement.innerText = '';
+        this._emitChange(true);
+    }
+    onInputFocus(e) {
+        this._inputElement = e.target;
+        this.focusedTokenIndex = this._inputElement ? this.formTokens.findIndex((t) => t.id === this._inputElement.getAttribute('data-id')) : -1;
+        // console.log('FIndex: ' + this.focusedTokenIndex);
+    }
+    onInput(e) {
+        this._processValue();
+        this._emitChange();
+    }
+    onArrowLeft(e) {
+        const cp = this._getCaretPos(e.target);
+        if (cp === 0) {
+            e.stopPropagation();
+            e.preventDefault();
+            this._focusInput(-1);
+        }
+    }
+    onArrowRight(e) {
+        const cp = this._getCaretPos(e.target);
+        if (cp === e.target.innerText.length) {
+            e.stopPropagation();
+            e.preventDefault();
+            this._focusInput(1);
+        }
+    }
+    onDelete(e, index) {
+        const cp = this._getCaretPos(e.target);
+        if (cp === e.target.innerText.length) {
+            e.stopPropagation();
+            e.preventDefault();
+            // remove next token
+            if (index < this.formTokens.length - 2) {
+                this.formTokens.splice(index + 1, 1);
+                // if prev token is also a text token => merge
+                const nextIdx = index + 1;
+                if (nextIdx < this.formTokens.length && this.formTokens[nextIdx].type === this.TEXT_TOKEN_TYPE) {
+                    const content = this.formTokens[index].label;
+                    const nextContent = this.formTokens[nextIdx].label;
+                    const mergedToken = {
+                        id: this.formTokens[index + 1].id,
+                        label: `${content} ${nextContent}`,
+                        type: this.TEXT_TOKEN_TYPE
+                    };
+                    this.formTokens.splice(index + 1, 2, mergedToken);
+                    const el = this.elRef.nativeElement.querySelector(`[data-id="${this.formTokens[index + 1].id}"]`);
+                    if (el) {
+                        el.innerText = mergedToken.label;
+                        this._setCaretPos(el, content.length);
+                    }
+                }
+                this._emitChange();
+            }
+        }
+    }
+    onBackspace(e, index) {
+        const cp = this._getCaretPos(e.target);
+        if (cp === 0) {
+            e.stopPropagation();
+            e.preventDefault();
+            // remove prev token
+            if (index > 0) {
+                this.formTokens.splice(index - 1, 1);
+                // if prev token is also a text token => merge
+                const prevIdx = index - 2;
+                if (prevIdx >= 0 && this.formTokens[prevIdx].type === this.TEXT_TOKEN_TYPE) {
+                    const content = this.formTokens[index - 1].label;
+                    const prevContent = this.formTokens[prevIdx].label;
+                    const mergedToken = {
+                        id: this.formTokens[prevIdx].id,
+                        label: `${prevContent} ${content}`,
+                        type: this.TEXT_TOKEN_TYPE
+                    };
+                    this.formTokens.splice(prevIdx, 2, mergedToken);
+                    const el = this.elRef.nativeElement.querySelector(`[data-id="${this.formTokens[prevIdx].id}"]`);
+                    if (el) {
+                        el.innerText = mergedToken.label;
+                        this._setCaretPos(el, prevContent.length);
+                    }
+                }
+                else {
+                    this._focusFirst();
+                }
+                this._emitChange();
+            }
+        }
+    }
+    _focusFirst() {
+        const el = this.elRef.nativeElement.querySelector(`[contenteditable]`);
+        if (el)
+            setTimeout(() => {
+                el?.focus();
+            });
+    }
+    _focusInput(offset) {
+        const inputs = Array.from(this.elRef.nativeElement.querySelectorAll('[contenteditable]'));
+        let i = inputs.findIndex((i) => i === document.activeElement);
+        i = i + offset;
+        if (i > inputs.length - 1)
+            i = 0;
+        if (i < 0)
+            i = inputs.length - 1;
+        this.ngZone.run(() => inputs[i].focus());
+        this._setCaretPos(inputs[i], offset > 0 || inputs[i].innerText.length === 0 ? 0 : inputs[i].innerText.length);
+    }
+    _setCaretPos(element, pos) {
+        const targetNode = element.childNodes.length ? element.childNodes[0] : element;
+        const range = document.createRange();
+        range.selectNode(element);
+        range.setStart(targetNode, pos);
+        range.setEnd(targetNode, pos);
+        const selection = window.getSelection();
+        selection.removeAllRanges();
+        selection.addRange(range);
+    }
+    _getCaretPos(node) {
+        const selection = window.getSelection();
+        const range = selection.getRangeAt(0);
+        const clonedRange = range.cloneRange();
+        clonedRange.selectNodeContents(node);
+        clonedRange.setEnd(range.endContainer, range.endOffset);
+        return clonedRange.toString().length;
+    }
+    onOptionSelect(o) {
+        let tokensAdded = 0;
+        let tokensRemoved = 0;
+        const inputValue = this._getInputValue();
+        const wordTokens = this._tokenize(inputValue);
+        const lastWord = wordTokens[wordTokens.length - 1];
+        if (lastWord.length === inputValue.length) {
+            this.formTokens.pop();
+            tokensRemoved++;
+        }
+        this.formTokens.splice(this.focusedTokenIndex + 1, 0, structuredClone(o));
+        tokensAdded++;
+        const shadowTokens = [];
+        // check for inbetween tokens
+        let txtTokenCount = -1;
+        this.formTokens.forEach((t, i) => {
+            if (t.type === this.TEXT_TOKEN_TYPE) {
+                txtTokenCount++;
+                t.id = this._textTokenId(txtTokenCount);
+            }
+            shadowTokens.push(t);
+            const nextToken = this.formTokens[i + 1];
+            if (t.type !== this.TEXT_TOKEN_TYPE && nextToken && nextToken.type !== this.TEXT_TOKEN_TYPE) {
+                // add inbetween token
+                txtTokenCount++;
+                shadowTokens.push(this._newTextToken(txtTokenCount));
+                tokensAdded++;
+            }
+        });
+        if (this.formTokens[this.formTokens.length - 1].type !== this.TEXT_TOKEN_TYPE) {
+            // add empty text token at the end
+            txtTokenCount++;
+            shadowTokens.push(this._newTextToken(txtTokenCount));
+            tokensAdded++;
+        }
+        this.formTokens = shadowTokens;
+        this._inputElement.innerText = inputValue.substring(0, inputValue.length - lastWord.length).trim();
+        this._emitChange();
+        setTimeout(() => {
+            // console.log(`fi: ${this.focusedTokenIndex}, ta: ${tokensAdded}, tr: ${tokensRemoved}, ne: ${this.focusedTokenIndex + (tokensAdded - tokensRemoved)}`);
+            this._focusTokenInput(this.focusedTokenIndex + (tokensAdded - tokensRemoved));
+        });
+        this.closeOptions();
+    }
+    _focusTokenInput(index) {
+        const selector = index === undefined ? 'div:last-child' : `div:nth-child(${index + 1})`;
+        console.log(selector);
+        const lastInput = this.elRef.nativeElement.querySelector(selector);
+        lastInput.focus();
+        return lastInput;
+    }
+    // private _focusInput(): HTMLElement {
+    //   const lastInput: HTMLElement = (
+    //     this.elRef.nativeElement as HTMLElement
+    //   ).querySelector('[contenteditable]:last-child') as HTMLElement;
+    //   lastInput.focus();
+    //   return lastInput;
+    // }
+    openOptions() {
+        if (this._overlayRef || !this.autocompleteValues.length)
+            return;
+        this._overlayRef = this.overlay.open(this.optionsTemplate(), null, {
+            lightDismiss: true,
+            maxHeight: '97vh'
+        }, this.elRef);
+    }
+    closeOptions() {
+        if (this._overlayRef) {
+            this._overlayRef.close();
+            this._overlayRef = undefined;
+        }
+        this.autocompleteSelectedIndex = -1;
+        this.autocompleteValues = [];
+    }
+    onTokenEnter(e) {
+        e.preventDefault();
+    }
+    _emitChange(focusFirst = false) {
+        // need to set timeout so DOM changes are applied before accessing elements
+        setTimeout(() => {
+            this.formTokens.forEach((t) => {
+                if (t.type === this.TEXT_TOKEN_TYPE) {
+                    const el = this.elRef.nativeElement.querySelector(`[data-id="${t.id}"]`);
+                    if (el)
+                        t.label = el.innerText;
+                }
+            });
+            this.change.emit(this.formTokens
+                .filter((t) => t.type !== this.TEXT_TOKEN_TYPE || t.label.length > 0)
+                .map((t) => ({
+                id: t.id,
+                label: t.label,
+                type: t.type
+            })));
+            if (focusFirst)
+                this._focusFirst();
+        });
+    }
+    _newTextToken(idx) {
+        const index = idx !== undefined ? idx : this.formTokens?.length ? this.formTokens.filter((t) => t.type === this.TEXT_TOKEN_TYPE).length : 0;
+        return {
+            id: this._textTokenId(index),
+            label: '',
+            type: this.TEXT_TOKEN_TYPE
+        };
+    }
+    _textTokenId(i) {
+        return `txt_${i}`;
+    }
+    _tokenize(value) {
+        const wordTokens = value.split(/\W+/).filter((t) => t?.length);
+        return wordTokens;
+    }
+    _getInputValue() {
+        return this._inputElement.innerText.replaceAll('&nbsp;', '');
+    }
+    _processValue() {
+        const wordTokens = this._tokenize(this._getInputValue());
+        const lastWord = wordTokens[wordTokens.length - 1];
+        this.autocompleteValues =
+            !lastWord || lastWord.length < 2
+                ? []
+                : this.tokens().filter((t) => lastWord && new RegExp(lastWord, this.caseSensitive() ? '' : 'i').test(t.label));
+        this.autocompleteSelectedIndex = this.autocompleteValues.length ? 0 : -1;
+        if (this.autocompleteValues.length)
+            this.openOptions();
+        else
+            this.closeOptions();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TokenInputComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TokenInputComponent, isStandalone: true, selector: "yuv-token-input", inputs: { tokens: { classPropertyName: "tokens", publicName: "tokens", isSignal: true, isRequired: false, transformFunction: null }, caseSensitive: { classPropertyName: "caseSensitive", publicName: "caseSensitive", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { change: "change" }, host: { listeners: { "keydown.arrowUp": "onArrowUpKey($event)", "keydown.arrowDown": "onArrowDownKey($event)", "keydown.enter": "onEnterKey($event)" } }, queries: [{ propertyName: "tokenTemplate", first: true, predicate: ["tokenTemplate"], descendants: true, isSignal: true }, { propertyName: "optionTemplate", first: true, predicate: ["optionTemplate"], descendants: true, isSignal: true }], viewQueries: [{ propertyName: "optionsTemplate", first: true, predicate: ["options"], descendants: true, isSignal: true }], ngImport: i0, template: "<!-- fi {{focusedTokenIndex}} -->\n\n@for (ft of formTokens; let i = $index; track $index) {\n  @if (ft.type === TEXT_TOKEN_TYPE) {\n    <div\n      contenteditable\n      [attr.data-id]=\"ft.id\"\n      (input)=\"onInput($event)\"\n      (focus)=\"onInputFocus($event)\"\n      (keydown.enter)=\"onTokenEnter($event)\"\n      (keydown.arrowLeft)=\"onArrowLeft($event)\"\n      (keydown.arrowRight)=\"onArrowRight($event)\"\n      (keydown.delete)=\"onDelete($event, i)\"\n      (keydown.backspace)=\"onBackspace($event, i)\"\n    ></div>\n  } @else {\n    @if (tokenTemplate()) {\n      <ng-container *ngTemplateOutlet=\"tokenTemplate()!; context: { $implicit: ft }\"></ng-container>\n    } @else {\n      <div class=\"chip\">{{ ft.label }}</div>\n    }\n  }\n}\n\n<ng-template #options>\n  <yvc-autocomplete-options\n    class=\"popover animateIn\"\n    [values]=\"autocompleteValues\"\n    [(focusedIndex)]=\"autocompleteSelectedIndex\"\n    [autocompleteOptionTemplate]=\"optionTemplate() || null\"\n    (optionSelect)=\"onOptionSelect($event)\"\n    [field]=\"'label'\"\n  ></yvc-autocomplete-options>\n</ng-template>\n", styles: [":host{--token-input-chip-border-color: var(--item-focus-border-color);--token-input-chip-background-color: var(--item-focus-background-color);--token-padding-y: .15em;display:flex;align-items:center;flex-flow:row wrap;padding:2px}:host [contenteditable],:host .chip{border:1px solid transparent;border-radius:2px}:host [contenteditable]{display:inline-block;padding:var(--token-padding-y) 2px;min-width:1px}:host [contenteditable]:focus-visible{outline:0}:host [contenteditable]:last-child{flex:1}:host .chip{padding:var(--token-padding-y) .25em;border-color:var(--token-input-chip-border-color);background-color:var(--token-input-chip-background-color)}:host .chip>span{font-size:var(--font-hint);color:var(--text-color-hint)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: YvcAutocompleteModule }, { kind: "component", type: i2.AutocompleteOptionsComponent, selector: "yvc-autocomplete-options", inputs: ["autocompleteOptionTemplate", "values", "field", "focusedIndex"], outputs: ["focusedIndexChange", "optionSelect"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TokenInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'yuv-token-input', standalone: true, imports: [CommonModule, YvcAutocompleteModule], template: "<!-- fi {{focusedTokenIndex}} -->\n\n@for (ft of formTokens; let i = $index; track $index) {\n  @if (ft.type === TEXT_TOKEN_TYPE) {\n    <div\n      contenteditable\n      [attr.data-id]=\"ft.id\"\n      (input)=\"onInput($event)\"\n      (focus)=\"onInputFocus($event)\"\n      (keydown.enter)=\"onTokenEnter($event)\"\n      (keydown.arrowLeft)=\"onArrowLeft($event)\"\n      (keydown.arrowRight)=\"onArrowRight($event)\"\n      (keydown.delete)=\"onDelete($event, i)\"\n      (keydown.backspace)=\"onBackspace($event, i)\"\n    ></div>\n  } @else {\n    @if (tokenTemplate()) {\n      <ng-container *ngTemplateOutlet=\"tokenTemplate()!; context: { $implicit: ft }\"></ng-container>\n    } @else {\n      <div class=\"chip\">{{ ft.label }}</div>\n    }\n  }\n}\n\n<ng-template #options>\n  <yvc-autocomplete-options\n    class=\"popover animateIn\"\n    [values]=\"autocompleteValues\"\n    [(focusedIndex)]=\"autocompleteSelectedIndex\"\n    [autocompleteOptionTemplate]=\"optionTemplate() || null\"\n    (optionSelect)=\"onOptionSelect($event)\"\n    [field]=\"'label'\"\n  ></yvc-autocomplete-options>\n</ng-template>\n", styles: [":host{--token-input-chip-border-color: var(--item-focus-border-color);--token-input-chip-background-color: var(--item-focus-background-color);--token-padding-y: .15em;display:flex;align-items:center;flex-flow:row wrap;padding:2px}:host [contenteditable],:host .chip{border:1px solid transparent;border-radius:2px}:host [contenteditable]{display:inline-block;padding:var(--token-padding-y) 2px;min-width:1px}:host [contenteditable]:focus-visible{outline:0}:host [contenteditable]:last-child{flex:1}:host .chip{padding:var(--token-padding-y) .25em;border-color:var(--token-input-chip-border-color);background-color:var(--token-input-chip-background-color)}:host .chip>span{font-size:var(--font-hint);color:var(--text-color-hint)}\n"] }]
+        }], propDecorators: { onArrowUpKey: [{
+                type: HostListener,
+                args: ['keydown.arrowUp', ['$event']]
+            }], onArrowDownKey: [{
+                type: HostListener,
+                args: ['keydown.arrowDown', ['$event']]
+            }], onEnterKey: [{
+                type: HostListener,
+                args: ['keydown.enter', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"token-input.component.js","sourceRoot":"","sources":["../../../../../../../../../libs/yuuvis/client-framework/common/src/lib/components/token-input/token-input.component.ts","../../../../../../../../../libs/yuuvis/client-framework/common/src/lib/components/token-input/token-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, HostListener, NgZone, TemplateRef, contentChild, inject, input, output, viewChild } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { InnerInputToken, InputToken } from './token-input.interface';\nimport { YvcOverlayRef, YvcOverlayService } from '@yuuvis/components/overlay';\nimport { YvcAutocompleteModule } from '@yuuvis/components/autocomplete';\n\n// TODO: Move to @yuuvis/components\n@Component({\n  selector: 'yuv-token-input',\n  standalone: true,\n  imports: [CommonModule, YvcAutocompleteModule],\n  templateUrl: './token-input.component.html',\n  styleUrl: './token-input.component.scss'\n})\nexport class TokenInputComponent {\n  private elRef = inject(ElementRef);\n  private overlay = inject(YvcOverlayService);\n  private ngZone = inject(NgZone);\n\n  optionsTemplate = viewChild.required<TemplateRef<any>>('options');\n  /**\n   * Template to be used for rendering selected tokens\n   */\n  tokenTemplate = contentChild<TemplateRef<any>>('tokenTemplate');\n  /**\n   * Template to be used for rendering autocomplete suggestion entries\n   */\n  optionTemplate = contentChild<TemplateRef<any>>('optionTemplate');\n\n  TEXT_TOKEN_TYPE = 'txt';\n  private _inputElement?: HTMLInputElement;\n  private _overlayRef?: YvcOverlayRef;\n\n  tokens = input<InputToken[]>([]);\n  caseSensitive = input<boolean>(false);\n\n  change = output<InputToken[]>();\n\n  private readonly _cleanFormTokens: InputToken[] = [this._newTextToken()];\n  formTokens: InputToken[] = structuredClone(this._cleanFormTokens);\n  autocompleteValues: InputToken[] = [];\n  autocompleteSelectedIndex = -1;\n  focusedTokenIndex = -1;\n\n  @HostListener('keydown.arrowUp', ['$event']) onArrowUpKey(event: KeyboardEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n    if (this.autocompleteSelectedIndex > 0) this.autocompleteSelectedIndex--;\n  }\n  @HostListener('keydown.arrowDown', ['$event']) onArrowDownKey(event: KeyboardEvent) {\n    event.preventDefault();\n    event.stopPropagation();\n    if (this.autocompleteValues && this.autocompleteSelectedIndex < this.autocompleteValues.length - 1) this.autocompleteSelectedIndex++;\n  }\n  @HostListener('keydown.enter', ['$event']) onEnterKey(event: KeyboardEvent) {\n    if (this.autocompleteValues.length && this.autocompleteSelectedIndex >= 0) {\n      event.preventDefault();\n      event.stopPropagation();\n      this.onOptionSelect(this.autocompleteValues[this.autocompleteSelectedIndex]);\n    }\n  }\n\n  clear() {\n    this.formTokens = structuredClone(this._cleanFormTokens);\n    this._inputElement!.innerText = '';\n    this._emitChange(true);\n  }\n\n  onInputFocus(e: any) {\n    this._inputElement = e.target;\n    this.focusedTokenIndex = this._inputElement ? this.formTokens.findIndex((t) => t.id === this._inputElement!.getAttribute('data-id')) : -1;\n    // console.log('FIndex: ' + this.focusedTokenIndex);\n  }\n\n  onInput(e: any) {\n    this._processValue();\n    this._emitChange();\n  }\n\n  onArrowLeft(e: Event) {\n    const cp = this._getCaretPos(e.target as Node);\n    if (cp === 0) {\n      e.stopPropagation();\n      e.preventDefault();\n      this._focusInput(-1);\n    }\n  }\n  onArrowRight(e: Event) {\n    const cp = this._getCaretPos(e.target as Node);\n    if (cp === (e.target as HTMLElement).innerText.length) {\n      e.stopPropagation();\n      e.preventDefault();\n      this._focusInput(1);\n    }\n  }\n\n  onDelete(e: Event, index: number) {\n    const cp = this._getCaretPos(e.target as Node);\n    if (cp === (e.target as HTMLElement).innerText.length) {\n      e.stopPropagation();\n      e.preventDefault();\n\n      // remove next token\n      if (index < this.formTokens.length - 2) {\n        this.formTokens.splice(index + 1, 1);\n\n        // if prev token is also a text token => merge\n        const nextIdx = index + 1;\n        if (nextIdx < this.formTokens.length && this.formTokens[nextIdx].type === this.TEXT_TOKEN_TYPE) {\n          const content = this.formTokens[index].label;\n          const nextContent = this.formTokens[nextIdx].label;\n          const mergedToken: InputToken = {\n            id: this.formTokens[index + 1].id,\n            label: `${content} ${nextContent}`,\n            type: this.TEXT_TOKEN_TYPE\n          };\n          this.formTokens.splice(index + 1, 2, mergedToken);\n\n          const el: HTMLElement | null = (this.elRef.nativeElement as HTMLElement).querySelector(`[data-id=\"${this.formTokens[index + 1].id}\"]`);\n          if (el) {\n            el.innerText = mergedToken.label;\n            this._setCaretPos(el, content.length);\n          }\n        }\n        this._emitChange();\n      }\n    }\n  }\n\n  onBackspace(e: Event, index: number) {\n    const cp = this._getCaretPos(e.target as Node);\n    if (cp === 0) {\n      e.stopPropagation();\n      e.preventDefault();\n\n      // remove prev token\n      if (index > 0) {\n        this.formTokens.splice(index - 1, 1);\n        // if prev token is also a text token => merge\n        const prevIdx = index - 2;\n        if (prevIdx >= 0 && this.formTokens[prevIdx].type === this.TEXT_TOKEN_TYPE) {\n          const content = this.formTokens[index - 1].label;\n          const prevContent = this.formTokens[prevIdx].label;\n          const mergedToken: InputToken = {\n            id: this.formTokens[prevIdx].id,\n            label: `${prevContent} ${content}`,\n            type: this.TEXT_TOKEN_TYPE\n          };\n          this.formTokens.splice(prevIdx, 2, mergedToken);\n          const el: HTMLElement | null = (this.elRef.nativeElement as HTMLElement).querySelector(`[data-id=\"${this.formTokens[prevIdx].id}\"]`);\n          if (el) {\n            el.innerText = mergedToken.label;\n            this._setCaretPos(el, prevContent.length);\n          }\n        } else {\n          this._focusFirst();\n        }\n        this._emitChange();\n      }\n    }\n  }\n\n  private _focusFirst() {\n    const el: HTMLElement | null = (this.elRef.nativeElement as HTMLElement).querySelector(`[contenteditable]`);\n    if (el)\n      setTimeout(() => {\n        el?.focus();\n      });\n  }\n\n  private _focusInput(offset: number) {\n    const inputs: HTMLInputElement[] = Array.from(this.elRef.nativeElement.querySelectorAll('[contenteditable]'));\n    let i = inputs.findIndex((i) => i === document.activeElement);\n    i = i + offset;\n    if (i > inputs.length - 1) i = 0;\n    if (i < 0) i = inputs.length - 1;\n    this.ngZone.run(() => inputs[i].focus());\n\n    this._setCaretPos(inputs[i], offset > 0 || inputs[i].innerText.length === 0 ? 0 : inputs[i].innerText.length);\n  }\n\n  private _setCaretPos(element: HTMLElement, pos: number) {\n    const targetNode = element.childNodes.length ? element.childNodes[0] : element;\n    const range = document.createRange();\n    range.selectNode(element);\n    range.setStart(targetNode, pos);\n    range.setEnd(targetNode, pos);\n    const selection = window.getSelection();\n    selection!.removeAllRanges();\n    selection!.addRange(range);\n  }\n\n  private _getCaretPos(node: Node): number {\n    const selection = window.getSelection();\n    const range = selection!.getRangeAt(0);\n    const clonedRange = range.cloneRange();\n    clonedRange.selectNodeContents(node);\n    clonedRange.setEnd(range.endContainer, range.endOffset);\n    return clonedRange.toString().length;\n  }\n\n  onOptionSelect(o: InputToken) {\n    let tokensAdded = 0;\n    let tokensRemoved = 0;\n    const inputValue = this._getInputValue();\n    const wordTokens: string[] = this._tokenize(inputValue);\n    const lastWord = wordTokens[wordTokens.length - 1];\n    if (lastWord.length === inputValue.length) {\n      this.formTokens.pop();\n      tokensRemoved++;\n    }\n\n    this.formTokens.splice(this.focusedTokenIndex + 1, 0, structuredClone(o));\n    tokensAdded++;\n\n    const shadowTokens: InputToken[] = [];\n    // check for inbetween tokens\n    let txtTokenCount = -1;\n    this.formTokens.forEach((t: InputToken, i: number) => {\n      if (t.type === this.TEXT_TOKEN_TYPE) {\n        txtTokenCount++;\n        t.id = this._textTokenId(txtTokenCount);\n      }\n      shadowTokens.push(t);\n      const nextToken = this.formTokens[i + 1];\n      if (t.type !== this.TEXT_TOKEN_TYPE && nextToken && nextToken.type !== this.TEXT_TOKEN_TYPE) {\n        // add inbetween token\n        txtTokenCount++;\n        shadowTokens.push(this._newTextToken(txtTokenCount));\n        tokensAdded++;\n      }\n    });\n\n    if (this.formTokens[this.formTokens.length - 1].type !== this.TEXT_TOKEN_TYPE) {\n      // add empty text token at the end\n      txtTokenCount++;\n      shadowTokens.push(this._newTextToken(txtTokenCount));\n      tokensAdded++;\n    }\n    this.formTokens = shadowTokens;\n    this._inputElement!.innerText = inputValue.substring(0, inputValue.length - lastWord.length).trim();\n    this._emitChange();\n    setTimeout(() => {\n      // console.log(`fi: ${this.focusedTokenIndex}, ta: ${tokensAdded}, tr: ${tokensRemoved}, ne: ${this.focusedTokenIndex + (tokensAdded - tokensRemoved)}`);\n\n      this._focusTokenInput(this.focusedTokenIndex + (tokensAdded - tokensRemoved));\n    });\n\n    this.closeOptions();\n  }\n\n  private _focusTokenInput(index?: number): HTMLElement {\n    const selector = index === undefined ? 'div:last-child' : `div:nth-child(${index + 1})`;\n    console.log(selector);\n\n    const lastInput: HTMLElement = (this.elRef.nativeElement as HTMLElement).querySelector(selector) as HTMLElement;\n    lastInput.focus();\n    return lastInput;\n  }\n\n  // private _focusInput(): HTMLElement {\n  //   const lastInput: HTMLElement = (\n  //     this.elRef.nativeElement as HTMLElement\n  //   ).querySelector('[contenteditable]:last-child') as HTMLElement;\n  //   lastInput.focus();\n  //   return lastInput;\n  // }\n\n  openOptions() {\n    if (this._overlayRef || !this.autocompleteValues.length) return;\n    this._overlayRef = this.overlay.open(\n      this.optionsTemplate(),\n      null,\n      {\n        lightDismiss: true,\n        maxHeight: '97vh'\n      },\n      this.elRef\n    );\n  }\n\n  closeOptions(): void {\n    if (this._overlayRef) {\n      this._overlayRef.close();\n      this._overlayRef = undefined;\n    }\n    this.autocompleteSelectedIndex = -1;\n    this.autocompleteValues = [];\n  }\n\n  onTokenEnter(e: Event) {\n    e.preventDefault();\n  }\n\n  private _emitChange(focusFirst = false) {\n    // need to set timeout so DOM changes are applied before accessing elements\n    setTimeout(() => {\n      this.formTokens.forEach((t) => {\n        if (t.type === this.TEXT_TOKEN_TYPE) {\n          const el: HTMLElement | null = (this.elRef.nativeElement as HTMLElement).querySelector(`[data-id=\"${t.id}\"]`);\n          if (el) t.label = el.innerText;\n        }\n      });\n      this.change.emit(\n        this.formTokens\n          .filter((t: InnerInputToken) => t.type !== this.TEXT_TOKEN_TYPE || t.label.length > 0)\n          .map((t: InnerInputToken) => ({\n            id: t.id,\n            label: t.label,\n            type: t.type\n          }))\n      );\n      if (focusFirst) this._focusFirst();\n    });\n  }\n\n  private _newTextToken(idx?: number): InnerInputToken {\n    const index = idx !== undefined ? idx : this.formTokens?.length ? this.formTokens.filter((t) => t.type === this.TEXT_TOKEN_TYPE).length : 0;\n    return {\n      id: this._textTokenId(index),\n      label: '',\n      type: this.TEXT_TOKEN_TYPE\n    };\n  }\n\n  private _textTokenId(i: number): string {\n    return `txt_${i}`;\n  }\n\n  private _tokenize(value: string): string[] {\n    const wordTokens: string[] = value.split(/\\W+/).filter((t: string) => t?.length);\n    return wordTokens;\n  }\n\n  private _getInputValue(): string {\n    return this._inputElement!.innerText.replaceAll('&nbsp;', '');\n  }\n\n  private _processValue() {\n    const wordTokens: string[] = this._tokenize(this._getInputValue());\n    const lastWord = wordTokens[wordTokens.length - 1];\n\n    this.autocompleteValues =\n      !lastWord || lastWord.length < 2\n        ? []\n        : this.tokens().filter((t: InputToken) => lastWord && new RegExp(lastWord, this.caseSensitive() ? '' : 'i').test(t.label));\n    this.autocompleteSelectedIndex = this.autocompleteValues.length ? 0 : -1;\n    if (this.autocompleteValues.length) this.openOptions();\n    else this.closeOptions();\n  }\n}\n","<!-- fi {{focusedTokenIndex}} -->\n\n@for (ft of formTokens; let i = $index; track $index) {\n  @if (ft.type === TEXT_TOKEN_TYPE) {\n    <div\n      contenteditable\n      [attr.data-id]=\"ft.id\"\n      (input)=\"onInput($event)\"\n      (focus)=\"onInputFocus($event)\"\n      (keydown.enter)=\"onTokenEnter($event)\"\n      (keydown.arrowLeft)=\"onArrowLeft($event)\"\n      (keydown.arrowRight)=\"onArrowRight($event)\"\n      (keydown.delete)=\"onDelete($event, i)\"\n      (keydown.backspace)=\"onBackspace($event, i)\"\n    ></div>\n  } @else {\n    @if (tokenTemplate()) {\n      <ng-container *ngTemplateOutlet=\"tokenTemplate()!; context: { $implicit: ft }\"></ng-container>\n    } @else {\n      <div class=\"chip\">{{ ft.label }}</div>\n    }\n  }\n}\n\n<ng-template #options>\n  <yvc-autocomplete-options\n    class=\"popover animateIn\"\n    [values]=\"autocompleteValues\"\n    [(focusedIndex)]=\"autocompleteSelectedIndex\"\n    [autocompleteOptionTemplate]=\"optionTemplate() || null\"\n    (optionSelect)=\"onOptionSelect($event)\"\n    [field]=\"'label'\"\n  ></yvc-autocomplete-options>\n</ng-template>\n"]}

package/esm2022/common/lib/components/token-input/token-input.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidG9rZW4taW5wdXQuaW50ZXJmYWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy95dXV2aXMvY2xpZW50LWZyYW1ld29yay9jb21tb24vc3JjL2xpYi9jb21wb25lbnRzL3Rva2VuLWlucHV0L3Rva2VuLWlucHV0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBJbnB1dFRva2VuIHtcbiAgaWQ6IHN0cmluZztcbiAgbGFiZWw6IHN0cmluZztcbiAgdHlwZTogc3RyaW5nO1xufVxuZXhwb3J0IGludGVyZmFjZSBJbm5lcklucHV0VG9rZW4gZXh0ZW5kcyBJbnB1dFRva2VuIHtcbiAgaXNJbmJldHdlZW5Ub2tlbj86IGJvb2xlYW47XG59XG4iXX0=

package/esm2022/common/lib/directives/busy-overlay.directive.mjs

@@ -0,0 +1,88 @@
+import { Directive, ElementRef, HostBinding, Input, inject } from '@angular/core';
+import { Utils } from '@yuuvis/client-core';
+import * as i0 from "@angular/core";
+/**
+ * A directive that will overlay its host component with a translucent background
+ * and a loading spinner once the condition resolves with true. This is useful for example to
+ * prevent user intercation while component data is loading or some processing is done.
+ *
+ * It'll also set the `inert` attribute on the host element. This will disable the host and
+ * all elements inside (like buttons, inputs etc.)
+ *
+ * @example
+ * <div class="result-list" [yuvBusyOverlay]="waitingForServerResponse">...</div>
+ *
+ */
+export class BusyOverlayDirective {
+    constructor() {
+        this.stylePosition = 'initial';
+        this.#elRef = inject(ElementRef);
+        this.#overlayId = null;
+    }
+    #elRef;
+    #overlayId;
+    /**
+     * The Boolean expression to evaluate as the condition for showing the busy overlay
+     */
+    set yuvBusyOverlay(b) {
+        if (b === true) {
+            this.#addBusyOverlay();
+        }
+        else if (this.#overlayId) {
+            this.#removeBusyOverlay();
+        }
+    }
+    #addBusyOverlay() {
+        this.stylePosition = 'relative';
+        const overlay = document.createElement('div');
+        overlay.style.position = 'absolute';
+        overlay.style.transition = 'opacity 200ms';
+        overlay.style.opacity = '0';
+        overlay.style.inset = '0';
+        overlay.style.display = 'grid';
+        overlay.style.alignItems = 'center';
+        overlay.style.justifyContent = 'center';
+        overlay.style.zIndex = '5';
+        overlay.style.backgroundColor = 'var(--busy-overlay-background)';
+        this.#overlayId = `p${Utils.uuid()}`;
+        overlay.setAttribute('id', this.#overlayId);
+        const spinner = document.createElement('div');
+        spinner.setAttribute('class', 'yuv-loader');
+        overlay.append(spinner);
+        const el = this.#elRef.nativeElement;
+        el.setAttribute('inert', '');
+        el.append(overlay);
+        setTimeout(() => {
+            overlay.style.opacity = '1';
+        });
+    }
+    #removeBusyOverlay() {
+        const el = this.#elRef.nativeElement.querySelector(`#${this.#overlayId}`);
+        if (el) {
+            el.style.opacity = '0';
+            setTimeout(() => {
+                el.remove();
+            }, 200);
+        }
+        this.#elRef.nativeElement.removeAttribute('inert');
+        this.#overlayId = null;
+    }
+    ngOnInit() {
+        this.stylePosition = getComputedStyle(this.#elRef.nativeElement).position;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BusyOverlayDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: BusyOverlayDirective, isStandalone: true, selector: "[yuvBusyOverlay]", inputs: { yuvBusyOverlay: "yuvBusyOverlay" }, host: { properties: { "style.position": "this.stylePosition" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BusyOverlayDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvBusyOverlay]',
+                    standalone: true
+                }]
+        }], propDecorators: { stylePosition: [{
+                type: HostBinding,
+                args: ['style.position']
+            }], yuvBusyOverlay: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/directives/click-double.directive.mjs

@@ -0,0 +1,61 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * Fixes the issue of 'click' event beeing triggered on 'doubleclick' by defining new outputs that
+ * distinguish between single and double click.
+ */
+export class ClickDoubleDirective {
+    constructor() {
+        this.debounceTime = 200;
+        this.doubleClick = new EventEmitter();
+        this.singleClick = new EventEmitter();
+        this.clicksSubject = new Subject();
+        this.clicksSubject.pipe(takeUntilDestroyed(), debounceTime(this.debounceTime)).subscribe({
+            next: (event) => {
+                if (event.type === 'click') {
+                    this.singleClick.emit(event);
+                }
+                else {
+                    this.doubleClick.emit(event);
+                }
+            }
+        });
+    }
+    clickEvent(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.clicksSubject.next(event);
+    }
+    doubleClickEvent(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.clicksSubject.next(event);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ClickDoubleDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ClickDoubleDirective, isStandalone: true, selector: "[click.single],[click.double]", inputs: { debounceTime: "debounceTime" }, outputs: { doubleClick: "click.double", singleClick: "click.single" }, host: { listeners: { "click": "clickEvent($event)", "dblclick": "doubleClickEvent($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ClickDoubleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[click.single],[click.double]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [], propDecorators: { debounceTime: [{
+                type: Input
+            }], doubleClick: [{
+                type: Output,
+                args: ['click.double']
+            }], singleClick: [{
+                type: Output,
+                args: ['click.single']
+            }], clickEvent: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }], doubleClickEvent: [{
+                type: HostListener,
+                args: ['dblclick', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/common/lib/directives/container-size.directive.mjs

@@ -0,0 +1,56 @@
+import { Directive, ElementRef, NgZone, inject, output } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive to watch the size of an element inside the DOM. Usefull for example to provide
+ * a different layout (different components) depending on the available screen estate. You
+ * should first try to use CSS container queries but somtimes you need a different set of
+ * components to be loaded for a certain component size.
+ *
+ * Let's say you have components designed for bigger screens. You do not want to load them
+ * if there is not enough space for them. So you rather load components that are designed to
+ * take less space by providing the best user experience on smaller devices.
+ *
+ * ```html
+ * <div yuvContainerSize (containerHeight)="onContainerResize($event)" (containerWidth)="onContainerResize($event)"></div>
+ * ```
+ *
+ */
+export class ContainerSizeDirective {
+    constructor() {
+        this.elRef = inject(ElementRef);
+        this.ngZone = inject(NgZone);
+        this.containerHeight = output();
+        this.containerWidth = output();
+        this._resizeObserver = new ResizeObserver((entries) => {
+            const size = entries[0].borderBoxSize[0];
+            if (!this._size || size.blockSize !== this._size.blockSize) {
+                this._emit(size.blockSize, true);
+            }
+            if (!this._size || size.inlineSize !== this._size.inlineSize) {
+                this._emit(size.inlineSize);
+            }
+            this._size = size;
+        });
+        this._resizeObserver.observe(this.elRef.nativeElement);
+    }
+    _emit(value, isHeight = false) {
+        // ResizeObserver callback is not covered by change detection
+        // so it has to be executed withing ngZone
+        this.ngZone.run(() => {
+            (isHeight ? this.containerHeight : this.containerWidth).emit(value);
+        });
+    }
+    ngOnDestroy() {
+        this._resizeObserver.unobserve(this.elRef.nativeElement);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContainerSizeDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ContainerSizeDirective, isStandalone: true, selector: "[yuvContainerSize]", outputs: { containerHeight: "containerHeight", containerWidth: "containerWidth" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ContainerSizeDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[yuvContainerSize]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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