@leafer/decorator 1.0.0-beta.9 → 1.0.0-rc.10

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@leafer/decorator",
-  "version": "1.0.0-beta.9",
+  "version": "1.0.0-rc.10",
   "description": "@leafer/decorator",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
   "main": "src/index.ts",
+  "types": "types/index.d.ts",
   "files": [
-    "src"
+    "src",
+    "types",
+    "dist"
   ],
   "repository": {
     "type": "git",
@@ -19,10 +22,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/platform": "1.0.0-beta.9",
-    "@leafer/debug": "1.0.0-beta.9"
+    "@leafer/platform": "1.0.0-rc.10",
+    "@leafer/debug": "1.0.0-rc.10"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-beta.9"
+    "@leafer/interface": "1.0.0-rc.10"
   }
 }

package/src/data.ts

@@ -1,25 +1,14 @@
-import { ILeafData, ILeaf, IObject, __Value } from '@leafer/interface'
+import { ILeafData, ILeaf, IObject, IValue } from '@leafer/interface'
 import { defineKey, getDescriptor } from './object'
 import { Debug } from '@leafer/debug'
 
 
 // name
 
-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 defineLeafAttr(target: ILeaf, key: string, defaultValue?: __Value, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
+export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
     const defaultDescriptor: IObject & ThisType<ILeaf> = {
         get() { return this.__getAttr(key) },
-        set(value: __Value) { this.__setAttr(key, value) },
+        set(value: IValue) { this.__setAttr(key, value) },
         configurable: true,
         enumerable: true
     }
@@ -27,27 +16,40 @@ export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: __Valu
     defineDataProcessor(target, key, defaultValue)
 }
 
-export function dataType(defaultValue?: __Value) {
+export function dataType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue)
     }
 }
 
-export function positionType(defaultValue?: __Value) {
+export function positionType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
-                this.__layout.positionChanged || this.__layout.positionChange()
+                this.__layout.matrixChanged || this.__layout.matrixChange()
             }
         })
     }
 }
 
-export function scaleType(defaultValue?: __Value) {
+export function autoLayoutType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
+                this.__setAttr(key, value)
+                this.__layout.matrixChanged || this.__layout.matrixChange()
+                this.__hasAutoLayout = !!value
+                if (!this.__local) this.__layout.createLocal()
+            }
+        })
+    }
+}
+
+export function scaleType(defaultValue?: IValue) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.scaleChanged || this.__layout.scaleChange()
             }
@@ -56,10 +58,10 @@ export function scaleType(defaultValue?: __Value) {
 }
 
 
-export function rotationType(defaultValue?: __Value) {
+export function rotationType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.rotationChanged || this.__layout.rotationChange()
 
@@ -68,12 +70,13 @@ export function rotationType(defaultValue?: __Value) {
     }
 }
 
-export function boundsType(defaultValue?: __Value) {
+export function boundsType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.boxChanged || this.__layout.boxChange()
+                if (this.__hasAutoLayout) this.__layout.matrixChanged || this.__layout.matrixChange()
             }
         })
     }
@@ -82,10 +85,10 @@ export function boundsType(defaultValue?: __Value) {
 export const pathType = boundsType
 
 
-export function affectStrokeBoundsType(defaultValue?: __Value) {
+export function affectStrokeBoundsType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.strokeChanged || this.__layout.strokeChange()
             }
@@ -95,10 +98,10 @@ export function affectStrokeBoundsType(defaultValue?: __Value) {
 
 export const strokeType = affectStrokeBoundsType
 
-export function affectRenderBoundsType(defaultValue?: __Value) {
+export function affectRenderBoundsType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.renderChanged || this.__layout.renderChange()
             }
@@ -106,10 +109,10 @@ export function affectRenderBoundsType(defaultValue?: __Value) {
     }
 }
 
-export function surfaceType(defaultValue?: __Value) {
+export function surfaceType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.surfaceChanged || this.__layout.surfaceChange()
             }
@@ -117,10 +120,10 @@ export function surfaceType(defaultValue?: __Value) {
     }
 }
 
-export function opacityType(defaultValue?: __Value) {
+export function opacityType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.opacityChanged || this.__layout.opacityChange()
             }
@@ -128,19 +131,19 @@ export function opacityType(defaultValue?: __Value) {
     }
 }
 
-export function sortType(defaultValue?: __Value) {
+export function sortType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 this.__layout.surfaceChanged || this.__layout.surfaceChange()
-                this.waitParent(() => { this.parent.__layout.childrenSortChanged = true })
+                this.waitParent(() => { this.parent.__layout.childrenSortChange() })
             }
         })
     }
 }
 
-export function maskType(defaultValue?: __Value) {
+export function maskType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
             set(value: boolean) {
@@ -152,7 +155,7 @@ export function maskType(defaultValue?: __Value) {
     }
 }
 
-export function eraserType(defaultValue?: __Value) {
+export function eraserType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
             set(value: boolean) {
@@ -163,12 +166,24 @@ export function eraserType(defaultValue?: __Value) {
     }
 }
 
-export function hitType(defaultValue?: __Value) {
+export function hitType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 if (Debug.showHitView) { this.__layout.surfaceChanged || this.__layout.surfaceChange() }
+                if (this.leafer) this.leafer.updateCursor()
+            }
+        })
+    }
+}
+
+export function cursorType(defaultValue?: IValue) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: IValue) {
+                this.__setAttr(key, value)
+                if (this.leafer) this.leafer.updateCursor()
             }
         })
     }
@@ -178,7 +193,7 @@ export function hitType(defaultValue?: __Value) {
 // get
 
 export function dataProcessor(processor: IObject) {
-    return (target: ILeaf, _key: string) => {
+    return (target: IObject, _key?: string) => {
         defineKey(target, '__DataProcessor', {
             get() { return processor }
         })
@@ -186,7 +201,7 @@ export function dataProcessor(processor: IObject) {
 }
 
 export function layoutProcessor(processor: IObject) {
-    return (target: ILeaf, _key: string) => {
+    return (target: IObject, _key?: string) => {
         defineKey(target, '__LayoutProcessor', {
             get() { return processor }
         })
@@ -200,24 +215,21 @@ 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?: IValue): void {
 
-    const data = target.__DataProcessor.prototype as ILeafData
+    const data = target.__DataProcessor.prototype
     const computedKey = '_' + key
     const setMethodName = getSetMethodName(key)
 
     const property: IObject & ThisType<ILeafData> = {
         get() {
-            const v = this[computedKey]
+            const v = (this as IObject)[computedKey]
             return v === undefined ? defaultValue : v
         },
-        set(value: __Value) {
-            this[computedKey] = value
+        set(value: IValue) {
+            (this as IObject)[computedKey] = value
         },
         configurable: true,
         enumerable: true
@@ -237,12 +249,17 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: _
         }
     }
 
-    const descriptor = getDescriptor(data, key)
+    // find parent proto
+    let descriptor, find = data
+    while (!descriptor && find) {
+        descriptor = getDescriptor(find, key)
+        find = find.__proto__
+    }
 
-    if (descriptor && descriptor.set) property.set = descriptor.set // use custom set
+    if (descriptor && descriptor.set) property.set = descriptor.set // use exist set
 
     if (data[setMethodName]) {
-        property.set = data[setMethodName] //  use custom setKey(value)
+        property.set = data[setMethodName] // first use custom setKey(value)
         delete data[setMethodName]
     }
 

package/src/define.ts

@@ -1,4 +1,4 @@
-import { ILeaf, IObject, __Value } from '@leafer/interface'
+import { ILeaf, IObject } from '@leafer/interface'
 
 import * as types from './data'
 

package/src/index.ts

@@ -1,4 +1,4 @@
-export { aliasType, defineLeafAttr, dataType, positionType, boundsType, affectStrokeBoundsType, strokeType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, sortType, maskType, eraserType, hitType, pathType, dataProcessor, layoutProcessor, setDefaultValue, defineDataProcessor } from './data'
+export { defineLeafAttr, dataType, positionType, autoLayoutType, boundsType, affectStrokeBoundsType, strokeType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, sortType, maskType, eraserType, hitType, pathType, cursorType, dataProcessor, layoutProcessor, defineDataProcessor } from './data'
 export { useModule, rewrite, rewriteAble } from './rewrite'
 export { defineKey, getDescriptor } from './object'
 export { registerUI, registerUIEvent } from './class'

package/types/index.d.ts

@@ -0,0 +1,35 @@
+import { ILeaf, IValue, IObject, IFunction } from '@leafer/interface';
+
+declare function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, mergeDescriptor?: IObject & ThisType<ILeaf>): void;
+declare function dataType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function positionType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function autoLayoutType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function scaleType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function rotationType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function boundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare const pathType: typeof boundsType;
+declare function affectStrokeBoundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare const strokeType: typeof affectStrokeBoundsType;
+declare function affectRenderBoundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function surfaceType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function opacityType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function sortType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function maskType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function eraserType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function hitType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function cursorType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function dataProcessor(processor: IObject): (target: IObject, _key?: string) => void;
+declare function layoutProcessor(processor: IObject): (target: IObject, _key?: string) => void;
+declare function defineDataProcessor(target: ILeaf, key: string, defaultValue?: IValue): void;
+
+declare function rewrite(method: IFunction): (target: IObject, key: string) => void;
+declare function rewriteAble(): (_target: IObject) => void;
+declare function useModule(module: IObject, exclude?: string[]): (target: IObject) => void;
+
+declare function defineKey<T>(target: T, key: string, descriptor: IObject & ThisType<T>): void;
+declare function getDescriptor(object: IObject, name: string): PropertyDescriptor;
+
+declare function registerUI(): (target: IObject) => void;
+declare function registerUIEvent(): (target: IObject) => void;
+
+export { affectRenderBoundsType, affectStrokeBoundsType, autoLayoutType, boundsType, cursorType, dataProcessor, dataType, defineDataProcessor, defineKey, defineLeafAttr, eraserType, getDescriptor, hitType, layoutProcessor, maskType, opacityType, pathType, positionType, registerUI, registerUIEvent, rewrite, rewriteAble, rotationType, scaleType, sortType, strokeType, surfaceType, useModule };