moodle_local_treestudyplan/amd/src/vue-easy-dnd/vue-class-component.js

/* eslint-disable */
/*eslint no-unused-vars: "off" */
/**
  * vue-class-component v7.2.5
  * (c) 2015-present Evan You
  * @license MIT
  */

import Vue from './vue/vue';


 // 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(key => {
     forwardMetadata(to.prototype, from.prototype, key);
   });
   Object.getOwnPropertyNames(from).forEach(key => {
     forwardMetadata(to, from, key);
   });
 }
 
 function forwardMetadata(to, from, propertyKey) {
   var metaKeys = propertyKey ? Reflect.getOwnMetadataKeys(from, propertyKey) : Reflect.getOwnMetadataKeys(from);
   metaKeys.forEach(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 (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(options => 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 () {
     // 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(key => {
       Object.defineProperty(this, key, {
         get: () => vm[key],
         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(key => {
     if (data[key] !== undefined) {
       plainData[key] = data[key];
     }
   });
 
   {
     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
 ];
 function componentFactory(Component) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   options.name = options.name || Component._componentTag || Component.name; // prototype props.
 
   var proto = Component.prototype;
   Object.getOwnPropertyNames(proto).forEach(function (key) {
     if (key === 'constructor') {
       return;
     } // hooks
 
 
     if ($internalHooks.indexOf(key) > -1) {
       options[key] = proto[key];
       return;
     }
 
     var descriptor = Object.getOwnPropertyDescriptor(proto, key);
 
     if (descriptor.value !== void 0) {
       // methods
       if (typeof descriptor.value === 'function') {
         (options.methods || (options.methods = {}))[key] = descriptor.value;
       } else {
         // typescript decorated data
         (options.mixins || (options.mixins = [])).push({
           data() {
             return {
               [key]: descriptor.value
             };
           }
 
         });
       }
     } else if (descriptor.get || descriptor.set) {
       // computed properties
       (options.computed || (options.computed = {}))[key] = {
         get: descriptor.get,
         set: descriptor.set
       };
     }
   });
   (options.mixins || (options.mixins = [])).push({
     data() {
       return collectDataFromConstructor(this, Component);
     }
 
   }); // decorate options
 
   var decorators = Component.__decorators__;
 
   if (decorators) {
     decorators.forEach(fn => 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);
   }
 
   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(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 ( 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);
   });
 }
 
 function Component(options) {
   if (typeof options === 'function') {
     return componentFactory(options);
   }
 
   return function (Component) {
     return componentFactory(Component, options);
   };
 }
 
 Component.registerHooks = function registerHooks(keys) {
   $internalHooks.push(...keys);
 };
 
 export { Component, createDecorator, mixins };