curvy 0.3.2 → 1.0.0

package/dist/curve.cjs

@@ -1,194 +0,0 @@
-'use strict';
-
-const invariant = require('tiny-invariant');
-const axis = require('./axis.cjs');
-const util = require('./shared/curvy.262f6070.cjs');
-const splines = require('./splines.cjs');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const invariant__default = /*#__PURE__*/_interopDefaultCompat(invariant);
-
-function createNode(interval) {
-  return {
-    interval,
-    left: null,
-    right: null
-  };
-}
-function takeCenterInterval(boundaries) {
-  const mid = Math.floor((boundaries.length - 1) / 2);
-  const left = mid > 0 ? boundaries.slice(0, mid + 1) : null;
-  const right = mid + 1 < boundaries.length - 1 ? boundaries.slice(mid + 1) : null;
-  return {
-    center: [boundaries[mid], boundaries[mid + 1]],
-    left,
-    right
-  };
-}
-function createIntervalTree(boundaries) {
-  const container = createNode([0, 0]);
-  const branches = [{ parent: container, direction: "left", boundaries }];
-  for (const branch of branches) {
-    const { parent, direction, boundaries: boundaries2 } = branch;
-    const { center, left, right } = takeCenterInterval(boundaries2);
-    const node = createNode(center);
-    if (direction === "left") {
-      parent.left = node;
-    } else {
-      parent.right = node;
-    }
-    if (left !== null) {
-      branches.push({ parent: node, direction: "left", boundaries: left });
-    }
-    if (right !== null) {
-      branches.push({ parent: node, direction: "right", boundaries: right });
-    }
-  }
-  const root = container.left;
-  function searchNode(node, query) {
-    if (node.interval[0] <= query && node.interval[1] >= query) {
-      return node.interval;
-    }
-    if (node.interval[0] > query && node.left) {
-      return searchNode(node.left, query);
-    }
-    if (node.interval[1] < query && node.right) {
-      return searchNode(node.right, query);
-    }
-    return null;
-  }
-  function search(query) {
-    return searchNode(root, query);
-  }
-  return {
-    root,
-    search
-  };
-}
-
-function distance(a, b) {
-  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);
-  const lengthLookup = /* @__PURE__ */ new Map();
-  let lastPoint = positionAt(0);
-  let length = 0;
-  lengthLookup.set(0, 0);
-  for (const t of orderedSamples.slice(1)) {
-    const point = positionAt(t);
-    length = length + distance(lastPoint, point);
-    lengthLookup.set(length, t);
-    lastPoint = point;
-  }
-  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])
-    );
-  };
-}
-
-function createCurve(points, spline) {
-  const axisKeys = Object.keys(points[0]);
-  const axisPoints = {};
-  for (const key of axisKeys) {
-    axisPoints[key] = [];
-  }
-  for (const point of points) {
-    for (const key of axisKeys) {
-      invariant__default(key in point, `Point ${point} is missing axis "${key}"`);
-      axisPoints[key].push(point[key]);
-    }
-  }
-  const axes = {};
-  for (const key of axisKeys) {
-    axes[key] = axis.createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
-  }
-  const solveT = (t, precision = 12) => {
-    const rounded = util.round(t);
-    invariant__default(
-      rounded >= 0 && rounded <= 1,
-      `t must be between 0 and 1, got ${rounded}`
-    );
-    const position = {};
-    for (const key of axisKeys) {
-      position[key] = util.round(axes[key].solvePosition(rounded), precision);
-    }
-    return position;
-  };
-  const lengthLookup = createLengthLookup(solveT);
-  const positionAt = (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 = lengthLookup(input);
-      if (normalize === 1) {
-        t = denormalizedT;
-      } else {
-        t = (1 - normalize) * input + normalize * denormalizedT;
-      }
-    }
-    return solveT(t, precision);
-  };
-  const solveWhere = (axis, position, precision = 12) => {
-    const curveAxis = axes[axis];
-    invariant__default(curveAxis.monotonicity !== "none", "Axis is not monotonic");
-    const t = curveAxis.solveT(position, curveAxis.domain)[0];
-    invariant__default(
-      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 {
-    axes,
-    positionAt,
-    solveWhere
-  };
-}
-function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(points, splines.splines.basis(triplicateEndpoints));
-}
-function createBezierCurve(points) {
-  return createCurve(points, splines.splines.bezier);
-}
-function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(points, splines.splines.cardinal(tension, duplicateEndpoints));
-}
-function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(points, splines.splines.catmullRom(duplicateEndpoints));
-}
-function createHermiteCurve(points) {
-  return createCurve(points, splines.splines.hermite);
-}
-
-exports.createBasisCurve = createBasisCurve;
-exports.createBezierCurve = createBezierCurve;
-exports.createCardinalCurve = createCardinalCurve;
-exports.createCatmullRomCurve = createCatmullRomCurve;
-exports.createHermiteCurve = createHermiteCurve;

package/dist/curve.d.cts

@@ -1,18 +0,0 @@
-import { CurveAxis } from './axis.cjs';
-import './shared/curvy.df73166c.cjs';
-
-type Point<Axis extends string | number> = Readonly<{
-    [A in Axis]: number;
-}>;
-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, precision?: number) => Point<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 };

package/dist/curve.d.mts

@@ -1,18 +0,0 @@
-import { CurveAxis } from './axis.mjs';
-import './shared/curvy.df73166c.mjs';
-
-type Point<Axis extends string | number> = Readonly<{
-    [A in Axis]: number;
-}>;
-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, precision?: number) => Point<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 };

package/dist/curve.d.ts

@@ -1,18 +0,0 @@
-import { CurveAxis } from './axis.js';
-import './shared/curvy.df73166c.js';
-
-type Point<Axis extends string | number> = Readonly<{
-    [A in Axis]: number;
-}>;
-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, precision?: number) => Point<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 };

package/dist/curve.mjs

@@ -1,184 +0,0 @@
-import invariant from 'tiny-invariant';
-import { createCurveAxis } from './axis.mjs';
-import { r as remap, a as round } from './shared/curvy.9cd8b44c.mjs';
-import { splines } from './splines.mjs';
-
-function createNode(interval) {
-  return {
-    interval,
-    left: null,
-    right: null
-  };
-}
-function takeCenterInterval(boundaries) {
-  const mid = Math.floor((boundaries.length - 1) / 2);
-  const left = mid > 0 ? boundaries.slice(0, mid + 1) : null;
-  const right = mid + 1 < boundaries.length - 1 ? boundaries.slice(mid + 1) : null;
-  return {
-    center: [boundaries[mid], boundaries[mid + 1]],
-    left,
-    right
-  };
-}
-function createIntervalTree(boundaries) {
-  const container = createNode([0, 0]);
-  const branches = [{ parent: container, direction: "left", boundaries }];
-  for (const branch of branches) {
-    const { parent, direction, boundaries: boundaries2 } = branch;
-    const { center, left, right } = takeCenterInterval(boundaries2);
-    const node = createNode(center);
-    if (direction === "left") {
-      parent.left = node;
-    } else {
-      parent.right = node;
-    }
-    if (left !== null) {
-      branches.push({ parent: node, direction: "left", boundaries: left });
-    }
-    if (right !== null) {
-      branches.push({ parent: node, direction: "right", boundaries: right });
-    }
-  }
-  const root = container.left;
-  function searchNode(node, query) {
-    if (node.interval[0] <= query && node.interval[1] >= query) {
-      return node.interval;
-    }
-    if (node.interval[0] > query && node.left) {
-      return searchNode(node.left, query);
-    }
-    if (node.interval[1] < query && node.right) {
-      return searchNode(node.right, query);
-    }
-    return null;
-  }
-  function search(query) {
-    return searchNode(root, query);
-  }
-  return {
-    root,
-    search
-  };
-}
-
-function distance(a, b) {
-  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);
-  const lengthLookup = /* @__PURE__ */ new Map();
-  let lastPoint = positionAt(0);
-  let length = 0;
-  lengthLookup.set(0, 0);
-  for (const t of orderedSamples.slice(1)) {
-    const point = positionAt(t);
-    length = length + distance(lastPoint, point);
-    lengthLookup.set(length, t);
-    lastPoint = point;
-  }
-  const totalLength = length;
-  const { search } = createIntervalTree(Array.from(lengthLookup.keys()));
-  return (normalized) => {
-    invariant(normalized >= 0 && normalized <= 1, "Length out of bounds");
-    const length2 = normalized * totalLength;
-    const result = search(length2);
-    invariant(result, "Length not found");
-    return remap(
-      length2,
-      result[0],
-      result[1],
-      lengthLookup.get(result[0]),
-      lengthLookup.get(result[1])
-    );
-  };
-}
-
-function createCurve(points, spline) {
-  const axisKeys = Object.keys(points[0]);
-  const axisPoints = {};
-  for (const key of axisKeys) {
-    axisPoints[key] = [];
-  }
-  for (const point of points) {
-    for (const key of axisKeys) {
-      invariant(key in point, `Point ${point} is missing axis "${key}"`);
-      axisPoints[key].push(point[key]);
-    }
-  }
-  const axes = {};
-  for (const key of axisKeys) {
-    axes[key] = createCurveAxis(spline.chunkCoefficients(axisPoints[key]));
-  }
-  const solveT = (t, precision = 12) => {
-    const rounded = round(t);
-    invariant(
-      rounded >= 0 && rounded <= 1,
-      `t must be between 0 and 1, got ${rounded}`
-    );
-    const position = {};
-    for (const key of axisKeys) {
-      position[key] = round(axes[key].solvePosition(rounded), precision);
-    }
-    return position;
-  };
-  const lengthLookup = createLengthLookup(solveT);
-  const positionAt = (input, normalize = 1, precision = 12) => {
-    invariant(
-      input >= 0 && input <= 1,
-      `Input must be between 0 and 1, got ${input}`
-    );
-    let t = input;
-    if (normalize > 0) {
-      const denormalizedT = lengthLookup(input);
-      if (normalize === 1) {
-        t = denormalizedT;
-      } else {
-        t = (1 - normalize) * input + normalize * denormalizedT;
-      }
-    }
-    return solveT(t, precision);
-  };
-  const solveWhere = (axis, position, precision = 12) => {
-    const curveAxis = axes[axis];
-    invariant(curveAxis.monotonicity !== "none", "Axis is not monotonic");
-    const t = curveAxis.solveT(position, curveAxis.domain)[0];
-    invariant(
-      typeof t === "number",
-      `Could not solve for ${axis} = ${position}`
-    );
-    const result = { [axis]: round(position, precision) };
-    for (const key of axisKeys) {
-      if (key !== axis) {
-        result[key] = round(axes[key].solvePosition(t), precision);
-      }
-    }
-    return result;
-  };
-  return {
-    axes,
-    positionAt,
-    solveWhere
-  };
-}
-function createBasisCurve(points, triplicateEndpoints = true) {
-  return createCurve(points, splines.basis(triplicateEndpoints));
-}
-function createBezierCurve(points) {
-  return createCurve(points, splines.bezier);
-}
-function createCardinalCurve(points, tension = 0.5, duplicateEndpoints = true) {
-  return createCurve(points, splines.cardinal(tension, duplicateEndpoints));
-}
-function createCatmullRomCurve(points, duplicateEndpoints = true) {
-  return createCurve(points, splines.catmullRom(duplicateEndpoints));
-}
-function createHermiteCurve(points) {
-  return createCurve(points, splines.hermite);
-}
-
-export { createBasisCurve, createBezierCurve, createCardinalCurve, createCatmullRomCurve, createHermiteCurve };

package/dist/shared/curvy.262f6070.cjs

@@ -1,16 +0,0 @@
-'use strict';
-
-function round(value, precision = 12) {
-  const scale = 10 ** precision;
-  const result = Math.round(value * scale) / scale;
-  if (result === 0) {
-    return 0;
-  }
-  return result;
-}
-function remap(x, x1, x2, y1, y2) {
-  return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
-}
-
-exports.remap = remap;
-exports.round = round;

package/dist/shared/curvy.9cd8b44c.mjs

@@ -1,13 +0,0 @@
-function round(value, precision = 12) {
-  const scale = 10 ** precision;
-  const result = Math.round(value * scale) / scale;
-  if (result === 0) {
-    return 0;
-  }
-  return result;
-}
-function remap(x, x1, x2, y1, y2) {
-  return y1 + (x - x1) / (x2 - x1) * (y2 - y1);
-}
-
-export { round as a, remap as r };

package/dist/shared/curvy.df73166c.d.cts

@@ -1,38 +0,0 @@
-type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
-type Interval = readonly [number, number];
-type LinearCoefficients = readonly [number, number];
-type LinearPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: LinearCoefficients;
-    readonly root: number | null;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number) => number;
-};
-type QuadraticCoefficients = readonly [number, number, number];
-type QuadraticPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: QuadraticCoefficients;
-    readonly extreme: number | null;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: LinearPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-type CubicCoefficients = readonly [number, number, number, number];
-type CubicPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: CubicCoefficients;
-    readonly extrema: ReadonlyArray<number>;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: QuadraticPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-
-export type { CubicPolynomial as C, Interval as I, Monotonicity as M, CubicCoefficients as a };

package/dist/shared/curvy.df73166c.d.mts

@@ -1,38 +0,0 @@
-type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
-type Interval = readonly [number, number];
-type LinearCoefficients = readonly [number, number];
-type LinearPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: LinearCoefficients;
-    readonly root: number | null;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number) => number;
-};
-type QuadraticCoefficients = readonly [number, number, number];
-type QuadraticPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: QuadraticCoefficients;
-    readonly extreme: number | null;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: LinearPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-type CubicCoefficients = readonly [number, number, number, number];
-type CubicPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: CubicCoefficients;
-    readonly extrema: ReadonlyArray<number>;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: QuadraticPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-
-export type { CubicPolynomial as C, Interval as I, Monotonicity as M, CubicCoefficients as a };

package/dist/shared/curvy.df73166c.d.ts

@@ -1,38 +0,0 @@
-type Monotonicity = 'none' | 'increasing' | 'decreasing' | 'constant';
-type Interval = readonly [number, number];
-type LinearCoefficients = readonly [number, number];
-type LinearPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: LinearCoefficients;
-    readonly root: number | null;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number) => number;
-};
-type QuadraticCoefficients = readonly [number, number, number];
-type QuadraticPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: QuadraticCoefficients;
-    readonly extreme: number | null;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: LinearPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-type CubicCoefficients = readonly [number, number, number, number];
-type CubicPolynomial = {
-    readonly domain: Interval;
-    readonly range: Interval;
-    readonly monotonicity: Monotonicity;
-    readonly coefficients: CubicCoefficients;
-    readonly extrema: ReadonlyArray<number>;
-    readonly roots: ReadonlyArray<number>;
-    readonly derivative: QuadraticPolynomial;
-    readonly solve: (x: number) => number;
-    readonly solveInverse: (y: number, domain?: Interval) => ReadonlyArray<number>;
-};
-
-export type { CubicPolynomial as C, Interval as I, Monotonicity as M, CubicCoefficients as a };