@autumnsgrove/gossamer 0.1.1 → 0.2.0

package/src/index.ts

@@ -1,234 +0,0 @@
-/**
- * Gossamer - ASCII Visual Effects Library
- *
- * Threads of light. Delicate textures woven through your space.
- *
- * @packageDocumentation
- */
-
-// =============================================================================
-// Core Types
-// =============================================================================
-
-/**
- * Core configuration for ASCII rendering
- */
-export interface GossamerConfig {
-  /** Character set for ASCII rendering (light to dark) */
-  characters?: string;
-  /** Cell width in pixels */
-  cellWidth?: number;
-  /** Cell height in pixels */
-  cellHeight?: number;
-  /** Foreground color */
-  color?: string;
-  /** Background color (transparent if not set) */
-  backgroundColor?: string;
-  /** Font family for ASCII characters */
-  fontFamily?: string;
-  /** Enable animation loop */
-  animate?: boolean;
-  /** Target FPS for animation */
-  fps?: number;
-}
-
-/**
- * Preset configuration for effects
- */
-export interface PresetConfig {
-  /** Preset display name */
-  name: string;
-  /** Preset description */
-  description: string;
-  /** Character set */
-  characters: string;
-  /** Pattern type */
-  pattern: 'perlin' | 'waves' | 'static' | 'ripple' | 'fbm' | 'clouds' | 'plasma' | 'vortex' | 'matrix' | 'gradient' | 'diamond' | 'fractal';
-  /** Pattern frequency */
-  frequency: number;
-  /** Pattern amplitude */
-  amplitude: number;
-  /** Animation speed */
-  speed: number;
-  /** Default opacity */
-  opacity: number;
-}
-
-// =============================================================================
-// Constants
-// =============================================================================
-
-/**
- * Default character set ordered from light to dark
- */
-export const DEFAULT_CHARACTERS = ' .:-=+*#%@';
-
-/**
- * Default configuration values
- */
-export const DEFAULT_CONFIG: Required<GossamerConfig> = {
-  characters: DEFAULT_CHARACTERS,
-  cellWidth: 8,
-  cellHeight: 12,
-  color: '#ffffff',
-  backgroundColor: '',
-  fontFamily: 'monospace',
-  animate: false,
-  fps: 30,
-};
-
-// =============================================================================
-// Core Functions
-// =============================================================================
-
-/**
- * Calculate brightness from RGB values using luminance formula
- * Uses the standard luminance coefficients: 0.21 R + 0.72 G + 0.07 B
- */
-export function calculateBrightness(r: number, g: number, b: number): number {
-  return 0.21 * r + 0.72 * g + 0.07 * b;
-}
-
-/**
- * Map a brightness value (0-255) to an ASCII character
- */
-export function brightnessToChar(
-  brightness: number,
-  characters: string = DEFAULT_CHARACTERS
-): string {
-  const index = Math.floor((brightness / 255) * (characters.length - 1));
-  return characters[Math.min(index, characters.length - 1)];
-}
-
-// =============================================================================
-// Module Exports
-// =============================================================================
-
-// Renderer
-export { GossamerRenderer } from './renderer';
-export type { RenderConfig } from './renderer';
-
-// Patterns
-export {
-  // Core noise functions
-  perlinNoise2D,
-  fbmNoise,
-  staticNoise,
-  seededNoise2D,
-  // Pattern generators
-  wavePattern,
-  ripplePattern,
-  cloudsPattern,
-  plasmaPattern,
-  vortexPattern,
-  matrixPattern,
-  gradientPattern,
-  diamondPattern,
-  fractalPattern,
-  // Grid generation (legacy API)
-  generateBrightnessGrid,
-  gridToImageData,
-  // Performance-optimized API
-  createBrightnessBuffer,
-  fillBrightnessBuffer,
-  getBufferValue,
-  // Config
-  DEFAULT_PATTERN_CONFIG,
-} from './patterns';
-export type { PatternConfig, PatternType, BrightnessBuffer } from './patterns';
-
-// Characters
-export {
-  CHARACTER_SETS,
-  getCharacterSet,
-  getCharacters,
-  getCharacterSetNames,
-  createCharacterSet,
-  validateCharacterSet,
-  invertCharacters,
-} from './characters';
-export type { CharacterSet } from './characters';
-
-// Colors (Grove palette)
-export {
-  GROVE_GREEN,
-  CREAM,
-  BARK,
-  STATUS,
-  GROVE_COLORS,
-  GLASS_SCHEMES,
-  getGroveColor,
-  getGlassScheme,
-  getGroveColorNames,
-  getGlassSchemeNames,
-  hexToRgba,
-} from './colors';
-export type { ColorDef, GroveColorName, GlassSchemeName } from './colors';
-
-// Animation
-export {
-  createAnimationLoop,
-  throttle,
-  debounce,
-  calculateFPS,
-  easings,
-} from './animation';
-export type { AnimationState, AnimationOptions, EasingFunction } from './animation';
-
-// Canvas Utilities
-export {
-  createCanvas,
-  getDevicePixelRatio,
-  resizeCanvasToContainer,
-  createOffscreenCanvas,
-  clearCanvas,
-  getImageData,
-  optimizeContext,
-  setupTextRendering,
-  measureTextWidth,
-  calculateCellSize,
-  setBlendMode,
-} from './utils/canvas';
-export type { CanvasOptions } from './utils/canvas';
-
-// Image Utilities
-export {
-  loadImage,
-  loadAndScaleImage,
-  imageToPixelData,
-  extractBrightness,
-  sampleImageCells,
-  rgbToHex,
-  hexToRgb,
-  adjustBrightness,
-  adjustContrast,
-  invertColors,
-  toGrayscale,
-} from './utils/image';
-export type { ImageLoadOptions } from './utils/image';
-
-// Performance Utilities
-export {
-  createVisibilityObserver,
-  createResizeObserver,
-  prefersReducedMotion,
-  onReducedMotionChange,
-  isLowPowerMode,
-  getRecommendedFPS,
-  createFPSCounter,
-  requestIdleCallback,
-  cancelIdleCallback,
-  isBrowser,
-  isCanvasSupported,
-  isOffscreenCanvasSupported,
-} from './utils/performance';
-export type { VisibilityCallback, PerformanceMetrics } from './utils/performance';
-
-// =============================================================================
-// Version
-// =============================================================================
-
-/**
- * Gossamer version
- */
-export const VERSION = '0.1.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);
-  });
-});