utils

Author: ruojianll

src/option/computed.ts

@@ -1,5 +1,5 @@
 import type { VueCons } from '../class'
-import { obtainSlot, toComponentReverse, getValidNames } from '../utils'
+import { obtainSlot, toComponentReverse, getValidOwnPropertyNames } from '../utils'
 import type { OptionBuilder } from '../optionBuilder'
 
 export function build(cons: VueCons, optionBuilder: OptionBuilder) {
@@ -9,7 +9,7 @@ export function build(cons: VueCons, optionBuilder: OptionBuilder) {
     const vanillaMap = slot.obtainMap('vanilla')
     const protoArr = toComponentReverse(cons.prototype)
     protoArr.forEach(proto => {
-        getValidNames(proto, (des, name) => {
+        getValidOwnPropertyNames(proto, (des, name) => {
             return (typeof des.get === 'function' || typeof des.set === 'function') && !vanillaMap.has(name)
         }).forEach(name => {
 

src/option/data.ts

@@ -1,20 +1,19 @@
 import type { VueCons } from '../class'
 import type { OptionBuilder } from '../optionBuilder'
-import { makeObject, obtainSlot, excludeNames, getValidNames } from '../utils'
+import { makeObject, obtainSlot, filterNames, getValidOwnPropertyNames } from '../utils'
 
 export function build(cons: VueCons, optionBuilder: OptionBuilder, vueInstance: any) {
     optionBuilder.data ??= {}
     const sample = new cons(optionBuilder, vueInstance) as any
-    let names = getValidNames(sample, (des, name) => {
+    let names = getValidOwnPropertyNames(sample, (des, name) => {
         return !!des.enumerable
             && !optionBuilder.methods?.[name]
             && !optionBuilder.props?.[name]
     })
     const slot = obtainSlot(cons.prototype)
-    names = excludeNames(names, slot,(mapName) => {
-        //include these names:
-        //provide, user may access field directly
-        return !['provide'].includes(mapName)
-    })
+    //include these names:
+    //provide, user may access field directly
+    //customDecorator
+    names = filterNames(names, slot, ['provide', 'customDecorator'])
     Object.assign(optionBuilder.data, makeObject(names, sample))
 }

src/option/methodsAndHooks.ts

@@ -1,6 +1,6 @@
 import type { VueCons } from '../class'
 import type { OptionBuilder } from '../optionBuilder'
-import { obtainSlot, toComponentReverse, excludeNames, getValidNames, optionNullableMemberDecorator } from '../utils'
+import { obtainSlot, toComponentReverse, filterNames, getValidOwnPropertyNames, optionNullableMemberDecorator } from '../utils'
 
 export const HookNames: ReadonlyArray<string> = [
     "beforeCreate",
@@ -39,16 +39,16 @@ export function build(cons: VueCons, optionBuilder: OptionBuilder) {
     const HookFunctions: Record<string, Function> = {}
     const MethodFunctions: Record<string, Function> = {}
     protoArr.forEach(proto => {
-        let names = getValidNames(proto, (des, name) => {
+        let names = getValidOwnPropertyNames(proto, (des, name) => {
             return typeof des.value === 'function' && name !== 'constructor'
         })
-        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', 'provide'].includes(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
+        //provide, user may access field directly
+        //customDecorator
+        names = filterNames(names, slot, ['watch', 'hooks', 'emits', 'provide', 'customDecorator']);
         names.forEach(name => {
             if (HookNames.includes(name) || map.has(name)) {
                 HookFunctions[name] = proto[name]

src/utils.ts

@@ -31,12 +31,13 @@ export type SlotMapTypes = {
     setup: Map<string, SetupConfig>
     customDecorator: Map<string, CustomDecoratorRecord[]>
 }
+type SlotMapNames = keyof SlotMapTypes
 class Slot {
     master: any
     constructor(master: any) {
         this.master = master
     }
-    names: Map<string, SlotMapTypes[keyof SlotMapTypes]> = new Map()
+    names: Map<keyof SlotMapTypes, SlotMapTypes[keyof SlotMapTypes]> = new Map()
     obtainMap<T extends keyof SlotMapTypes>(name: T): SlotMapTypes[T] {
         let map = this.getMap(name)
         if (!map) {
@@ -112,26 +113,25 @@ export function getSuperSlot(obj: any) {
 }
 
 /**
- * Exclude decorated names by a filter
+ * Filter decorated names
  */
-export function excludeNames(names: string[], slot: Slot, filter?: (mapName: string) => boolean) {
+export function filterNames(names: string[], slot: Slot, mapNames?: SlotMapNames[]) {
     return names.filter(name => {
         let currSlot: Slot | null = slot
         while (currSlot != null) {
             for (const mapName of currSlot.names.keys()) {
-                if (filter && !filter(mapName)) {
-                    continue
-                }
                 if (mapName === 'customDecorator') {
                     const map = currSlot.obtainMap('customDecorator')
                     if (map.has(name)) {
                         if (map.get(name)!.every(ite => !ite.preserve)) {
                             return false
-                        } else {
-                            continue
                         }
                     }
                 }
+                if (mapNames && mapNames.includes(mapName)) {
+                    continue
+                }
+                
                 const map = currSlot.names.get(mapName)!
                 if (map.has(name)) {
                     return false
@@ -145,13 +145,22 @@ export function excludeNames(names: string[], slot: Slot, filter?: (mapName: str
 }
 
 /**
- * Get own properties by a filter
+ * Get own propertie name by a filter
  */
-export function getValidNames(obj: any, filter: (des: PropertyDescriptor, name: string) => boolean) {
+export function getValidOwnPropertyNames(obj: any, filter: (des: PropertyDescriptor, name: string) => boolean) {
     const descriptors = Object.getOwnPropertyDescriptors(obj)
     return Object.keys(descriptors).filter(name => filter(descriptors[name], name))
 }
 
+
+/**
+ * Transform provide into function.
+ */
+export function getProviderFunction(provide: any): () => {} {
+    if (typeof provide === 'function') return provide
+    return function () { return provide || {} }
+}
+
 export function optionNullableMemberDecorator<T>(handler: { (proto: any, name: string, option?: T): any }) {
     function decorator(): any
     function decorator(option: T): any//option
@@ -197,7 +206,3 @@ export function optionNullableClassDecorator<T>(handler: { (cons: VueCons, optio
     return decorator
 }
 
-export function getProviderFunction(provide: any): () => {} {
-    if (typeof provide === 'function') return provide
-    return function () { return provide || {} }
-}