curvy 2.0.0-alpha.13 → 2.0.0-alpha.14

package/dist/splines/cardinal2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Bezier2d } from './bezier2d.ts';
@@ -244,6 +245,83 @@ export declare const withOptions: {
      */
     (c: Cardinal2d, options: Options): Cardinal2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every control point in a `Cardinal2d`,
+     * preserving point count, tension, and alpha.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Cardinal2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Cardinal2d) => Cardinal2d;
+    /**
+     * Applies a per-point transform to every control point in a `Cardinal2d`.
+     *
+     * @param s - The cardinal spline.
+     * @param f - The point transform.
+     * @returns A new `Cardinal2d` with the transform applied to each control point.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, f: (p: Vector2) => Vector2): Cardinal2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Cardinal2d` as the result. The returned spline's tension and alpha come
+     * from the mapper's output, not the input — to preserve the input's
+     * parameterization, the mapper should re-supply it (e.g. by reading the
+     * original spline in the data-first form, or chaining `withOptions`
+     * afterward).
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Cardinal2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Cardinal2d): (s: Cardinal2d) => Cardinal2d;
+    /**
+     * Hands the spline's full control-point array to `f` and uses its returned
+     * `Cardinal2d` as the result.
+     *
+     * @param s - The cardinal spline.
+     * @param f - The bulk transform.
+     * @returns The `Cardinal2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, f: (points: ReadonlyArray<Vector2>) => Cardinal2d): Cardinal2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Cardinal2d`,
+     * preserving the spline's `tension` and `alpha`.
+     *
+     * **Exactness depends on parameterization.** With `alpha = 0` (uniform
+     * Catmull-Rom) the affine basis commutes exactly with evaluation, so the
+     * result parameterizes the affine image of the original curve. With
+     * `alpha != 0` (centripetal / chordal), chord lengths between control points
+     * drive the parameterization and a non-uniform-scaling transform changes
+     * those chord lengths in axis-dependent ways. In that case the returned
+     * curve is still a sensible Cardinal spline on the transformed control
+     * points, but it no longer matches the affine image of the original
+     * pointwise. For pixel-exact transforms of centripetal splines, convert to
+     * `Bezier2d` via {@link toBezier} first, then transform.
+     *
+     * @param s - The cardinal spline.
+     * @param a - The affine transform.
+     * @returns A new `Cardinal2d` whose control points are the affine images of
+     *   the input's, with the same parameterization.
+     * @since 2.0.0
+     */
+    (s: Cardinal2d, a: Affine2d): Cardinal2d;
+    /**
+     * Applies an `Affine2d` transform to every control point of a `Cardinal2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Cardinal2d` and returns the transformed spline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Cardinal2d) => Cardinal2d;
+};
 /**
  * Converts a `Cardinal2d` to a `CubicPath2d` using the spline's `tension` and
  * `alpha`. With the default options (`{ tension: 0.5, alpha: 0.5 }`) the

package/dist/splines/hermite2d.d.ts

@@ -1,4 +1,5 @@
 import type { CubicPath2d } from '../path/cubic2d.ts';
+import type { Affine2d } from '../transform/affine2d.ts';
 import type { Pipeable } from '../utils.ts';
 import type { Vector2 } from '../vector/vector2.ts';
 import type { Bezier2d } from './bezier2d.ts';
@@ -95,6 +96,81 @@ export declare const prepend: {
      */
     (p: Hermite2d, p0: Vector2, v0: Vector2): Hermite2d;
 };
+export declare const mapPoints: {
+    /**
+     * Applies a per-point transform to every entry in a `Hermite2d`, preserving
+     * the alternating position/velocity layout and total point count.
+     *
+     * The transform receives both positions and velocity vectors as plain
+     * `Vector2`s — Hermite splines store them in interleaved slots without a
+     * structural distinction. Linear transforms (rotation, scaling) act
+     * correctly on both slot kinds, but a uniform translation will offset the
+     * velocity slots as well as the positions; to translate positions only,
+     * reach for {@link flatMap} and split the array yourself.
+     *
+     * @param f - The point transform.
+     * @returns A function that takes a `Hermite2d` and returns the mapped spline.
+     * @since 2.0.0
+     */
+    (f: (p: Vector2) => Vector2): (s: Hermite2d) => Hermite2d;
+    /**
+     * Applies a per-point transform to every entry in a `Hermite2d`.
+     *
+     * @param s - The hermite spline.
+     * @param f - The point transform.
+     * @returns A new `Hermite2d` with the transform applied to each entry.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, f: (p: Vector2) => Vector2): Hermite2d;
+};
+export declare const flatMap: {
+    /**
+     * Hands the spline's full entry array to `f` (alternating positions and
+     * velocities) and uses its returned `Hermite2d` as the result. The returned
+     * spline goes through this module's builders, so the even-arity and
+     * minimum-4-entry invariants are enforced at construction.
+     *
+     * @param f - The bulk transform.
+     * @returns A function that takes a `Hermite2d` and returns the rebuilt spline.
+     * @since 2.0.0
+     */
+    (f: (points: ReadonlyArray<Vector2>) => Hermite2d): (s: Hermite2d) => Hermite2d;
+    /**
+     * Hands the spline's full entry array to `f` and uses its returned
+     * `Hermite2d` as the result.
+     *
+     * @param s - The hermite spline.
+     * @param f - The bulk transform.
+     * @returns The `Hermite2d` returned by `f`.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, f: (points: ReadonlyArray<Vector2>) => Hermite2d): Hermite2d;
+};
+export declare const transform: {
+    /**
+     * Applies an `Affine2d` transform to a `Hermite2d`, treating the entries
+     * correctly by kind: positions (even indices) receive the full affine, and
+     * tangent vectors (odd indices) receive only the linear part — translation
+     * doesn't move tangents, only the linear map does.
+     *
+     * The result exactly parameterizes the affine image of the original curve.
+     *
+     * @param s - The hermite spline.
+     * @param a - The affine transform.
+     * @returns A new `Hermite2d` with positions and tangents transformed
+     *   appropriately.
+     * @since 2.0.0
+     */
+    (s: Hermite2d, a: Affine2d): Hermite2d;
+    /**
+     * Applies an `Affine2d` transform to a `Hermite2d`.
+     *
+     * @param a - The affine transform.
+     * @returns A function that takes a `Hermite2d` and returns the transformed spline.
+     * @since 2.0.0
+     */
+    (a: Affine2d): (s: Hermite2d) => Hermite2d;
+};
 /**
  * Creates a new `CubicPath2d` instance from a `Hermite2d`.
  *

package/dist/splines/index.mjs

@@ -1,14 +1,15 @@
 import { t as __exportAll } from "../shared/chunk-25Hzd3z8.mjs";
 import { Pipeable, dual, invariant } from "../utils.mjs";
-import { epsEquals } from "../number.mjs";
-import { a as make$12, c as subtract, i as magnitude, o as makeWeighted, r as isVector2, s as scale, t as add } from "../shared/vector2-CSkaMXvp.mjs";
-import { t as make$13 } from "../shared/vector3-CR2LPV03.mjs";
-import { n as transpose, t as make$14 } from "../shared/vector4-PO_7EYd-.mjs";
-import { a as vectorProductLeft, i as multiply, t as inverse } from "../shared/matrix4x4-BWmf4lZM.mjs";
-import { o as none, s as one } from "../shared/solution-B2JdOZpe.mjs";
-import { S as fromEndpoints, c as fromCoefficients, l as fromPolynomials, r as fromBezierPoints } from "../shared/rationalCubic2d-CeHgpNht.mjs";
-import { a as cubicHermite, i as cubicBezier, r as cubicBasisSpline, t as apply } from "../shared/characteristic-BkEr-rr8.mjs";
-import { a as fromArray$13, i as make$15, t as fromArray$12 } from "../shared/rationalCubic2d-H1J2Fjyy.mjs";
+import { coincident } from "../number.mjs";
+import { a as magnitude, c as scale, i as liftWithWeight, l as subtract, o as make$12, r as isVector2, s as makeWeighted, t as add } from "../shared/vector2-DuA3EmfL.mjs";
+import { t as make$13 } from "../shared/vector3-oxtggkDp.mjs";
+import { n as transpose, t as make$14 } from "../shared/vector4-DGHuCvTV.mjs";
+import { c as one, s as none } from "../shared/solution-BW0BBMXI.mjs";
+import { a as vectorProductLeft, i as multiply, t as inverseUnsafe } from "../shared/matrix4x4-BrqgYZCD.mjs";
+import { l as fromCoefficients, r as fromBezierPoints, u as fromPolynomials, v as fromEndpoints } from "../shared/rationalCubic2d-CZSwwKtS.mjs";
+import { a as cubicHermite, i as cubicBezier, r as cubicBasisSpline, t as apply } from "../shared/characteristic--7nC4Q_a.mjs";
+import { a as fromArray$13, i as make$15, t as fromArray$12 } from "../shared/rationalCubic2d-bveuGqBZ.mjs";
+import { i as linearPart, n as apply$1, r as applyTo } from "../shared/affine2d-Dvna84gc.mjs";
 //#region src/splines/rationalBezier2d.internal.ts
 const RationalBezier2dTypeId = Symbol("curvy/splines/rationalBezier2d");
 var RationalBezier2dImpl = class extends Pipeable {
@@ -68,6 +69,17 @@ const toPath$11 = (r) => {
 	return fromArray$12(curves);
 };
 /** @internal */
+const mapPoints$11 = dual(2, (s, f) => {
+	const homogeneous = homogeneousOf(s);
+	const mapped = [];
+	for (const h of homogeneous) mapped.push(lift(f(makeWeighted(h.x / h.z, h.y / h.z, h.z))));
+	return new RationalBezier2dImpl(mapped);
+});
+/** @internal */
+const flatMap$11 = dual(2, (s, f) => f([...s]));
+/** @internal */
+const transform$11 = dual(2, (s, a) => mapPoints$11(s, liftWithWeight(applyTo(a))));
+/** @internal */
 const subdivide$3 = dual(2, (r, u) => {
 	invariant(u > 0 && u < 1, "subdivide parameter u must be in the open interval (0, 1)");
 	const homogeneous = homogeneousOf(r);
@@ -123,7 +135,7 @@ const toBezierPoints = (r) => {
 	const w0 = homogeneous[0].z;
 	const points = [];
 	for (const h of homogeneous) {
-		if (!epsEquals(h.z, w0)) return none;
+		if (!coincident(h.z, w0)) return none;
 		points.push(make$12(h.x / h.z, h.y / h.z));
 	}
 	return one(points);
@@ -175,7 +187,7 @@ function* toCurves(points, matrix, stride) {
 }
 //#endregion
 //#region src/splines/bezier2d.internal.ts
-const characteristicInverse = inverse(cubicBezier);
+const characteristicInverse = inverseUnsafe(cubicBezier);
 const conversionCache = /* @__PURE__ */ new WeakMap();
 const getConversionMatrix = (source) => {
 	let combined = conversionCache.get(source);
@@ -254,6 +266,14 @@ const appendAccelerationAligned$1 = dual(2, (p, p6) => {
 	return append$9(p, make$12(2 * p3.x - p2.x, 2 * p3.y - p2.y), make$12(p1.x + 4 * (p3.x - p2.x), p1.y + 4 * (p3.y - p2.y)), p6);
 });
 /** @internal */
+const mapPoints$10 = dual(2, (s, f) => {
+	return new Bezier2dImpl((s instanceof Bezier2dImpl ? s.points : [...s]).map(f));
+});
+/** @internal */
+const flatMap$10 = dual(2, (s, f) => f(s instanceof Bezier2dImpl ? s.points : [...s]));
+/** @internal */
+const transform$10 = dual(2, (s, a) => mapPoints$10(s, applyTo(a)));
+/** @internal */
 const toPath$10 = (p) => make$15(...toCurves(p, cubicBezier, 3));
 /** @internal */
 const fromRational$1 = (r) => {
@@ -313,13 +333,16 @@ var bezier2d_exports = /* @__PURE__ */ __exportAll({
 	appendCurvatureAligned: () => appendCurvatureAligned,
 	appendTangentAligned: () => appendTangentAligned,
 	appendVelocityAligned: () => appendVelocityAligned,
+	flatMap: () => flatMap$9,
 	fromArray: () => fromArray$9,
 	fromRational: () => fromRational,
 	fromTuples: () => fromTuples$9,
 	isCubicBezier2d: () => isCubicBezier2d,
 	make: () => make$9,
+	mapPoints: () => mapPoints$9,
 	subdivide: () => subdivide$1,
-	toPath: () => toPath$9
+	toPath: () => toPath$9,
+	transform: () => transform$9
 });
 /**
 * Creates a new `Bezier2d` instance.
@@ -362,6 +385,9 @@ const appendTangentAligned = appendTangentAligned$1;
 const appendCurvatureAligned = appendCurvatureAligned$1;
 const appendVelocityAligned = appendVelocityAligned$1;
 const appendAccelerationAligned = appendAccelerationAligned$1;
+const mapPoints$9 = mapPoints$10;
+const flatMap$9 = flatMap$10;
+const transform$9 = transform$10;
 /**
 * Converts a `Bezier2d` to a `CubicPath2d`.
 *
@@ -464,6 +490,14 @@ const withTension$1 = dual(2, (p, tension) => new Cardinal2dImpl(p.points, tensi
 const withAlpha$1 = dual(2, (p, alpha) => new Cardinal2dImpl(p.points, p.tension, alpha));
 /** @internal */
 const withOptions$1 = dual(2, (p, options) => new Cardinal2dImpl(p.points, options.tension ?? p.tension, options.alpha ?? p.alpha));
+/** @internal */
+const mapPoints$8 = dual(2, (s, f) => {
+	return new Cardinal2dImpl((s instanceof Cardinal2dImpl ? s.points : [...s]).map(f), s.tension, s.alpha);
+});
+/** @internal */
+const flatMap$8 = dual(2, (s, f) => f(s instanceof Cardinal2dImpl ? s.points : [...s]));
+/** @internal */
+const transform$8 = dual(2, (s, a) => mapPoints$8(s, applyTo(a)));
 const buildCardinalSegment = (p0, p1, p2, p3, tension, alpha) => {
 	const d01 = magnitude(subtract(p1, p0)) ** alpha;
 	const d12 = magnitude(subtract(p2, p1)) ** alpha;
@@ -514,13 +548,16 @@ const toBezier$5 = (p) => {
 //#region src/splines/cardinal2d.ts
 var cardinal2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append$6,
+	flatMap: () => flatMap$7,
 	fromArray: () => fromArray$7,
 	fromTuples: () => fromTuples$7,
 	isCardinal2d: () => isCardinal2d,
 	make: () => make$7,
+	mapPoints: () => mapPoints$7,
 	prepend: () => prepend$6,
 	toBezier: () => toBezier$4,
 	toPath: () => toPath$7,
+	transform: () => transform$7,
 	withAlpha: () => withAlpha,
 	withDuplicatedEndpoints: () => withDuplicatedEndpoints,
 	withInterpolatedEndpoints: () => withInterpolatedEndpoints,
@@ -584,6 +621,9 @@ const withReflectedEndpoints = withReflectedEndpoints$1;
 const withTension = withTension$1;
 const withAlpha = withAlpha$1;
 const withOptions = withOptions$1;
+const mapPoints$7 = mapPoints$8;
+const flatMap$7 = flatMap$8;
+const transform$7 = transform$8;
 /**
 * Converts a `Cardinal2d` to a `CubicPath2d` using the spline's `tension` and
 * `alpha`. With the default options (`{ tension: 0.5, alpha: 0.5 }`) the
@@ -646,6 +686,20 @@ const prepend$5 = dual(3, (p, p0, v0) => {
 	return new Hermite2dImpl([p0, v0].concat(points));
 });
 /** @internal */
+const mapPoints$6 = dual(2, (s, f) => {
+	return new Hermite2dImpl((s instanceof Hermite2dImpl ? s.points : [...s]).map(f));
+});
+/** @internal */
+const flatMap$6 = dual(2, (s, f) => f(s instanceof Hermite2dImpl ? s.points : [...s]));
+/** @internal */
+const transform$6 = dual(2, (s, a) => {
+	const points = s instanceof Hermite2dImpl ? s.points : [...s];
+	const linear = linearPart(a);
+	const next = Array.from({ length: points.length });
+	for (let i = 0; i < points.length; i++) next[i] = apply$1(i % 2 === 0 ? a : linear, points[i]);
+	return new Hermite2dImpl(next);
+});
+/** @internal */
 const toPath$6 = (p) => make$15(...toCurves(p, cubicHermite, 2));
 /** @internal */
 const toBezier$3 = (p) => fromBasis(p, cubicHermite, 2);
@@ -653,13 +707,16 @@ const toBezier$3 = (p) => fromBasis(p, cubicHermite, 2);
 //#region src/splines/hermite2d.ts
 var hermite2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append$4,
+	flatMap: () => flatMap$5,
 	fromArray: () => fromArray$5,
 	fromTuples: () => fromTuples$5,
 	isHermite2d: () => isHermite2d,
 	make: () => make$5,
+	mapPoints: () => mapPoints$5,
 	prepend: () => prepend$4,
 	toBezier: () => toBezier$2,
-	toPath: () => toPath$5
+	toPath: () => toPath$5,
+	transform: () => transform$5
 });
 /**
 * Checks if a value is a `Hermite2d`.
@@ -699,6 +756,9 @@ const fromArray$5 = fromArray$6;
 const fromTuples$5 = fromTuples$6;
 const append$4 = append$5;
 const prepend$4 = prepend$5;
+const mapPoints$5 = mapPoints$6;
+const flatMap$5 = flatMap$6;
+const transform$5 = transform$6;
 /**
 * Creates a new `CubicPath2d` instance from a `Hermite2d`.
 *
@@ -759,6 +819,14 @@ const withTriplicatedEndpoints$1 = (p) => {
 	]);
 };
 /** @internal */
+const mapPoints$4 = dual(2, (s, f) => {
+	return new Basis2dImpl((s instanceof Basis2dImpl ? s.points : [...s]).map(f));
+});
+/** @internal */
+const flatMap$4 = dual(2, (s, f) => f(s instanceof Basis2dImpl ? s.points : [...s]));
+/** @internal */
+const transform$4 = dual(2, (s, a) => mapPoints$4(s, applyTo(a)));
+/** @internal */
 const toPath$4 = (p) => make$15(...toCurves(p, cubicBasisSpline, 1));
 /** @internal */
 const toBezier$1 = (p) => fromBasis(p, cubicBasisSpline, 1);
@@ -766,13 +834,16 @@ const toBezier$1 = (p) => fromBasis(p, cubicBasisSpline, 1);
 //#region src/splines/basis2d.ts
 var basis2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append$2,
+	flatMap: () => flatMap$3,
 	fromArray: () => fromArray$3,
 	fromTuples: () => fromTuples$3,
 	isBasis2d: () => isBasis2d,
 	make: () => make$3,
+	mapPoints: () => mapPoints$3,
 	prepend: () => prepend$2,
 	toBezier: () => toBezier,
 	toPath: () => toPath$3,
+	transform: () => transform$3,
 	withTriplicatedEndpoints: () => withTriplicatedEndpoints
 });
 /**
@@ -812,6 +883,9 @@ const fromArray$3 = fromArray$4;
 const fromTuples$3 = fromTuples$4;
 const append$2 = append$3;
 const prepend$2 = prepend$3;
+const mapPoints$3 = mapPoints$4;
+const flatMap$3 = flatMap$4;
+const transform$3 = transform$4;
 /**
 * Triplicates the endpoints of a `Basis2d`.
 *
@@ -870,6 +944,14 @@ const append$1 = dual((args) => isLinear2d$1(args[0]), (p, ...points) => new Lin
 /** @internal */
 const prepend$1 = dual((args) => isLinear2d$1(args[0]), (p, ...points) => new Linear2dImpl([...points, ...p]));
 /** @internal */
+const mapPoints$2 = dual(2, (s, f) => {
+	return new Linear2dImpl((s instanceof Linear2dImpl ? s.points : [...s]).map(f));
+});
+/** @internal */
+const flatMap$2 = dual(2, (s, f) => f(s instanceof Linear2dImpl ? s.points : [...s]));
+/** @internal */
+const transform$2 = dual(2, (s, a) => mapPoints$2(s, applyTo(a)));
+/** @internal */
 const toPath$2 = (p) => {
 	const points = p instanceof Linear2dImpl ? p.points : [...p];
 	const segments = [];
@@ -880,12 +962,15 @@ const toPath$2 = (p) => {
 //#region src/splines/linear2d.ts
 var linear2d_exports = /* @__PURE__ */ __exportAll({
 	append: () => append,
+	flatMap: () => flatMap$1,
 	fromArray: () => fromArray$1,
 	fromTuples: () => fromTuples$1,
 	isLinear2d: () => isLinear2d,
 	make: () => make$1,
+	mapPoints: () => mapPoints$1,
 	prepend: () => prepend,
-	toPath: () => toPath$1
+	toPath: () => toPath$1,
+	transform: () => transform$1
 });
 /**
 * Checks if a value is a `Linear2d`.
@@ -925,6 +1010,9 @@ const fromArray$1 = fromArray$2;
 const fromTuples$1 = fromTuples$2;
 const append = append$1;
 const prepend = prepend$1;
+const mapPoints$1 = mapPoints$2;
+const flatMap$1 = flatMap$2;
+const transform$1 = transform$2;
 /**
 * Converts a `Linear2d` to a `LinearPath2d` by joining consecutive points
 * with straight segments. The result is unbranded; assert
@@ -939,14 +1027,17 @@ const toPath$1 = toPath$2;
 //#endregion
 //#region src/splines/rationalBezier2d.ts
 var rationalBezier2d_exports = /* @__PURE__ */ __exportAll({
+	flatMap: () => flatMap,
 	fromArray: () => fromArray,
 	fromBezier: () => fromBezier,
 	fromPoints: () => fromPoints,
 	fromTuples: () => fromTuples,
 	isRationalBezier2d: () => isRationalBezier2d,
 	make: () => make,
+	mapPoints: () => mapPoints,
 	subdivide: () => subdivide,
-	toPath: () => toPath
+	toPath: () => toPath,
+	transform: () => transform
 });
 /**
 * Checks if a value is a `RationalBezier2d`.
@@ -1037,6 +1128,9 @@ const fromBezier = fromBezier$1;
 * @since 2.0.0
 */
 const toPath = toPath$11;
+const mapPoints = mapPoints$11;
+const flatMap = flatMap$11;
+const transform = transform$11;
 const subdivide = subdivide$3;
 //#endregion
 export { basis2d_exports as Basis2d, bezier2d_exports as Bezier2d, cardinal2d_exports as Cardinal2d, hermite2d_exports as Hermite2d, linear2d_exports as Linear2d, rationalBezier2d_exports as RationalBezier2d };