@idraw/renderer 0.4.0-beta.39 → 0.4.0-beta.40

package/dist/esm/virtual-flat/index.js

@@ -0,0 +1,45 @@
+import { is, getGroupQueueByElementPosition, calcElementOriginRectInfo, originRectInfoToRangeRectInfo } from '@idraw/util';
+import { calcVirtualTextDetail } from './text';
+export function calcVirtualFlatDetail(elem, opts) {
+    let virtualDetail = {};
+    if (elem.type === 'text') {
+        virtualDetail = calcVirtualTextDetail(elem, opts);
+    }
+    return virtualDetail;
+}
+export function elementsToVirtualFlatMap(elements, opts) {
+    const virtualFlatMap = {};
+    const currentPosition = [];
+    const _walk = (elem) => {
+        const baseInfo = {
+            type: elem.type,
+            isVisibleInView: true,
+            position: [...currentPosition]
+        };
+        let originRectInfo = null;
+        const groupQueue = getGroupQueueByElementPosition(elements, currentPosition);
+        originRectInfo = calcElementOriginRectInfo(elem, {
+            groupQueue: groupQueue || []
+        });
+        const virtualItem = Object.assign(Object.assign(Object.assign({}, baseInfo), {
+            originRectInfo: originRectInfo,
+            rangeRectInfo: is.angle(elem.angle)
+                ? originRectInfoToRangeRectInfo(originRectInfo)
+                : originRectInfo
+        }), calcVirtualFlatDetail(elem, opts));
+        virtualFlatMap[elem.uuid] = virtualItem;
+        if (elem.type === 'group') {
+            elem.detail.children.forEach((ele, i) => {
+                currentPosition.push(i);
+                _walk(ele);
+                currentPosition.pop();
+            });
+        }
+    };
+    elements.forEach((elem, index) => {
+        currentPosition.push(index);
+        _walk(elem);
+        currentPosition.pop();
+    });
+    return virtualFlatMap;
+}

package/dist/esm/virtual-flat/text.d.ts

@@ -0,0 +1,2 @@
+import type { Element, CalcVirtualDetailOptions, VirtualFlatTextDetail } from '@idraw/types';
+export declare function calcVirtualTextDetail(elem: Element<'text'>, opts: CalcVirtualDetailOptions): VirtualFlatTextDetail;

package/dist/esm/virtual-flat/text.js

@@ -0,0 +1,151 @@
+import { enhanceFontFamliy, getDefaultElementDetailConfig } from '@idraw/util';
+const detailConfig = getDefaultElementDetailConfig();
+function isTextWidthWithinErrorRange(w0, w1, scale) {
+    if (scale < 0.5) {
+        if (w0 < w1 && (w0 - w1) / w0 > -0.15) {
+            return true;
+        }
+    }
+    return w0 >= w1;
+}
+export function calcVirtualTextDetail(elem, opts) {
+    const { w, h } = elem;
+    const x = 0;
+    const y = 0;
+    const ctx = opts.tempContext;
+    const lines = [];
+    const detail = Object.assign(Object.assign({}, detailConfig), elem.detail);
+    const originFontSize = detail.fontSize || detailConfig.fontSize;
+    const fontSize = originFontSize;
+    if (fontSize < 2) {
+        return {};
+    }
+    const originLineHeight = detail.lineHeight || originFontSize;
+    const lineHeight = originLineHeight;
+    ctx.textBaseline = 'top';
+    ctx.$setFont({
+        fontWeight: detail.fontWeight,
+        fontSize: fontSize,
+        fontFamily: enhanceFontFamliy(detail.fontFamily)
+    });
+    let detailText = detail.text.replace(/\r\n/gi, '\n');
+    if (detail.textTransform === 'lowercase') {
+        detailText = detailText.toLowerCase();
+    }
+    else if (detail.textTransform === 'uppercase') {
+        detailText = detailText.toUpperCase();
+    }
+    const fontHeight = lineHeight;
+    const detailTextList = detailText.split('\n');
+    let lineNum = 0;
+    detailTextList.forEach((itemText, idx) => {
+        if (detail.minInlineSize === 'maxContent') {
+            lines.push({
+                x,
+                y: 0,
+                text: itemText,
+                width: ctx.$undoPixelRatio(ctx.measureText(itemText).width)
+            });
+        }
+        else {
+            let lineText = '';
+            let splitStr = '';
+            let tempStrList = itemText.split(splitStr);
+            if (detail.wordBreak === 'normal') {
+                splitStr = ' ';
+                const wordList = itemText.split(splitStr);
+                tempStrList = [];
+                wordList.forEach((word, idx) => {
+                    tempStrList.push(word);
+                    if (idx < wordList.length - 1) {
+                        tempStrList.push(splitStr);
+                    }
+                });
+            }
+            if (tempStrList.length === 1 && detail.overflow === 'visible') {
+                lines.push({
+                    x,
+                    y: 0,
+                    text: tempStrList[0],
+                    width: ctx.$undoPixelRatio(ctx.measureText(tempStrList[0]).width)
+                });
+            }
+            else if (tempStrList.length > 0) {
+                for (let i = 0; i < tempStrList.length; i++) {
+                    if (isTextWidthWithinErrorRange(ctx.$doPixelRatio(w), ctx.measureText(lineText + tempStrList[i]).width, 1)) {
+                        lineText += tempStrList[i] || '';
+                    }
+                    else {
+                        lines.push({
+                            x,
+                            y: 0,
+                            text: lineText,
+                            width: ctx.$undoPixelRatio(ctx.measureText(lineText).width)
+                        });
+                        lineText = tempStrList[i] || '';
+                        lineNum++;
+                    }
+                    if ((lineNum + 1) * fontHeight > h && detail.overflow === 'hidden') {
+                        break;
+                    }
+                    if (tempStrList.length - 1 === i) {
+                        if ((lineNum + 1) * fontHeight <= h) {
+                            lines.push({
+                                x,
+                                y: 0,
+                                text: lineText,
+                                width: ctx.$undoPixelRatio(ctx.measureText(lineText).width)
+                            });
+                            if (idx < detailTextList.length - 1) {
+                                lineNum++;
+                            }
+                            break;
+                        }
+                    }
+                }
+            }
+            else {
+                lines.push({
+                    x,
+                    y: 0,
+                    text: '',
+                    width: 0
+                });
+            }
+        }
+    });
+    let startY = 0;
+    let eachLineStartY = 0;
+    if (fontHeight > fontSize) {
+        eachLineStartY = (fontHeight - fontSize) / 2;
+    }
+    if (lines.length * fontHeight < h) {
+        if (elem.detail.verticalAlign === 'top') {
+            startY = 0;
+        }
+        else if (elem.detail.verticalAlign === 'bottom') {
+            startY += h - lines.length * fontHeight;
+        }
+        else {
+            startY += (h - lines.length * fontHeight) / 2;
+        }
+    }
+    {
+        const _y = y + startY;
+        lines.forEach((line, i) => {
+            let _x = x;
+            if (detail.textAlign === 'center') {
+                _x = x + (w - line.width) / 2;
+            }
+            else if (detail.textAlign === 'right') {
+                _x = x + (w - line.width);
+            }
+            lines[i].x = _x;
+            lines[i].y = _y + fontHeight * i + eachLineStartY;
+        });
+    }
+    const virtualTextDetail = {
+        textLines: lines
+    };
+    return virtualTextDetail;
+}