@tldraw/editor 3.14.0-canary.8d29afff2d04 → 3.14.0-canary.8ea0ff8489db

package/src/lib/primitives/geometry/CubicSpline2d.ts

@@ -4,22 +4,22 @@ import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
 export class CubicSpline2d extends Geometry2d {
-	points: Vec[]
+	private _points: Vec[]
 
 	constructor(config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & { points: Vec[] }) {
 		super({ ...config, isClosed: false, isFilled: false })
 		const { points } = config
 
-		this.points = points
+		this._points = points
 	}
 
-	_segments?: CubicBezier2d[]
+	private _segments?: CubicBezier2d[]
 
 	// eslint-disable-next-line no-restricted-syntax
 	get segments() {
 		if (!this._segments) {
 			this._segments = []
-			const { points } = this
+			const { _points: points } = this
 
 			const len = points.length
 			const last = len - 2
@@ -54,7 +54,7 @@ export class CubicSpline2d extends Geometry2d {
 		const vertices = this.segments.reduce((acc, segment) => {
 			return acc.concat(segment.vertices)
 		}, [] as Vec[])
-		vertices.push(this.points[this.points.length - 1])
+		vertices.push(this._points[this._points.length - 1])
 		return vertices
 	}
 

package/src/lib/primitives/geometry/Edge2d.ts

@@ -3,38 +3,34 @@ import { Geometry2d } from './Geometry2d'
 
 /** @public */
 export class Edge2d extends Geometry2d {
-	start: Vec
-	end: Vec
-	d: Vec
-	u: Vec
-	ul: number
+	private _start: Vec
+	private _end: Vec
+	private _d: Vec
+	private _u: Vec
+	private _ul: number
 
 	constructor(config: { start: Vec; end: Vec }) {
 		super({ ...config, isClosed: false, isFilled: false })
 		const { start, end } = config
 
-		this.start = start
-		this.end = end
+		this._start = start
+		this._end = end
 
-		this.d = start.clone().sub(end) // the delta from start to end
-		this.u = this.d.clone().uni() // the unit vector of the edge
-		this.ul = this.u.len() // the length of the unit vector
+		this._d = start.clone().sub(end) // the delta from start to end
+		this._u = this._d.clone().uni() // the unit vector of the edge
+		this._ul = this._u.len() // the length of the unit vector
 	}
 
 	override getLength() {
-		return this.d.len()
-	}
-
-	midPoint(): Vec {
-		return this.start.lrp(this.end, 0.5)
+		return this._d.len()
 	}
 
 	override getVertices(): Vec[] {
-		return [this.start, this.end]
+		return [this._start, this._end]
 	}
 
 	override nearestPoint(point: VecLike): Vec {
-		const { start, end, d, u, ul: l } = this
+		const { _start: start, _end: end, _d: d, _u: u, _ul: l } = this
 		if (d.len() === 0) return start // start and end are the same
 		if (l === 0) return start // no length in the unit vector
 		const k = Vec.Sub(point, start).dpr(u) / l
@@ -48,7 +44,7 @@ export class Edge2d extends Geometry2d {
 	}
 
 	getSvgPathData(first = true) {
-		const { start, end } = this
+		const { _start: start, _end: end } = this
 		return `${first ? `M${start.toFixed()}` : ``} L${end.toFixed()}`
 	}
 }

package/src/lib/primitives/geometry/Ellipse2d.ts

@@ -1,14 +1,15 @@
 import { Box } from '../Box'
 import { Vec, VecLike } from '../Vec'
-import { PI, PI2, perimeterOfEllipse } from '../utils'
+import { PI, PI2, clamp, perimeterOfEllipse } from '../utils'
 import { Edge2d } from './Edge2d'
 import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 import { getVerticesCountForLength } from './geometry-constants'
 
 /** @public */
 export class Ellipse2d extends Geometry2d {
-	w: number
-	h: number
+	private _w: number
+	private _h: number
+	private _edges?: Edge2d[]
 
 	constructor(
 		public config: Omit<Geometry2dOptions, 'isClosed'> & {
@@ -18,12 +19,10 @@ export class Ellipse2d extends Geometry2d {
 	) {
 		super({ ...config, isClosed: true })
 		const { width, height } = config
-		this.w = width
-		this.h = height
+		this._w = width
+		this._h = height
 	}
 
-	_edges?: Edge2d[]
-
 	// eslint-disable-next-line no-restricted-syntax
 	get edges() {
 		if (!this._edges) {
@@ -41,8 +40,8 @@ export class Ellipse2d extends Geometry2d {
 
 	getVertices() {
 		// Perimeter of the ellipse
-		const w = Math.max(1, this.w)
-		const h = Math.max(1, this.h)
+		const w = Math.max(1, this._w)
+		const h = Math.max(1, this._h)
 		const cx = w / 2
 		const cy = h / 2
 		const q = Math.pow(cx - cy, 2) / Math.pow(cx + cy, 2)
@@ -63,7 +62,7 @@ export class Ellipse2d extends Geometry2d {
 		const vertices = Array(len)
 
 		for (let i = 0; i < len; i++) {
-			vertices[i] = new Vec(cx + cx * cos, cy + cy * sin)
+			vertices[i] = new Vec(clamp(cx + cx * cos, 0, w), clamp(cy + cy * sin, 0, h))
 			ts = b * cos + a * sin
 			tc = a * cos - b * sin
 			sin = ts
@@ -95,11 +94,11 @@ export class Ellipse2d extends Geometry2d {
 	}
 
 	getBounds() {
-		return new Box(0, 0, this.w, this.h)
+		return new Box(0, 0, this._w, this._h)
 	}
 
 	getLength(): number {
-		const { w, h } = this
+		const { _w: w, _h: h } = this
 		const cx = w / 2
 		const cy = h / 2
 		const rx = Math.max(0, cx)
@@ -108,7 +107,7 @@ export class Ellipse2d extends Geometry2d {
 	}
 
 	getSvgPathData(first = false) {
-		const { w, h } = this
+		const { _w: w, _h: h } = this
 		const cx = w / 2
 		const cy = h / 2
 		const rx = Math.max(0, cx)

package/src/lib/primitives/geometry/Point2d.ts

@@ -3,7 +3,7 @@ import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
 export class Point2d extends Geometry2d {
-	point: Vec
+	private _point: Vec
 
 	constructor(
 		config: Omit<Geometry2dOptions, 'isClosed' | 'isFilled'> & { margin: number; point: Vec }
@@ -11,23 +11,23 @@ export class Point2d extends Geometry2d {
 		super({ ...config, isClosed: true, isFilled: true })
 		const { point } = config
 
-		this.point = point
+		this._point = point
 	}
 
 	getVertices() {
-		return [this.point]
+		return [this._point]
 	}
 
 	nearestPoint(): Vec {
-		return this.point
+		return this._point
 	}
 
 	hitTestLineSegment(A: VecLike, B: VecLike, margin: number): boolean {
-		return Vec.DistanceToLineSegment(A, B, this.point) < margin
+		return Vec.DistanceToLineSegment(A, B, this._point) < margin
 	}
 
 	getSvgPathData() {
-		const { point } = this
+		const { _point: point } = this
 		return `M${point.toFixed()}`
 	}
 }

package/src/lib/primitives/geometry/Polygon2d.ts

@@ -7,5 +7,9 @@ export class Polygon2d extends Polyline2d {
 	constructor(config: Omit<Geometry2dOptions, 'isClosed'> & { points: Vec[] }) {
 		super({ ...config })
 		this.isClosed = true
+
+		if (config.points.length < 3) {
+			throw new Error('Polygon2d: points must be an array of at least 3 points')
+		}
 	}
 }

package/src/lib/primitives/geometry/Polyline2d.ts

@@ -4,18 +4,21 @@ import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
 export class Polyline2d extends Geometry2d {
-	points: Vec[]
+	private _points: Vec[]
+	private _segments?: Edge2d[]
 
 	constructor(config: Omit<Geometry2dOptions, 'isFilled' | 'isClosed'> & { points: Vec[] }) {
 		super({ isClosed: false, isFilled: false, ...config })
 		const { points } = config
-		this.points = points
-	}
+		this._points = points
 
-	_segments?: Edge2d[]
+		if (points.length < 2) {
+			throw new Error('Polyline2d: points must be an array of at least 2 points')
+		}
+	}
 
 	// eslint-disable-next-line no-restricted-syntax
-	get segments() {
+	protected get segments() {
 		if (!this._segments) {
 			this._segments = []
 			const { vertices } = this
@@ -38,12 +41,12 @@ export class Polyline2d extends Geometry2d {
 	}
 
 	getVertices() {
-		return this.points
+		return this._points
 	}
 
 	nearestPoint(A: VecLike): Vec {
 		const { segments } = this
-		let nearest = this.points[0]
+		let nearest = this._points[0]
 		let dist = Infinity
 		let p: Vec // current point on segment
 		let d: number // distance from A to p

package/src/lib/primitives/geometry/Rectangle2d.ts

@@ -5,10 +5,10 @@ import { Polygon2d } from './Polygon2d'
 
 /** @public */
 export class Rectangle2d extends Polygon2d {
-	x: number
-	y: number
-	w: number
-	h: number
+	private _x: number
+	private _y: number
+	private _w: number
+	private _h: number
 
 	constructor(
 		config: Omit<Geometry2dOptions, 'isClosed'> & {
@@ -28,18 +28,31 @@ export class Rectangle2d extends Polygon2d {
 				new Vec(x, y + height),
 			],
 		})
-		this.x = x
-		this.y = y
-		this.w = width
-		this.h = height
+		this._x = x
+		this._y = y
+		this._w = width
+		this._h = height
 	}
 
 	getBounds() {
-		return new Box(this.x, this.y, this.w, this.h)
+		return new Box(this._x, this._y, this._w, this._h)
 	}
 
 	getSvgPathData(): string {
-		const { x, y, w, h } = this
-		return `M${x},${y} h${w} v${h} h-${w}z`
+		const { _x: x, _y: y, _w: w, _h: h } = this
+		this.negativeZeroFix()
+		return `M${x},${y} h${w} v${h} h${-w}z`
 	}
+
+	private negativeZeroFix() {
+		this._x = zeroFix(this._x)
+		this._y = zeroFix(this._y)
+		this._w = zeroFix(this._w)
+		this._h = zeroFix(this._h)
+	}
+}
+
+function zeroFix(value: number) {
+	if (Object.is(value, -0)) return 0
+	return value
 }

package/src/lib/primitives/geometry/Stadium2d.ts

@@ -7,13 +7,12 @@ import { Geometry2d, Geometry2dOptions } from './Geometry2d'
 
 /** @public */
 export class Stadium2d extends Geometry2d {
-	w: number
-	h: number
-
-	a: Arc2d
-	b: Edge2d
-	c: Arc2d
-	d: Edge2d
+	private _w: number
+	private _h: number
+	private _a: Arc2d
+	private _b: Edge2d
+	private _c: Arc2d
+	private _d: Edge2d
 
 	constructor(
 		public config: Omit<Geometry2dOptions, 'isClosed'> & {
@@ -23,45 +22,45 @@ export class Stadium2d extends Geometry2d {
 	) {
 		super({ ...config, isClosed: true })
 		const { width: w, height: h } = config
-		this.w = w
-		this.h = h
+		this._w = w
+		this._h = h
 
 		if (h > w) {
 			const r = w / 2
-			this.a = new Arc2d({
+			this._a = new Arc2d({
 				start: new Vec(0, r),
 				end: new Vec(w, r),
 				center: new Vec(w / 2, r),
 				sweepFlag: 1,
 				largeArcFlag: 1,
 			})
-			this.b = new Edge2d({ start: new Vec(w, r), end: new Vec(w, h - r) })
-			this.c = new Arc2d({
+			this._b = new Edge2d({ start: new Vec(w, r), end: new Vec(w, h - r) })
+			this._c = new Arc2d({
 				start: new Vec(w, h - r),
 				end: new Vec(0, h - r),
 				center: new Vec(w / 2, h - r),
 				sweepFlag: 1,
 				largeArcFlag: 1,
 			})
-			this.d = new Edge2d({ start: new Vec(0, h - r), end: new Vec(0, r) })
+			this._d = new Edge2d({ start: new Vec(0, h - r), end: new Vec(0, r) })
 		} else {
 			const r = h / 2
-			this.a = new Arc2d({
+			this._a = new Arc2d({
 				start: new Vec(r, h),
 				end: new Vec(r, 0),
 				center: new Vec(r, r),
 				sweepFlag: 1,
 				largeArcFlag: 1,
 			})
-			this.b = new Edge2d({ start: new Vec(r, 0), end: new Vec(w - r, 0) })
-			this.c = new Arc2d({
+			this._b = new Edge2d({ start: new Vec(r, 0), end: new Vec(w - r, 0) })
+			this._c = new Arc2d({
 				start: new Vec(w - r, 0),
 				end: new Vec(w - r, h),
 				center: new Vec(w - r, r),
 				sweepFlag: 1,
 				largeArcFlag: 1,
 			})
-			this.d = new Edge2d({ start: new Vec(w - r, h), end: new Vec(r, h) })
+			this._d = new Edge2d({ start: new Vec(w - r, h), end: new Vec(r, h) })
 		}
 	}
 
@@ -71,7 +70,7 @@ export class Stadium2d extends Geometry2d {
 		let _d: number
 		let p: Vec
 
-		const { a, b, c, d } = this
+		const { _a: a, _b: b, _c: c, _d: d } = this
 		for (const part of [a, b, c, d]) {
 			p = part.nearestPoint(A)
 			_d = Vec.Dist2(p, A)
@@ -85,12 +84,12 @@ export class Stadium2d extends Geometry2d {
 	}
 
 	hitTestLineSegment(A: VecLike, B: VecLike): boolean {
-		const { a, b, c, d } = this
+		const { _a: a, _b: b, _c: c, _d: d } = this
 		return [a, b, c, d].some((edge) => edge.hitTestLineSegment(A, B))
 	}
 
 	getVertices() {
-		const { a, b, c, d } = this
+		const { _a: a, _b: b, _c: c, _d: d } = this
 		return [a, b, c, d].reduce<Vec[]>((a, p) => {
 			a.push(...p.vertices)
 			return a
@@ -98,17 +97,17 @@ export class Stadium2d extends Geometry2d {
 	}
 
 	getBounds() {
-		return new Box(0, 0, this.w, this.h)
+		return new Box(0, 0, this._w, this._h)
 	}
 
 	getLength() {
-		const { h, w } = this
+		const { _h: h, _w: w } = this
 		if (h > w) return (PI * (w / 2) + (h - w)) * 2
 		else return (PI * (h / 2) + (w - h)) * 2
 	}
 
 	getSvgPathData() {
-		const { a, b, c, d } = this
+		const { _a: a, _b: b, _c: c, _d: d } = this
 		return [a, b, c, d].map((p, i) => p.getSvgPathData(i === 0)).join(' ') + ' Z'
 	}
 }

package/src/lib/utils/areShapesContentEqual.ts

@@ -1,4 +1,5 @@
 import { TLShape } from '@tldraw/tlschema'
 
+/** @public */
 export const areShapesContentEqual = (a: TLShape, b: TLShape) =>
-	a.props === b.props && a.meta === b.meta
+	a.parentId === b.parentId && a.props === b.props && a.meta === b.meta

package/src/version.ts

@@ -1,9 +1,9 @@
 // This file is automatically generated by internal/scripts/refresh-assets.ts.
 // Do not edit manually. Or do, I'm a comment, not a cop.
 
-export const version = '3.14.0-canary.8d29afff2d04'
+export const version = '3.14.0-canary.8ea0ff8489db'
 export const publishDates = {
 	major: '2024-09-13T14:36:29.063Z',
-	minor: '2025-05-27T13:18:08.385Z',
-	patch: '2025-05-27T13:18:08.385Z',
+	minor: '2025-06-04T10:57:28.152Z',
+	patch: '2025-06-04T10:57:28.152Z',
 }