vue-class-component/dist/vue-class-component.global.js

/**
  * vue-class-component v8.0.0-beta.4
  * (c) 2015-present Evan You
  * @license MIT
  */
var VueClassComponent = (function (exports, vue) {
  'use strict';

  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);
    return Constructor;
  }

  function _defineProperty(obj, key, value) {
    if (key in obj) {
      Object.defineProperty(obj, key, {
        value: value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    } else {
      obj[key] = value;
    }

    return obj;
  }

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread2(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(Object(source), true).forEach(function (key) {
          _defineProperty(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(Object(source)).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) _setPrototypeOf(subClass, superClass);
  }

  function _getPrototypeOf(o) {
    _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  function _setPrototypeOf(o, p) {
    _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    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 {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _construct(Parent, args, Class) {
    if (_isNativeReflectConstruct()) {
      _construct = Reflect.construct;
    } else {
      _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) _setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }

    return _construct.apply(null, arguments);
  }

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  function _possibleConstructorReturn(self, call) {
    if (call && (typeof call === "object" || typeof call === "function")) {
      return call;
    }

    return _assertThisInitialized(self);
  }

  function _createSuper(Derived) {
    var hasNativeReflectConstruct = _isNativeReflectConstruct();

    return function _createSuperInternal() {
      var Super = _getPrototypeOf(Derived),
          result;

      if (hasNativeReflectConstruct) {
        var NewTarget = _getPrototypeOf(this).constructor;

        result = Reflect.construct(Super, arguments, NewTarget);
      } else {
        result = Super.apply(this, arguments);
      }

      return _possibleConstructorReturn(this, result);
    };
  }

  function _toConsumableArray(arr) {
    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
  }

  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
  }

  function _iterableToArray(iter) {
    if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
  }

  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 _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
  }

  function defineGetter(obj, key, getter) {
    Object.defineProperty(obj, key, {
      get: getter,
      enumerable: false,
      configurable: true
    });
  }

  function defineProxy(proxy, key, target) {
    Object.defineProperty(proxy, key, {
      get: function get() {
        return target[key].value;
      },
      set: function set(value) {
        target[key].value = value;
      },
      enumerable: true,
      configurable: true
    });
  }

  function getSuper(Ctor) {
    var superProto = Object.getPrototypeOf(Ctor.prototype);

    if (!superProto) {
      return undefined;
    }

    return superProto.constructor;
  }

  var VueImpl = /*#__PURE__*/function () {
    function VueImpl(props, ctx) {
      var _this = this;

      _classCallCheck(this, VueImpl);

      defineGetter(this, '$props', function () {
        return props;
      });
      defineGetter(this, '$attrs', function () {
        return ctx.attrs;
      });
      defineGetter(this, '$slots', function () {
        return ctx.slots;
      });
      defineGetter(this, '$emit', function () {
        return ctx.emit;
      });
      Object.keys(props).forEach(function (key) {
        Object.defineProperty(_this, key, {
          enumerable: false,
          configurable: true,
          writable: true,
          value: props[key]
        });
      });
    }
    /** @internal */


    _createClass(VueImpl, null, [{
      key: "__vccExtend",
      value: function __vccExtend(options) {
        options.mixins = options.mixins || [];
        options.mixins.push(this.__vccOpts);
      }
      /** @internal */

    }, {
      key: "registerHooks",
      value: function registerHooks(keys) {
        var _this$__vccHooks;

        (_this$__vccHooks = this.__vccHooks).push.apply(_this$__vccHooks, _toConsumableArray(keys));
      }
    }, {
      key: "props",
      value: function props(Props) {
        var propsMeta = new Props();
        var props = {};
        Object.keys(propsMeta).forEach(function (key) {
          var meta = propsMeta[key];
          props[key] = meta !== null && meta !== void 0 ? meta : null;
        });

        var PropsMixin = /*#__PURE__*/function (_this2) {
          _inherits(PropsMixin, _this2);

          var _super = _createSuper(PropsMixin);

          function PropsMixin() {
            _classCallCheck(this, PropsMixin);

            return _super.apply(this, arguments);
          }

          _createClass(PropsMixin, null, [{
            key: "__vccExtend",
            value: function __vccExtend(options) {
              options.props = props;
            }
          }]);

          return PropsMixin;
        }(this);

        return PropsMixin;
      }
    }, {
      key: "__vccOpts",
      get: function get() {
        // Early return if `this` is base class as it does not have any options
        if (this === Vue) {
          return {};
        }

        var cache = this.hasOwnProperty('__vccCache') && this.__vccCache;

        if (cache) {
          return cache;
        }

        var Ctor = this; // If the options are provided via decorator use it as a base

        var options = this.__vccCache = this.hasOwnProperty('__vccBase') ? _objectSpread2({}, this.__vccBase) : {}; // Handle super class options

        var Super = getSuper(Ctor);

        if (Super) {
          Super.__vccExtend(options);
        }

        options.methods = _objectSpread2({}, options.methods);
        options.computed = _objectSpread2({}, options.computed);
        var proto = Ctor.prototype;
        Object.getOwnPropertyNames(proto).forEach(function (key) {
          if (key === 'constructor') {
            return;
          } // hooks


          if (Ctor.__vccHooks.indexOf(key) > -1) {
            options[key] = proto[key];
            return;
          }

          var descriptor = Object.getOwnPropertyDescriptor(proto, key); // methods

          if (typeof descriptor.value === 'function') {
            options.methods[key] = descriptor.value;
            return;
          } // computed properties


          if (descriptor.get || descriptor.set) {
            options.computed[key] = {
              get: descriptor.get,
              set: descriptor.set
            };
            return;
          }
        });

        options.setup = function (props, ctx) {
          var _promise;

          var data = new Ctor(props, ctx);
          var dataKeys = Object.keys(data);
          var plainData = {};
          var promise = null; // Initialize reactive data and convert constructor `this` to a proxy

          dataKeys.forEach(function (key) {
            // Skip if the value is undefined not to make it reactive.
            // If the value has `__s`, it's a value from `setup` helper, proceed it later.
            if (data[key] === undefined || data[key] && data[key].__s) {
              return;
            }

            plainData[key] = vue.ref(data[key]);
            defineProxy(data, key, plainData);
          }); // Invoke composition functions

          dataKeys.forEach(function (key) {
            if (data[key] && data[key].__s) {
              var setupState = data[key].__s();

              if (setupState instanceof Promise) {
                if (!promise) {
                  promise = Promise.resolve(plainData);
                }

                promise = promise.then(function () {
                  return setupState.then(function (value) {
                    plainData[key] = vue.proxyRefs(value);
                    return plainData;
                  });
                });
              } else {
                plainData[key] = vue.proxyRefs(setupState);
              }
            }
          });
          return (_promise = promise) !== null && _promise !== void 0 ? _promise : plainData;
        };

        var decorators = this.hasOwnProperty('__vccDecorators') && this.__vccDecorators;

        if (decorators) {
          decorators.forEach(function (fn) {
            return fn(options);
          });
        } // from Vue Loader


        var injections = ['render', 'ssrRender', '__file', '__cssModules', '__scopeId', '__hmrId'];
        injections.forEach(function (key) {
          if (Ctor[key]) {
            options[key] = Ctor[key];
          }
        });
        return options;
      }
    }]);

    return VueImpl;
  }();
  /** @internal */


  VueImpl.__vccHooks = ['data', 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUnmount', 'unmounted', 'beforeUpdate', 'updated', 'activated', 'deactivated', 'render', 'errorCaptured', 'serverPrefetch'];
  var Vue = VueImpl;

  function Options(options) {
    return function (Component) {
      Component.__vccBase = options;
      return Component;
    };
  }
  function createDecorator(factory) {
    return function (target, key, index) {
      var Ctor = typeof target === 'function' ? target : target.constructor;

      if (!Ctor.__vccDecorators) {
        Ctor.__vccDecorators = [];
      }

      if (typeof index !== 'number') {
        index = undefined;
      }

      Ctor.__vccDecorators.push(function (options) {
        return factory(options, key, index);
      });
    };
  }
  function mixins() {
    for (var _len = arguments.length, Ctors = new Array(_len), _key = 0; _key < _len; _key++) {
      Ctors[_key] = arguments[_key];
    }

    return /*#__PURE__*/function (_Vue) {
      _inherits(MixedVue, _Vue);

      var _super = _createSuper(MixedVue);

      _createClass(MixedVue, null, [{
        key: "__vccExtend",
        value: function __vccExtend(options) {
          Ctors.forEach(function (Ctor) {
            return Ctor.__vccExtend(options);
          });
        }
      }]);

      function MixedVue() {
        var _this;

        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        _classCallCheck(this, MixedVue);

        _this = _super.call.apply(_super, [this].concat(args));
        Ctors.forEach(function (Ctor) {
          var data = _construct(Ctor, args);

          Object.keys(data).forEach(function (key) {
            _this[key] = data[key];
          });
        });
        return _this;
      }

      return MixedVue;
    }(Vue);
  }
  function setup(setupFn) {
    // Hack to delay the invocation of setup function.
    // Will be called after dealing with class properties.
    return {
      __s: setupFn
    };
  }

  // Actual implementation
  function prop(options) {
    return options;
  }

  exports.Options = Options;
  exports.Vue = Vue;
  exports.createDecorator = createDecorator;
  exports.mixins = mixins;
  exports.prop = prop;
  exports.setup = setup;

  return exports;

}({}, Vue));