curvy 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/splines/index.mjs

@@ -1,14 +1,14 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
 import { epsEquals } from "../number.mjs";
-import { a as makeWeighted, i as make$10, o as scale, s as subtract, t as add } from "../shared/vector2-CL1HDdPr.mjs";
-import { t as make$11 } from "../shared/vector3-D-tv_aKL.mjs";
-import { n as transpose, t as make$12 } from "../shared/vector4-5KbjoHVj.mjs";
+import { a as make$10, c as subtract, i as magnitude, o as makeWeighted, r as isVector2, s as scale, t as add } from "../shared/vector2-CCuJx1rX.mjs";
+import { t as make$11 } from "../shared/vector3-C-qgKAjR.mjs";
+import { n as transpose, t as make$12 } from "../shared/vector4-BhOKDhD5.mjs";
 import { a as vectorProductLeft, i as multiply, t as inverse } from "../shared/matrix4x4-Ck2WROK-.mjs";
-import { o as none, s as one } from "../shared/solution-CrtLfqEq.mjs";
-import { n as fromBezierPoints, s as fromPolynomials } from "../shared/rationalCubic2d-Bys2Uory.mjs";
-import { a as cubicCardinal, i as cubicBezier, o as cubicHermite, r as cubicBasisSpline, t as apply } from "../shared/characteristic-B9nCh_cx.mjs";
-import { i as make$13, t as fromArray$10 } from "../shared/rationalCubic2d-BEgUGSFf.mjs";
+import { o as none, s as one } from "../shared/solution-3TDATEMn.mjs";
+import { c as fromPolynomials, n as fromBezierPoints, s as fromCoefficients } from "../shared/rationalCubic2d-D658ltUM.mjs";
+import { a as cubicHermite, i as cubicBezier, r as cubicBasisSpline, t as apply } from "../shared/characteristic-DLlhja-I.mjs";
+import { i as make$13, t as fromArray$10 } from "../shared/rationalCubic2d-Vw4qGPZj.mjs";
 //#region src/splines/rationalBezier2d.internal.ts
 const RationalBezier2dTypeId = Symbol("curvy/splines/rationalBezier2d");
 var RationalBezier2dImpl = class extends Pipeable {
@@ -33,6 +33,7 @@ const make$9 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
 	lift(p3)
 ]);
 const fromArray$9 = (points) => new RationalBezier2dImpl(points.map(lift));
+const fromTuples$9 = (tuples) => new RationalBezier2dImpl(tuples.map(([x, y, weight]) => make$11(x * weight, y * weight, weight)));
 const fromPoints$1 = (p0, p1, p2, p3) => new RationalBezier2dImpl([
 	make$11(p0.x, p0.y, 1),
 	make$11(p1.x, p1.y, 1),
@@ -197,6 +198,7 @@ const make$8 = (p0, p1, p2, p3) => new Bezier2dImpl([
 	p3
 ]);
 const fromArray$8 = (points) => new Bezier2dImpl(points);
+const fromTuples$8 = (tuples) => new Bezier2dImpl(tuples.map(([x, y]) => make$10(x, y)));
 const append$7 = dual(4, (p, p1, p2, p3) => new Bezier2dImpl((p instanceof Bezier2dImpl ? p.points : Array.from(p)).concat(p1, p2, p3)));
 const fromBasis = (p, matrix, stride) => {
 	const conversion = getConversionMatrix(matrix);
@@ -291,6 +293,7 @@ var bezier2d_exports = /* @__PURE__ */ __exportAll({
 	appendVelocityAligned: () => appendVelocityAligned,
 	fromArray: () => fromArray$7,
 	fromRational: () => fromRational,
+	fromTuples: () => fromTuples$7,
 	isCubicBezier2d: () => isCubicBezier2d,
 	make: () => make$7,
 	subdivide: () => subdivide$1,
@@ -316,6 +319,15 @@ const make$7 = make$8;
 */
 const fromArray$7 = fromArray$8;
 /**
+* Creates a new `Bezier2d` from an array of `[x, y]` tuples. Convenient for
+* data sourced from JSON, CSV, or other tuple-shaped formats.
+*
+* @param tuples - The control points as `[x, y]` tuples.
+* @returns A new `Bezier2d` instance.
+* @since 2.0.0
+*/
+const fromTuples$7 = fromTuples$8;
+/**
 * Checks if a value is a `Bezier2d`.
 *
 * @param p - The value to check.
@@ -346,38 +358,61 @@ const toPath$7 = toPath$8;
 *
 * @param r - The rational bezier to convert.
 * @returns Either a `Bezier2d` instance or `Solution.none`.
-* @since 2.1.0
+* @since 2.0.0
 */
 const fromRational = fromRational$1;
 const subdivide$1 = subdivide$2;
 //#endregion
 //#region src/splines/cardinal2d.internal.ts
 const Cardinal2dTypeId = Symbol.for("curvy/splines/cardinal2d");
+const DEFAULT_TENSION = .5;
+const DEFAULT_ALPHA = .5;
 var Cardinal2dImpl = class extends Pipeable {
 	[Cardinal2dTypeId] = Cardinal2dTypeId;
 	points;
-	constructor(points) {
+	tension;
+	alpha;
+	constructor(points, tension, alpha) {
 		invariant(points.length >= 2, "cardinal splines requires 2 or more points");
 		super();
 		this.points = points;
+		this.tension = tension;
+		this.alpha = alpha;
 	}
 	[Symbol.iterator]() {
 		return this.points[Symbol.iterator]();
 	}
 };
 const isCardinal2d$1 = (p) => typeof p === "object" && p !== null && Cardinal2dTypeId in p;
-const make$6 = (...points) => new Cardinal2dImpl(points);
-const fromArray$6 = (points) => new Cardinal2dImpl(points);
-const append$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...p, ...points]));
-const prepend$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...points, ...p]));
+const resolveOptions = (options) => ({
+	tension: options?.tension ?? DEFAULT_TENSION,
+	alpha: options?.alpha ?? DEFAULT_ALPHA
+});
+const make$6 = (...args) => {
+	if (isVector2(args[0])) return new Cardinal2dImpl(args, DEFAULT_TENSION, DEFAULT_ALPHA);
+	const [options, ...points] = args;
+	const { tension, alpha } = resolveOptions(options);
+	return new Cardinal2dImpl(points, tension, alpha);
+};
+const fromArray$6 = (points, options) => {
+	const { tension, alpha } = resolveOptions(options);
+	return new Cardinal2dImpl(points, tension, alpha);
+};
+const fromTuples$6 = (tuples, options) => {
+	const { tension, alpha } = resolveOptions(options);
+	return new Cardinal2dImpl(tuples.map(([x, y]) => make$10(x, y)), tension, alpha);
+};
+const append$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...p, ...points], p.tension, p.alpha));
+const prepend$5 = dual((args) => isCardinal2d$1(args[0]), (p, ...points) => new Cardinal2dImpl([...points, ...p], p.tension, p.alpha));
 const withDuplicatedEndpoints$1 = (p) => {
 	const points = p instanceof Cardinal2dImpl ? p.points : [...p];
 	return new Cardinal2dImpl([
 		points[0],
 		...points,
 		points[points.length - 1]
-	]);
+	], p.tension, p.alpha);
 };
+const withInterpolatedEndpoints$1 = (p) => withDuplicatedEndpoints$1(p);
 const withReflectedEndpoints$1 = dual((args) => isCardinal2d$1(args[0]), (p, scale$1 = 1) => {
 	if (scale$1 === 0) return withDuplicatedEndpoints$1(p);
 	const points = p instanceof Cardinal2dImpl ? p.points : [...p];
@@ -389,22 +424,72 @@ const withReflectedEndpoints$1 = dual((args) => isCardinal2d$1(args[0]), (p, sca
 		subtract(p1, p0).pipe(scale(scale$1), add(p0)),
 		...points,
 		subtract(p2, p3).pipe(scale(scale$1), add(p3))
-	]);
+	], p.tension, p.alpha);
 });
-const toPath$6 = dual((args) => isCardinal2d$1(args[0]), (p, scale = .5) => make$13(...toCurves(p, cubicCardinal(scale), 1)));
-const toBezier$5 = (p, scale = .5) => fromBasis(p, cubicCardinal(scale), 1);
+const withTension$1 = dual(2, (p, tension) => new Cardinal2dImpl(p.points, tension, p.alpha));
+const withAlpha$1 = dual(2, (p, alpha) => new Cardinal2dImpl(p.points, p.tension, alpha));
+const withOptions$1 = dual(2, (p, options) => new Cardinal2dImpl(p.points, options.tension ?? p.tension, options.alpha ?? p.alpha));
+const buildCardinalSegment = (p0, p1, p2, p3, tension, alpha) => {
+	const d01 = magnitude(subtract(p1, p0)) ** alpha;
+	const d12 = magnitude(subtract(p2, p1)) ** alpha;
+	const d23 = magnitude(subtract(p3, p2)) ** alpha;
+	invariant(Number.isFinite(d01) && Number.isFinite(d12) && Number.isFinite(d23), "cardinal: non-finite chord length");
+	const factor = 2 * tension;
+	const lead = d01 === 0 ? 0 : d12 / d01;
+	const trail = d23 === 0 ? 0 : d12 / d23;
+	const mid01 = d01 + d12 === 0 ? 0 : d12 / (d01 + d12);
+	const mid23 = d12 + d23 === 0 ? 0 : d12 / (d12 + d23);
+	const v1x = factor * ((p1.x - p0.x) * lead - (p2.x - p0.x) * mid01 + (p2.x - p1.x));
+	const v1y = factor * ((p1.y - p0.y) * lead - (p2.y - p0.y) * mid01 + (p2.y - p1.y));
+	const v2x = factor * (p2.x - p1.x - (p3.x - p1.x) * mid23 + (p3.x - p2.x) * trail);
+	const v2y = factor * (p2.y - p1.y - (p3.y - p1.y) * mid23 + (p3.y - p2.y) * trail);
+	const dx = p2.x - p1.x;
+	const dy = p2.y - p1.y;
+	return fromCoefficients(make$10(p1.x, p1.y), make$10(v1x, v1y), make$10(3 * dx - 2 * v1x - v2x, 3 * dy - 2 * v1y - v2y), make$10(-2 * dx + v1x + v2x, -2 * dy + v1y + v2y));
+};
+function* cardinalCurves(p) {
+	for (const [p0, p1, p2, p3] of toPointQuads(p, 1)) yield buildCardinalSegment(p0, p1, p2, p3, p.tension, p.alpha);
+}
+const toPath$6 = (p) => make$13(...cardinalCurves(p));
+const toBezier$5 = (p) => {
+	const points = [];
+	let first = true;
+	for (const curve of cardinalCurves(p)) {
+		const c0x = curve.x.c0;
+		const c0y = curve.y.c0;
+		const c1x = curve.x.c1;
+		const c1y = curve.y.c1;
+		const c2x = curve.x.c2;
+		const c2y = curve.y.c2;
+		const c3x = curve.x.c3;
+		const c3y = curve.y.c3;
+		if (first) {
+			points.push(make$10(c0x, c0y));
+			first = false;
+		}
+		points.push(make$10(c0x + c1x / 3, c0y + c1y / 3));
+		points.push(make$10(c0x + 2 * c1x / 3 + c2x / 3, c0y + 2 * c1y / 3 + c2y / 3));
+		points.push(make$10(c0x + c1x + c2x + c3x, c0y + c1y + c2y + c3y));
+	}
+	return fromArray$8(points);
+};
 //#endregion
 //#region src/splines/cardinal2d.ts
 var cardinal2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append$4,
 	fromArray: () => fromArray$5,
+	fromTuples: () => fromTuples$5,
 	isCardinal2d: () => isCardinal2d,
 	make: () => make$5,
 	prepend: () => prepend$4,
 	toBezier: () => toBezier$4,
 	toPath: () => toPath$5,
+	withAlpha: () => withAlpha,
 	withDuplicatedEndpoints: () => withDuplicatedEndpoints,
-	withReflectedEndpoints: () => withReflectedEndpoints
+	withInterpolatedEndpoints: () => withInterpolatedEndpoints,
+	withOptions: () => withOptions,
+	withReflectedEndpoints: () => withReflectedEndpoints,
+	withTension: () => withTension
 });
 /**
 * Checks if a value is a `Cardinal2d`.
@@ -414,36 +499,76 @@ var cardinal2d_exports = /* @__PURE__ */ __exportAll({
 * @since 1.0.0
 */
 const isCardinal2d = isCardinal2d$1;
+const make$5 = make$6;
 /**
-* Creates a new `Cardinal2d` instance.
+* Creates a new `Cardinal2d` from an array of control points.
 *
-* @param p0 - The first control point.
-* @param p1 - The second control point.
-* @param points - The remaining control points.
+* @param points - The control points.
+* @param options - Tension and alpha. See {@link Options}. Defaults to centripetal Catmull-Rom.
 * @returns A new `Cardinal2d` instance.
 * @since 1.0.0
 */
-const make$5 = make$6;
+const fromArray$5 = fromArray$6;
 /**
-* Creates a new `Cardinal2d` instance from an array of control points.
+* Creates a new `Cardinal2d` from an array of `[x, y]` tuples.
 *
-* @param points - The control points.
+* @param tuples - The control points as `[x, y]` tuples.
+* @param options - Tension and alpha. See {@link Options}. Defaults to centripetal Catmull-Rom.
 * @returns A new `Cardinal2d` instance.
-* @since 1.0.0
+* @since 2.0.0
 */
-const fromArray$5 = fromArray$6;
+const fromTuples$5 = fromTuples$6;
 const append$4 = append$5;
 const prepend$4 = prepend$5;
 /**
-* Doubles the endpoints of a `Cardinal2d` spline.
+* Doubles the endpoints of a `Cardinal2d` spline. Tension and alpha are
+* preserved.
 *
 * @param c - The `Cardinal2d` to duplicate the endpoints of.
-* @returns A new `Cardinal2d` instance with the duplicated endpoints.
+* @returns A new `Cardinal2d` instance with duplicated endpoints.
 * @since 1.0.0
 */
 const withDuplicatedEndpoints = withDuplicatedEndpoints$1;
+/**
+* Pads the spline so that it interpolates its first and last control points.
+* The resulting path passes through `points[0]` at `u = 0` and `points[points.length - 1]`
+* at `u = 1`. Equivalent to {@link withReflectedEndpoints} called with
+* `scale = 0` (and to {@link withDuplicatedEndpoints}), but reads more
+* directly as the user-facing intent.
+*
+* Tension and alpha are preserved.
+*
+* @param c - The `Cardinal2d` to pad.
+* @returns A new `Cardinal2d` instance whose first and last control points are interpolated.
+* @since 2.0.0
+*/
+const withInterpolatedEndpoints = withInterpolatedEndpoints$1;
 const withReflectedEndpoints = withReflectedEndpoints$1;
+const withTension = withTension$1;
+const withAlpha = withAlpha$1;
+const withOptions = withOptions$1;
+/**
+* Converts a `Cardinal2d` to a `CubicPath2d` using the spline's `tension` and
+* `alpha`. With the default options (`{ tension: 0.5, alpha: 0.5 }`) the
+* result is a centripetal Catmull-Rom path — the canonical recommended
+* Catmull-Rom variant, which avoids the cusps and self-intersections that
+* uniform Catmull-Rom can produce when control points cluster.
+*
+* @param c - The Cardinal spline.
+* @returns A new `CubicPath2d` representing the spline.
+* @since 1.0.0
+*/
 const toPath$5 = toPath$6;
+/**
+* Converts a `Cardinal2d` to a `Bezier2d`. Equivalent to {@link toPath}
+* followed by per-segment monomial-to-Bernstein conversion — same underlying
+* curve, expressed in cubic Bézier control-point form. Uses the spline's
+* `tension` and `alpha`.
+*
+* @param c - The Cardinal spline.
+* @returns A new `Bezier2d` representing the spline.
+* @since 1.0.0
+*/
 const toBezier$4 = toBezier$5;
 //#endregion
 //#region src/splines/hermite2d.internal.ts
@@ -469,6 +594,7 @@ const make$4 = (p0, v0, p1, v1) => new Hermite2dImpl([
 	v1
 ]);
 const fromArray$4 = (points) => new Hermite2dImpl(points);
+const fromTuples$4 = (tuples) => new Hermite2dImpl(tuples.map(([x, y]) => make$10(x, y)));
 const append$3 = dual(3, (p, p1, v1) => {
 	return new Hermite2dImpl((p instanceof Hermite2dImpl ? p.points : Array.from(p)).concat(p1, v1));
 });
@@ -483,6 +609,7 @@ const toBezier$3 = (p) => fromBasis(p, cubicHermite, 2);
 var hermite2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append$2,
 	fromArray: () => fromArray$3,
+	fromTuples: () => fromTuples$3,
 	isHermite2d: () => isHermite2d,
 	make: () => make$3,
 	prepend: () => prepend$2,
@@ -516,6 +643,15 @@ const make$3 = make$4;
 * @since 1.0.0
 */
 const fromArray$3 = fromArray$4;
+/**
+* Creates a new `Hermite2d` from an array of `[x, y]` tuples, alternating
+* `[position, velocity]` pairs.
+*
+* @param tuples - The point/velocity pairs as `[x, y]` tuples.
+* @returns A new `Hermite2d` instance.
+* @since 2.0.0
+*/
+const fromTuples$3 = fromTuples$4;
 const append$2 = append$3;
 const prepend$2 = prepend$3;
 /**
@@ -557,6 +693,7 @@ const make$2 = (p0, p1, p2, p3) => new Basis2dImpl([
 	p3
 ]);
 const fromArray$2 = (points) => new Basis2dImpl(points);
+const fromTuples$2 = (tuples) => new Basis2dImpl(tuples.map(([x, y]) => make$10(x, y)));
 const append$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...p, ...points]));
 const prepend$1 = dual((args) => isBasis2d$1(args[0]), (p, ...points) => new Basis2dImpl([...points, ...p]));
 const withTriplicatedEndpoints$1 = (p) => {
@@ -576,6 +713,7 @@ const toBezier$1 = (p) => fromBasis(p, cubicBasisSpline, 1);
 var basis2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append,
 	fromArray: () => fromArray$1,
+	fromTuples: () => fromTuples$1,
 	isBasis2d: () => isBasis2d,
 	make: () => make$1,
 	prepend: () => prepend,
@@ -610,6 +748,14 @@ const make$1 = make$2;
 * @since 1.0.0
 */
 const fromArray$1 = fromArray$2;
+/**
+* Creates a new `Basis2d` from an array of `[x, y]` tuples.
+*
+* @param tuples - The control points as `[x, y]` tuples.
+* @returns A new `Basis2d` instance.
+* @since 2.0.0
+*/
+const fromTuples$1 = fromTuples$2;
 const append = append$1;
 const prepend = prepend$1;
 /**
@@ -644,6 +790,7 @@ var rationalBezier2d_exports = /* @__PURE__ */ __exportAll({
 	fromArray: () => fromArray,
 	fromBezier: () => fromBezier,
 	fromPoints: () => fromPoints,
+	fromTuples: () => fromTuples,
 	isRationalBezier2d: () => isRationalBezier2d,
 	make: () => make,
 	subdivide: () => subdivide,
@@ -654,7 +801,7 @@ var rationalBezier2d_exports = /* @__PURE__ */ __exportAll({
 *
 * @param p - The value to check.
 * @returns `true` if the value is a `RationalBezier2d`, `false` otherwise.
-* @since 2.1.0
+* @since 2.0.0
 */
 const isRationalBezier2d = isRationalBezier2d$1;
 /**
@@ -669,7 +816,7 @@ const isRationalBezier2d = isRationalBezier2d$1;
 * @param p2 - The third weighted control point (end handle).
 * @param p3 - The fourth weighted control point (curve end).
 * @returns A new `RationalBezier2d` instance.
-* @since 2.1.0
+* @since 2.0.0
 */
 const make = make$9;
 /**
@@ -680,10 +827,21 @@ const make = make$9;
 *
 * @param points - The weighted control points.
 * @returns A new `RationalBezier2d` instance.
-* @since 2.1.0
+* @since 2.0.0
 */
 const fromArray = fromArray$9;
 /**
+* Creates a new `RationalBezier2d` from an array of `[x, y, weight]` tuples.
+* Weight is the projective denominator at each control point — `1` everywhere
+* yields the polynomial Bézier; varying weights bend the curve toward the
+* heavier control points.
+*
+* @param tuples - The weighted control points as `[x, y, weight]` tuples.
+* @returns A new `RationalBezier2d` instance.
+* @since 2.0.0
+*/
+const fromTuples = fromTuples$9;
+/**
 * Creates a new single-segment `RationalBezier2d` from four points with all
 * weights equal to one.
 *
@@ -698,7 +856,7 @@ const fromArray = fromArray$9;
 * @param p2 - The third control point (end handle).
 * @param p3 - The fourth control point (curve end).
 * @returns A new `RationalBezier2d` with unit weights.
-* @since 2.1.0
+* @since 2.0.0
 */
 const fromPoints = fromPoints$1;
 /**
@@ -707,7 +865,7 @@ const fromPoints = fromPoints$1;
 *
 * @param b - The non-rational bezier to lift.
 * @returns A new `RationalBezier2d` with unit weights.
-* @since 2.1.0
+* @since 2.0.0
 */
 const fromBezier = fromBezier$1;
 /**
@@ -724,7 +882,7 @@ const fromBezier = fromBezier$1;
 *
 * @param r - The rational bezier to convert.
 * @returns A new `RationalCubicPath2d` instance representing the same curve.
-* @since 2.1.0
+* @since 2.0.0
 */
 const toPath = toPath$9;
 const subdivide = subdivide$3;