@leafer/decorator 1.0.0-alpha.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023-present, Chao (Leafer) Wan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @leafer/decorator

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@leafer/decorator",
+  "version": "1.0.0-alpha.1",
+  "description": "@leafer/decorator",
+  "author": "Chao (Leafer) Wan",
+  "license": "MIT",
+  "main": "src/index.ts",
+  "files": ["src"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leaferjs/leafer.git"
+  },
+  "homepage": "https://github.com/leaferjs/leafer/tree/main/packages/decorator",
+  "bugs": "https://github.com/leaferjs/leafer/issues",
+  "keywords": [
+    "leafer",
+    "leaferjs"
+  ],
+  "dependencies": {
+    "@leafer/platform": "1.0.0-alpha.1",
+    "@leafer/debug": "1.0.0-alpha.1"
+  },
+  "devDependencies": {
+     "@leafer/interface": "1.0.0-alpha.1"
+  }
+}

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 registerEvent() {
+    return (target: IObject) => {
+        EventCreator.register(target)
+    }
+}

package/src/data.ts

@@ -0,0 +1,216 @@
+import { ILeafData, ILeaf, IObject, __Value } from '@leafer/interface'
+import { defineKey, getDescriptor } from './object'
+
+// name
+
+export function aliasType(name: string) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(name) },
+            set(value: __Value) {
+                this.root ? this.__set(name, value) : this.__[name] = value
+            }
+        })
+    }
+}
+
+export function dataType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function positionType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.positionChanged || this.__layout.positionChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function scaleType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.scaleChanged || this.__layout.scaleChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function rotationType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.rotationChanged || this.__layout.rotationChange()
+
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function boundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.boxBoundsChanged || this.__layout.boxBoundsChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export const pathType = boundsType
+
+
+export function affectEventBoundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.eventBoundsChanged || this.__layout.eventBoundsChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function affectRenderBoundsType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.renderBoundsChanged || this.__layout.renderBoundsChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function surfaceType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.surfaceChanged || this.__layout.surfaceChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function opacityType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.opacityChanged || this.__layout.opacityChange()
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+export function sortType(defaultValue?: __Value) {
+    return (target: ILeaf, key: string) => {
+        defineKey(target, key, {
+            get() { return this.__get(key) },
+            set(value: __Value) {
+                this.root ? this.__set(key, value) : this.__[key] = value
+                this.__layout.surfaceChanged || this.__layout.surfaceChange()
+
+                if (this.parent) {
+                    this.parent.__layout.childrenSortChanged || (this.parent.__layout.childrenSortChanged = true)
+                } else {
+                    this.__addParentWait(() => { this.parent.__layout.childrenSortChanged || (this.parent.__layout.childrenSortChanged = true) })
+                }
+            }
+        })
+        defineDataProcessor(target, key, defaultValue)
+    }
+}
+
+
+// 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)
+}
+
+// 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
+        }
+    }
+
+    if (defaultValue === undefined) property.get = function () { return this[computedKey] }
+
+    const descriptor = getDescriptor(data, key)
+
+    if (descriptor) {
+        if (descriptor.set) property.set = descriptor.set // use custom set
+        if (descriptor.get) property.get = descriptor.get // use custom get
+    }
+
+    if (data[setMethodName]) {
+        property.set = data[setMethodName] //  use custom setKey(value)
+        delete data[setMethodName]
+    }
+
+    Object.defineProperty(data, key, property)
+
+}
+

package/src/index.ts

@@ -0,0 +1,4 @@
+export { aliasType, dataType, positionType, boundsType, affectEventBoundsType, affectRenderBoundsType, scaleType, rotationType, surfaceType, opacityType, sortType, pathType, dataProcessor, layoutProcessor, defineDataProcessor } from './data'
+export { useModule, rewrite, rewriteAble } from './rewrite'
+export { defineKey, getDescriptor } from './object'
+export { registerUI, registerEvent } from './class'

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(child: IObject) {
+    return (target: IObject) => {
+        const names = child.prototype ? getNames(child.prototype) : Object.keys(child)
+        names.forEach(name => {
+            if (!excludeNames.includes(name)) {
+                if (child.prototype) {
+                    const d = getDescriptor(child.prototype, name)
+                    if (d.writable) target.prototype[name] = child.prototype[name]
+                } else {
+                    target.prototype[name] = child[name]
+                }
+            }
+        })
+    }
+}