@leafer-ui/bounds 1.9.5 → 1.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer-ui/bounds",
-  "version": "1.9.5",
+  "version": "1.9.6",
   "description": "@leafer-ui/bounds",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -22,9 +22,9 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/core": "1.9.5"
+    "@leafer/core": "1.9.6"
   },
   "devDependencies": {
-    "@leafer-ui/interface": "1.9.5"
+    "@leafer-ui/interface": "1.9.6"
   }
 }

package/src/DragBoundsHelper.ts

@@ -1,53 +1,95 @@
-import { IPointData, IBoundsData, IDragBoundsType, ILeaf } from '@leafer/interface'
-import { MathHelper } from '@leafer/core'
+import { IPointData, IBoundsData, IDragBoundsType, ILeaf, ISide } from '@leafer/interface'
+import { Bounds, MathHelper } from '@leafer/core'
 
 
+const { float } = MathHelper
+const tempContent = new Bounds(), tempMerge = new Bounds(), tempIntersect = new Bounds()
+
 export const DragBoundsHelper = {
 
+    // 拖拽区域内移动
+    limitMove(leaf: ILeaf, move: IPointData): void {
+        const { dragBounds, dragBoundsType } = leaf
+        if (dragBounds) D.getValidMove(leaf.__localBoxBounds, D.getDragBounds(leaf), dragBoundsType, move, true)
+        D.axisMove(leaf, move)
+    },
+
+    // 拖拽区域内缩放
+    limitScaleOf(leaf: ILeaf, origin: IPointData, scale: IPointData): void {
+        const { dragBounds, dragBoundsType } = leaf
+        if (dragBounds) D.getValidScaleOf(leaf.__localBoxBounds, D.getDragBounds(leaf), dragBoundsType, leaf.getLocalPointByInner(leaf.getInnerPointByBox(origin)), scale, true)
+    },
+
+    // 按轴移动
+    axisMove(leaf: ILeaf, move: IPointData) {
+        const { draggable } = leaf
+        if (draggable === 'x') move.y = 0
+        if (draggable === 'y') move.x = 0
+    },
+
+    getDragBounds(leaf: ILeaf): IBoundsData {
+        const { dragBounds } = leaf
+        return dragBounds === 'parent' ? leaf.parent.boxBounds : dragBounds
+    },
+
+    isInnerMode(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, sideType: ISide): boolean {
+        return dragBoundsType === 'inner' || (dragBoundsType === 'auto' && content[sideType] > dragBounds[sideType])
+    },
+
     getValidMove(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, move: IPointData, change?: boolean): IPointData {
         const x = content.x + move.x, y = content.y + move.y, right = x + content.width, bottom = y + content.height
         const boundsRight = dragBounds.x + dragBounds.width, boundsBottom = dragBounds.y + dragBounds.height
 
         if (!change) move = { ...move }
 
-        const isBiggerWidth = content.width > dragBounds.width
-        const isBiggerHeight = content.height > dragBounds.height
-
-        if (isBiggerWidth && dragBoundsType !== 'outer') {  // inner / auto 模式
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, 'width')) {  // inner 模式
             if (x > dragBounds.x) move.x += dragBounds.x - x
             else if (right < boundsRight) move.x += boundsRight - right
-        } else {
+        } else { // outer 模式
             if (x < dragBounds.x) move.x += dragBounds.x - x
             else if (right > boundsRight) move.x += boundsRight - right
         }
 
-        if (isBiggerHeight && dragBoundsType !== 'outer') { // inner / auto 模式
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, 'height')) { // inner 模式
             if (y > dragBounds.y) move.y += dragBounds.y - y
             else if (bottom < boundsBottom) move.y += boundsBottom - bottom
-        } else {
+        } else { // outer 模式
             if (y < dragBounds.y) move.y += dragBounds.y - y
             else if (bottom > boundsBottom) move.y += boundsBottom - bottom
         }
 
         // 避免出现很小为0的小数
-        move.x = MathHelper.float(move.x)
-        move.y = MathHelper.float(move.y)
+        move.x = float(move.x)
+        move.y = float(move.y)
 
         return move
     },
 
-    // 按轴移动
-    axisMove(leaf: ILeaf, move: IPointData) {
-        const { draggable } = leaf
-        if (draggable === 'x') move.y = 0
-        if (draggable === 'y') move.x = 0
-    },
+    getValidScaleOf(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, origin: IPointData, scale: IPointData, change?: boolean): IPointData {
+        if (!change) scale = { ...scale }
 
-    // 拖拽区域内移动
-    limitMove(leaf: ILeaf, move: IPointData): void {
-        const { dragBounds, dragBoundsType } = leaf
-        if (dragBounds) D.getValidMove(leaf.__localBoxBounds, dragBounds === 'parent' ? leaf.parent.boxBounds : dragBounds, dragBoundsType, move, true)
-        D.axisMove(leaf, move)
+        let fitScaleX: number, fitScaleY: number
+
+        tempContent.set(content).scaleOf(origin, scale.x, scale.y).unsign()
+        tempMerge.set(tempContent).add(dragBounds)
+        tempIntersect.set(tempContent).intersect(dragBounds)
+
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, 'width')) {  // inner 模式
+            fitScaleX = tempMerge.width / tempContent.width
+        } else { // outer 模式
+            fitScaleX = tempIntersect.width / tempContent.width
+        }
+
+        if (D.isInnerMode(content, dragBounds, dragBoundsType, 'height')) { // inner 模式
+            fitScaleY = tempMerge.height / tempContent.height
+        } else { // outer 模式
+            fitScaleY = tempIntersect.height / tempContent.height
+        }
+
+        scale.x = float(tempIntersect.width) ? scale.x * fitScaleX : 1
+        scale.y = float(tempIntersect.height) ? scale.y * fitScaleY : 1
+
+        return scale
     }
 }
 

package/src/UIBounds.ts

@@ -1,6 +1,6 @@
 import { IUIBoundsModule } from "@leafer-ui/interface"
 
-import { Filter } from '@leafer-ui/external'
+import { Effect, Filter } from '@leafer-ui/external'
 
 
 export const UIBounds: IUIBoundsModule = {
@@ -35,7 +35,7 @@ export const UIBounds: IUIBoundsModule = {
         let width: number = 0
         const { shadow, innerShadow, blur, backgroundBlur, filter, renderSpread } = this.__
 
-        if (shadow) shadow.forEach(item => width = Math.max(width, Math.max(Math.abs(item.y), Math.abs(item.x)) + (item.spread > 0 ? item.spread : 0) + item.blur * 1.5))
+        if (shadow) width = Effect.getShadowSpread(this, shadow)
 
         if (blur) width = Math.max(width, blur)
 

package/types/index.d.ts

@@ -1,12 +1,16 @@
 import { IUIBoundsModule } from '@leafer-ui/interface';
-import { IBoundsData, IDragBoundsType, IPointData, ILeaf } from '@leafer/interface';
+import { ILeaf, IPointData, IBoundsData, IDragBoundsType, ISide } from '@leafer/interface';
 
 declare const UIBounds: IUIBoundsModule;
 
 declare const DragBoundsHelper: {
-    getValidMove(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, move: IPointData, change?: boolean): IPointData;
-    axisMove(leaf: ILeaf, move: IPointData): void;
     limitMove(leaf: ILeaf, move: IPointData): void;
+    limitScaleOf(leaf: ILeaf, origin: IPointData, scale: IPointData): void;
+    axisMove(leaf: ILeaf, move: IPointData): void;
+    getDragBounds(leaf: ILeaf): IBoundsData;
+    isInnerMode(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, sideType: ISide): boolean;
+    getValidMove(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, move: IPointData, change?: boolean): IPointData;
+    getValidScaleOf(content: IBoundsData, dragBounds: IBoundsData, dragBoundsType: IDragBoundsType, origin: IPointData, scale: IPointData, change?: boolean): IPointData;
 };
 
 export { DragBoundsHelper, UIBounds };