@yuzhouu/canvas-kit 0.1.2

package/_vendor/canvas-core/geometry/Box.ts

@@ -0,0 +1,80 @@
+import { Vec } from "./Vec";
+
+export class Box {
+  constructor(
+    public x: number,
+    public y: number,
+    public w: number,
+    public h: number,
+  ) {}
+
+  get minX(): number {
+    return this.x;
+  }
+  get minY(): number {
+    return this.y;
+  }
+  get maxX(): number {
+    return this.x + this.w;
+  }
+  get maxY(): number {
+    return this.y + this.h;
+  }
+  get center(): Vec {
+    return new Vec(this.x + this.w / 2, this.y + this.h / 2);
+  }
+
+  containsPoint(p: Vec): boolean {
+    return (
+      p.x >= this.minX &&
+      p.x <= this.maxX &&
+      p.y >= this.minY &&
+      p.y <= this.maxY
+    );
+  }
+
+  containsBox(other: Box): boolean {
+    return (
+      other.minX >= this.minX &&
+      other.maxX <= this.maxX &&
+      other.minY >= this.minY &&
+      other.maxY <= this.maxY
+    );
+  }
+
+  intersects(other: Box): boolean {
+    return (
+      this.minX < other.maxX &&
+      this.maxX > other.minX &&
+      this.minY < other.maxY &&
+      this.maxY > other.minY
+    );
+  }
+
+  expand(amount: number): Box {
+    return new Box(
+      this.x - amount,
+      this.y - amount,
+      this.w + amount * 2,
+      this.h + amount * 2,
+    );
+  }
+
+  clone(): Box {
+    return new Box(this.x, this.y, this.w, this.h);
+  }
+
+  static FromPoints(points: Vec[]): Box {
+    let minX = Infinity;
+    let minY = Infinity;
+    let maxX = -Infinity;
+    let maxY = -Infinity;
+    for (const p of points) {
+      minX = Math.min(minX, p.x);
+      minY = Math.min(minY, p.y);
+      maxX = Math.max(maxX, p.x);
+      maxY = Math.max(maxY, p.y);
+    }
+    return new Box(minX, minY, maxX - minX, maxY - minY);
+  }
+}

package/_vendor/canvas-core/geometry/Ellipse2d.ts

@@ -0,0 +1,67 @@
+import { Geometry2d } from "./Geometry2d";
+import { Vec } from "./Vec";
+import { Box } from "./Box";
+
+export class Ellipse2d extends Geometry2d {
+  readonly width: number;
+  readonly height: number;
+
+  constructor(opts: { width: number; height: number }) {
+    super();
+    this.width = opts.width;
+    this.height = opts.height;
+  }
+
+  get bounds(): Box {
+    return new Box(0, 0, this.width, this.height);
+  }
+
+  get isClosed(): boolean {
+    return true;
+  }
+
+  get vertices(): Vec[] {
+    const cx = this.width / 2;
+    const cy = this.height / 2;
+    const rx = this.width / 2;
+    const ry = this.height / 2;
+    const points: Vec[] = [];
+    const segments = 32;
+    for (let i = 0; i < segments; i++) {
+      const angle = (i / segments) * Math.PI * 2;
+      points.push(
+        new Vec(cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)),
+      );
+    }
+    return points;
+  }
+
+  nearestPoint(point: Vec): Vec {
+    const cx = this.width / 2;
+    const cy = this.height / 2;
+    const rx = this.width / 2;
+    const ry = this.height / 2;
+
+    // Normalize point relative to center
+    const dx = point.x - cx;
+    const dy = point.y - cy;
+
+    if (dx === 0 && dy === 0) {
+      return new Vec(cx + rx, cy);
+    }
+
+    // Scale to unit circle space
+    const angle = Math.atan2(dy / ry, dx / rx);
+    return new Vec(cx + rx * Math.cos(angle), cy + ry * Math.sin(angle));
+  }
+
+  hitTestPoint(point: Vec, margin = 0): boolean {
+    const cx = this.width / 2;
+    const cy = this.height / 2;
+    const rx = this.width / 2 + margin;
+    const ry = this.height / 2 + margin;
+    const dx = point.x - cx;
+    const dy = point.y - cy;
+    return (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry) <= 1;
+  }
+}

package/_vendor/canvas-core/geometry/Geometry2d.ts

@@ -0,0 +1,52 @@
+import { Vec } from "./Vec";
+import { Box } from "./Box";
+
+export abstract class Geometry2d {
+  abstract get bounds(): Box;
+  abstract get isClosed(): boolean;
+  abstract get vertices(): Vec[];
+  abstract nearestPoint(point: Vec): Vec;
+  abstract hitTestPoint(point: Vec, margin?: number): boolean;
+
+  distanceToPoint(point: Vec): number {
+    return point.dist(this.nearestPoint(point));
+  }
+
+  /**
+   * Find intersection points between a line segment (a→b) and the shape outline.
+   * Default implementation uses the polygon formed by `vertices`.
+   */
+  intersectLineSegment(a: Vec, b: Vec): Vec[] {
+    const verts = this.vertices;
+    const results: Vec[] = [];
+    const n = verts.length;
+    if (n < 2) return results;
+
+    for (let i = 0; i < n; i++) {
+      const c = verts[i];
+      const d = verts[(i + 1) % n];
+      const pt = segmentIntersection(a, b, c, d);
+      if (pt) results.push(pt);
+    }
+    return results;
+  }
+}
+
+/** Returns the intersection point of segments AB and CD, or null if they don't intersect. */
+function segmentIntersection(a: Vec, b: Vec, c: Vec, d: Vec): Vec | null {
+  const dx1 = b.x - a.x;
+  const dy1 = b.y - a.y;
+  const dx2 = d.x - c.x;
+  const dy2 = d.y - c.y;
+
+  const denom = dx1 * dy2 - dy1 * dx2;
+  if (Math.abs(denom) < 1e-10) return null; // parallel
+
+  const t = ((c.x - a.x) * dy2 - (c.y - a.y) * dx2) / denom;
+  const u = ((c.x - a.x) * dy1 - (c.y - a.y) * dx1) / denom;
+
+  if (t >= 0 && t <= 1 && u >= 0 && u <= 1) {
+    return new Vec(a.x + t * dx1, a.y + t * dy1);
+  }
+  return null;
+}

package/_vendor/canvas-core/geometry/Mat.ts

@@ -0,0 +1,92 @@
+import { Vec } from "./Vec";
+
+/**
+ * 2D affine transform matrix:
+ * [a c e]
+ * [b d f]
+ * [0 0 1]
+ */
+export class Mat {
+  constructor(
+    public a: number,
+    public b: number,
+    public c: number,
+    public d: number,
+    public e: number,
+    public f: number,
+  ) {}
+
+  static Identity(): Mat {
+    return new Mat(1, 0, 0, 1, 0, 0);
+  }
+
+  static Translate(x: number, y: number): Mat {
+    return new Mat(1, 0, 0, 1, x, y);
+  }
+
+  static Rotate(angle: number): Mat {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return new Mat(cos, sin, -sin, cos, 0, 0);
+  }
+
+  static Scale(sx: number, sy: number): Mat {
+    return new Mat(sx, 0, 0, sy, 0, 0);
+  }
+
+  /** Compose: this × other */
+  compose(other: Mat): Mat {
+    return new Mat(
+      this.a * other.a + this.c * other.b,
+      this.b * other.a + this.d * other.b,
+      this.a * other.c + this.c * other.d,
+      this.b * other.c + this.d * other.d,
+      this.a * other.e + this.c * other.f + this.e,
+      this.b * other.e + this.d * other.f + this.f,
+    );
+  }
+
+  applyToPoint(p: Vec): Vec {
+    return new Vec(
+      this.a * p.x + this.c * p.y + this.e,
+      this.b * p.x + this.d * p.y + this.f,
+    );
+  }
+
+  invert(): Mat {
+    const det = this.a * this.d - this.b * this.c;
+    if (det === 0) return Mat.Identity();
+    const invDet = 1 / det;
+    return new Mat(
+      this.d * invDet,
+      -this.b * invDet,
+      -this.c * invDet,
+      this.a * invDet,
+      (this.c * this.f - this.d * this.e) * invDet,
+      (this.b * this.e - this.a * this.f) * invDet,
+    );
+  }
+
+  toCssString(): string {
+    return `matrix(${this.a},${this.b},${this.c},${this.d},${this.e},${this.f})`;
+  }
+
+  toSvgString(): string {
+    return `matrix(${this.a} ${this.b} ${this.c} ${this.d} ${this.e} ${this.f})`;
+  }
+
+  /** Create a transform for a shape: translate(x,y) * rotate(rotation) * scale(scaleX, scaleY) */
+  static ForShape(
+    x: number,
+    y: number,
+    rotation: number,
+    scaleX = 1,
+    scaleY = 1,
+  ): Mat {
+    const translation = Mat.Translate(x, y);
+    const rotationMat = rotation === 0 ? Mat.Identity() : Mat.Rotate(rotation);
+    const scaleMat =
+      scaleX === 1 && scaleY === 1 ? Mat.Identity() : Mat.Scale(scaleX, scaleY);
+    return translation.compose(rotationMat).compose(scaleMat);
+  }
+}

package/_vendor/canvas-core/geometry/Polyline2d.ts

@@ -0,0 +1,63 @@
+import { Geometry2d } from "./Geometry2d";
+import { Vec } from "./Vec";
+import { Box } from "./Box";
+
+export class Polyline2d extends Geometry2d {
+  readonly points: Vec[];
+
+  constructor(opts: { points: Vec[] }) {
+    super();
+    this.points = opts.points;
+  }
+
+  get bounds(): Box {
+    return Box.FromPoints(this.points);
+  }
+
+  get isClosed(): boolean {
+    return false;
+  }
+
+  get vertices(): Vec[] {
+    return this.points;
+  }
+
+  nearestPoint(point: Vec): Vec {
+    let nearest = this.points[0];
+    let minDist = Infinity;
+
+    for (let i = 0; i < this.points.length - 1; i++) {
+      const a = this.points[i];
+      const b = this.points[i + 1];
+      const p = nearestPointOnSegment(a, b, point);
+      const d = point.dist(p);
+      if (d < minDist) {
+        minDist = d;
+        nearest = p;
+      }
+    }
+
+    return nearest;
+  }
+
+  hitTestPoint(point: Vec, margin = 0): boolean {
+    for (let i = 0; i < this.points.length - 1; i++) {
+      const a = this.points[i];
+      const b = this.points[i + 1];
+      const p = nearestPointOnSegment(a, b, point);
+      if (point.dist(p) <= margin + 4) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+function nearestPointOnSegment(a: Vec, b: Vec, p: Vec): Vec {
+  const ab = b.sub(a);
+  const ap = p.sub(a);
+  const abLenSq = ab.x * ab.x + ab.y * ab.y;
+  if (abLenSq === 0) return a;
+  const t = Math.max(0, Math.min(1, (ap.x * ab.x + ap.y * ab.y) / abLenSq));
+  return new Vec(a.x + t * ab.x, a.y + t * ab.y);
+}

package/_vendor/canvas-core/geometry/Rectangle2d.ts

@@ -0,0 +1,64 @@
+import { Geometry2d } from "./Geometry2d";
+import { Vec } from "./Vec";
+import { Box } from "./Box";
+
+export class Rectangle2d extends Geometry2d {
+  readonly width: number;
+  readonly height: number;
+
+  constructor(opts: { width: number; height: number }) {
+    super();
+    this.width = opts.width;
+    this.height = opts.height;
+  }
+
+  get bounds(): Box {
+    return new Box(0, 0, this.width, this.height);
+  }
+
+  get isClosed(): boolean {
+    return true;
+  }
+
+  get vertices(): Vec[] {
+    return [
+      new Vec(0, 0),
+      new Vec(this.width, 0),
+      new Vec(this.width, this.height),
+      new Vec(0, this.height),
+    ];
+  }
+
+  nearestPoint(point: Vec): Vec {
+    const x = point.x;
+    const y = point.y;
+    const w = this.width;
+    const h = this.height;
+
+    // If the point is outside, clamp to the nearest edge
+    if (x <= 0 || x >= w || y <= 0 || y >= h) {
+      return new Vec(Math.max(0, Math.min(w, x)), Math.max(0, Math.min(h, y)));
+    }
+
+    // Point is inside: find the nearest edge
+    const distLeft = x;
+    const distRight = w - x;
+    const distTop = y;
+    const distBottom = h - y;
+    const min = Math.min(distLeft, distRight, distTop, distBottom);
+
+    if (min === distLeft) return new Vec(0, y);
+    if (min === distRight) return new Vec(w, y);
+    if (min === distTop) return new Vec(x, 0);
+    return new Vec(x, h);
+  }
+
+  hitTestPoint(point: Vec, margin = 0): boolean {
+    return (
+      point.x >= -margin &&
+      point.x <= this.width + margin &&
+      point.y >= -margin &&
+      point.y <= this.height + margin
+    );
+  }
+}

package/_vendor/canvas-core/geometry/Vec.ts

@@ -0,0 +1,123 @@
+export class Vec {
+  constructor(
+    public x: number,
+    public y: number,
+  ) {}
+
+  add(v: Vec): Vec {
+    return new Vec(this.x + v.x, this.y + v.y);
+  }
+
+  sub(v: Vec): Vec {
+    return new Vec(this.x - v.x, this.y - v.y);
+  }
+
+  mul(s: number): Vec {
+    return new Vec(this.x * s, this.y * s);
+  }
+
+  div(s: number): Vec {
+    return new Vec(this.x / s, this.y / s);
+  }
+
+  len2(): number {
+    return this.x * this.x + this.y * this.y;
+  }
+
+  len(): number {
+    return Math.sqrt(this.len2());
+  }
+
+  dist2(v: Vec): number {
+    const dx = this.x - v.x;
+    const dy = this.y - v.y;
+    return dx * dx + dy * dy;
+  }
+
+  dist(v: Vec): number {
+    return Math.sqrt(this.dist2(v));
+  }
+
+  rot(angle: number): Vec {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return new Vec(this.x * c - this.y * s, this.x * s + this.y * c);
+  }
+
+  /** Perpendicular vector (rotated 90° counter-clockwise). */
+  per(): Vec {
+    return new Vec(-this.y, this.x);
+  }
+
+  /** Unit vector (alias for normalize). */
+  uni(): Vec {
+    return this.normalize();
+  }
+
+  normalize(): Vec {
+    const l = this.len();
+    if (l === 0) return new Vec(0, 0);
+    return this.div(l);
+  }
+
+  equals(v: Vec): boolean {
+    return this.x === v.x && this.y === v.y;
+  }
+
+  clone(): Vec {
+    return new Vec(this.x, this.y);
+  }
+
+  static From(x: number, y: number): Vec {
+    return new Vec(x, y);
+  }
+
+  static Zero(): Vec {
+    return new Vec(0, 0);
+  }
+
+  /** Midpoint between two vectors. */
+  static Med(a: Vec, b: Vec): Vec {
+    return new Vec((a.x + b.x) / 2, (a.y + b.y) / 2);
+  }
+
+  /** Linear interpolation between two vectors. */
+  static Lrp(a: Vec, b: Vec, t: number): Vec {
+    return new Vec(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+  }
+
+  /** Distance between two vectors. */
+  static Dist(a: Vec, b: Vec): number {
+    return a.dist(b);
+  }
+
+  static Dist2(a: Vec, b: Vec): number {
+    return a.dist2(b);
+  }
+
+  /** Angle from center to point (atan2). */
+  static Angle(center: Vec, point: Vec): number {
+    return Math.atan2(point.y - center.y, point.x - center.x);
+  }
+
+  /** Move point toward target by distance. */
+  static Nudge(from: Vec, toward: Vec, distance: number): Vec {
+    const d = toward.sub(from);
+    const l = d.len();
+    if (l === 0) return from.clone();
+    return from.add(d.mul(distance / l));
+  }
+
+  /** Rotate point around a center by angle. */
+  static RotWith(point: Vec, center: Vec, angle: number): Vec {
+    const dx = point.x - center.x;
+    const dy = point.y - center.y;
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    return new Vec(center.x + dx * c - dy * s, center.y + dx * s + dy * c);
+  }
+
+  static IsNaN(v: Vec): boolean {
+    return isNaN(v.x) || isNaN(v.y);
+  }
+}

package/_vendor/canvas-core/geometry/index.ts

@@ -0,0 +1,13 @@
+export { Vec } from "./Vec";
+export { Box } from "./Box";
+export { Mat } from "./Mat";
+export { Geometry2d } from "./Geometry2d";
+export { Rectangle2d } from "./Rectangle2d";
+export { Ellipse2d } from "./Ellipse2d";
+export { Polyline2d } from "./Polyline2d";
+export {
+  distanceBetweenSegments,
+  distanceToSegment,
+  nearestPointOnSegment,
+  segmentsIntersect,
+} from "./segments";

package/_vendor/canvas-core/geometry/segments.ts

@@ -0,0 +1,65 @@
+import { Vec } from "./Vec";
+
+export function nearestPointOnSegment(start: Vec, end: Vec, point: Vec): Vec {
+  const segment = end.sub(start);
+  const pointOffset = point.sub(start);
+  const lengthSquared = segment.x * segment.x + segment.y * segment.y;
+  if (lengthSquared === 0) {
+    return start;
+  }
+
+  const t = Math.max(
+    0,
+    Math.min(
+      1,
+      (pointOffset.x * segment.x + pointOffset.y * segment.y) / lengthSquared,
+    ),
+  );
+  return new Vec(start.x + segment.x * t, start.y + segment.y * t);
+}
+
+export function distanceToSegment(
+  point: Vec,
+  start: Vec,
+  end: Vec,
+): number {
+  return point.dist(nearestPointOnSegment(start, end, point));
+}
+
+export function segmentsIntersect(
+  firstStart: Vec,
+  firstEnd: Vec,
+  secondStart: Vec,
+  secondEnd: Vec,
+): boolean {
+  const first = firstEnd.sub(firstStart);
+  const second = secondEnd.sub(secondStart);
+  const denominator = first.x * second.y - first.y * second.x;
+  if (Math.abs(denominator) < 1e-8) {
+    return false;
+  }
+
+  const delta = secondStart.sub(firstStart);
+  const t = (delta.x * second.y - delta.y * second.x) / denominator;
+  const u = (delta.x * first.y - delta.y * first.x) / denominator;
+
+  return t >= 0 && t <= 1 && u >= 0 && u <= 1;
+}
+
+export function distanceBetweenSegments(
+  firstStart: Vec,
+  firstEnd: Vec,
+  secondStart: Vec,
+  secondEnd: Vec,
+): number {
+  if (segmentsIntersect(firstStart, firstEnd, secondStart, secondEnd)) {
+    return 0;
+  }
+
+  return Math.min(
+    distanceToSegment(firstStart, secondStart, secondEnd),
+    distanceToSegment(firstEnd, secondStart, secondEnd),
+    distanceToSegment(secondStart, firstStart, firstEnd),
+    distanceToSegment(secondEnd, firstStart, firstEnd),
+  );
+}