@flarehr/apollo-benefits 0.1.109 → 0.3.53405

package/dist/lib/cjs/fl-dropdown-async_2.cjs.entry.js

@@ -1,467 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const index = require('./index-f1fadf90.js');
-const async = require('./async-6a7926f0.js');
-const distinctUntilChanged = require('./distinctUntilChanged-e8538790.js');
-
-function noop() { }
-
-function mergeMap(project, resultSelector, concurrent = Number.POSITIVE_INFINITY) {
-    if (typeof resultSelector === 'function') {
-        return (source) => source.pipe(mergeMap((a, i) => distinctUntilChanged.from(project(a, i)).pipe(distinctUntilChanged.map((b, ii) => resultSelector(a, b, i, ii))), concurrent));
-    }
-    else if (typeof resultSelector === 'number') {
-        concurrent = resultSelector;
-    }
-    return (source) => source.lift(new MergeMapOperator(project, concurrent));
-}
-class MergeMapOperator {
-    constructor(project, concurrent = Number.POSITIVE_INFINITY) {
-        this.project = project;
-        this.concurrent = concurrent;
-    }
-    call(observer, source) {
-        return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));
-    }
-}
-class MergeMapSubscriber extends distinctUntilChanged.SimpleOuterSubscriber {
-    constructor(destination, project, concurrent = Number.POSITIVE_INFINITY) {
-        super(destination);
-        this.project = project;
-        this.concurrent = concurrent;
-        this.hasCompleted = false;
-        this.buffer = [];
-        this.active = 0;
-        this.index = 0;
-    }
-    _next(value) {
-        if (this.active < this.concurrent) {
-            this._tryNext(value);
-        }
-        else {
-            this.buffer.push(value);
-        }
-    }
-    _tryNext(value) {
-        let result;
-        const index = this.index++;
-        try {
-            result = this.project(value, index);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        this.active++;
-        this._innerSub(result);
-    }
-    _innerSub(ish) {
-        const innerSubscriber = new distinctUntilChanged.SimpleInnerSubscriber(this);
-        const destination = this.destination;
-        destination.add(innerSubscriber);
-        const innerSubscription = distinctUntilChanged.innerSubscribe(ish, innerSubscriber);
-        if (innerSubscription !== innerSubscriber) {
-            destination.add(innerSubscription);
-        }
-    }
-    _complete() {
-        this.hasCompleted = true;
-        if (this.active === 0 && this.buffer.length === 0) {
-            this.destination.complete();
-        }
-        this.unsubscribe();
-    }
-    notifyNext(innerValue) {
-        this.destination.next(innerValue);
-    }
-    notifyComplete() {
-        const buffer = this.buffer;
-        this.active--;
-        if (buffer.length > 0) {
-            this._next(buffer.shift());
-        }
-        else if (this.active === 0 && this.hasCompleted) {
-            this.destination.complete();
-        }
-    }
-}
-
-function fromEvent(target, eventName, options, resultSelector) {
-    if (async.isFunction(options)) {
-        resultSelector = options;
-        options = undefined;
-    }
-    if (resultSelector) {
-        return fromEvent(target, eventName, options).pipe(distinctUntilChanged.map(args => async.isArray(args) ? resultSelector(...args) : resultSelector(args)));
-    }
-    return new async.Observable(subscriber => {
-        function handler(e) {
-            if (arguments.length > 1) {
-                subscriber.next(Array.prototype.slice.call(arguments));
-            }
-            else {
-                subscriber.next(e);
-            }
-        }
-        setupSubscription(target, eventName, handler, subscriber, options);
-    });
-}
-function setupSubscription(sourceObj, eventName, handler, subscriber, options) {
-    let unsubscribe;
-    if (isEventTarget(sourceObj)) {
-        const source = sourceObj;
-        sourceObj.addEventListener(eventName, handler, options);
-        unsubscribe = () => source.removeEventListener(eventName, handler, options);
-    }
-    else if (isJQueryStyleEventEmitter(sourceObj)) {
-        const source = sourceObj;
-        sourceObj.on(eventName, handler);
-        unsubscribe = () => source.off(eventName, handler);
-    }
-    else if (isNodeStyleEventEmitter(sourceObj)) {
-        const source = sourceObj;
-        sourceObj.addListener(eventName, handler);
-        unsubscribe = () => source.removeListener(eventName, handler);
-    }
-    else if (sourceObj && sourceObj.length) {
-        for (let i = 0, len = sourceObj.length; i < len; i++) {
-            setupSubscription(sourceObj[i], eventName, handler, subscriber, options);
-        }
-    }
-    else {
-        throw new TypeError('Invalid event target');
-    }
-    subscriber.add(unsubscribe);
-}
-function isNodeStyleEventEmitter(sourceObj) {
-    return sourceObj && typeof sourceObj.addListener === 'function' && typeof sourceObj.removeListener === 'function';
-}
-function isJQueryStyleEventEmitter(sourceObj) {
-    return sourceObj && typeof sourceObj.on === 'function' && typeof sourceObj.off === 'function';
-}
-function isEventTarget(sourceObj) {
-    return sourceObj && typeof sourceObj.addEventListener === 'function' && typeof sourceObj.removeEventListener === 'function';
-}
-
-function debounceTime(dueTime, scheduler = async.async) {
-    return (source) => source.lift(new DebounceTimeOperator(dueTime, scheduler));
-}
-class DebounceTimeOperator {
-    constructor(dueTime, scheduler) {
-        this.dueTime = dueTime;
-        this.scheduler = scheduler;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new DebounceTimeSubscriber(subscriber, this.dueTime, this.scheduler));
-    }
-}
-class DebounceTimeSubscriber extends async.Subscriber {
-    constructor(destination, dueTime, scheduler) {
-        super(destination);
-        this.dueTime = dueTime;
-        this.scheduler = scheduler;
-        this.debouncedSubscription = null;
-        this.lastValue = null;
-        this.hasValue = false;
-    }
-    _next(value) {
-        this.clearDebounce();
-        this.lastValue = value;
-        this.hasValue = true;
-        this.add(this.debouncedSubscription = this.scheduler.schedule(dispatchNext, this.dueTime, this));
-    }
-    _complete() {
-        this.debouncedNext();
-        this.destination.complete();
-    }
-    debouncedNext() {
-        this.clearDebounce();
-        if (this.hasValue) {
-            const { lastValue } = this;
-            this.lastValue = null;
-            this.hasValue = false;
-            this.destination.next(lastValue);
-        }
-    }
-    clearDebounce() {
-        const debouncedSubscription = this.debouncedSubscription;
-        if (debouncedSubscription !== null) {
-            this.remove(debouncedSubscription);
-            debouncedSubscription.unsubscribe();
-            this.debouncedSubscription = null;
-        }
-    }
-}
-function dispatchNext(subscriber) {
-    subscriber.debouncedNext();
-}
-
-function tap(nextOrObserver, error, complete) {
-    return function tapOperatorFunction(source) {
-        return source.lift(new DoOperator(nextOrObserver, error, complete));
-    };
-}
-class DoOperator {
-    constructor(nextOrObserver, error, complete) {
-        this.nextOrObserver = nextOrObserver;
-        this.error = error;
-        this.complete = complete;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new TapSubscriber(subscriber, this.nextOrObserver, this.error, this.complete));
-    }
-}
-class TapSubscriber extends async.Subscriber {
-    constructor(destination, observerOrNext, error, complete) {
-        super(destination);
-        this._tapNext = noop;
-        this._tapError = noop;
-        this._tapComplete = noop;
-        this._tapError = error || noop;
-        this._tapComplete = complete || noop;
-        if (async.isFunction(observerOrNext)) {
-            this._context = this;
-            this._tapNext = observerOrNext;
-        }
-        else if (observerOrNext) {
-            this._context = observerOrNext;
-            this._tapNext = observerOrNext.next || noop;
-            this._tapError = observerOrNext.error || noop;
-            this._tapComplete = observerOrNext.complete || noop;
-        }
-    }
-    _next(value) {
-        try {
-            this._tapNext.call(this._context, value);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        this.destination.next(value);
-    }
-    _error(err) {
-        try {
-            this._tapError.call(this._context, err);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        this.destination.error(err);
-    }
-    _complete() {
-        try {
-            this._tapComplete.call(this._context);
-        }
-        catch (err) {
-            this.destination.error(err);
-            return;
-        }
-        return this.destination.complete();
-    }
-}
-
-const dropdownAsyncCss = "fl-dropdown .dropdown-menu{max-height:min(20rem, 50vh)}fl-dropdown .dropdown-menu .dropdown-item{cursor:pointer}fl-dropdown .dropdown-menu .dropdown-item.selected{background-color:rgba(253, 189, 0, 0.5)}";
-
-const DEFAULT_SEARCH_LENGTH = 3;
-const SelectInputAsync = class {
-  constructor(hostRef) {
-    index.registerInstance(this, hostRef);
-    this.valueChanged = index.createEvent(this, "valueChanged", 7);
-    this.required = false;
-    this.disabled = false;
-    this.minSearchStringLength = DEFAULT_SEARCH_LENGTH;
-    this.isMouseOver = false;
-    this.searchState = 'pristine';
-    this.inputValue = '';
-    this.isDropdownVisible = false;
-    this.filteredOptions = [];
-    this.shouldExecuteSearch = (searchQuery) => {
-      var _a;
-      return (this.isDropdownVisible &&
-        (searchQuery === null || searchQuery === void 0 ? void 0 : searchQuery.length) >= this.minSearchStringLength &&
-        ((_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) !== searchQuery);
-    };
-    this.onBeginSearch = (searchQuery) => {
-      this.inputValue = searchQuery;
-      this.searchState = 'in progress';
-    };
-    this.onCompleteSearch = (results) => {
-      this.filteredOptions = results;
-      this.highlightedOptionIndex = undefined;
-      this.searchState = 'done';
-    };
-    this.renderFilteredResults = () => {
-      if (this.searchState === 'pristine') {
-        return index.h("span", { class: "dropdown-item disabled" }, "Start typing to find the results");
-      }
-      if (this.searchState === 'in progress') {
-        return (index.h("div", { class: "d-flex justify-content-end align-items-center pr-4" }, index.h("span", { class: "dropdown-item disabled" }, "Searching..."), index.h("i", { class: "dot-falling" })));
-      }
-      if (this.filteredOptions.length === 0) {
-        return index.h("span", { class: "dropdown-item disabled" }, "No items match your search");
-      }
-      return this.filteredOptions.map((option, index$1) => (index.h("span", { class: {
-          'dropdown-item text-wrap': true,
-          selected: this.isOptionSelected(option),
-          active: this.highlightedOptionIndex === index$1
-        }, onClick: (_event) => {
-          this.toggleDropdown(false);
-          this.selectOption(option);
-        } }, option.label)));
-    };
-    this.resetInput = () => {
-      var _a, _b;
-      this.inputValue = (_b = (_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : '';
-    };
-    this.toggleDropdown = (newState) => {
-      this.isDropdownVisible = newState;
-    };
-    this.processKeyboardNavigation = (event) => {
-      const ENTER_KEY = 'Enter';
-      const DOWN_KEY = 'ArrowDown';
-      const UP_KEY = 'ArrowUp';
-      const ESC_KEY = 'Escape';
-      switch (event.key) {
-        case DOWN_KEY:
-          this.toggleDropdown(true);
-          this.highlightNextItem();
-          return true;
-        case UP_KEY:
-          this.highlightPreviousItem();
-          return true;
-        case ENTER_KEY:
-          if (this.highlightedOptionIndex !== undefined) {
-            this.toggleDropdown(false);
-            this.selectOption(this.filteredOptions[this.highlightedOptionIndex]);
-          }
-          return true;
-        case ESC_KEY:
-          this.inputElement.blur();
-          return true;
-      }
-      return false;
-    };
-    this.highlightPreviousItem = () => {
-      if (this.filteredOptions.length === 0) {
-        return;
-      }
-      this.highlightedOptionIndex =
-        this.highlightedOptionIndex === undefined ? 0 : Math.max(this.highlightedOptionIndex - 1, 0);
-    };
-    this.highlightNextItem = () => {
-      if (this.filteredOptions.length === 0) {
-        return;
-      }
-      this.highlightedOptionIndex =
-        this.highlightedOptionIndex === undefined
-          ? 0
-          : Math.min(this.highlightedOptionIndex + 1, this.filteredOptions.length - 1);
-    };
-    this.selectOption = (option) => {
-      this.selectedOption = option;
-      this.inputValue = option.label;
-      this.valueChanged.emit(option);
-    };
-    this.isOptionSelected = (option) => {
-      var _a;
-      return ((_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) === option.label;
-    };
-  }
-  componentWillLoad() {
-    this.selectedOption = this.value;
-  }
-  componentDidLoad() {
-    this.searchResultsSubscription = fromEvent(this.inputElement, 'keyup')
-      .pipe(debounceTime(500), distinctUntilChanged.map((_) => this.inputElement.value), distinctUntilChanged.distinctUntilChanged(), distinctUntilChanged.filter(this.shouldExecuteSearch), tap(this.onBeginSearch), mergeMap(this._searchFunction), tap(this.onCompleteSearch))
-      .subscribe();
-  }
-  componentDidUnload() {
-    this.searchResultsSubscription.unsubscribe();
-  }
-  handleFocus() {
-    this.toggleDropdown(true);
-  }
-  handleBlur() {
-    if (this.isMouseOver) {
-      return;
-    }
-    this.toggleDropdown(false);
-    this.highlightedOptionIndex = undefined;
-    this.resetInput();
-  }
-  handleKeyDown(event) {
-    if (this.processKeyboardNavigation(event)) {
-      event.preventDefault();
-    }
-  }
-  render() {
-    var _a;
-    return [
-      index.h("div", { class: "dropdown" }, index.h("input", { type: "text", class: "form-control", placeholder: this.placeholder, required: this.required, disabled: this.disabled, value: this.inputValue, ref: (el) => (this.inputElement = el) }), index.h("div", { class: {
-          'invalid-feedback': true,
-          'd-none': this.isDropdownVisible
-        } }, (_a = this.requiredValidationMessage) !== null && _a !== void 0 ? _a : 'Required.'), index.h("div", { class: {
-          'dropdown-menu shadow mt-0 w-100 overflow-auto': true,
-          show: this.isDropdownVisible
-        }, onMouseEnter: (_event) => (this.isMouseOver = true), onMouseLeave: (_event) => (this.isMouseOver = false) }, this.renderFilteredResults()))
-    ];
-  }
-  get _searchFunction() {
-    if (this.searchFunction === undefined) {
-      throw new Error("Can't render <fl-dropdown-async/> component with no searchFunction");
-    }
-    return this.searchFunction;
-  }
-};
-SelectInputAsync.style = dropdownAsyncCss;
-
-const promiseButtonCss = "fl-promise-button fl-loading-indicator{left:50%;top:50%;transform:translate(-50%, -50%)}";
-
-var PromiseButtonState;
-(function (PromiseButtonState) {
-  PromiseButtonState[PromiseButtonState["Available"] = 0] = "Available";
-  PromiseButtonState[PromiseButtonState["Pending"] = 1] = "Pending";
-  PromiseButtonState[PromiseButtonState["Error"] = 2] = "Error";
-})(PromiseButtonState || (PromiseButtonState = {}));
-const PromiseButton = class {
-  constructor(hostRef) {
-    index.registerInstance(this, hostRef);
-    this.isBlockElement = false;
-    this.isRounded = false;
-    this.disabled = false;
-    this.variant = 'primary';
-    this.promiseFn = () => Promise.resolve();
-    // tslint:disable-next-line: member-ordering
-    this.state = PromiseButtonState.Available;
-  }
-  render() {
-    return this.state === PromiseButtonState.Pending
-      ? this.renderLoadingButton()
-      : this.renderActiveButton();
-  }
-  renderActiveButton() {
-    return (index.h("fl-button", { disabled: this.disabled, onClick: () => this.clicked(), isBlockElement: this.isBlockElement, variant: this.variant }, index.h("div", null, index.h("slot", null))));
-  }
-  renderLoadingButton() {
-    return (index.h("fl-button", { disabled: true, onClick: () => this.clicked(), isBlockElement: this.isBlockElement, class: "position-relative", variant: this.variant }, index.h("fl-loading-indicator", { class: "position-absolute", theme: "dark" }), index.h("div", { class: "invisible" }, index.h("slot", null))));
-  }
-  async clicked() {
-    this.state = PromiseButtonState.Pending;
-    try {
-      await this.promiseFn();
-      this.state = PromiseButtonState.Available;
-    }
-    catch (err) {
-      this.state = PromiseButtonState.Error;
-      throw err;
-    }
-  }
-};
-PromiseButton.style = promiseButtonCss;
-
-exports.fl_dropdown_async = SelectInputAsync;
-exports.fl_promise_button = PromiseButton;

package/dist/lib/cjs/fl-dropdown.cjs.entry.js

@@ -1,232 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-const index = require('./index-f1fadf90.js');
-
-var src = {
-	compareTwoStrings,
-	findBestMatch
-};
-
-function compareTwoStrings(first, second) {
-	first = first.replace(/\s+/g, '');
-	second = second.replace(/\s+/g, '');
-
-	if (!first.length && !second.length) return 1;                   // if both are empty strings
-	if (!first.length || !second.length) return 0;                   // if only one is empty string
-	if (first === second) return 1;       							 // identical
-	if (first.length === 1 && second.length === 1) return 0;         // both are 1-letter strings
-	if (first.length < 2 || second.length < 2) return 0;			 // if either is a 1-letter string
-
-	let firstBigrams = new Map();
-	for (let i = 0; i < first.length - 1; i++) {
-		const bigram = first.substring(i, i + 2);
-		const count = firstBigrams.has(bigram)
-			? firstBigrams.get(bigram) + 1
-			: 1;
-
-		firstBigrams.set(bigram, count);
-	}
-	let intersectionSize = 0;
-	for (let i = 0; i < second.length - 1; i++) {
-		const bigram = second.substring(i, i + 2);
-		const count = firstBigrams.has(bigram)
-			? firstBigrams.get(bigram)
-			: 0;
-
-		if (count > 0) {
-			firstBigrams.set(bigram, count - 1);
-			intersectionSize++;
-		}
-	}
-
-	return (2.0 * intersectionSize) / (first.length + second.length - 2);
-}
-
-function findBestMatch(mainString, targetStrings) {
-	if (!areArgsValid(mainString, targetStrings)) throw new Error('Bad arguments: First argument should be a string, second should be an array of strings');
-	
-	const ratings = [];
-	let bestMatchIndex = 0;
-
-	for (let i = 0; i < targetStrings.length; i++) {
-		const currentTargetString = targetStrings[i];
-		const currentRating = compareTwoStrings(mainString, currentTargetString);
-		ratings.push({target: currentTargetString, rating: currentRating});
-		if (currentRating > ratings[bestMatchIndex].rating) {
-			bestMatchIndex = i;
-		}
-	}
-	
-	
-	const bestMatch = ratings[bestMatchIndex];
-	
-	return { ratings, bestMatch, bestMatchIndex };
-}
-
-function areArgsValid(mainString, targetStrings) {
-	if (typeof mainString !== 'string') return false;
-	if (!Array.isArray(targetStrings)) return false;
-	if (!targetStrings.length) return false;
-	if (targetStrings.find(s => typeof s !== 'string')) return false;
-	return true;
-}
-
-const dropdownCss = "fl-dropdown .dropdown-menu{max-height:min(20rem, 50vh)}fl-dropdown .dropdown-menu .dropdown-item{cursor:pointer}fl-dropdown .dropdown-menu .dropdown-item.selected{background-color:rgba(253, 189, 0, 0.5)}";
-
-const Dropdown = class {
-  constructor(hostRef) {
-    index.registerInstance(this, hostRef);
-    this.valueChanged = index.createEvent(this, "valueChanged", 7);
-    this.required = false;
-    this.disabled = false;
-    this.isMouseOver = false;
-    this.inputValue = '';
-    this.isDropdownVisible = false;
-    this.filteredOptions = [];
-    this.renderFilteredResults = () => {
-      if (this.filteredOptions.length === 0) {
-        return index.h("span", { class: "dropdown-item disabled" }, "No items match your search");
-      }
-      return this.filteredOptions.map((option, index$1) => (index.h("span", { class: {
-          'dropdown-item text-wrap': true,
-          selected: this.isOptionSelected(option),
-          active: this.highlightedOptionIndex === index$1
-        }, onClick: (_event) => {
-          this.toggleDropdown(false);
-          this.selectOption(option);
-        } }, index.h("span", null, option.label))));
-    };
-    this.filterResults = (searchString) => {
-      this.filteredOptions = this.sortOptionsByRelevancy(this._options.filter((option) => option.label.toLowerCase().includes(searchString.toLowerCase())), searchString);
-      this.highlightedOptionIndex = undefined;
-    };
-    this.selectOption = (option) => {
-      this.selectedOption = option;
-      this.inputValue = option.label;
-      this.valueChanged.emit(option);
-    };
-    this.isOptionSelected = (option) => {
-      var _a;
-      return ((_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) === option.label;
-    };
-    this.toggleDropdown = (newState) => {
-      this.isDropdownVisible = newState;
-    };
-    this.resetInput = () => {
-      var _a, _b;
-      this.inputValue = (_b = (_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : '';
-      this.filteredOptions = this._options;
-    };
-    this.processKeyboardNavigation = (event) => {
-      const ENTER_KEY = 'Enter';
-      const DOWN_KEY = 'ArrowDown';
-      const UP_KEY = 'ArrowUp';
-      const ESC_KEY = 'Escape';
-      switch (event.key) {
-        case DOWN_KEY:
-          this.toggleDropdown(true);
-          this.highlightNextItem();
-          return true;
-        case UP_KEY:
-          this.highlightPreviousItem();
-          return true;
-        case ENTER_KEY:
-          if (this.highlightedOptionIndex !== undefined) {
-            this.toggleDropdown(false);
-            this.selectOption(this.filteredOptions[this.highlightedOptionIndex]);
-          }
-          return true;
-        case ESC_KEY:
-          this.inputElement.blur();
-          return true;
-      }
-      return false;
-    };
-    this.highlightPreviousItem = () => {
-      if (this.filteredOptions.length === 0) {
-        return;
-      }
-      this.highlightedOptionIndex =
-        this.highlightedOptionIndex === undefined ? 0 : Math.max(this.highlightedOptionIndex - 1, 0);
-    };
-    this.highlightNextItem = () => {
-      if (this.filteredOptions.length === 0) {
-        return;
-      }
-      this.highlightedOptionIndex =
-        this.highlightedOptionIndex === undefined
-          ? 0
-          : Math.min(this.highlightedOptionIndex + 1, this.filteredOptions.length - 1);
-    };
-  }
-  get _options() {
-    if (this.options === undefined) {
-      throw new Error("Can't render <fl-dropdown /> component with no options");
-    }
-    return this.options;
-  }
-  componentWillLoad() {
-    var _a, _b;
-    this.filteredOptions = this._options;
-    this.selectedOption = this._options.find((item) => item.value === this.value);
-    this.inputValue = (_b = (_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : '';
-  }
-  handleFocus() {
-    this.toggleDropdown(true);
-  }
-  handleBlur() {
-    if (this.isMouseOver) {
-      return;
-    }
-    this.toggleDropdown(false);
-    this.resetInput();
-  }
-  handleKeyDown(event) {
-    if (this.processKeyboardNavigation(event)) {
-      event.preventDefault();
-    }
-  }
-  onOptionsChanged() {
-    this.filteredOptions = this._options;
-  }
-  onValueChanged() {
-    var _a, _b;
-    this.selectedOption = this._options.find((item) => item.value === this.value);
-    this.inputValue = (_b = (_a = this.selectedOption) === null || _a === void 0 ? void 0 : _a.label) !== null && _b !== void 0 ? _b : '';
-  }
-  render() {
-    var _a;
-    return [
-      index.h("div", { class: "dropdown" }, index.h("input", { type: "text", class: "form-control custom-select", placeholder: this.placeholder, required: this.required, disabled: this.disabled, value: this.inputValue, onInput: (event) => {
-          const newValue = event.target.value;
-          this.inputValue = newValue;
-          this.filterResults(newValue);
-          this.toggleDropdown(true);
-        }, ref: (el) => (this.inputElement = el) }), index.h("div", { class: {
-          'invalid-feedback': true,
-          'd-none': this.isDropdownVisible
-        } }, (_a = this.requiredValidationMessage) !== null && _a !== void 0 ? _a : 'Required.'), index.h("div", { class: {
-          'dropdown-menu shadow mt-0 w-100 overflow-auto': true,
-          show: this.isDropdownVisible
-        }, onMouseEnter: (_event) => (this.isMouseOver = true), onMouseLeave: (_event) => (this.isMouseOver = false) }, this.renderFilteredResults()))
-    ];
-  }
-  sortOptionsByRelevancy(options, searchString) {
-    return options
-      .map((option) => (Object.assign(Object.assign({}, option), { relevancyScore: src.compareTwoStrings(option.label.toLowerCase(), searchString.toLowerCase()) })))
-      .sort((a, b) => b.relevancyScore - a.relevancyScore)
-      .map((weightedOption) => ({
-      label: weightedOption.label,
-      value: weightedOption.value
-    }));
-  }
-  static get watchers() { return {
-    "options": ["onOptionsChanged"],
-    "value": ["onValueChanged"]
-  }; }
-};
-Dropdown.style = dropdownCss;
-
-exports.fl_dropdown = Dropdown;