@altpsyche/maths 0.2.1 → 0.4.0

package/dist/values/interval.js

@@ -0,0 +1,66 @@
+/**
+ * A run of numbers from one bound to the other, and the arithmetic that reads
+ * one against another.
+ *
+ * This is what a graph's own units are given in, and what a figure's units are
+ * given in, so mapping a value from a graph onto a picture is one interval read
+ * against another rather than four loose numbers passed around together.
+ *
+ * A bound above its partner is allowed everywhere here. An axis that counts down
+ * the screen and a scale that reverses a direction are both an interval given
+ * the other way round, and neither is a mistake to be corrected.
+ */
+import { clamp, lerp, remap as remapNumber } from './scalar.js';
+function makeInterval(from, to) {
+    return { from, to };
+}
+/** How far the interval reaches, without a sign, so an interval given either way
+ * round reports the same width. */
+function span(interval) {
+    return Math.abs(interval.to - interval.from);
+}
+/** Both bounds counting as inside, whichever way round they were given. */
+function holds(interval, value) {
+    const low = Math.min(interval.from, interval.to);
+    const high = Math.max(interval.from, interval.to);
+    return value >= low && value <= high;
+}
+/** The same two bounds with the lower one first, for anything that has to walk
+ * from one end to the other and would otherwise step backwards. */
+function ordered(interval) {
+    return interval.from <= interval.to ? interval : { from: interval.to, to: interval.from };
+}
+/** A fraction of the way along, and past either bound when the fraction is
+ * outside zero to one. */
+function at(interval, along) {
+    return lerp(interval.from, interval.to, along);
+}
+/** Held inside the two bounds, whichever way round they were given. */
+function clampTo(interval, value) {
+    return clamp(value, interval.from, interval.to);
+}
+/**
+ * The place a value holds in one interval, read at the same place in another.
+ *
+ * A source of no width has no place to read, so this hands back the target's
+ * first bound rather than an infinity that then spreads through every coordinate
+ * built on it.
+ */
+function remap(value, source, target) {
+    return remapNumber(value, source.from, source.to, target.from, target.to);
+}
+/**
+ * The interval calls under one name, so a call site says which kind of thing it
+ * is reading and an import line says what these operate on.
+ *
+ * The width is not called `length`: a function's own `length` is how many
+ * arguments it takes, it is not writable, and assigning one throws.
+ */
+export const interval = Object.assign(makeInterval, {
+    span,
+    holds,
+    ordered,
+    at,
+    clampTo,
+    remap,
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altpsyche/maths",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "The mathematics AltPsyche's figures are drawn from: vectors, matrices, curves, and a value walked over time.",
   "license": "MIT",
   "author": "Siva",
@@ -36,6 +36,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
     "test": "vitest run",
+    "demos": "tsc -p tsconfig.demos.json && node .demos/demos/write.js",
     "type-check": "tsc --noEmit -p tsconfig.json",
     "prepack": "npm run build"
   },