454 lines
14 KiB
TypeScript
454 lines
14 KiB
TypeScript
// Clear all type of caches in Skia
|
|
export function clearAllCache(): void
|
|
|
|
export interface DOMMatrix2DInit {
|
|
a: number
|
|
b: number
|
|
c: number
|
|
d: number
|
|
e: number
|
|
f: number
|
|
}
|
|
|
|
interface DOMMatrixReadOnly {
|
|
readonly a: number
|
|
readonly b: number
|
|
readonly c: number
|
|
readonly d: number
|
|
readonly e: number
|
|
readonly f: number
|
|
readonly is2D: boolean
|
|
readonly isIdentity: boolean
|
|
readonly m11: number
|
|
readonly m12: number
|
|
readonly m13: number
|
|
readonly m14: number
|
|
readonly m21: number
|
|
readonly m22: number
|
|
readonly m23: number
|
|
readonly m24: number
|
|
readonly m31: number
|
|
readonly m32: number
|
|
readonly m33: number
|
|
readonly m34: number
|
|
readonly m41: number
|
|
readonly m42: number
|
|
readonly m43: number
|
|
readonly m44: number
|
|
flipX(): DOMMatrix
|
|
flipY(): DOMMatrix
|
|
inverse(): DOMMatrix
|
|
multiply(other?: DOMMatrixInit): DOMMatrix
|
|
rotate(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix
|
|
rotateAxisAngle(x?: number, y?: number, z?: number, angle?: number): DOMMatrix
|
|
rotateFromVector(x?: number, y?: number): DOMMatrix
|
|
scale(
|
|
scaleX?: number,
|
|
scaleY?: number,
|
|
scaleZ?: number,
|
|
originX?: number,
|
|
originY?: number,
|
|
originZ?: number,
|
|
): DOMMatrix
|
|
scale3d(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
|
|
skewX(sx?: number): DOMMatrix
|
|
skewY(sy?: number): DOMMatrix
|
|
toFloat32Array(): Float32Array
|
|
toFloat64Array(): Float64Array
|
|
transformPoint(point?: DOMPointInit): DOMPoint
|
|
translate(tx?: number, ty?: number, tz?: number): DOMMatrix
|
|
toString(): string
|
|
}
|
|
|
|
export interface DOMMatrix extends DOMMatrixReadOnly {
|
|
a: number
|
|
b: number
|
|
c: number
|
|
d: number
|
|
e: number
|
|
f: number
|
|
m11: number
|
|
m12: number
|
|
m13: number
|
|
m14: number
|
|
m21: number
|
|
m22: number
|
|
m23: number
|
|
m24: number
|
|
m31: number
|
|
m32: number
|
|
m33: number
|
|
m34: number
|
|
m41: number
|
|
m42: number
|
|
m43: number
|
|
m44: number
|
|
invertSelf(): DOMMatrix
|
|
multiplySelf(other?: DOMMatrixInit): DOMMatrix
|
|
preMultiplySelf(other?: DOMMatrixInit): DOMMatrix
|
|
rotateAxisAngleSelf(x?: number, y?: number, z?: number, angle?: number): DOMMatrix
|
|
rotateFromVectorSelf(x?: number, y?: number): DOMMatrix
|
|
rotateSelf(rotX?: number, rotY?: number, rotZ?: number): DOMMatrix
|
|
scale3dSelf(scale?: number, originX?: number, originY?: number, originZ?: number): DOMMatrix
|
|
scaleSelf(
|
|
scaleX?: number,
|
|
scaleY?: number,
|
|
scaleZ?: number,
|
|
originX?: number,
|
|
originY?: number,
|
|
originZ?: number,
|
|
): DOMMatrix
|
|
setMatrixValue(transformList: string): DOMMatrix
|
|
skewXSelf(sx?: number): DOMMatrix
|
|
skewYSelf(sy?: number): DOMMatrix
|
|
translateSelf(tx?: number, ty?: number, tz?: number): DOMMatrix
|
|
toJSON(): { [K in OmitNeverOfMatrix]: DOMMatrix[K] }
|
|
}
|
|
|
|
type OmitMatrixMethod = {
|
|
[K in keyof DOMMatrix]: DOMMatrix[K] extends (...args: any[]) => any ? never : K
|
|
}
|
|
|
|
type OmitNeverOfMatrix = OmitMatrixMethod[keyof OmitMatrixMethod]
|
|
|
|
export const DOMMatrix: {
|
|
prototype: DOMMatrix
|
|
new (init?: string | number[]): DOMMatrix
|
|
fromFloat32Array(array32: Float32Array): DOMMatrix
|
|
fromFloat64Array(array64: Float64Array): DOMMatrix
|
|
fromMatrix(other?: DOMMatrixInit): DOMMatrix
|
|
}
|
|
|
|
interface DOMRectReadOnly {
|
|
readonly bottom: number
|
|
readonly height: number
|
|
readonly left: number
|
|
readonly right: number
|
|
readonly top: number
|
|
readonly width: number
|
|
readonly x: number
|
|
readonly y: number
|
|
}
|
|
|
|
export interface DOMRect extends DOMRectReadOnly {
|
|
height: number
|
|
width: number
|
|
x: number
|
|
y: number
|
|
toJSON(): Omit<this, 'toJSON' | 'fromRect'>
|
|
}
|
|
|
|
export const DOMRect: {
|
|
prototype: DOMRect
|
|
new (x?: number, y?: number, width?: number, height?: number): DOMRect
|
|
fromRect(other?: DOMRectInit): DOMRect
|
|
}
|
|
|
|
interface DOMPointReadOnly {
|
|
readonly w: number
|
|
readonly x: number
|
|
readonly y: number
|
|
readonly z: number
|
|
matrixTransform(matrix?: DOMMatrixInit): DOMPoint
|
|
}
|
|
|
|
export interface DOMPoint extends DOMPointReadOnly {
|
|
w: number
|
|
x: number
|
|
y: number
|
|
z: number
|
|
toJSON(): Omit<DOMPoint, 'matrixTransform' | 'toJSON'>
|
|
}
|
|
|
|
export const DOMPoint: {
|
|
prototype: DOMPoint
|
|
new (x?: number, y?: number, z?: number, w?: number): DOMPoint
|
|
fromPoint(other?: DOMPointInit): DOMPoint
|
|
}
|
|
|
|
export class ImageData {
|
|
/**
|
|
* Returns the one-dimensional array containing the data in RGBA order, as integers in the range 0 to 255.
|
|
*/
|
|
readonly data: Uint8ClampedArray
|
|
/**
|
|
* Returns the actual dimensions of the data in the ImageData object, in pixels.
|
|
*/
|
|
readonly height: number
|
|
/**
|
|
* Returns the actual dimensions of the data in the ImageData object, in pixels.
|
|
*/
|
|
readonly width: number
|
|
|
|
constructor(sw: number, sh: number, attr?: { colorSpace?: ColorSpace })
|
|
constructor(imageData: ImageData, attr?: { colorSpace?: ColorSpace })
|
|
constructor(data: Uint8ClampedArray, sw: number, sh?: number)
|
|
}
|
|
|
|
export class Image {
|
|
constructor()
|
|
// attrs only affects SVG
|
|
constructor(width: number, height: number, attrs?: { colorSpace?: ColorSpace })
|
|
width: number
|
|
height: number
|
|
readonly naturalWidth: number
|
|
readonly naturalHeight: number
|
|
readonly complete: boolean
|
|
alt: string
|
|
src: Buffer
|
|
}
|
|
|
|
export class Path2D {
|
|
constructor(path?: Path2D | string)
|
|
|
|
addPath(path: Path2D, transform?: DOMMatrix2DInit): void
|
|
arc(x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): void
|
|
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): void
|
|
bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void
|
|
closePath(): void
|
|
ellipse(
|
|
x: number,
|
|
y: number,
|
|
radiusX: number,
|
|
radiusY: number,
|
|
rotation: number,
|
|
startAngle: number,
|
|
endAngle: number,
|
|
anticlockwise?: boolean,
|
|
): void
|
|
lineTo(x: number, y: number): void
|
|
moveTo(x: number, y: number): void
|
|
quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void
|
|
rect(x: number, y: number, w: number, h: number): void
|
|
|
|
// PathKit methods
|
|
op(path: Path2D, operation: PathOp): Path2D
|
|
toSVGString(): string
|
|
getFillType(): FillType
|
|
getFillTypeString(): string
|
|
setFillType(type: FillType): void
|
|
simplify(): Path2D
|
|
asWinding(): Path2D
|
|
stroke(stroke?: StrokeOptions): Path2D
|
|
transform(transform: DOMMatrix2DInit): Path2D
|
|
getBounds(): [left: number, top: number, right: number, bottom: number]
|
|
computeTightBounds(): [left: number, top: number, right: number, bottom: number]
|
|
trim(start: number, end: number, isComplement?: boolean): Path2D
|
|
dash(on: number, off: number, phase: number): Path2D
|
|
equals(path: Path2D): boolean
|
|
}
|
|
|
|
export interface StrokeOptions {
|
|
width?: number
|
|
miterLimit?: number
|
|
cap?: StrokeCap
|
|
join?: StrokeJoin
|
|
}
|
|
|
|
export interface SKRSContext2D
|
|
extends Omit<
|
|
CanvasRenderingContext2D,
|
|
'drawImage' | 'createPattern' | 'getTransform' | 'drawFocusIfNeeded' | 'scrollPathIntoView'
|
|
> {
|
|
/**
|
|
* @param startAngle The angle at which to begin the gradient, in radians. Angle measurements start vertically above the centre and move around clockwise.
|
|
* @param x The x-axis coordinate of the centre of the gradient.
|
|
* @param y The y-axis coordinate of the centre of the gradient.
|
|
*/
|
|
createConicGradient(startAngle: number, x: number, y: number): CanvasGradient
|
|
drawImage(image: Image | Canvas, dx: number, dy: number): void
|
|
drawImage(image: Image | Canvas, dx: number, dy: number, dw: number, dh: number): void
|
|
drawImage(
|
|
image: Image | Canvas,
|
|
sx: number,
|
|
sy: number,
|
|
sw: number,
|
|
sh: number,
|
|
dx: number,
|
|
dy: number,
|
|
dw: number,
|
|
dh: number,
|
|
): void
|
|
createPattern(
|
|
image: Image | ImageData,
|
|
repeat: 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat' | null,
|
|
): CanvasPattern
|
|
getContextAttributes(): { alpha: boolean; desynchronized: boolean }
|
|
getTransform(): {
|
|
a: number
|
|
b: number
|
|
c: number
|
|
d: number
|
|
e: number
|
|
f: number
|
|
}
|
|
}
|
|
|
|
export type ColorSpace = 'srgb' | 'display-p3'
|
|
|
|
export interface ContextAttributes {
|
|
alpha?: boolean
|
|
colorSpace?: ColorSpace
|
|
}
|
|
|
|
export interface SvgCanvas {
|
|
width: number
|
|
height: number
|
|
getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D
|
|
|
|
getContent(): Buffer
|
|
}
|
|
|
|
export interface AvifConfig {
|
|
/** 0-100 scale, 100 is lossless */
|
|
quality?: number
|
|
/** 0-100 scale */
|
|
alphaQuality?: number
|
|
/** rav1e preset 1 (slow) 10 (fast but crappy), default is 4 */
|
|
speed?: number
|
|
/** How many threads should be used (0 = match core count) */
|
|
threads?: number
|
|
/** set to '4:2:0' to use chroma subsampling, default '4:4:4' */
|
|
chromaSubsampling?: ChromaSubsampling
|
|
}
|
|
/**
|
|
* https://en.wikipedia.org/wiki/Chroma_subsampling#Types_of_sampling_and_subsampling
|
|
* https://developer.mozilla.org/en-US/docs/Web/Media/Formats/Video_concepts
|
|
*/
|
|
export enum ChromaSubsampling {
|
|
/**
|
|
* Each of the three Y'CbCr components has the same sample rate, thus there is no chroma subsampling. This scheme is sometimes used in high-end film scanners and cinematic post-production.
|
|
* Note that "4:4:4" may instead be wrongly referring to R'G'B' color space, which implicitly also does not have any chroma subsampling (except in JPEG R'G'B' can be subsampled).
|
|
* Formats such as HDCAM SR can record 4:4:4 R'G'B' over dual-link HD-SDI.
|
|
*/
|
|
Yuv444 = 0,
|
|
/**
|
|
* The two chroma components are sampled at half the horizontal sample rate of luma: the horizontal chroma resolution is halved. This reduces the bandwidth of an uncompressed video signal by one-third.
|
|
* Many high-end digital video formats and interfaces use this scheme:
|
|
* - [AVC-Intra 100](https://en.wikipedia.org/wiki/AVC-Intra)
|
|
* - [Digital Betacam](https://en.wikipedia.org/wiki/Betacam#Digital_Betacam)
|
|
* - [Betacam SX](https://en.wikipedia.org/wiki/Betacam#Betacam_SX)
|
|
* - [DVCPRO50](https://en.wikipedia.org/wiki/DV#DVCPRO) and [DVCPRO HD](https://en.wikipedia.org/wiki/DV#DVCPRO_HD)
|
|
* - [Digital-S](https://en.wikipedia.org/wiki/Digital-S)
|
|
* - [CCIR 601](https://en.wikipedia.org/wiki/Rec._601) / [Serial Digital Interface](https://en.wikipedia.org/wiki/Serial_digital_interface) / [D1](https://en.wikipedia.org/wiki/D-1_(Sony))
|
|
* - [ProRes (HQ, 422, LT, and Proxy)](https://en.wikipedia.org/wiki/Apple_ProRes)
|
|
* - [XDCAM HD422](https://en.wikipedia.org/wiki/XDCAM)
|
|
* - [Canon MXF HD422](https://en.wikipedia.org/wiki/Canon_XF-300)
|
|
*/
|
|
Yuv422 = 1,
|
|
/**
|
|
* n 4:2:0, the horizontal sampling is doubled compared to 4:1:1,
|
|
* but as the **Cb** and **Cr** channels are only sampled on each alternate line in this scheme, the vertical resolution is halved.
|
|
* The data rate is thus the same.
|
|
* This fits reasonably well with the PAL color encoding system, since this has only half the vertical chrominance resolution of [NTSC](https://en.wikipedia.org/wiki/NTSC).
|
|
* It would also fit extremely well with the [SECAM](https://en.wikipedia.org/wiki/SECAM) color encoding system,
|
|
* since like that format, 4:2:0 only stores and transmits one color channel per line (the other channel being recovered from the previous line).
|
|
* However, little equipment has actually been produced that outputs a SECAM analogue video signal.
|
|
* In general, SECAM territories either have to use a PAL-capable display or a [transcoder](https://en.wikipedia.org/wiki/Transcoding) to convert the PAL signal to SECAM for display.
|
|
*/
|
|
Yuv420 = 2,
|
|
/**
|
|
* What if the chroma subsampling model is 4:0:0?
|
|
* That says to use every pixel of luma data, but that each row has 0 chroma samples applied to it. The resulting image, then, is comprised solely of the luminance data—a greyscale image.
|
|
*/
|
|
Yuv400 = 3,
|
|
}
|
|
|
|
export class Canvas {
|
|
constructor(width: number, height: number, flag?: SvgExportFlag)
|
|
|
|
width: number
|
|
height: number
|
|
getContext(contextType: '2d', contextAttributes?: ContextAttributes): SKRSContext2D
|
|
encodeSync(format: 'webp' | 'jpeg', quality?: number): Buffer
|
|
encodeSync(format: 'png'): Buffer
|
|
encodeSync(format: 'avif', cfg?: AvifConfig): Buffer
|
|
encode(format: 'webp' | 'jpeg', quality?: number): Promise<Buffer>
|
|
encode(format: 'png'): Promise<Buffer>
|
|
encode(format: 'avif', cfg?: AvifConfig): Promise<Buffer>
|
|
|
|
toBuffer(mime: 'image/png'): Buffer
|
|
toBuffer(mime: 'image/jpeg' | 'image/webp', quality?: number): Buffer
|
|
toBuffer(mime: 'image/avif', cfg?: AvifConfig): Buffer
|
|
// raw pixels
|
|
data(): Buffer
|
|
toDataURL(mime?: 'image/png'): string
|
|
toDataURL(mime: 'image/jpeg' | 'image/webp', quality?: number): string
|
|
toDataURL(mime?: 'image/jpeg' | 'image/webp' | 'image/png', quality?: number): string
|
|
toDataURL(mime?: 'image/avif', cfg?: AvifConfig): string
|
|
|
|
toDataURLAsync(mime?: 'image/png'): Promise<string>
|
|
toDataURLAsync(mime: 'image/jpeg' | 'image/webp', quality?: number): Promise<string>
|
|
toDataURLAsync(mime?: 'image/jpeg' | 'image/webp' | 'image/png', quality?: number): Promise<string>
|
|
toDataURLAsync(mime?: 'image/avif', cfg?: AvifConfig): Promise<string>
|
|
}
|
|
|
|
export function createCanvas(width: number, height: number): Canvas
|
|
|
|
export function createCanvas(width: number, height: number, svgExportFlag: SvgExportFlag): SvgCanvas
|
|
|
|
interface IGlobalFonts {
|
|
readonly families: {
|
|
family: string
|
|
styles: {
|
|
weight: number
|
|
width: string
|
|
style: string
|
|
}[]
|
|
}[]
|
|
// return true if succeeded
|
|
register(font: Buffer, nameAlias?: string): boolean
|
|
// absolute path
|
|
registerFromPath(path: string, nameAlias?: string): boolean
|
|
has(name: string): boolean
|
|
loadFontsFromDir(path: string): number
|
|
}
|
|
|
|
export const GlobalFonts: IGlobalFonts
|
|
|
|
export enum PathOp {
|
|
Difference = 0, // subtract the op path from the first path
|
|
Intersect = 1, // intersect the two paths
|
|
Union = 2, // union (inclusive-or) the two paths
|
|
Xor = 3, // exclusive-or the two paths
|
|
ReverseDifference = 4, // subtract the first path from the op path
|
|
}
|
|
|
|
export enum FillType {
|
|
Winding = 0,
|
|
EvenOdd = 1,
|
|
InverseWinding = 2,
|
|
InverseEvenOdd = 3,
|
|
}
|
|
|
|
export enum StrokeJoin {
|
|
Miter = 0,
|
|
Round = 1,
|
|
Bevel = 2,
|
|
}
|
|
|
|
export enum StrokeCap {
|
|
Butt = 0,
|
|
Round = 1,
|
|
Square = 2,
|
|
}
|
|
|
|
export enum SvgExportFlag {
|
|
ConvertTextToPaths = 0x01,
|
|
NoPrettyXML = 0x02,
|
|
RelativePathEncoding = 0x04,
|
|
}
|
|
|
|
export function convertSVGTextToPath(svg: Buffer | string): Buffer
|
|
|
|
export interface LoadImageOptions {
|
|
alt?: string
|
|
maxRedirects?: number
|
|
requestOptions?: import('http').RequestOptions
|
|
}
|
|
|
|
export function loadImage(
|
|
source: string | URL | Buffer | ArrayBufferLike | Uint8Array | Image | import('stream').Readable,
|
|
options?: LoadImageOptions,
|
|
): Promise<Image>
|