@flighthq/tween 0.1.0

package/dist/updateTweens.js

@@ -0,0 +1,78 @@
+import { emitSignal } from '@flighthq/signals';
+import { initializeTween } from './internal';
+export function completeTween(tween) {
+    if (tween.complete)
+        return;
+    if (!tween.initialized)
+        initializeTween(tween);
+    const effectiveT = tween.reverse ? 0 : 1;
+    const easedT = tween.ease(effectiveT);
+    const target = tween.target;
+    for (const detail of tween.properties) {
+        let value = detail.start + detail.change * easedT;
+        if (tween.snapping)
+            value = Math.round(value);
+        target[detail.key] = value;
+    }
+    tween.complete = true;
+    emitSignal(tween.onComplete);
+}
+function updateTween(tween, deltaTime) {
+    if (tween.paused || tween.complete)
+        return;
+    tween.elapsed += deltaTime;
+    const activeElapsed = tween.elapsed - tween.delay;
+    if (activeElapsed <= 0)
+        return;
+    if (!tween.initialized)
+        initializeTween(tween);
+    const t = Math.min(activeElapsed / tween.duration, 1);
+    const effectiveT = tween.reverse ? 1 - t : t;
+    const easedT = tween.ease(effectiveT);
+    const target = tween.target;
+    for (const detail of tween.properties) {
+        let value = detail.start + detail.change * easedT;
+        if (tween.snapping)
+            value = Math.round(value);
+        target[detail.key] = value;
+    }
+    emitSignal(tween.onUpdate);
+    if (t >= 1) {
+        if (tween.repeat === 0) {
+            tween.complete = true;
+            emitSignal(tween.onComplete);
+        }
+        else {
+            if (tween.reflect) {
+                tween.reverse = !tween.reverse;
+                emitSignal(tween.onYoyo);
+            }
+            tween.elapsed = tween.delay;
+            if (tween.repeat > 0)
+                tween.repeat--;
+            emitSignal(tween.onRepeat);
+        }
+    }
+}
+// Time is unit-agnostic. `deltaTime` here and every duration value (`duration`,
+// `delay`, `repeatDelay`, `each`) pass through unchanged in whatever unit the
+// caller supplies — there is no built-in seconds assumption. The only contract
+// is consistency: feed `updateTweens` and the duration fields the same unit
+// (all seconds, or all milliseconds, or all frames). The package never converts.
+export function updateTweens(manager, deltaTime) {
+    for (const [target, list] of manager.tweens) {
+        let i = list.length - 1;
+        while (i >= 0) {
+            if (list[i].complete) {
+                list.splice(i, 1);
+            }
+            else {
+                updateTween(list[i], deltaTime);
+            }
+            i--;
+        }
+        if (list.length === 0)
+            manager.tweens.delete(target);
+    }
+}
+//# sourceMappingURL=updateTweens.js.map

package/dist/updateTweens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"updateTweens.js","sourceRoot":"","sources":["../src/updateTweens.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@flighthq/tween",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/easing": "0.1.0",
+    "@flighthq/signals": "0.1.0",
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "Tween animation system with easing functions",
+  "sideEffects": false
+}

package/src/colorTween.test.ts

@@ -0,0 +1,48 @@
+import { createColorTween } from './colorTween';
+import { createTweenManager } from './tweenManager';
+import { updateTweens } from './updateTweens';
+
+describe('createColorTween', () => {
+  it('reaches the target color after full duration', () => {
+    const manager = createTweenManager();
+    const target = { color: 0xff0000 }; // red
+    createColorTween(manager, target, 'color', 1000, 0x0000ff); // to blue
+    updateTweens(manager, 1000);
+    expect(target.color).toBe(0x0000ff);
+  });
+
+  it('starts from the current color value', () => {
+    const manager = createTweenManager();
+    const target = { color: 0x00ff00 }; // green
+    createColorTween(manager, target, 'color', 1000, 0xff0000, { ease: (t) => t });
+    updateTweens(manager, 1000);
+    expect(target.color).toBe(0xff0000);
+  });
+
+  it('writes an integer color on each update', () => {
+    const manager = createTweenManager();
+    const target = { color: 0x000000 };
+    createColorTween(manager, target, 'color', 1000, 0xffffff, { ease: (t) => t });
+    updateTweens(manager, 500);
+    expect(Number.isInteger(target.color)).toBe(true);
+  });
+
+  it('interpolates components independently at the midpoint', () => {
+    const manager = createTweenManager();
+    const target = { color: 0xff0000 }; // red: r=255 g=0 b=0
+    createColorTween(manager, target, 'color', 1000, 0x0000ff, { ease: (t) => t }); // blue: r=0 g=0 b=255
+    updateTweens(manager, 500);
+    // midpoint: r≈128, g=0, b≈128 → 0x800080
+    const r = (target.color >> 16) & 0xff;
+    const b = target.color & 0xff;
+    expect(r).toBeCloseTo(128, 0);
+    expect(b).toBeCloseTo(128, 0);
+  });
+
+  it('does not affect the target before any update', () => {
+    const manager = createTweenManager();
+    const target = { color: 0xabcdef };
+    createColorTween(manager, target, 'color', 1000, 0x000000);
+    expect(target.color).toBe(0xabcdef);
+  });
+});

package/src/timer.test.ts

@@ -0,0 +1,56 @@
+import { connectSignal } from '@flighthq/signals';
+
+import { createTweenTimer } from './timer';
+import { createTweenManager } from './tweenManager';
+import { updateTweens } from './updateTweens';
+
+describe('createTweenTimer', () => {
+  it('fires onComplete after the specified duration', () => {
+    const manager = createTweenManager();
+    const timer = createTweenTimer(manager, 1000);
+    let fired = 0;
+    connectSignal(timer.onComplete, () => fired++);
+    updateTweens(manager, 1000);
+    expect(fired).toBe(1);
+  });
+
+  it('does not fire onComplete before duration elapses', () => {
+    const manager = createTweenManager();
+    const timer = createTweenTimer(manager, 1000);
+    let fired = 0;
+    connectSignal(timer.onComplete, () => fired++);
+    updateTweens(manager, 500);
+    expect(fired).toBe(0);
+  });
+
+  it('respects the delay option', () => {
+    const manager = createTweenManager();
+    const timer = createTweenTimer(manager, 1000, { delay: 500 });
+    let fired = 0;
+    connectSignal(timer.onComplete, () => fired++);
+    updateTweens(manager, 1000);
+    expect(fired).toBe(0);
+    updateTweens(manager, 500);
+    expect(fired).toBe(1);
+  });
+
+  it('each call produces an independent sentinel target', () => {
+    const manager = createTweenManager();
+    const t1 = createTweenTimer(manager, 1000);
+    const t2 = createTweenTimer(manager, 1000);
+    expect(t1.target).not.toBe(t2.target);
+    expect(manager.tweens.size).toBe(2);
+  });
+
+  it('fires onRepeat and keeps running when repeat: -1', () => {
+    const manager = createTweenManager();
+    const timer = createTweenTimer(manager, 1000, { repeat: -1 });
+    let ticks = 0;
+    connectSignal(timer.onRepeat, () => ticks++);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    updateTweens(manager, 1000);
+    expect(ticks).toBe(3);
+    expect(timer.complete).toBe(false);
+  });
+});

package/src/tween.test.ts

@@ -0,0 +1,385 @@
+import { connectSignal } from '@flighthq/signals';
+
+import {
+  applyTween,
+  createTween,
+  getActiveTweenCount,
+  getTweensOf,
+  hasTweensOf,
+  killTweensOfProperty,
+  pauseAllTweens,
+  pauseTween,
+  pauseTweens,
+  resetAllTweens,
+  resumeAllTweens,
+  resumeTween,
+  resumeTweens,
+  stopAllTweens,
+  stopTween,
+  stopTweens,
+} from './tween';
+import { createTweenManager } from './tweenManager';
+import { updateTweens } from './updateTweens';
+
+describe('applyTween', () => {
+  it('immediately sets properties on target', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    applyTween(manager, target, { x: 50 });
+    expect(target.x).toBe(50);
+  });
+
+  it('stops conflicting tweens before applying', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    applyTween(manager, target, { x: 50 });
+    expect(tween.complete).toBe(true);
+    expect(target.x).toBe(50);
+  });
+});
+
+describe('createTween', () => {
+  it('registers with manager', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 });
+    expect(manager.tweens.has(target)).toBe(true);
+  });
+
+  it('uses defaultManager when no manager provided', () => {
+    const target = { x: 0 };
+    const tween = createTween(target, 1000, { x: 100 });
+    expect(tween.target).toBe(target);
+  });
+
+  it('stops existing tween on same property when overwrite=true', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const first = createTween(manager, target, 1000, { x: 100 });
+    createTween(manager, target, 1000, { x: 200 });
+    expect(first.complete).toBe(true);
+  });
+
+  it('does not stop existing tween when overwrite=false', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const first = createTween(manager, target, 1000, { x: 100 });
+    createTween(manager, target, 1000, { x: 200 }, { overwrite: false });
+    expect(first.complete).toBe(false);
+  });
+
+  it('does not stop existing tween with non-overlapping properties', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    const first = createTween(manager, target, 1000, { x: 100 });
+    createTween(manager, target, 1000, { y: 200 });
+    expect(first.complete).toBe(false);
+  });
+
+  it('initializes with correct defaults', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    expect(tween.complete).toBe(false);
+    expect(tween.elapsed).toBe(0);
+    expect(tween.paused).toBe(false);
+    expect(tween.repeat).toBe(0);
+    expect(tween.reflect).toBe(false);
+    expect(tween.reverse).toBe(false);
+    expect(tween.smartRotation).toBe(false);
+    expect(tween.snapping).toBe(false);
+  });
+
+  it('pre-allocates properties array from propertyMap at creation', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0, y: 0 }, 1000, { x: 100, y: 200 });
+    expect(tween.properties).toHaveLength(2);
+    expect(tween.properties.map((d) => d.key)).toEqual(expect.arrayContaining(['x', 'y']));
+  });
+});
+
+describe('getActiveTweenCount', () => {
+  it('returns 0 for an empty manager', () => {
+    const manager = createTweenManager();
+    expect(getActiveTweenCount(manager)).toBe(0);
+  });
+
+  it('counts total tweens across all targets', () => {
+    const manager = createTweenManager();
+    createTween(manager, { x: 0 }, 1000, { x: 100 });
+    createTween(manager, { y: 0 }, 1000, { y: 100 });
+    expect(getActiveTweenCount(manager)).toBe(2);
+  });
+
+  it('decreases after tweens complete and are cleaned up', () => {
+    const manager = createTweenManager();
+    createTween(manager, { x: 0 }, 1000, { x: 100 });
+    updateTweens(manager, 1000);
+    updateTweens(manager, 0); // cleanup pass
+    expect(getActiveTweenCount(manager)).toBe(0);
+  });
+});
+
+describe('getTweensOf', () => {
+  it('returns empty array when target has no tweens', () => {
+    const manager = createTweenManager();
+    expect(getTweensOf(manager, {})).toEqual([]);
+  });
+
+  it('returns the tweens registered for a target', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    const t1 = createTween(manager, target, 1000, { x: 100 });
+    const t2 = createTween(manager, target, 1000, { y: 100 }, { overwrite: false });
+    const result = getTweensOf(manager, target);
+    expect(result).toContain(t1);
+    expect(result).toContain(t2);
+  });
+});
+
+describe('hasTweensOf', () => {
+  it('returns false when target has no tweens', () => {
+    const manager = createTweenManager();
+    expect(hasTweensOf(manager, {})).toBe(false);
+  });
+
+  it('returns true when target has active tweens', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 });
+    expect(hasTweensOf(manager, target)).toBe(true);
+  });
+
+  it('returns false after all tweens for that target complete and are cleaned up', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 });
+    updateTweens(manager, 1000);
+    updateTweens(manager, 0); // cleanup pass
+    expect(hasTweensOf(manager, target)).toBe(false);
+  });
+});
+
+describe('killTweensOfProperty', () => {
+  it('marks all tweens with the given property as complete', () => {
+    const manager = createTweenManager();
+    const a = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    const b = createTween(manager, { x: 0 }, 1000, { x: 200 }, { overwrite: false });
+    killTweensOfProperty(manager, 'x');
+    expect(a.complete).toBe(true);
+    expect(b.complete).toBe(true);
+  });
+
+  it('does not affect tweens without the given property', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    const a = createTween(manager, target, 1000, { x: 100 });
+    const b = createTween(manager, target, 1000, { y: 100 }, { overwrite: false });
+    killTweensOfProperty(manager, 'x');
+    expect(a.complete).toBe(true);
+    expect(b.complete).toBe(false);
+  });
+
+  it('is a no-op when no tweens match', () => {
+    const manager = createTweenManager();
+    createTween(manager, { x: 0 }, 1000, { x: 100 });
+    expect(() => killTweensOfProperty(manager, 'z')).not.toThrow();
+  });
+
+  it('kills matching tweens across multiple targets', () => {
+    const manager = createTweenManager();
+    const t1 = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    const t2 = createTween(manager, { x: 0 }, 1000, { x: 200 });
+    killTweensOfProperty(manager, 'x');
+    expect(t1.complete).toBe(true);
+    expect(t2.complete).toBe(true);
+  });
+});
+
+describe('pauseAllTweens', () => {
+  it('sets paused=true on every tween in the manager', () => {
+    const manager = createTweenManager();
+    const a = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseAllTweens(manager);
+    expect(a.paused).toBe(true);
+  });
+});
+
+describe('pauseTween', () => {
+  it('sets paused to true on a single tween', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseTween(tween);
+    expect(tween.paused).toBe(true);
+  });
+});
+
+describe('pauseTweens', () => {
+  it('pauses only tweens for the given target', () => {
+    const manager = createTweenManager();
+    const t = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseTweens(manager, t.target);
+    expect(t.paused).toBe(true);
+  });
+});
+
+describe('resetAllTweens', () => {
+  it('removes all tweens from the manager without completing them', () => {
+    const manager = createTweenManager();
+    const a = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    const b = createTween(manager, { y: 0 }, 1000, { y: 100 });
+    resetAllTweens(manager);
+    expect(manager.tweens.size).toBe(0);
+    expect(a.complete).toBe(false);
+    expect(b.complete).toBe(false);
+  });
+});
+
+describe('resumeAllTweens', () => {
+  it('sets paused=false on every tween in the manager', () => {
+    const manager = createTweenManager();
+    const a = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseAllTweens(manager);
+    resumeAllTweens(manager);
+    expect(a.paused).toBe(false);
+  });
+});
+
+describe('resumeTween', () => {
+  it('sets paused to false on a single tween', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseTween(tween);
+    resumeTween(tween);
+    expect(tween.paused).toBe(false);
+  });
+});
+
+describe('resumeTweens', () => {
+  it('resumes only tweens for the given target', () => {
+    const manager = createTweenManager();
+    const t = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    pauseTweens(manager, t.target);
+    resumeTweens(manager, t.target);
+    expect(t.paused).toBe(false);
+  });
+});
+
+describe('stopAllTweens', () => {
+  it('marks every tween in the manager as complete', () => {
+    const manager = createTweenManager();
+    const a = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    stopAllTweens(manager);
+    expect(a.complete).toBe(true);
+  });
+});
+
+describe('stopTween', () => {
+  it('marks a single tween as complete', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    stopTween(tween);
+    expect(tween.complete).toBe(true);
+  });
+
+  it('leaves the target value at its current position, does not jump to end', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50);
+    stopTween(tween);
+    expect(target.x).toBeCloseTo(50); // unchanged — pass { complete: true } to jump to end instead
+  });
+
+  it('complete: true jumps to end values before stopping', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    stopTween(tween, { complete: true });
+    expect(target.x).toBe(100);
+  });
+
+  it('complete: true fires onComplete by default', () => {
+    const manager = createTweenManager();
+    const tween = createTween(manager, { x: 0 }, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    stopTween(tween, { complete: true });
+    expect(fired).toBe(1);
+  });
+
+  it('complete: true with sendEvent: false suppresses onComplete', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    stopTween(tween, { complete: true, sendEvent: false });
+    expect(fired).toBe(0);
+    expect(target.x).toBe(100); // values still applied
+  });
+});
+
+describe('stopTweens', () => {
+  it('stops all tweens for a target', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    const a = createTween(manager, target, 1000, { x: 100 });
+    const b = createTween(manager, target, 1000, { y: 100 }, { overwrite: false });
+    stopTweens(manager, target);
+    expect(a.complete).toBe(true);
+    expect(b.complete).toBe(true);
+  });
+
+  it('stops only tweens with matching properties', () => {
+    const manager = createTweenManager();
+    const target = { x: 0, y: 0 };
+    const a = createTween(manager, target, 1000, { x: 100 });
+    const b = createTween(manager, target, 1000, { y: 100 }, { overwrite: false });
+    stopTweens(manager, target, { x: 0 });
+    expect(a.complete).toBe(true);
+    expect(b.complete).toBe(false);
+  });
+
+  it('leaves the target value at its current position, does not jump to end', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50);
+    stopTweens(manager, target);
+    expect(target.x).toBeCloseTo(50); // unchanged — use completeTween to jump to end instead
+  });
+
+  it('complete: true jumps to end values before stopping', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: (t) => t });
+    updateTweens(manager, 500);
+    stopTweens(manager, target, undefined, { complete: true });
+    expect(target.x).toBe(100);
+  });
+
+  it('complete: true fires onComplete by default', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    stopTweens(manager, target, undefined, { complete: true });
+    expect(fired).toBe(1);
+  });
+
+  it('complete: true with sendEvent: false suppresses onComplete', () => {
+    const manager = createTweenManager();
+    const target = { x: 0 };
+    const tween = createTween(manager, target, 1000, { x: 100 });
+    let fired = 0;
+    connectSignal(tween.onComplete, () => fired++);
+    stopTweens(manager, target, undefined, { complete: true, sendEvent: false });
+    expect(fired).toBe(0);
+    expect(target.x).toBe(100); // values still applied
+  });
+});

package/src/tweenManager.test.ts

@@ -0,0 +1,52 @@
+import { createTween } from './tween';
+import { createTweenManager, defaultManager } from './tweenManager';
+import { updateTweens } from './updateTweens';
+
+describe('createTweenManager', () => {
+  it('returns a TweenManager with empty tweens map', () => {
+    const manager = createTweenManager();
+    expect(manager.tweens).toBeInstanceOf(Map);
+    expect(manager.tweens.size).toBe(0);
+  });
+
+  it('each call returns a distinct instance', () => {
+    const a = createTweenManager();
+    const b = createTweenManager();
+    expect(a).not.toBe(b);
+    expect(a.tweens).not.toBe(b.tweens);
+  });
+});
+
+describe('defaultEase', () => {
+  it('defaults to easeOutExponential when no option provided', () => {
+    const manager = createTweenManager();
+    expect(typeof manager.defaultEase).toBe('function');
+    expect(manager.defaultEase(0)).toBe(0);
+    expect(manager.defaultEase(1)).toBeCloseTo(1);
+  });
+
+  it('uses provided defaultEase for tweens that omit ease option', () => {
+    const linearEase = (t: number) => t;
+    const manager = createTweenManager({ defaultEase: linearEase });
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 });
+    updateTweens(manager, 500);
+    expect(target.x).toBeCloseTo(50); // linear: exactly 50% at 50% time
+  });
+
+  it('explicit ease option overrides defaultEase', () => {
+    const linearEase = (t: number) => t;
+    const alwaysOne = () => 1;
+    const manager = createTweenManager({ defaultEase: linearEase });
+    const target = { x: 0 };
+    createTween(manager, target, 1000, { x: 100 }, { ease: alwaysOne });
+    updateTweens(manager, 1);
+    expect(target.x).toBe(100); // alwaysOne ease jumps straight to end
+  });
+});
+
+describe('defaultManager', () => {
+  it('is a TweenManager', () => {
+    expect(defaultManager.tweens).toBeInstanceOf(Map);
+  });
+});