curvy 0.3.1 → 0.3.3

package/dist/curve.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const invariant = require('tiny-invariant');
-const axis = require('./axis.cjs');
+const axis = require('./shared/curvy.db103082.cjs');
 const util = require('./shared/curvy.262f6070.cjs');
 const splines = require('./splines.cjs');
 
@@ -67,42 +67,193 @@ function createIntervalTree(boundaries) {
   };
 }
 
+function collectPointsOfInterest(axis) {
+  const samples = new Set(Array.from({ length: 33 }, (_, i) => i / 32));
+  const segmentToNormalized = 1 / axis.segments.length;
+  for (const [index, segment] of axis.segments.entries()) {
+    samples.add(index * segmentToNormalized);
+    samples.add((index + 1) * segmentToNormalized);
+    for (const t of segment.extrema) {
+      samples.add((index + t) * segmentToNormalized);
+    }
+    for (const root of segment.roots) {
+      samples.add((index + root) * segmentToNormalized);
+    }
+    for (const root of segment.derivative.roots) {
+      samples.add((index + root) * segmentToNormalized);
+    }
+  }
+  return Array.from(samples).sort((a, b) => a - b);
+}
+function takeLinearIntegral(x1, x2, y1, y2) {
+  const m = (y2 - y1) / (x2 - x1);
+  const b = y1 - m * x1;
+  const s1 = x1 ** 2 * m / 2 + b * x1;
+  const s2 = x2 ** 2 * m / 2 + b * x2;
+  return Math.abs(s2 - s1);
+}
+function takePolynomialIntegral(coefficients, start, end) {
+  let s1 = 0;
+  let s2 = 0;
+  for (let i = 0; i < coefficients.length; i++) {
+    const power = coefficients.length - i;
+    s1 += coefficients[i] * start ** power / power;
+    s2 += coefficients[i] * end ** power / power;
+  }
+  return Math.abs(s2 - s1);
+}
+function* createAxisSampler(key, axis$1) {
+  const queue = collectPointsOfInterest(axis$1);
+  let totalLength = 0;
+  const lengthLookup = /* @__PURE__ */ new Map();
+  while (queue.length > 0) {
+    const current = queue[0];
+    const next = queue[1];
+    if (next === void 0) {
+      yield current;
+      lengthLookup.set(totalLength, current);
+      break;
+    }
+    const segment = axis$1.segments[Math.floor(current * axis$1.segments.length)];
+    const currentPosition = axis$1.solvePosition(current);
+    const nextPosition = axis$1.solvePosition(next);
+    const currentVelocity = axis$1.solveVelocity(current);
+    const nextVelocity = axis$1.solveVelocity(next);
+    const lutPositionIntegral = takeLinearIntegral(
+      current,
+      next,
+      currentPosition,
+      nextPosition
+    );
+    const curvePositionIntegral = takePolynomialIntegral(
+      axis.computeCubicAntiderivative(segment.coefficients, 0),
+      current,
+      next
+    );
+    const lutVelocityIntegral = takeLinearIntegral(
+      current,
+      next,
+      currentVelocity,
+      nextVelocity
+    );
+    const curveVelocityIntegral = takePolynomialIntegral(
+      segment.derivative.coefficients,
+      current,
+      next
+    );
+    const error = Math.max(
+      Math.abs(lutPositionIntegral - curvePositionIntegral),
+      Math.abs(lutVelocityIntegral - curveVelocityIntegral)
+    );
+    if (error > 1) {
+      queue.splice(1, 0, (current + next) / 2);
+    } else {
+      yield current;
+      lengthLookup.set(totalLength, current);
+      totalLength += Math.hypot(current - next, currentPosition - nextPosition);
+      queue.shift();
+    }
+  }
+  return [
+    key,
+    {
+      length: totalLength,
+      lookup: lengthLookup
+    }
+  ];
+}
 function distance(a, b) {
-  const keys = Object.keys(a);
-  const deltas = keys.map((key) => a[key] - b[key]);
+  const deltas = [];
+  for (const key of Object.keys(a)) {
+    deltas.push(a[key] - b[key]);
+  }
   return Math.hypot(...deltas);
 }
-function createLengthLookup(positionAt) {
-  const count = 512;
-  const orderedSamples = Array.from({ length: count + 1 }, (_, i) => i / count);
+function createSampleBuffer() {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    get size() {
+      return values.size;
+    },
+    add(key, value) {
+      if (!values.has(key)) {
+        values.set(key, /* @__PURE__ */ new Set());
+      }
+      values.get(key)?.add(value);
+    },
+    get(key) {
+      return values.get(key);
+    },
+    remove(key, value) {
+      values.get(key)?.delete(value);
+      if (values.get(key)?.size === 0) {
+        values.delete(key);
+      }
+    },
+    keys() {
+      return Array.from(values.keys());
+    }
+  };
+}
+function createLengthLookup({
+  length: totalLength,
+  lookup
+}) {
+  const { search } = createIntervalTree(Array.from(lookup.keys()));
+  return (normalized) => {
+    invariant__default(normalized >= 0 && normalized <= 1, "Length out of bounds");
+    const length = normalized * totalLength;
+    const result = search(length);
+    invariant__default(result, "Length not found");
+    return util.remap(
+      length,
+      result[0],
+      result[1],
+      lookup.get(result[0]),
+      lookup.get(result[1])
+    );
+  };
+}
+function createCurveLengthLookups(axes, positionAt) {
   const lengthLookup = /* @__PURE__ */ new Map();
+  const axesLookups = {};
+  const sampleBuffer = createSampleBuffer();
+  for (const [key, axis] of Object.entries(axes)) {
+    const sampler = createAxisSampler(key, axis);
+    const first = sampler.next();
+    if (first.done) {
+      axesLookups[first.value[0]] = createLengthLookup(first.value[1]);
+    } else {
+      sampleBuffer.add(first.value, sampler);
+    }
+  }
   let lastPoint = positionAt(0);
   let length = 0;
   lengthLookup.set(0, 0);
-  for (const t of orderedSamples.slice(1)) {
+  while (sampleBuffer.size > 0) {
+    const t = Math.min(...sampleBuffer.keys());
     const point = positionAt(t);
     length = length + distance(lastPoint, point);
     lengthLookup.set(length, t);
     lastPoint = point;
+    const samplers = sampleBuffer.get(t);
+    for (const sampler of samplers) {
+      const next = sampler.next();
+      if (next.done) {
+        axesLookups[next.value[0]] = createLengthLookup(next.value[1]);
+      } else {
+        sampleBuffer.add(next.value, sampler);
+      }
+      sampleBuffer.remove(t, sampler);
+    }
   }
-  const totalLength = length;
-  const { search } = createIntervalTree(Array.from(lengthLookup.keys()));
-  return (normalized) => {
-    invariant__default(normalized >= 0 && normalized <= 1, "Length out of bounds");
-    const length2 = normalized * totalLength;
-    const result = search(length2);
-    invariant__default(result, "Length not found");
-    return util.remap(
-      length2,
-      result[0],
-      result[1],
-      lengthLookup.get(result[0]),
-      lengthLookup.get(result[1])
-    );
+  return {
+    curve: createLengthLookup({ length, lookup: lengthLookup }),
+    axes: axesLookups
   };
 }
 
-function createCurve(points, spline) {
+function convertPointsToAxes(points, spline) {
   const axisKeys = Object.keys(points[0]);
   const axisPoints = {};
   for (const key of axisKeys) {
@@ -118,6 +269,10 @@ function createCurve(points, spline) {
   for (const key of axisKeys) {
     axes[key] = axis.createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
   }
+  return axes;
+}
+function createCurve(axes) {
+  const axisKeys = Object.keys(axes);
   const solveT = (t, precision = 12) => {
     const rounded = util.round(t);
     invariant__default(
@@ -130,7 +285,7 @@ function createCurve(points, spline) {
     }
     return position;
   };
-  const lengthLookup = createLengthLookup(solveT);
+  const lengthLookups = createCurveLengthLookups(axes, solveT);
   const positionAt = (input, normalize = 1, precision = 12) => {
     invariant__default(
       input >= 0 && input <= 1,
@@ -138,7 +293,23 @@ function createCurve(points, spline) {
     );
     let t = input;
     if (normalize > 0) {
-      const denormalizedT = lengthLookup(input);
+      const denormalizedT = lengthLookups.curve(input);
+      if (normalize === 1) {
+        t = denormalizedT;
+      } else {
+        t = (1 - normalize) * input + normalize * denormalizedT;
+      }
+    }
+    return solveT(t, precision);
+  };
+  const solveAlong = (axis, input, normalize = 1, precision = 12) => {
+    invariant__default(
+      input >= 0 && input <= 1,
+      `Input must be between 0 and 1, got ${input}`
+    );
+    let t = input;
+    if (normalize > 0) {
+      const denormalizedT = lengthLookups.axes[axis](input);
       if (normalize === 1) {
         t = denormalizedT;
       } else {
@@ -155,38 +326,40 @@ function createCurve(points, spline) {
       typeof t === "number",
       `Could not solve for ${axis} = ${position}`
     );
-    const result = { [axis]: util.round(position, precision) };
-    for (const key of axisKeys) {
-      if (key !== axis) {
-        result[key] = util.round(axes[key].solvePosition(t), precision);
-      }
-    }
-    return result;
+    return positionAt(t, 0, precision);
   };
   return {
     axes,
     positionAt,
+    solveAlong,
     solveWhere
   };
 }
 function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(points, splines.splines.basis(triplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.splines.basis(triplicateEndpoints))
+  );
 }
 function createBezierCurve(points) {
-  return createCurve(points, splines.splines.bezier);
+  return createCurve(convertPointsToAxes(points, splines.splines.bezier));
 }
 function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(points, splines.splines.cardinal(tension, duplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.splines.cardinal(tension, duplicateEndpoints))
+  );
 }
 function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(points, splines.splines.catmullRom(duplicateEndpoints));
+  return createCurve(
+    convertPointsToAxes(points, splines.splines.catmullRom(duplicateEndpoints))
+  );
 }
 function createHermiteCurve(points) {
-  return createCurve(points, splines.splines.hermite);
+  return createCurve(convertPointsToAxes(points, splines.splines.hermite));
 }
 
 exports.createBasisCurve = createBasisCurve;
 exports.createBezierCurve = createBezierCurve;
 exports.createCardinalCurve = createCardinalCurve;
 exports.createCatmullRomCurve = createCatmullRomCurve;
+exports.createCurve = createCurve;
 exports.createHermiteCurve = createHermiteCurve;

package/dist/curve.d.cts

@@ -1,5 +1,5 @@
 import { CurveAxis } from './axis.cjs';
-import './shared/curvy.0f1371d7.cjs';
+import './shared/curvy.df73166c.cjs';
 
 type Point<Axis extends string | number> = Readonly<{
     [A in Axis]: number;
@@ -7,12 +7,14 @@ type Point<Axis extends string | number> = Readonly<{
 type Curve<Axis extends string | number> = {
     readonly axes: Readonly<Record<Axis, CurveAxis>>;
     readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+    readonly solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
 };
+declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<Axis>;
 declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
 declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 
-export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createCurve, createHermiteCurve };

package/dist/curve.d.mts

@@ -1,5 +1,5 @@
 import { CurveAxis } from './axis.mjs';
-import './shared/curvy.0f1371d7.mjs';
+import './shared/curvy.df73166c.mjs';
 
 type Point<Axis extends string | number> = Readonly<{
     [A in Axis]: number;
@@ -7,12 +7,14 @@ type Point<Axis extends string | number> = Readonly<{
 type Curve<Axis extends string | number> = {
     readonly axes: Readonly<Record<Axis, CurveAxis>>;
     readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+    readonly solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
 };
+declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<Axis>;
 declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
 declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 
-export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createCurve, createHermiteCurve };

package/dist/curve.d.ts

@@ -1,5 +1,5 @@
 import { CurveAxis } from './axis.js';
-import './shared/curvy.0f1371d7.js';
+import './shared/curvy.df73166c.js';
 
 type Point<Axis extends string | number> = Readonly<{
     [A in Axis]: number;
@@ -7,12 +7,14 @@ type Point<Axis extends string | number> = Readonly<{
 type Curve<Axis extends string | number> = {
     readonly axes: Readonly<Record<Axis, CurveAxis>>;
     readonly positionAt: (input: number, normalize?: number, precision?: number) => Point<Axis>;
-    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precsiion?: number) => Point<Axis>;
+    readonly solveAlong: <SolveAxis extends Axis>(axis: SolveAxis, input: number, normalize?: number, precision?: number) => Point<Axis>;
+    readonly solveWhere: <SolveAxis extends Axis>(axis: SolveAxis, position: number, precision?: number) => Point<Axis>;
 };
+declare function createCurve<Axis extends string | number>(axes: Record<Axis, CurveAxis>): Curve<Axis>;
 declare function createBasisCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, triplicateEndpoints?: boolean): Curve<Axis>;
 declare function createBezierCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 declare function createCardinalCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, tension?: number, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createCatmullRomCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>, duplicateEndpoints?: boolean): Curve<Axis>;
 declare function createHermiteCurve<Axis extends string | number>(points: ReadonlyArray<Point<Axis>>): Curve<Axis>;
 
-export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };
+export { type Curve, type Point, createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createCurve, createHermiteCurve };