@sebgroup/green-angular 4.6.1 → 4.6.3

package/esm2022/v-angular/dropdown/typeahead/typeahead-highlight/typeahead-highlight.component.mjs

@@ -0,0 +1,85 @@
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class NgvTypeaheadHighlightComponent {
+    constructor() {
+        this.text = '';
+        this.input = '';
+        /**
+         * Regexp of characters that are allowed in textContent without being found in textToHighlight
+         * Allow whitespaces.
+         * */
+        this.allowedNonMatchingChars = new RegExp(/\s/);
+    }
+    ngOnChanges(changes) {
+        const { textContent, textToHighlight } = changes;
+        if (textContent?.currentValue != null)
+            this.text = `${textContent.currentValue}`;
+        if (textToHighlight?.currentValue != null)
+            this.input = `${textToHighlight.currentValue}`;
+        this.updateValues();
+    }
+    updateValues() {
+        const splittedText = this.text.toLocaleLowerCase().split('');
+        const splittedInput = this.input.toLocaleLowerCase().split('');
+        const { start, end } = this.getHighlightedPart(splittedText, splittedInput);
+        // If user input is not found within the textcontent, reset options and return.
+        if (start === -1 || end === -1) {
+            this.prefix = this.match = this.suffix = '';
+            return;
+        }
+        this.prefix = this.text.substring(0, start);
+        this.match = this.text.substring(start, end);
+        this.suffix = this.text.substring(end);
+    }
+    /**
+     * Function that finds the start and end index of where the input is located within the text to display.
+     * First occurence is returned. Allows for spaces to occur despite input not matching space.
+     * Loops through each character in splittedText and when a char in splittedText equlas the first character of
+     * splittedInput, evaluate wether it's match on the entire input.
+     * - If it's => return indexes.
+     * - If it's not => break out and check next char in outer loop.
+     * @param splittedText the text content splitted in an array
+     * @param splittedInput the input splitted in an array
+     * @returns { start: number, end: number } Indexes of where the match starts and ends in the text displatyed
+     */
+    getHighlightedPart(splittedText, splittedInput) {
+        let start = -1;
+        let end = -1;
+        for (let i = 0; i < splittedText.length; i++) {
+            // If start and end have been set, break and return
+            if (start > -1 || end > -1)
+                break;
+            // If current char match first in input, try see if whole input match from that index
+            if (splittedText[i] === splittedInput[0]) {
+                let matches = 1;
+                for (let t = 1; t <= splittedText.length; t++) {
+                    // If match on last character of input, we're finished.
+                    if (matches === splittedInput.length) {
+                        start = i;
+                        end = start + t;
+                        break;
+                    }
+                    if (splittedText[t + i] === splittedInput[matches])
+                        matches++;
+                    else if (this.allowedNonMatchingChars.test(splittedText[t + i]))
+                        continue; // Ignore whitespace, continue
+                    else
+                        break; // No match, break out of inner loop to check next char in text
+                }
+            }
+        }
+        return { start, end };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadHighlightComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: NgvTypeaheadHighlightComponent, selector: "nggv-typeahead-highlight", inputs: { textContent: "textContent", textToHighlight: "textToHighlight" }, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"!this.match\">{{ textContent }}</ng-container>\n<!-- Note that this is sensitive to line breaks producing extra spacing between the different parts -->\n<ng-container *ngIf=\"!!this.match\">\n    {{ prefix || '' }}<span class=\"match\">{{ match }}</span>{{ suffix ||''}}\n</ng-container>", styles: [":host .match{font-weight:500}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadHighlightComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'nggv-typeahead-highlight', template: "<ng-container *ngIf=\"!this.match\">{{ textContent }}</ng-container>\n<!-- Note that this is sensitive to line breaks producing extra spacing between the different parts -->\n<ng-container *ngIf=\"!!this.match\">\n    {{ prefix || '' }}<span class=\"match\">{{ match }}</span>{{ suffix ||''}}\n</ng-container>", styles: [":host .match{font-weight:500}\n"] }]
+        }], propDecorators: { textContent: [{
+                type: Input
+            }], textToHighlight: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead-highlight.component.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/src/v-angular/dropdown/typeahead/typeahead-highlight/typeahead-highlight.component.ts","../../../../../../../../libs/angular/src/v-angular/dropdown/typeahead/typeahead-highlight/typeahead-highlight.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, OnChanges, SimpleChanges } from '@angular/core'\n\n@Component({\n  selector: 'nggv-typeahead-highlight',\n  templateUrl: './typeahead-highlight.component.html',\n  styleUrls: ['./typeahead-highlight.component.scss'],\n})\nexport class NgvTypeaheadHighlightComponent implements OnChanges {\n  /** The text that is displayed in the dropdown list */\n  @Input() textContent?: string\n  /** The substring that should be highlighted within textContent */\n  @Input() textToHighlight?: string\n\n  prefix?: string // Substring before the match\n  match?: string // The match\n  suffix?: string // Substring after the match\n\n  text = ''\n  input = ''\n\n  /**\n   * Regexp of characters that are allowed in textContent without being found in textToHighlight\n   * Allow whitespaces.\n   * */\n  allowedNonMatchingChars = new RegExp(/\\s/)\n\n  ngOnChanges(changes: SimpleChanges) {\n    const { textContent, textToHighlight } = changes\n    if (textContent?.currentValue != null)\n      this.text = `${textContent.currentValue}`\n    if (textToHighlight?.currentValue != null)\n      this.input = `${textToHighlight.currentValue}`\n    this.updateValues()\n  }\n\n  private updateValues() {\n    const splittedText = this.text.toLocaleLowerCase().split('')\n    const splittedInput = this.input.toLocaleLowerCase().split('')\n\n    const { start, end } = this.getHighlightedPart(splittedText, splittedInput)\n\n    // If user input is not found within the textcontent, reset options and return.\n    if (start === -1 || end === -1) {\n      this.prefix = this.match = this.suffix = ''\n      return\n    }\n    this.prefix = this.text.substring(0, start)\n    this.match = this.text.substring(start, end)\n    this.suffix = this.text.substring(end)\n  }\n\n  /**\n   * Function that finds the start and end index of where the input is located within the text to display.\n   * First occurence is returned. Allows for spaces to occur despite input not matching space.\n   * Loops through each character in splittedText and when a char in splittedText equlas the first character of\n   * splittedInput, evaluate wether it's match on the entire input.\n   * - If it's => return indexes.\n   * - If it's not => break out and check next char in outer loop.\n   * @param splittedText the text content splitted in an array\n   * @param splittedInput the input splitted in an array\n   * @returns { start: number, end: number } Indexes of where the match starts and ends in the text displatyed\n   */\n  private getHighlightedPart(\n    splittedText: string[],\n    splittedInput: string[],\n  ): { start: number; end: number } {\n    let start = -1\n    let end = -1\n\n    for (let i = 0; i < splittedText.length; i++) {\n      // If start and end have been set, break and return\n      if (start > -1 || end > -1) break\n\n      // If current char match first in input, try see if whole input match from that index\n      if (splittedText[i] === splittedInput[0]) {\n        let matches = 1\n        for (let t = 1; t <= splittedText.length; t++) {\n          // If match on last character of input, we're finished.\n          if (matches === splittedInput.length) {\n            start = i\n            end = start + t\n            break\n          }\n          if (splittedText[t + i] === splittedInput[matches]) matches++\n          else if (this.allowedNonMatchingChars.test(splittedText[t + i]))\n            continue // Ignore whitespace, continue\n          else break // No match, break out of inner loop to check next char in text\n        }\n      }\n    }\n    return { start, end }\n  }\n}\n","<ng-container *ngIf=\"!this.match\">{{ textContent }}</ng-container>\n<!-- Note that this is sensitive to line breaks producing extra spacing between the different parts -->\n<ng-container *ngIf=\"!!this.match\">\n    {{ prefix || '' }}<span class=\"match\">{{ match }}</span>{{ suffix ||''}}\n</ng-container>"]}

package/esm2022/v-angular/dropdown/typeahead/typeahead-input/typeahead-input.component.mjs

@@ -0,0 +1,132 @@
+import { ChangeDetectorRef, Component, ElementRef, HostListener, Inject, Input, Optional, Renderer2, Self, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { takeUntil } from 'rxjs';
+import { TRANSLOCO_SCOPE } from '@ngneat/transloco';
+import { NgvDropdownComponent } from '../../dropdown.component';
+import { NgvInputComponent } from '@sebgroup/green-angular/src/v-angular/input';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@angular/common";
+export class NgvTypeaheadInputComponent extends NgvInputComponent {
+    get dropdownButton() {
+        return this.hostComponent.inputRef?.nativeElement;
+    }
+    constructor(element, renderer2, ngControl, translocoScope, cdr) {
+        super(ngControl, translocoScope, cdr);
+        this.element = element;
+        this.renderer2 = renderer2;
+        this.ngControl = ngControl;
+        this.translocoScope = translocoScope;
+        this.cdr = cdr;
+        /** Boolean to indicate wether the dropdown is expanded or not, to apply appropriate styling */
+        this.expanded = false;
+        super.ngOnInit();
+    }
+    ngOnInit() {
+        this.autocomplete = 'off';
+        this.debounceTime = 0;
+        this.hostComponent.selectOnSingleOption = false;
+        this.moveInput();
+        this.handleExpandedChange();
+    }
+    /**
+     * @internal
+     * Allow space to be inputted as text
+     * @param event fired containing which key was released.
+     */
+    onKeyUp(event) {
+        if (event.code === 'Space') {
+            event.preventDefault();
+        }
+    }
+    /**
+     * @internal
+     * First time the dropdown is expanded, move the input sp it becomes a child of the dropdown button
+     * to better reflect semantics and styling.
+     */
+    moveInput() {
+        // Workaround to execute code in setTimeout due to hooks management etc.
+        setTimeout(() => {
+            // Only move if parent dropdown is found
+            if (this.dropdownButton) {
+                this.renderer2.appendChild(this.dropdownButton.querySelector('button'), this.element.nativeElement);
+                // Get the height of the parent button so the input can be explicitly set to the same height since it's absolutely positioned
+                this.buttonHeight =
+                    this.dropdownButton.getBoundingClientRect().height || 32; // Default to 2em;
+            }
+        }, 0);
+    }
+    /**
+     * @internal
+     * When dropdown is expanded, focus on the input. If a value is selected, set it in the input.
+     * When the dropdown is collapsed, empty the input from text.
+     */
+    handleExpandedChange() {
+        this.hostComponent.expandedChange
+            .pipe(takeUntil(this._destroy$))
+            .subscribe((state) => {
+            this.expanded = state;
+            if (this.expanded) {
+                // Weird workaround for setting focus. Didn't set focus, but wrapping in setTimeout solved it.
+                // See suggestion here: https://github.com/ionic-team/stencil/issues/3772#issuecomment-1292599609
+                setTimeout(() => this.setFocus());
+                // Format and interpolate result since return type can be other than string from the formatter
+                const formattedValue = `${this.formatSelected(this.hostComponent.state)}`;
+                this.setInput(formattedValue, false);
+            }
+            else
+                this.setInput('', true);
+        });
+    }
+    /**
+     * @internal Formats the selected option to display in the input. Interpolate the returned value
+     * since we don't know the return type or label type.
+     * @param value The selected value
+     * @returns The formatted value
+     */
+    formatSelected(value) {
+        if (value?.key == null)
+            return '';
+        // If no formatter exists, return the label or empty string
+        if (!this.selectedFormatter)
+            return value.label ?? '';
+        // If a formatter exists, use it
+        return this.selectedFormatter(value) ?? '';
+    }
+    /**
+     * Sets the input programmatically instead of native HTML input event.
+     * @param input
+     */
+    setInput(input, triggerFilter) {
+        this.state = input;
+        if (triggerFilter) {
+            this.onChange(this.state);
+            this.inputChange$.next(this.state);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadInputComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.NgControl, optional: true, self: true }, { token: TRANSLOCO_SCOPE, optional: true }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.2.12", type: NgvTypeaheadInputComponent, selector: "nggv-typeahead-input", inputs: { hostComponent: "hostComponent", resultFormatter: "resultFormatter", selectedFormatter: "selectedFormatter" }, host: { listeners: { "document:keyup": "onKeyUp($event)" } }, usesInheritance: true, ngImport: i0, template: "<ng-container>\n    <div class=\"input-wrapper\"\n        [ngClass]=\"{ 'expanded': expanded, 'collapsed': !expanded }\"\n        [ngStyle]=\"{ 'height.px': buttonHeight }\"\n        (click)=\"$event.stopPropagation();\">\n        <!-- INPUT FIELD -->\n        <div class=\"input-group\">\n            <input #input\n                [id]=\"id + '-input'\"\n                class=\"sdv-field\"\n                [attr.type]=\"type\"\n                [attr.name]=\"name\"\n                [attr.required]=\"required\"\n                [attr.email]=\"email\"\n                [min]=\"min\"\n                [max]=\"max\"\n                [step]=\"step\"\n                [attr.maxlength]=\"maxlength\"\n                [attr.minlength]=\"minlength\"\n                [pattern]=\"pattern\"\n                [disabled]=\"disabled\"\n                [autocomplete]=\"autocomplete\"\n                [autofocus]=\"autofocus\"\n                [readOnly]=\"readonly\"\n                [attr.role]=\"role\"\n                [attr.placeholder]=\"placeholder\"\n                [attr.aria-label]=\"description\"\n                [value]=\"state\"\n                (input)=\"onInput($event)\"\n                (focus)=\"onFocus($event)\"\n                (blur)=\"onBlur($event)\" />\n        </div>\n    </div>\n</ng-container>", styles: [":host{position:absolute;top:0;left:0;width:calc(100% - 2.625em)}:host .input-wrapper{border:none;box-shadow:none}:host .input-wrapper.expanded{display:flex}:host .input-wrapper.expanded .input-group input.sdv-field{height:100%;width:100%;min-height:unset;margin-left:1px;border:none;box-shadow:none}:host .input-wrapper.collapsed{display:none}:host .input-wrapper .input-group{width:100%}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'nggv-typeahead-input', template: "<ng-container>\n    <div class=\"input-wrapper\"\n        [ngClass]=\"{ 'expanded': expanded, 'collapsed': !expanded }\"\n        [ngStyle]=\"{ 'height.px': buttonHeight }\"\n        (click)=\"$event.stopPropagation();\">\n        <!-- INPUT FIELD -->\n        <div class=\"input-group\">\n            <input #input\n                [id]=\"id + '-input'\"\n                class=\"sdv-field\"\n                [attr.type]=\"type\"\n                [attr.name]=\"name\"\n                [attr.required]=\"required\"\n                [attr.email]=\"email\"\n                [min]=\"min\"\n                [max]=\"max\"\n                [step]=\"step\"\n                [attr.maxlength]=\"maxlength\"\n                [attr.minlength]=\"minlength\"\n                [pattern]=\"pattern\"\n                [disabled]=\"disabled\"\n                [autocomplete]=\"autocomplete\"\n                [autofocus]=\"autofocus\"\n                [readOnly]=\"readonly\"\n                [attr.role]=\"role\"\n                [attr.placeholder]=\"placeholder\"\n                [attr.aria-label]=\"description\"\n                [value]=\"state\"\n                (input)=\"onInput($event)\"\n                (focus)=\"onFocus($event)\"\n                (blur)=\"onBlur($event)\" />\n        </div>\n    </div>\n</ng-container>", styles: [":host{position:absolute;top:0;left:0;width:calc(100% - 2.625em)}:host .input-wrapper{border:none;box-shadow:none}:host .input-wrapper.expanded{display:flex}:host .input-wrapper.expanded .input-group input.sdv-field{height:100%;width:100%;min-height:unset;margin-left:1px;border:none;box-shadow:none}:host .input-wrapper.collapsed{display:none}:host .input-wrapper .input-group{width:100%}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLOCO_SCOPE]
+                }] }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { hostComponent: [{
+                type: Input
+            }], resultFormatter: [{
+                type: Input
+            }], selectedFormatter: [{
+                type: Input
+            }], onKeyUp: [{
+                type: HostListener,
+                args: ['document:keyup', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead-input.component.js","sourceRoot":"","sources":["../../../../../../../../libs/angular/src/v-angular/dropdown/typeahead/typeahead-input/typeahead-input.component.ts","../../../../../../../../libs/angular/src/v-angular/dropdown/typeahead/typeahead-input/typeahead-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  HostListener,\n  Inject,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Renderer2,\n  Self,\n} from '@angular/core'\nimport { NgControl } from '@angular/forms'\n\nimport { takeUntil } from 'rxjs'\n\nimport { TRANSLOCO_SCOPE, TranslocoScope } from '@ngneat/transloco'\n\nimport { OptionBase } from '@sebgroup/green-angular/src/v-angular/core'\nimport { NgvDropdownComponent } from '../../dropdown.component'\nimport { NgvInputComponent } from '@sebgroup/green-angular/src/v-angular/input'\n\n@Component({\n  selector: 'nggv-typeahead-input',\n  templateUrl: './typeahead-input.component.html',\n  styleUrls: ['./typeahead-input.component.scss'],\n})\nexport class NgvTypeaheadInputComponent\n  extends NgvInputComponent\n  implements OnInit, OnDestroy\n{\n  /** Reference to the host dropdown */\n  @Input() hostComponent!: NgvDropdownComponent\n\n  /** Formats each item that is displayed as an option. Only applies format if the option if it implement Option interface. */\n  @Input() resultFormatter?: (option: OptionBase<any>) => string\n\n  /** Formats the selected item in the input when dropdown is opened. If no function is provided, it will display the value of the selected objects label property */\n  @Input() selectedFormatter?: (selected: OptionBase<any>) => string\n\n  get dropdownButton(): HTMLElement {\n    return this.hostComponent.inputRef?.nativeElement\n  }\n\n  /** Boolean to indicate wether the dropdown is expanded or not, to apply appropriate styling */\n  expanded = false\n\n  /** Used to determine the height of the inputin html */\n  buttonHeight?: number\n\n  constructor(\n    private element: ElementRef,\n    private renderer2: Renderer2,\n    @Self() @Optional() public ngControl: NgControl,\n    @Optional()\n    @Inject(TRANSLOCO_SCOPE)\n    protected translocoScope: TranslocoScope,\n    protected cdr: ChangeDetectorRef,\n  ) {\n    super(ngControl, translocoScope, cdr)\n    super.ngOnInit()\n  }\n\n  ngOnInit() {\n    this.autocomplete = 'off'\n    this.debounceTime = 0\n    this.hostComponent.selectOnSingleOption = false\n\n    this.moveInput()\n    this.handleExpandedChange()\n  }\n\n  /**\n   * @internal\n   * Allow space to be inputted as text\n   * @param event fired containing which key was released.\n   */\n  @HostListener('document:keyup', ['$event'])\n  onKeyUp(event: KeyboardEvent) {\n    if (event.code === 'Space') {\n      event.preventDefault()\n    }\n  }\n\n  /**\n   * @internal\n   * First time the dropdown is expanded, move the input sp it becomes a child of the dropdown button\n   * to better reflect semantics and styling.\n   */\n  private moveInput() {\n    // Workaround to execute code in setTimeout due to hooks management etc.\n    setTimeout(() => {\n      // Only move if parent dropdown is found\n      if (this.dropdownButton) {\n        this.renderer2.appendChild(\n          this.dropdownButton.querySelector('button'),\n          this.element.nativeElement,\n        )\n        // Get the height of the parent button so the input can be explicitly set to the same height since it's absolutely positioned\n        this.buttonHeight =\n          this.dropdownButton.getBoundingClientRect().height || 32 // Default to 2em;\n      }\n    }, 0)\n  }\n\n  /**\n   * @internal\n   * When dropdown is expanded, focus on the input. If a value is selected, set it in the input.\n   * When the dropdown is collapsed, empty the input from text.\n   */\n  private handleExpandedChange() {\n    this.hostComponent.expandedChange\n      .pipe(takeUntil(this._destroy$))\n      .subscribe((state) => {\n        this.expanded = state\n\n        if (this.expanded) {\n          // Weird workaround for setting focus. Didn't set focus, but wrapping in setTimeout solved it.\n          // See suggestion here: https://github.com/ionic-team/stencil/issues/3772#issuecomment-1292599609\n          setTimeout(() => this.setFocus())\n          // Format and interpolate result since return type can be other than string from the formatter\n          const formattedValue = `${this.formatSelected(this.hostComponent.state)}`\n          this.setInput(formattedValue, false)\n        } else this.setInput('', true)\n      })\n  }\n\n  /**\n   * @internal Formats the selected option to display in the input. Interpolate the returned value\n   * since we don't know the return type or label type.\n   * @param value The selected value\n   * @returns The formatted value\n   */\n  private formatSelected(value: OptionBase<any>) {\n    if (value?.key == null) return ''\n    // If no formatter exists, return the label or empty string\n    if (!this.selectedFormatter) return value.label ?? ''\n    // If a formatter exists, use it\n    return this.selectedFormatter(value) ?? ''\n  }\n\n  /**\n   * Sets the input programmatically instead of native HTML input event.\n   * @param input\n   */\n  private setInput(input: string, triggerFilter: boolean) {\n    this.state = input\n    if (triggerFilter) {\n      this.onChange(this.state)\n      this.inputChange$.next(this.state)\n    }\n  }\n}\n","<ng-container>\n    <div class=\"input-wrapper\"\n        [ngClass]=\"{ 'expanded': expanded, 'collapsed': !expanded }\"\n        [ngStyle]=\"{ 'height.px': buttonHeight }\"\n        (click)=\"$event.stopPropagation();\">\n        <!-- INPUT FIELD -->\n        <div class=\"input-group\">\n            <input #input\n                [id]=\"id + '-input'\"\n                class=\"sdv-field\"\n                [attr.type]=\"type\"\n                [attr.name]=\"name\"\n                [attr.required]=\"required\"\n                [attr.email]=\"email\"\n                [min]=\"min\"\n                [max]=\"max\"\n                [step]=\"step\"\n                [attr.maxlength]=\"maxlength\"\n                [attr.minlength]=\"minlength\"\n                [pattern]=\"pattern\"\n                [disabled]=\"disabled\"\n                [autocomplete]=\"autocomplete\"\n                [autofocus]=\"autofocus\"\n                [readOnly]=\"readonly\"\n                [attr.role]=\"role\"\n                [attr.placeholder]=\"placeholder\"\n                [attr.aria-label]=\"description\"\n                [value]=\"state\"\n                (input)=\"onInput($event)\"\n                (focus)=\"onFocus($event)\"\n                (blur)=\"onBlur($event)\" />\n        </div>\n    </div>\n</ng-container>"]}

package/esm2022/v-angular/dropdown/typeahead/typeahead.directive.mjs

@@ -0,0 +1,177 @@
+import { Directive, ElementRef, EventEmitter, Host, HostListener, Input, Optional, Output, ViewContainerRef, } from '@angular/core';
+import { distinctUntilChanged, from, Subject, takeUntil, tap, withLatestFrom, } from 'rxjs';
+import { NgvDropdownComponent } from '../dropdown.component';
+import { NgvInputComponent } from '@sebgroup/green-angular/src/v-angular/input';
+import { NgvTypeaheadDropdownListComponent } from '../typeahead/typeahead-dropdown-list/typeahead-dropdown-list.component';
+import { NgvTypeaheadInputComponent } from './typeahead-input/typeahead-input.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../dropdown.component";
+import * as i2 from "@sebgroup/green-angular/src/v-angular/input";
+export class NgvTypeaheadDirective {
+    /** Function that filter the inputvalue */
+    set nggvTypeahead(value) {
+        this.typeaheadFunction = value;
+        // If inputsubscription already exists, unsubscribe and subscribe again
+        if (this.inputSubscription$) {
+            this.inputSubscription$?.unsubscribe();
+            this.inputSubscription$ = undefined;
+            this.handleInputChanges();
+        }
+    }
+    /** Forward text inputs to apply the filter function*/
+    onNgvInput(event) {
+        this.inputValue$.next(event);
+    }
+    /** Helper to the determine if the host is nggv-drodpown or nggv-input*/
+    get hostIsDropdown() {
+        return !!this.hostDropdown;
+    }
+    /** Predefined options */
+    get defaultNullishOption() {
+        return { key: null, label: this.unselectLabel || '\u00A0' };
+    }
+    get emptyOption() {
+        return { key: null, label: 'label.nomatchingoptions', disabled: true };
+    }
+    /** Name of the component. nggv-dropdown if NgvDropdownComponent or nggv-input if NgvInputComponent */
+    get localName() {
+        return this.element.nativeElement.localName;
+    }
+    constructor(viewContainerRef, element, hostDropdown, hostInput) {
+        this.viewContainerRef = viewContainerRef;
+        this.element = element;
+        this.hostDropdown = hostDropdown;
+        this.hostInput = hostInput;
+        /** Allow option to be unselected in the dropdown even if it is required. Defaults to true */
+        this.allowUnselect = true;
+        /** Emits the entered string the user has written in the input */
+        this.filterPhraseChange = new EventEmitter();
+        this.inputValue$ = new Subject();
+        this.onDestroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.handleInputChanges();
+        this.inputValue$.next('');
+        if (this.hostIsDropdown)
+            this.createInput();
+        else
+            this.createDropdownList();
+    }
+    ngOnDestroy() {
+        this.onDestroy$.next(true);
+        this.onDestroy$.complete();
+    }
+    /**
+     * @internal
+     * Core functionality of typeahead. Emits input, then filters the result based on the supplied function
+     * If directive is applied on nggv-input, manually show or hide options in the list.
+     * If directive is applied on nggv-dropdown, let the dropdown itself choose when to open or close
+     */
+    handleInputChanges() {
+        this.inputSubscription$ = this.inputValue$
+            .pipe(takeUntil(this.onDestroy$), distinctUntilChanged(), tap((inputValue) => this.filterPhraseChange.emit(inputValue)), this.typeaheadFunction ? this.typeaheadFunction : () => from([]), withLatestFrom(this.inputValue$))
+            .subscribe(([filteredValues, input]) => this.setOptions(filteredValues, input));
+    }
+    /**
+     * @internal
+     * Creates a nggv-input if the host itself is not a text-input
+     * Set styles to not display the input when closed
+     * Trigger filtering when changes occur in the field
+     * */
+    createInput() {
+        // Create the input component
+        this.inputComponent = this.viewContainerRef.createComponent(NgvTypeaheadInputComponent);
+        // Forward necessary info to component
+        this.inputComponent.setInput('hostComponent', this.hostDropdown);
+        this.inputComponent.setInput('selectedFormatter', this.selectedFormatter);
+        this.inputComponent.setInput('resultFormatter', this.resultFormatter);
+        // Listen to value changes
+        this.inputComponent.instance.nggvInput
+            .pipe(takeUntil(this.onDestroy$))
+            .subscribe((inputValue) => this.inputValue$.next(inputValue));
+    }
+    /** @internal Creates a nggv-dropdown-list if the host itself is a nggv-input */
+    createDropdownList() {
+        this.dropdownListComponent = this.viewContainerRef.createComponent(NgvTypeaheadDropdownListComponent);
+        this.dropdownListComponent.setInput('hostComponent', this.hostInput);
+    }
+    /**
+     * @internal Sets the options the user can select.
+     * If the host is a nggv-dropdown, utilize the dropdown itself to display the options
+     * If the host is a nggv-input, use the created nggv-dropdown-list to displaye the options
+     * @param filteredValues The options to display in the dropdown
+     * @param emptyInput If the input is empty
+     */
+    setOptions(filteredValues, input) {
+        if (!filteredValues)
+            return;
+        // Conditionally add empty or nullish option if it's allowed, the input is empty and does not already contain nullish
+        const allowNullish = this.allowUnselect &&
+            !input &&
+            !(Object.keys(filteredValues[0]).includes('key') &&
+                filteredValues[0].key == null);
+        if (filteredValues.length === 0) {
+            filteredValues = [this.emptyOption];
+        }
+        else if (allowNullish) {
+            filteredValues = [this.defaultNullishOption].concat(filteredValues);
+        }
+        if (this.hostIsDropdown) {
+            // Add nullish option when no input is written (or when dropdown is epanded and has a selection)
+            this.hostDropdown.allowControlNullishOption = false;
+            this.hostDropdown.options = this.formatOptions(filteredValues);
+            this.hostDropdown.textToHighlight = `${input || ''}`;
+            this.hostDropdown.detectChanges();
+            return;
+        }
+        if (!this.hostIsDropdown) {
+            this.dropdownListComponent.setInput('options', this.formatOptions(filteredValues));
+            this.dropdownListComponent.setInput('textToHighlight', `${input || ''}`);
+        }
+    }
+    /**
+     * @internal Formats the available options to display in the dropdown list
+     * @param options The selected value
+     * @returns The formatted value
+     */
+    formatOptions(options) {
+        if (!options)
+            return [];
+        if (!this.resultFormatter)
+            return options;
+        return options.map((value) => value?.label ? this.resultFormatter?.(value) : value);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadDirective, deps: [{ token: i0.ViewContainerRef }, { token: i0.ElementRef }, { token: i1.NgvDropdownComponent, host: true, optional: true }, { token: i2.NgvInputComponent, host: true, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.2.12", type: NgvTypeaheadDirective, isStandalone: true, selector: "nggv-input[nggvTypeahead], nggv-dropdown[nggvTypeahead]", inputs: { nggvTypeahead: "nggvTypeahead", resultFormatter: "resultFormatter", selectedFormatter: "selectedFormatter", allowUnselect: "allowUnselect", unselectLabel: "unselectLabel" }, outputs: { filterPhraseChange: "filterPhraseChange" }, host: { listeners: { "nggvInput": "onNgvInput($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'nggv-input[nggvTypeahead], nggv-dropdown[nggvTypeahead]',
+                    standalone: true,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ElementRef }, { type: i1.NgvDropdownComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }, { type: i2.NgvInputComponent, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }] }]; }, propDecorators: { nggvTypeahead: [{
+                type: Input
+            }], resultFormatter: [{
+                type: Input
+            }], selectedFormatter: [{
+                type: Input
+            }], allowUnselect: [{
+                type: Input
+            }], unselectLabel: [{
+                type: Input
+            }], filterPhraseChange: [{
+                type: Output
+            }], onNgvInput: [{
+                type: HostListener,
+                args: ['nggvInput', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typeahead.directive.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/v-angular/dropdown/typeahead/typeahead.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ComponentRef,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  Host,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  ViewContainerRef,\n} from '@angular/core'\n\nimport {\n  distinctUntilChanged,\n  from,\n  OperatorFunction,\n  Subject,\n  Subscription,\n  takeUntil,\n  tap,\n  withLatestFrom,\n} from 'rxjs'\n\nimport { Option, OptionBase } from '@sebgroup/green-angular/src/v-angular/core'\nimport { NgvDropdownComponent } from '../dropdown.component'\nimport { NgvInputComponent } from '@sebgroup/green-angular/src/v-angular/input'\nimport { NgvTypeaheadDropdownListComponent } from '../typeahead/typeahead-dropdown-list/typeahead-dropdown-list.component'\nimport { NgvTypeaheadInputComponent } from './typeahead-input/typeahead-input.component'\n\n@Directive({\n  selector: 'nggv-input[nggvTypeahead], nggv-dropdown[nggvTypeahead]',\n  standalone: true,\n})\nexport class NgvTypeaheadDirective<\n    K = string | null | undefined,\n    V = string | null | undefined,\n    T extends Option<K, V> = Option<K, V>,\n  >\n  implements OnInit, OnDestroy\n{\n  /** Function that filter the inputvalue */\n  @Input() set nggvTypeahead(value: OperatorFunction<string, T[]> | undefined) {\n    this.typeaheadFunction = value\n\n    // If inputsubscription already exists, unsubscribe and subscribe again\n    if (this.inputSubscription$) {\n      this.inputSubscription$?.unsubscribe()\n      this.inputSubscription$ = undefined\n      this.handleInputChanges()\n    }\n  }\n\n  /** Formats each item that is displayed as an option. Only applies format if the option if it implement Option interface. */\n  @Input() resultFormatter?: (option: OptionBase<any>) => string\n\n  /** Formats the selected item in the input when dropdown is opened. If no function is provided, it will display the value of the selected objects label property */\n  @Input() selectedFormatter?: (selected: OptionBase<any>) => string\n\n  /** Allow option to be unselected in the dropdown even if it is required. Defaults to true */\n  @Input() allowUnselect = true\n\n  /** Custom label for the unselect option */\n  @Input() unselectLabel?: string\n\n  /** Emits the entered string the user has written in the input */\n  @Output() filterPhraseChange = new EventEmitter<string>()\n\n  /** Forward text inputs to apply the filter function*/\n  @HostListener('nggvInput', ['$event']) onNgvInput(event: any) {\n    this.inputValue$.next(event)\n  }\n\n  /** Helper to the determine if the host is nggv-drodpown or nggv-input*/\n  get hostIsDropdown() {\n    return !!this.hostDropdown\n  }\n\n  /** Predefined options */\n  get defaultNullishOption(): OptionBase<any> {\n    return { key: null, label: this.unselectLabel || '\\u00A0' }\n  }\n\n  get emptyOption(): OptionBase<any> {\n    return { key: null, label: 'label.nomatchingoptions', disabled: true }\n  }\n\n  /** Name of the component. nggv-dropdown if NgvDropdownComponent or nggv-input if NgvInputComponent */\n  get localName() {\n    return this.element.nativeElement.localName\n  }\n\n  dropdownListComponent!: ComponentRef<NgvTypeaheadDropdownListComponent>\n  inputComponent!: ComponentRef<NgvTypeaheadInputComponent>\n\n  private typeaheadFunction?: OperatorFunction<string, T[]>\n  private inputValue$ = new Subject<any>()\n  private inputSubscription$?: Subscription\n  private onDestroy$ = new Subject<boolean>()\n\n  constructor(\n    private viewContainerRef: ViewContainerRef,\n    private element: ElementRef,\n    @Optional() @Host() private hostDropdown: NgvDropdownComponent,\n    @Optional() @Host() private hostInput: NgvInputComponent,\n  ) {}\n\n  ngOnInit() {\n    this.handleInputChanges()\n    this.inputValue$.next('')\n\n    if (this.hostIsDropdown) this.createInput()\n    else this.createDropdownList()\n  }\n\n  ngOnDestroy(): void {\n    this.onDestroy$.next(true)\n    this.onDestroy$.complete()\n  }\n\n  /**\n   * @internal\n   * Core functionality of typeahead. Emits input, then filters the result based on the supplied function\n   * If directive is applied on nggv-input, manually show or hide options in the list.\n   * If directive is applied on nggv-dropdown, let the dropdown itself choose when to open or close\n   */\n  private handleInputChanges() {\n    this.inputSubscription$ = this.inputValue$\n      .pipe(\n        takeUntil(this.onDestroy$),\n        distinctUntilChanged(),\n        tap((inputValue) => this.filterPhraseChange.emit(inputValue)),\n        this.typeaheadFunction ? this.typeaheadFunction : () => from([]),\n        withLatestFrom(this.inputValue$),\n      )\n      .subscribe(([filteredValues, input]) =>\n        this.setOptions(filteredValues, input),\n      )\n  }\n\n  /**\n   * @internal\n   * Creates a nggv-input if the host itself is not a text-input\n   * Set styles to not display the input when closed\n   * Trigger filtering when changes occur in the field\n   * */\n  private createInput() {\n    // Create the input component\n    this.inputComponent = this.viewContainerRef.createComponent(\n      NgvTypeaheadInputComponent,\n    )\n    // Forward necessary info to component\n    this.inputComponent.setInput('hostComponent', this.hostDropdown)\n    this.inputComponent.setInput('selectedFormatter', this.selectedFormatter)\n    this.inputComponent.setInput('resultFormatter', this.resultFormatter)\n    // Listen to value changes\n    this.inputComponent.instance.nggvInput\n      .pipe(takeUntil(this.onDestroy$))\n      .subscribe((inputValue) => this.inputValue$.next(inputValue))\n  }\n\n  /** @internal Creates a nggv-dropdown-list if the host itself is a nggv-input */\n  private createDropdownList() {\n    this.dropdownListComponent = this.viewContainerRef.createComponent(\n      NgvTypeaheadDropdownListComponent,\n    )\n    this.dropdownListComponent.setInput('hostComponent', this.hostInput)\n  }\n\n  /**\n   * @internal Sets the options the user can select.\n   * If the host is a nggv-dropdown, utilize the dropdown itself to display the options\n   * If the host is a nggv-input, use the created nggv-dropdown-list to displaye the options\n   * @param filteredValues The options to display in the dropdown\n   * @param emptyInput If the input is empty\n   */\n  private setOptions(filteredValues: T[], input: string) {\n    if (!filteredValues) return\n    // Conditionally add empty or nullish option if it's allowed, the input is empty and does not already contain nullish\n    const allowNullish =\n      this.allowUnselect &&\n      !input &&\n      !(\n        Object.keys(filteredValues[0]).includes('key') &&\n        filteredValues[0].key == null\n      )\n    if (filteredValues.length === 0) {\n      filteredValues = [this.emptyOption]\n    } else if (allowNullish) {\n      filteredValues = [this.defaultNullishOption].concat(filteredValues)\n    }\n\n    if (this.hostIsDropdown) {\n      // Add nullish option when no input is written (or when dropdown is epanded and has a selection)\n      this.hostDropdown.allowControlNullishOption = false\n      this.hostDropdown.options = this.formatOptions(filteredValues)\n      this.hostDropdown.textToHighlight = `${input || ''}`\n      this.hostDropdown.detectChanges()\n      return\n    }\n\n    if (!this.hostIsDropdown) {\n      this.dropdownListComponent.setInput(\n        'options',\n        this.formatOptions(filteredValues),\n      )\n      this.dropdownListComponent.setInput('textToHighlight', `${input || ''}`)\n    }\n  }\n\n  /**\n   * @internal Formats the available options to display in the dropdown list\n   * @param options The selected value\n   * @returns The formatted value\n   */\n  private formatOptions(options: T[]): OptionBase<any>[] {\n    if (!options) return []\n    if (!this.resultFormatter) return options\n    return options.map((value) =>\n      value?.label ? this.resultFormatter?.(value) : value,\n    )\n  }\n}\n"]}

package/esm2022/v-angular/dropdown/typeahead/typeahead.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NgvTypeaheadHighlightComponent } from './typeahead-highlight/typeahead-highlight.component';
+import { NgvTypeaheadInputComponent } from './typeahead-input/typeahead-input.component';
+import { NgvTooltipModule } from '@sebgroup/green-angular/src/v-angular/tooltip';
+import { NgvTypeaheadDropdownListComponent } from './typeahead-dropdown-list/typeahead-dropdown-list.component';
+import * as i0 from "@angular/core";
+export class NgvTypeaheadModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadModule, declarations: [NgvTypeaheadHighlightComponent,
+            NgvTypeaheadInputComponent,
+            NgvTypeaheadDropdownListComponent], imports: [CommonModule, NgvTooltipModule], exports: [NgvTypeaheadHighlightComponent,
+            NgvTypeaheadInputComponent,
+            NgvTypeaheadDropdownListComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadModule, imports: [CommonModule, NgvTooltipModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvTypeaheadModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        NgvTypeaheadHighlightComponent,
+                        NgvTypeaheadInputComponent,
+                        NgvTypeaheadDropdownListComponent,
+                    ],
+                    imports: [CommonModule, NgvTooltipModule],
+                    exports: [
+                        NgvTypeaheadHighlightComponent,
+                        NgvTypeaheadInputComponent,
+                        NgvTypeaheadDropdownListComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v-angular/i18n/i18n.json

@@ -0,0 +1,12 @@
+{
+    "error.fieldinputmask": "Invalid value pattern",
+    "error.fieldrequired": "Field must have content",
+    "error.fieldmaxlength": "Field content should not be longer than {{requiredLength}} characters",
+    "label.defaultlabel": "Label",
+    "label.maxlength": "characters left",
+    "label.optional": "Optional",
+    "button_cancel": "Cancel",
+    "button_apply": "Apply",
+    "button_save": "Save",
+    "text_dialogue": "You can supply the content seen here either through the <code>[content]=\"string\"</code> property or</br>by passing children between the opening and closing tags <code>&lt;c-dialog&gt; ...children &lt;/c-dialog&gt;</code>"
+}

package/esm2022/v-angular/i18n/i18n.module.mjs

@@ -0,0 +1,83 @@
+import { Inject, Injectable, isDevMode, NgModule } from '@angular/core';
+import { delay, lastValueFrom, of } from 'rxjs';
+import { provideTransloco, provideTranslocoMissingHandler, TRANSLOCO_TRANSPILER, TranslocoModule, } from '@ngneat/transloco';
+import defaultLang from './i18n.json';
+import * as i0 from "@angular/core";
+export class NgvMissingHandler {
+    constructor(transpiler) {
+        this.transpiler = transpiler;
+    }
+    handle(key, _, params) {
+        const keyWithoutLocale = key.charAt(2) === '.' ? key.substring(3) : key;
+        const withoutScope = keyWithoutLocale.replace(/^((?:\w+)(?<!label|heading|button|alt|link|title|href|fieldhelp|error|text|image|list)(?:\.))/, '');
+        const transpiledKey = this.transpiler.transpile(defaultLang[keyWithoutLocale], params, {}, keyWithoutLocale);
+        return transpiledKey || withoutScope;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvMissingHandler, deps: [{ token: TRANSLOCO_TRANSPILER }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvMissingHandler }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvMissingHandler, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TRANSLOCO_TRANSPILER]
+                }] }]; } });
+const en = {
+    'error.fieldinputmask': 'Invalid value pattern',
+    'error.fieldrequired': 'Field must have content',
+    'error.fieldmaxlength': 'Field content should not be longer than {{requiredLength}} characters',
+    'label.defaultlabel': 'Label',
+    'label.maxlength': 'characters left',
+    'label.optional': 'Optional',
+};
+const sv = {
+    'error.fieldinputmask': 'Icke giltigt tecken mönster',
+    'error.fieldrequired': 'Fältet får inte lämnas tomt',
+    'error.fieldmaxlength': 'Fältinnehållet måste vara längre än {{requiredLength}} tecken',
+    'label.maxlength': 'tecken kvar',
+};
+class TranslocoInlineLoader {
+    getTranslation(lang) {
+        if (lang === 'sv') {
+            return lastValueFrom(of(sv).pipe(delay(1500)));
+        }
+        return lastValueFrom(of(en).pipe(delay(500)));
+    }
+}
+export class NgvI18nModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvI18nModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.2.12", ngImport: i0, type: NgvI18nModule, exports: [TranslocoModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvI18nModule, providers: [
+            provideTransloco({
+                config: {
+                    availableLangs: ['en', 'sv'],
+                    defaultLang: 'en',
+                    // Remove this option if your application doesn't support changing language in runtime.
+                    reRenderOnLangChange: true,
+                    prodMode: !isDevMode(),
+                },
+                loader: TranslocoInlineLoader,
+            }),
+            provideTranslocoMissingHandler(NgvMissingHandler),
+        ], imports: [TranslocoModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.2.12", ngImport: i0, type: NgvI18nModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [
+                        provideTransloco({
+                            config: {
+                                availableLangs: ['en', 'sv'],
+                                defaultLang: 'en',
+                                // Remove this option if your application doesn't support changing language in runtime.
+                                reRenderOnLangChange: true,
+                                prodMode: !isDevMode(),
+                            },
+                            loader: TranslocoInlineLoader,
+                        }),
+                        provideTranslocoMissingHandler(NgvMissingHandler),
+                    ],
+                    exports: [TranslocoModule],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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