curvy 0.1.1 → 0.3.2

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,38 @@
+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/splines.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+const invariant = require('tiny-invariant');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const invariant__default = /*#__PURE__*/_interopDefaultCompat(invariant);
+
+function chunkPointsBy(values, stride) {
+  const chunks = [];
+  invariant__default(values.length >= 4, "Values must have at least 4 elements");
+  invariant__default(
+    stride === 1 || stride === 2 || stride === 3,
+    "Stride must be 1, 2, or 3"
+  );
+  if (stride === 3) {
+    invariant__default(
+      values.length % stride === 1,
+      "Values length must be a multiple of 3 plus 1"
+    );
+  } else {
+    invariant__default(
+      values.length % stride === 0,
+      `Values length must be a multiple of ${stride}`
+    );
+  }
+  for (let i = 0; i <= values.length - 4; i += stride) {
+    chunks.push([
+      values[i],
+      values[i + 1],
+      values[i + 2],
+      values[i + 3]
+    ]);
+  }
+  return chunks;
+}
+function pointsToCoefficients(matrix, parameters) {
+  return [
+    parameters[0] * matrix[0][0] + parameters[1] * matrix[0][1] + parameters[2] * matrix[0][2] + parameters[3] * matrix[0][3],
+    parameters[0] * matrix[1][0] + parameters[1] * matrix[1][1] + parameters[2] * matrix[1][2] + parameters[3] * matrix[1][3],
+    parameters[0] * matrix[2][0] + parameters[1] * matrix[2][1] + parameters[2] * matrix[2][2] + parameters[3] * matrix[2][3],
+    parameters[0] * matrix[3][0] + parameters[1] * matrix[3][1] + parameters[2] * matrix[3][2] + parameters[3] * matrix[3][3]
+  ];
+}
+const bezier = {
+  matrix: [
+    [-1, 3, -3, 1],
+    [3, -6, 3, 0],
+    [-3, 3, 0, 0],
+    [1, 0, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(parameters, 3)) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+};
+const hermite = {
+  matrix: [
+    [2, 1, -2, 1],
+    [-3, -2, 3, -1],
+    [0, 1, 0, 0],
+    [1, 0, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(parameters, 2)) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+};
+const cardinal = (a, duplicateEndpoints = true) => ({
+  matrix: [
+    [-a, 2 - a, a - 2, a],
+    [2 * a, a - 3, 3 - 2 * a, -a],
+    [-a, 0, a, 0],
+    [0, 1, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      duplicateEndpoints ? [parameters[0], ...parameters, parameters[parameters.length - 1]] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const catmullRom = (duplicateEndpoints = true) => ({
+  matrix: [
+    [-0.5, 1.5, -1.5, 0.5],
+    [1, -2.5, 2, -0.5],
+    [-0.5, 0, 0.5, 0],
+    [0, 1, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      duplicateEndpoints ? [parameters[0], ...parameters, parameters[parameters.length - 1]] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const ONE_SIXTH = 1 / 6;
+const basis = (triplicateEndpoints = true) => ({
+  matrix: [
+    [-ONE_SIXTH, 0.5, -0.5, ONE_SIXTH],
+    [0.5, -1, 0.5, 0],
+    [-0.5, 0, 0.5, 0],
+    [ONE_SIXTH, 4 * ONE_SIXTH, ONE_SIXTH, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      triplicateEndpoints ? [
+        parameters[0],
+        parameters[0],
+        ...parameters,
+        parameters[parameters.length - 1],
+        parameters[parameters.length - 1]
+      ] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const splines = {
+  basis,
+  bezier,
+  cardinal,
+  catmullRom,
+  hermite
+};
+
+exports.basis = basis;
+exports.bezier = bezier;
+exports.cardinal = cardinal;
+exports.catmullRom = catmullRom;
+exports.hermite = hermite;
+exports.pointsToCoefficients = pointsToCoefficients;
+exports.splines = splines;

package/dist/splines.d.cts

@@ -0,0 +1,27 @@
+import { a as CubicCoefficients } from './shared/curvy.df73166c.cjs';
+
+type Matrix4x4 = readonly [
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients
+];
+type Spline = {
+    matrix: Matrix4x4;
+    chunkCoefficients: (parameters: ReadonlyArray<number>) => ReadonlyArray<CubicCoefficients>;
+};
+declare function pointsToCoefficients(matrix: Matrix4x4, parameters: CubicCoefficients): CubicCoefficients;
+declare const bezier: Spline;
+declare const hermite: Spline;
+declare const cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+declare const catmullRom: (duplicateEndpoints?: boolean) => Spline;
+declare const basis: (triplicateEndpoints?: boolean) => Spline;
+declare const splines: {
+    readonly basis: (triplicateEndpoints?: boolean) => Spline;
+    readonly bezier: Spline;
+    readonly cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+    readonly catmullRom: (duplicateEndpoints?: boolean) => Spline;
+    readonly hermite: Spline;
+};
+
+export { type Matrix4x4, type Spline, basis, bezier, cardinal, catmullRom, hermite, pointsToCoefficients, splines };

package/dist/splines.d.mts

@@ -0,0 +1,27 @@
+import { a as CubicCoefficients } from './shared/curvy.df73166c.mjs';
+
+type Matrix4x4 = readonly [
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients
+];
+type Spline = {
+    matrix: Matrix4x4;
+    chunkCoefficients: (parameters: ReadonlyArray<number>) => ReadonlyArray<CubicCoefficients>;
+};
+declare function pointsToCoefficients(matrix: Matrix4x4, parameters: CubicCoefficients): CubicCoefficients;
+declare const bezier: Spline;
+declare const hermite: Spline;
+declare const cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+declare const catmullRom: (duplicateEndpoints?: boolean) => Spline;
+declare const basis: (triplicateEndpoints?: boolean) => Spline;
+declare const splines: {
+    readonly basis: (triplicateEndpoints?: boolean) => Spline;
+    readonly bezier: Spline;
+    readonly cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+    readonly catmullRom: (duplicateEndpoints?: boolean) => Spline;
+    readonly hermite: Spline;
+};
+
+export { type Matrix4x4, type Spline, basis, bezier, cardinal, catmullRom, hermite, pointsToCoefficients, splines };

package/dist/splines.d.ts

@@ -0,0 +1,27 @@
+import { a as CubicCoefficients } from './shared/curvy.df73166c.js';
+
+type Matrix4x4 = readonly [
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients,
+    CubicCoefficients
+];
+type Spline = {
+    matrix: Matrix4x4;
+    chunkCoefficients: (parameters: ReadonlyArray<number>) => ReadonlyArray<CubicCoefficients>;
+};
+declare function pointsToCoefficients(matrix: Matrix4x4, parameters: CubicCoefficients): CubicCoefficients;
+declare const bezier: Spline;
+declare const hermite: Spline;
+declare const cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+declare const catmullRom: (duplicateEndpoints?: boolean) => Spline;
+declare const basis: (triplicateEndpoints?: boolean) => Spline;
+declare const splines: {
+    readonly basis: (triplicateEndpoints?: boolean) => Spline;
+    readonly bezier: Spline;
+    readonly cardinal: (a: number, duplicateEndpoints?: boolean) => Spline;
+    readonly catmullRom: (duplicateEndpoints?: boolean) => Spline;
+    readonly hermite: Spline;
+};
+
+export { type Matrix4x4, type Spline, basis, bezier, cardinal, catmullRom, hermite, pointsToCoefficients, splines };

package/dist/splines.mjs

@@ -0,0 +1,138 @@
+import invariant from 'tiny-invariant';
+
+function chunkPointsBy(values, stride) {
+  const chunks = [];
+  invariant(values.length >= 4, "Values must have at least 4 elements");
+  invariant(
+    stride === 1 || stride === 2 || stride === 3,
+    "Stride must be 1, 2, or 3"
+  );
+  if (stride === 3) {
+    invariant(
+      values.length % stride === 1,
+      "Values length must be a multiple of 3 plus 1"
+    );
+  } else {
+    invariant(
+      values.length % stride === 0,
+      `Values length must be a multiple of ${stride}`
+    );
+  }
+  for (let i = 0; i <= values.length - 4; i += stride) {
+    chunks.push([
+      values[i],
+      values[i + 1],
+      values[i + 2],
+      values[i + 3]
+    ]);
+  }
+  return chunks;
+}
+function pointsToCoefficients(matrix, parameters) {
+  return [
+    parameters[0] * matrix[0][0] + parameters[1] * matrix[0][1] + parameters[2] * matrix[0][2] + parameters[3] * matrix[0][3],
+    parameters[0] * matrix[1][0] + parameters[1] * matrix[1][1] + parameters[2] * matrix[1][2] + parameters[3] * matrix[1][3],
+    parameters[0] * matrix[2][0] + parameters[1] * matrix[2][1] + parameters[2] * matrix[2][2] + parameters[3] * matrix[2][3],
+    parameters[0] * matrix[3][0] + parameters[1] * matrix[3][1] + parameters[2] * matrix[3][2] + parameters[3] * matrix[3][3]
+  ];
+}
+const bezier = {
+  matrix: [
+    [-1, 3, -3, 1],
+    [3, -6, 3, 0],
+    [-3, 3, 0, 0],
+    [1, 0, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(parameters, 3)) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+};
+const hermite = {
+  matrix: [
+    [2, 1, -2, 1],
+    [-3, -2, 3, -1],
+    [0, 1, 0, 0],
+    [1, 0, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(parameters, 2)) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+};
+const cardinal = (a, duplicateEndpoints = true) => ({
+  matrix: [
+    [-a, 2 - a, a - 2, a],
+    [2 * a, a - 3, 3 - 2 * a, -a],
+    [-a, 0, a, 0],
+    [0, 1, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      duplicateEndpoints ? [parameters[0], ...parameters, parameters[parameters.length - 1]] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const catmullRom = (duplicateEndpoints = true) => ({
+  matrix: [
+    [-0.5, 1.5, -1.5, 0.5],
+    [1, -2.5, 2, -0.5],
+    [-0.5, 0, 0.5, 0],
+    [0, 1, 0, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      duplicateEndpoints ? [parameters[0], ...parameters, parameters[parameters.length - 1]] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const ONE_SIXTH = 1 / 6;
+const basis = (triplicateEndpoints = true) => ({
+  matrix: [
+    [-ONE_SIXTH, 0.5, -0.5, ONE_SIXTH],
+    [0.5, -1, 0.5, 0],
+    [-0.5, 0, 0.5, 0],
+    [ONE_SIXTH, 4 * ONE_SIXTH, ONE_SIXTH, 0]
+  ],
+  chunkCoefficients(parameters) {
+    const coefficients = [];
+    for (const chunk of chunkPointsBy(
+      triplicateEndpoints ? [
+        parameters[0],
+        parameters[0],
+        ...parameters,
+        parameters[parameters.length - 1],
+        parameters[parameters.length - 1]
+      ] : parameters,
+      1
+    )) {
+      coefficients.push(pointsToCoefficients(this.matrix, chunk));
+    }
+    return coefficients;
+  }
+});
+const splines = {
+  basis,
+  bezier,
+  cardinal,
+  catmullRom,
+  hermite
+};
+
+export { basis, bezier, cardinal, catmullRom, hermite, pointsToCoefficients, splines };

package/package.json

@@ -1,25 +1,38 @@
 {
   "name": "curvy",
-  "version": "0.1.1",
+  "version": "0.3.2",
   "description": "Spline and Curve utilities",
   "author": "Tim Morris <timthewebguy@gmail.com>",
   "homepage": "https://github.com/tkofh/curvy#readme",
   "license": "MIT",
   "sideEffects": false,
   "type": "module",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/curve.cjs",
+  "module": "./dist/curve.mjs",
+  "types": "./dist/curve.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.mjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/curve.cjs",
+      "import": "./dist/curve.mjs",
+      "types": "./dist/curve.d.ts"
+    },
+    "./axis": {
+      "require": "./dist/axis.cjs",
+      "import": "./dist/axis.mjs",
+      "types": "./dist/axis.d.ts"
+    },
+    "./convert": {
+      "require": "./dist/convert.cjs",
+      "import": "./dist/convert.mjs",
+      "types": "./dist/convert.d.ts"
+    },
+    "./splines": {
+      "require": "./dist/splines.cjs",
+      "import": "./dist/splines.mjs",
+      "types": "./dist/splines.d.ts"
     }
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "publishConfig": {
     "access": "public"
   },
@@ -45,6 +58,5 @@
   },
   "dependencies": {
     "tiny-invariant": "^1.3.3"
-  },
-  "gitHead": "d2a3088660eb3cadd190c1c6c48ae7757cea9433"
+  }
 }

package/LICENSE.md

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Tim Morris
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.