vue-class-component.esm.js

/**
  * vue-class-component v7.2.6
  * (c) 2015-present Evan You
  * @license MIT
  */
import Vue from 'vue';

function _typeof(obj) {
  "@babel/helpers - typeof";

  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
    _typeof = function (obj) {
      return typeof obj;
    };
  } else {
    _typeof = function (obj) {
      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
    };
  }

  return _typeof(obj);
}

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 _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.");
}

// The rational behind the verbose Reflect-feature check below is the fact that there are polyfills
// which add an implementation for Reflect.defineMetadata but not for Reflect.getOwnMetadataKeys.
// Without this check consumers will encounter hard to track down runtime errors.
function reflectionIsSupported() {
  return typeof Reflect !== 'undefined' && Reflect.defineMetadata && Reflect.getOwnMetadataKeys;
}
function copyReflectionMetadata(to, from) {
  forwardMetadata(to, from);
  Object.getOwnPropertyNames(from.prototype).forEach(function (key) {
    forwardMetadata(to.prototype, from.prototype, key);
  });
  Object.getOwnPropertyNames(from).forEach(function (key) {
    forwardMetadata(to, from, key);
  });
}

function forwardMetadata(to, from, propertyKey) {
  var metaKeys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);
  metaKeys.forEach(function (metaKey) {
    var metadata = propertyKey ? Reflect.getOwnMetadata(metaKey, from, propertyKey) : Reflect.getOwnMetadata(metaKey, from);

    if (propertyKey) {
      Reflect.defineMetadata(metaKey, metadata, to, propertyKey);
    } else {
      Reflect.defineMetadata(metaKey, metadata, to);
    }
  });
}

var fakeArray = {
  __proto__: []
};
var hasProto = fakeArray instanceof Array;
function createDecorator(factory) {
  return function (target, key, index) {
    var Ctor = typeof target === 'function' ? target : target.constructor;

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

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

    Ctor.__decorators__.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 Vue.extend({
    mixins: Ctors
  });
}
function isPrimitive(value) {
  var type = _typeof(value);

  return value == null || type !== 'object' && type !== 'function';
}
function warn(message) {
  if (typeof console !== 'undefined') {
    console.warn('[vue-class-component] ' + message);
  }
}

function collectDataFromConstructor(vm, Component) {
  // override _init to prevent to init as Vue instance
  var originalInit = Component.prototype._init;

  Component.prototype._init = function () {
    var _this = this;

    // proxy to actual vm
    var keys = Object.getOwnPropertyNames(vm); // 2.2.0 compat (props are no longer exposed as self properties)

    if (vm.$options.props) {
      for (var key in vm.$options.props) {
        if (!vm.hasOwnProperty(key)) {
          keys.push(key);
        }
      }
    }

    keys.forEach(function (key) {
      Object.defineProperty(_this, key, {
        get: function get() {
          return vm[key];
        },
        set: function set(value) {
          vm[key] = value;
        },
        configurable: true
      });
    });
  }; // should be acquired class property values


  var data = new Component(); // restore original _init to avoid memory leak (#209)

  Component.prototype._init = originalInit; // create plain data object

  var plainData = {};
  Object.keys(data).forEach(function (key) {
    if (data[key] !== undefined) {
      plainData[key] = data[key];
    }
  });

  if (process.env.NODE_ENV !== 'production') {
    if (!(Component.prototype instanceof Vue) && Object.keys(plainData).length > 0) {
      warn('Component class must inherit Vue or its descendant class ' + 'when class property is used.');
    }
  }

  return plainData;
}

var $internalHooks = ['data', 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeDestroy', 'destroyed', 'beforeUpdate', 'updated', 'activated', 'deactivated', 'render', 'errorCaptured', 'serverPrefetch' // 2.6
]; // BIFIT: Список хуков, для которых будет работать правильно наследование. Поддержка остальных может потребовать лезть в кишки Vue

var $keepHooks = ['beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeDestroy', 'destroyed', 'beforeUpdate', 'updated', 'activated', 'deactivated'];
function componentFactory(Component) {
  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  options.name = options.name || Component._componentTag || Component.name;
  var proto = Component.prototype; // BIFIT: ---------- start

  var protoMethods = [];
  var protoGetAndSets = [];
  var protoHooks = [];
  var protoMarker = Symbol(); // BIFIT: ---------- end

  Object.getOwnPropertyNames(proto).forEach(function (key) {
    if (key === 'constructor') {
      return;
    }

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

    if ($internalHooks.indexOf(key) > -1) {
      if ($keepHooks.indexOf(key) > -1 && descriptor.value !== void 0 && typeof descriptor.value === 'function') {
        // Этот метод используется как метод, а не хук
        proto[key] = function () {
          descriptor.value.call(this);
        }; // BIFIT: Этот метод будет вызывать Vue для хуков жизненного цикла


        var methodHiddenAccess = Symbol();

        proto[methodHiddenAccess] = function () {
          // BIFIT: Vue вызывает хуки один за одним у всех наследников
          // BIFIT: Только, если совпадает владелец функции и место декларации функции
          if (this.$marker === protoMarker) {
            descriptor.value.call(this);
          } // BIFIT: Только, если это декларация хука на самом верху цепочки наследования
          else if (this.__proto__ && !this.__proto__.hasOwnProperty(key)) {
              var startProto = this.__proto__;

              while (startProto && !startProto.hasOwnProperty(key)) {
                startProto = startProto.__proto__;
              }

              if (startProto && startProto.$marker === protoMarker) {
                descriptor.value.call(this);
              }
            }
        };

        protoHooks.push({
          key: key,
          descriptor: Object.getOwnPropertyDescriptor(proto, key)
        });
        options[key] = proto[methodHiddenAccess];
      } else {
        options[key] = proto[key];
      }

      return;
    }

    if (descriptor.value !== void 0) {
      // methods
      if (typeof descriptor.value === 'function') {
        (options.methods || (options.methods = {}))[key] = descriptor.value;
        protoMethods.push(key);
      } else {
        // typescript decorated data
        (options.mixins || (options.mixins = [])).push({
          data: function data() {
            return _defineProperty({}, key, descriptor.value);
          }
        });
      }
    } else if (descriptor.get || descriptor.set) {
      // computed properties
      (options.computed || (options.computed = {}))[key] = {
        get: descriptor.get,
        set: descriptor.set
      };
      protoGetAndSets.push(key);
    }
  });
  (options.mixins || (options.mixins = [])).push({
    data: function data() {
      return collectDataFromConstructor(this, Component);
    }
  }); // decorate options

  var decorators = Component.__decorators__;

  if (decorators) {
    decorators.forEach(function (fn) {
      return fn(options);
    });
    delete Component.__decorators__;
  } // find super


  var superProto = Object.getPrototypeOf(Component.prototype);
  var Super = superProto instanceof Vue ? superProto.constructor : Vue;
  var Extended = Super.extend(options);
  forwardStaticMembers(Extended, Component, Super);

  if (reflectionIsSupported()) {
    copyReflectionMetadata(Extended, Component);
  } // BIFIT: ---------- start
  // const printMethods = (data: any, name: string): void => {
  //   console.log(">> print for: ", name);
  //   Object.getOwnPropertyNames(data).forEach(function (key) {
  //     const descriptor = Object.getOwnPropertyDescriptor(data, key)!
  //     if (descriptor && descriptor.value !== void 0) {
  //       console.log("  --- ", key);
  //     }
  //   });
  // }


  Extended.prototype.$marker = protoMarker; // const compName = (<any> Extended).prototype.constructor && (<any> Extended).prototype.constructor.name || protoSymbol;
  // console.log("Обработка компонента " + compName);

  protoMethods.forEach(function (key) {
    installMethods(Extended, key); // console.log("    Сохраняем метод " + data.key);
  });
  protoGetAndSets.forEach(function (key) {
    installGetAndSets(Extended, key); // console.log("    Сохраняем  get/set " + key);
  });
  protoHooks.forEach(function (data) {
    installHooks(Extended, data.key, data.descriptor); // console.log("    Сохраняем хук " + data.key);
  }); // BIFIT: ---------- end

  return Extended;
}
var reservedPropertyNames = [// Unique id
'cid', // Super Vue constructor
'super', // Component options that will be used by the component
'options', 'superOptions', 'extendOptions', 'sealedOptions', // Private assets
'component', 'directive', 'filter'];
var shouldIgnore = {
  prototype: true,
  arguments: true,
  callee: true,
  caller: true
};

function forwardStaticMembers(Extended, Original, Super) {
  // We have to use getOwnPropertyNames since Babel registers methods as non-enumerable
  Object.getOwnPropertyNames(Original).forEach(function (key) {
    // Skip the properties that should not be overwritten
    if (shouldIgnore[key]) {
      return;
    } // Some browsers does not allow reconfigure built-in properties


    var extendedDescriptor = Object.getOwnPropertyDescriptor(Extended, key);

    if (extendedDescriptor && !extendedDescriptor.configurable) {
      return;
    }

    var descriptor = Object.getOwnPropertyDescriptor(Original, key); // If the user agent does not support `__proto__` or its family (IE <= 10),
    // the sub class properties may be inherited properties from the super class in TypeScript.
    // We need to exclude such properties to prevent to overwrite
    // the component options object which stored on the extended constructor (See #192).
    // If the value is a referenced value (object or function),
    // we can check equality of them and exclude it if they have the same reference.
    // If it is a primitive value, it will be forwarded for safety.

    if (!hasProto) {
      // Only `cid` is explicitly exluded from property forwarding
      // because we cannot detect whether it is a inherited property or not
      // on the no `__proto__` environment even though the property is reserved.
      if (key === 'cid') {
        return;
      }

      var superDescriptor = Object.getOwnPropertyDescriptor(Super, key);

      if (!isPrimitive(descriptor.value) && superDescriptor && superDescriptor.value === descriptor.value) {
        return;
      }
    } // Warn if the users manually declare reserved properties


    if (process.env.NODE_ENV !== 'production' && reservedPropertyNames.indexOf(key) >= 0) {
      warn("Static property name '".concat(key, "' declared on class '").concat(Original.name, "' ") + 'conflicts with reserved property name of Vue internal. ' + 'It may cause unexpected behavior of the component. Consider renaming the property.');
    }

    Object.defineProperty(Extended, key, descriptor);
  });
} // BIFIT: ---------- start

/**
 * BIFIT: Сохранение методов в прототипе объекта. Они теряются после декларации const Extended = Super.extend(options)
 * @param target целевой объект - Extended
 * @param propertyKey наименование метода
 */


function installMethods(target, propertyKey) {
  var scope = target.prototype || target.__proto__;

  if (scope && scope.constructor && scope.constructor.extendOptions && scope.constructor.extendOptions.methods && scope.constructor.extendOptions.methods[propertyKey] && !scope.hasOwnProperty(propertyKey)) {
    scope[propertyKey] = scope.constructor.extendOptions.methods[propertyKey];
  } else if (scope && scope.constructor && scope.constructor.superOptions && scope.constructor.superOptions.methods && scope.constructor.superOptions.methods[propertyKey] && !scope.hasOwnProperty(propertyKey)) {
    scope[propertyKey] = scope.constructor.superOptions.methods[propertyKey];
  }
}
/**
 * BIFIT: Сохранение get/set в прототипе объекта. Они теряют связь с наследником после декларации const Extended = Super.extend(options)
 * @param target целевой объект - Extended
 * @param propertyKey наименование get/set
 */


function installGetAndSets(target, propertyKey) {
  var scope = target.prototype || target.__proto__;

  if (scope && scope.constructor && scope.constructor.extendOptions && scope.constructor.extendOptions.computed && scope.constructor.extendOptions.computed[propertyKey]
  /* && !scope.hasOwnProperty(propertyKey) */
  ) {
      Object.defineProperty(scope, propertyKey, scope.constructor.extendOptions.computed[propertyKey]);
    } else if (scope && scope.constructor && scope.constructor.superOptions && scope.constructor.superOptions.computed && scope.constructor.superOptions.computed[propertyKey]
  /* && !scope.hasOwnProperty(propertyKey)*/
  ) {
      Object.defineProperty(scope, propertyKey, scope.constructor.superOptions.computed[propertyKey]);
    }
}
/**
 * BIFIT: Сохранение хуков в прототипе объекта. Они теряются после декларации const Extended = Super.extend(options)
 * Список хуков для сохранения следующий `$keepHooks`:
    -  'beforeCreate',
    -  'created',
    -  'beforeMount',
    -  'mounted',
    -  'beforeDestroy',
    -  'destroyed',
    -  'beforeUpdate',
    -  'updated',
    -  'activated',
    -  'deactivated'
 * @param target целевой объект - Extended
 * @param propertyKey наименование хука
 * @param descriptor
 */


function installHooks(target, propertyKey, descriptor) {
  var scope = target.prototype || target.__proto__;

  if (scope && !scope.hasOwnProperty(propertyKey)) {
    scope[propertyKey] = descriptor.value;
  }
} // BIFIT: ---------- end

function Component(options) {
  if (typeof options === 'function') {
    return componentFactory(options);
  }

  return function (Component) {
    return componentFactory(Component, options);
  };
}

Component.registerHooks = function registerHooks(keys) {
  $internalHooks.push.apply($internalHooks, _toConsumableArray(keys));
};

export default Component;
export { createDecorator, mixins };