@sarmal/core 0.9.0 → 0.9.7

package/dist/auto-init.cjs

@@ -1,8 +1,12 @@
-'use strict';
+"use strict";
 
 // src/engine.ts
 var TWO_PI = Math.PI * 2;
 var POINTS_PER_PERIOD_UNIT = 50;
+function lerp(start, end, t) {
+  return start + (end - start) * t;
+}
+var EMPTY_PARAMS = {};
 var CircularBuffer = class {
   constructor(capacity) {
     this.head = 0;
@@ -45,16 +49,29 @@ var CircularBuffer = class {
   }
 };
 function resolveCurve(curveDef) {
+  const period = curveDef.period ?? TWO_PI;
+  if (!Number.isFinite(period) || period <= 0) {
+    throw new RangeError(`[sarmal] period must be a positive finite number, got ${period}`);
+  }
+  const speed = curveDef.speed ?? 1;
+  if (!Number.isFinite(speed)) {
+    throw new RangeError(`[sarmal] speed must be a finite number, got ${speed}`);
+  }
   return {
     name: curveDef.name,
     fn: curveDef.fn,
-    period: curveDef.period ?? TWO_PI,
-    speed: curveDef.speed ?? 1,
+    period,
+    speed,
     skeleton: curveDef.skeleton,
-    skeletonFn: curveDef.skeletonFn
+    skeletonFn: curveDef.skeletonFn,
   };
 }
 function createEngine(curveDef, trailLength = 120) {
+  if (!Number.isFinite(trailLength) || trailLength <= 0) {
+    throw new RangeError(
+      `[sarmal] trailLength must be a positive finite number, got ${trailLength}`,
+    );
+  }
   let curve = resolveCurve(curveDef);
   const trail = new CircularBuffer(trailLength);
   let t = 0;
@@ -67,21 +84,25 @@ function createEngine(curveDef, trailLength = 120) {
       return c.skeletonFn(sampleT);
     }
     if (c.skeleton === "live") {
-      return c.fn(sampleT, actualTime, {});
+      return c.fn(sampleT, actualTime, EMPTY_PARAMS);
     }
-    return c.fn(sampleT, 0, {});
+    return c.fn(sampleT, 0, EMPTY_PARAMS);
   }
   return {
     tick(deltaTime) {
-      t = (t + curve.speed * deltaTime) % curve.period;
+      let effectiveSpeed = curve.speed;
+      if (morphCurveB !== null && _morphAlpha !== null) {
+        effectiveSpeed = lerp(curve.speed, morphCurveB.speed, _morphAlpha);
+      }
+      t = (t + effectiveSpeed * deltaTime) % curve.period;
       actualTime += deltaTime;
       if (morphCurveB !== null && _morphAlpha !== null) {
-        const a = curve.fn(t, actualTime, {});
-        const tB = _morphStrategy === "normalized" ? t / curve.period * morphCurveB.period : t;
-        const b = morphCurveB.fn(tB, actualTime, {});
+        const a = curve.fn(t, actualTime, EMPTY_PARAMS);
+        const tB = _morphStrategy === "normalized" ? (t / curve.period) * morphCurveB.period : t;
+        const b = morphCurveB.fn(tB, actualTime, EMPTY_PARAMS);
         trail.push(a.x + (b.x - a.x) * _morphAlpha, a.y + (b.y - a.y) * _morphAlpha);
       } else {
-        const point = curve.fn(t, actualTime, {});
+        const point = curve.fn(t, actualTime, EMPTY_PARAMS);
         trail.push(point.x, point.y);
       }
       return trail.toArray();
@@ -101,14 +122,14 @@ function createEngine(curveDef, trailLength = 120) {
       trail.clear();
     },
     seek(newT, { clearTrail = false } = {}) {
-      t = (newT % curve.period + curve.period) % curve.period;
+      t = ((newT % curve.period) + curve.period) % curve.period;
       if (clearTrail) {
         trail.clear();
       }
     },
     seekWithTrail(targetT, { wrap = false, step = curve.period / trailLength } = {}) {
       const advance = curve.speed * step;
-      const target = (targetT % curve.period + curve.period) % curve.period;
+      const target = ((targetT % curve.period) + curve.period) % curve.period;
       const targetTime = target / curve.speed;
       t = target;
       actualTime = targetTime;
@@ -117,9 +138,9 @@ function createEngine(curveDef, trailLength = 120) {
       const count = wrap ? trailLength : Math.min(trailLength, pointsFromStart);
       for (let i = count - 1; i >= 0; i--) {
         const sampleT = target - i * advance;
-        const wrappedT = sampleT < 0 ? sampleT + curve.period : sampleT;
+        const wrappedT = ((sampleT % curve.period) + curve.period) % curve.period;
         const time = targetTime - i * step;
-        const point = curve.fn(wrappedT, time, {});
+        const point = curve.fn(wrappedT, time, EMPTY_PARAMS);
         trail.push(point.x, point.y);
       }
     },
@@ -134,13 +155,16 @@ function createEngine(curveDef, trailLength = 120) {
           ...frozenB,
           fn: (sampleT, time, params) => {
             const a = frozenA.fn(sampleT, time, params);
-            const tB = frozenStrategy === "normalized" ? sampleT / frozenA.period * frozenB.period : sampleT;
+            const tB =
+              frozenStrategy === "normalized"
+                ? (sampleT / frozenA.period) * frozenB.period
+                : sampleT;
             const b = frozenB.fn(tB, time, params);
             return {
               x: a.x + (b.x - a.x) * frozenAlpha,
-              y: a.y + (b.y - a.y) * frozenAlpha
+              y: a.y + (b.y - a.y) * frozenAlpha,
             };
-          }
+          },
         };
       }
       _morphStrategy = strategy;
@@ -153,7 +177,7 @@ function createEngine(curveDef, trailLength = 120) {
     completeMorph() {
       if (morphCurveB !== null) {
         if (_morphStrategy === "normalized" && curve.period !== morphCurveB.period) {
-          t = t / curve.period * morphCurveB.period;
+          t = (t / curve.period) * morphCurveB.period;
         }
         curve = morphCurveB;
       }
@@ -165,23 +189,26 @@ function createEngine(curveDef, trailLength = 120) {
       const points = new Array(steps);
       if (morphCurveB !== null && _morphAlpha !== null) {
         for (let i = 0; i < steps; i++) {
-          const sampleT = i / (steps - 1) * curve.period;
+          const sampleT = (i / (steps - 1)) * curve.period;
           const a = sampleSkeleton(curve, sampleT);
-          const tB = _morphStrategy === "normalized" ? sampleT / curve.period * morphCurveB.period : sampleT;
+          const tB =
+            _morphStrategy === "normalized"
+              ? (sampleT / curve.period) * morphCurveB.period
+              : sampleT;
           const b = sampleSkeleton(morphCurveB, tB);
           points[i] = {
             x: a.x + (b.x - a.x) * _morphAlpha,
-            y: a.y + (b.y - a.y) * _morphAlpha
+            y: a.y + (b.y - a.y) * _morphAlpha,
           };
         }
         return points;
       }
       for (let i = 0; i < steps; i++) {
-        const sampleT = i / (steps - 1) * curve.period;
+        const sampleT = (i / (steps - 1)) * curve.period;
         points[i] = sampleSkeleton(curve, sampleT);
       }
       return points;
-    }
+    },
   };
 }
 
@@ -201,7 +228,7 @@ var GRADIENT = {
   ocean: ["#1e3a8a", "#06b6d4", "#22d3ee", "#e0f2fe"],
   ice: ["#1e3a8a", "#67e8f9"],
   fire: ["#7f1d1d", "#fbbf24"],
-  forest: ["#14532d", "#86efac"]
+  forest: ["#14532d", "#86efac"],
 };
 var PRESETS = {
   bard: GRADIENT.bard,
@@ -209,16 +236,16 @@ var PRESETS = {
   ocean: GRADIENT.ocean,
   ice: GRADIENT.ice,
   fire: GRADIENT.fire,
-  forest: GRADIENT.forest
+  forest: GRADIENT.forest,
 };
 function hexToRgb(hex) {
   const n = parseInt(hex.slice(1), 16);
-  return { r: n >> 16, g: n >> 8 & 255, b: n & 255 };
+  return { r: n >> 16, g: (n >> 8) & 255, b: n & 255 };
 }
 var lerpRgb = (a, b, t) => ({
   r: Math.round(a.r + (b.r - a.r) * t),
   g: Math.round(a.g + (b.g - a.g) * t),
-  b: Math.round(a.b + (b.b - a.b) * t)
+  b: Math.round(a.b + (b.b - a.b) * t),
 });
 function getPaletteColor(palette, position, timeOffset = 0) {
   if (palette.length === 0) return { r: 255, g: 255, b: 255 };
@@ -238,7 +265,7 @@ function resolvePalette(palette, trailStyle) {
 }
 function hexToRgbComponents(hex) {
   const n = parseInt(hex.slice(1), 16);
-  return `${n >> 16},${n >> 8 & 255},${n & 255}`;
+  return `${n >> 16},${(n >> 8) & 255},${n & 255}`;
 }
 function computeTangent(trail, i) {
   const count = trail.length;
@@ -283,7 +310,7 @@ function createRenderer(options) {
     skeletonColor: options.skeletonColor ?? DEFAULT_SKELETON_COLOR,
     trailColor: options.trailColor ?? "#ffffff",
     headColor: options.headColor ?? "#ffffff",
-    headRadius: options.headRadius ?? DEFAULT_HEAD_RADIUS
+    headRadius: options.headRadius ?? DEFAULT_HEAD_RADIUS,
   };
   const trailStyle = options.trailStyle ?? "default";
   const palette = resolvePalette(options.palette, trailStyle);
@@ -316,15 +343,31 @@ function createRenderer(options) {
   function computeBoundaries(pts) {
     if (pts.length === 0) return null;
     const first = pts[0];
-    let minX = first.x, maxX = first.x, minY = first.y, maxY = first.y;
+    let minX = first.x,
+      maxX = first.x,
+      minY = first.y,
+      maxY = first.y;
     for (const p of pts) {
-      if (p.x < minX) minX = p.x;
-      if (p.x > maxX) maxX = p.x;
-      if (p.y < minY) minY = p.y;
-      if (p.y > maxY) maxY = p.y;
+      if (p.x < minX) {
+        minX = p.x;
+      }
+      if (p.x > maxX) {
+        maxX = p.x;
+      }
+      if (p.y < minY) {
+        minY = p.y;
+      }
+      if (p.y > maxY) {
+        maxY = p.y;
+      }
     }
     const width = maxX - minX;
     const height = maxY - minY;
+    if (width === 0 && height === 0) {
+      throw new Error(
+        "[sarmal] Degenerate curve: all skeleton points are identical. Check that your curve fn returns distinct points for different values of t.",
+      );
+    }
     const scaleX = logicalWidth / (width * (1 + FIT_PADDING * 2));
     const scaleY = logicalHeight / (height * (1 + FIT_PADDING * 2));
     const s = Math.min(scaleX, scaleY);
@@ -333,7 +376,7 @@ function createRenderer(options) {
     return {
       scale: s,
       offsetX: (logicalWidth - boundsWidth) / 2 - minX * s,
-      offsetY: (logicalHeight - boundsHeight) / 2 - minY * s
+      offsetY: (logicalHeight - boundsHeight) / 2 - minY * s,
     };
   }
   function calculateBoundaries() {
@@ -539,156 +582,199 @@ function createRenderer(options) {
       return new Promise((resolve) => {
         morphResolve = resolve;
       });
-    }
+    },
   };
 }
 
-// src/curves.ts
+// src/curves/artemis2.ts
 var TWO_PI2 = Math.PI * 2;
-function artemis2(t, _time, _params) {
-  const a = 0.35, b = 0.15, ox = 0.175;
-  const s = Math.sin(t), c = Math.cos(t);
+function artemis2Fn(t, _time, _params) {
+  const a = 0.35,
+    b = 0.15,
+    ox = 0.175;
+  const s = Math.sin(t),
+    c = Math.cos(t);
   const denom = 1 + s * s;
   return {
-    x: c * (1 + a * c) / denom - ox,
-    y: s * c * (1 + b * c) / denom
+    x: (c * (1 + a * c)) / denom - ox,
+    y: (s * c * (1 + b * c)) / denom,
   };
 }
-function epitrochoid7(t, _time, _params) {
-  const d = 1 + 0.55 * Math.sin(t * 0.5);
-  return {
-    x: 7 * Math.cos(t) - d * Math.cos(7 * t),
-    y: 7 * Math.sin(t) - d * Math.sin(7 * t)
-  };
-}
-function epitrochoid7Skeleton(t) {
-  const d = 1.275;
-  return {
-    x: 7 * Math.cos(t) - d * Math.cos(7 * t),
-    y: 7 * Math.sin(t) - d * Math.sin(7 * t)
-  };
-}
-function astroid(t, _time, _params) {
+var artemis2 = {
+  name: "Artemis II",
+  fn: artemis2Fn,
+  period: TWO_PI2,
+  speed: 0.7,
+};
+
+// src/curves/astroid.ts
+var TWO_PI3 = Math.PI * 2;
+function astroidFn(t, _time, _params) {
   const c = Math.cos(t);
   const s = Math.sin(t);
   return {
     x: c * c * c,
-    y: s * s * s
+    y: s * s * s,
   };
 }
-function deltoid(t, _time, _params) {
+var astroid = {
+  name: "Astroid",
+  fn: astroidFn,
+  period: TWO_PI3,
+  speed: 1.1,
+};
+
+// src/curves/deltoid.ts
+var TWO_PI4 = Math.PI * 2;
+function deltoidFn(t, _time, _params) {
   return {
     x: 2 * Math.cos(t) + Math.cos(2 * t),
-    y: 2 * Math.sin(t) - Math.sin(2 * t)
+    y: 2 * Math.sin(t) - Math.sin(2 * t),
   };
 }
-function rose5(t, _time, _params) {
-  const r = Math.cos(5 * t);
+var deltoid = {
+  name: "Deltoid",
+  fn: deltoidFn,
+  period: TWO_PI4,
+  speed: 0.9,
+};
+
+// src/curves/epicycloid3.ts
+var TWO_PI5 = Math.PI * 2;
+function epicycloid3Fn(t, _time, _params) {
   return {
-    x: r * Math.cos(t),
-    y: r * Math.sin(t)
+    x: 4 * Math.cos(t) - Math.cos(4 * t),
+    y: 4 * Math.sin(t) - Math.sin(4 * t),
   };
 }
-function rose3(t, _time, _params) {
-  const r = Math.cos(3 * t);
+var epicycloid3 = {
+  name: "Epicycloid (n=3)",
+  fn: epicycloid3Fn,
+  period: TWO_PI5,
+  speed: 0.75,
+};
+
+// src/curves/epitrochoid7.ts
+var TWO_PI6 = Math.PI * 2;
+function epitrochoid7Fn(t, _time, _params) {
+  const d = 1 + 0.55 * Math.sin(t * 0.5);
   return {
-    x: r * Math.cos(t),
-    y: r * Math.sin(t)
+    x: 7 * Math.cos(t) - d * Math.cos(7 * t),
+    y: 7 * Math.sin(t) - d * Math.sin(7 * t),
+  };
+}
+function epitrochoid7SkeletonFn(t) {
+  const d = 1.275;
+  return {
+    x: 7 * Math.cos(t) - d * Math.cos(7 * t),
+    y: 7 * Math.sin(t) - d * Math.sin(7 * t),
   };
 }
-function lissajous32(t, time, _params) {
+var epitrochoid7 = {
+  name: "Epitrochoid",
+  fn: epitrochoid7Fn,
+  period: TWO_PI6,
+  speed: 1.4,
+  skeletonFn: epitrochoid7SkeletonFn,
+};
+
+// src/curves/lissajous32.ts
+var TWO_PI7 = Math.PI * 2;
+function lissajous32Fn(t, time, _params) {
   const phi = time * 0.45;
   return {
     x: Math.sin(3 * t + phi),
-    y: Math.sin(2 * t)
+    y: Math.sin(2 * t),
   };
 }
-function lissajous43(t, time, _params) {
+var lissajous32 = {
+  name: "Lissajous 3:2",
+  fn: lissajous32Fn,
+  period: TWO_PI7,
+  speed: 2,
+  skeleton: "live",
+};
+
+// src/curves/lissajous43.ts
+var TWO_PI8 = Math.PI * 2;
+function lissajous43Fn(t, time, _params) {
   const phi = time * 0.38;
   return {
     x: Math.sin(4 * t + phi),
-    y: Math.sin(3 * t)
+    y: Math.sin(3 * t),
   };
 }
-function epicycloid3(t, _time, _params) {
+var lissajous43 = {
+  name: "Lissajous 4:3",
+  fn: lissajous43Fn,
+  period: TWO_PI8,
+  speed: 1.8,
+  skeleton: "live",
+};
+
+// src/curves/lame.ts
+var TWO_PI9 = Math.PI * 2;
+function lameFn(t, time, _params) {
+  const p = 1.75 + 1.25 * Math.sin(time * 0.48);
+  const c = Math.cos(t),
+    s = Math.sin(t);
   return {
-    x: 4 * Math.cos(t) - Math.cos(4 * t),
-    y: 4 * Math.sin(t) - Math.sin(4 * t)
+    x: Math.sign(c) * Math.pow(Math.abs(c), p),
+    y: Math.sign(s) * Math.pow(Math.abs(s), p),
   };
 }
-function lame(t, time, _params) {
-  const p = 1.75 + 1.25 * Math.sin(time * 0.48);
-  const c = Math.cos(t), s = Math.sin(t);
+var lame = {
+  name: "Lam\xE9 Curve",
+  fn: lameFn,
+  period: TWO_PI9,
+  speed: 1,
+  skeleton: "live",
+};
+
+// src/curves/rose3.ts
+var TWO_PI10 = Math.PI * 2;
+function rose3Fn(t, _time, _params) {
+  const r = Math.cos(3 * t);
   return {
-    x: Math.sign(c) * Math.pow(Math.abs(c), p),
-    y: Math.sign(s) * Math.pow(Math.abs(s), p)
+    x: r * Math.cos(t),
+    y: r * Math.sin(t),
+  };
+}
+var rose3 = {
+  name: "Rose (n=3)",
+  fn: rose3Fn,
+  period: TWO_PI10,
+  speed: 1.15,
+};
+
+// src/curves/rose5.ts
+var TWO_PI11 = Math.PI * 2;
+function rose5Fn(t, _time, _params) {
+  const r = Math.cos(5 * t);
+  return {
+    x: r * Math.cos(t),
+    y: r * Math.sin(t),
   };
 }
+var rose5 = {
+  name: "Rose (n=5)",
+  fn: rose5Fn,
+  period: TWO_PI11,
+  speed: 1,
+};
+
+// src/curves/index.ts
 var curves = {
-  artemis2: {
-    name: "Artemis II",
-    fn: artemis2,
-    period: TWO_PI2,
-    speed: 0.7
-  },
-  epitrochoid7: {
-    name: "Epitrochoid",
-    fn: epitrochoid7,
-    period: TWO_PI2,
-    speed: 1.4,
-    skeletonFn: epitrochoid7Skeleton
-  },
-  astroid: {
-    name: "Astroid",
-    fn: astroid,
-    period: TWO_PI2,
-    speed: 1.1
-  },
-  deltoid: {
-    name: "Deltoid",
-    fn: deltoid,
-    period: TWO_PI2,
-    speed: 0.9
-  },
-  rose5: {
-    name: "Rose (n=5)",
-    fn: rose5,
-    period: TWO_PI2,
-    speed: 1
-  },
-  rose3: {
-    name: "Rose (n=3)",
-    fn: rose3,
-    period: TWO_PI2,
-    speed: 1.15
-  },
-  lissajous32: {
-    name: "Lissajous 3:2",
-    fn: lissajous32,
-    period: TWO_PI2,
-    speed: 2,
-    skeleton: "live"
-  },
-  lissajous43: {
-    name: "Lissajous 4:3",
-    fn: lissajous43,
-    period: TWO_PI2,
-    speed: 1.8,
-    skeleton: "live"
-  },
-  epicycloid3: {
-    name: "Epicycloid (n=3)",
-    fn: epicycloid3,
-    period: TWO_PI2,
-    speed: 0.75
-  },
-  lame: {
-    name: "Lam\xE9 Curve",
-    fn: lame,
-    period: TWO_PI2,
-    speed: 1,
-    skeleton: "live"
-  }
+  artemis2,
+  epitrochoid7,
+  astroid,
+  deltoid,
+  rose5,
+  rose3,
+  lissajous32,
+  lissajous43,
+  epicycloid3,
+  lame,
 };
 
 // src/index.ts
@@ -699,31 +785,46 @@ function createSarmal(canvas, curveDef, options) {
 }
 
 // src/auto-init.ts
+function parsePalette(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (Array.isArray(parsed)) {
+      return parsed;
+    }
+  } catch {}
+  return value;
+}
 function init() {
   const canvases = document.querySelectorAll("canvas[data-sarmal]");
   canvases.forEach((canvas) => {
     const curveName = canvas.getAttribute("data-sarmal");
     if (curveName == null) {
-      return console.warn("[sarmal] curveName isrequried");
+      return console.warn("[sarmal] curveName is required");
     }
     const curveDef = curves[curveName];
     if (!curveDef) {
       return console.error(`[sarmal] "${curveName}" is not a valid curve name`);
     }
     const sarmal = createSarmal(canvas, curveDef, {
-      ...canvas.dataset.trailColor && { trailColor: canvas.dataset.trailColor },
-      ...canvas.dataset.skeletonColor && { skeletonColor: canvas.dataset.skeletonColor },
-      ...canvas.dataset.headColor && { headColor: canvas.dataset.headColor },
-      ...canvas.dataset.headRadius && { headRadius: parseFloat(canvas.dataset.headRadius) },
-      ...canvas.dataset.trailLength && { trailLength: parseInt(canvas.dataset.trailLength, 10) }
+      ...(canvas.dataset.trailColor && { trailColor: canvas.dataset.trailColor }),
+      ...(canvas.dataset.skeletonColor && { skeletonColor: canvas.dataset.skeletonColor }),
+      ...(canvas.dataset.headColor && { headColor: canvas.dataset.headColor }),
+      ...(canvas.dataset.headRadius && { headRadius: parseFloat(canvas.dataset.headRadius) }),
+      ...(canvas.dataset.trailLength && { trailLength: parseInt(canvas.dataset.trailLength, 10) }),
+      ...(canvas.dataset.trailStyle && {
+        trailStyle: canvas.dataset.trailStyle,
+      }),
+      ...(canvas.dataset.palette && { palette: parsePalette(canvas.dataset.palette) }),
     });
     sarmal.start();
   });
 }
 if (document.readyState === "loading") {
-  document.addEventListener("DOMContentLoaded", init);
+  document.addEventListener("DOMContentLoaded", () => {
+    requestAnimationFrame(init);
+  });
 } else {
-  init();
+  requestAnimationFrame(init);
 }
 //# sourceMappingURL=auto-init.cjs.map
-//# sourceMappingURL=auto-init.cjs.map
+//# sourceMappingURL=auto-init.cjs.map