@leafer-ui/node 1.4.2 → 1.5.0

package/dist/node.cjs

@@ -2124,13 +2124,14 @@ function toChar(data, charX, rowData, isOverflow) {
 }
 
 function layoutText(drawData, style) {
-    const { rows, bounds } = drawData;
+    const { rows, bounds } = drawData, countRows = rows.length;
     const { __lineHeight, __baseLine, __letterSpacing, __clipText, textAlign, verticalAlign, paraSpacing, autoSizeAlign } = style;
-    let { x, y, width, height } = bounds, realHeight = __lineHeight * rows.length + (paraSpacing ? paraSpacing * (drawData.paraNumber - 1) : 0);
+    let { x, y, width, height } = bounds, realHeight = __lineHeight * countRows + (paraSpacing ? paraSpacing * (drawData.paraNumber - 1) : 0);
     let starY = __baseLine;
     if (__clipText && realHeight > height) {
         realHeight = Math.max(height, __lineHeight);
-        drawData.overflow = rows.length;
+        if (countRows > 1)
+            drawData.overflow = countRows;
     }
     else if (height || autoSizeAlign) {
         switch (verticalAlign) {
@@ -2142,7 +2143,7 @@ function layoutText(drawData, style) {
     }
     starY += y;
     let row, rowX, rowWidth, layoutWidth = (width || autoSizeAlign) ? width : drawData.maxWidth;
-    for (let i = 0, len = rows.length; i < len; i++) {
+    for (let i = 0, len = countRows; i < len; i++) {
         row = rows[i];
         row.x = x;
         if (row.width < width || (row.width > width && !__clipText)) {
@@ -2211,7 +2212,7 @@ function clipText(drawData, style, x, width) {
                     if (i === end && charRight < right) {
                         break;
                     }
-                    else if (charRight < right && char.char !== ' ') {
+                    else if ((charRight < right && char.char !== ' ') || !i) {
                         row.data.splice(i + 1);
                         row.width -= char.width;
                         break;
@@ -2355,124 +2356,134 @@ function getTrimBounds(canvas) {
 }
 
 const ExportModule = {
-    export(leaf, filename, options) {
+    syncExport(leaf, filename, options) {
         this.running = true;
+        let result;
         const fileType = draw.FileHelper.fileType(filename);
         const isDownload = filename.includes('.');
         options = draw.FileHelper.getExportOptions(options);
-        return addTask((success) => new Promise((resolve) => {
-            const over = (result) => {
-                success(result);
-                resolve();
-                this.running = false;
-            };
-            const { toURL } = draw.Platform;
-            const { download } = draw.Platform.origin;
-            if (fileType === 'json') {
-                isDownload && download(toURL(JSON.stringify(leaf.toJSON(options.json)), 'text'), filename);
-                return over({ data: isDownload ? true : leaf.toJSON(options.json) });
+        const { toURL } = draw.Platform;
+        const { download } = draw.Platform.origin;
+        if (fileType === 'json') {
+            isDownload && download(toURL(JSON.stringify(leaf.toJSON(options.json)), 'text'), filename);
+            result = { data: isDownload ? true : leaf.toJSON(options.json) };
+        }
+        else if (fileType === 'svg') {
+            isDownload && download(toURL(leaf.toSVG(), 'svg'), filename);
+            result = { data: isDownload ? true : leaf.toSVG() };
+        }
+        else {
+            let renderBounds, trimBounds, scaleX = 1, scaleY = 1;
+            const { worldTransform, isLeafer, leafer, isFrame } = leaf;
+            const { slice, trim, padding, onCanvas } = options;
+            const smooth = options.smooth === undefined ? (leafer ? leafer.config.smooth : true) : options.smooth;
+            const contextSettings = options.contextSettings || (leafer ? leafer.config.contextSettings : undefined);
+            const screenshot = options.screenshot || leaf.isApp;
+            const fill = (isLeafer && screenshot) ? (options.fill === undefined ? leaf.fill : options.fill) : options.fill;
+            const needFill = draw.FileHelper.isOpaqueImage(filename) || fill, matrix = new draw.Matrix();
+            if (screenshot) {
+                renderBounds = screenshot === true ? (isLeafer ? leafer.canvas.bounds : leaf.worldRenderBounds) : screenshot;
             }
-            if (fileType === 'svg') {
-                isDownload && download(toURL(leaf.toSVG(), 'svg'), filename);
-                return over({ data: isDownload ? true : leaf.toSVG() });
+            else {
+                let relative = options.relative || (isLeafer ? 'inner' : 'local');
+                scaleX = worldTransform.scaleX;
+                scaleY = worldTransform.scaleY;
+                switch (relative) {
+                    case 'inner':
+                        matrix.set(worldTransform);
+                        break;
+                    case 'local':
+                        matrix.set(worldTransform).divide(leaf.localTransform);
+                        scaleX /= leaf.scaleX;
+                        scaleY /= leaf.scaleY;
+                        break;
+                    case 'world':
+                        scaleX = 1;
+                        scaleY = 1;
+                        break;
+                    case 'page':
+                        relative = leafer || leaf;
+                    default:
+                        matrix.set(worldTransform).divide(leaf.getTransform(relative));
+                        const l = relative.worldTransform;
+                        scaleX /= scaleX / l.scaleX;
+                        scaleY /= scaleY / l.scaleY;
+                }
+                renderBounds = leaf.getBounds('render', relative);
             }
-            const { leafer } = leaf;
-            if (leafer) {
-                checkLazy(leaf);
-                leafer.waitViewCompleted(() => __awaiter(this, void 0, void 0, function* () {
-                    let renderBounds, trimBounds, scaleX = 1, scaleY = 1;
-                    const { worldTransform, isLeafer, isFrame } = leaf;
-                    const { slice, trim, padding, onCanvas } = options;
-                    const smooth = options.smooth === undefined ? leafer.config.smooth : options.smooth;
-                    const contextSettings = options.contextSettings || leafer.config.contextSettings;
-                    const screenshot = options.screenshot || leaf.isApp;
-                    const fill = (isLeafer && screenshot) ? (options.fill === undefined ? leaf.fill : options.fill) : options.fill;
-                    const needFill = draw.FileHelper.isOpaqueImage(filename) || fill, matrix = new draw.Matrix();
-                    if (screenshot) {
-                        renderBounds = screenshot === true ? (isLeafer ? leafer.canvas.bounds : leaf.worldRenderBounds) : screenshot;
-                    }
-                    else {
-                        let relative = options.relative || (isLeafer ? 'inner' : 'local');
-                        scaleX = worldTransform.scaleX;
-                        scaleY = worldTransform.scaleY;
-                        switch (relative) {
-                            case 'inner':
-                                matrix.set(worldTransform);
-                                break;
-                            case 'local':
-                                matrix.set(worldTransform).divide(leaf.localTransform);
-                                scaleX /= leaf.scaleX;
-                                scaleY /= leaf.scaleY;
-                                break;
-                            case 'world':
-                                scaleX = 1;
-                                scaleY = 1;
-                                break;
-                            case 'page':
-                                relative = leaf.leafer;
-                            default:
-                                matrix.set(worldTransform).divide(leaf.getTransform(relative));
-                                const l = relative.worldTransform;
-                                scaleX /= scaleX / l.scaleX;
-                                scaleY /= scaleY / l.scaleY;
-                        }
-                        renderBounds = leaf.getBounds('render', relative);
-                    }
-                    const scaleData = { scaleX: 1, scaleY: 1 };
-                    draw.MathHelper.getScaleData(options.scale, options.size, renderBounds, scaleData);
-                    let pixelRatio = options.pixelRatio || 1;
-                    if (leaf.isApp) {
-                        scaleData.scaleX *= pixelRatio;
-                        scaleData.scaleY *= pixelRatio;
-                        pixelRatio = leaf.app.pixelRatio;
-                    }
-                    const { x, y, width, height } = new draw.Bounds(renderBounds).scale(scaleData.scaleX, scaleData.scaleY);
-                    const renderOptions = { matrix: matrix.scale(1 / scaleData.scaleX, 1 / scaleData.scaleY).invert().translate(-x, -y).withScale(1 / scaleX * scaleData.scaleX, 1 / scaleY * scaleData.scaleY) };
-                    let canvas = draw.Creator.canvas({ width: Math.round(width), height: Math.round(height), pixelRatio, smooth, contextSettings });
-                    let sliceLeaf;
-                    if (slice) {
-                        sliceLeaf = leaf;
-                        sliceLeaf.__worldOpacity = 0;
-                        leaf = leafer;
-                        renderOptions.bounds = canvas.bounds;
-                    }
-                    canvas.save();
-                    if (isFrame && fill !== undefined) {
-                        const oldFill = leaf.get('fill');
-                        leaf.fill = '';
-                        leaf.__render(canvas, renderOptions);
-                        leaf.fill = oldFill;
-                    }
-                    else {
-                        leaf.__render(canvas, renderOptions);
-                    }
-                    canvas.restore();
-                    if (sliceLeaf)
-                        sliceLeaf.__updateWorldOpacity();
-                    if (trim) {
-                        trimBounds = getTrimBounds(canvas);
-                        const old = canvas, { width, height } = trimBounds;
-                        const config = { x: 0, y: 0, width, height, pixelRatio };
-                        canvas = draw.Creator.canvas(config);
-                        canvas.copyWorld(old, trimBounds, config);
-                    }
-                    if (padding) {
-                        const [top, right, bottom, left] = draw.MathHelper.fourNumber(padding);
-                        const old = canvas, { width, height } = old;
-                        canvas = draw.Creator.canvas({ width: width + left + right, height: height + top + bottom, pixelRatio });
-                        canvas.copyWorld(old, old.bounds, { x: left, y: top, width, height });
-                    }
-                    if (needFill)
-                        canvas.fillWorld(canvas.bounds, fill || '#FFFFFF', 'destination-over');
-                    if (onCanvas)
-                        onCanvas(canvas);
-                    const data = filename === 'canvas' ? canvas : yield canvas.export(filename, options);
-                    over({ data, width: canvas.pixelWidth, height: canvas.pixelHeight, renderBounds, trimBounds });
-                }));
+            const scaleData = { scaleX: 1, scaleY: 1 };
+            draw.MathHelper.getScaleData(options.scale, options.size, renderBounds, scaleData);
+            let pixelRatio = options.pixelRatio || 1;
+            if (leaf.isApp) {
+                scaleData.scaleX *= pixelRatio;
+                scaleData.scaleY *= pixelRatio;
+                pixelRatio = leaf.app.pixelRatio;
+            }
+            const { x, y, width, height } = new draw.Bounds(renderBounds).scale(scaleData.scaleX, scaleData.scaleY);
+            const renderOptions = { matrix: matrix.scale(1 / scaleData.scaleX, 1 / scaleData.scaleY).invert().translate(-x, -y).withScale(1 / scaleX * scaleData.scaleX, 1 / scaleY * scaleData.scaleY) };
+            let canvas = draw.Creator.canvas({ width: Math.floor(width), height: Math.floor(height), pixelRatio, smooth, contextSettings });
+            let sliceLeaf;
+            if (slice) {
+                sliceLeaf = leaf;
+                sliceLeaf.__worldOpacity = 0;
+                leaf = leafer || leaf;
+                renderOptions.bounds = canvas.bounds;
+            }
+            canvas.save();
+            if (isFrame && fill !== undefined) {
+                const oldFill = leaf.get('fill');
+                leaf.fill = '';
+                leaf.__render(canvas, renderOptions);
+                leaf.fill = oldFill;
             }
             else {
-                over({ data: false });
+                leaf.__render(canvas, renderOptions);
+            }
+            canvas.restore();
+            if (sliceLeaf)
+                sliceLeaf.__updateWorldOpacity();
+            if (trim) {
+                trimBounds = getTrimBounds(canvas);
+                const old = canvas, { width, height } = trimBounds;
+                const config = { x: 0, y: 0, width, height, pixelRatio };
+                canvas = draw.Creator.canvas(config);
+                canvas.copyWorld(old, trimBounds, config);
+            }
+            if (padding) {
+                const [top, right, bottom, left] = draw.MathHelper.fourNumber(padding);
+                const old = canvas, { width, height } = old;
+                canvas = draw.Creator.canvas({ width: width + left + right, height: height + top + bottom, pixelRatio });
+                canvas.copyWorld(old, old.bounds, { x: left, y: top, width, height });
             }
+            if (needFill)
+                canvas.fillWorld(canvas.bounds, fill || '#FFFFFF', 'destination-over');
+            if (onCanvas)
+                onCanvas(canvas);
+            const data = filename === 'canvas' ? canvas : canvas.export(filename, options);
+            result = { data, width: canvas.pixelWidth, height: canvas.pixelHeight, renderBounds, trimBounds };
+        }
+        this.running = false;
+        return result;
+    },
+    export(leaf, filename, options) {
+        this.running = true;
+        return addTask((success) => new Promise((resolve) => {
+            const getResult = () => __awaiter(this, void 0, void 0, function* () {
+                if (!draw.Resource.isComplete)
+                    return draw.Platform.requestRender(getResult);
+                const result = ExportModule.syncExport(leaf, filename, options);
+                if (result.data instanceof Promise)
+                    result.data = yield result.data;
+                success(result);
+                resolve();
+            });
+            leaf.updateLayout();
+            checkLazy(leaf);
+            const { leafer } = leaf;
+            if (leafer)
+                leafer.waitViewCompleted(getResult);
+            else
+                getResult();
         }));
     }
 };
@@ -2531,6 +2542,9 @@ Object.assign(draw.Export, ExportModule);
 draw.UI.prototype.export = function (filename, options) {
     return draw.Export.export(this, filename, options);
 };
+draw.UI.prototype.syncExport = function (filename, options) {
+    return draw.Export.syncExport(this, filename, options);
+};
 
 Object.assign(core.Creator, {
     interaction: (target, canvas, selector, options) => { return new core$1.InteractionBase(target, canvas, selector, options); },