@fmdevui/fm-dev 1.0.112 → 1.0.114

package/lib/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/contain/windingLine.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function windingLine(x0, y0, x1, y1, x, y) {
+    if ((y > y0 && y > y1) || (y < y0 && y < y1)) {
+        return 0;
+    }
+    if (y1 === y0) {
+        return 0;
+    }
+    var t = (y - y0) / (y1 - y0);
+    var dir = y1 < y0 ? 1 : -1;
+    if (t === 1 || t === 0) {
+        dir = y1 < y0 ? 0.5 : -0.5;
+    }
+    var x_ = t * (x1 - x0) + x0;
+    return x_ === x ? Infinity : x_ > x ? dir : 0;
+}
+
+exports.default = windingLine;

package/lib/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/BoundingRect.js

@@ -0,0 +1,328 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var matrix = require('./matrix.js');
+var Point = require('./Point.js');
+
+var mathMin = Math.min;
+var mathMax = Math.max;
+var mathAbs = Math.abs;
+var XY = ['x', 'y'];
+var WH = ['width', 'height'];
+var lt = new Point.default();
+var rb = new Point.default();
+var lb = new Point.default();
+var rt = new Point.default();
+var _intersectCtx = createIntersectContext();
+var _minTv = _intersectCtx.minTv;
+var _maxTv = _intersectCtx.maxTv;
+var _lenMinMax = [0, 0];
+var BoundingRect = (function () {
+    function BoundingRect(x, y, width, height) {
+        BoundingRect.set(this, x, y, width, height);
+    }
+    BoundingRect.set = function (target, x, y, width, height) {
+        if (width < 0) {
+            x = x + width;
+            width = -width;
+        }
+        if (height < 0) {
+            y = y + height;
+            height = -height;
+        }
+        target.x = x;
+        target.y = y;
+        target.width = width;
+        target.height = height;
+        return target;
+    };
+    BoundingRect.prototype.union = function (other) {
+        var x = mathMin(other.x, this.x);
+        var y = mathMin(other.y, this.y);
+        if (isFinite(this.x) && isFinite(this.width)) {
+            this.width = mathMax(other.x + other.width, this.x + this.width) - x;
+        }
+        else {
+            this.width = other.width;
+        }
+        if (isFinite(this.y) && isFinite(this.height)) {
+            this.height = mathMax(other.y + other.height, this.y + this.height) - y;
+        }
+        else {
+            this.height = other.height;
+        }
+        this.x = x;
+        this.y = y;
+    };
+    BoundingRect.prototype.applyTransform = function (m) {
+        BoundingRect.applyTransform(this, this, m);
+    };
+    BoundingRect.prototype.calculateTransform = function (b) {
+        var a = this;
+        var sx = b.width / a.width;
+        var sy = b.height / a.height;
+        var m = matrix.create();
+        matrix.translate(m, m, [-a.x, -a.y]);
+        matrix.scale(m, m, [sx, sy]);
+        matrix.translate(m, m, [b.x, b.y]);
+        return m;
+    };
+    BoundingRect.prototype.intersect = function (b, mtv, opt) {
+        return BoundingRect.intersect(this, b, mtv, opt);
+    };
+    BoundingRect.intersect = function (a, b, mtv, opt) {
+        if (mtv) {
+            Point.default.set(mtv, 0, 0);
+        }
+        var outIntersectRect = opt && opt.outIntersectRect || null;
+        var clamp = opt && opt.clamp;
+        if (outIntersectRect) {
+            outIntersectRect.x = outIntersectRect.y = outIntersectRect.width = outIntersectRect.height = NaN;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        if (!(a instanceof BoundingRect)) {
+            a = BoundingRect.set(_tmpIntersectA, a.x, a.y, a.width, a.height);
+        }
+        if (!(b instanceof BoundingRect)) {
+            b = BoundingRect.set(_tmpIntersectB, b.x, b.y, b.width, b.height);
+        }
+        var useMTV = !!mtv;
+        _intersectCtx.reset(opt, useMTV);
+        var touchThreshold = _intersectCtx.touchThreshold;
+        var ax0 = a.x + touchThreshold;
+        var ax1 = a.x + a.width - touchThreshold;
+        var ay0 = a.y + touchThreshold;
+        var ay1 = a.y + a.height - touchThreshold;
+        var bx0 = b.x + touchThreshold;
+        var bx1 = b.x + b.width - touchThreshold;
+        var by0 = b.y + touchThreshold;
+        var by1 = b.y + b.height - touchThreshold;
+        if (ax0 > ax1 || ay0 > ay1 || bx0 > bx1 || by0 > by1) {
+            return false;
+        }
+        var overlap = !(ax1 < bx0 || bx1 < ax0 || ay1 < by0 || by1 < ay0);
+        if (useMTV || outIntersectRect) {
+            _lenMinMax[0] = Infinity;
+            _lenMinMax[1] = 0;
+            intersectOneDim(ax0, ax1, bx0, bx1, 0, useMTV, outIntersectRect, clamp);
+            intersectOneDim(ay0, ay1, by0, by1, 1, useMTV, outIntersectRect, clamp);
+            if (useMTV) {
+                Point.default.copy(mtv, overlap
+                    ? (_intersectCtx.useDir ? _intersectCtx.dirMinTv : _minTv)
+                    : _maxTv);
+            }
+        }
+        return overlap;
+    };
+    BoundingRect.contain = function (rect, x, y) {
+        return x >= rect.x
+            && x <= (rect.x + rect.width)
+            && y >= rect.y
+            && y <= (rect.y + rect.height);
+    };
+    BoundingRect.prototype.contain = function (x, y) {
+        return BoundingRect.contain(this, x, y);
+    };
+    BoundingRect.prototype.clone = function () {
+        return new BoundingRect(this.x, this.y, this.width, this.height);
+    };
+    BoundingRect.prototype.copy = function (other) {
+        BoundingRect.copy(this, other);
+    };
+    BoundingRect.prototype.plain = function () {
+        return {
+            x: this.x,
+            y: this.y,
+            width: this.width,
+            height: this.height
+        };
+    };
+    BoundingRect.prototype.isFinite = function () {
+        return isFinite(this.x)
+            && isFinite(this.y)
+            && isFinite(this.width)
+            && isFinite(this.height);
+    };
+    BoundingRect.prototype.isZero = function () {
+        return this.width === 0 || this.height === 0;
+    };
+    BoundingRect.create = function (rect) {
+        return new BoundingRect(rect.x, rect.y, rect.width, rect.height);
+    };
+    BoundingRect.copy = function (target, source) {
+        target.x = source.x;
+        target.y = source.y;
+        target.width = source.width;
+        target.height = source.height;
+        return target;
+    };
+    BoundingRect.applyTransform = function (target, source, m) {
+        if (!m) {
+            if (target !== source) {
+                BoundingRect.copy(target, source);
+            }
+            return;
+        }
+        if (m[1] < 1e-5 && m[1] > -1e-5 && m[2] < 1e-5 && m[2] > -1e-5) {
+            var sx = m[0];
+            var sy = m[3];
+            var tx = m[4];
+            var ty = m[5];
+            target.x = source.x * sx + tx;
+            target.y = source.y * sy + ty;
+            target.width = source.width * sx;
+            target.height = source.height * sy;
+            if (target.width < 0) {
+                target.x += target.width;
+                target.width = -target.width;
+            }
+            if (target.height < 0) {
+                target.y += target.height;
+                target.height = -target.height;
+            }
+            return;
+        }
+        lt.x = lb.x = source.x;
+        lt.y = rt.y = source.y;
+        rb.x = rt.x = source.x + source.width;
+        rb.y = lb.y = source.y + source.height;
+        lt.transform(m);
+        rt.transform(m);
+        rb.transform(m);
+        lb.transform(m);
+        target.x = mathMin(lt.x, rb.x, lb.x, rt.x);
+        target.y = mathMin(lt.y, rb.y, lb.y, rt.y);
+        var maxX = mathMax(lt.x, rb.x, lb.x, rt.x);
+        var maxY = mathMax(lt.y, rb.y, lb.y, rt.y);
+        target.width = maxX - target.x;
+        target.height = maxY - target.y;
+    };
+    return BoundingRect;
+}());
+var _tmpIntersectA = new BoundingRect(0, 0, 0, 0);
+var _tmpIntersectB = new BoundingRect(0, 0, 0, 0);
+function intersectOneDim(a0, a1, b0, b1, updateDimIdx, useMTV, outIntersectRect, clamp) {
+    var d0 = mathAbs(a1 - b0);
+    var d1 = mathAbs(b1 - a0);
+    var d01min = mathMin(d0, d1);
+    var updateDim = XY[updateDimIdx];
+    var zeroDim = XY[1 - updateDimIdx];
+    var wh = WH[updateDimIdx];
+    if (a1 < b0 || b1 < a0) {
+        if (d0 < d1) {
+            if (useMTV) {
+                _maxTv[updateDim] = -d0;
+            }
+            if (clamp) {
+                outIntersectRect[updateDim] = a1;
+                outIntersectRect[wh] = 0;
+            }
+        }
+        else {
+            if (useMTV) {
+                _maxTv[updateDim] = d1;
+            }
+            if (clamp) {
+                outIntersectRect[updateDim] = a0;
+                outIntersectRect[wh] = 0;
+            }
+        }
+    }
+    else {
+        if (outIntersectRect) {
+            outIntersectRect[updateDim] = mathMax(a0, b0);
+            outIntersectRect[wh] = mathMin(a1, b1) - outIntersectRect[updateDim];
+        }
+        if (useMTV) {
+            if (d01min < _lenMinMax[0] || _intersectCtx.useDir) {
+                _lenMinMax[0] = mathMin(d01min, _lenMinMax[0]);
+                if (d0 < d1 || !_intersectCtx.bidirectional) {
+                    _minTv[updateDim] = d0;
+                    _minTv[zeroDim] = 0;
+                    if (_intersectCtx.useDir) {
+                        _intersectCtx.calcDirMTV();
+                    }
+                }
+                if (d0 >= d1 || !_intersectCtx.bidirectional) {
+                    _minTv[updateDim] = -d1;
+                    _minTv[zeroDim] = 0;
+                    if (_intersectCtx.useDir) {
+                        _intersectCtx.calcDirMTV();
+                    }
+                }
+            }
+        }
+    }
+}
+function createIntersectContext() {
+    var _direction = 0;
+    var _dirCheckVec = new Point.default();
+    var _dirTmp = new Point.default();
+    var _ctx = {
+        minTv: new Point.default(),
+        maxTv: new Point.default(),
+        useDir: false,
+        dirMinTv: new Point.default(),
+        touchThreshold: 0,
+        bidirectional: true,
+        negativeSize: false,
+        reset: function (opt, useMTV) {
+            _ctx.touchThreshold = 0;
+            if (opt && opt.touchThreshold != null) {
+                _ctx.touchThreshold = mathMax(0, opt.touchThreshold);
+            }
+            _ctx.negativeSize = false;
+            if (!useMTV) {
+                return;
+            }
+            _ctx.minTv.set(Infinity, Infinity);
+            _ctx.maxTv.set(0, 0);
+            _ctx.useDir = false;
+            if (opt && opt.direction != null) {
+                _ctx.useDir = true;
+                _ctx.dirMinTv.copy(_ctx.minTv);
+                _dirTmp.copy(_ctx.minTv);
+                _direction = opt.direction;
+                _ctx.bidirectional = opt.bidirectional == null || !!opt.bidirectional;
+                if (!_ctx.bidirectional) {
+                    _dirCheckVec.set(Math.cos(_direction), Math.sin(_direction));
+                }
+            }
+        },
+        calcDirMTV: function () {
+            var minTv = _ctx.minTv;
+            var dirMinTv = _ctx.dirMinTv;
+            var squareMag = minTv.y * minTv.y + minTv.x * minTv.x;
+            var dirSin = Math.sin(_direction);
+            var dirCos = Math.cos(_direction);
+            var dotProd = dirSin * minTv.y + dirCos * minTv.x;
+            if (nearZero(dotProd)) {
+                if (nearZero(minTv.x) && nearZero(minTv.y)) {
+                    dirMinTv.set(0, 0);
+                }
+                return;
+            }
+            _dirTmp.x = squareMag * dirCos / dotProd;
+            _dirTmp.y = squareMag * dirSin / dotProd;
+            if (nearZero(_dirTmp.x) && nearZero(_dirTmp.y)) {
+                dirMinTv.set(0, 0);
+                return;
+            }
+            if ((_ctx.bidirectional
+                || _dirCheckVec.dot(_dirTmp) > 0)
+                && _dirTmp.len() < dirMinTv.len()) {
+                dirMinTv.copy(_dirTmp);
+            }
+        }
+    };
+    function nearZero(val) {
+        return mathAbs(val) < 1e-10;
+    }
+    return _ctx;
+}
+
+exports.createIntersectContext = createIntersectContext;
+exports.default = BoundingRect;

package/lib/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/Eventful.js

@@ -0,0 +1,167 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var Eventful = (function () {
+    function Eventful(eventProcessors) {
+        if (eventProcessors) {
+            this._$eventProcessor = eventProcessors;
+        }
+    }
+    Eventful.prototype.on = function (event, query, handler, context) {
+        if (!this._$handlers) {
+            this._$handlers = {};
+        }
+        var _h = this._$handlers;
+        if (typeof query === 'function') {
+            context = handler;
+            handler = query;
+            query = null;
+        }
+        if (!handler || !event) {
+            return this;
+        }
+        var eventProcessor = this._$eventProcessor;
+        if (query != null && eventProcessor && eventProcessor.normalizeQuery) {
+            query = eventProcessor.normalizeQuery(query);
+        }
+        if (!_h[event]) {
+            _h[event] = [];
+        }
+        for (var i = 0; i < _h[event].length; i++) {
+            if (_h[event][i].h === handler) {
+                return this;
+            }
+        }
+        var wrap = {
+            h: handler,
+            query: query,
+            ctx: (context || this),
+            callAtLast: handler.zrEventfulCallAtLast
+        };
+        var lastIndex = _h[event].length - 1;
+        var lastWrap = _h[event][lastIndex];
+        (lastWrap && lastWrap.callAtLast)
+            ? _h[event].splice(lastIndex, 0, wrap)
+            : _h[event].push(wrap);
+        return this;
+    };
+    Eventful.prototype.isSilent = function (eventName) {
+        var _h = this._$handlers;
+        return !_h || !_h[eventName] || !_h[eventName].length;
+    };
+    Eventful.prototype.off = function (eventType, handler) {
+        var _h = this._$handlers;
+        if (!_h) {
+            return this;
+        }
+        if (!eventType) {
+            this._$handlers = {};
+            return this;
+        }
+        if (handler) {
+            if (_h[eventType]) {
+                var newList = [];
+                for (var i = 0, l = _h[eventType].length; i < l; i++) {
+                    if (_h[eventType][i].h !== handler) {
+                        newList.push(_h[eventType][i]);
+                    }
+                }
+                _h[eventType] = newList;
+            }
+            if (_h[eventType] && _h[eventType].length === 0) {
+                delete _h[eventType];
+            }
+        }
+        else {
+            delete _h[eventType];
+        }
+        return this;
+    };
+    Eventful.prototype.trigger = function (eventType) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!this._$handlers) {
+            return this;
+        }
+        var _h = this._$handlers[eventType];
+        var eventProcessor = this._$eventProcessor;
+        if (_h) {
+            var argLen = args.length;
+            var len = _h.length;
+            for (var i = 0; i < len; i++) {
+                var hItem = _h[i];
+                if (eventProcessor
+                    && eventProcessor.filter
+                    && hItem.query != null
+                    && !eventProcessor.filter(eventType, hItem.query)) {
+                    continue;
+                }
+                switch (argLen) {
+                    case 0:
+                        hItem.h.call(hItem.ctx);
+                        break;
+                    case 1:
+                        hItem.h.call(hItem.ctx, args[0]);
+                        break;
+                    case 2:
+                        hItem.h.call(hItem.ctx, args[0], args[1]);
+                        break;
+                    default:
+                        hItem.h.apply(hItem.ctx, args);
+                        break;
+                }
+            }
+        }
+        eventProcessor && eventProcessor.afterTrigger
+            && eventProcessor.afterTrigger(eventType);
+        return this;
+    };
+    Eventful.prototype.triggerWithContext = function (type) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (!this._$handlers) {
+            return this;
+        }
+        var _h = this._$handlers[type];
+        var eventProcessor = this._$eventProcessor;
+        if (_h) {
+            var argLen = args.length;
+            var ctx = args[argLen - 1];
+            var len = _h.length;
+            for (var i = 0; i < len; i++) {
+                var hItem = _h[i];
+                if (eventProcessor
+                    && eventProcessor.filter
+                    && hItem.query != null
+                    && !eventProcessor.filter(type, hItem.query)) {
+                    continue;
+                }
+                switch (argLen) {
+                    case 0:
+                        hItem.h.call(ctx);
+                        break;
+                    case 1:
+                        hItem.h.call(ctx, args[0]);
+                        break;
+                    case 2:
+                        hItem.h.call(ctx, args[0], args[1]);
+                        break;
+                    default:
+                        hItem.h.apply(ctx, args.slice(1, argLen - 1));
+                        break;
+                }
+            }
+        }
+        eventProcessor && eventProcessor.afterTrigger
+            && eventProcessor.afterTrigger(type);
+        return this;
+    };
+    return Eventful;
+}());
+
+exports.default = Eventful;

package/lib/node_modules/.pnpm/zrender@6.0.0/node_modules/zrender/lib/core/GestureMgr.js

@@ -0,0 +1,86 @@
+'use strict';
+
+var event = require('./event.js');
+
+var GestureMgr = (function () {
+    function GestureMgr() {
+        this._track = [];
+    }
+    GestureMgr.prototype.recognize = function (event, target, root) {
+        this._doTrack(event, target, root);
+        return this._recognize(event);
+    };
+    GestureMgr.prototype.clear = function () {
+        this._track.length = 0;
+        return this;
+    };
+    GestureMgr.prototype._doTrack = function (event$1, target, root) {
+        var touches = event$1.touches;
+        if (!touches) {
+            return;
+        }
+        var trackItem = {
+            points: [],
+            touches: [],
+            target: target,
+            event: event$1
+        };
+        for (var i = 0, len = touches.length; i < len; i++) {
+            var touch = touches[i];
+            var pos = event.clientToLocal(root, touch, {});
+            trackItem.points.push([pos.zrX, pos.zrY]);
+            trackItem.touches.push(touch);
+        }
+        this._track.push(trackItem);
+    };
+    GestureMgr.prototype._recognize = function (event) {
+        for (var eventName in recognizers) {
+            if (recognizers.hasOwnProperty(eventName)) {
+                var gestureInfo = recognizers[eventName](this._track, event);
+                if (gestureInfo) {
+                    return gestureInfo;
+                }
+            }
+        }
+    };
+    return GestureMgr;
+}());
+function dist(pointPair) {
+    var dx = pointPair[1][0] - pointPair[0][0];
+    var dy = pointPair[1][1] - pointPair[0][1];
+    return Math.sqrt(dx * dx + dy * dy);
+}
+function center(pointPair) {
+    return [
+        (pointPair[0][0] + pointPair[1][0]) / 2,
+        (pointPair[0][1] + pointPair[1][1]) / 2
+    ];
+}
+var recognizers = {
+    pinch: function (tracks, event) {
+        var trackLen = tracks.length;
+        if (!trackLen) {
+            return;
+        }
+        var pinchEnd = (tracks[trackLen - 1] || {}).points;
+        var pinchPre = (tracks[trackLen - 2] || {}).points || pinchEnd;
+        if (pinchPre
+            && pinchPre.length > 1
+            && pinchEnd
+            && pinchEnd.length > 1) {
+            var pinchScale = dist(pinchEnd) / dist(pinchPre);
+            !isFinite(pinchScale) && (pinchScale = 1);
+            event.pinchScale = pinchScale;
+            var pinchCenter = center(pinchEnd);
+            event.pinchX = pinchCenter[0];
+            event.pinchY = pinchCenter[1];
+            return {
+                type: 'pinch',
+                target: tracks[0].target,
+                event: event
+            };
+        }
+    }
+};
+
+exports.GestureMgr = GestureMgr;