@next2d/renderer 2.0.0

package/src/TextField/usecase/TextFieldDrawOffscreenCanvasUseCase.js

@@ -0,0 +1,272 @@
+import { execute as textFiledGetAlignOffsetService } from "../service/TextFiledGetAlignOffsetService";
+import { execute as textFieldGenerateFontStyleService } from "../service/TextFieldGenerateFontStyleService";
+import { $intToRGBA } from "../../RendererUtil";
+/**
+ * @description TextDataを元にOffscreenCanvasにテキストを描画
+ *              Draw text in OffscreenCanvas based on TextData
+ *
+ * @param  {ITextData} text_data
+ * @param  {object} text_setting
+ * @param  {number} x_scale
+ * @param  {number} y_scale
+ * @return {OffscreenCanvas}
+ * @method
+ * @protected
+ */
+export const execute = (text_data, text_setting, x_scale, y_scale) => {
+    const canvas = new OffscreenCanvas(text_setting.width, text_setting.height);
+    const context = canvas.getContext("2d");
+    if (!context) {
+        return canvas;
+    }
+    const lineWidth = Math.min(1, Math.max(x_scale, y_scale));
+    // border and background
+    if (text_setting.background || text_setting.border) {
+        context.beginPath();
+        context.moveTo(0, 0);
+        context.lineTo(text_setting.width, 0);
+        context.lineTo(text_setting.width, text_setting.height);
+        context.lineTo(0, text_setting.height);
+        context.lineTo(0, 0);
+        if (text_setting.background) {
+            const color = $intToRGBA(text_setting.backgroundColor);
+            context.fillStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+            context.fill();
+        }
+        if (text_setting.border) {
+            const color = $intToRGBA(text_setting.borderColor);
+            context.lineWidth = lineWidth;
+            context.strokeStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+            context.stroke();
+        }
+    }
+    if (!text_data) {
+        return canvas;
+    }
+    context.save();
+    context.beginPath();
+    context.moveTo(2, 2);
+    context.lineTo(text_setting.width - 2, 2);
+    context.lineTo(text_setting.width - 2, text_setting.height - 2);
+    context.lineTo(2, text_setting.height - 2);
+    context.lineTo(2, 2);
+    context.clip();
+    let tx = 2;
+    if (text_setting.scrollX > 0) {
+        const scaleX = (text_setting.textWidth + 4 - text_setting.rawWidth) / text_setting.rawWidth;
+        tx += -text_setting.scrollX * scaleX;
+    }
+    let ty = 2;
+    if (text_setting.scrollY > 0) {
+        const scaleY = (text_setting.textHeight + 2 - text_setting.rawHeight) / text_setting.rawHeight;
+        ty += -text_setting.scrollY * scaleY;
+    }
+    context.setTransform(x_scale, 0, 0, y_scale, tx * x_scale, ty * y_scale);
+    context.beginPath();
+    if (text_setting.selectIndex > -1
+        && text_setting.focusIndex > -1) {
+        const range = text_data.textTable.length - 1;
+        let minIndex = 0;
+        let maxIndex = 0;
+        if (text_setting.focusIndex <= text_setting.selectIndex) {
+            minIndex = Math.min(text_setting.focusIndex, range);
+            maxIndex = Math.min(text_setting.selectIndex, range);
+        }
+        else {
+            minIndex = Math.min(text_setting.selectIndex, range);
+            maxIndex = Math.min(text_setting.focusIndex - 1, range);
+        }
+        const textObject = text_data.textTable[minIndex];
+        const lineObject = text_data.lineTable[textObject.line];
+        const offsetAlign = textFiledGetAlignOffsetService(text_data, lineObject, text_setting);
+        let x = 0;
+        if (minIndex && textObject.mode === "text") {
+            let idx = minIndex;
+            while (idx) {
+                const textObject = text_data.textTable[--idx];
+                if (textObject.mode !== "text") {
+                    break;
+                }
+                x += textObject.w;
+            }
+        }
+        context.fillStyle = "#b4d7ff";
+        let w = 0;
+        for (let idx = minIndex; idx <= maxIndex; ++idx) {
+            const textObject = text_data.textTable[idx];
+            if (textObject.mode === "text") {
+                w += textObject.w;
+                if (idx !== maxIndex) {
+                    continue;
+                }
+            }
+            let y = 0;
+            const line = textObject.mode === "text"
+                ? textObject.line
+                : textObject.line - 1;
+            for (let idx = 0; idx < line; ++idx) {
+                y += text_data.heightTable[idx];
+            }
+            context.beginPath();
+            context.rect(x, y, w + offsetAlign, text_data.heightTable[line]);
+            context.fill();
+            x = 0;
+            w = 0;
+        }
+    }
+    const rawWidth = text_setting.rawWidth;
+    let scrollX = 0;
+    if (text_setting.scrollX > 0) {
+        const scaleX = (text_setting.textWidth - rawWidth) / rawWidth;
+        scrollX = text_setting.scrollX * scaleX;
+    }
+    const limitWidth = rawWidth + scrollX;
+    const rawHeight = text_setting.rawHeight;
+    let scrollY = 0;
+    if (text_setting.scrollY > 0) {
+        const scaleY = (text_setting.textHeight - rawHeight) / rawHeight;
+        scrollY = text_setting.scrollY * scaleY;
+    }
+    const limitHeight = rawHeight + scrollY;
+    // setup
+    let offsetWidth = 0;
+    let offsetHeight = 0;
+    let offsetAlign = 0;
+    let verticalAlign = 0;
+    let skip = false;
+    let currentIndex = -1;
+    for (let idx = 0; idx < text_data.textTable.length; ++idx) {
+        const textObject = text_data.textTable[idx];
+        if (!textObject) {
+            continue;
+        }
+        if (textObject.mode === "text" || textObject.mode === "break") {
+            currentIndex++;
+            if (text_setting.stopIndex > -1
+                && currentIndex > text_setting.stopIndex) {
+                break;
+            }
+        }
+        if (skip && textObject.mode === "text") {
+            continue;
+        }
+        const textFormat = textObject.textFormat;
+        // check
+        if (text_setting.autoSize === "none") {
+            if (offsetHeight > limitHeight) {
+                break;
+            }
+            if (textObject.mode === "text") {
+                if (scrollX > offsetWidth + textObject.w
+                    || offsetWidth > limitWidth) {
+                    offsetWidth += textObject.w;
+                    continue;
+                }
+            }
+        }
+        // color setting
+        const color = $intToRGBA(textFormat.color || 0);
+        context.fillStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+        // focus line
+        if (text_setting.focusVisible
+            && text_setting.focusIndex === idx) {
+            const x = offsetWidth + offsetAlign + 0.1;
+            let line = textObject.line;
+            let h = textObject.y;
+            let y = text_data.ascentTable[line];
+            if (textObject.mode !== "text") {
+                h = textObject.mode === "break"
+                    ? textObject.h
+                    : text_data.ascentTable[line - 1];
+                if (line > 0) {
+                    line = textObject.line - 1;
+                    y = text_data.ascentTable[line];
+                }
+                else {
+                    y = textObject.h;
+                }
+            }
+            if (line > 0 && text_data.ascentTable[line] === 0) {
+                line++;
+            }
+            for (let idx = 0; idx < line; ++idx) {
+                y += text_data.heightTable[idx];
+            }
+            context.strokeStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+            context.beginPath();
+            context.moveTo(x, y);
+            context.lineTo(x, y - h);
+            context.stroke();
+        }
+        if (text_setting.thickness) {
+            const color = $intToRGBA(text_setting.thicknessColor);
+            context.lineWidth = text_setting.thickness;
+            context.strokeStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+        }
+        const line = textObject.line | 0;
+        switch (textObject.mode) {
+            case "break":
+            case "wrap":
+                // reset width
+                offsetWidth = 0;
+                if (line) {
+                    offsetHeight += text_data.heightTable[line - 1];
+                }
+                if (scrollY > offsetHeight + text_data.heightTable[line]) {
+                    skip = true;
+                    continue;
+                }
+                verticalAlign = text_data.ascentTable[line];
+                offsetAlign = textFiledGetAlignOffsetService(text_data, textObject, text_setting);
+                skip = false;
+                break;
+            case "text":
+                {
+                    context.beginPath();
+                    context.font = textFieldGenerateFontStyleService(textFormat);
+                    const x = offsetWidth + offsetAlign;
+                    const y = offsetHeight + verticalAlign;
+                    if (textFormat.underline) {
+                        const color = $intToRGBA(textFormat.color || 0);
+                        context.lineWidth = lineWidth;
+                        context.strokeStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+                        context.beginPath();
+                        context.moveTo(x, y + 2);
+                        context.lineTo(x + textObject.w, y + 2);
+                        context.stroke();
+                    }
+                    if (text_setting.thickness) {
+                        context.strokeText(textObject.text, x, y);
+                    }
+                    context.fillText(textObject.text, x, y);
+                    offsetWidth += textObject.w;
+                }
+                break;
+            case "image":
+                break;
+            default:
+                break;
+        }
+    }
+    if (text_setting.focusVisible
+        && text_setting.focusIndex >= text_data.textTable.length) {
+        const textObject = text_data.textTable[text_setting.focusIndex - 1];
+        if (textObject) {
+            const color = $intToRGBA(textObject.textFormat.color || 0);
+            context.strokeStyle = `rgba(${color.R},${color.G},${color.B},${color.A})`;
+            const x = offsetWidth + offsetAlign + 0.1;
+            const y = offsetHeight + verticalAlign;
+            context.beginPath();
+            if (textObject.mode === "text") {
+                context.moveTo(x, y - textObject.y);
+            }
+            else {
+                context.moveTo(x, y + textObject.h);
+            }
+            context.lineTo(x, y);
+            context.stroke();
+        }
+    }
+    context.restore();
+    return canvas;
+};

package/src/TextField/usecase/TextFieldRenderUseCase.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @description TextFieldの描画を実行します。
+ *              Execute the drawing of TextField.
+ *
+ * @param  {Float32Array} render_queue
+ * @param  {number} index
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: (render_queue: Float32Array, index: number) => number;

package/src/TextField/usecase/TextFieldRenderUseCase.js

@@ -0,0 +1,150 @@
+import { $cacheStore } from "@next2d/cache";
+import { execute as displayObjectGetBlendModeService } from "../../DisplayObject/service/DisplayObjectGetBlendModeService";
+import { execute as textFieldDrawOffscreenCanvasUseCase } from "./TextFieldDrawOffscreenCanvasUseCase";
+import { $context } from "../../RendererUtil";
+/**
+ * @type {TextDecoder}
+ * @private
+ */
+const $textDecoder = new TextDecoder();
+/**
+ * @description TextFieldの描画を実行します。
+ *              Execute the drawing of TextField.
+ *
+ * @param  {Float32Array} render_queue
+ * @param  {number} index
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (render_queue, index) => {
+    const matrix = render_queue.subarray(index, index + 6);
+    index += 6;
+    const colorTransform = render_queue.subarray(index, index + 8);
+    index += 8;
+    const bounds = render_queue.subarray(index, index + 4);
+    index += 4;
+    // baseBounds
+    const xMin = render_queue[index++];
+    const yMin = render_queue[index++];
+    const xMax = render_queue[index++];
+    const yMax = render_queue[index++];
+    // cache uniqueKey
+    const uniqueKey = `${render_queue[index++]}`;
+    const cacheKey = render_queue[index++];
+    // text state
+    const changed = Boolean(render_queue[index++]);
+    const xScale = Math.round(Math.sqrt(matrix[0] * matrix[0]
+        + matrix[1] * matrix[1]) * 10000) / 10000;
+    const yScale = Math.round(Math.sqrt(matrix[2] * matrix[2]
+        + matrix[3] * matrix[3]) * 10000) / 10000;
+    let node;
+    const hasCache = render_queue[index++];
+    if (!hasCache) {
+        const width = Math.ceil(Math.abs(xMax - xMin) * xScale);
+        const height = Math.ceil(Math.abs(yMax - yMin) * yScale);
+        const hasNode = Boolean(render_queue[index++]);
+        node = hasNode
+            ? $cacheStore.get(uniqueKey, `${cacheKey}`)
+            : $context.createNode(width, height);
+        if (!hasNode) {
+            $cacheStore.set(uniqueKey, `${cacheKey}`, node);
+        }
+        const length = render_queue[index++];
+        const buffer = new Uint8Array(render_queue.subarray(index, index + length));
+        index += length;
+        let autoSize = "none";
+        switch (render_queue[index++]) {
+            case 0:
+                autoSize = "center";
+                break;
+            case 1:
+                autoSize = "left";
+                break;
+            case 2:
+                autoSize = "none";
+                break;
+            case 3:
+                autoSize = "right";
+                break;
+        }
+        const textSetting = {
+            "width": width,
+            "height": height,
+            "autoSize": autoSize,
+            "stopIndex": render_queue[index++],
+            "scrollX": render_queue[index++],
+            "scrollY": render_queue[index++],
+            "textWidth": render_queue[index++],
+            "textHeight": render_queue[index++],
+            "rawWidth": render_queue[index++],
+            "rawHeight": render_queue[index++],
+            "focusIndex": render_queue[index++],
+            "selectIndex": render_queue[index++],
+            "focusVisible": Boolean(render_queue[index++]),
+            "thickness": render_queue[index++],
+            "thicknessColor": render_queue[index++],
+            "wordWrap": Boolean(render_queue[index++]),
+            "border": Boolean(render_queue[index++]),
+            "borderColor": render_queue[index++],
+            "background": Boolean(render_queue[index++]),
+            "backgroundColor": render_queue[index++],
+            "defaultColor": render_queue[index++],
+            "defaultSize": render_queue[index++]
+        };
+        const canvas = textFieldDrawOffscreenCanvasUseCase(JSON.parse($textDecoder.decode(buffer)), textSetting, xScale, yScale);
+        // fixed logic
+        const currentAttachment = $context.currentAttachmentObject;
+        $context.bind($context.atlasAttachmentObject);
+        $context.reset();
+        $context.beginNodeRendering(node);
+        const offsetY = $context.atlasAttachmentObject.height - node.y - height;
+        $context.setTransform(1, 0, 0, 1, node.x, offsetY);
+        $context.drawElement(node, canvas);
+        $context.endNodeRendering();
+        if (currentAttachment) {
+            $context.bind(currentAttachment);
+        }
+    }
+    else {
+        node = $cacheStore.get(uniqueKey, `${cacheKey}`);
+        if (!node) {
+            return index;
+        }
+    }
+    const blendMode = render_queue[index++];
+    // フィルター設定があればフィルターを実行
+    const useFilfer = Boolean(render_queue[index++]);
+    if (useFilfer) {
+        const updated = Boolean(render_queue[index++]);
+        const filterBounds = render_queue.subarray(index, index + 4);
+        index += 4;
+        const length = render_queue[index++];
+        const params = render_queue.subarray(index, index + length);
+        const width = Math.ceil(Math.abs(bounds[2] - bounds[0]));
+        const height = Math.ceil(Math.abs(bounds[3] - bounds[1]));
+        $context.applyFilter(node, uniqueKey, Boolean(Math.max(+changed, +updated)), width, height, false, matrix, colorTransform, displayObjectGetBlendModeService(blendMode), filterBounds, params);
+        index += length;
+        return index;
+    }
+    $context.globalAlpha = Math.min(Math.max(0, colorTransform[3] + colorTransform[7] / 255), 1);
+    $context.imageSmoothingEnabled = true;
+    $context.globalCompositeOperation = displayObjectGetBlendModeService(blendMode);
+    const radianX = Math.atan2(matrix[1], matrix[0]);
+    const radianY = Math.atan2(-matrix[2], matrix[3]);
+    if (radianX || radianY) {
+        const tx = xMin * xScale;
+        const ty = yMin * yScale;
+        const cosX = Math.cos(radianX);
+        const sinX = Math.sin(radianX);
+        const cosY = Math.cos(radianY);
+        const sinY = Math.sin(radianY);
+        $context.setTransform(cosX, sinX, -sinY, cosY, tx * cosX - ty * sinY + matrix[4], tx * sinX + ty * cosY + matrix[5]);
+    }
+    else {
+        $context.setTransform(1, 0, 0, 1, bounds[0], bounds[1]);
+    }
+    // 描画範囲をinstanced arrayに設定
+    $context.drawDisplayObject(node, bounds[0], bounds[1], bounds[2], bounds[3], colorTransform);
+    return index;
+};

package/src/Video/usecase/VideoRenderUseCase.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @description Videoの描画を実行します。
+ *              Execute the drawing of Video.
+ *
+ * @param  {Float32Array} render_queue
+ * @param  {number} index
+ * @param  {ImageBitmap[]} image_bitmaps
+ * @return {number}
+ * @method
+ * @protected
+ */
+export declare const execute: (render_queue: Float32Array, index: number, image_bitmaps: ImageBitmap[] | null) => number;

package/src/Video/usecase/VideoRenderUseCase.js

@@ -0,0 +1,88 @@
+import { $cacheStore } from "@next2d/cache";
+import { $context } from "../../RendererUtil";
+import { execute as displayObjectGetBlendModeService } from "../../DisplayObject/service/DisplayObjectGetBlendModeService";
+/**
+ * @description Videoの描画を実行します。
+ *              Execute the drawing of Video.
+ *
+ * @param  {Float32Array} render_queue
+ * @param  {number} index
+ * @param  {ImageBitmap[]} image_bitmaps
+ * @return {number}
+ * @method
+ * @protected
+ */
+export const execute = (render_queue, index, image_bitmaps) => {
+    const matrix = render_queue.subarray(index, index + 6);
+    index += 6;
+    const colorTransform = render_queue.subarray(index, index + 8);
+    index += 8;
+    const bounds = render_queue.subarray(index, index + 4);
+    index += 4;
+    // baseBounds
+    const xMin = render_queue[index++];
+    const yMin = render_queue[index++];
+    const xMax = render_queue[index++];
+    const yMax = render_queue[index++];
+    // cache uniqueKey
+    const uniqueKey = `${render_queue[index++]}`;
+    const cacheKey = "0";
+    // video state
+    const changed = Boolean(render_queue[index++]);
+    let node;
+    const hasCache = render_queue[index++];
+    if (!hasCache) {
+        const width = Math.abs(xMax - xMin);
+        const height = Math.abs(yMax - yMin);
+        const hasNode = Boolean(render_queue[index++]);
+        node = hasNode
+            ? $cacheStore.get(uniqueKey, `${cacheKey}`)
+            : $context.createNode(width, height);
+        if (!hasNode) {
+            $cacheStore.set(uniqueKey, `${cacheKey}`, node);
+        }
+        if (image_bitmaps && image_bitmaps.length) {
+            // fixed logic
+            const currentAttachment = $context.currentAttachmentObject;
+            $context.bind($context.atlasAttachmentObject);
+            $context.reset();
+            $context.beginNodeRendering(node);
+            const offsetY = $context.atlasAttachmentObject.height - node.y - height;
+            $context.setTransform(1, 0, 0, 1, node.x, offsetY);
+            const imageBitmap = image_bitmaps.shift();
+            $context.drawElement(node, imageBitmap);
+            $context.endNodeRendering();
+            if (currentAttachment) {
+                $context.bind(currentAttachment);
+            }
+        }
+    }
+    else {
+        node = $cacheStore.get(uniqueKey, `${cacheKey}`);
+        if (!node) {
+            return index;
+        }
+    }
+    const blendMode = render_queue[index++];
+    // フィルター設定があればフィルターを実行
+    const useFilfer = Boolean(render_queue[index++]);
+    if (useFilfer) {
+        const updated = Boolean(render_queue[index++]);
+        const filterBounds = render_queue.subarray(index, index + 4);
+        index += 4;
+        const length = render_queue[index++];
+        const params = render_queue.subarray(index, index + length);
+        const width = Math.ceil(Math.abs(bounds[2] - bounds[0]));
+        const height = Math.ceil(Math.abs(bounds[3] - bounds[1]));
+        $context.applyFilter(node, uniqueKey, Boolean(Math.max(+changed, +updated)), width, height, true, matrix, colorTransform, displayObjectGetBlendModeService(blendMode), filterBounds, params);
+        index += length;
+        return index;
+    }
+    $context.globalAlpha = Math.min(Math.max(0, colorTransform[3] + colorTransform[7] / 255), 1);
+    $context.imageSmoothingEnabled = true;
+    $context.globalCompositeOperation = displayObjectGetBlendModeService(blendMode);
+    $context.setTransform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
+    // 描画範囲をinstanced arrayに設定
+    $context.drawDisplayObject(node, bounds[0], bounds[1], bounds[2], bounds[3], colorTransform);
+    return index;
+};

package/src/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/src/index.js

@@ -0,0 +1,26 @@
+"use strict";
+import { CommandController } from "./CommandController";
+/**
+ * @description CommandControllerのインスタンス
+ *              Instance of CommandController
+ *
+ * @type {CommandController}
+ * @public
+ */
+const command = new CommandController();
+/**
+ * @description OffscreenCanvasのメッセージイベント
+ *              OffscreenCanvas message event
+ *
+ * @params {MessageEvent} event
+ * @return {Promise<void>}
+ * @method
+ * @public
+ */
+self.addEventListener("message", async (event) => {
+    command.queue.push(event.data);
+    if (command.state === "deactivate") {
+        await command.execute();
+    }
+});
+export default {};

package/src/interface/IBlendMode.d.ts

@@ -0,0 +1 @@
+export type IBlendMode = "copy" | "add" | "alpha" | "darken" | "difference" | "erase" | "hardlight" | "invert" | "layer" | "lighten" | "multiply" | "normal" | "overlay" | "screen" | "subtract";

package/src/interface/IBlendMode.js

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

package/src/interface/IMessage.d.ts

@@ -0,0 +1,11 @@
+export interface IMessage {
+    command: string;
+    buffer: Float32Array;
+    width?: number;
+    height?: number;
+    length?: number;
+    imageBitmaps?: ImageBitmap[] | null;
+    canvas?: OffscreenCanvas;
+    devicePixelRatio?: number;
+    id?: string;
+}

package/src/interface/IMessage.js

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

package/src/interface/INode.d.ts

@@ -0,0 +1,7 @@
+export interface INode {
+    index: number;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}

package/src/interface/INode.js

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

package/src/interface/IRGBA.d.ts

@@ -0,0 +1,6 @@
+export interface IRGBA {
+    A: number;
+    R: number;
+    G: number;
+    B: number;
+}

package/src/interface/IRGBA.js

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

package/src/interface/ITextData.d.ts

@@ -0,0 +1,8 @@
+import type { ITextObject } from "./ITextObject";
+export interface ITextData {
+    ascentTable: number[];
+    heightTable: number[];
+    lineTable: ITextObject[];
+    textTable: ITextObject[];
+    widthTable: number[];
+}

package/src/interface/ITextData.js

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

package/src/interface/ITextFieldAutoSize.d.ts

@@ -0,0 +1 @@
+export type ITextFieldAutoSize = "center" | "left" | "none" | "right";

package/src/interface/ITextFieldAutoSize.js

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

package/src/interface/ITextFormat.d.ts

@@ -0,0 +1,14 @@
+import type { ITextFormatAlign } from "./ITextFormatAlign";
+export interface ITextFormat {
+    align: ITextFormatAlign | null;
+    bold: boolean | null;
+    color: number | null;
+    font: string | null;
+    italic: boolean | null;
+    leading: number | null;
+    leftMargin: number | null;
+    letterSpacing: number | null;
+    rightMargin: number | null;
+    size: number | null;
+    underline: boolean | null;
+}

package/src/interface/ITextFormat.js

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

package/src/interface/ITextFormatAlign.d.ts

@@ -0,0 +1 @@
+export type ITextFormatAlign = "center" | "left" | "right";

package/src/interface/ITextFormatAlign.js

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

package/src/interface/ITextObject.d.ts

@@ -0,0 +1,12 @@
+import type { ITextFormat } from "./ITextFormat";
+import type { ITextObjectMode } from "./ITextObjectMode";
+export interface ITextObject {
+    mode: ITextObjectMode;
+    text: string;
+    textFormat: ITextFormat;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    line: number;
+}

package/src/interface/ITextObject.js

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

package/src/interface/ITextObjectMode.d.ts

@@ -0,0 +1 @@
+export type ITextObjectMode = "break" | "wrap" | "image" | "text";