@leafer-in/view 1.0.0-rc.18

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-in/view

package/dist/view.esm.js

@@ -0,0 +1,90 @@
+import { Leafer, Bounds, LeafBoundsHelper } from '@leafer-ui/draw';
+
+function getZoomScale(scaleX, type) {
+    let scale = 1;
+    const out = type === 'out', absScale = Math.abs(scaleX);
+    if (absScale > 1) {
+        while (out ? scale < absScale : scale <= absScale)
+            scale *= 2;
+        if (out)
+            scale /= 2;
+    }
+    else {
+        while (out ? scale >= absScale : scale > absScale)
+            scale /= 2;
+        if (!out)
+            scale *= 2;
+    }
+    return scale / scaleX;
+}
+function getFixBounds(bounds, scaleBounds) {
+    let { x, y, width, height } = bounds;
+    let fix;
+    if (!height)
+        height = width * (scaleBounds.height / scaleBounds.width), fix = true;
+    if (!width)
+        width = height * (scaleBounds.width / scaleBounds.height), fix = true;
+    return fix ? { x, y, width, height } : bounds;
+}
+
+Leafer.prototype.zoom = function (zoomType, padding, fixed) {
+    const { zoomLayer } = this;
+    const limitBounds = this.canvas.bounds.clone().shrink(padding ? padding : 30), bounds = new Bounds();
+    const center = { x: limitBounds.x + limitBounds.width / 2, y: limitBounds.y + limitBounds.height / 2 };
+    let scale;
+    if (typeof zoomType === 'string') {
+        const { scaleX } = this.__;
+        switch (zoomType) {
+            case 'in':
+                scale = getZoomScale(scaleX, 'in');
+                break;
+            case 'out':
+                scale = getZoomScale(scaleX, 'out');
+                break;
+            case 'fit':
+                zoomType = this.boxBounds;
+                break;
+            case 'fit-width':
+                zoomType = new Bounds(this.boxBounds);
+                zoomType.height = 0;
+                break;
+            case 'fit-height':
+                zoomType = new Bounds(this.boxBounds);
+                zoomType.width = 0;
+                break;
+        }
+    }
+    else if (typeof zoomType === 'number') {
+        scale = zoomType;
+    }
+    if (scale) {
+        zoomLayer.scaleOfWorld(center, this.validScale(scale));
+    }
+    else if (typeof zoomType === 'object') {
+        const isArray = zoomType instanceof Array;
+        if (isArray || zoomType.tag) {
+            const list = isArray ? zoomType : [zoomType];
+            bounds.setListWithFn(list, LeafBoundsHelper.worldBounds);
+        }
+        else {
+            const innerBounds = getFixBounds(zoomType, limitBounds);
+            bounds.set(zoomLayer.getWorldBounds(innerBounds));
+        }
+        const { x, y, width, height } = bounds;
+        let moveX = limitBounds.x - x, moveY = limitBounds.y - y;
+        if (fixed) {
+            moveX += Math.max((limitBounds.width - width) / 2, 0);
+            moveY += Math.max((limitBounds.height - height) / 2, 0);
+        }
+        else {
+            const fitScale = this.validScale(Math.min(limitBounds.width / width, limitBounds.height / height));
+            moveX += (limitBounds.width - width * fitScale) / 2;
+            moveY += (limitBounds.height - height * fitScale) / 2;
+            zoomLayer.scaleOfWorld(bounds, fitScale);
+            bounds.scaleOf(bounds, fitScale);
+        }
+        zoomLayer.move(moveX, moveY);
+        return bounds.move(moveX, moveY);
+    }
+    return zoomLayer.worldBoxBounds;
+};

package/dist/view.esm.min.js

@@ -0,0 +1 @@
+import{Leafer as t,Bounds as e,LeafBoundsHelper as i}from"@leafer-ui/draw";function h(t,e){let i=1;const h="out"===e,o=Math.abs(t);if(o>1){for(;h?i<o:i<=o;)i*=2;h&&(i/=2)}else{for(;h?i>=o:i>o;)i/=2;h||(i*=2)}return i/t}t.prototype.zoom=function(t,o,s){const{zoomLayer:n}=this,a=this.canvas.bounds.clone().shrink(o||30),r=new e,c={x:a.x+a.width/2,y:a.y+a.height/2};let d;if("string"==typeof t){const{scaleX:i}=this.__;switch(t){case"in":d=h(i,"in");break;case"out":d=h(i,"out");break;case"fit":t=this.boxBounds;break;case"fit-width":(t=new e(this.boxBounds)).height=0;break;case"fit-height":(t=new e(this.boxBounds)).width=0}}else"number"==typeof t&&(d=t);if(d)n.scaleOfWorld(c,this.validScale(d));else if("object"==typeof t){const e=t instanceof Array;if(e||t.tag){const h=e?t:[t];r.setListWithFn(h,i.worldBounds)}else{const e=function(t,e){let i,{x:h,y:o,width:s,height:n}=t;return n||(n=s*(e.height/e.width),i=!0),s||(s=n*(e.width/e.height),i=!0),i?{x:h,y:o,width:s,height:n}:t}(t,a);r.set(n.getWorldBounds(e))}const{x:h,y:o,width:c,height:d}=r;let l=a.x-h,f=a.y-o;if(s)l+=Math.max((a.width-c)/2,0),f+=Math.max((a.height-d)/2,0);else{const t=this.validScale(Math.min(a.width/c,a.height/d));l+=(a.width-c*t)/2,f+=(a.height-d*t)/2,n.scaleOfWorld(r,t),r.scaleOf(r,t)}return n.move(l,f),r.move(l,f)}return n.worldBoxBounds};

package/dist/view.js

@@ -0,0 +1,93 @@
+(function (draw) {
+    'use strict';
+
+    function getZoomScale(scaleX, type) {
+        let scale = 1;
+        const out = type === 'out', absScale = Math.abs(scaleX);
+        if (absScale > 1) {
+            while (out ? scale < absScale : scale <= absScale)
+                scale *= 2;
+            if (out)
+                scale /= 2;
+        }
+        else {
+            while (out ? scale >= absScale : scale > absScale)
+                scale /= 2;
+            if (!out)
+                scale *= 2;
+        }
+        return scale / scaleX;
+    }
+    function getFixBounds(bounds, scaleBounds) {
+        let { x, y, width, height } = bounds;
+        let fix;
+        if (!height)
+            height = width * (scaleBounds.height / scaleBounds.width), fix = true;
+        if (!width)
+            width = height * (scaleBounds.width / scaleBounds.height), fix = true;
+        return fix ? { x, y, width, height } : bounds;
+    }
+
+    draw.Leafer.prototype.zoom = function (zoomType, padding, fixed) {
+        const { zoomLayer } = this;
+        const limitBounds = this.canvas.bounds.clone().shrink(padding ? padding : 30), bounds = new draw.Bounds();
+        const center = { x: limitBounds.x + limitBounds.width / 2, y: limitBounds.y + limitBounds.height / 2 };
+        let scale;
+        if (typeof zoomType === 'string') {
+            const { scaleX } = this.__;
+            switch (zoomType) {
+                case 'in':
+                    scale = getZoomScale(scaleX, 'in');
+                    break;
+                case 'out':
+                    scale = getZoomScale(scaleX, 'out');
+                    break;
+                case 'fit':
+                    zoomType = this.boxBounds;
+                    break;
+                case 'fit-width':
+                    zoomType = new draw.Bounds(this.boxBounds);
+                    zoomType.height = 0;
+                    break;
+                case 'fit-height':
+                    zoomType = new draw.Bounds(this.boxBounds);
+                    zoomType.width = 0;
+                    break;
+            }
+        }
+        else if (typeof zoomType === 'number') {
+            scale = zoomType;
+        }
+        if (scale) {
+            zoomLayer.scaleOfWorld(center, this.validScale(scale));
+        }
+        else if (typeof zoomType === 'object') {
+            const isArray = zoomType instanceof Array;
+            if (isArray || zoomType.tag) {
+                const list = isArray ? zoomType : [zoomType];
+                bounds.setListWithFn(list, draw.LeafBoundsHelper.worldBounds);
+            }
+            else {
+                const innerBounds = getFixBounds(zoomType, limitBounds);
+                bounds.set(zoomLayer.getWorldBounds(innerBounds));
+            }
+            const { x, y, width, height } = bounds;
+            let moveX = limitBounds.x - x, moveY = limitBounds.y - y;
+            if (fixed) {
+                moveX += Math.max((limitBounds.width - width) / 2, 0);
+                moveY += Math.max((limitBounds.height - height) / 2, 0);
+            }
+            else {
+                const fitScale = this.validScale(Math.min(limitBounds.width / width, limitBounds.height / height));
+                moveX += (limitBounds.width - width * fitScale) / 2;
+                moveY += (limitBounds.height - height * fitScale) / 2;
+                zoomLayer.scaleOfWorld(bounds, fitScale);
+                bounds.scaleOf(bounds, fitScale);
+            }
+            zoomLayer.move(moveX, moveY);
+            return bounds.move(moveX, moveY);
+        }
+        return zoomLayer.worldBoxBounds;
+    };
+
+})(LeaferUI);

package/dist/view.min.js

@@ -0,0 +1 @@
+!function(t){"use strict";function e(t,e){let i=1;const s="out"===e,o=Math.abs(t);if(o>1){for(;s?i<o:i<=o;)i*=2;s&&(i/=2)}else{for(;s?i>=o:i>o;)i/=2;s||(i*=2)}return i/t}t.Leafer.prototype.zoom=function(i,s,o){const{zoomLayer:h}=this,n=this.canvas.bounds.clone().shrink(s||30),a=new t.Bounds,r={x:n.x+n.width/2,y:n.y+n.height/2};let c;if("string"==typeof i){const{scaleX:s}=this.__;switch(i){case"in":c=e(s,"in");break;case"out":c=e(s,"out");break;case"fit":i=this.boxBounds;break;case"fit-width":(i=new t.Bounds(this.boxBounds)).height=0;break;case"fit-height":(i=new t.Bounds(this.boxBounds)).width=0}}else"number"==typeof i&&(c=i);if(c)h.scaleOfWorld(r,this.validScale(c));else if("object"==typeof i){const e=i instanceof Array;if(e||i.tag){const s=e?i:[i];a.setListWithFn(s,t.LeafBoundsHelper.worldBounds)}else{const t=function(t,e){let i,{x:s,y:o,width:h,height:n}=t;return n||(n=h*(e.height/e.width),i=!0),h||(h=n*(e.width/e.height),i=!0),i?{x:s,y:o,width:h,height:n}:t}(i,n);a.set(h.getWorldBounds(t))}const{x:s,y:r,width:c,height:d}=a;let f=n.x-s,l=n.y-r;if(o)f+=Math.max((n.width-c)/2,0),l+=Math.max((n.height-d)/2,0);else{const t=this.validScale(Math.min(n.width/c,n.height/d));f+=(n.width-c*t)/2,l+=(n.height-d*t)/2,h.scaleOfWorld(a,t),a.scaleOf(a,t)}return h.move(f,l),a.move(f,l)}return h.worldBoxBounds}}(LeaferUI);

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@leafer-in/view",
+  "version": "1.0.0-rc.18",
+  "description": "@leafer-in/view",
+  "author": "Chao (Leafer) Wan",
+  "license": "MIT",
+  "main": "dist/view.esm.js",
+  "unpkg": "dist/view.js",
+  "jsdelivr": "dist/view.js",
+  "types": "types/index.d.ts",
+  "files": [
+    "src",
+    "types",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leaferjs/in.git"
+  },
+  "homepage": "https://github.com/leaferjs/in/tree/main/packages/view",
+  "bugs": "https://github.com/leaferjs/in/issues",
+  "keywords": [
+    "leafer view",
+    "leafer-view",
+    "leafer-in",
+    "view",
+    "leafer-ui",
+    "leaferjs"
+  ],
+  "dependencies": {
+    "@leafer-ui/draw": "1.0.0-rc.18"
+  },
+  "devDependencies": {
+    "@leafer-ui/interface": "1.0.0-rc.18",
+    "@leafer-in/interface": "1.0.0-rc.18"
+  }
+}

package/src/helper.ts

@@ -0,0 +1,23 @@
+import { IBoundsData } from '@leafer-ui/interface'
+
+
+export function getZoomScale(scaleX: number, type: 'in' | 'out'): number {
+    let scale = 1
+    const out = type === 'out', absScale = Math.abs(scaleX)
+    if (absScale > 1) {
+        while (out ? scale < absScale : scale <= absScale) scale *= 2
+        if (out) scale /= 2
+    } else {
+        while (out ? scale >= absScale : scale > absScale) scale /= 2
+        if (!out) scale *= 2
+    }
+    return scale / scaleX
+}
+
+export function getFixBounds(bounds: IBoundsData, scaleBounds: IBoundsData): IBoundsData {
+    let { x, y, width, height } = bounds
+    let fix: boolean
+    if (!height) height = width * (scaleBounds.height / scaleBounds.width), fix = true
+    if (!width) width = height * (scaleBounds.width / scaleBounds.height), fix = true
+    return fix ? { x, y, width, height } : bounds
+}

package/src/index.ts

@@ -0,0 +1,86 @@
+import { ILeaf, IBoundsData, IZoomType, IFourNumber, IPointData } from '@leafer-ui/interface'
+import { Leafer, Bounds, LeafBoundsHelper } from '@leafer-ui/draw'
+
+import { getFixBounds, getZoomScale } from './helper'
+
+
+Leafer.prototype.zoom = function (zoomType: IZoomType, padding?: IFourNumber, fixed?: boolean): IBoundsData {
+
+    const { zoomLayer } = this
+    const limitBounds = this.canvas.bounds.clone().shrink(padding ? padding : 30), bounds = new Bounds()
+    const center: IPointData = { x: limitBounds.x + limitBounds.width / 2, y: limitBounds.y + limitBounds.height / 2 }
+
+    let scale: number
+
+    if (typeof zoomType === 'string') {
+
+        const { scaleX } = this.__
+
+        switch (zoomType) {
+            case 'in':
+                scale = getZoomScale(scaleX, 'in')
+                break
+            case 'out':
+                scale = getZoomScale(scaleX, 'out')
+                break
+            case 'fit':
+                zoomType = this.boxBounds
+                break
+            case 'fit-width':
+                zoomType = new Bounds(this.boxBounds)
+                zoomType.height = 0
+                break
+            case 'fit-height':
+                zoomType = new Bounds(this.boxBounds)
+                zoomType.width = 0
+                break
+        }
+
+    } else if (typeof zoomType === 'number') {
+        scale = zoomType
+    }
+
+
+    if (scale) {
+
+        zoomLayer.scaleOfWorld(center, this.validScale(scale))
+
+    } else if (typeof zoomType === 'object') {
+
+        const isArray = zoomType instanceof Array
+
+        if (isArray || (zoomType as ILeaf).tag) {
+            const list: ILeaf[] = isArray ? zoomType as ILeaf[] : [zoomType as ILeaf]
+            bounds.setListWithFn(list, LeafBoundsHelper.worldBounds)
+        } else {
+            const innerBounds = getFixBounds(zoomType as IBoundsData, limitBounds)
+            bounds.set(zoomLayer.getWorldBounds(innerBounds))
+        }
+
+        const { x, y, width, height } = bounds
+        let moveX = limitBounds.x - x, moveY = limitBounds.y - y
+
+        if (fixed) {
+
+            moveX += Math.max((limitBounds.width - width) / 2, 0)
+            moveY += Math.max((limitBounds.height - height) / 2, 0)
+
+        } else {
+
+            const fitScale = this.validScale(Math.min(limitBounds.width / width, limitBounds.height / height))
+            moveX += (limitBounds.width - width * fitScale) / 2
+            moveY += (limitBounds.height - height * fitScale) / 2
+
+            zoomLayer.scaleOfWorld(bounds, fitScale)
+            bounds.scaleOf(bounds, fitScale)
+
+        }
+
+        zoomLayer.move(moveX, moveY)
+        return bounds.move(moveX, moveY)
+
+    }
+
+    return zoomLayer.worldBoxBounds
+
+}

package/types/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }