@mapsindoors/map-template 1.93.2 → 1.94.0

package/dist/mi-route-instructions.entry.js

@@ -0,0 +1,157 @@
+import { r as registerInstance, c as createEvent, h, H as Host } from './index-7e9696f3.js';
+import { R as RouteTravelMode } from './route-travel-mode.enum-7f4ce9c7.js';
+import { U as UnitSystem } from './unit-system.enum-eaefb53e.js';
+import { c as isInternetExplorer } from './utils-ae714467.js';
+
+const routeInstructionsCss = ":host{display:block;background-color:#fcfcfc;font-family:Figtree, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Oxygen, Ubuntu, Cantarell, \"Fira Sans\", \"Droid Sans\", \"Helvetica Neue\", Arial, sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\"}:host mi-route-instructions-step:hover{cursor:pointer;background-color:#f9fafb;transition:300ms ease}:host mi-route-instructions-step.active{background-color:#f3f4f6;transition:none;cursor:default}:host .instructions-destination{display:flex}:host .instructions-destination-icon{width:40px;display:flex;justify-content:center;align-items:center}:host .instructions-destination-icon mi-icon{width:24px;height:24px;background-color:#1c1917}:host .instructions-destination-details{flex:1;padding:12px}:host .instructions-destination-details mi-location-info{font-size:0.875rem}";
+
+const RouteInstructions = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.clicked = createEvent(this, "clicked", 7);
+    this.miStepElements = [];
+    this.lastStepRouteContext = null;
+    this.lastStepTravelMode = null;
+    this.lastStepTransitStop = null;
+    this.activeStep = {
+      legIndex: 0,
+      stepIndex: 0
+    };
+    this.unit = UnitSystem.Metric;
+    this.route = undefined;
+    this.hideIndoorSubsteps = false;
+    this.travelMode = RouteTravelMode.Walking;
+    this.originLocation = undefined;
+    this.originName = undefined;
+    this.destinationLocation = undefined;
+    this.destinationName = undefined;
+    this.translations = {
+      walk: 'Walk',
+      bike: 'Bike',
+      transit: 'Transit',
+      drive: 'Drive',
+      leave: 'Leave',
+      from: 'From',
+      park: 'Park',
+      at: 'at',
+      building: 'Building',
+      venue: 'Venue',
+      takeStaircaseToLevel: 'Take staircase to level',
+      takeLadderToLevel: 'Take the ladder to level',
+      takeElevatorToLevel: 'Take elevator to level',
+      takeEscalatorToLevel: 'Take escalator to level',
+      takeWheelchairLiftToLevel: 'Take wheelchair lift to level',
+      takeWheelchairRampToLevel: 'Take wheelchair ramp to level',
+      exit: 'Exit',
+      enter: 'Enter',
+      stops: 'stops',
+      andContinue: 'and continue',
+      continueStraightAhead: 'Continue straight ahead',
+      goLeft: 'Go left',
+      goSharpLeft: 'Go sharp left',
+      goSlightLeft: 'Go slight left',
+      goRight: 'Go right',
+      goSharpRight: 'Go sharp right',
+      goSlightRight: 'Go slight right',
+      turnAround: 'Turn around',
+      days: 'd',
+      hours: 'h',
+      minutes: 'min',
+      rideTheBus: 'Ride the bus'
+    };
+  }
+  componentDidRender() {
+    this.miStepElements.forEach((element) => {
+      element.hideIndoorSubsteps = this.hideIndoorSubsteps;
+    });
+  }
+  /**
+   * Transform the step in legs to a flat array of steps.
+   *
+   * @returns {Step[]}
+   */
+  getRouteSteps() {
+    if (!this.route) {
+      return [];
+    }
+    return this.route.legs.reduce((accummulator, leg, legIndex) => {
+      for (const stepIndex in leg.steps) {
+        const step = leg.steps[stepIndex];
+        step.originalLegIndex = legIndex;
+        step.originalStepIndex = parseInt(stepIndex);
+        accummulator.push(step);
+      }
+      return accummulator;
+    }, []);
+  }
+  /**
+   * Updates the activeStep attribute and emits an object with leg, step and maneuver index information.
+   *
+   * @param {CustomEvent<any>} event Step object.
+   * @param {number} stepIndex step index.
+   */
+  stepClickedHandler(event, stepIndex) {
+    const originalStep = this.getRouteSteps()[stepIndex];
+    // Update activeStep attribute
+    this.activeStep = {
+      legIndex: originalStep.originalLegIndex,
+      stepIndex: originalStep.originalStepIndex
+    };
+    this.clicked.emit({
+      legIndex: originalStep.originalLegIndex,
+      stepIndex: originalStep.originalStepIndex,
+      maneuverIndex: event.detail.maneuverIndex
+    });
+  }
+  /**
+   * Check if the step is active.
+   *
+   * @param {Step} step
+   * @returns {boolean}
+   */
+  isActiveStep(step) {
+    // Check that activeStep attribute is set
+    if (!this.activeStep)
+      return false;
+    // Check that the indexes matches those set at the activeStep attribute
+    const isActiveStep = this.activeStep.legIndex === step.originalLegIndex &&
+      this.activeStep.stepIndex === step.originalStepIndex;
+    return isActiveStep;
+  }
+  render() {
+    return this.route ? this.renderInstructions() : null;
+  }
+  /**
+   * Render instructions.
+   *
+   * @returns {JSX.Element}
+   */
+  renderInstructions() {
+    return (h(Host, null, this.getRouteSteps().map((currentStep, stepIndex) => {
+      var _a, _b, _c, _d, _e;
+      const originName = ((_b = (_a = this.originLocation) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.name) ? this.originLocation.properties.name : this.originName || '';
+      const isFirstRouteStep = currentStep.originalLegIndex === 0 && currentStep.originalStepIndex === 0;
+      const lastStepRouteContext = isFirstRouteStep ? originName : this.lastStepRouteContext;
+      const lastTravelMode = this.lastStepTravelMode;
+      const lastTransitStop = this.lastStepTransitStop;
+      this.lastStepRouteContext = currentStep.route_context;
+      this.lastStepTravelMode = currentStep.travel_mode;
+      this.lastStepTransitStop = ((_d = (_c = currentStep.transit_information) === null || _c === void 0 ? void 0 : _c.arrival_stop) === null || _d === void 0 ? void 0 : _d.name) ? (_e = currentStep.transit_information) === null || _e === void 0 ? void 0 : _e.arrival_stop.name : null;
+      return h("mi-route-instructions-step-legacy", { ref: (el) => this.miStepElements.push(el), "from-travel-mode": lastTravelMode, "from-route-context": lastStepRouteContext, "from-transit-stop": lastTransitStop, step: JSON.stringify(currentStep), translations: JSON.stringify(this.translations), unit: this.unit, onStepClicked: (event) => this.stepClickedHandler(event, stepIndex), class: this.isActiveStep(currentStep) ? 'active' : '', part: this.isActiveStep(currentStep) ? 'step active' : 'step',
+        // @ts-ignore
+        exportparts: "\n                            step-toggle,\n                            step-heading,\n                            step-description,\n                            step-info,\n                            step-travel-mode,\n                            step-travel-mode-icon,\n                            maneuver-icon,\n                            maneuver-description,\n                            maneuver-description-distance,\n                            maneuver-description-distance-border" });
+    }), this.destinationLocation || this.destinationName ? this.renderDestination() : null));
+  }
+  /**
+   * Render destination.
+   *
+   * @returns {JSX.Element}
+   */
+  renderDestination() {
+    return (h("div", { class: "instructions-destination" }, h("div", { class: "instructions-destination-icon" }, isInternetExplorer() ? null :
+      h("mi-icon", { "icon-name": "marker" })), h("div", { part: "instructions-destination", class: "instructions-destination-details" }, this.destinationLocation ? this.destinationLocation.properties.name : this.destinationName, this.destinationLocation ? h("mi-location-info", { part: "instructions-destination-info", location: this.destinationLocation }) : null)));
+  }
+};
+RouteInstructions.style = routeInstructionsCss;
+
+export { RouteInstructions as mi_route_instructions };

package/dist/mi-scroll-buttons.entry.js

@@ -0,0 +1,112 @@
+import { r as registerInstance, h } from './index-7e9696f3.js';
+
+const scrollButtonsCss = "a.mi-button{cursor:default}.mi-button{border-radius:4px;border-width:1px;border-style:solid;font-family:Inter, -apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Oxygen, Ubuntu, Cantarell, \"Fira Sans\", \"Droid Sans\", \"Helvetica Neue\", Arial, sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\";font-size:1rem;font-weight:500;padding-left:16px;padding-right:16px;padding-top:12px;padding-bottom:12px;display:inline-flex;align-items:center}.mi-button:disabled{opacity:0.48;cursor:not-allowed}.mi-button object{filter:invert(9%) sepia(13%) saturate(692%) hue-rotate(185deg) brightness(98%) contrast(91%);width:16px;height:16px}.mi-button--small{padding-left:12px;padding-right:12px;padding-top:8px;padding-bottom:8px;font-size:0.875rem;height:32px}.mi-button--small object{width:16px;height:16px}.mi-button--large{padding-left:16px;padding-right:16px;font-size:1.25rem}.mi-button--large object{width:20px;height:20px}.mi-button--full-width{width:100%;justify-content:center}.mi-button--icon-left{padding-left:12px}.mi-button--icon-left object{margin-right:8px}.mi-button--icon-right{padding-right:12px}.mi-button--icon-right object{margin-left:8px}.mi-button--icon-both{padding-top:12px;padding-bottom:12px}.mi-button--icon-both object:first-of-type{margin-right:8px}.mi-button--icon-both object:last-of-type{margin-left:8px}.mi-button--base{background:linear-gradient(#f5f7fa, #ebeff5);color:#1e2025;border-color:#c8d0e0}.mi-button--base:not(:disabled):hover{background:linear-gradient(#ebeff5, #dee3ed);border-color:#aeb9cb}.mi-button--base:not(:disabled):active{background:linear-gradient(#dee3ed, #ebeff5)}.mi-button--primary{color:#ffffff;border-color:#20693e;background:linear-gradient(#3ba064, #2a844e)}.mi-button--primary object{filter:invert(100%) sepia(93%) saturate(0%) hue-rotate(201deg) brightness(106%) contrast(106%)}.mi-button--primary:not(:disabled):hover{background:linear-gradient(#2a844e, #20693e)}.mi-button--primary:not(:disabled):active{background:linear-gradient(#20693e, #2a844e)}.mi-button--delete{background:linear-gradient(#f55151, #de1b1b);color:#ffffff;border-color:#ba0d0d}.mi-button--delete object{filter:invert(100%) sepia(93%) saturate(0%) hue-rotate(201deg) brightness(106%) contrast(106%)}.mi-button--delete:not(:disabled):hover{background:linear-gradient(#de1b1b, #ba0d0d)}.mi-button--delete:not(:disabled):active{background:linear-gradient(#ba0d0d, #de1b1b)}.mi-button--outline{color:#3071d9;border-color:#3071d9;background-color:transparent}.mi-button--outline object{filter:invert(38%) sepia(97%) saturate(742%) hue-rotate(188deg) brightness(86%) contrast(97%)}.mi-button--outline:not(:disabled):hover{color:#1d5bbf;border-color:#1d5bbf;background-color:#eef4fc}.mi-button--outline:not(:disabled):active{color:#1d5bbf;border-color:#1d5bbf;background-color:#cfe0fc}.mi-button--link{color:#3071d9;border-style:none;background-color:transparent;cursor:pointer}.mi-button--link object{filter:invert(38%) sepia(97%) saturate(742%) hue-rotate(188deg) brightness(86%) contrast(97%)}.mi-button--link:not(:disabled):hover{color:#1d5bbf;border-color:#1d5bbf;background-color:#eef4fc}.mi-button--link:disabled:hover{cursor:not-allowed}.mi-button--link:not(:disabled):active{color:#1d5bbf;border-color:#1d5bbf;background-color:#cfe0fc}html{box-sizing:border-box}*,*:before,*:after{box-sizing:inherit}.scroll-buttons{height:100%;width:64px;display:flex;flex-direction:column;align-items:center;justify-content:center;row-gap:16px}.scroll-buttons .btn{margin:0;padding:0;background:none;width:64px;height:64px;background-color:#ffffff;border:none;border-radius:8px;display:flex;align-items:center;justify-content:center}.scroll-buttons .btn mi-icon{width:32px}.scroll-buttons .btn:hover{background:none;background-color:#ffffff;cursor:pointer}.scroll-buttons .btn:disabled{opacity:1}.scroll-buttons .btn:disabled mi-icon{background-color:#a5a9af}";
+
+const ScrollButtons = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.scrollContainerElementRef = undefined;
+    this.scrollLength = 100;
+  }
+  /**
+   * Update scroll buttons enabled/disabled states.
+   */
+  async updateScrollButtons() {
+    this.updateScrollButtonsState();
+  }
+  /**
+   * Watch for container scroll events.
+   */
+  addScrollEventListener() {
+    var _a, _b;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+    (_b = this.scrollContainerElementRef) === null || _b === void 0 ? void 0 : _b.addEventListener('scroll', () => {
+      this.updateScrollButtonsState();
+    });
+    if (this.scrollContainerElementRef) {
+      // Setup a ResizeObserver to update scroll buttons state whenever the dimensions of the scroll container changes.
+      this.resizeObserver = new ResizeObserver(() => {
+        this.updateScrollButtonsState();
+      });
+      this.resizeObserver.observe(this.scrollContainerElementRef);
+    }
+  }
+  /**
+   * Adds scroll event listener to the container element when this component is first attached to the DOM.
+   */
+  connectedCallback() {
+    this.addScrollEventListener();
+  }
+  /**
+   * Disconnects ResizeObserver.
+   */
+  disconnectedCallback() {
+    var _a;
+    (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+  }
+  /**
+   * Updates enable/disable state for scroll up and down buttons.
+   *
+   * @returns {Promise<void>}
+   */
+  async updateScrollButtonsState() {
+    // Disable or enable the scroll up button
+    if (this.scrollContainerElementRef.scrollTop === 0) {
+      this.upButtonElement.disabled = true;
+    }
+    else if (this.upButtonElement.disabled) {
+      this.upButtonElement.disabled = false;
+    }
+    // Disable or enable the scroll down button
+    if (this.scrollContainerElementRef.scrollHeight - this.scrollContainerElementRef.scrollTop === this.scrollContainerElementRef.clientHeight
+      && this.upButtonElement.disabled === true) {
+      this.downButtonElement.disabled = true;
+    }
+    else if (this.scrollContainerElementRef.scrollHeight - this.scrollContainerElementRef.scrollTop > this.scrollContainerElementRef.clientHeight) {
+      this.downButtonElement.disabled = false;
+    }
+    else {
+      this.downButtonElement.disabled = true;
+    }
+  }
+  /**
+   * Update scroll position.
+   *
+   * @param {number} value - Value to scroll.
+   */
+  updateScrollPosition(value) {
+    if (!('scrollBehavior' in document.documentElement.style)) { // Internet Explorer feature check
+      this.scrollContainerElementRef.scrollTop = value;
+    }
+    else {
+      this.scrollContainerElementRef.scroll({
+        top: this.scrollContainerElementRef.scrollTop + value,
+        behavior: 'smooth'
+      });
+    }
+  }
+  /**
+   * Render scroll buttons.
+   *
+   * @returns {JSX.Element}
+   */
+  render() {
+    return (h("div", { part: "container", class: "scroll-buttons" }, h("button", { part: "button button-up", class: "mi-button mi-button--base btn btn-up", type: "button", disabled: true, "aria-label": "Scroll Up", ref: (el) => {
+        this.upButtonElement = el;
+      }, onClick: (event) => {
+        event.stopPropagation();
+        this.updateScrollPosition(-this.scrollLength);
+      } }, h("mi-icon", { "icon-name": "chevron-up" })), h("button", { part: "button button-down", class: "mi-button mi-button--base btn btn-down", type: "button", "aria-label": "Scroll Down", ref: (el) => {
+        this.downButtonElement = el;
+      }, onClick: (event) => {
+        event.stopPropagation();
+        this.updateScrollPosition(this.scrollLength);
+      } }, h("mi-icon", { "icon-name": "chevron-down" }))));
+  }
+  static get watchers() { return {
+    "scrollContainerElementRef": ["addScrollEventListener"]
+  }; }
+};
+ScrollButtons.style = scrollButtonsCss;
+
+export { ScrollButtons as mi_scroll_buttons };

package/dist/mi-search.entry.js

@@ -0,0 +1,376 @@
+import { r as registerInstance, c as createEvent, h, H as Host } from './index-7e9696f3.js';
+import { c as createCommonjsModule, g as getDefaultExportFromCjs } from './_commonjsHelpers-ba3f0406.js';
+
+var Debounce$1 = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = outerDecorator;
+exports.debounce = debounce;
+var DEFAULT_DEBOUNCE_DURATION = 500;
+
+exports.DEFAULT_DEBOUNCE_DURATION = DEFAULT_DEBOUNCE_DURATION;
+/** Decorates a class method so that it is debounced by the specified duration */
+
+function outerDecorator(duration) {
+  return function innerDecorator(target, key, descriptor) {
+    return {
+      configurable: true,
+      enumerable: descriptor.enumerable,
+      get: function getter() {
+        // Attach this function to the instance (not the class)
+        Object.defineProperty(this, key, {
+          configurable: true,
+          enumerable: descriptor.enumerable,
+          value: debounce(descriptor.value, duration)
+        });
+
+        return this[key];
+      }
+    };
+  };
+}
+
+/** Debounces the specified function and returns a wrapper function */
+
+function debounce(method) {
+  var duration = arguments.length <= 1 || arguments[1] === undefined ? DEFAULT_DEBOUNCE_DURATION : arguments[1];
+
+  var timeoutId = undefined;
+
+  function debounceWrapper() {
+    var _this = this;
+
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    debounceWrapper.clear();
+
+    timeoutId = setTimeout(function () {
+      timeoutId = null;
+      method.apply(_this, args);
+    }, duration);
+  }
+
+  debounceWrapper.clear = function () {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+
+  return debounceWrapper;
+}
+});
+
+var dist = createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+
+function _interopExportWildcard(obj, defaults) { var newObj = defaults({}, obj); delete newObj['default']; return newObj; }
+
+function _defaults(obj, defaults) { var keys = Object.getOwnPropertyNames(defaults); for (var i = 0; i < keys.length; i++) { var key = keys[i]; var value = Object.getOwnPropertyDescriptor(defaults, key); if (value && value.configurable && obj[key] === undefined) { Object.defineProperty(obj, key, value); } } return obj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
+
+
+
+var _DebounceJs2 = _interopRequireDefault(Debounce$1);
+
+exports['default'] = _DebounceJs2['default'];
+
+_defaults(exports, _interopExportWildcard(Debounce$1, _defaults));
+});
+
+const Debounce = /*@__PURE__*/getDefaultExportFromCjs(dist);
+
+const searchCss = "@charset \"UTF-8\";mi-search{display:block;position:relative;}mi-search input[type=search]{border-radius:8px;background-color:#ffffff;padding-left:2.5rem;min-height:3rem;height:auto;font-size:1rem;padding-right:2.5rem;font-family:-apple-system, BlinkMacSystemFont, \"Segoe UI\", Roboto, Oxygen, Ubuntu, Cantarell, \"Fira Sans\", \"Droid Sans\", \"Helvetica Neue\", Arial, sans-serif, \"Apple Color Emoji\", \"Segoe UI Emoji\", \"Segoe UI Symbol\";-webkit-appearance:none;-moz-appearance:none;appearance:none;width:100%;position:relative;background-image:url(\"data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTgiIGhlaWdodD0iMTgiIHZpZXdCb3g9IjAgMCAxOCAxOCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik0xMS43MSAxMUgxMi41TDE3LjQ5IDE2TDE2IDE3LjQ5TDExIDEyLjVWMTEuNzFMMTAuNzMgMTEuNDNDOS41OSAxMi40MSA4LjExIDEzIDYuNSAxM0MyLjkxIDEzIDAgMTAuMDkgMCA2LjVDMCAyLjkxIDIuOTEgMCA2LjUgMEMxMC4wOSAwIDEzIDIuOTEgMTMgNi41QzEzIDguMTEgMTIuNDEgOS41OSAxMS40MyAxMC43M0wxMS43MSAxMVpNMiA2LjVDMiA4Ljk5IDQuMDEgMTEgNi41IDExQzguOTkgMTEgMTEgOC45OSAxMSA2LjVDMTEgNC4wMSA4Ljk5IDIgNi41IDJDNC4wMSAyIDIgNC4wMSAyIDYuNVoiIGZpbGw9IiM4RDk4QUEiLz4KPC9zdmc+Cg==\");background-repeat:no-repeat;background-position:1rem center;background-size:1.125rem 1.125rem;border-color:#E6E6E6;color:var(--tailwind-colors-neutral-500);border:1px solid var(--tailwind-colors-gray-200)}mi-search input[type=search]:-moz-placeholder-shown{padding-right:0.875rem}mi-search input[type=search]:placeholder-shown{padding-right:0.875rem}mi-search input[type=search]:focus{border-color:#3b82f6;box-shadow:0 0 0 2px #cfe0fc;}mi-search input[type=search][disabled]{pointer-events:none}mi-search input::-webkit-search-cancel-button{-webkit-appearance:none}mi-search input::-ms-clear{display:none}mi-search input::-moz-search-clear-button{-moz-appearance:none}mi-search button{position:absolute;right:0.875rem;top:50%;transform:translateY(-50%);width:1.25rem;height:1.25rem;background-color:#6b7280;border-radius:50%;padding:0;border-width:0;display:flex;align-items:center;justify-content:center}mi-search button:focus{outline:0}mi-search button svg{fill:white;width:0.625rem;height:0.625rem}";
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+const Search = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.results = createEvent(this, "results", 7);
+    this.cleared = createEvent(this, "cleared", 7);
+    this.componentRendered = createEvent(this, "componentRendered", 7);
+    this.shortInput = createEvent(this, "shortInput", 7);
+    this.changed = createEvent(this, "changed", 7);
+    /**
+     * Sets the prevention of the search.
+     */
+    this.preventSearch = false;
+    this.placeholder = '';
+    this.idAttribute = '';
+    this.dataAttributes = {};
+    this.mapsindoors = false;
+    this.google = false;
+    this.mapbox = false;
+    this.language = 'en';
+    this.miFields = 'name,description,aliases,categories,externalId';
+    this.miTake = undefined;
+    this.miSkip = undefined;
+    this.miOrder = undefined;
+    this.miCategories = undefined;
+    this.miNear = undefined;
+    this.miVenue = undefined;
+    this.gmCountryCode = undefined;
+    this.value = undefined;
+    this.disabled = false;
+    this.sessionToken = undefined;
+    this.userPosition = undefined;
+  }
+  valueChange(newValue) {
+    if (!newValue || !this.inputElement) {
+      return;
+    }
+    if (newValue !== this.inputElement.value) {
+      // If newValue is different from what is in the input element, we know it's set from outside the component.
+      this.inputElement.value = newValue;
+      if (!this.preventSearch) {
+        this.inputChanged();
+      }
+    }
+  }
+  /**
+   * Clear the input field.
+   */
+  async clear() {
+    this.inputElement.value = '';
+    this.value = '';
+    this.lastRequested = null;
+    this.cleared.emit();
+  }
+  /**
+   * Programmatically trigger the search.
+   */
+  triggerSearch() {
+    const inputValue = this.inputElement.value;
+    this.search(inputValue);
+  }
+  /**
+   * Sets text to be shown in the search field.
+   * Setting it will not perform a search.
+   */
+  setDisplayText(displayText) {
+    this.preventSearch = true;
+    this.inputElement.value = displayText;
+    this.value = displayText;
+    this.preventSearch = false;
+  }
+  /**
+   * Set focus on the input field.
+   * The preventScroll boolean is passed as true to prevent the browser
+   * from scrolling the document to bring the newly-focused element into view.
+   */
+  focusInput() {
+    this.inputElement.focus({ preventScroll: true });
+  }
+  /**
+   * Get hold of the search input field.
+   */
+  async getInputField() {
+    return this.inputElement;
+  }
+  /**
+   * Perform the search.
+   */
+  search(inputValue) {
+    Promise.all([
+      this.makeMapsIndoorsQuery(inputValue),
+      this.makeGooglePlacesQuery(inputValue),
+      this.getMapboxSearchResults(inputValue),
+    ])
+      .then(results => {
+      this.lastRequested = inputValue;
+      if (this.google) {
+        this.pushResults(results[0].concat(results[1]));
+      }
+      else if (this.mapbox && mapboxgl.accessToken) {
+        this.pushResults(results[0].concat(results[2]));
+      }
+      else {
+        this.pushResults(results[0]);
+      }
+    });
+  }
+  /**
+   * Handles incoming input change event, eg. input field value has changed.
+   * The function is debounced 500ms to avoid firing too many requests while typing.
+   */
+  inputChanged() {
+    const inputValue = this.inputElement.value;
+    this.value = inputValue; // reflect on value attribute
+    if (!this.preventSearch) {
+      if (inputValue.length < 2) {
+        this.lastRequested = null;
+        if (inputValue.length === 1) {
+          this.shortInput.emit();
+        }
+        else {
+          this.clear();
+        }
+        return;
+      }
+      if (inputValue.length > 1 && inputValue !== this.lastRequested) {
+        this.search(inputValue);
+      }
+      this.changed.emit();
+    }
+  }
+  /**
+   * Push the results via the results event.
+   * @param object[] Locations
+   */
+  pushResults(locations) {
+    this.results.emit(locations);
+  }
+  /**
+   * Make MapsIndoors locations request based on given search query.
+   * @param {string} query
+   * @return {Promise<any[]>}
+   */
+  makeMapsIndoorsQuery(query) {
+    if (!this.mapsindoors) {
+      return Promise.resolve([]);
+    }
+    // Transform miNear string attribute to object if it matches a latlng
+    let miNear;
+    if (this.miNear) {
+      miNear = this.miNear;
+      if (/^(-?\d+(\.\d+)?),\s*(-?\d+(\.\d+)?)$/.test(this.miNear)) {
+        const near = this.miNear.split(',');
+        miNear = { lat: parseFloat(near[0]), lng: parseFloat(near[1]) };
+      }
+    }
+    return mapsindoors.services.LocationsService.getLocations({
+      q: query.trim(),
+      fields: this.miFields,
+      take: this.miTake,
+      skip: this.miSkip,
+      orderBy: this.miOrder,
+      near: miNear,
+      venue: this.miVenue,
+      categories: this.miCategories
+    });
+  }
+  /**
+   * Make Google Places autocomplete suggestion request.
+   *
+   * @param {string} query
+   * @return {Promise<any>}
+   */
+  makeGooglePlacesQuery(query) {
+    if (this.google) {
+      if (!this.googleAutocompleteService) {
+        this.googleAutocompleteService = new google.maps.places.AutocompleteService();
+      }
+    }
+    else {
+      this.googleAutocompleteService = null;
+    }
+    if (!this.googleAutocompleteService) {
+      return Promise.resolve([]);
+    }
+    return new Promise((resolve) => {
+      const params = {
+        input: query,
+        language: this.language
+      };
+      if (this.gmCountryCode) {
+        params.componentRestrictions = { country: this.gmCountryCode };
+      }
+      this.googleAutocompleteService.getPlacePredictions(params, (results) => {
+        const places = (results || []).map((result) => ({
+          id: result.place_id,
+          type: 'Feature',
+          properties: {
+            type: 'google_places',
+            placeId: result.place_id,
+            name: result.structured_formatting.main_text,
+            subtitle: result.structured_formatting.secondary_text || '',
+            floor: 0
+          }
+        }));
+        resolve(places);
+      });
+    });
+  }
+  /**
+   * Get Mapbox Places results.
+   *
+   * @param {string} query
+   * @return {Promise<any>}
+   */
+  getMapboxSearchResults(query) {
+    if (this.mapbox && mapboxgl.accessToken) {
+      if (query) {
+        return new Promise((resolve) => {
+          const language = this.language.split('-')[0]; // Mapbox seemingly only supports the primary language subtag.
+          let url = `https://api.mapbox.com/search/searchbox/v1/suggest?q=${query}&session_token=${this.sessionToken}&access_token=${mapboxgl.accessToken}&language=${language}`;
+          if (this.userPosition) {
+            url = url.concat(`&proximity=${this.userPosition}`);
+          }
+          fetch(url)
+            .then((response) => {
+            return response.json();
+          })
+            .then((result) => {
+            const places = result.suggestions.map((result) => ({
+              id: result.mapbox_id,
+              type: 'Feature',
+              properties: {
+                type: 'mapbox_places',
+                placeId: result.mapbox_id,
+                name: result.name,
+                subtitle: result.place_formatted || '',
+                floor: 0
+              }
+            }));
+            resolve(places);
+          })
+            .catch(() => {
+            resolve([]);
+          });
+        });
+      }
+    }
+    else {
+      return Promise.resolve([]);
+    }
+  }
+  componentDidRender() {
+    if (this.dataAttributes) {
+      for (const key in this.dataAttributes) {
+        this.inputElement.setAttribute(key, this.dataAttributes[key]);
+      }
+    }
+    this.componentRendered.emit();
+  }
+  render() {
+    var _a;
+    return (h(Host, null, h("input", { disabled: this.disabled, id: this.idAttribute ? this.idAttribute : null, type: "search", ref: (el) => this.inputElement = el, onInput: () => this.inputChanged(), placeholder: this.placeholder, autocomplete: "off" }), ((_a = this.inputElement) === null || _a === void 0 ? void 0 : _a.value) &&
+      h("button", { type: "button", onClick: () => this.clear(), "aria-label": "Clear" }, h("svg", { width: "14", height: "14", viewBox: "0 0 14 14", fill: "none", xmlns: "http://www.w3.org/2000/svg" }, h("path", { d: "M14 1.41L12.59 0L7 5.59L1.41 0L0 1.41L5.59 7L0 12.59L1.41 14L7 8.41L12.59 14L14 12.59L8.41 7L14 1.41Z" })))));
+  }
+  static get watchers() { return {
+    "value": ["valueChange"]
+  }; }
+};
+__decorate([
+  Debounce(500)
+], Search.prototype, "inputChanged", null);
+Search.style = searchCss;
+
+export { Search as mi_search };