@visactor/vutils 0.11.1 → 0.13.0

package/dist/index.js

@@ -325,7 +325,7 @@
 	var eventemitter3Exports = eventemitter3.exports;
 	var index$1 = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports);
 
-	const isType = (value, type) => toString.call(value) === `[object ${type}]`;
+	const isType = (value, type) => Object.prototype.toString.call(value) === `[object ${type}]`;
 
 	const isBoolean = (value, fuzzy = false) => {
 	    if (fuzzy) {
@@ -3713,7 +3713,7 @@
 	    _context = null;
 	    _contextSaved = false;
 	    _notSupportCanvas = false;
-	    _notSupportCanopus = false;
+	    _notSupportVRender = false;
 	    _userSpec = {};
 	    textSpec;
 	    _option;
@@ -3738,7 +3738,10 @@
 	            if (isValid(this._option.getCanvasForMeasure)) {
 	                this._canvas = this._option.getCanvasForMeasure();
 	            }
-	            if (isNil(this._canvas) && isValid(globalThis.document)) {
+	            if (isNil(this._canvas) &&
+	                typeof window !== 'undefined' &&
+	                typeof window.document !== 'undefined' &&
+	                isValid(globalThis.document)) {
 	                this._canvas = globalThis.document.createElement('canvas');
 	            }
 	        }
@@ -3775,6 +3778,7 @@
 	    }
 	    measure(text, method) {
 	        switch (method) {
+	            case 'vrender':
 	            case 'canopus':
 	                return this.fullMeasure(text);
 	            case 'canvas':
@@ -3790,7 +3794,7 @@
 	        if (isNil(text)) {
 	            return { width: 0, height: 0 };
 	        }
-	        if (isNil(this._option.getTextBounds) || !this._notSupportCanopus) {
+	        if (isNil(this._option.getTextBounds) || !this._notSupportVRender) {
 	            return this.measureWithNaiveCanvas(text);
 	        }
 	        const { fontFamily, fontSize, fontWeight, textAlign, textBaseline, ellipsis, limit, lineHeight } = this.textSpec;
@@ -3810,7 +3814,7 @@
 	            size = { width: bounds.width(), height: bounds.height() };
 	        }
 	        catch (e) {
-	            this._notSupportCanopus = true;
+	            this._notSupportVRender = true;
 	            size = this.measureWithNaiveCanvas(text);
 	        }
 	        return size;
@@ -3960,7 +3964,7 @@
 	            .fill(0)
 	            .map(callback);
 	        const methodMap = {
-	            canopus: this.fullMeasure.bind(this),
+	            vrender: this.fullMeasure.bind(this),
 	            canvas: this.measureWithNaiveCanvas.bind(this),
 	            simple: this.quickMeasureWithoutCanvas.bind(this),
 	            quick: this.quickMeasure.bind(this),
@@ -4015,62 +4019,119 @@
 	}
 
 	function log(method, level, input) {
-	    const hasConsole = typeof console !== 'undefined';
-	    if (hasConsole) {
-	        const args = [level].concat([].slice.call(input));
-	        console[method].apply(console, args);
-	    }
-	}
-	const None = 0;
-	const Error$1 = 1;
-	const Warn = 2;
-	const Info = 3;
-	const Debug = 4;
-	function logger(logLevel, method) {
-	    let level = logLevel || None;
-	    return {
-	        level(levelValue) {
-	            if (arguments.length) {
-	                level = +levelValue;
-	                return this;
-	            }
-	            return level;
-	        },
-	        error(...args) {
-	            if (level >= Error$1) {
-	                log(method || 'error', 'ERROR', args);
-	            }
-	            return this;
-	        },
-	        warn(...args) {
-	            if (level >= Warn) {
-	                log(method || 'warn', 'WARN', args);
-	            }
+	    const args = [level].concat([].slice.call(input));
+	    console[method].apply(console, args);
+	}
+	var LoggerLevel;
+	(function (LoggerLevel) {
+	    LoggerLevel[LoggerLevel["None"] = 0] = "None";
+	    LoggerLevel[LoggerLevel["Error"] = 1] = "Error";
+	    LoggerLevel[LoggerLevel["Warn"] = 2] = "Warn";
+	    LoggerLevel[LoggerLevel["Info"] = 3] = "Info";
+	    LoggerLevel[LoggerLevel["Debug"] = 4] = "Debug";
+	})(LoggerLevel || (LoggerLevel = {}));
+	class Logger {
+	    static _instance = null;
+	    static getInstance(level, method) {
+	        if (Logger._instance && isNumber(level)) {
+	            Logger._instance.level(level);
+	        }
+	        else if (!Logger._instance) {
+	            Logger._instance = new Logger(level, method);
+	        }
+	        return Logger._instance;
+	    }
+	    static setInstance(logger) {
+	        return (Logger._instance = logger);
+	    }
+	    static setInstanceLevel(level) {
+	        if (Logger._instance) {
+	            Logger._instance.level(level);
+	        }
+	        else {
+	            Logger._instance = new Logger(level);
+	        }
+	    }
+	    static clearInstance() {
+	        Logger._instance = null;
+	    }
+	    _level;
+	    _method;
+	    _onErrorHandler = [];
+	    constructor(level = LoggerLevel.None, method) {
+	        this._level = level;
+	        this._method = method;
+	    }
+	    addErrorHandler(handler) {
+	        if (this._onErrorHandler.find(h => h === handler)) {
+	            return;
+	        }
+	        this._onErrorHandler.push(handler);
+	    }
+	    removeErrorHandler(handler) {
+	        const index = this._onErrorHandler.findIndex(h => h === handler);
+	        if (index < 0) {
+	            return;
+	        }
+	        this._onErrorHandler.splice(index, 1);
+	    }
+	    callErrorHandler(...args) {
+	        this._onErrorHandler.forEach(h => h(args));
+	    }
+	    canLogInfo() {
+	        return this._level >= LoggerLevel.Info;
+	    }
+	    canLogDebug() {
+	        return this._level >= LoggerLevel.Debug;
+	    }
+	    canLogError() {
+	        return this._level >= LoggerLevel.Error;
+	    }
+	    canLogWarn() {
+	        return this._level >= LoggerLevel.Warn;
+	    }
+	    level(levelValue) {
+	        if (arguments.length) {
+	            this._level = +levelValue;
 	            return this;
-	        },
-	        info(...args) {
-	            if (level >= Info) {
-	                log(method || 'log', 'INFO', args);
+	        }
+	        return this._level;
+	    }
+	    error(...args) {
+	        if (this._level >= LoggerLevel.Error) {
+	            if (this._onErrorHandler.length) {
+	                this.callErrorHandler(args);
 	            }
-	            return this;
-	        },
-	        debug(...args) {
-	            if (level >= Debug) {
-	                log(method || 'log', 'DEBUG', args);
+	            else {
+	                log(this._method ?? 'error', 'ERROR', args);
 	            }
-	            return this;
 	        }
-	    };
+	        return this;
+	    }
+	    warn(...args) {
+	        if (this._level >= LoggerLevel.Warn) {
+	            log(this._method || 'warn', 'WARN', args);
+	        }
+	        return this;
+	    }
+	    info(...args) {
+	        if (this._level >= LoggerLevel.Info) {
+	            log(this._method || 'log', 'INFO', args);
+	        }
+	        return this;
+	    }
+	    debug(...args) {
+	        if (this._level >= LoggerLevel.Debug) {
+	            log(this._method || 'log', 'DEBUG', args);
+	        }
+	        return this;
+	    }
 	}
 
-	var logger$1 = /*#__PURE__*/Object.freeze({
+	var logger = /*#__PURE__*/Object.freeze({
 		__proto__: null,
-		Debug: Debug,
-		Error: Error$1,
-		Info: Info,
-		None: None,
-		Warn: Warn,
-		logger: logger
+		Logger: Logger,
+		get LoggerLevel () { return LoggerLevel; }
 	});
 
 	function normalizePadding(padding) {
@@ -4509,19 +4570,8 @@
 	    };
 	}
 	function getElementAbsolutePosition(element) {
-	    let actualLeft = element.offsetLeft;
-	    let current = element.offsetParent;
-	    while (current) {
-	        actualLeft += current.offsetLeft;
-	        current = current.offsetParent;
-	    }
-	    let actualTop = element.offsetTop;
-	    current = element.offsetParent;
-	    while (current) {
-	        actualTop += current.offsetTop + current.clientTop;
-	        current = current.offsetParent;
-	    }
-	    return { x: actualLeft, y: actualTop };
+	    const { x, y } = element.getBoundingClientRect();
+	    return { x, y };
 	}
 	function getElementRelativePosition(element, base) {
 	    const posElement = getElementAbsolutePosition(element);
@@ -4546,26 +4596,18 @@
 	    }
 	    return element.scrollTop;
 	};
-	function getElementAbsoluteScrollOffset(element) {
-	    let actualLeft = getScrollLeft(element);
-	    let current = element.parentElement;
-	    while (current) {
-	        actualLeft += getScrollLeft(current);
-	        current = current.parentElement;
-	    }
-	    let actualTop = getScrollTop(element);
-	    current = element.parentElement;
-	    while (current) {
-	        actualTop += getScrollTop(current);
-	        current = current.parentElement;
-	    }
-	    return { x: actualLeft, y: actualTop };
-	}
-	function getElementRelativeScrollOffset(element, base) {
-	    const posElement = getElementAbsoluteScrollOffset(element);
-	    const posBase = getElementAbsoluteScrollOffset(base);
-	    return { x: posElement.x - posBase.x, y: posElement.y - posBase.y };
-	}
+	const getScaleX = (element) => {
+	    return element.getBoundingClientRect().width / element.offsetWidth;
+	};
+	const getScaleY = (element) => {
+	    return element.getBoundingClientRect().height / element.offsetHeight;
+	};
+	const getScale = (element) => {
+	    if (element.offsetWidth > 0) {
+	        return getScaleX(element);
+	    }
+	    return getScaleY(element);
+	};
 	function hasParentElement(element, target) {
 	    let parent = element.parentNode;
 	    while (parent !== null) {
@@ -4689,7 +4731,7 @@
 	exports.HashTable = HashTable;
 	exports.HashValue = HashValue;
 	exports.LRU = LRU;
-	exports.Logger = logger$1;
+	exports.Logger = logger;
 	exports.MINUTE = MINUTE;
 	exports.MONTH = MONTH;
 	exports.Matrix = Matrix;
@@ -4754,14 +4796,17 @@
 	exports.getContainerSize = getContainerSize;
 	exports.getContextFont = getContextFont;
 	exports.getElementAbsolutePosition = getElementAbsolutePosition;
-	exports.getElementAbsoluteScrollOffset = getElementAbsoluteScrollOffset;
 	exports.getElementRelativePosition = getElementRelativePosition;
-	exports.getElementRelativeScrollOffset = getElementRelativeScrollOffset;
 	exports.getFormatFromValue = getFormatFromValue;
 	exports.getIntersectPoint = getIntersectPoint;
 	exports.getIntervalOptions = getIntervalOptions;
 	exports.getOBBFromLine = getOBBFromLine;
 	exports.getRectIntersect = getRectIntersect;
+	exports.getScale = getScale;
+	exports.getScaleX = getScaleX;
+	exports.getScaleY = getScaleY;
+	exports.getScrollLeft = getScrollLeft;
+	exports.getScrollTop = getScrollTop;
 	exports.getTestNumbers = getTestNumbers;
 	exports.getTestWord = getTestWord;
 	exports.getTimeFormatter = getTimeFormatter;