@leafer/decorator 1.0.0-rc.1 → 1.0.0-rc.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/decorator",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0-rc.10",
   "description": "@leafer/decorator",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,10 +22,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/platform": "1.0.0-rc.1",
-    "@leafer/debug": "1.0.0-rc.1"
+    "@leafer/platform": "1.0.0-rc.10",
+    "@leafer/debug": "1.0.0-rc.10"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-rc.1"
+    "@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,13 +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.__.around) this.__layout.positionChanged || this.__layout.positionChange()
+                if (this.__hasAutoLayout) this.__layout.matrixChanged || this.__layout.matrixChange()
             }
         })
     }
@@ -83,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()
             }
@@ -96,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()
             }
@@ -107,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()
             }
@@ -118,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()
             }
@@ -129,10 +131,10 @@ 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.childrenSortChange() })
@@ -141,7 +143,7 @@ export function sortType(defaultValue?: __Value) {
     }
 }
 
-export function maskType(defaultValue?: __Value) {
+export function maskType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
             set(value: boolean) {
@@ -153,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) {
@@ -164,10 +166,10 @@ 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()
@@ -176,10 +178,10 @@ export function hitType(defaultValue?: __Value) {
     }
 }
 
-export function cursorType(defaultValue?: __Value) {
+export function cursorType(defaultValue?: IValue) {
     return (target: ILeaf, key: string) => {
         defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
+            set(value: IValue) {
                 this.__setAttr(key, value)
                 if (this.leafer) this.leafer.updateCursor()
             }
@@ -191,7 +193,7 @@ export function cursorType(defaultValue?: __Value) {
 // get
 
 export function dataProcessor(processor: IObject) {
-    return (target: ILeaf, _key: string) => {
+    return (target: IObject, _key?: string) => {
         defineKey(target, '__DataProcessor', {
             get() { return processor }
         })
@@ -199,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 }
         })
@@ -213,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
@@ -250,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, cursorType, 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

@@ -1,27 +1,26 @@
-import { ILeaf, __Value, IObject, IFunction } from '@leafer/interface';
+import { ILeaf, IValue, IObject, IFunction } from '@leafer/interface';
 
-declare function aliasType(name: string): (target: ILeaf, key: string) => void;
-declare function defineLeafAttr(target: ILeaf, key: string, defaultValue?: __Value, mergeDescriptor?: IObject & ThisType<ILeaf>): void;
-declare function dataType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function positionType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function scaleType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function rotationType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function boundsType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
+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?: __Value): (target: ILeaf, key: string) => void;
+declare function affectStrokeBoundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
 declare const strokeType: typeof affectStrokeBoundsType;
-declare function affectRenderBoundsType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function surfaceType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function opacityType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function sortType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function maskType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function eraserType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function hitType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function cursorType(defaultValue?: __Value): (target: ILeaf, key: string) => void;
-declare function dataProcessor(processor: IObject): (target: ILeaf, _key: string) => void;
-declare function layoutProcessor(processor: IObject): (target: ILeaf, _key: string) => void;
-declare function setDefaultValue(target: IObject, key: string, defaultValue: __Value): void;
-declare function defineDataProcessor(target: ILeaf, key: string, defaultValue?: __Value): void;
+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;
@@ -33,4 +32,4 @@ declare function getDescriptor(object: IObject, name: string): PropertyDescripto
 declare function registerUI(): (target: IObject) => void;
 declare function registerUIEvent(): (target: IObject) => void;
 
-export { affectRenderBoundsType, affectStrokeBoundsType, aliasType, boundsType, cursorType, dataProcessor, dataType, defineDataProcessor, defineKey, defineLeafAttr, eraserType, getDescriptor, hitType, layoutProcessor, maskType, opacityType, pathType, positionType, registerUI, registerUIEvent, rewrite, rewriteAble, rotationType, scaleType, setDefaultValue, sortType, strokeType, surfaceType, useModule };
+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 };