@autumnsgrove/gossamer 0.1.0 → 0.2.0

package/src/patterns.test.ts

@@ -1,273 +0,0 @@
-/**
- * Tests for pattern generators
- */
-import { describe, it, expect } from 'vitest';
-import {
-  perlinNoise2D,
-  fbmNoise,
-  wavePattern,
-  ripplePattern,
-  staticNoise,
-  seededNoise2D,
-  generateBrightnessGrid,
-  gridToImageData,
-  DEFAULT_PATTERN_CONFIG,
-} from './patterns';
-
-describe('perlinNoise2D', () => {
-  it('should return value between -1 and 1', () => {
-    for (let i = 0; i < 100; i++) {
-      const x = Math.random() * 100;
-      const y = Math.random() * 100;
-      const value = perlinNoise2D(x, y);
-      expect(value).toBeGreaterThanOrEqual(-1);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should be deterministic (same input = same output)', () => {
-    const val1 = perlinNoise2D(5.5, 3.2);
-    const val2 = perlinNoise2D(5.5, 3.2);
-    expect(val1).toBe(val2);
-  });
-
-  it('should vary with position', () => {
-    // Use non-integer coordinates (Perlin returns 0 at integer coords)
-    const val1 = perlinNoise2D(0.5, 0.5);
-    const val2 = perlinNoise2D(10.5, 10.5);
-    expect(val1).not.toBe(val2);
-  });
-
-  it('should produce smooth transitions', () => {
-    const val1 = perlinNoise2D(1.0, 1.0);
-    const val2 = perlinNoise2D(1.01, 1.01);
-    const diff = Math.abs(val1 - val2);
-    expect(diff).toBeLessThan(0.1);
-  });
-});
-
-describe('fbmNoise', () => {
-  it('should return value between -1 and 1', () => {
-    for (let i = 0; i < 50; i++) {
-      const x = Math.random() * 100;
-      const y = Math.random() * 100;
-      const value = fbmNoise(x, y);
-      expect(value).toBeGreaterThanOrEqual(-1);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should be deterministic', () => {
-    const val1 = fbmNoise(3.3, 7.7);
-    const val2 = fbmNoise(3.3, 7.7);
-    expect(val1).toBe(val2);
-  });
-
-  it('should accept octaves parameter', () => {
-    // Use non-integer coordinates (noise returns 0 at integer coords)
-    const val1 = fbmNoise(5.5, 5.5, 2);
-    const val2 = fbmNoise(5.5, 5.5, 8);
-    // Different octaves should produce different results
-    expect(val1).not.toBe(val2);
-  });
-
-  it('should accept persistence parameter', () => {
-    // Use non-integer coordinates (noise returns 0 at integer coords)
-    const val1 = fbmNoise(5.5, 5.5, 4, 0.3);
-    const val2 = fbmNoise(5.5, 5.5, 4, 0.7);
-    expect(val1).not.toBe(val2);
-  });
-});
-
-describe('wavePattern', () => {
-  it('should return value between -1 and 1', () => {
-    for (let t = 0; t < 10; t++) {
-      const value = wavePattern(50, 50, t);
-      expect(value).toBeGreaterThanOrEqual(-1);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should vary with time', () => {
-    const val1 = wavePattern(10, 10, 0);
-    const val2 = wavePattern(10, 10, 5);
-    expect(val1).not.toBe(val2);
-  });
-
-  it('should use custom config', () => {
-    const config = { frequency: 0.1, amplitude: 0.5, speed: 1.0 };
-    const value = wavePattern(10, 10, 1, config);
-    expect(Math.abs(value)).toBeLessThanOrEqual(0.5);
-  });
-});
-
-describe('ripplePattern', () => {
-  it('should return value between -1 and 1', () => {
-    for (let i = 0; i < 50; i++) {
-      const value = ripplePattern(
-        Math.random() * 100,
-        Math.random() * 100,
-        50,
-        50,
-        Math.random() * 10
-      );
-      expect(value).toBeGreaterThanOrEqual(-1);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should vary with distance from center', () => {
-    const centerVal = ripplePattern(50, 50, 50, 50, 0);
-    const edgeVal = ripplePattern(100, 50, 50, 50, 0);
-    expect(centerVal).not.toBe(edgeVal);
-  });
-
-  it('should animate over time', () => {
-    const val1 = ripplePattern(60, 60, 50, 50, 0);
-    const val2 = ripplePattern(60, 60, 50, 50, 1);
-    expect(val1).not.toBe(val2);
-  });
-});
-
-describe('staticNoise', () => {
-  it('should return value between 0 and 1', () => {
-    for (let i = 0; i < 100; i++) {
-      const value = staticNoise();
-      expect(value).toBeGreaterThanOrEqual(0);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should be deterministic with seed', () => {
-    const val1 = staticNoise(12345);
-    const val2 = staticNoise(12345);
-    expect(val1).toBe(val2);
-  });
-
-  it('should vary with different seeds', () => {
-    const val1 = staticNoise(1);
-    const val2 = staticNoise(2);
-    expect(val1).not.toBe(val2);
-  });
-});
-
-describe('seededNoise2D', () => {
-  it('should return value between 0 and 1', () => {
-    for (let i = 0; i < 100; i++) {
-      const value = seededNoise2D(Math.random() * 100, Math.random() * 100);
-      expect(value).toBeGreaterThanOrEqual(0);
-      expect(value).toBeLessThanOrEqual(1);
-    }
-  });
-
-  it('should be deterministic', () => {
-    const val1 = seededNoise2D(5, 10, 42);
-    const val2 = seededNoise2D(5, 10, 42);
-    expect(val1).toBe(val2);
-  });
-
-  it('should vary with coordinates', () => {
-    const val1 = seededNoise2D(0, 0);
-    const val2 = seededNoise2D(10, 10);
-    expect(val1).not.toBe(val2);
-  });
-
-  it('should vary with seed', () => {
-    const val1 = seededNoise2D(5, 5, 0);
-    const val2 = seededNoise2D(5, 5, 100);
-    expect(val1).not.toBe(val2);
-  });
-});
-
-describe('DEFAULT_PATTERN_CONFIG', () => {
-  it('should have expected default values', () => {
-    expect(DEFAULT_PATTERN_CONFIG.frequency).toBe(0.05);
-    expect(DEFAULT_PATTERN_CONFIG.amplitude).toBe(1.0);
-    expect(DEFAULT_PATTERN_CONFIG.speed).toBe(0.5);
-  });
-});
-
-describe('generateBrightnessGrid', () => {
-  it('should generate grid with correct dimensions', () => {
-    const grid = generateBrightnessGrid(10, 8, 'perlin');
-    expect(grid.length).toBe(8); // rows
-    expect(grid[0].length).toBe(10); // cols
-  });
-
-  it('should generate brightness values between 0 and 255', () => {
-    const grid = generateBrightnessGrid(20, 15, 'perlin');
-    for (const row of grid) {
-      for (const value of row) {
-        expect(value).toBeGreaterThanOrEqual(0);
-        expect(value).toBeLessThanOrEqual(255);
-        expect(Number.isInteger(value)).toBe(true);
-      }
-    }
-  });
-
-  it('should support all pattern types', () => {
-    const patterns: Array<'perlin' | 'waves' | 'static' | 'ripple' | 'fbm'> = [
-      'perlin',
-      'waves',
-      'static',
-      'ripple',
-      'fbm',
-    ];
-
-    for (const pattern of patterns) {
-      const grid = generateBrightnessGrid(5, 5, pattern);
-      expect(grid.length).toBe(5);
-      expect(grid[0].length).toBe(5);
-    }
-  });
-
-  it('should use time parameter for animation', () => {
-    const grid1 = generateBrightnessGrid(10, 10, 'perlin', 0);
-    const grid2 = generateBrightnessGrid(10, 10, 'perlin', 100);
-
-    // At least some values should differ
-    let hasDifference = false;
-    for (let r = 0; r < 10 && !hasDifference; r++) {
-      for (let c = 0; c < 10 && !hasDifference; c++) {
-        if (grid1[r][c] !== grid2[r][c]) {
-          hasDifference = true;
-        }
-      }
-    }
-    expect(hasDifference).toBe(true);
-  });
-});
-
-// Note: gridToImageData tests require browser environment with canvas support
-// These tests are skipped in Node.js/jsdom as ImageData is not available
-describe.skip('gridToImageData (browser only)', () => {
-  it('should create ImageData with correct dimensions', () => {
-    const grid = [
-      [100, 150],
-      [200, 50],
-    ];
-    const imageData = gridToImageData(grid, 8, 12);
-
-    expect(imageData.width).toBe(16); // 2 cols * 8
-    expect(imageData.height).toBe(24); // 2 rows * 12
-  });
-
-  it('should fill cells with brightness values', () => {
-    const grid = [[128]]; // Single cell
-    const imageData = gridToImageData(grid, 2, 2);
-
-    // Check first pixel (should be brightness 128)
-    expect(imageData.data[0]).toBe(128); // R
-    expect(imageData.data[1]).toBe(128); // G
-    expect(imageData.data[2]).toBe(128); // B
-    expect(imageData.data[3]).toBe(255); // A (full opacity)
-  });
-
-  it('should handle empty grid', () => {
-    const grid: number[][] = [];
-    const imageData = gridToImageData(grid, 8, 12);
-
-    expect(imageData.width).toBe(0);
-    expect(imageData.height).toBe(0);
-  });
-});

package/src/patterns.ts

@@ -1,316 +0,0 @@
-/**
- * Gossamer Pattern Generators
- *
- * Provides noise and pattern generation functions for ambient ASCII effects.
- * Includes Perlin noise, wave patterns, and static noise.
- */
-
-/**
- * Configuration for pattern generation
- */
-export interface PatternConfig {
-  /** Pattern scale - higher values create finer detail */
-  frequency: number;
-  /** Pattern intensity multiplier */
-  amplitude: number;
-  /** Animation speed multiplier */
-  speed: number;
-}
-
-/**
- * Default pattern configuration
- */
-export const DEFAULT_PATTERN_CONFIG: PatternConfig = {
-  frequency: 0.05,
-  amplitude: 1.0,
-  speed: 0.5,
-};
-
-// Permutation table for Perlin noise
-const PERMUTATION = new Uint8Array(512);
-const P = new Uint8Array([
-  151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225, 140, 36, 103, 30, 69, 142,
-  8, 99, 37, 240, 21, 10, 23, 190, 6, 148, 247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203,
-  117, 35, 11, 32, 57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175, 74, 165,
-  71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122, 60, 211, 133, 230, 220, 105, 92,
-  41, 55, 46, 245, 40, 244, 102, 143, 54, 65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208,
-  89, 18, 169, 200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64, 52, 217,
-  226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212, 207, 206, 59, 227, 47, 16, 58,
-  17, 182, 189, 28, 42, 223, 183, 170, 213, 119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155,
-  167, 43, 172, 9, 129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104, 218,
-  246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241, 81, 51, 145, 235, 249,
-  14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157, 184, 84, 204, 176, 115, 121, 50, 45, 127, 4,
-  150, 254, 138, 236, 205, 93, 222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156,
-  180,
-]);
-
-// Initialize permutation table
-for (let i = 0; i < 256; i++) {
-  PERMUTATION[i] = P[i];
-  PERMUTATION[i + 256] = P[i];
-}
-
-/**
- * Fade function for smooth interpolation (6t^5 - 15t^4 + 10t^3)
- */
-function fade(t: number): number {
-  return t * t * t * (t * (t * 6 - 15) + 10);
-}
-
-/**
- * Linear interpolation
- */
-function lerp(a: number, b: number, t: number): number {
-  return a + t * (b - a);
-}
-
-/**
- * Gradient function for Perlin noise
- */
-function grad(hash: number, x: number, y: number): number {
-  const h = hash & 3;
-  const u = h < 2 ? x : y;
-  const v = h < 2 ? y : x;
-  return ((h & 1) === 0 ? u : -u) + ((h & 2) === 0 ? v : -v);
-}
-
-/**
- * 2D Perlin noise function
- *
- * @param x - X coordinate
- * @param y - Y coordinate
- * @returns Noise value between -1 and 1
- */
-export function perlinNoise2D(x: number, y: number): number {
-  // Find unit square containing point
-  const xi = Math.floor(x) & 255;
-  const yi = Math.floor(y) & 255;
-
-  // Find relative position in square
-  const xf = x - Math.floor(x);
-  const yf = y - Math.floor(y);
-
-  // Fade curves
-  const u = fade(xf);
-  const v = fade(yf);
-
-  // Hash coordinates of square corners
-  const aa = PERMUTATION[PERMUTATION[xi] + yi];
-  const ab = PERMUTATION[PERMUTATION[xi] + yi + 1];
-  const ba = PERMUTATION[PERMUTATION[xi + 1] + yi];
-  const bb = PERMUTATION[PERMUTATION[xi + 1] + yi + 1];
-
-  // Blend results from 4 corners
-  const x1 = lerp(grad(aa, xf, yf), grad(ba, xf - 1, yf), u);
-  const x2 = lerp(grad(ab, xf, yf - 1), grad(bb, xf - 1, yf - 1), u);
-
-  return lerp(x1, x2, v);
-}
-
-/**
- * Fractal Brownian Motion (fBm) using Perlin noise
- * Creates more organic-looking noise by layering multiple octaves
- *
- * @param x - X coordinate
- * @param y - Y coordinate
- * @param octaves - Number of noise layers (default: 4)
- * @param persistence - Amplitude decay per octave (default: 0.5)
- * @returns Noise value between -1 and 1
- */
-export function fbmNoise(x: number, y: number, octaves: number = 4, persistence: number = 0.5): number {
-  let total = 0;
-  let frequency = 1;
-  let amplitude = 1;
-  let maxValue = 0;
-
-  for (let i = 0; i < octaves; i++) {
-    total += perlinNoise2D(x * frequency, y * frequency) * amplitude;
-    maxValue += amplitude;
-    amplitude *= persistence;
-    frequency *= 2;
-  }
-
-  return total / maxValue;
-}
-
-/**
- * Wave pattern generator
- *
- * @param x - X coordinate
- * @param y - Y coordinate
- * @param time - Time value for animation
- * @param config - Pattern configuration
- * @returns Value between -1 and 1
- */
-export function wavePattern(
-  x: number,
-  y: number,
-  time: number,
-  config: PatternConfig = DEFAULT_PATTERN_CONFIG
-): number {
-  const { frequency, amplitude, speed } = config;
-  const wave1 = Math.sin(x * frequency + time * speed);
-  const wave2 = Math.cos(y * frequency + time * speed * 0.7);
-  const wave3 = Math.sin((x + y) * frequency * 0.5 + time * speed * 0.5);
-
-  return ((wave1 + wave2 + wave3) / 3) * amplitude;
-}
-
-/**
- * Ripple pattern (concentric waves from center)
- *
- * @param x - X coordinate
- * @param y - Y coordinate
- * @param centerX - Ripple center X
- * @param centerY - Ripple center Y
- * @param time - Time value for animation
- * @param config - Pattern configuration
- * @returns Value between -1 and 1
- */
-export function ripplePattern(
-  x: number,
-  y: number,
-  centerX: number,
-  centerY: number,
-  time: number,
-  config: PatternConfig = DEFAULT_PATTERN_CONFIG
-): number {
-  const { frequency, amplitude, speed } = config;
-  const dx = x - centerX;
-  const dy = y - centerY;
-  const distance = Math.sqrt(dx * dx + dy * dy);
-
-  return Math.sin(distance * frequency - time * speed) * amplitude;
-}
-
-/**
- * Static noise generator (random values)
- *
- * @param seed - Optional seed for reproducible noise
- * @returns Value between 0 and 1
- */
-export function staticNoise(seed?: number): number {
-  if (seed !== undefined) {
-    // Simple seeded random using sine
-    const x = Math.sin(seed * 12.9898) * 43758.5453;
-    return x - Math.floor(x);
-  }
-  return Math.random();
-}
-
-/**
- * Seeded 2D noise for reproducible patterns
- *
- * @param x - X coordinate
- * @param y - Y coordinate
- * @param seed - Seed value
- * @returns Value between 0 and 1
- */
-export function seededNoise2D(x: number, y: number, seed: number = 0): number {
-  const n = Math.sin(x * 12.9898 + y * 78.233 + seed) * 43758.5453;
-  return n - Math.floor(n);
-}
-
-/**
- * Generate a brightness grid for pattern rendering
- *
- * @param cols - Number of columns
- * @param rows - Number of rows
- * @param pattern - Pattern type
- * @param time - Current time in seconds
- * @param config - Pattern configuration
- * @returns 2D array of brightness values (0-255)
- */
-export function generateBrightnessGrid(
-  cols: number,
-  rows: number,
-  pattern: 'perlin' | 'waves' | 'static' | 'ripple' | 'fbm',
-  time: number = 0,
-  config: PatternConfig = DEFAULT_PATTERN_CONFIG
-): number[][] {
-  const grid: number[][] = [];
-  const { frequency, amplitude, speed } = config;
-
-  for (let row = 0; row < rows; row++) {
-    grid[row] = [];
-    for (let col = 0; col < cols; col++) {
-      let value: number;
-
-      switch (pattern) {
-        case 'perlin':
-          value = perlinNoise2D(
-            col * frequency + time * speed * 0.1,
-            row * frequency + time * speed * 0.05
-          );
-          break;
-
-        case 'fbm':
-          value = fbmNoise(
-            col * frequency + time * speed * 0.1,
-            row * frequency + time * speed * 0.05,
-            4,
-            0.5
-          );
-          break;
-
-        case 'waves':
-          value = wavePattern(col, row, time, config);
-          break;
-
-        case 'ripple':
-          value = ripplePattern(col, row, cols / 2, rows / 2, time, config);
-          break;
-
-        case 'static':
-        default:
-          // For static, use time as seed for animated static
-          value = seededNoise2D(col, row, Math.floor(time * speed * 10)) * 2 - 1;
-          break;
-      }
-
-      // Normalize from [-1, 1] to [0, 255] with amplitude
-      const normalized = (value + 1) * 0.5 * amplitude;
-      const brightness = Math.max(0, Math.min(255, Math.floor(normalized * 255)));
-      grid[row][col] = brightness;
-    }
-  }
-
-  return grid;
-}
-
-/**
- * Generate ImageData from a brightness grid
- *
- * @param grid - 2D array of brightness values
- * @param cellWidth - Width of each cell
- * @param cellHeight - Height of each cell
- * @returns ImageData object
- */
-export function gridToImageData(grid: number[][], cellWidth: number, cellHeight: number): ImageData {
-  const rows = grid.length;
-  const cols = grid[0]?.length || 0;
-  const width = cols * cellWidth;
-  const height = rows * cellHeight;
-  const data = new Uint8ClampedArray(width * height * 4);
-
-  for (let row = 0; row < rows; row++) {
-    for (let col = 0; col < cols; col++) {
-      const brightness = grid[row][col];
-
-      // Fill cell region with brightness value
-      for (let cy = 0; cy < cellHeight; cy++) {
-        for (let cx = 0; cx < cellWidth; cx++) {
-          const px = ((row * cellHeight + cy) * width + (col * cellWidth + cx)) * 4;
-          data[px] = brightness; // R
-          data[px + 1] = brightness; // G
-          data[px + 2] = brightness; // B
-          data[px + 3] = 255; // A
-        }
-      }
-    }
-  }
-
-  return new ImageData(data, width, height);
-}
-
-export type PatternType = 'perlin' | 'waves' | 'static' | 'ripple' | 'fbm';