@leafer/display-module 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/display-module",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "@leafer/display-module",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,12 +22,12 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/helper": "1.0.2",
-    "@leafer/event": "1.0.2",
-    "@leafer/math": "1.0.2",
-    "@leafer/debug": "1.0.2"
+    "@leafer/helper": "1.0.4",
+    "@leafer/event": "1.0.4",
+    "@leafer/math": "1.0.4",
+    "@leafer/debug": "1.0.4"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.2"
+    "@leafer/interface": "1.0.4"
   }
 }

package/src/LeafBounds.ts

@@ -98,6 +98,7 @@ export const LeafBounds: ILeafBoundsModule = {
     },
 
     __updateLocalBoxBounds(): void {
+        if (this.__hasMotionPath) this.__updateMotionPath()
         if (this.__hasAutoLayout) this.__updateAutoLayout() //  origin / around / flow
         toOuterOf(this.__layout.boxBounds, this.__local, this.__local)
     },

package/src/LeafDataProxy.ts

@@ -18,8 +18,8 @@ export const LeafDataProxy: ILeafDataProxyModule = {
             }
 
             if (typeof newValue === 'object' || oldValue !== newValue) {
-                (this.__ as IObject)[name] = newValue
-                if (this.__proxyData) this.setProxyAttr(name, newValue)
+
+                this.__realSetAttr(name, newValue)
 
                 const { CHANGE } = PropertyEvent
                 const event = new PropertyEvent(CHANGE, this, name, oldValue, newValue)
@@ -31,18 +31,29 @@ export const LeafDataProxy: ILeafDataProxyModule = {
                 }
 
                 this.leafer.emitEvent(event)
+
                 return true
             } else {
                 return false
             }
 
         } else {
-            (this.__ as IObject)[name] = newValue
-            if (this.__proxyData) this.setProxyAttr(name, newValue)
+
+            this.__realSetAttr(name, newValue)
+
             return true
+
         }
     },
 
+    __realSetAttr(name: string, newValue: IValue): void {
+        const data = this.__ as IObject
+        data[name] = newValue
+        if (this.__proxyData) this.setProxyAttr(name, newValue)
+        if (data.normalStyle) this.lockNormalStyle || data.normalStyle[name] === undefined || (data.normalStyle[name] = newValue)
+    },
+
+
     __getAttr(name: string): IValue {
         if (this.__proxyData) return this.getProxyAttr(name)
         return this.__.__get(name)

package/src/LeafEventer.ts

@@ -1,154 +1,6 @@
-import { IEventListener, IEventListenerMap, IEventListenerItem, IEventListenerId, IEvent, IObject, IEventTarget, ILeafEventerModule, IEventOption } from '@leafer/interface'
-import { EventCreator } from '@leafer/platform'
+import { ILeafEventerModule } from '@leafer/interface'
+import { Eventer } from '@leafer/event'
 
-const empty = {}
+const { on, on_, off, off_, once, emit, emitEvent, hasEvent, destroy } = Eventer.prototype
 
-export const LeafEventer: ILeafEventerModule = {
-
-    on(type: string | string[], listener: IEventListener, options?: IEventOption): void {
-        let capture: boolean, once: boolean
-        if (options) {
-            if (options === 'once') {
-                once = true
-            } else if (typeof options === 'boolean') {
-                capture = options
-            } else {
-                capture = options.capture
-                once = options.once
-            }
-        }
-
-        let events: IEventListenerItem[]
-        const map = __getListenerMap(this, capture, true)
-        const typeList = typeof type === 'string' ? type.split(' ') : type
-        const item = once ? { listener, once } : { listener }
-
-        typeList.forEach(type => {
-            if (type) {
-                events = map[type]
-                if (events) {
-                    if (events.findIndex(item => item.listener === listener) === -1) events.push(item)
-                } else {
-                    map[type] = [item]
-                }
-            }
-        })
-    },
-
-    off(type?: string | string[], listener?: IEventListener, options?: IEventOption): void {
-        if (type) {
-
-            const typeList = typeof type === 'string' ? type.split(' ') : type
-
-            if (listener) {
-
-                let capture: boolean
-                if (options) capture = typeof options === 'boolean' ? options : (options === 'once' ? false : options.capture)
-
-                let events: IEventListenerItem[], index: number
-                const map = __getListenerMap(this, capture)
-
-                typeList.forEach(type => {
-                    if (type) {
-                        events = map[type]
-                        if (events) {
-                            index = events.findIndex(item => item.listener === listener)
-                            if (index > -1) events.splice(index, 1)
-                            if (!events.length) delete map[type]
-                        }
-                    }
-                })
-
-            } else {
-
-                // off type
-                const { __bubbleMap: b, __captureMap: c } = this
-                typeList.forEach(type => {
-                    if (b) delete b[type]
-                    if (c) delete c[type]
-                })
-
-            }
-
-        } else {
-
-            this.__bubbleMap = this.__captureMap = undefined  // off all
-
-        }
-
-    },
-
-    on_(type: string | string[], listener: IEventListener, bind?: IObject, options?: IEventOption): IEventListenerId {
-        if (bind) listener = listener.bind(bind)
-        this.on(type, listener, options)
-        return { type, current: this, listener, options }
-    },
-
-    off_(id: IEventListenerId | IEventListenerId[]): void {
-        if (!id) return
-        const list = id instanceof Array ? id : [id]
-        list.forEach(item => item.current.off(item.type, item.listener, item.options))
-        list.length = 0
-    },
-
-    once(type: string | string[], listener: IEventListener, capture?: boolean): void {
-        this.on(type, listener, { once: true, capture })
-    },
-
-    emit(type: string, event?: IEvent | IObject, capture?: boolean): void {
-        if (!event && EventCreator.has(type)) event = EventCreator.get(type, { type, target: this, current: this } as IEvent)
-
-        const map = __getListenerMap(this, capture)
-        const list = map[type]
-        if (list) {
-            let item: IEventListenerItem
-            for (let i = 0, len = list.length; i < len; i++) {
-                item = list[i]
-                item.listener(event)
-                if (item.once) {
-                    this.off(type, item.listener, capture)
-                    i--, len--
-                }
-                if (event && (event as IEvent).isStopNow) break
-            }
-        }
-
-        this.syncEventer && this.syncEventer.emitEvent(event, capture)
-    },
-
-    emitEvent(event: IEvent, capture?: boolean): void {
-        event.current = this
-        this.emit(event.type, event, capture)
-    },
-
-    hasEvent(type: string, capture?: boolean): boolean {
-        if (this.syncEventer && this.syncEventer.hasEvent(type, capture)) return true
-
-        const { __bubbleMap: b, __captureMap: c } = this
-        const hasB = b && b[type], hasC = c && c[type]
-        return !!(capture === undefined ? (hasB || hasC) : (capture ? hasC : hasB))
-    },
-
-}
-
-function __getListenerMap(eventer: IEventTarget, capture?: boolean, create?: boolean): IEventListenerMap {
-    if (capture) {
-
-        const { __captureMap: c } = eventer
-        if (c) {
-            return c
-        } else {
-            return create ? eventer.__captureMap = {} : empty
-        }
-
-    } else {
-
-        const { __bubbleMap: b } = eventer
-        if (b) {
-            return b
-        } else {
-            return create ? eventer.__bubbleMap = {} : empty
-        }
-
-    }
-}
+export const LeafEventer: ILeafEventerModule = { on, on_, off, off_, once, emit, emitEvent, hasEvent, destroyEventer: destroy }