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

package/package.json

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

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 { 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 { useModule, rewrite, rewriteAble } from './rewrite'
 export { defineKey, getDescriptor } from './object'
 export { registerUI, registerUIEvent } from './class'

package/types/index.d.ts

@@ -0,0 +1,36 @@
+import { ILeaf, __Value, 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 const pathType: typeof boundsType;
+declare function affectStrokeBoundsType(defaultValue?: __Value): (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 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, 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 };

package/src/class.ts

@@ -1,14 +0,0 @@
-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

@@ -1,252 +0,0 @@
-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()
-            }
-        })
-    }
-}
-
-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() }
-            }
-        })
-    }
-}
-
-
-// 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

@@ -1,35 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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]
-                }
-            }
-        })
-    }
-}