@leafer/decorator 1.0.0-alpha.7 → 1.0.0-bate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/decorator",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-bate",
   "description": "@leafer/decorator",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,10 +19,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/platform": "1.0.0-alpha.7",
-    "@leafer/debug": "1.0.0-alpha.7"
+    "@leafer/platform": "1.0.0-bate",
+    "@leafer/debug": "1.0.0-bate"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-alpha.7"
+    "@leafer/interface": "1.0.0-bate"
   }
 }

package/src/class.ts

@@ -1,12 +1,14 @@
 import { IObject } from '@leafer/interface'
 import { EventCreator, UICreator } from '@leafer/platform'
 
-export function registerUI() { return (target: IObject) => registerUI__(target) }
-export function registerUI__(target: IObject) {
-    UICreator.register(target)
+export function registerUI() {
+    return (target: IObject) => {
+        UICreator.register(target)
+    }
 }
 
-export function registerEvent() { return (target: IObject) => registerEvent__(target) }
-export function registerEvent__(target: IObject) {
-    EventCreator.register(target)
+export function registerUIEvent() {
+    return (target: IObject) => {
+        EventCreator.register(target)
+    }
 }

package/src/data.ts

@@ -1,165 +1,195 @@
 import { ILeafData, ILeaf, IObject, __Value } from '@leafer/interface'
 import { defineKey, getDescriptor } from './object'
+import { Debug } from '@leafer/debug'
+
 
 // name
 
-export function aliasType(name: string) { return (target: ILeaf, key: string) => aliasType__(target, key, name) }
-export function aliasType__(target: ILeaf, key: string, name: string) {
-    defineKey(target, key, {
-        get() { return this.__get(name) },
-        set(value: __Value) {
-            this.root ? this.__set(name, value) : this.__[name] = value
-        }
-    })
+export function aliasType(name: string) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__getAttr(name) },
+            set(value: __Value) {
+                this.__setAttr(name, value)
+            }
+        })
+    }
 }
 
-export function dataType(defaultValue?: __Value) { return (target: ILeaf, key: string) => dataType__(target, key, defaultValue) }
-export function dataType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-        }
-    })
+export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: __Value, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
+    const defaultDescriptor: IObject & ThisType<ILeaf> = {
+        get() { return this.__getAttr(key) },
+        set(value: __Value) { this.__setAttr(key, value) },
+        configurable: true,
+        enumerable: true
+    }
+    defineKey(target, key, Object.assign(defaultDescriptor, mergeDescriptor || {}))
     defineDataProcessor(target, key, defaultValue)
 }
 
-
-export function positionType(defaultValue?: __Value) { return (target: ILeaf, key: string) => positionType__(target, key, defaultValue) }
-export function positionType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.positionChanged || this.__layout.positionChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function dataType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue)
+    }
 }
 
+export function positionType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.positionChanged || this.__layout.positionChange()
+            }
+        })
+    }
+}
 
-export function scaleType(defaultValue?: __Value) { return (target: ILeaf, key: string) => scaleType__(target, key, defaultValue) }
-export function scaleType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.scaleChanged || this.__layout.scaleChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function scaleType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.scaleChanged || this.__layout.scaleChange()
+            }
+        })
+    }
 }
 
-export function rotationType(defaultValue?: __Value) { return (target: ILeaf, key: string) => rotationType__(target, key, defaultValue) }
-export function rotationType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.rotationChanged || this.__layout.rotationChange()
 
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function rotationType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.rotationChanged || this.__layout.rotationChange()
+
+            }
+        })
+    }
 }
 
-export function boundsType(defaultValue?: __Value) { return (target: ILeaf, key: string) => boundsType__(target, key, defaultValue) }
-export function boundsType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.boxBoundsChanged || this.__layout.boxBoundsChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function boundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.boxChanged || this.__layout.boxChange()
+            }
+        })
+    }
 }
 
 export const pathType = boundsType
-export const pathType__ = boundsType__
 
 
-export function affectEventBoundsType(defaultValue?: __Value) { return (target: ILeaf, key: string) => affectEventBoundsType__(target, key, defaultValue) }
-export function affectEventBoundsType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.eventBoundsChanged || this.__layout.eventBoundsChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function affectStrokeBoundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.strokeChanged || this.__layout.strokeChange()
+            }
+        })
+    }
 }
 
-export function affectRenderBoundsType(defaultValue?: __Value) { return (target: ILeaf, key: string) => affectRenderBoundsType__(target, key, defaultValue) }
-export function affectRenderBoundsType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.renderBoundsChanged || this.__layout.renderBoundsChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export const strokeType = affectStrokeBoundsType
+
+export function affectRenderBoundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.renderChanged || this.__layout.renderChange()
+            }
+        })
+    }
 }
 
-export function surfaceType(defaultValue?: __Value) { return (target: ILeaf, key: string) => surfaceType__(target, key, defaultValue) }
-export function surfaceType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.surfaceChanged || this.__layout.surfaceChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function surfaceType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.surfaceChanged || this.__layout.surfaceChange()
+            }
+        })
+    }
 }
 
-export function opacityType(defaultValue?: __Value) { return (target: ILeaf, key: string) => opacityType__(target, key, defaultValue) }
-export function opacityType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.opacityChanged || this.__layout.opacityChange()
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+export function opacityType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.opacityChanged || this.__layout.opacityChange()
+            }
+        })
+    }
 }
 
-export function sortType(defaultValue?: __Value) { return (target: ILeaf, key: string) => { sortType__(target, key, defaultValue) } }
-export function sortType__(target: ILeaf, key: string, defaultValue?: __Value) {
-    defineKey(target, key, {
-        get() { return this.__get(key) },
-        set(value: __Value) {
-            this.root ? this.__set(key, value) : this.__[key] = value
-            this.__layout.surfaceChanged || this.__layout.surfaceChange()
+export function sortType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.surfaceChanged || this.__layout.surfaceChange()
+
+                if (this.parent) {
+                    this.parent.__layout.childrenSortChanged = true
+                } else {
+                    this.waitParent(() => { this.parent.__layout.childrenSortChanged = true })
+                }
+            }
+        })
+    }
+}
 
-            if (this.parent) {
-                this.parent.__layout.childrenSortChanged || (this.parent.__layout.childrenSortChanged = true)
-            } else {
-                this.__addParentWait(() => { this.parent.__layout.childrenSortChanged || (this.parent.__layout.childrenSortChanged = true) })
+export function maskType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: boolean) {
+                this.__setAttr(key, value)
+                this.__layout.boxChanged || this.__layout.boxChange()
+
+                if (this.parent) {
+                    this.parent.__updateMask(value)
+                } else {
+                    this.waitParent(() => { this.parent.__updateMask(value) })
+                }
             }
-        }
-    })
-    defineDataProcessor(target, key, defaultValue)
+        })
+    }
+}
+
+export function hitType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                if (Debug.showHitView) { this.__layout.surfaceChanged || this.__layout.surfaceChange() }
+            }
+        })
+    }
 }
 
 
 // get
 
-export function dataProcessor(processor: IObject) { return (target: ILeaf, _key: string) => dataProcessor__(target, processor) }
-export function dataProcessor__(target: ILeaf, processor: IObject) {
-    defineKey(target, '__DataProcessor', {
-        get() { return processor }
-    })
+export function dataProcessor(processor: IObject) {
+    return (target: ILeaf, _key: string) => {
+        defineKey(target, '__DataProcessor', {
+            get() { return processor }
+        })
+    }
 }
 
-export function layoutProcessor(processor: IObject) { return (target: ILeaf, _key: string) => layoutProcessor__(target, processor) }
-export function layoutProcessor__(target: ILeaf, processor: IObject) {
-    defineKey(target, '__LayoutProcessor', {
-        get() { return processor }
-    })
+export function layoutProcessor(processor: IObject) {
+    return (target: ILeaf, _key: string) => {
+        defineKey(target, '__LayoutProcessor', {
+            get() { return processor }
+        })
+    }
 }
 
 
@@ -169,8 +199,12 @@ function getSetMethodName(key: string): string {
     return 'set' + key.charAt(0).toUpperCase() + key.slice(1)
 }
 
+export function setDefaultValue(target: IObject, key: string, defaultValue: __Value): void {
+    defineDataProcessor(target.prototype, key, defaultValue)
+}
+
 // define leaf.__[key] getter/setter
-export function defineDataProcessor(target: ILeaf, key: string, defaultValue: __Value): void {
+export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: __Value): void {
 
     const data = target.__DataProcessor.prototype as ILeafData
     const computedKey = '_' + key
@@ -183,17 +217,16 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue: __
         },
         set(value: __Value) {
             this[computedKey] = value
-        }
+        },
+        configurable: true,
+        enumerable: true
     }
 
     if (defaultValue === undefined) property.get = function () { return this[computedKey] }
 
     const descriptor = getDescriptor(data, key)
 
-    if (descriptor) {
-        if (descriptor.set) property.set = descriptor.set // use custom set
-        if (descriptor.get) property.get = descriptor.get // use custom get
-    }
+    if (descriptor && descriptor.set) property.set = descriptor.set // use custom set
 
     if (data[setMethodName]) {
         property.set = data[setMethodName] //  use custom setKey(value)

package/src/define.ts

@@ -0,0 +1,35 @@
+import { ILeaf, IObject, __Value } from '@leafer/interface'
+
+import * as types from './data'
+
+interface IDataTypeFunction {
+    (target: ILeaf, key: string): void
+}
+
+interface IDataTypeDecorator {
+    (...arg: any): IDataTypeFunction
+}
+
+interface IDataTypeDecoratorMap {
+    [key: string]: IDataTypeDecorator
+}
+
+export const DataTypeDecorator = {
+
+    list: {} as IDataTypeDecoratorMap,
+
+    register(name: string, decorator: IDataTypeDecorator): void {
+        this.list[name] = decorator
+    },
+
+    get(name: string): IDataTypeDecorator {
+        const decorator = this.list[name]
+        return decorator
+    }
+}
+
+Object.keys(types).forEach(key => {
+    if (key.includes('Type')) {
+        DataTypeDecorator.register(key, (types as IObject)[key] as IDataTypeDecorator)
+    }
+})

package/src/index.ts

@@ -1,4 +1,4 @@
-export { registerUI, registerUI__, registerEvent, registerEvent__ } from './class'
-export { aliasType, aliasType__, dataType, dataType__, positionType, positionType__, boundsType, boundsType__, affectEventBoundsType, affectEventBoundsType__, affectRenderBoundsType, affectRenderBoundsType__, scaleType, scaleType__, rotationType, rotationType__, surfaceType, surfaceType__, opacityType, opacityType__, sortType, sortType__, pathType, pathType__, dataProcessor, dataProcessor__, layoutProcessor, layoutProcessor__, defineDataProcessor } from './data'
-export { useModule, useModule__, rewrite, rewriteAble } from './rewrite'
-export { defineKey, getDescriptor } from './object'
+export { aliasType, defineLeafAttr, dataType, positionType, boundsType, affectStrokeBoundsType, strokeType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, sortType, maskType, hitType, pathType, dataProcessor, layoutProcessor, setDefaultValue, defineDataProcessor } from './data'
+export { useModule, rewrite, rewriteAble } from './rewrite'
+export { defineKey, getDescriptor } from './object'
+export { registerUI, registerUIEvent } from './class'

package/src/rewrite.ts

@@ -42,17 +42,18 @@ setTimeout(() => doRewrite(true))
 
 // class
 
-export function useModule(module: IObject) { return (target: IObject) => useModule__(target, module) }
-export function useModule__(target: IObject, module: IObject) {
-    const names = module.prototype ? getNames(module.prototype) : Object.keys(module)
-    names.forEach(name => {
-        if (!excludeNames.includes(name)) {
-            if (module.prototype) {
-                const d = getDescriptor(module.prototype, name)
-                if (d.writable) target.prototype[name] = module.prototype[name]
-            } else {
-                target.prototype[name] = module[name]
+export function useModule(module: IObject, exclude?: string[]) {
+    return (target: IObject) => {
+        const names = module.prototype ? getNames(module.prototype) : Object.keys(module)
+        names.forEach(name => {
+            if (!excludeNames.includes(name) && (!exclude || !exclude.includes(name))) {
+                if (module.prototype) {
+                    const d = getDescriptor(module.prototype, name)
+                    if (d.writable) target.prototype[name] = module.prototype[name]
+                } else {
+                    target.prototype[name] = module[name]
+                }
             }
-        }
-    })
-}
+        })
+    }
+}