goatdee-canvas 0.0.76 → 0.0.78

package/dist/bind/binding.d.ts

@@ -0,0 +1,2 @@
+import { TGFX } from './types';
+export declare const TGFXBind: (module: TGFX) => void;

package/dist/bind/constant.d.ts

@@ -0,0 +1 @@
+export declare const CANVAS_POOL_MAX_SIZE = 10;

package/dist/bind/core/bitmap-image.d.ts

@@ -0,0 +1,5 @@
+export declare class BitmapImage {
+    bitmap: ImageBitmap | null;
+    constructor(bitmap: ImageBitmap | null);
+    setBitmap(bitmap: ImageBitmap): void;
+}

package/dist/bind/core/matrix.d.ts

@@ -0,0 +1,45 @@
+import { MatrixIndex } from '../types';
+export declare class Matrix {
+    wasmIns: any;
+    isDestroyed: boolean;
+    constructor(wasmIns: any);
+    /**
+     * scaleX; horizontal scale factor to store
+     */
+    get a(): number;
+    set a(value: number);
+    /**
+     * skewY; vertical skew factor to store
+     */
+    get b(): number;
+    set b(value: number);
+    /**
+     * skewX; horizontal skew factor to store
+     */
+    get c(): number;
+    set c(value: number);
+    /**
+     * scaleY; vertical scale factor to store
+     */
+    get d(): number;
+    set d(value: number);
+    /**
+     * transX; horizontal translation to store
+     */
+    get tx(): number;
+    set tx(value: number);
+    /**
+     * transY; vertical translation to store
+     */
+    get ty(): number;
+    set ty(value: number);
+    /**
+     * Returns one matrix value.
+     */
+    get(index: MatrixIndex): number;
+    /**
+     * Sets Matrix value.
+     */
+    set(index: MatrixIndex, value: number): void;
+    destroy(): void;
+}

package/dist/bind/core/scaler-context.d.ts

@@ -0,0 +1,29 @@
+import type { Rect } from '../types';
+export declare class ScalerContext {
+    static canvas: HTMLCanvasElement | OffscreenCanvas;
+    static context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D;
+    private static hasMeasureBoundsAPI;
+    static setCanvas(canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    static setContext(context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
+    static isUnicodePropertyEscapeSupported(): boolean;
+    static isEmoji(text: string): boolean;
+    private static measureDirectly;
+    private readonly fontName;
+    private readonly fontStyle;
+    private readonly size;
+    private fontMetrics;
+    private fontBoundingBoxMap;
+    constructor(fontName: string, fontStyle: string, size: number);
+    fontString(fauxBold: boolean, fauxItalic: boolean): string;
+    getFontMetrics(): {
+        ascent: number;
+        descent: number;
+        xHeight: number;
+        capHeight: number;
+    };
+    getBounds(text: string, fauxBold: boolean, fauxItalic: boolean): Rect;
+    getAdvance(text: string): number;
+    generateImage(text: string, bounds: Rect): HTMLCanvasElement | OffscreenCanvas;
+    protected loadCanvas(): void;
+    private measureText;
+}

package/dist/bind/core/web-mask.d.ts

@@ -0,0 +1,26 @@
+import { ctor, Point, Vector } from '../types';
+export interface WebFont {
+    name: string;
+    style: string;
+    size: number;
+    bold: boolean;
+    italic: boolean;
+}
+export declare class WebMask {
+    static create(canvas: HTMLCanvasElement | OffscreenCanvas): WebMask;
+    private static getLineCap;
+    private static getLineJoin;
+    protected canvas: HTMLCanvasElement | OffscreenCanvas;
+    private context;
+    constructor(canvas: HTMLCanvasElement | OffscreenCanvas);
+    updateCanvas(canvas: HTMLCanvasElement | OffscreenCanvas): void;
+    fillPath(path: Path2D, fillType: ctor): void;
+    fillText(webFont: WebFont, texts: Vector<string>, positions: Vector<Point>, matrixWasmIns: any): void;
+    strokeText(webFont: WebFont, stroke: {
+        width: number;
+        cap: ctor;
+        join: ctor;
+        miterLimit: number;
+    }, texts: Vector<string>, positions: Vector<Point>, matrixWasmIns: any): void;
+    clear(): void;
+}

package/dist/bind/tgfx-module.d.ts

@@ -0,0 +1,4 @@
+import type { TGFX } from './types';
+export declare let TGFXModule: TGFX;
+export declare const setTGFXModule: (module: TGFX) => void;
+export declare const getTGFXModule: () => TGFX;

package/dist/bind/tgfx.d.ts

@@ -0,0 +1,15 @@
+import { getCanvas2D } from './utils/canvas';
+import { BitmapImage } from './core/bitmap-image';
+import type { EmscriptenGL, TGFX } from './types';
+export declare const createImage: (source: string) => Promise<HTMLImageElement | null>;
+export declare const createImageFromBytes: (bytes: ArrayBuffer) => Promise<HTMLImageElement | null>;
+export declare const readImagePixels: (module: TGFX, image: CanvasImageSource, width: number, height: number) => Uint8Array<ArrayBuffer> | null;
+export declare const hasWebpSupport: () => boolean;
+export declare const getSourceSize: (source: TexImageSource | OffscreenCanvas) => {
+    width: number;
+    height: number;
+};
+export declare const uploadToTexture: (GL: EmscriptenGL, source: TexImageSource | OffscreenCanvas | BitmapImage, textureID: number, alphaOnly: boolean) => void;
+export declare const releaseNativeImage: (source: TexImageSource | OffscreenCanvas) => void;
+export declare const getBytesFromPath: (module: TGFX, path: string) => Promise<Uint8Array<ArrayBuffer>>;
+export { getCanvas2D as createCanvas2D };

package/dist/bind/types.d.ts

@@ -0,0 +1,133 @@
+export declare class Vector<T> {
+    private constructor();
+    /**
+     * Get item from Vector by index.
+     */
+    get(index: number): T;
+    /**
+     * Push item into Vector.
+     */
+    push_back(value: T): void;
+    /**
+     * Get item number in Vector.
+     */
+    size(): number;
+    /**
+     * Delete Vector instance.
+     */
+    delete(): void;
+}
+export declare const enum MatrixIndex {
+    a = 0,
+    c = 1,
+    tx = 2,
+    b = 3,
+    d = 4,
+    ty = 5
+}
+export interface ctor {
+    value: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Rect {
+    /**
+     * smaller x-axis bounds.
+     */
+    left: number;
+    /**
+     * smaller y-axis bounds.
+     */
+    top: number;
+    /**
+     * larger x-axis bounds.
+     */
+    right: number;
+    /**
+     * larger y-axis bounds.
+     */
+    bottom: number;
+}
+export interface TGFXLineCap {
+    /**
+     * No stroke extension.
+     */
+    Butt: ctor;
+    /**
+     * Adds circle
+     */
+    Round: ctor;
+    /**
+     * Adds square
+     */
+    Square: ctor;
+}
+export interface TGFXLineJoin {
+    /**
+     * Extends to miter limit.
+     */
+    Miter: ctor;
+    /**
+     * Adds circle.
+     */
+    Round: ctor;
+    /**
+     * Connects outside edges.
+     */
+    Bevel: ctor;
+}
+export interface TGFXPathFillType {
+    /**
+     * Enclosed by a non-zero sum of contour directions.
+     */
+    Winding: ctor;
+    /**
+     * Enclosed by an odd number of contours.
+     */
+    EvenOdd: ctor;
+    /**
+     * Enclosed by a zero sum of contour directions.
+     */
+    InverseWinding: ctor;
+    /**
+     * Enclosed by an even number of contours.
+     */
+    InverseEvenOdd: ctor;
+}
+export interface EmscriptenGLContext {
+    handle: number;
+    GLctx: WebGLRenderingContext;
+    attributes: EmscriptenGLContextAttributes;
+    initExtensionsDone: boolean;
+    version: number;
+}
+export type EmscriptenGLContextAttributes = {
+    majorVersion: number;
+    minorVersion: number;
+} & WebGLContextAttributes;
+export interface EmscriptenGL {
+    contexts: (EmscriptenGLContext | null)[];
+    createContext: (canvas: HTMLCanvasElement | OffscreenCanvas, webGLContextAttributes: EmscriptenGLContextAttributes) => number;
+    currentContext?: EmscriptenGLContext;
+    deleteContext: (contextHandle: number) => void;
+    framebuffers: (WebGLFramebuffer | null)[];
+    getContext: (contextHandle: number) => EmscriptenGLContext;
+    getNewId: (array: any[]) => number;
+    makeContextCurrent: (contextHandle: number) => boolean;
+    registerContext: (ctx: WebGLRenderingContext, webGLContextAttributes: EmscriptenGLContextAttributes) => number;
+    textures: (WebGLTexture | null)[];
+}
+export interface TGFX {
+    TGFXLineCap: TGFXLineCap;
+    TGFXLineJoin: TGFXLineJoin;
+    GL: EmscriptenGL;
+    TGFXPathFillType: TGFXPathFillType;
+    _Matrix: {
+        _MakeAll: (scaleX: number, skewX: number, transX: number, skewY: number, scaleY: number, transY: number, pers0: number, pers1: number, pers2: number) => any;
+        _MakeScale: ((sx: number, sy: number) => any) & ((scale: number) => any);
+        _MakeTrans: (dx: number, dy: number) => any;
+    };
+    [key: string]: any;
+}

package/dist/bind/utils/canvas.d.ts

@@ -0,0 +1,8 @@
+export declare const isOffscreenCanvas: (element: any) => boolean;
+export declare const isCanvas: (element: any) => boolean;
+export declare const getCanvas2D: (width: number, height: number) => HTMLCanvasElement | OffscreenCanvas;
+export declare const releaseCanvas2D: (canvas: HTMLCanvasElement | OffscreenCanvas) => void;
+export declare const calculateDisplaySize: (canvas: HTMLCanvasElement) => {
+    width: number;
+    height: number;
+};

package/dist/bind/utils/decorators.d.ts

@@ -0,0 +1,3 @@
+export declare function wasmAwaitRewind(constructor: any): void;
+export declare function wasmAsyncMethod(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+export declare function destroyVerify(constructor: any): void;

package/dist/bind/utils/font-family.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultFontNames: string[];
+export declare const getFontFamilies: (name: string, style?: string) => string[];

package/dist/bind/utils/measure-text.d.ts

@@ -0,0 +1,10 @@
+export declare const measureText: (imageData: ImageData) => {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export declare const getLeftPixel: (imageDataArray: Int32Array, width: number, height: number) => number;
+export declare const getTopPixel: (imageDataArray: Int32Array, width: number, height: number) => number;
+export declare const getRightPixel: (imageDataArray: Int32Array, width: number, height: number) => number;
+export declare const getBottomPixel: (imageDataArray: Int32Array, width: number, height: number) => number;

package/dist/bind/utils/type-utils.d.ts

@@ -0,0 +1 @@
+export declare const isInstanceOf: (value: any, type: any) => boolean;

package/dist/bind/utils/ua.d.ts

@@ -0,0 +1,7 @@
+export declare const ANDROID: boolean;
+export declare const MOBILE: boolean;
+export declare const MACOS: boolean;
+export declare const IPHONE: boolean;
+export declare const WECHAT: boolean;
+export declare const SAFARI_OR_IOS_WEBVIEW: boolean;
+export declare const WORKER: boolean;