refactoring some code and improve performance

Author: ruojianll

src/component.ts

@@ -30,16 +30,10 @@ function ComponentOption(cons: Cons, extend?: any) {
     optionInject(cons, optionBuilder)
     optionEmit(cons, optionBuilder)
     optionRef(cons, optionBuilder)//after Computed
-    optionMethodsAndHooks(cons, optionBuilder)//after Ref Computed
     optionAccessor(cons, optionBuilder)
-
-
-    const setupFunction: OptionSetupFunction | undefined = optionBuilder.setup ? function (props, ctx) {
-        return optionBuilder.setup!(props, ctx)
-    } : undefined
-
+    optionMethodsAndHooks(cons, optionBuilder)//the last one
     const raw = {
-        setup: setupFunction,
+        setup: optionBuilder.setup,
         data() {
             delete optionBuilder.data
             optionData(cons, optionBuilder, this)
@@ -71,7 +65,9 @@ type ComponentOption = {
     mixins?: any[]
     setup?: ComponentSetupFunction
 }
+
 type ComponentConsOption = Cons | ComponentOption
+
 function buildComponent(cons: Cons, arg: ComponentOption, extend?: any): any {
     const option = ComponentOption(cons, extend)
     const slot = obtainSlot(cons.prototype)
@@ -82,21 +78,21 @@ function buildComponent(cons: Cons, arg: ComponentOption, extend?: any): any {
         option[name] = arg[name as keyof ComponentOption]
         return option
     }, option)
+
+    //apply event emits
     let emits = Array.from(slot.obtainMap('emits').keys())
     if (Array.isArray(arg.emits)) {
         emits = Array.from(new Set([...emits, ...arg.emits]))
     }
     option.emits = emits
 
-    arg.setup ??= function () { return {} }
-
+    //merge setup function
     if (!option.setup) {
-
         option.setup = arg.setup
     } else {
 
         const oldSetup: OptionSetupFunction = option.setup
-        const newSetup: ComponentSetupFunction = arg.setup
+        const newSetup: ComponentSetupFunction = arg.setup ?? function () { return {} }
 
         const setup: ComponentSetupFunction = function (props, ctx) {
             const newRet = newSetup(props, ctx)
@@ -116,16 +112,24 @@ function buildComponent(cons: Cons, arg: ComponentOption, extend?: any): any {
         option.setup = setup
     }
 
-    slot.obtainMap('customDecorator').forEach((v) => {
-        v.creator.apply({}, [option, v.key])
-    })
+    //custom decorator
+    const map = slot.getMap('customDecorator')
+    if (map && map.size > 0) {
+        map.forEach((v) => {
+            v.creator.apply({}, [option, v.key])
+        })
+    }
 
+    //shallow merge options
     if (arg.options) {
         Object.assign(option, arg.options)
     }
+
+    //apply modifier
     if (arg.modifier) {
         arg.modifier(option)
     }
+
     return defineComponent(option)
 }
 function build(cons: Cons, option: ComponentOption) {

src/index-return-cons.ts

@@ -1 +1,2 @@
+// This feature is deprecated and is preserved for compatibility
 export * from './index'

src/option/accessor.ts

@@ -1,14 +1,17 @@
 import type { Cons } from '../component'
-import { type OptionBuilder, applyAccessors} from '../optionBuilder'
+import { type OptionBuilder, applyAccessors } from '../optionBuilder'
 import { toComponentReverse, obtainSlot } from '../utils'
 
 export function build(cons: Cons, optionBuilder: OptionBuilder) {
     const slot = obtainSlot(cons.prototype)
-    const vanillaMap = slot.obtainMap('vanilla')
+    const vanillaMap = slot.getMap('vanilla')
+    if (!vanillaMap || vanillaMap.size === 0) {
+        return
+    }
     const protoArr = toComponentReverse(cons.prototype)
-    const map: Map<string, { get: (() => any) | undefined, set: ((v: any) => any) | undefined }> = new Map
+    const map: Map<string, { get: (() => any) | undefined, set: ((v: any) => any) | undefined }> | undefined = new Map
 
-    applyAccessors(optionBuilder,(ctx:any)=>{
+    applyAccessors(optionBuilder, (ctx: any) => {
         protoArr.forEach(proto => {
             const deses = Object.getOwnPropertyDescriptors(proto)
             for (const name in deses) {

src/option/data.ts

@@ -2,19 +2,12 @@ import type { Cons } from '../component'
 import type { OptionBuilder } from '../optionBuilder'
 import { makeObject, obtainSlot, excludeNames, getValidNames } from '../utils'
 
-export function build(cons: Cons, optionBuilder: OptionBuilder, vueInstance: any, _propNames?: string[]) {
+export function build(cons: Cons, optionBuilder: OptionBuilder, vueInstance: any) {
     optionBuilder.data ??= {}
-
-
-
-    
     const sample = new cons(optionBuilder,vueInstance)
-
     let names = getValidNames(sample, (des) => {
         return !!des.enumerable
     })
-
-
     const slot = obtainSlot(cons.prototype)
     names = excludeNames(names, slot)
     Object.assign(optionBuilder.data, makeObject(names, sample))

src/option/emit.ts

@@ -1,7 +1,6 @@
 import type { Cons } from '../component'
 import type { OptionBuilder } from '../optionBuilder'
 import { obtainSlot, optoinNullableMemberDecorator } from '../utils'
-import { compatibleMemberDecorator } from '../deco3/utils'
 export type EmitConfig = null | string
 
 export const decorator = optoinNullableMemberDecorator(function (proto: any, name: string, key?: string) {
@@ -14,25 +13,25 @@ export function build(cons: Cons, optionBuilder: OptionBuilder) {
     optionBuilder.methods ??= {}
     const proto = cons.prototype
     const slot = obtainSlot(proto)
-    const names = slot.obtainMap('emit')
+    const names = slot.getMap('emit')
+    if (!names || names.size === 0) {
+        return
+    }
     const emits = slot.obtainMap('emits')
+    names.forEach((value, key) => {
+        const eventName = value === null ? key : value
+        emits.set(eventName, true)
+        optionBuilder.methods![key] = async function (this: any) {
 
-    if (names) {
-        names.forEach((value, key) => {
-            const eventName = value === null ? key : value
-            emits.set(eventName, true)
-            optionBuilder.methods![key] = async function (this: any) {
-
-                const ret = proto[key].apply(this, arguments)
-                if (ret instanceof Promise) {
-                    const proRet = await ret
-                    this.$emit(eventName, proRet)
-                }
-                else {
-                    this.$emit(eventName, ret)
-                }
+            const ret = proto[key].apply(this, arguments)
+            if (ret instanceof Promise) {
+                const proRet = await ret
+                this.$emit(eventName, proRet)
             }
-        })
-    }
+            else {
+                this.$emit(eventName, ret)
+            }
+        }
+    })
 
 }

src/option/inject.ts

@@ -19,13 +19,15 @@ export const decorator = optoinNullableMemberDecorator(function (proto: any, nam
 export function build(cons: Cons, optionBuilder: OptionBuilder) {
     optionBuilder.inject ??= {}
     const slot = obtainSlot(cons.prototype)
-    const names = slot.obtainMap('inject')
-    if (names) {
-        names.forEach((value, name) => {
-            optionBuilder.inject![name] = value
-        })
+    const names = slot.getMap('inject')
+    if (!names || names.size === 0) {
+        return
     }
 
+    names.forEach((value, name) => {
+        optionBuilder.inject![name] = value
+    })
+
 }
 
 

src/option/methodsAndHooks.ts

@@ -51,7 +51,13 @@ export function build(cons: Cons, optionBuilder: OptionBuilder) {
             }
             return false
         })
-        names = excludeNames(names, slot);
+        names = excludeNames(names, slot, (mapName) => {
+            //include these names:
+            //watch, user may call watch method directly
+            //hooks, user may call hook method directly
+            //emits, user may have a method name which is same as one of event names
+            return !['watch', 'hooks', 'emits'].includes(mapName)
+        });
         names.forEach(name => {
             if (HookNames.includes(name as any) || map.has(name)) {
 
@@ -66,13 +72,13 @@ export function build(cons: Cons, optionBuilder: OptionBuilder) {
     })
 
     Object.assign(optionBuilder.methods, MethodFunctions)
-    const bccbs = optionBuilder.beforeCreateCallbacks
-    if (bccbs && bccbs.length > 0) {
-        const oldBc = HookFunctions['beforeCreate']
+    const beforeCreateCallbacks = [...optionBuilder.beforeCreateCallbacks??[]]
+    if (beforeCreateCallbacks && beforeCreateCallbacks.length > 0) {
+        const oldBeforeCreateCallback = HookFunctions['beforeCreate']
         HookFunctions['beforeCreate'] = function () {
-            bccbs.forEach(bccb => bccb.apply(this, arguments))
-            if (oldBc) {
-                oldBc.apply(this, arguments)
+            beforeCreateCallbacks.forEach(callback => callback.apply(this, arguments))
+            if (oldBeforeCreateCallback) {
+                oldBeforeCreateCallback.apply(this, arguments)
             }
         }
     }

src/option/props.ts

@@ -19,14 +19,16 @@ export const decorator = optoinNullableMemberDecorator(function (proto: any, nam
 export function build(cons: Cons, optionBuilder: OptionBuilder) {
     optionBuilder.props ??= {}
     const slot = obtainSlot(cons.prototype)
-    const names = slot.obtainMap('props')
-
-    if (names) {
-        names.forEach((value, name) => {
-            optionBuilder.props![name] = value
-        })
+    const names = slot.getMap('props')
+    if (!names || names.size === 0) {
+        return
     }
 
+    names.forEach((value, name) => {
+        optionBuilder.props![name] = value
+    })
+
+
 }
 
 

src/option/ref.ts

@@ -11,19 +11,22 @@ export const decorator = optoinNullableMemberDecorator(function (proto: any, nam
 
 export function build(cons: Cons, optionBuilder: OptionBuilder) {
     const slot = obtainSlot(cons.prototype)
-    const names = slot.obtainMap('ref')!
-    if (names) {
-        applyAccessors(optionBuilder, (ctx: any) => {
-            const data: Map<string, { get: () => any, set: undefined }> = new Map
-            names.forEach((value, name) => {
-                data.set(name, {
-                    get: function (this: any) {
-                        return ctx.$refs[name]
-                    },
-                    set: undefined
-                })
+    const names = slot.getMap('ref')
+    if (!names || names.size === 0) {
+        return
+    }
+
+    applyAccessors(optionBuilder, (ctx: any) => {
+        const data: Map<string, { get: () => any, set: undefined }> = new Map
+        names.forEach((value, name) => {
+            data.set(name, {
+                get: function (this: any) {
+                    return ctx.$refs[name]
+                },
+                set: undefined
             })
-            return data
         })
-    }
+        return data
+    })
+
 }

src/option/setup.ts

@@ -1,4 +1,4 @@
-import { compatibleMemberDecorator} from '../deco3/utils'
+import { compatibleMemberDecorator } from '../deco3/utils'
 import type { OptionSetupFunction } from '../component'
 import type { Cons } from '../component'
 import type { OptionBuilder } from '../optionBuilder'
@@ -19,16 +19,15 @@ export function decorator(setupFunction: OptionSetupFunction) {
 }
 
 const isPromise = (v: any): v is Promise<any> => v instanceof Promise
-//(v: any) => typeof v === 'object' && typeof v.then === 'function'
 
 export function build(cons: Cons, optionBuilder: OptionBuilder) {
     const slot = obtainSlot(cons.prototype)
-    const map = slot.obtainMap('setup')
-    if (map.size === 0) {
+    const map = slot.getMap('setup')
+    if (!map || map.size === 0) {
         return
     }
     const setup: OptionSetupFunction = function (props, ctx) {
-        
+
         const setupData: Record<string, any> = {};
         let promises: Promise<any>[] | null = null;
         for (const name of map.keys()) {