@vue-interface/select-field 0.9.17 → 0.11.1

package/dist/select-field.es.js

@@ -0,0 +1,780 @@
+function _typeof(obj) {
+  "@babel/helpers - typeof";
+  return _typeof = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(obj2) {
+    return typeof obj2;
+  } : function(obj2) {
+    return obj2 && typeof Symbol == "function" && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
+  }, _typeof(obj);
+}
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor)
+      descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps)
+    _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps)
+    _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf2(o2, p2) {
+    o2.__proto__ = p2;
+    return o2;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct)
+    return false;
+  if (Reflect.construct.sham)
+    return false;
+  if (typeof Proxy === "function")
+    return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct;
+  } else {
+    _construct = function _construct2(Parent2, args2, Class2) {
+      var a = [null];
+      a.push.apply(a, args2);
+      var Constructor = Function.bind.apply(Parent2, a);
+      var instance = new Constructor();
+      if (Class2)
+        _setPrototypeOf(instance, Class2.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr))
+    return arr;
+}
+function _iterableToArrayLimit(arr, i) {
+  var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+  if (_i == null)
+    return;
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _s, _e;
+  try {
+    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i)
+        break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null)
+        _i["return"]();
+    } finally {
+      if (_d)
+        throw _e;
+    }
+  }
+  return _arr;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o)
+    return;
+  if (typeof o === "string")
+    return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor)
+    n = o.constructor.name;
+  if (n === "Map" || n === "Set")
+    return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+    return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length)
+    len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++)
+    arr2[i] = arr[i];
+  return arr2;
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+var _assign = function __assign() {
+  _assign = Object.assign || function __assign22(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) {
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+      }
+    }
+    return t;
+  };
+  return _assign.apply(this, arguments);
+};
+function lowerCase$1(str) {
+  return str.toLowerCase();
+}
+var DEFAULT_SPLIT_REGEXP$1 = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+var DEFAULT_STRIP_REGEXP$1 = /[^A-Z0-9]+/gi;
+function noCase$1(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP$1 : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP$1 : _b, _c = options.transform, transform = _c === void 0 ? lowerCase$1 : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
+  var result = replace$1(replace$1(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  var start = 0;
+  var end = result.length;
+  while (result.charAt(start) === "\0") {
+    start++;
+  }
+  while (result.charAt(end - 1) === "\0") {
+    end--;
+  }
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace$1(input, re, value) {
+  if (re instanceof RegExp)
+    return input.replace(re, value);
+  return re.reduce(function(input2, re2) {
+    return input2.replace(re2, value);
+  }, input);
+}
+function dotCase$1(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return noCase$1(input, _assign({
+    delimiter: "."
+  }, options));
+}
+function paramCase$1(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return dotCase$1(input, _assign({
+    delimiter: "-"
+  }, options));
+}
+var ComponentRegistry = /* @__PURE__ */ function() {
+  function ComponentRegistry2() {
+    var _this = this;
+    var components = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    _classCallCheck(this, ComponentRegistry2);
+    this.components = {};
+    Object.entries(components).forEach(function(_ref) {
+      var _ref2 = _slicedToArray(_ref, 2), key = _ref2[0], value = _ref2[1];
+      _this.register(key, value);
+    });
+  }
+  _createClass(ComponentRegistry2, [{
+    key: "validate",
+    value: function validate(value) {
+      if (_typeof(value) === "object" || typeof value === "function") {
+        return value;
+      }
+      throw new Error("Invalid data type `".concat(_typeof(value), "`. Should be type `object` or `function`."));
+    }
+  }, {
+    key: "get",
+    value: function get(name) {
+      var match = this.components[name = paramCase$1(name)];
+      if (match) {
+        return match;
+      }
+      throw new Error('"'.concat(name, '" has not been registered yet!'));
+    }
+  }, {
+    key: "register",
+    value: function register(name, value) {
+      var _this2 = this;
+      if (_typeof(name) === "object") {
+        Object.entries(name).forEach(function(_ref3) {
+          var _ref4 = _slicedToArray(_ref3, 2), name2 = _ref4[0], module = _ref4[1];
+          _this2.register(paramCase$1(name2), module);
+        });
+        return this;
+      }
+      this.components[paramCase$1(name)] = this.validate(value);
+      return this;
+    }
+  }, {
+    key: "remove",
+    value: function remove(name) {
+      delete this.components[paramCase$1(name)];
+      return this;
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.components = {};
+      return this;
+    }
+  }]);
+  return ComponentRegistry2;
+}();
+function factory() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  return _construct(ComponentRegistry, args);
+}
+const registry = factory();
+var render$1 = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", { staticClass: "activity-indicator", class: _vm.classes, style: _vm.style }, [_c("div", { staticClass: "activity-indicator-content" }, [_c(_vm.component, { tag: "component", staticClass: "mx-auto" }), _vm.label ? _c("div", { staticClass: "activity-indicator-label" }, [_vm._v(" " + _vm._s(_vm.label) + " ")]) : _vm._e()], 1)]);
+};
+var staticRenderFns$1 = [];
+var ActivityIndicator_vue_vue_type_style_index_0_lang = "";
+function normalizeComponent(scriptExports, render2, staticRenderFns2, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
+  var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
+  if (render2) {
+    options.render = render2;
+    options.staticRenderFns = staticRenderFns2;
+    options._compiled = true;
+  }
+  if (functionalTemplate) {
+    options.functional = true;
+  }
+  if (scopeId) {
+    options._scopeId = "data-v-" + scopeId;
+  }
+  var hook;
+  if (moduleIdentifier) {
+    hook = function(context) {
+      context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
+      if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
+        context = __VUE_SSR_CONTEXT__;
+      }
+      if (injectStyles) {
+        injectStyles.call(this, context);
+      }
+      if (context && context._registeredComponents) {
+        context._registeredComponents.add(moduleIdentifier);
+      }
+    };
+    options._ssrRegister = hook;
+  } else if (injectStyles) {
+    hook = shadowMode ? function() {
+      injectStyles.call(this, (options.functional ? this.parent : this).$root.$options.shadowRoot);
+    } : injectStyles;
+  }
+  if (hook) {
+    if (options.functional) {
+      options._injectStyles = hook;
+      var originalRender = options.render;
+      options.render = function renderWithStyleInjection(h, context) {
+        hook.call(context);
+        return originalRender(h, context);
+      };
+    } else {
+      var existing = options.beforeCreate;
+      options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+    }
+  }
+  return {
+    exports: scriptExports,
+    options
+  };
+}
+function unit(value, uom = "px") {
+  return value !== null && value !== void 0 && value !== false && isFinite(value) ? `${value}${uom}` : value;
+}
+const __vue2_script$1 = {
+  name: "ActivityIndicator",
+  props: {
+    absolute: Boolean,
+    center: Boolean,
+    label: String,
+    size: {
+      type: String,
+      default: "md"
+    },
+    registry: {
+      type: ComponentRegistry,
+      default() {
+        return registry;
+      }
+    },
+    type: {
+      type: String,
+      required: true
+    },
+    height: [String, Number],
+    maxHeight: [String, Number],
+    minHeight: [String, Number],
+    width: [String, Number],
+    maxWidth: [String, Number],
+    minWidth: [String, Number]
+  },
+  computed: {
+    classes() {
+      return {
+        "activity-indicator-center": this.center,
+        "activity-indicator-absolute": this.absolute,
+        [this.size && `activity-indicator-${this.size}`]: !!this.size
+      };
+    },
+    style() {
+      return {
+        width: unit(this.width),
+        maxWidth: unit(this.maxWidth),
+        minWidth: unit(this.minWidth),
+        height: unit(this.height),
+        maxHeight: unit(this.maxHeight),
+        minHeight: unit(this.minHeight)
+      };
+    },
+    component() {
+      return () => {
+        const component = registry.get(this.type);
+        if (component instanceof Promise) {
+          return component;
+        }
+        if (typeof component === "function") {
+          return component();
+        }
+        return Promise.resolve(component);
+      };
+    }
+  }
+};
+const __cssModules$1 = {};
+var __component__$1 = /* @__PURE__ */ normalizeComponent(__vue2_script$1, render$1, staticRenderFns$1, false, __vue2_injectStyles$1, null, null, null);
+function __vue2_injectStyles$1(context) {
+  for (let o in __cssModules$1) {
+    this[o] = __cssModules$1[o];
+  }
+}
+var ActivityIndicator = /* @__PURE__ */ function() {
+  return __component__$1.exports;
+}();
+var Chase_vue_vue_type_style_index_0_lang = "";
+var CircleFade_vue_vue_type_style_index_0_lang = "";
+var CircleOrbit_vue_vue_type_style_index_0_lang = "";
+var CircleTrail_vue_vue_type_style_index_0_lang = "";
+var Dots_vue_vue_type_style_index_0_lang = "";
+var DoublePulse_vue_vue_type_style_index_0_lang = "";
+var Facebook_vue_vue_type_style_index_0_lang = "";
+var Grid_vue_vue_type_style_index_0_lang = "";
+var Pulse_vue_vue_type_style_index_0_lang = "";
+var Spinner_vue_vue_type_style_index_0_lang = "";
+var Spotify_vue_vue_type_style_index_0_lang = "";
+var Square_vue_vue_type_style_index_0_lang = "";
+var SquareFold_vue_vue_type_style_index_0_lang = "";
+var SquareOrbit_vue_vue_type_style_index_0_lang = "";
+var Shadowable = {
+  props: {
+    dropShadow: [Boolean, String],
+    dropShadowableClassPrefix: {
+      type: String,
+      default: "drop-shadow"
+    },
+    shadow: [Boolean, String],
+    shadowableClassPrefix: {
+      type: String,
+      default: "shadow"
+    }
+  },
+  computed: {
+    shadowableClass() {
+      const dropShadowClassName = this.dropShadow === true ? "" : this.dropShadow && `-${this.dropShadow}`;
+      const shadowClassName = this.shadow === true ? "" : this.shadow && `-${this.shadow}`;
+      return {
+        [`${this.dropShadowableClassPrefix}${dropShadowClassName}`]: !!this.dropShadow,
+        [`${this.shadowableClassPrefix}${shadowClassName}`]: !!this.shadow
+      };
+    }
+  }
+};
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+var __assign2 = function() {
+  __assign2 = Object.assign || function __assign3(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p))
+          t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign2.apply(this, arguments);
+};
+function lowerCase(str) {
+  return str.toLowerCase();
+}
+var DEFAULT_SPLIT_REGEXP = [/([a-z0-9])([A-Z])/g, /([A-Z])([A-Z][a-z])/g];
+var DEFAULT_STRIP_REGEXP = /[^A-Z0-9]+/gi;
+function noCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _a = options.splitRegexp, splitRegexp = _a === void 0 ? DEFAULT_SPLIT_REGEXP : _a, _b = options.stripRegexp, stripRegexp = _b === void 0 ? DEFAULT_STRIP_REGEXP : _b, _c = options.transform, transform = _c === void 0 ? lowerCase : _c, _d = options.delimiter, delimiter = _d === void 0 ? " " : _d;
+  var result = replace(replace(input, splitRegexp, "$1\0$2"), stripRegexp, "\0");
+  var start = 0;
+  var end = result.length;
+  while (result.charAt(start) === "\0")
+    start++;
+  while (result.charAt(end - 1) === "\0")
+    end--;
+  return result.slice(start, end).split("\0").map(transform).join(delimiter);
+}
+function replace(input, re, value) {
+  if (re instanceof RegExp)
+    return input.replace(re, value);
+  return re.reduce(function(input2, re2) {
+    return input2.replace(re2, value);
+  }, input);
+}
+function dotCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return noCase(input, __assign2({
+    delimiter: "."
+  }, options));
+}
+function paramCase(input, options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return dotCase(input, __assign2({
+    delimiter: "-"
+  }, options));
+}
+function prefix(key, value, delimeter = "-") {
+  const string = value.toString().replace(new RegExp(`^${key}${delimeter}?`), "");
+  return [paramCase(string), key].filter((value2) => !!value2).join(delimeter);
+}
+function isObject(subject) {
+  return !Array.isArray(subject) && typeof subject === "object";
+}
+var FormControl = {
+  directives: {
+    bindEvents: {
+      bind(el, binding, vnode) {
+        el.addEventListener("focus", () => {
+          vnode.context.hasFocus = true;
+        });
+        el.addEventListener("blur", () => {
+          vnode.context.hasFocus = false;
+        });
+        el.addEventListener(el.tagName === "SELECT" ? "change" : "input", (e) => {
+          vnode.context.isEmpty = !el.value;
+          vnode.context.currentValue = el.value;
+        });
+        vnode.context.hasChanged = !!el.value;
+        vnode.context.bindEvents.forEach((name) => {
+          el.addEventListener(name, (event) => {
+            vnode.context.$emit(name, event);
+          });
+        });
+        if (el.tagName === "SELECT") {
+          const opt = el.querySelector('[value=""]');
+          if (opt && opt.value === el.value) {
+            vnode.context.defaultEmpty = true;
+          }
+        }
+      }
+    }
+  },
+  mixins: [Shadowable],
+  inheritAttrs: false,
+  props: {
+    activity: {
+      type: Boolean,
+      default: false
+    },
+    bindEvents: {
+      type: Array,
+      default() {
+        return ["focus", "blur", "change", "click", "keypress", "keyup", "keydown", "progress", "paste"];
+      }
+    },
+    componentName: {
+      type: String,
+      default() {
+        return this.$options.name;
+      }
+    },
+    defaultControlClass: {
+      type: String,
+      default: "form-control"
+    },
+    defaultValue: {
+      default: null
+    },
+    error: [String, Array, Boolean],
+    errors: {
+      type: [Array, Object, Boolean],
+      default() {
+        return {};
+      }
+    },
+    feedback: [String, Array],
+    group: {
+      type: Boolean,
+      default: true
+    },
+    helpText: [Number, String],
+    hideLabel: Boolean,
+    indicator: {
+      type: String,
+      default: "spinner"
+    },
+    indicatorSize: String,
+    inline: Boolean,
+    invalid: Boolean,
+    label: [Number, String],
+    labelClass: {
+      type: [Object, String],
+      default: "form-label"
+    },
+    pill: Boolean,
+    plaintext: Boolean,
+    size: String,
+    spacing: String,
+    valid: Boolean,
+    value: {
+      default: null
+    }
+  },
+  data() {
+    return {
+      currentValue: this.value || this.defaultValue,
+      defaultEmpty: false,
+      hasChanged: false,
+      hasFocus: false,
+      isEmpty: !(this.value || this.defaultValue)
+    };
+  },
+  computed: {
+    id() {
+      return this.$attrs.id || this.$attrs.name;
+    },
+    controlAttributes() {
+      return Object.keys(this.$attrs).concat([["id", this.id], ["class", this.controlClasses]]).reduce((carry, key) => {
+        if (Array.isArray(key)) {
+          carry[key[0]] = key[1];
+        } else {
+          carry[key] = this[key] || this.$attrs[key];
+        }
+        return carry;
+      }, {});
+    },
+    controlClass() {
+      return this.defaultControlClass;
+    },
+    controlSizeClass() {
+      return prefix(this.size, this.controlClass);
+    },
+    formGroupClasses() {
+      return {
+        [paramCase(this.componentName)]: !!this.componentName,
+        [this.size && prefix(this.size, this.componentName)]: !!this.size,
+        "default-empty": this.defaultEmpty,
+        "form-group": this.group,
+        [this.size && prefix(this.size, "form-group")]: !!this.size,
+        "has-activity": this.activity,
+        "has-changed": this.hasChanged,
+        "has-focus": this.hasFocus,
+        "has-icon": !!this.$slots.icon,
+        "is-empty": this.isEmpty,
+        "is-invalid": !!(this.invalid || this.invalidFeedback),
+        "is-valid": !!(this.valid || this.validFeedback)
+      };
+    },
+    controlClasses() {
+      return Object.assign({
+        [this.controlClass]: !!this.controlClass,
+        [this.controlSizeClass]: !!this.controlSizeClass,
+        "form-control-icon": !!this.$slots.icon,
+        "is-valid": !!(this.valid || this.validFeedback),
+        "is-invalid": !!(this.invalid || this.invalidFeedback),
+        [this.pillClasses]: this.pill,
+        [this.plaintextClass]: this.plaintext,
+        [this.spacing]: !!this.spacing
+      }, this.shadowableClass);
+    },
+    hasDefaultSlot() {
+      return !!this.$slots.default;
+    },
+    invalidFeedback() {
+      if (this.error === "") {
+        return null;
+      }
+      if (this.error) {
+        return this.error;
+      }
+      const errors = this.getFieldErrors();
+      return Array.isArray(errors) ? errors.filter((error) => {
+        return error && typeof error === "string";
+      }).join("<br>") : errors;
+    },
+    pillClasses() {
+      return "rounded rounded-pill";
+    },
+    plaintextClass() {
+      return "form-control-plaintext";
+    },
+    validFeedback() {
+      return Array.isArray(this.feedback) ? this.feedback.join("<br>") : this.feedback;
+    }
+  },
+  watch: {
+    hasFocus() {
+      if (this.shouldChangeOnFocus()) {
+        this.hasChanged = true;
+      }
+    },
+    value(value) {
+      this.currentValue = value;
+    },
+    currentValue() {
+      this.hasChanged = true;
+    },
+    defaultEmpty() {
+      this.hasChanged = true;
+    }
+  },
+  mounted() {
+    if (this.value === null && this.defaultValue !== null) {
+      this.$emit("input", this.defaultValue);
+    }
+  },
+  methods: {
+    blur() {
+      if (this.getInputField()) {
+        this.getInputField().blur();
+      }
+    },
+    focus() {
+      if (this.getInputField()) {
+        this.getInputField().focus();
+      }
+    },
+    getInputField() {
+      return this.$el.querySelector(".form-control, input, select, textarea");
+    },
+    getFieldErrors() {
+      let errors = this.error || this.errors;
+      if (isObject(this.errors)) {
+        errors = this.errors[this.$attrs.name || this.$attrs.id];
+      }
+      return !errors || Array.isArray(errors) || isObject(errors) ? errors : [errors];
+    },
+    shouldChangeOnFocus() {
+      return !this.getInputField().readOnly;
+    },
+    onInput(e) {
+      this.$emit("input", e.target.value);
+      this.$emit("update:value", e.target.value);
+    }
+  }
+};
+var render = function() {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _c("div", { class: _vm.formGroupClasses }, [_vm._t("label", function() {
+    return [_vm.label ? _c("label", { ref: "label", class: _vm.labelClass, attrs: { "for": _vm.id }, domProps: { "innerHTML": _vm._s(_vm.label) }, on: { "click": _vm.focus } }) : _vm._e()];
+  }), _c("div", { staticClass: "form-group-inner" }, [_vm._t("control", function() {
+    var _obj;
+    return [_vm.$slots.icon ? _c("div", { staticClass: "form-group-inner-icon", on: { "click": _vm.focus } }, [_vm._t("icon")], 2) : _vm._e(), _c("select", _vm._b({ directives: [{ name: "bind-events", rawName: "v-bind-events" }], ref: "field", domProps: { "value": _vm.currentValue }, on: { "input": _vm.onInput } }, "select", Object.assign((_obj = {}, _obj["disabled"] = _vm.$attrs.readonly, _obj), _vm.controlAttributes), false), [_vm._t("default")], 2)];
+  }), _vm._t("activity", function() {
+    return [_c("transition", { attrs: { "name": "select-field-fade" } }, [_vm.activity ? _c("activity-indicator", { key: "activity", ref: "activity", attrs: { "type": _vm.indicator, "size": _vm.indicatorSize || _vm.size } }) : _vm._e()], 1)];
+  })], 2), _vm._t("feedback", function() {
+    return [_vm.invalidFeedback ? _c("div", { staticClass: "invalid-feedback", attrs: { "invalid": "" }, domProps: { "innerHTML": _vm._s(_vm.invalidFeedback) } }) : _vm.validFeedback ? _c("div", { staticClass: "valid-feedback", attrs: { "valid": "" }, domProps: { "innerHTML": _vm._s(_vm.validFeedback) } }) : _vm._e()];
+  }), _vm._t("help", function() {
+    return [_vm.helpText ? _c("small", { ref: "help" }, [_vm._v(" " + _vm._s(_vm.helpText) + " ")]) : _vm._e()];
+  })], 2);
+};
+var staticRenderFns = [];
+var SelectField_vue_vue_type_style_index_0_lang = "";
+const __vue2_script = {
+  name: "SelectField",
+  components: {
+    ActivityIndicator
+  },
+  mixins: [
+    FormControl
+  ],
+  props: {
+    defaultControlClass: {
+      type: String,
+      default: "form-select"
+    }
+  },
+  computed: {
+    controlClass() {
+      return this.plaintext ? `${this.defaultControlClass}-plaintext` : this.defaultControlClass;
+    }
+  },
+  mounted() {
+    const selected = this.$el.querySelector("[selected]");
+    if (selected) {
+      this.currentValue = selected.value;
+      this.$emit("input", this.currentValue);
+      this.$emit("update:value", this.currentValue);
+    }
+  },
+  methods: {
+    shouldChangeOnFocus() {
+      return false;
+    }
+  }
+};
+const __cssModules = {};
+var __component__ = /* @__PURE__ */ normalizeComponent(__vue2_script, render, staticRenderFns, false, __vue2_injectStyles, null, null, null);
+function __vue2_injectStyles(context) {
+  for (let o in __cssModules) {
+    this[o] = __cssModules[o];
+  }
+}
+var SelectField = /* @__PURE__ */ function() {
+  return __component__.exports;
+}();
+export { SelectField };