@senntyou/mint-ui/lib/components/MultiSelect.js

mint-ui extensions

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports["default"] = void 0;

/* script */
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
var __vue_script__ = {
  name: 'StMtMultiSelect',
  props: {
    value: {
      type: Boolean,
      required: !0,
      "default": !1
    },
    options: {
      type: Array,
      required: !0,
      "default": function _default() {
        return [];
      }
    },
    onSubmit: {
      type: Function,
      required: !0,
      "default": function _default() {}
    },
    onCancel: {
      type: Function,
      required: !1,
      "default": function _default() {}
    },
    okText: {
      type: String,
      required: !1,
      "default": 'OK'
    },
    cancelText: {
      type: String,
      required: !1,
      "default": 'Cancel'
    }
  },
  data: function data() {
    return {
      result: [],
      visible: false,
      // picker instance
      picker: undefined
    };
  },
  watch: {
    visible: function visible(val) {
      this.$emit('input', val);
    },
    value: function value(val) {
      this.visible = val;
    },
    options: function options() {
      this.result = [];
    }
  },
  methods: {
    submit: function submit() {
      this.visible = !1;
      this.onSubmit(this.result);
    },
    cancel: function cancel() {
      this.visible = !1;
      if (this.onCancel) this.onCancel();
    }
  }
};
/* template */

var __vue_render__ = function __vue_render__() {
  var _vm = this;

  var _h = _vm.$createElement;

  var _c = _vm._self._c || _h;

  return _c("div", {
    staticClass: "st-mt-picker st-mt-multi-select"
  }, [_c("mt-popup", {
    staticClass: "c-mint-popup",
    attrs: {
      position: "bottom"
    },
    model: {
      value: _vm.visible,
      callback: function callback($$v) {
        _vm.visible = $$v;
      },
      expression: "visible"
    }
  }, [_c("div", {
    staticClass: "picker-toolbar"
  }, [_c("span", {
    staticClass: "mint-datetime-action mint-datetime-cancel",
    on: {
      click: _vm.cancel
    }
  }, [_vm._v(_vm._s(_vm.cancelText))]), _vm._v(" "), _c("span", {
    staticClass: "mint-datetime-action mint-datetime-confirm",
    on: {
      click: _vm.submit
    }
  }, [_vm._v(_vm._s(_vm.okText))])]), _vm._v(" "), _c("div", {
    staticClass: "st-mt-content"
  }, [_c("mt-checklist", {
    attrs: {
      options: _vm.options
    },
    model: {
      value: _vm.result,
      callback: function callback($$v) {
        _vm.result = $$v;
      },
      expression: "result"
    }
  })], 1)])], 1);
};

var __vue_staticRenderFns__ = [];
__vue_render__._withStripped = true;
/* style */

var __vue_inject_styles__ = undefined;
/* scoped */

var __vue_scope_id__ = undefined;
/* module identifier */

var __vue_module_identifier__ = undefined;
/* functional template */

var __vue_is_functional_template__ = false;
/* component normalizer */

function __vue_normalize__(template, style, script, scope, functional, moduleIdentifier, createInjector, createInjectorSSR) {
  var component = (typeof script === 'function' ? script.options : script) || {}; // For security concerns, we use only base name in production mode.

  component.__file = "src/components/MultiSelect.vue";

  if (!component.render) {
    component.render = template.render;
    component.staticRenderFns = template.staticRenderFns;
    component._compiled = true;
    if (functional) component.functional = true;
  }

  component._scopeId = scope;

  if (false) {
    var hook;

    if (false) {
      // In SSR.
      hook = function hook(context) {
        // 2.3 injection
        context = context || // cached call
        this.$vnode && this.$vnode.ssrContext || // stateful
        this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext; // functional
        // 2.2 with runInNewContext: true

        if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
          context = __VUE_SSR_CONTEXT__;
        } // inject component styles


        if (style) {
          style.call(this, createInjectorSSR(context));
        } // register component module identifier for async chunk inference


        if (context && context._registeredComponents) {
          context._registeredComponents.add(moduleIdentifier);
        }
      }; // used by ssr in case component is cached and beforeCreate
      // never gets called


      component._ssrRegister = hook;
    } else if (style) {
      hook = function hook(context) {
        style.call(this, createInjector(context));
      };
    }

    if (hook !== undefined) {
      if (component.functional) {
        // register for functional component in vue file
        var originalRender = component.render;

        component.render = function renderWithStyleInjection(h, context) {
          hook.call(context);
          return originalRender(h, context);
        };
      } else {
        // inject component registration as beforeCreate hook
        var existing = component.beforeCreate;
        component.beforeCreate = existing ? [].concat(existing, hook) : [hook];
      }
    }
  }

  return component;
}
/* style inject */

/* style inject SSR */


var _default2 = __vue_normalize__({
  render: __vue_render__,
  staticRenderFns: __vue_staticRenderFns__
}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, undefined, undefined);

exports["default"] = _default2;