@leafer/decorator 1.0.0-alpha.23 → 1.0.0-alpha.31

package/package.json

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

package/src/data.ts

@@ -1,5 +1,7 @@
 import { ILeafData, ILeaf, IObject, __Value } from '@leafer/interface'
 import { defineKey, getDescriptor } from './object'
+import { Debug } from '@leafer/debug'
+
 
 // name
 
@@ -14,11 +16,12 @@ export function aliasType(name: string) {
     }
 }
 
-
-export function defineLeafAttr(target: ILeaf, key: string, defaultValue: __Value, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
+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) }
+        set(value: __Value) { this.__setAttr(key, value) },
+        configurable: true,
+        enumerable: true
     }
     defineKey(target, key, Object.assign(defaultDescriptor, mergeDescriptor || {}))
     defineDataProcessor(target, key, defaultValue)
@@ -52,6 +55,7 @@ export function scaleType(defaultValue?: __Value) {
     }
 }
 
+
 export function rotationType(defaultValue?: __Value) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
@@ -78,7 +82,7 @@ export function boundsType(defaultValue?: __Value) {
 export const pathType = boundsType
 
 
-export function affectEventBoundsType(defaultValue?: __Value) {
+export function affectStrokeBoundsType(defaultValue?: __Value) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
             set(value: __Value) {
@@ -89,6 +93,8 @@ export function affectEventBoundsType(defaultValue?: __Value) {
     }
 }
 
+export const strokeType = affectStrokeBoundsType
+
 export function affectRenderBoundsType(defaultValue?: __Value) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
@@ -132,7 +138,7 @@ export function sortType(defaultValue?: __Value) {
                 if (this.parent) {
                     this.parent.__layout.childrenSortChanged = true
                 } else {
-                    this.__addParentWait(() => { this.parent.__layout.childrenSortChanged = true })
+                    this.waitParent(() => { this.parent.__layout.childrenSortChanged = true })
                 }
             }
         })
@@ -142,20 +148,31 @@ export function sortType(defaultValue?: __Value) {
 export function maskType(defaultValue?: __Value) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: boolean) {
                 this.__setAttr(key, value)
                 this.__layout.boxBoundsChanged || this.__layout.boxBoundsChange()
 
                 if (this.parent) {
-                    this.parent.__hasMask = value ? true : this.parent.children.some(item => item.isMask)
+                    this.parent.__updateMask(value)
                 } else {
-                    this.__addParentWait(() => { this.parent.__hasMask = value ? true : this.parent.children.some(item => item.isMask) })
+                    this.waitParent(() => { this.parent.__updateMask(value) })
                 }
             }
         })
     }
 }
 
+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
 
@@ -182,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
@@ -196,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 { aliasType, defineLeafAttr, dataType, positionType, boundsType, affectEventBoundsType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, sortType, maskType, pathType, dataProcessor, layoutProcessor, defineDataProcessor } from './data'
+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,11 +42,11 @@ setTimeout(() => doRewrite(true))
 
 // class
 
-export function useModule(module: IObject) {
+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)) {
+            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]