uplot-webgpu 0.1.0 → 0.2.0

package/scripts/{webgpu → ts/webgpu}/GPUPath.ts

@@ -1,16 +1,58 @@
-// @ts-nocheck
 const TAU = Math.PI * 2;
 const EPS = 1e-9;
 
-function cloneCommand(cmd) {
-	return cmd.slice();
+type Matrix2DArray = [number, number, number, number, number, number];
+export type GPUPathPoint = [number, number];
+export type GPUPathArcFlag = 0 | 1;
+export type GPUPathMoveCommand = [0, number, number];
+export type GPUPathLineCommand = [1, number, number];
+export type GPUPathCubicCommand = [2, number, number, number, number, number, number];
+export type GPUPathArcCommand = [3, number, number, number, number, number, GPUPathArcFlag];
+export type GPUPathRectCommand = [4, number, number, number, number];
+export type GPUPathCloseCommand = [5];
+export type GPUPathEllipseCommand = [6, number, number, number, number, number, number, number, GPUPathArcFlag];
+
+export type GPUPathCommand =
+	| GPUPathMoveCommand
+	| GPUPathLineCommand
+	| GPUPathCubicCommand
+	| GPUPathArcCommand
+	| GPUPathRectCommand
+	| GPUPathCloseCommand
+	| GPUPathEllipseCommand;
+
+export interface GPUPathBounds {
+	minX: number;
+	minY: number;
+	maxX: number;
+	maxY: number;
+	width: number;
+	height: number;
 }
 
-function isFiniteNumber(v) {
+export interface GPUPathRect {
+	x: number;
+	y: number;
+	w: number;
+	h: number;
+	winding: number;
+}
+
+export type GPUPathSubpath = GPUPathPoint[] & {closed?: boolean};
+export interface GPUPathLike {
+	cmds?: GPUPathCommand[];
+	toSubpaths?: (curveSteps?: number) => GPUPathSubpath[];
+}
+
+function cloneCommand(cmd: GPUPathCommand): GPUPathCommand {
+	return cmd.slice() as GPUPathCommand;
+}
+
+function isFiniteNumber(v: unknown): v is number {
 	return typeof v == 'number' && Number.isFinite(v);
 }
 
-function allFinite(vals) {
+function allFinite(vals: readonly unknown[]): vals is readonly number[] {
 	for (let v of vals) {
 		if (!isFiniteNumber(v))
 			return false;
@@ -18,18 +60,18 @@ function allFinite(vals) {
 	return true;
 }
 
-function dist(a, b, c, d) {
+function dist(a: number, b: number, c: number, d: number): number {
 	let dx = c - a;
 	let dy = d - b;
 	return Math.sqrt(dx * dx + dy * dy);
 }
 
-function cubicAt(a, b, c, d, t) {
+function cubicAt(a: number, b: number, c: number, d: number, t: number): number {
 	let mt = 1 - t;
 	return mt * mt * mt * a + 3 * mt * mt * t * b + 3 * mt * t * t * c + t * t * t * d;
 }
 
-function normalizeAngle(a) {
+function normalizeAngle(a: number): number {
 	while (a < 0)
 		a += TAU;
 	while (a >= TAU)
@@ -37,7 +79,7 @@ function normalizeAngle(a) {
 	return a;
 }
 
-function arcSweep(start, end, ccw) {
+function arcSweep(start: number, end: number, ccw: boolean): number {
 	let raw = end - start;
 
 	if (!Number.isFinite(raw))
@@ -62,27 +104,29 @@ function arcSweep(start, end, ccw) {
 }
 
 
-function matrixFrom(transform) {
+function matrixFrom(transform: DOMMatrix | DOMMatrix2DInit | readonly number[] | null | undefined): Matrix2DArray | null {
 	if (transform == null)
 		return null;
 
-	if (Array.isArray(transform))
-		return transform;
+	if (Array.isArray(transform) && transform.length >= 6)
+		return transform.slice(0, 6) as Matrix2DArray;
 
 	if (typeof DOMMatrix != 'undefined' && transform instanceof DOMMatrix)
 		return [transform.a, transform.b, transform.c, transform.d, transform.e, transform.f];
 
-	if (typeof transform == 'object')
-		return [transform.a, transform.b, transform.c, transform.d, transform.e, transform.f];
+	if (typeof transform == 'object') {
+		let m = transform as DOMMatrix2DInit;
+		return [m.a ?? 1, m.b ?? 0, m.c ?? 0, m.d ?? 1, m.e ?? 0, m.f ?? 0];
+	}
 
 	return null;
 }
 
-function applyMatrix(m, x, y) {
+function applyMatrix(m: Matrix2DArray, x: number, y: number): GPUPathPoint {
 	return [m[0] * x + m[2] * y + m[4], m[1] * x + m[3] * y + m[5]];
 }
 
-function ellipsePoint(cx, cy, rx, ry, rotation, angle) {
+function ellipsePoint(cx: number, cy: number, rx: number, ry: number, rotation: number, angle: number): GPUPathPoint {
 	let ca = Math.cos(angle);
 	let sa = Math.sin(angle);
 	let cr = Math.cos(rotation);
@@ -92,7 +136,7 @@ function ellipsePoint(cx, cy, rx, ry, rotation, angle) {
 	return [cx + x * cr - y * sr, cy + x * sr + y * cr];
 }
 
-function normalizeRadii(radii) {
+function normalizeRadii(radii: number | number[] | DOMPointInit | DOMPointInit[] | null | undefined): [number, number, number, number] {
 	if (radii == null)
 		return [0, 0, 0, 0];
 
@@ -100,7 +144,7 @@ function normalizeRadii(radii) {
 		return [radii, radii, radii, radii];
 
 	let arr = Array.isArray(radii) ? radii : [radii];
-	let vals = arr.map(v => typeof v == 'number' ? v : Math.max(v.x || 0, v.y || 0));
+	let vals = arr.map(v => typeof v == 'number' ? v : Math.max(v?.x || 0, v?.y || 0));
 
 	if (vals.length == 1)
 		return [vals[0], vals[0], vals[0], vals[0]];
@@ -112,7 +156,7 @@ function normalizeRadii(radii) {
 	return [vals[0], vals[1], vals[2], vals[3]];
 }
 
-function pushPoint(points, x, y) {
+function pushPoint(points: GPUPathSubpath, x: number, y: number): void {
 	let p = points[points.length - 1];
 
 	if (p == null || Math.abs(p[0] - x) > EPS || Math.abs(p[1] - y) > EPS)
@@ -120,7 +164,14 @@ function pushPoint(points, x, y) {
 }
 
 export class GPUPath {
-	constructor(copyFrom) {
+	cmds: GPUPathCommand[];
+	commands?: GPUPathCommand[];
+	_x?: number;
+	_y?: number;
+	_sx?: number;
+	_sy?: number;
+	_hasPoint?: boolean;
+	constructor(copyFrom: GPUPathLike | null = null) {
 		this.cmds = [];
 		this._x = 0;
 		this._y = 0;
@@ -147,7 +198,7 @@ export class GPUPath {
 		return this;
 	}
 
-	syncCurrentFromCommands() {
+	syncCurrentFromCommands(): void {
 		this._x = 0;
 		this._y = 0;
 		this._sx = 0;
@@ -216,7 +267,7 @@ export class GPUPath {
 		}
 	}
 
-	moveTo(x, y) {
+	moveTo(x: number, y: number): void {
 		if (!allFinite([x, y]))
 			return;
 		this.cmds.push([0, x, y]);
@@ -225,7 +276,7 @@ export class GPUPath {
 		this._hasPoint = true;
 	}
 
-	lineTo(x, y) {
+	lineTo(x: number, y: number): void {
 		if (!allFinite([x, y]))
 			return;
 		if (!this._hasPoint)
@@ -237,7 +288,7 @@ export class GPUPath {
 		}
 	}
 
-	bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
+	bezierCurveTo(cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number): void {
 		if (!allFinite([cp1x, cp1y, cp2x, cp2y, x, y]))
 			return;
 		if (!this._hasPoint)
@@ -249,7 +300,7 @@ export class GPUPath {
 		}
 	}
 
-	quadraticCurveTo(cpx, cpy, x, y) {
+	quadraticCurveTo(cpx: number, cpy: number, x: number, y: number): void {
 		if (!allFinite([cpx, cpy, x, y]))
 			return;
 		if (!this._hasPoint)
@@ -263,7 +314,7 @@ export class GPUPath {
 		}
 	}
 
-	arc(x, y, r, startAngle, endAngle, counterclockwise = false) {
+	arc(x: number, y: number, r: number, startAngle: number, endAngle: number, counterclockwise = false): void {
 		if (!allFinite([x, y, r, startAngle, endAngle]) || r <= 0)
 			return;
 
@@ -282,7 +333,7 @@ export class GPUPath {
 		this._y = ey;
 	}
 
-	ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise = false) {
+	ellipse(x: number, y: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, counterclockwise = false): void {
 		if (!allFinite([x, y, radiusX, radiusY, rotation, startAngle, endAngle]) || radiusX <= 0 || radiusY <= 0)
 			return;
 
@@ -301,7 +352,7 @@ export class GPUPath {
 		this._y = end[1];
 	}
 
-	roundRect(x, y, w, h, radii = 0) {
+	roundRect(x: number, y: number, w: number, h: number, radii: number | number[] | DOMPointInit | DOMPointInit[] = 0): void {
 		if (!allFinite([x, y, w, h]))
 			return;
 		let [tl, tr, br, bl] = normalizeRadii(radii);
@@ -333,7 +384,7 @@ export class GPUPath {
 		this.closePath();
 	}
 
-	arcTo(x1, y1, x2, y2, r) {
+	arcTo(x1: number, y1: number, x2: number, y2: number, r: number): void {
 		if (!allFinite([x1, y1, x2, y2, r]))
 			return;
 		if (!this._hasPoint || r <= 0) {
@@ -393,7 +444,7 @@ export class GPUPath {
 		this.arc(cx, cy, r, start, end, cross < 0);
 	}
 
-	rect(x, y, w, h) {
+	rect(x: number, y: number, w: number, h: number): void {
 		if (!allFinite([x, y, w, h]))
 			return;
 		this.cmds.push([4, x, y, w, h]);
@@ -404,7 +455,7 @@ export class GPUPath {
 		this._hasPoint = true;
 	}
 
-	closePath() {
+	closePath(): void {
 		if (!this._hasPoint)
 			return;
 		this.cmds.push([5]);
@@ -412,15 +463,15 @@ export class GPUPath {
 		this._y = this._sy;
 	}
 
-	isEmpty() {
+	isEmpty(): boolean {
 		return this.cmds.length == 0;
 	}
 
-	clone() {
+	clone(): GPUPath {
 		return new GPUPath(this);
 	}
 
-	addPath(path, transform = null) {
+	addPath(path: GPUPathLike | null | undefined, transform: DOMMatrix | DOMMatrix2DInit | readonly number[] | null = null): void {
 		if (path == null)
 			return;
 
@@ -448,8 +499,8 @@ export class GPUPath {
 		}
 	}
 
-	getRects() {
-		let rects = [];
+	getRects(): GPUPathRect[] | null {
+		let rects: GPUPathRect[] = [];
 
 		for (let cmd of this.cmds) {
 			if (cmd[0] != 4)
@@ -477,16 +528,16 @@ export class GPUPath {
 		return rects;
 	}
 
-	toSubpaths(curveSteps = 12) {
-		let paths = [];
-		let pts = [];
+	toSubpaths(curveSteps = 12): GPUPathSubpath[] {
+		let paths: GPUPathSubpath[] = [];
+		let pts: GPUPathSubpath = [];
 		let x = 0;
 		let y = 0;
 		let sx = 0;
 		let sy = 0;
 		let hasPoint = false;
 
-		function flush(closed = false) {
+		function flush(closed = false): void {
 			if (pts.length > 0) {
 				pts.closed = closed;
 				paths.push(pts);
@@ -609,7 +660,7 @@ export class GPUPath {
 				let ry = cmd[2];
 				let rw = cmd[3];
 				let rh = cmd[4];
-				pts = [[rx, ry], [rx + rw, ry], [rx + rw, ry + rh], [rx, ry + rh], [rx, ry]];
+				pts = [[rx, ry], [rx + rw, ry], [rx + rw, ry + rh], [rx, ry + rh], [rx, ry]] as GPUPathSubpath;
 				flush(true);
 				x = sx = rx;
 				y = sy = ry;