@leafer/decorator 1.0.0-rc.9 → 1.0.1

package/package.json

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

package/src/data.ts

@@ -1,191 +1,208 @@
-import { ILeafData, ILeaf, IObject, IValue } from '@leafer/interface'
+import { ILeafData, ILeaf, IObject, IValue, ILeafAttrDescriptor, ILeafAttrDescriptorFn } from '@leafer/interface'
 import { defineKey, getDescriptor } from './object'
 import { Debug } from '@leafer/debug'
 
 
 // name
 
-export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
-    const defaultDescriptor: IObject & ThisType<ILeaf> = {
+export function decorateLeafAttr(defaultValue?: IValue, descriptorFn?: ILeafAttrDescriptorFn) {
+    return (target: ILeaf, key: string) => defineLeafAttr(target, key, defaultValue, descriptorFn && descriptorFn(key))
+}
+
+export function attr(partDescriptor?: ILeafAttrDescriptor): ILeafAttrDescriptor {
+    return partDescriptor
+}
+
+
+export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, partDescriptor?: ILeafAttrDescriptor): void {
+    const defaultDescriptor: ILeafAttrDescriptor = {
         get() { return this.__getAttr(key) },
-        set(value: IValue) { this.__setAttr(key, value) },
-        configurable: true,
-        enumerable: true
+        set(value: IValue) { this.__setAttr(key, value) }
     }
-    defineKey(target, key, Object.assign(defaultDescriptor, mergeDescriptor || {}))
+    defineKey(target, key, Object.assign(defaultDescriptor, partDescriptor || {}))
     defineDataProcessor(target, key, defaultValue)
 }
 
+
 export function dataType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue)
-    }
+    return decorateLeafAttr(defaultValue)
 }
 
-export function positionType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.matrixChanged || this.__layout.matrixChange()
-            }
-        })
-    }
+export function positionType(defaultValue?: IValue, checkFiniteNumber?: boolean) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.matrixChanged || this.__layout.matrixChange())
+        }
+    }))
 }
 
 export function autoLayoutType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            if (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()
-            }
-        })
-    }
+export function scaleType(defaultValue?: IValue, checkFiniteNumber?: boolean) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.scaleChanged || this.__layout.scaleChange())
+
+        }
+    }))
 }
 
+export function rotationType(defaultValue?: IValue, checkFiniteNumber?: boolean) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value, checkFiniteNumber) && (this.__layout.rotationChanged || this.__layout.rotationChange())
+        }
 
-export function rotationType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.rotationChanged || this.__layout.rotationChange()
+    }))
+}
 
-            }
-        })
-    }
+export function boundsType(defaultValue?: IValue, checkFiniteNumber?: boolean) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value, checkFiniteNumber) && doBoundsType(this)
+        }
+    }))
 }
 
-export function boundsType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.boxChanged || this.__layout.boxChange()
-                if (this.__hasAutoLayout) this.__layout.matrixChanged || this.__layout.matrixChange()
-            }
-        })
-    }
+export function naturalBoundsType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value) && (doBoundsType(this), this.__.__removeNaturalSize())
+        }
+    }))
+}
+
+export function doBoundsType(leaf: ILeaf): void {
+    leaf.__layout.boxChanged || leaf.__layout.boxChange()
+    if (leaf.__hasAutoLayout) leaf.__layout.matrixChanged || leaf.__layout.matrixChange()
+}
+
+export function pathInputType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            const data = this.__
+            if (data.__pathInputed !== 2) data.__pathInputed = value ? 1 : 0
+            if (!value) data.__pathForRender = undefined
+            this.__setAttr(key, value)
+            doBoundsType(this)
+        }
+    }))
 }
 
 export const pathType = boundsType
 
 
 export function affectStrokeBoundsType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.strokeChanged || this.__layout.strokeChange()
-            }
-        })
-    }
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value) && doStrokeType(this)
+        }
+    }))
+}
+
+export function doStrokeType(leaf: ILeaf): void {
+    leaf.__layout.strokeChanged || leaf.__layout.strokeChange()
+    if (leaf.__.__useArrow) doBoundsType(leaf)
 }
 
 export const strokeType = affectStrokeBoundsType
 
 export function affectRenderBoundsType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.renderChanged || this.__layout.renderChange()
-            }
-        })
-    }
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value)
+            this.__layout.renderChanged || this.__layout.renderChange()
+        }
+    }))
 }
 
 export function surfaceType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
-                this.__layout.surfaceChanged || this.__layout.surfaceChange()
-            }
-        })
-    }
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value) && (this.__layout.surfaceChanged || this.__layout.surfaceChange())
+        }
+    }))
 }
 
 export function opacityType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value) && (this.__layout.opacityChanged || this.__layout.opacityChange())
+        }
+    }))
+}
+
+export function visibleType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            const oldValue = this.visible
+            if (this.__setAttr(key, value)) {
                 this.__layout.opacityChanged || this.__layout.opacityChange()
+                if (oldValue === 0 || value === 0) doBoundsType(this) // 0 = display: none
             }
-        })
-    }
+        }
+    }))
 }
 
 export function sortType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            if (this.__setAttr(key, value)) {
                 this.__layout.surfaceChanged || this.__layout.surfaceChange()
                 this.waitParent(() => { this.parent.__layout.childrenSortChange() })
             }
-        })
-    }
+        }
+    }))
 }
 
 export function maskType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: boolean) {
-                this.__setAttr(key, value)
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: boolean) {
+            if (this.__setAttr(key, value)) {
                 this.__layout.boxChanged || this.__layout.boxChange()
                 this.waitParent(() => { this.parent.__updateMask(value) })
             }
-        })
-    }
+        }
+    }))
 }
 
 export function eraserType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: boolean) {
-                this.__setAttr(key, value)
-                this.waitParent(() => { this.parent.__updateEraser(value) })
-            }
-        })
-    }
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: boolean) {
+            this.__setAttr(key, value) && this.waitParent(() => { this.parent.__updateEraser(value) })
+        }
+    }))
 }
 
 export function hitType(defaultValue?: IValue) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: IValue) {
-                this.__setAttr(key, value)
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            if (this.__setAttr(key, value)) {
+                this.__layout.hitCanvasChanged = true
                 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()
-            }
-        })
-    }
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value)
+            if (this.leafer) this.leafer.updateCursor()
+        }
+    }))
 }
 
 
@@ -229,9 +246,7 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: I
         },
         set(value: IValue) {
             (this as IObject)[computedKey] = value
-        },
-        configurable: true,
-        enumerable: true
+        }
     }
 
     if (defaultValue === undefined) {
@@ -239,12 +254,22 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: I
     } else if (key === 'width') {
         property.get = function () {
             const v = this[computedKey]
-            return v === undefined ? ((this as ILeafData).__naturalWidth || defaultValue) : v
+            if (v === undefined) {
+                const t = this as ILeafData
+                return (t as IObject)._height && t.__naturalWidth && t.__useNaturalRatio ? (t as IObject)._height * t.__naturalWidth / t.__naturalHeight : t.__naturalWidth || defaultValue
+            } else {
+                return v
+            }
         }
     } else if (key === 'height') {
         property.get = function () {
             const v = this[computedKey]
-            return v === undefined ? ((this as ILeafData).__naturalHeight || defaultValue) : v
+            if (v === undefined) {
+                const t = this as ILeafData
+                return (t as IObject)._width && t.__naturalHeight && t.__useNaturalRatio ? (t as IObject)._width * t.__naturalHeight / t.__naturalWidth : t.__naturalHeight || defaultValue
+            } else {
+                return v
+            }
         }
     }
 
@@ -262,7 +287,7 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: I
         delete data[setMethodName]
     }
 
-    Object.defineProperty(data, key, property)
+    defineKey(data, key, property)
 
 }
 

package/src/index.ts

@@ -1,4 +1,4 @@
-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 { defineLeafAttr, decorateLeafAttr, attr, dataType, positionType, autoLayoutType, boundsType, doBoundsType, naturalBoundsType, affectStrokeBoundsType, doStrokeType, strokeType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, visibleType, sortType, maskType, eraserType, hitType, pathType, pathInputType, cursorType, dataProcessor, layoutProcessor, defineDataProcessor } from './data'
 export { useModule, rewrite, rewriteAble } from './rewrite'
 export { defineKey, getDescriptor } from './object'
 export { registerUI, registerUIEvent } from './class'

package/src/object.ts

@@ -1,6 +1,7 @@
 import { IObject } from '@leafer/interface'
 
-export function defineKey<T>(target: T, key: string, descriptor: IObject & ThisType<T>): void {
+export function defineKey<T>(target: T, key: string, descriptor: IObject & ThisType<T>, noConfigurable?: boolean): void {
+    if (!noConfigurable) descriptor.configurable = descriptor.enumerable = true
     Object.defineProperty(target, key, descriptor)
 }
 

package/types/index.d.ts

@@ -1,18 +1,25 @@
-import { ILeaf, IValue, IObject, IFunction } from '@leafer/interface';
+import { IValue, ILeafAttrDescriptorFn, ILeaf, ILeafAttrDescriptor, IObject, IFunction } from '@leafer/interface';
 
-declare function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, mergeDescriptor?: IObject & ThisType<ILeaf>): void;
+declare function decorateLeafAttr(defaultValue?: IValue, descriptorFn?: ILeafAttrDescriptorFn): (target: ILeaf, key: string) => void;
+declare function attr(partDescriptor?: ILeafAttrDescriptor): ILeafAttrDescriptor;
+declare function defineLeafAttr(target: ILeaf, key: string, defaultValue?: IValue, partDescriptor?: ILeafAttrDescriptor): void;
 declare function dataType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
-declare function positionType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function positionType(defaultValue?: IValue, checkFiniteNumber?: boolean): (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 function scaleType(defaultValue?: IValue, checkFiniteNumber?: boolean): (target: ILeaf, key: string) => void;
+declare function rotationType(defaultValue?: IValue, checkFiniteNumber?: boolean): (target: ILeaf, key: string) => void;
+declare function boundsType(defaultValue?: IValue, checkFiniteNumber?: boolean): (target: ILeaf, key: string) => void;
+declare function naturalBoundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function doBoundsType(leaf: ILeaf): void;
+declare function pathInputType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
 declare const pathType: typeof boundsType;
 declare function affectStrokeBoundsType(defaultValue?: IValue): (target: ILeaf, key: string) => void;
+declare function doStrokeType(leaf: ILeaf): 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 visibleType(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;
@@ -26,10 +33,10 @@ declare function rewrite(method: IFunction): (target: IObject, key: string) => v
 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 defineKey<T>(target: T, key: string, descriptor: IObject & ThisType<T>, noConfigurable?: boolean): 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 };
+export { affectRenderBoundsType, affectStrokeBoundsType, attr, autoLayoutType, boundsType, cursorType, dataProcessor, dataType, decorateLeafAttr, defineDataProcessor, defineKey, defineLeafAttr, doBoundsType, doStrokeType, eraserType, getDescriptor, hitType, layoutProcessor, maskType, naturalBoundsType, opacityType, pathInputType, pathType, positionType, registerUI, registerUIEvent, rewrite, rewriteAble, rotationType, scaleType, sortType, strokeType, surfaceType, useModule, visibleType };