chore: run lint

Author: antfu

src/createElement.ts

@@ -1,23 +1,24 @@
-import Vue from 'vue';
-import { currentVM, getCurrentVue } from './runtimeContext';
-import { defineComponentInstance } from './helper';
-import { warn } from './utils';
+import Vue from 'vue'
+import { currentVM, getCurrentVue } from './runtimeContext'
+import { defineComponentInstance } from './helper'
+import { warn } from './utils'
 
-type CreateElement = Vue['$createElement'];
+type CreateElement = Vue['$createElement']
 
-let fallbackCreateElement: CreateElement;
+let fallbackCreateElement: CreateElement
 
 const createElement: CreateElement = function createElement(...args: any) {
   if (!currentVM) {
-    warn('`createElement()` has been called outside of render function.');
+    warn('`createElement()` has been called outside of render function.')
     if (!fallbackCreateElement) {
-      fallbackCreateElement = defineComponentInstance(getCurrentVue()).$createElement;
+      fallbackCreateElement = defineComponentInstance(getCurrentVue())
+        .$createElement
     }
 
-    return fallbackCreateElement.apply(fallbackCreateElement, args);
+    return fallbackCreateElement.apply(fallbackCreateElement, args)
   }
 
-  return currentVM.$createElement.apply(currentVM, args);
-} as any;
+  return currentVM.$createElement.apply(currentVM, args)
+} as any
 
-export default createElement;
+export default createElement

src/env.d.ts

@@ -1,32 +1,32 @@
-import { VueConstructor } from 'vue';
-import { VfaState } from './vmStateManager';
-import { VueWatcher } from './apis/watch';
+import { VueConstructor } from 'vue'
+import { VfaState } from './vmStateManager'
+import { VueWatcher } from './apis/watch'
 
 declare global {
   interface Window {
-    Vue: VueConstructor;
+    Vue: VueConstructor
   }
 }
 
 declare module 'vue/types/vue' {
   interface Vue {
-    readonly _uid: number;
-    readonly _data: Record<string, any>;
-    _watchers: VueWatcher[];
-    __secret_vfa_state__?: VfaState;
+    readonly _uid: number
+    readonly _data: Record<string, any>
+    _watchers: VueWatcher[]
+    __secret_vfa_state__?: VfaState
   }
 
   interface VueConstructor {
-    observable<T>(x: any): T;
+    observable<T>(x: any): T
     util: {
-      warn(msg: string, vm?: Vue);
+      warn(msg: string, vm?: Vue)
       defineReactive(
         obj: Object,
         key: string,
         val: any,
         customSetter?: Function,
         shallow?: boolean
-      );
-    };
+      )
+    }
   }
 }

src/global.d.ts

@@ -1,2 +1,2 @@
 // Global compile-time constants
-declare var __DEV__: boolean;
+declare var __DEV__: boolean

src/helper.ts

@@ -1,70 +1,73 @@
-import Vue, { VNode, ComponentOptions, VueConstructor } from 'vue';
-import { ComponentInstance } from './component';
-import { currentVue, getCurrentVM } from './runtimeContext';
-import { warn } from './utils';
+import Vue, { VNode, ComponentOptions, VueConstructor } from 'vue'
+import { ComponentInstance } from './component'
+import { currentVue, getCurrentVM } from './runtimeContext'
+import { warn } from './utils'
 
 export function currentVMInFn(hook: string): ComponentInstance | null {
-  const vm = getCurrentVM();
+  const vm = getCurrentVM()
   if (__DEV__ && !vm) {
     warn(
       `${hook} is called when there is no active component instance to be ` +
         `associated with. ` +
         `Lifecycle injection APIs can only be used during execution of setup().`
-    );
+    )
   }
-  return vm;
+  return vm
 }
 
 export function defineComponentInstance<V extends Vue = Vue>(
   Ctor: VueConstructor<V>,
   options: ComponentOptions<V> = {}
 ) {
-  const silent = Ctor.config.silent;
-  Ctor.config.silent = true;
-  const vm = new Ctor(options);
-  Ctor.config.silent = silent;
-  return vm;
+  const silent = Ctor.config.silent
+  Ctor.config.silent = true
+  const vm = new Ctor(options)
+  Ctor.config.silent = silent
+  return vm
 }
 
 export function isComponentInstance(obj: any) {
-  return currentVue && obj instanceof currentVue;
+  return currentVue && obj instanceof currentVue
 }
 
 export function createSlotProxy(vm: ComponentInstance, slotName: string) {
   return (...args: any) => {
     if (!vm.$scopedSlots[slotName]) {
-      return warn(`slots.${slotName}() got called outside of the "render()" scope`, vm);
+      return warn(
+        `slots.${slotName}() got called outside of the "render()" scope`,
+        vm
+      )
     }
 
-    return vm.$scopedSlots[slotName]!.apply(vm, args);
-  };
+    return vm.$scopedSlots[slotName]!.apply(vm, args)
+  }
 }
 
 export function resolveSlots(
   slots: { [key: string]: Function } | void,
   normalSlots: { [key: string]: VNode[] | undefined }
 ): { [key: string]: true } {
-  let res: { [key: string]: true };
+  let res: { [key: string]: true }
   if (!slots) {
-    res = {};
+    res = {}
   } else if (slots._normalized) {
     // fast path 1: child component re-render only, parent did not change
-    return slots._normalized as any;
+    return slots._normalized as any
   } else {
-    res = {};
+    res = {}
     for (const key in slots) {
       if (slots[key] && key[0] !== '$') {
-        res[key] = true;
+        res[key] = true
       }
     }
   }
 
   // expose normal slots on scopedSlots
   for (const key in normalSlots) {
     if (!(key in res)) {
-      res[key] = true;
+      res[key] = true
     }
   }
 
-  return res;
+  return res
 }

src/index.ts

@@ -1,41 +1,41 @@
-import Vue, { VueConstructor } from 'vue';
-import { Data, SetupFunction, SetupContext } from './component';
-import { currentVue } from './runtimeContext';
-import { install } from './install';
-import { mixin } from './setup';
+import Vue, { VueConstructor } from 'vue'
+import { Data, SetupFunction, SetupContext } from './component'
+import { currentVue } from './runtimeContext'
+import { install } from './install'
+import { mixin } from './setup'
 
 declare module 'vue/types/options' {
   interface ComponentOptions<V extends Vue> {
-    setup?: SetupFunction<Data, Data>;
+    setup?: SetupFunction<Data, Data>
   }
 }
 
-const _install = (Vue: VueConstructor) => install(Vue, mixin);
+const _install = (Vue: VueConstructor) => install(Vue, mixin)
 const plugin = {
   install: _install,
-};
+}
 // Auto install if it is not done yet and `window` has `Vue`.
 // To allow users to avoid auto-installation in some cases,
 if (currentVue && typeof window !== 'undefined' && window.Vue) {
-  _install(window.Vue);
+  _install(window.Vue)
 }
 
-export default plugin;
-export { default as createElement } from './createElement';
-export { SetupContext };
+export default plugin
+export { default as createElement } from './createElement'
+export { SetupContext }
 export {
   createComponent,
   defineComponent,
   ComponentRenderProxy,
   PropType,
   PropOptions,
-} from './component';
+} from './component'
 // For getting a hold of the interal instance in setup() - useful for advanced
 // plugins
-export { getCurrentVM as getCurrentInstance } from './runtimeContext';
+export { getCurrentVM as getCurrentInstance } from './runtimeContext'
 
-export * from './apis/state';
-export * from './apis/lifecycle';
-export * from './apis/watch';
-export * from './apis/computed';
-export * from './apis/inject';
+export * from './apis/state'
+export * from './apis/lifecycle'
+export * from './apis/watch'
+export * from './apis/computed'
+export * from './apis/inject'

src/install.ts

@@ -1,58 +1,67 @@
-import { AnyObject } from './types/basic';
-import { hasSymbol, hasOwn, isPlainObject, assert } from './utils';
-import { isRef } from './reactivity';
-import { setCurrentVue, currentVue } from './runtimeContext';
-import { VueConstructor } from 'vue';
+import { AnyObject } from './types/basic'
+import { hasSymbol, hasOwn, isPlainObject, assert } from './utils'
+import { isRef } from './reactivity'
+import { setCurrentVue, currentVue } from './runtimeContext'
+import { VueConstructor } from 'vue'
 
 /**
  * Helper that recursively merges two data objects together.
  */
 function mergeData(from: AnyObject, to: AnyObject): Object {
-  if (!from) return to;
-  let key: any;
-  let toVal: any;
-  let fromVal: any;
+  if (!from) return to
+  let key: any
+  let toVal: any
+  let fromVal: any
 
-  const keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
+  const keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from)
 
   for (let i = 0; i < keys.length; i++) {
-    key = keys[i];
+    key = keys[i]
     // in case the object is already observed...
-    if (key === '__ob__') continue;
-    toVal = to[key];
-    fromVal = from[key];
+    if (key === '__ob__') continue
+    toVal = to[key]
+    fromVal = from[key]
     if (!hasOwn(to, key)) {
-      to[key] = fromVal;
+      to[key] = fromVal
     } else if (
       toVal !== fromVal &&
       isPlainObject(toVal) &&
       !isRef(toVal) &&
       isPlainObject(fromVal) &&
       !isRef(fromVal)
     ) {
-      mergeData(fromVal, toVal);
+      mergeData(fromVal, toVal)
     }
   }
-  return to;
+  return to
 }
 
-export function install(Vue: VueConstructor, _install: (Vue: VueConstructor) => void) {
+export function install(
+  Vue: VueConstructor,
+  _install: (Vue: VueConstructor) => void
+) {
   if (currentVue && currentVue === Vue) {
     if (__DEV__) {
-      assert(false, 'already installed. Vue.use(plugin) should be called only once');
+      assert(
+        false,
+        'already installed. Vue.use(plugin) should be called only once'
+      )
     }
-    return;
+    return
   }
 
-  Vue.config.optionMergeStrategies.setup = function (parent: Function, child: Function) {
+  Vue.config.optionMergeStrategies.setup = function (
+    parent: Function,
+    child: Function
+  ) {
     return function mergedSetupFn(props: any, context: any) {
       return mergeData(
         typeof parent === 'function' ? parent(props, context) || {} : {},
         typeof child === 'function' ? child(props, context) || {} : {}
-      );
-    };
-  };
+      )
+    }
+  }
 
-  setCurrentVue(Vue);
-  _install(Vue);
+  setCurrentVue(Vue)
+  _install(Vue)
 }

src/runtimeContext.ts

@@ -1,28 +1,28 @@
-import { VueConstructor } from 'vue';
-import { ComponentInstance } from './component';
-import { assert } from './utils';
+import { VueConstructor } from 'vue'
+import { ComponentInstance } from './component'
+import { assert } from './utils'
 
-let currentVue: VueConstructor | null = null;
-let currentVM: ComponentInstance | null = null;
+let currentVue: VueConstructor | null = null
+let currentVM: ComponentInstance | null = null
 
 export function getCurrentVue(): VueConstructor {
   if (__DEV__) {
-    assert(currentVue, `must call Vue.use(plugin) before using any function.`);
+    assert(currentVue, `must call Vue.use(plugin) before using any function.`)
   }
 
-  return currentVue!;
+  return currentVue!
 }
 
 export function setCurrentVue(vue: VueConstructor) {
-  currentVue = vue;
+  currentVue = vue
 }
 
 export function getCurrentVM(): ComponentInstance | null {
-  return currentVM;
+  return currentVM
 }
 
 export function setCurrentVM(vm: ComponentInstance | null) {
-  currentVM = vm;
+  currentVM = vm
 }
 
-export { currentVue, currentVM };
+export { currentVue, currentVM }