@leafer/decorator 1.0.0-beta.15 → 1.0.0-beta.16

package/package.json

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

package/src/class.ts

@@ -0,0 +1,14 @@
+import { IObject } from '@leafer/interface'
+import { EventCreator, UICreator } from '@leafer/platform'
+
+export function registerUI() {
+    return (target: IObject) => {
+        UICreator.register(target)
+    }
+}
+
+export function registerUIEvent() {
+    return (target: IObject) => {
+        EventCreator.register(target)
+    }
+}

package/src/data.ts

@@ -0,0 +1,265 @@
+import { ILeafData, ILeaf, IObject, __Value } 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 {
+    const defaultDescriptor: IObject & ThisType<ILeaf> = {
+        get() { return this.__getAttr(key) },
+        set(value: __Value) { this.__setAttr(key, value) },
+        configurable: true,
+        enumerable: true
+    }
+    defineKey(target, key, Object.assign(defaultDescriptor, mergeDescriptor || {}))
+    defineDataProcessor(target, key, defaultValue)
+}
+
+export function dataType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, 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 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 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 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 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 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 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 opacityType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                this.__setAttr(key, value)
+                this.__layout.opacityChanged || this.__layout.opacityChange()
+            }
+        })
+    }
+}
+
+export function sortType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineLeafAttr(target, key, defaultValue, {
+            set(value: __Value) {
+                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)
+                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 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() }
+                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()
+            }
+        })
+    }
+}
+
+
+// get
+
+export function dataProcessor(processor: IObject) {
+    return (target: ILeaf, _key: string) => {
+        defineKey(target, '__DataProcessor', {
+            get() { return processor }
+        })
+    }
+}
+
+export function layoutProcessor(processor: IObject) {
+    return (target: ILeaf, _key: string) => {
+        defineKey(target, '__LayoutProcessor', {
+            get() { return processor }
+        })
+    }
+}
+
+
+// other 
+
+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 {
+
+    const data = target.__DataProcessor.prototype as ILeafData
+    const computedKey = '_' + key
+    const setMethodName = getSetMethodName(key)
+
+    const property: IObject & ThisType<ILeafData> = {
+        get() {
+            const v = this[computedKey]
+            return v === undefined ? defaultValue : v
+        },
+        set(value: __Value) {
+            this[computedKey] = value
+        },
+        configurable: true,
+        enumerable: true
+    }
+
+    if (defaultValue === undefined) {
+        property.get = function () { return this[computedKey] }
+    } else if (key === 'width') {
+        property.get = function () {
+            const v = this[computedKey]
+            return v === undefined ? ((this as ILeafData).__naturalWidth || defaultValue) : v
+        }
+    } else if (key === 'height') {
+        property.get = function () {
+            const v = this[computedKey]
+            return v === undefined ? ((this as ILeafData).__naturalHeight || defaultValue) : v
+        }
+    }
+
+    const descriptor = getDescriptor(data, key)
+
+    if (descriptor && descriptor.set) property.set = descriptor.set // use custom set
+
+    if (data[setMethodName]) {
+        property.set = data[setMethodName] //  use custom setKey(value)
+        delete data[setMethodName]
+    }
+
+    Object.defineProperty(data, key, property)
+
+}
+

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/object.ts

@@ -0,0 +1,14 @@
+import { IObject } from '@leafer/interface'
+
+export function defineKey<T>(target: T, key: string, descriptor: IObject & ThisType<T>): void {
+    Object.defineProperty(target, key, descriptor)
+}
+
+export function getDescriptor(object: IObject, name: string) {
+    return Object.getOwnPropertyDescriptor(object, name)
+}
+
+export function getNames(object: IObject): string[] {
+    return Object.getOwnPropertyNames(object)
+}
+

package/src/rewrite.ts

@@ -0,0 +1,59 @@
+import { IObject, IFunction } from '@leafer/interface'
+import { Debug } from '@leafer/debug'
+import { getDescriptor, getNames } from './object'
+
+interface IRewriteItem {
+    name: string
+    run: IFunction
+}
+
+const debug = new Debug('rewrite')
+
+const list: IRewriteItem[] = []
+const excludeNames = ['destroy', 'constructor']
+
+
+// method
+
+export function rewrite(method: IFunction) {
+    return (target: IObject, key: string) => {
+        list.push({ name: target.constructor.name + '.' + key, run: () => { target[key] = method } })
+    }
+}
+
+export function rewriteAble() {
+    return (_target: IObject) => {
+        doRewrite()
+    }
+}
+
+function doRewrite(error?: boolean): void {
+    if (list.length) {
+        list.forEach(item => {
+            if (error) debug.error(item.name, '需在Class上装饰@rewriteAble()')
+            item.run()
+        })
+        list.length = 0
+    }
+}
+
+setTimeout(() => doRewrite(true))
+
+
+// class
+
+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) && (!exclude || !exclude.includes(name))) {
+                if (module.prototype) {
+                    const d = getDescriptor(module.prototype, name)
+                    if (d.writable) target.prototype[name] = module.prototype[name]
+                } else {
+                    target.prototype[name] = module[name]
+                }
+            }
+        })
+    }
+}