@autumnsgrove/gossamer 0.1.1 → 0.2.0

package/src/animation.test.ts

@@ -1,254 +0,0 @@
-/**
- * Tests for animation utilities
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { throttle, debounce, calculateFPS, easings, createAnimationLoop } from './animation';
-
-describe('throttle', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('should call function immediately on first call', () => {
-    const fn = vi.fn();
-    const throttled = throttle(fn, 100);
-
-    throttled();
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should throttle subsequent calls within limit', () => {
-    const fn = vi.fn();
-    const throttled = throttle(fn, 100);
-
-    throttled();
-    throttled();
-    throttled();
-
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should call function again after limit expires', () => {
-    const fn = vi.fn();
-    const throttled = throttle(fn, 100);
-
-    throttled();
-    expect(fn).toHaveBeenCalledTimes(1);
-
-    vi.advanceTimersByTime(150);
-    throttled();
-    expect(fn).toHaveBeenCalledTimes(2);
-  });
-
-  it('should pass arguments to throttled function', () => {
-    const fn = vi.fn();
-    const throttled = throttle(fn, 100);
-
-    throttled('arg1', 'arg2');
-    expect(fn).toHaveBeenCalledWith('arg1', 'arg2');
-  });
-});
-
-describe('debounce', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it('should not call function immediately', () => {
-    const fn = vi.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced();
-    expect(fn).not.toHaveBeenCalled();
-  });
-
-  it('should call function after delay', () => {
-    const fn = vi.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced();
-    vi.advanceTimersByTime(100);
-
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should reset timer on subsequent calls', () => {
-    const fn = vi.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced();
-    vi.advanceTimersByTime(50);
-    debounced();
-    vi.advanceTimersByTime(50);
-
-    expect(fn).not.toHaveBeenCalled();
-
-    vi.advanceTimersByTime(50);
-    expect(fn).toHaveBeenCalledTimes(1);
-  });
-
-  it('should pass arguments to debounced function', () => {
-    const fn = vi.fn();
-    const debounced = debounce(fn, 100);
-
-    debounced('test', 123);
-    vi.advanceTimersByTime(100);
-
-    expect(fn).toHaveBeenCalledWith('test', 123);
-  });
-});
-
-describe('calculateFPS', () => {
-  it('should return 0 for empty array', () => {
-    expect(calculateFPS([])).toBe(0);
-  });
-
-  it('should return 0 for single frame time', () => {
-    expect(calculateFPS([1000])).toBe(0);
-  });
-
-  it('should calculate FPS correctly', () => {
-    // 60 frames over 1 second = 60 FPS
-    const frameTimes = Array.from({ length: 61 }, (_, i) => i * (1000 / 60));
-    const fps = calculateFPS(frameTimes);
-
-    expect(fps).toBeCloseTo(60, 0);
-  });
-
-  it('should handle 30 FPS', () => {
-    // 30 frames over 1 second = 30 FPS
-    const frameTimes = Array.from({ length: 31 }, (_, i) => i * (1000 / 30));
-    const fps = calculateFPS(frameTimes);
-
-    expect(fps).toBeCloseTo(30, 0);
-  });
-
-  it('should use sample size parameter', () => {
-    // Create 100 frame times
-    const frameTimes = Array.from({ length: 100 }, (_, i) => i * 16.67);
-
-    // Should only use last 10 samples
-    const fps = calculateFPS(frameTimes, 10);
-    expect(fps).toBeCloseTo(60, 0);
-  });
-});
-
-describe('easings', () => {
-  describe('linear', () => {
-    it('should return input unchanged', () => {
-      expect(easings.linear(0)).toBe(0);
-      expect(easings.linear(0.5)).toBe(0.5);
-      expect(easings.linear(1)).toBe(1);
-    });
-  });
-
-  describe('easeIn', () => {
-    it('should start slow', () => {
-      expect(easings.easeIn(0)).toBe(0);
-      expect(easings.easeIn(0.5)).toBe(0.25);
-      expect(easings.easeIn(1)).toBe(1);
-    });
-  });
-
-  describe('easeOut', () => {
-    it('should end slow', () => {
-      expect(easings.easeOut(0)).toBe(0);
-      expect(easings.easeOut(0.5)).toBe(0.75);
-      expect(easings.easeOut(1)).toBe(1);
-    });
-  });
-
-  describe('easeInOut', () => {
-    it('should start and end slow', () => {
-      expect(easings.easeInOut(0)).toBe(0);
-      expect(easings.easeInOut(0.5)).toBe(0.5);
-      expect(easings.easeInOut(1)).toBe(1);
-    });
-
-    it('should be symmetric around 0.5', () => {
-      const val1 = easings.easeInOut(0.25);
-      const val2 = 1 - easings.easeInOut(0.75);
-      expect(val1).toBeCloseTo(val2, 5);
-    });
-  });
-
-  describe('sineIn', () => {
-    it('should return 0 at start and 1 at end', () => {
-      expect(easings.sineIn(0)).toBe(0);
-      expect(easings.sineIn(1)).toBeCloseTo(1, 5);
-    });
-  });
-
-  describe('sineOut', () => {
-    it('should return 0 at start and 1 at end', () => {
-      expect(easings.sineOut(0)).toBe(0);
-      expect(easings.sineOut(1)).toBeCloseTo(1, 5);
-    });
-  });
-
-  describe('sineInOut', () => {
-    it('should return 0 at start, 0.5 at middle, 1 at end', () => {
-      expect(easings.sineInOut(0)).toBeCloseTo(0, 5);
-      expect(easings.sineInOut(0.5)).toBeCloseTo(0.5, 5);
-      expect(easings.sineInOut(1)).toBeCloseTo(1, 5);
-    });
-  });
-
-  describe('bounceOut', () => {
-    it('should return 0 at start and 1 at end', () => {
-      expect(easings.bounceOut(0)).toBe(0);
-      expect(easings.bounceOut(1)).toBeCloseTo(1, 5);
-    });
-
-    it('should overshoot intermediate values', () => {
-      // bounceOut creates bouncing effect with values close to 1
-      const val = easings.bounceOut(0.9);
-      expect(val).toBeGreaterThan(0.9);
-    });
-  });
-});
-
-describe('createAnimationLoop', () => {
-  it('should return control functions', () => {
-    const loop = createAnimationLoop({
-      onFrame: () => {},
-    });
-
-    expect(typeof loop.start).toBe('function');
-    expect(typeof loop.stop).toBe('function');
-    expect(typeof loop.pause).toBe('function');
-    expect(typeof loop.resume).toBe('function');
-    expect(typeof loop.getState).toBe('function');
-  });
-
-  it('should initialize with correct default state', () => {
-    const loop = createAnimationLoop({
-      fps: 60,
-      onFrame: () => {},
-    });
-
-    const state = loop.getState();
-    expect(state.isRunning).toBe(false);
-    expect(state.frameId).toBeNull();
-    expect(state.frameInterval).toBeCloseTo(1000 / 60, 1);
-    expect(state.elapsedTime).toBe(0);
-    expect(state.frameCount).toBe(0);
-  });
-
-  it('should use default FPS of 30', () => {
-    const loop = createAnimationLoop({
-      onFrame: () => {},
-    });
-
-    const state = loop.getState();
-    expect(state.frameInterval).toBeCloseTo(1000 / 30, 1);
-  });
-});

package/src/animation.ts

@@ -1,243 +0,0 @@
-/**
- * Gossamer Animation Utilities
- *
- * FPS limiting, animation loop management, and timing utilities.
- */
-
-/**
- * Animation state for tracking loop execution
- */
-export interface AnimationState {
-  /** Whether animation is currently running */
-  isRunning: boolean;
-  /** Current animation frame ID */
-  frameId: number | null;
-  /** Timestamp of last frame */
-  lastFrameTime: number;
-  /** Frame interval in ms (derived from FPS) */
-  frameInterval: number;
-  /** Total elapsed time in ms */
-  elapsedTime: number;
-  /** Current frame count */
-  frameCount: number;
-}
-
-/**
- * Options for creating an animation loop
- */
-export interface AnimationOptions {
-  /** Target frames per second (default: 30) */
-  fps?: number;
-  /** Callback when animation starts */
-  onStart?: () => void;
-  /** Callback when animation stops */
-  onStop?: () => void;
-  /** Callback for each frame - return false to stop */
-  onFrame: (time: number, deltaTime: number, frameCount: number) => boolean | void;
-}
-
-/**
- * Create a managed animation loop with FPS limiting
- */
-export function createAnimationLoop(options: AnimationOptions): {
-  start: () => void;
-  stop: () => void;
-  pause: () => void;
-  resume: () => void;
-  getState: () => AnimationState;
-} {
-  const { fps = 30, onStart, onStop, onFrame } = options;
-
-  const state: AnimationState = {
-    isRunning: false,
-    frameId: null,
-    lastFrameTime: 0,
-    frameInterval: 1000 / fps,
-    elapsedTime: 0,
-    frameCount: 0,
-  };
-
-  let pausedTime = 0;
-  let isPaused = false;
-
-  function animate(currentTime: number): void {
-    if (!state.isRunning || isPaused) return;
-
-    const deltaTime = currentTime - state.lastFrameTime;
-
-    if (deltaTime >= state.frameInterval) {
-      state.elapsedTime += deltaTime;
-      state.frameCount++;
-
-      const continueAnimation = onFrame(currentTime, deltaTime, state.frameCount);
-
-      if (continueAnimation === false) {
-        stop();
-        return;
-      }
-
-      // Adjust for frame timing drift
-      state.lastFrameTime = currentTime - (deltaTime % state.frameInterval);
-    }
-
-    state.frameId = requestAnimationFrame(animate);
-  }
-
-  function start(): void {
-    if (state.isRunning) return;
-
-    state.isRunning = true;
-    state.lastFrameTime = performance.now();
-    state.elapsedTime = 0;
-    state.frameCount = 0;
-    isPaused = false;
-
-    onStart?.();
-    state.frameId = requestAnimationFrame(animate);
-  }
-
-  function stop(): void {
-    state.isRunning = false;
-    isPaused = false;
-
-    if (state.frameId !== null) {
-      cancelAnimationFrame(state.frameId);
-      state.frameId = null;
-    }
-
-    onStop?.();
-  }
-
-  function pause(): void {
-    if (!state.isRunning || isPaused) return;
-
-    isPaused = true;
-    pausedTime = performance.now();
-
-    if (state.frameId !== null) {
-      cancelAnimationFrame(state.frameId);
-      state.frameId = null;
-    }
-  }
-
-  function resume(): void {
-    if (!state.isRunning || !isPaused) return;
-
-    isPaused = false;
-    // Adjust lastFrameTime to account for paused duration
-    state.lastFrameTime += performance.now() - pausedTime;
-    state.frameId = requestAnimationFrame(animate);
-  }
-
-  function getState(): AnimationState {
-    return { ...state };
-  }
-
-  return { start, stop, pause, resume, getState };
-}
-
-/**
- * Simple throttle function for limiting function execution
- */
-export function throttle<T extends (...args: unknown[]) => unknown>(
-  fn: T,
-  limit: number
-): (...args: Parameters<T>) => void {
-  let lastCall = 0;
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-
-  return (...args: Parameters<T>): void => {
-    const now = Date.now();
-
-    if (now - lastCall >= limit) {
-      lastCall = now;
-      fn(...args);
-    } else if (!timeout) {
-      timeout = setTimeout(() => {
-        lastCall = Date.now();
-        timeout = null;
-        fn(...args);
-      }, limit - (now - lastCall));
-    }
-  };
-}
-
-/**
- * Debounce function for delaying execution until activity stops
- */
-export function debounce<T extends (...args: unknown[]) => unknown>(
-  fn: T,
-  delay: number
-): (...args: Parameters<T>) => void {
-  let timeout: ReturnType<typeof setTimeout> | null = null;
-
-  return (...args: Parameters<T>): void => {
-    if (timeout) {
-      clearTimeout(timeout);
-    }
-
-    timeout = setTimeout(() => {
-      timeout = null;
-      fn(...args);
-    }, delay);
-  };
-}
-
-/**
- * Calculate actual FPS from frame times
- */
-export function calculateFPS(frameTimes: number[], sampleSize: number = 60): number {
-  if (frameTimes.length < 2) return 0;
-
-  const samples = frameTimes.slice(-sampleSize);
-  const totalTime = samples[samples.length - 1] - samples[0];
-  const frameCount = samples.length - 1;
-
-  if (totalTime <= 0) return 0;
-
-  return (frameCount / totalTime) * 1000;
-}
-
-/**
- * Easing functions for smooth animations
- */
-export const easings = {
-  /** Linear - no easing */
-  linear: (t: number): number => t,
-
-  /** Ease in - slow start */
-  easeIn: (t: number): number => t * t,
-
-  /** Ease out - slow end */
-  easeOut: (t: number): number => t * (2 - t),
-
-  /** Ease in/out - slow start and end */
-  easeInOut: (t: number): number => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
-
-  /** Sine ease in */
-  sineIn: (t: number): number => 1 - Math.cos((t * Math.PI) / 2),
-
-  /** Sine ease out */
-  sineOut: (t: number): number => Math.sin((t * Math.PI) / 2),
-
-  /** Sine ease in/out */
-  sineInOut: (t: number): number => -(Math.cos(Math.PI * t) - 1) / 2,
-
-  /** Bounce at end */
-  bounceOut: (t: number): number => {
-    const n1 = 7.5625;
-    const d1 = 2.75;
-
-    if (t < 1 / d1) {
-      return n1 * t * t;
-    } else if (t < 2 / d1) {
-      return n1 * (t -= 1.5 / d1) * t + 0.75;
-    } else if (t < 2.5 / d1) {
-      return n1 * (t -= 2.25 / d1) * t + 0.9375;
-    } else {
-      return n1 * (t -= 2.625 / d1) * t + 0.984375;
-    }
-  },
-};
-
-export type EasingFunction = (t: number) => number;

package/src/characters.test.ts

@@ -1,148 +0,0 @@
-/**
- * Tests for character set utilities
- */
-import { describe, it, expect } from 'vitest';
-import {
-  CHARACTER_SETS,
-  getCharacterSet,
-  getCharacters,
-  getCharacterSetNames,
-  createCharacterSet,
-  validateCharacterSet,
-  invertCharacters,
-} from './characters';
-
-describe('CHARACTER_SETS', () => {
-  it('should contain standard character set', () => {
-    expect(CHARACTER_SETS.standard).toBeDefined();
-    expect(CHARACTER_SETS.standard.characters).toBe(' .:-=+*#%@');
-  });
-
-  it('should have all expected character sets', () => {
-    const expectedSets = [
-      'standard',
-      'dense',
-      'minimal',
-      'grove',
-      'dots',
-      'blocks',
-      'lines',
-      'stars',
-      'nature',
-      'weather',
-      'binary',
-      'math',
-    ];
-
-    for (const setName of expectedSets) {
-      expect(CHARACTER_SETS[setName]).toBeDefined();
-    }
-  });
-
-  it('should have all character sets start with space', () => {
-    for (const [name, set] of Object.entries(CHARACTER_SETS)) {
-      expect(set.characters[0]).toBe(' ');
-    }
-  });
-});
-
-describe('getCharacterSet', () => {
-  it('should return character set by name', () => {
-    const result = getCharacterSet('standard');
-    expect(result).toBeDefined();
-    expect(result?.name).toBe('Standard');
-    expect(result?.characters).toBe(' .:-=+*#%@');
-  });
-
-  it('should return undefined for unknown set', () => {
-    const result = getCharacterSet('nonexistent');
-    expect(result).toBeUndefined();
-  });
-});
-
-describe('getCharacters', () => {
-  it('should return characters string for valid set', () => {
-    expect(getCharacters('minimal')).toBe(' .:*#');
-    expect(getCharacters('blocks')).toBe(' ░▒▓█');
-  });
-
-  it('should return standard characters for unknown set', () => {
-    expect(getCharacters('nonexistent')).toBe(' .:-=+*#%@');
-  });
-});
-
-describe('getCharacterSetNames', () => {
-  it('should return array of all set names', () => {
-    const names = getCharacterSetNames();
-    expect(Array.isArray(names)).toBe(true);
-    expect(names).toContain('standard');
-    expect(names).toContain('minimal');
-    expect(names).toContain('blocks');
-  });
-
-  it('should return same count as CHARACTER_SETS keys', () => {
-    const names = getCharacterSetNames();
-    expect(names.length).toBe(Object.keys(CHARACTER_SETS).length);
-  });
-});
-
-describe('createCharacterSet', () => {
-  it('should create character set with all properties', () => {
-    const result = createCharacterSet(
-      'custom',
-      ' abc',
-      'A custom set',
-      ['testing']
-    );
-
-    expect(result.name).toBe('custom');
-    expect(result.characters).toBe(' abc');
-    expect(result.description).toBe('A custom set');
-    expect(result.bestFor).toEqual(['testing']);
-  });
-
-  it('should use defaults for optional parameters', () => {
-    const result = createCharacterSet('minimal', ' xy');
-
-    expect(result.name).toBe('minimal');
-    expect(result.characters).toBe(' xy');
-    expect(result.description).toBe('');
-    expect(result.bestFor).toEqual([]);
-  });
-});
-
-describe('validateCharacterSet', () => {
-  it('should return true for valid character sets', () => {
-    expect(validateCharacterSet(' .:-=+*#%@')).toBe(true);
-    expect(validateCharacterSet(' ab')).toBe(true);
-    expect(validateCharacterSet(' ░▒▓█')).toBe(true);
-  });
-
-  it('should return false for too short sets', () => {
-    expect(validateCharacterSet('')).toBe(false);
-    expect(validateCharacterSet(' ')).toBe(false);
-  });
-
-  it('should return false for sets not starting with space', () => {
-    expect(validateCharacterSet('abc')).toBe(false);
-    expect(validateCharacterSet('.:-=')).toBe(false);
-  });
-});
-
-describe('invertCharacters', () => {
-  it('should reverse character string', () => {
-    expect(invertCharacters(' abc')).toBe('cba ');
-    expect(invertCharacters(' .:-=')).toBe('=-:. ');
-  });
-
-  it('should handle single character', () => {
-    expect(invertCharacters(' ')).toBe(' ');
-  });
-
-  it('should be reversible', () => {
-    const original = ' .:-=+*#%@';
-    const inverted = invertCharacters(original);
-    const restored = invertCharacters(inverted);
-    expect(restored).toBe(original);
-  });
-});