@yuzhouu/canvas-kit 0.1.2 → 0.1.3

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

@@ -1,80 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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/segments.ts

@@ -1,65 +0,0 @@
-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),
-  );
-}