@leafer/decorator 1.0.0-rc.3 → 1.0.0-rc.30

package/package.json

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

package/src/data.ts

@@ -1,197 +1,215 @@
-import { ILeafData, ILeaf, IObject, __Value } 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 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 decorateLeafAttr(defaultValue?: IValue, descriptorFn?: ILeafAttrDescriptorFn) {
+    return (target: ILeaf, key: string) => defineLeafAttr(target, key, defaultValue, descriptorFn && descriptorFn(key))
 }
 
-export function defineLeafAttr(target: ILeaf, key: string, defaultValue?: __Value, mergeDescriptor?: IObject & ThisType<ILeaf>): void {
-    const defaultDescriptor: IObject & ThisType<ILeaf> = {
+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: __Value) { 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?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue)
-    }
+
+export function dataType(defaultValue?: IValue) {
+    return decorateLeafAttr(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 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 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 autoLayoutType(defaultValue?: IValue) {
+    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, 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?: __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 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 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()
-                if (this.__.around) this.__layout.positionChanged || this.__layout.positionChange()
-            }
-        })
-    }
+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 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?: __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 affectStrokeBoundsType(defaultValue?: IValue) {
+    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?: __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 affectRenderBoundsType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value)
+            this.__layout.renderChanged || this.__layout.renderChange()
+        }
+    }))
 }
 
-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 surfaceType(defaultValue?: IValue) {
+    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 decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value) && (this.__layout.opacityChanged || this.__layout.opacityChange())
+        }
+    }))
 }
 
-export function opacityType(defaultValue?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
-                this.__setAttr(key, value)
+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?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
-                this.__setAttr(key, value)
+export function sortType(defaultValue?: IValue) {
+    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?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: boolean) {
-                this.__setAttr(key, value)
+export function maskType(defaultValue?: IValue) {
+    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?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: boolean) {
-                this.__setAttr(key, value)
-                this.waitParent(() => { this.parent.__updateEraser(value) })
-            }
-        })
-    }
+export function eraserType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: boolean) {
+            this.__setAttr(key, value) && this.waitParent(() => { this.parent.__updateEraser(value) })
+        }
+    }))
 }
 
-export function hitType(defaultValue?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
-                this.__setAttr(key, value)
+export function hitType(defaultValue?: IValue) {
+    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?: __Value) {
-    return (target: ILeaf, key: string) => {
-        defineLeafAttr(target, key, defaultValue, {
-            set(value: __Value) {
-                this.__setAttr(key, value)
-                if (this.leafer) this.leafer.updateCursor()
-            }
-        })
-    }
+export function cursorType(defaultValue?: IValue) {
+    return decorateLeafAttr(defaultValue, (key: string) => attr({
+        set(value: IValue) {
+            this.__setAttr(key, value)
+            if (this.leafer) this.leafer.updateCursor()
+        }
+    }))
 }
 
 
 // get
 
 export function dataProcessor(processor: IObject) {
-    return (target: ILeaf, _key: string) => {
+    return (target: IObject, _key?: string) => {
         defineKey(target, '__DataProcessor', {
             get() { return processor }
         })
@@ -199,7 +217,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,27 +231,22 @@ 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
-        },
-        configurable: true,
-        enumerable: true
+        set(value: IValue) {
+            (this as IObject)[computedKey] = value
+        }
     }
 
     if (defaultValue === undefined) {
@@ -241,25 +254,40 @@ export function defineDataProcessor(target: ILeaf, key: string, defaultValue?: _
     } 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
+            }
         }
     }
 
-    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]
     }
 
-    Object.defineProperty(data, key, property)
+    defineKey(data, key, property)
 
 }
 

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, 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,36 +1,42 @@
-import { ILeaf, __Value, IObject, IFunction } from '@leafer/interface';
+import { IValue, ILeafAttrDescriptorFn, ILeaf, ILeafAttrDescriptor, 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 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, checkFiniteNumber?: boolean): (target: ILeaf, key: string) => void;
+declare function autoLayoutType(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?: __Value): (target: ILeaf, key: string) => void;
+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?: __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 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;
+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 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, 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, 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 };