@effing/tween 0.1.0

package/LICENSE

@@ -0,0 +1,11 @@
+O'Saasy License
+
+Copyright © 2026, Trackuity BV.
+
+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:
+
+1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. No licensee or downstream recipient may use the Software (including any modified or derivative versions) to directly compete with the original Licensor by offering it to third parties as a hosted, managed, or Software-as-a-Service (SaaS) product or cloud service where the primary value of the service is the functionality of the Software itself.
+
+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.

package/README.md

@@ -0,0 +1,177 @@
+# @effing/tween
+
+**Easing functions and step iteration for frame-based animations.**
+
+> Part of the [**Effing**](../../README.md) family — programmatic video creation with TypeScript.
+
+Generate animation frames with precise timing control. Iterate over steps with progress values, apply easing functions for smooth motion.
+
+## Installation
+
+```bash
+npm install @effing/tween
+```
+
+## Quick Start
+
+```typescript
+import { tween, easeOutQuad } from "@effing/tween";
+import { pngFromSatori } from "@effing/satori";
+
+async function* generateFrames() {
+  yield* tween(90, async ({ lower: progress }) => {
+    // Apply easing to progress
+    const easedProgress = easeOutQuad(progress);
+
+    // Use eased progress for animation
+    const scale = 1 + 0.5 * easedProgress;
+    const opacity = easedProgress;
+
+    return pngFromSatori(
+      <div style={{ transform: `scale(${scale})`, opacity }}>
+        Animated!
+      </div>,
+      { width: 1080, height: 1920, fonts }
+    );
+  });
+}
+```
+
+## Concepts
+
+### Tweening
+
+The `tween()` async generator iterates over animation frames with concurrency control. Each frame receives a `TweenInterval` with `lower` and `upper` bounds representing its position in the animation (0→1):
+
+```typescript
+import { tween } from "@effing/tween";
+
+// Generate 60 frames with concurrent processing
+yield *
+  tween(60, async ({ lower, upper }, index) => {
+    // lower: 0/60, 1/60, 2/60, ... 59/60
+    // upper: 1/60, 2/60, 3/60, ... 60/60
+    // index: 0, 1, 2, ... 59
+    return renderFrame(lower);
+  });
+```
+
+Frames are processed concurrently (defaulting to CPU count) but yielded in order—ideal for CPU-bound rendering work.
+
+### Easing Functions
+
+Transform linear progress into curved motion. All easing functions take a value in `[0, 1]` and return a value in `[0, 1]`:
+
+```typescript
+import { easeOutQuad, easeInOutCubic } from "@effing/tween";
+
+const progress = 0.5;
+easeOutQuad(progress); // 0.75 — starts fast, ends slow
+easeInOutCubic(progress); // 0.5  — slow start and end
+```
+
+## API Overview
+
+### Step Iteration
+
+#### `steps(count)`
+
+Returns an array of progress values from 0 to (count-1)/count:
+
+```typescript
+function steps(count: number): number[];
+
+steps(4); // [0, 0.25, 0.5, 0.75]
+```
+
+#### `tween(count, fn, options?)`
+
+Tween frames, with concurrency control. Yields resulting frames in order.
+
+```typescript
+async function* tween<T>(
+  count: number,
+  fn: (interval: TweenInterval, index: number) => Promise<T>,
+  options?: { concurrency?: number }
+): AsyncGenerator<T>
+```
+
+#### `tweenToArray(count, fn, options?)`
+
+Tween frames, with concurrency control, returning an array.
+
+```typescript
+async function tweenToArray<T>(
+  count: number,
+  fn: (interval: TweenInterval, index: number) => Promise<T>,
+  options?: { concurrency?: number },
+): Promise<T[]>;
+```
+
+### Easing Functions
+
+All easing functions have the signature `(t: number) => number`.
+
+| Category | Functions                                             |
+| -------- | ----------------------------------------------------- |
+| Linear   | `linear`                                              |
+| Sine     | `easeInSine`, `easeOutSine`, `easeInOutSine`          |
+| Quad     | `easeInQuad`, `easeOutQuad`, `easeInOutQuad`          |
+| Cubic    | `easeInCubic`, `easeOutCubic`, `easeInOutCubic`       |
+| Quart    | `easeInQuart`, `easeOutQuart`, `easeInOutQuart`       |
+| Quint    | `easeInQuint`, `easeOutQuint`, `easeInOutQuint`       |
+| Expo     | `easeInExpo`, `easeOutExpo`, `easeInOutExpo`          |
+| Circ     | `easeInCirc`, `easeOutCirc`, `easeInOutCirc`          |
+| Back     | `easeInBack`, `easeOutBack`, `easeInOutBack`          |
+| Elastic  | `easeInElastic`, `easeOutElastic`, `easeInOutElastic` |
+| Bounce   | `easeInBounce`, `easeOutBounce`, `easeInOutBounce`    |
+
+**Naming convention:**
+
+- `easeIn*` — Starts slow, ends fast
+- `easeOut*` — Starts fast, ends slow
+- `easeInOut*` — Slow at both ends
+
+## Examples
+
+### Zoom Animation
+
+```typescript
+import { tween, easeOutQuad } from "@effing/tween";
+
+yield *
+  tween(90, async ({ lower: p }) => {
+    const zoom = 1 + 0.3 * easeOutQuad(p);
+    return renderFrame({ zoom });
+  });
+```
+
+### Fade In/Out
+
+```typescript
+import { tween, easeInOutSine } from "@effing/tween";
+
+yield *
+  tween(60, async ({ lower: p }) => {
+    // Fade in for first half, fade out for second half
+    const opacity = p < 0.5 ? easeInOutSine(p * 2) : easeInOutSine((1 - p) * 2);
+    return renderFrame({ opacity });
+  });
+```
+
+### Bounce Effect
+
+```typescript
+import { tween, easeOutBounce } from "@effing/tween";
+
+yield *
+  tween(45, async ({ lower: p }) => {
+    const y = 100 * (1 - easeOutBounce(p)); // Fall and bounce
+    return renderFrame({ translateY: y });
+  });
+```
+
+## Related Packages
+
+- [`@effing/annie`](../annie) — Package frames into TAR archives
+- [`@effing/satori`](../satori) — Render JSX to PNG for each frame

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Generate an array of step values for an animation
+ * @param count Number of steps
+ * @returns Array of step values from 0 to (count-1)/count
+ */
+declare function steps(count: number): number[];
+
+/**
+ * Tween interval representing a frame's position in the animation
+ */
+type TweenInterval = {
+    /** Lower bound (inclusive), in range [0, 1) */
+    lower: number;
+    /** Upper bound (exclusive for all but last frame), in range (0, 1] */
+    upper: number;
+};
+/**
+ * Tween frames with concurrency control
+ * @param count Number of frames to generate
+ * @param fn Function that takes a tween interval and index, returns a promise
+ * @param options Configuration options
+ * @yields Resulting frames in order
+ */
+declare function tween<T>(count: number, fn: (interval: TweenInterval, index: number) => Promise<T>, options?: {
+    concurrency?: number;
+}): AsyncGenerator<T>;
+/**
+ * Tween frames with concurrency control, returning an array
+ * @param count Number of frames to generate
+ * @param fn Function that takes a tween interval and index, returns a promise
+ * @param options Configuration options
+ * @returns Promise resolving to array of resulting frames
+ */
+declare function tweenToArray<T>(count: number, fn: (interval: TweenInterval, index: number) => Promise<T>, options?: {
+    concurrency?: number;
+}): Promise<T[]>;
+
+/** Linear interpolation (no easing) */
+declare function linear(x: number): number;
+/** Ease in using sine curve */
+declare function easeInSine(x: number): number;
+/** Ease out using sine curve */
+declare function easeOutSine(x: number): number;
+/** Ease in-out using sine curve */
+declare function easeInOutSine(x: number): number;
+/** Ease in using quadratic curve */
+declare function easeInQuad(x: number): number;
+/** Ease out using quadratic curve */
+declare function easeOutQuad(x: number): number;
+/** Ease in-out using quadratic curve */
+declare function easeInOutQuad(x: number): number;
+/** Ease in using cubic curve */
+declare function easeInCubic(x: number): number;
+/** Ease out using cubic curve */
+declare function easeOutCubic(x: number): number;
+/** Ease in-out using cubic curve */
+declare function easeInOutCubic(x: number): number;
+/** Ease in using quartic curve */
+declare function easeInQuart(x: number): number;
+/** Ease out using quartic curve */
+declare function easeOutQuart(x: number): number;
+/** Ease in-out using quartic curve */
+declare function easeInOutQuart(x: number): number;
+/** Ease in using quintic curve */
+declare function easeInQuint(x: number): number;
+/** Ease out using quintic curve */
+declare function easeOutQuint(x: number): number;
+/** Ease in-out using quintic curve */
+declare function easeInOutQuint(x: number): number;
+/** Ease in using exponential curve */
+declare function easeInExpo(x: number): number;
+/** Ease out using exponential curve */
+declare function easeOutExpo(x: number): number;
+/** Ease in-out using exponential curve */
+declare function easeInOutExpo(x: number): number;
+/** Ease in using circular curve */
+declare function easeInCirc(x: number): number;
+/** Ease out using circular curve */
+declare function easeOutCirc(x: number): number;
+/** Ease in-out using circular curve */
+declare function easeInOutCirc(x: number): number;
+/** Ease in with overshoot (back) */
+declare function easeInBack(x: number): number;
+/** Ease out with overshoot (back) */
+declare function easeOutBack(x: number): number;
+/** Ease in-out with overshoot (back) */
+declare function easeInOutBack(x: number): number;
+/** Ease in with elastic bounce */
+declare function easeInElastic(x: number): number;
+/** Ease out with elastic bounce */
+declare function easeOutElastic(x: number): number;
+/** Ease in-out with elastic bounce */
+declare function easeInOutElastic(x: number): number;
+/** Ease out with bounce */
+declare function easeOutBounce(x: number): number;
+/** Ease in with bounce */
+declare function easeInBounce(x: number): number;
+/** Ease in-out with bounce */
+declare function easeInOutBounce(x: number): number;
+
+export { type TweenInterval, easeInBack, easeInBounce, easeInCirc, easeInCubic, easeInElastic, easeInExpo, easeInOutBack, easeInOutBounce, easeInOutCirc, easeInOutCubic, easeInOutElastic, easeInOutExpo, easeInOutQuad, easeInOutQuart, easeInOutQuint, easeInOutSine, easeInQuad, easeInQuart, easeInQuint, easeInSine, easeOutBack, easeOutBounce, easeOutCirc, easeOutCubic, easeOutElastic, easeOutExpo, easeOutQuad, easeOutQuart, easeOutQuint, easeOutSine, linear, steps, tween, tweenToArray };

package/dist/index.js

@@ -0,0 +1,196 @@
+// src/steps.ts
+function steps(count) {
+  return Array.from({ length: count }, (_, i) => i / count);
+}
+
+// src/tween.ts
+import os from "os";
+async function* tween(count, fn, options = { concurrency: os.cpus().length }) {
+  if (count === 0) {
+    return;
+  }
+  const range = steps(count);
+  const maxConcurrency = Math.max(1, options.concurrency ?? os.cpus().length);
+  const activeTasks = /* @__PURE__ */ new Map();
+  let nextIndexToStart = 0;
+  let nextIndexToYield = 0;
+  const startTask = (index) => {
+    const lower = range[index];
+    const upper = range[index + 1] ?? 1;
+    const promise = fn({ lower, upper }, index);
+    activeTasks.set(index, promise);
+  };
+  const fillConcurrencySlots = () => {
+    while (nextIndexToStart < count && activeTasks.size < maxConcurrency) {
+      startTask(nextIndexToStart++);
+    }
+  };
+  fillConcurrencySlots();
+  while (nextIndexToYield < count) {
+    const taskPromise = activeTasks.get(nextIndexToYield);
+    if (!taskPromise) {
+      throw new Error(
+        `Internal error: task at index ${nextIndexToYield} not found in active tasks`
+      );
+    }
+    const result = await taskPromise;
+    activeTasks.delete(nextIndexToYield);
+    yield result;
+    fillConcurrencySlots();
+    nextIndexToYield++;
+  }
+}
+async function tweenToArray(count, fn, options = { concurrency: os.cpus().length }) {
+  return Array.fromAsync(tween(count, fn, options));
+}
+
+// src/easing.ts
+function linear(x) {
+  return x;
+}
+function easeInSine(x) {
+  return 1 - Math.cos(x * Math.PI / 2);
+}
+function easeOutSine(x) {
+  return Math.sin(x * Math.PI / 2);
+}
+function easeInOutSine(x) {
+  return -(Math.cos(Math.PI * x) - 1) / 2;
+}
+function easeInQuad(x) {
+  return x * x;
+}
+function easeOutQuad(x) {
+  return 1 - Math.pow(1 - x, 2);
+}
+function easeInOutQuad(x) {
+  return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;
+}
+function easeInCubic(x) {
+  return x * x * x;
+}
+function easeOutCubic(x) {
+  return 1 - Math.pow(1 - x, 3);
+}
+function easeInOutCubic(x) {
+  return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;
+}
+function easeInQuart(x) {
+  return x * x * x * x;
+}
+function easeOutQuart(x) {
+  return 1 - Math.pow(1 - x, 4);
+}
+function easeInOutQuart(x) {
+  return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;
+}
+function easeInQuint(x) {
+  return x * x * x * x * x;
+}
+function easeOutQuint(x) {
+  return 1 - Math.pow(1 - x, 5);
+}
+function easeInOutQuint(x) {
+  return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;
+}
+function easeInExpo(x) {
+  return x === 0 ? 0 : Math.pow(2, 10 * x - 10);
+}
+function easeOutExpo(x) {
+  return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);
+}
+function easeInOutExpo(x) {
+  return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? Math.pow(2, 20 * x - 10) / 2 : (2 - Math.pow(2, -20 * x + 10)) / 2;
+}
+function easeInCirc(x) {
+  return 1 - Math.sqrt(1 - Math.pow(x, 2));
+}
+function easeOutCirc(x) {
+  return Math.sqrt(1 - Math.pow(x - 1, 2));
+}
+function easeInOutCirc(x) {
+  return x < 0.5 ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2 : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;
+}
+function easeInBack(x) {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return c3 * x * x * x - c1 * x * x;
+}
+function easeOutBack(x) {
+  const c1 = 1.70158;
+  const c3 = c1 + 1;
+  return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);
+}
+function easeInOutBack(x) {
+  const c1 = 1.70158;
+  const c2 = c1 * 1.525;
+  return x < 0.5 ? Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2) / 2 : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;
+}
+function easeInElastic(x) {
+  const c4 = 2 * Math.PI / 3;
+  return x === 0 ? 0 : x === 1 ? 1 : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);
+}
+function easeOutElastic(x) {
+  const c4 = 2 * Math.PI / 3;
+  return x === 0 ? 0 : x === 1 ? 1 : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;
+}
+function easeInOutElastic(x) {
+  const c5 = 2 * Math.PI / 4.5;
+  return x === 0 ? 0 : x === 1 ? 1 : x < 0.5 ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2 : Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5) / 2 + 1;
+}
+function easeOutBounce(x) {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (x < 1 / d1) {
+    return n1 * x * x;
+  } else if (x < 2 / d1) {
+    return n1 * (x -= 1.5 / d1) * x + 0.75;
+  } else if (x < 2.5 / d1) {
+    return n1 * (x -= 2.25 / d1) * x + 0.9375;
+  } else {
+    return n1 * (x -= 2.625 / d1) * x + 0.984375;
+  }
+}
+function easeInBounce(x) {
+  return 1 - easeOutBounce(1 - x);
+}
+function easeInOutBounce(x) {
+  return x < 0.5 ? (1 - easeOutBounce(1 - 2 * x)) / 2 : (1 + easeOutBounce(2 * x - 1)) / 2;
+}
+export {
+  easeInBack,
+  easeInBounce,
+  easeInCirc,
+  easeInCubic,
+  easeInElastic,
+  easeInExpo,
+  easeInOutBack,
+  easeInOutBounce,
+  easeInOutCirc,
+  easeInOutCubic,
+  easeInOutElastic,
+  easeInOutExpo,
+  easeInOutQuad,
+  easeInOutQuart,
+  easeInOutQuint,
+  easeInOutSine,
+  easeInQuad,
+  easeInQuart,
+  easeInQuint,
+  easeInSine,
+  easeOutBack,
+  easeOutBounce,
+  easeOutCirc,
+  easeOutCubic,
+  easeOutElastic,
+  easeOutExpo,
+  easeOutQuad,
+  easeOutQuart,
+  easeOutQuint,
+  easeOutSine,
+  linear,
+  steps,
+  tween,
+  tweenToArray
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/steps.ts","../src/tween.ts","../src/easing.ts"],"sourcesContent":["/**\n * Generate an array of step values for an animation\n * @param count Number of steps\n * @returns Array of step values from 0 to (count-1)/count\n */\nexport function steps(count: number): number[] {\n  return Array.from({ length: count }, (_, i) => i / count);\n}\n","import os from \"os\";\nimport { steps } from \"./steps\";\n\n/**\n * Tween interval representing a frame's position in the animation\n */\nexport type TweenInterval = {\n  /** Lower bound (inclusive), in range [0, 1) */\n  lower: number;\n  /** Upper bound (exclusive for all but last frame), in range (0, 1] */\n  upper: number;\n};\n\n/**\n * Tween frames with concurrency control\n * @param count Number of frames to generate\n * @param fn Function that takes a tween interval and index, returns a promise\n * @param options Configuration options\n * @yields Resulting frames in order\n */\nexport async function* tween<T>(\n  count: number,\n  fn: (interval: TweenInterval, index: number) => Promise<T>,\n  options: { concurrency?: number } = { concurrency: os.cpus().length },\n): AsyncGenerator<T> {\n  if (count === 0) {\n    return;\n  }\n\n  const range = steps(count);\n  const maxConcurrency = Math.max(1, options.concurrency ?? os.cpus().length);\n  const activeTasks = new Map<number, Promise<T>>();\n\n  let nextIndexToStart = 0;\n  let nextIndexToYield = 0;\n\n  const startTask = (index: number): void => {\n    const lower = range[index];\n    const upper = range[index + 1] ?? 1;\n    const promise = fn({ lower, upper }, index);\n    activeTasks.set(index, promise);\n  };\n\n  const fillConcurrencySlots = (): void => {\n    while (nextIndexToStart < count && activeTasks.size < maxConcurrency) {\n      startTask(nextIndexToStart++);\n    }\n  };\n\n  fillConcurrencySlots();\n\n  while (nextIndexToYield < count) {\n    const taskPromise = activeTasks.get(nextIndexToYield);\n\n    if (!taskPromise) {\n      throw new Error(\n        `Internal error: task at index ${nextIndexToYield} not found in active tasks`,\n      );\n    }\n\n    const result = await taskPromise;\n    activeTasks.delete(nextIndexToYield);\n    yield result;\n\n    fillConcurrencySlots();\n    nextIndexToYield++;\n  }\n}\n\n/**\n * Tween frames with concurrency control, returning an array\n * @param count Number of frames to generate\n * @param fn Function that takes a tween interval and index, returns a promise\n * @param options Configuration options\n * @returns Promise resolving to array of resulting frames\n */\nexport async function tweenToArray<T>(\n  count: number,\n  fn: (interval: TweenInterval, index: number) => Promise<T>,\n  options: { concurrency?: number } = { concurrency: os.cpus().length },\n): Promise<T[]> {\n  return Array.fromAsync(tween(count, fn, options));\n}\n","// ============================================\n// Easing functions\n// See: https://easings.net/\n// ============================================\n\n/** Linear interpolation (no easing) */\nexport function linear(x: number): number {\n  return x;\n}\n\n// Sine\n\n/** Ease in using sine curve */\nexport function easeInSine(x: number): number {\n  return 1 - Math.cos((x * Math.PI) / 2);\n}\n\n/** Ease out using sine curve */\nexport function easeOutSine(x: number): number {\n  return Math.sin((x * Math.PI) / 2);\n}\n\n/** Ease in-out using sine curve */\nexport function easeInOutSine(x: number): number {\n  return -(Math.cos(Math.PI * x) - 1) / 2;\n}\n\n// Quad\n\n/** Ease in using quadratic curve */\nexport function easeInQuad(x: number): number {\n  return x * x;\n}\n\n/** Ease out using quadratic curve */\nexport function easeOutQuad(x: number): number {\n  return 1 - Math.pow(1 - x, 2);\n}\n\n/** Ease in-out using quadratic curve */\nexport function easeInOutQuad(x: number): number {\n  return x < 0.5 ? 2 * x * x : 1 - Math.pow(-2 * x + 2, 2) / 2;\n}\n\n// Cubic\n\n/** Ease in using cubic curve */\nexport function easeInCubic(x: number): number {\n  return x * x * x;\n}\n\n/** Ease out using cubic curve */\nexport function easeOutCubic(x: number): number {\n  return 1 - Math.pow(1 - x, 3);\n}\n\n/** Ease in-out using cubic curve */\nexport function easeInOutCubic(x: number): number {\n  return x < 0.5 ? 4 * x * x * x : 1 - Math.pow(-2 * x + 2, 3) / 2;\n}\n\n// Quart\n\n/** Ease in using quartic curve */\nexport function easeInQuart(x: number): number {\n  return x * x * x * x;\n}\n\n/** Ease out using quartic curve */\nexport function easeOutQuart(x: number): number {\n  return 1 - Math.pow(1 - x, 4);\n}\n\n/** Ease in-out using quartic curve */\nexport function easeInOutQuart(x: number): number {\n  return x < 0.5 ? 8 * x * x * x * x : 1 - Math.pow(-2 * x + 2, 4) / 2;\n}\n\n// Quint\n\n/** Ease in using quintic curve */\nexport function easeInQuint(x: number): number {\n  return x * x * x * x * x;\n}\n\n/** Ease out using quintic curve */\nexport function easeOutQuint(x: number): number {\n  return 1 - Math.pow(1 - x, 5);\n}\n\n/** Ease in-out using quintic curve */\nexport function easeInOutQuint(x: number): number {\n  return x < 0.5 ? 16 * x * x * x * x * x : 1 - Math.pow(-2 * x + 2, 5) / 2;\n}\n\n// Expo\n\n/** Ease in using exponential curve */\nexport function easeInExpo(x: number): number {\n  return x === 0 ? 0 : Math.pow(2, 10 * x - 10);\n}\n\n/** Ease out using exponential curve */\nexport function easeOutExpo(x: number): number {\n  return x === 1 ? 1 : 1 - Math.pow(2, -10 * x);\n}\n\n/** Ease in-out using exponential curve */\nexport function easeInOutExpo(x: number): number {\n  return x === 0\n    ? 0\n    : x === 1\n      ? 1\n      : x < 0.5\n        ? Math.pow(2, 20 * x - 10) / 2\n        : (2 - Math.pow(2, -20 * x + 10)) / 2;\n}\n\n// Circ\n\n/** Ease in using circular curve */\nexport function easeInCirc(x: number): number {\n  return 1 - Math.sqrt(1 - Math.pow(x, 2));\n}\n\n/** Ease out using circular curve */\nexport function easeOutCirc(x: number): number {\n  return Math.sqrt(1 - Math.pow(x - 1, 2));\n}\n\n/** Ease in-out using circular curve */\nexport function easeInOutCirc(x: number): number {\n  return x < 0.5\n    ? (1 - Math.sqrt(1 - Math.pow(2 * x, 2))) / 2\n    : (Math.sqrt(1 - Math.pow(-2 * x + 2, 2)) + 1) / 2;\n}\n\n// Back\n\n/** Ease in with overshoot (back) */\nexport function easeInBack(x: number): number {\n  const c1 = 1.70158;\n  const c3 = c1 + 1;\n  return c3 * x * x * x - c1 * x * x;\n}\n\n/** Ease out with overshoot (back) */\nexport function easeOutBack(x: number): number {\n  const c1 = 1.70158;\n  const c3 = c1 + 1;\n  return 1 + c3 * Math.pow(x - 1, 3) + c1 * Math.pow(x - 1, 2);\n}\n\n/** Ease in-out with overshoot (back) */\nexport function easeInOutBack(x: number): number {\n  const c1 = 1.70158;\n  const c2 = c1 * 1.525;\n\n  return x < 0.5\n    ? (Math.pow(2 * x, 2) * ((c2 + 1) * 2 * x - c2)) / 2\n    : (Math.pow(2 * x - 2, 2) * ((c2 + 1) * (x * 2 - 2) + c2) + 2) / 2;\n}\n\n// Elastic\n\n/** Ease in with elastic bounce */\nexport function easeInElastic(x: number): number {\n  const c4 = (2 * Math.PI) / 3;\n  return x === 0\n    ? 0\n    : x === 1\n      ? 1\n      : -Math.pow(2, 10 * x - 10) * Math.sin((x * 10 - 10.75) * c4);\n}\n\n/** Ease out with elastic bounce */\nexport function easeOutElastic(x: number): number {\n  const c4 = (2 * Math.PI) / 3;\n  return x === 0\n    ? 0\n    : x === 1\n      ? 1\n      : Math.pow(2, -10 * x) * Math.sin((x * 10 - 0.75) * c4) + 1;\n}\n\n/** Ease in-out with elastic bounce */\nexport function easeInOutElastic(x: number): number {\n  const c5 = (2 * Math.PI) / 4.5;\n  return x === 0\n    ? 0\n    : x === 1\n      ? 1\n      : x < 0.5\n        ? -(Math.pow(2, 20 * x - 10) * Math.sin((20 * x - 11.125) * c5)) / 2\n        : (Math.pow(2, -20 * x + 10) * Math.sin((20 * x - 11.125) * c5)) / 2 +\n          1;\n}\n\n// Bounce\n\n/** Ease out with bounce */\nexport function easeOutBounce(x: number): number {\n  const n1 = 7.5625;\n  const d1 = 2.75;\n\n  if (x < 1 / d1) {\n    return n1 * x * x;\n  } else if (x < 2 / d1) {\n    return n1 * (x -= 1.5 / d1) * x + 0.75;\n  } else if (x < 2.5 / d1) {\n    return n1 * (x -= 2.25 / d1) * x + 0.9375;\n  } else {\n    return n1 * (x -= 2.625 / d1) * x + 0.984375;\n  }\n}\n\n/** Ease in with bounce */\nexport function easeInBounce(x: number): number {\n  return 1 - easeOutBounce(1 - x);\n}\n\n/** Ease in-out with bounce */\nexport function easeInOutBounce(x: number): number {\n  return x < 0.5\n    ? (1 - easeOutBounce(1 - 2 * x)) / 2\n    : (1 + easeOutBounce(2 * x - 1)) / 2;\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@effing/tween",
+  "version": "0.1.0",
+  "description": "Tweening and easing functions for animations",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "animation",
+    "easing",
+    "tween",
+    "interpolation"
+  ],
+  "license": "O'Saasy",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}