[build] 7.2.4

dist/vue-class-component.common.js

@@ -1,5 +1,5 @@
 /**
- * vue-class-component v7.2.3
+ * vue-class-component v7.2.4
  * (c) 2015-present Evan You
  * @license MIT
  */
@@ -149,17 +149,15 @@ function collectDataFromConstructor(vm, Component) {
  }
 
  keys.forEach(function (key) {
- if (key.charAt(0) !== '_') {
- Object.defineProperty(_this, key, {
- get: function get() {
- return vm[key];
- },
- set: function set(value) {
- vm[key] = value;
- },
- configurable: true
- });
- }
+ 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
 

dist/vue-class-component.d.ts

@@ -0,0 +1,80 @@
+import { ComponentOptions } from 'vue';
+import { ComponentPublicInstance } from 'vue';
+import { SetupContext } from 'vue';
+import { UnwrapRef } from 'vue';
+import { VNode } from 'vue';
+
+export declare interface ClassComponentHooks {
+ data?(): object;
+ beforeCreate?(): void;
+ created?(): void;
+ beforeMount?(): void;
+ mounted?(): void;
+ beforeUnmount?(): void;
+ unmounted?(): void;
+ beforeUpdate?(): void;
+ updated?(): void;
+ activated?(): void;
+ deactivated?(): void;
+ render?(): VNode | void;
+ errorCaptured?(err: Error, vm: Vue, info: string): boolean | undefined;
+ serverPrefetch?(): Promise<unknown>;
+}
+
+export declare function createDecorator(factory: (options: ComponentOptions, key: string, index: number) => void): VueDecorator;
+
+export declare type ExtractInstance<T> = T extends VueMixin<infer V> ? V : never;
+
+export declare type MixedVueBase<Mixins extends VueMixin[]> = Mixins extends (infer T)[] ? VueBase<UnionToIntersection<ExtractInstance<T>> & Vue> & PropsMixin : never;
+
+export declare function mixins<T extends VueMixin[]>(...Ctors: T): MixedVueBase<T>;
+
+export declare function Options<V extends Vue>(options: ComponentOptions & ThisType<V>): <VC extends VueBase>(target: VC) => VC;
+
+export declare interface PropsMixin {
+ new <Props = unknown>(...args: any[]): {
+ $props: Props;
+ };
+}
+
+export declare function setup<R>(setupFn: () => R): UnwrapRef<R>;
+
+export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+export declare type Vue<Props = unknown> = ComponentPublicInstance<{}, {}, {}, {}, {}, Record<string, any>, Props> & ClassComponentHooks;
+
+export declare const Vue: VueConstructor;
+
+export declare type VueBase<V extends Vue = Vue> = VueMixin<V> & (new (...args: any[]) => V);
+
+export declare interface VueConstructor extends VueStatic {
+ new <Props = unknown>(prop: Props, ctx: SetupContext): Vue<Props>;
+}
+
+export declare interface VueDecorator {
+ (Ctor: VueBase): void;
+ (target: Vue, key: string): void;
+ (target: Vue, key: string, index: number): void;
+}
+
+export declare type VueMixin<V extends Vue = Vue> = VueStatic & {
+ prototype: V;
+};
+
+export declare interface VueStatic {
+ /* Excluded from this release type: __vccCache */
+ /* Excluded from this release type: __vccBase */
+ /* Excluded from this release type: __vccDecorators */
+ /* Excluded from this release type: __vccMixins */
+ /* Excluded from this release type: __vccHooks */
+ /* Excluded from this release type: __vccOpts */
+ /* Excluded from this release type: render */
+ /* Excluded from this release type: ssrRender */
+ /* Excluded from this release type: __file */
+ /* Excluded from this release type: __cssModules */
+ /* Excluded from this release type: __scopeId */
+ /* Excluded from this release type: __hmrId */
+ registerHooks(keys: string[]): void;
+}
+
+export { }

dist/vue-class-component.esm-browser.js

@@ -0,0 +1,260 @@
+/**
+ * vue-class-component v8.0.0-alpha.6
+ * (c) 2015-present Evan You
+ * @license MIT
+ */
+import { reactive } from 'vue';
+
+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 defineGetter(obj, key, getter) {
+ Object.defineProperty(obj, key, {
+ get: getter,
+ enumerable: false,
+ configurable: true
+ });
+}
+
+function defineProxy(proxy, key, target) {
+ Object.defineProperty(proxy, key, {
+ get: () => target[key],
+ set: value => {
+ target[key] = value;
+ },
+ enumerable: true,
+ configurable: true
+ });
+}
+
+function getSuperOptions(Ctor) {
+ var superProto = Object.getPrototypeOf(Ctor.prototype);
+
+ if (!superProto) {
+ return undefined;
+ }
+
+ var Super = superProto.constructor;
+ return Super.__vccOpts;
+}
+
+class VueImpl {
+ constructor(props, ctx) {
+ defineGetter(this, '$props', () => props);
+ defineGetter(this, '$attrs', () => ctx.attrs);
+ defineGetter(this, '$slots', () => ctx.slots);
+ defineGetter(this, '$emit', () => ctx.emit);
+ Object.keys(props).forEach(key => {
+ Object.defineProperty(this, key, {
+ enumerable: false,
+ configurable: true,
+ writable: true,
+ value: props[key]
+ });
+ });
+ }
+ /** @internal */
+
+
+ static get __vccOpts() {
+ // 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
+
+ options.extends = getSuperOptions(Ctor); // Handle mixins
+
+ var mixins = this.hasOwnProperty('__vccMixins') && this.__vccMixins;
+
+ if (mixins) {
+ options.mixins = options.mixins ? options.mixins.concat(mixins) : mixins;
+ }
+
+ options.methods = _objectSpread2({}, options.methods);
+ options.computed = _objectSpread2({}, options.computed);
+ var proto = Ctor.prototype;
+ Object.getOwnPropertyNames(proto).forEach(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 data = new Ctor(props, ctx);
+ var dataKeys = Object.keys(data);
+ var plainData = reactive({}); // Initialize reactive data and convert constructor `this` to a proxy
+
+ dataKeys.forEach(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] = data[key];
+ defineProxy(data, key, plainData);
+ }); // Invoke composition functions
+
+ dataKeys.forEach(key => {
+ if (data[key] && data[key].__s) {
+ plainData[key] = data[key].__s();
+ }
+ });
+ return plainData;
+ };
+
+ var decorators = this.hasOwnProperty('__vccDecorators') && this.__vccDecorators;
+
+ if (decorators) {
+ decorators.forEach(fn => fn(options));
+ } // from Vue Loader
+
+
+ var injections = ['render', 'ssrRender', '__file', '__cssModules', '__scopeId', '__hmrId'];
+ injections.forEach(key => {
+ if (Ctor[key]) {
+ options[key] = Ctor[key];
+ }
+ });
+ return options;
+ }
+
+ static registerHooks(keys) {
+ this.__vccHooks.push(...keys);
+ }
+
+}
+/** @internal */
+
+
+VueImpl.__vccHooks = ['data', 'beforeCreate', 'created', 'beforeMount', 'mounted', 'beforeUnmount', 'unmounted', 'beforeUpdate', 'updated', 'activated', 'deactivated', 'render', 'errorCaptured', 'serverPrefetch'];
+var Vue = VueImpl;
+
+function Options(options) {
+ return Component => {
+ Component.__vccBase = options;
+ return Component;
+ };
+}
+function createDecorator(factory) {
+ return (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(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];
+ }
+
+ var _a;
+
+ return _a = class MixedVue extends Vue {
+ constructor(props, ctx) {
+ super(props, ctx);
+ Ctors.forEach(Ctor => {
+ var data = new Ctor(props, ctx);
+ Object.keys(data).forEach(key => {
+ this[key] = data[key];
+ });
+ });
+ }
+
+ }, _a.__vccMixins = Ctors.map(Ctor => Ctor.__vccOpts), _a;
+}
+function setup(setupFn) {
+ // Hack to delay the invocation of setup function.
+ // Will be called after dealing with class properties.
+ return {
+ __s: setupFn
+ };
+}
+
+export { Options, Vue, createDecorator, mixins, setup };