@autumnsgrove/gossamer 0.0.1 → 0.1.1

package/src/colors.ts

@@ -0,0 +1,234 @@
+/**
+ * Gossamer Color Palettes
+ *
+ * Grove-themed color palettes for ASCII effects.
+ * Designed to complement Glass UI components.
+ */
+
+/**
+ * Color definition with metadata
+ */
+export interface ColorDef {
+  /** Hex color value */
+  hex: string;
+  /** Human-readable name */
+  name: string;
+  /** Recommended opacity for glass overlays (0-1) */
+  glassOpacity?: number;
+}
+
+/**
+ * Grove Green palette - Primary brand colors
+ */
+export const GROVE_GREEN = {
+  50: { hex: '#f0fdf4', name: 'Grove Green 50', glassOpacity: 0.3 },
+  100: { hex: '#dcfce7', name: 'Grove Green 100', glassOpacity: 0.25 },
+  200: { hex: '#bbf7d0', name: 'Grove Green 200', glassOpacity: 0.2 },
+  300: { hex: '#86efac', name: 'Grove Green 300', glassOpacity: 0.18 },
+  400: { hex: '#4ade80', name: 'Grove Green 400', glassOpacity: 0.15 },
+  500: { hex: '#22c55e', name: 'Grove Green 500', glassOpacity: 0.12 },
+  600: { hex: '#16a34a', name: 'Grove Green 600', glassOpacity: 0.1 },
+  700: { hex: '#15803d', name: 'Grove Green 700', glassOpacity: 0.1 },
+  800: { hex: '#166534', name: 'Grove Green 800', glassOpacity: 0.08 },
+  900: { hex: '#14532d', name: 'Grove Green 900', glassOpacity: 0.08 },
+} as const;
+
+/**
+ * Cream palette - Light/warm backgrounds
+ */
+export const CREAM = {
+  50: { hex: '#fefdfb', name: 'Cream 50', glassOpacity: 0.4 },
+  100: { hex: '#fdfcf8', name: 'Cream 100', glassOpacity: 0.35 },
+  200: { hex: '#faf8f3', name: 'Cream 200', glassOpacity: 0.3 },
+  300: { hex: '#f5f2ea', name: 'Cream 300', glassOpacity: 0.25 },
+  400: { hex: '#ede9de', name: 'Cream 400', glassOpacity: 0.2 },
+  500: { hex: '#e2ddd0', name: 'Cream 500', glassOpacity: 0.18 },
+  600: { hex: '#d4cec0', name: 'Cream 600', glassOpacity: 0.15 },
+  700: { hex: '#c4bdb0', name: 'Cream 700', glassOpacity: 0.12 },
+  800: { hex: '#b0a99c', name: 'Cream 800', glassOpacity: 0.1 },
+  900: { hex: '#9a9387', name: 'Cream 900', glassOpacity: 0.08 },
+} as const;
+
+/**
+ * Bark palette - Dark/earth tones
+ */
+export const BARK = {
+  50: { hex: '#faf7f5', name: 'Bark 50', glassOpacity: 0.3 },
+  100: { hex: '#f0ebe6', name: 'Bark 100', glassOpacity: 0.25 },
+  200: { hex: '#e0d5cc', name: 'Bark 200', glassOpacity: 0.2 },
+  300: { hex: '#ccb59c', name: 'Bark 300', glassOpacity: 0.18 },
+  400: { hex: '#b89a7a', name: 'Bark 400', glassOpacity: 0.15 },
+  500: { hex: '#a57c5a', name: 'Bark 500', glassOpacity: 0.12 },
+  600: { hex: '#8a6344', name: 'Bark 600', glassOpacity: 0.1 },
+  700: { hex: '#6f4d39', name: 'Bark 700', glassOpacity: 0.1 },
+  800: { hex: '#553a2a', name: 'Bark 800', glassOpacity: 0.08 },
+  900: { hex: '#3d2914', name: 'Bark 900', glassOpacity: 0.06 },
+} as const;
+
+/**
+ * Status colors
+ */
+export const STATUS = {
+  success: { hex: '#22c55e', name: 'Success', glassOpacity: 0.12 },
+  warning: { hex: '#f59e0b', name: 'Warning', glassOpacity: 0.12 },
+  error: { hex: '#dc2626', name: 'Error', glassOpacity: 0.1 },
+  info: { hex: '#0ea5e9', name: 'Info', glassOpacity: 0.12 },
+} as const;
+
+/**
+ * Combined Grove color schemes for easy access
+ */
+export const GROVE_COLORS = {
+  // Greens
+  grove: GROVE_GREEN[500].hex,
+  'grove-light': GROVE_GREEN[300].hex,
+  'grove-dark': GROVE_GREEN[700].hex,
+  'grove-muted': GROVE_GREEN[400].hex,
+
+  // Creams
+  cream: CREAM[50].hex,
+  'cream-warm': CREAM[200].hex,
+  'cream-deep': CREAM[500].hex,
+
+  // Barks
+  bark: BARK[900].hex,
+  'bark-light': BARK[500].hex,
+  'bark-medium': BARK[700].hex,
+
+  // Utility
+  white: '#ffffff',
+  black: '#000000',
+  transparent: 'transparent',
+} as const;
+
+/**
+ * Glass-optimized color schemes
+ * Pre-configured for use with Glass components
+ */
+export const GLASS_SCHEMES = {
+  // Light mode schemes (on light backgrounds)
+  'grove-mist': {
+    color: GROVE_GREEN[500].hex,
+    background: 'transparent',
+    opacity: 0.12,
+    description: 'Subtle green mist for light glass',
+  },
+  'cream-haze': {
+    color: CREAM[600].hex,
+    background: 'transparent',
+    opacity: 0.15,
+    description: 'Warm cream haze for cozy glass',
+  },
+  'bark-shadow': {
+    color: BARK[700].hex,
+    background: 'transparent',
+    opacity: 0.08,
+    description: 'Soft earth shadow for depth',
+  },
+
+  // Dark mode schemes (on dark backgrounds)
+  'grove-glow': {
+    color: GROVE_GREEN[400].hex,
+    background: '#1a1915',
+    opacity: 0.15,
+    description: 'Glowing green for dark glass',
+  },
+  'cream-dust': {
+    color: CREAM[300].hex,
+    background: '#1a1915',
+    opacity: 0.1,
+    description: 'Dusty cream particles in dark',
+  },
+  'moonlight': {
+    color: '#e2e8f0',
+    background: '#1a1915',
+    opacity: 0.08,
+    description: 'Cool moonlight glow',
+  },
+
+  // Accent schemes
+  'spring-fresh': {
+    color: GROVE_GREEN[300].hex,
+    background: 'transparent',
+    opacity: 0.18,
+    description: 'Fresh spring green overlay',
+  },
+  'autumn-warm': {
+    color: '#d97706',
+    background: 'transparent',
+    opacity: 0.1,
+    description: 'Warm autumn amber tones',
+  },
+  'winter-frost': {
+    color: '#93c5fd',
+    background: 'transparent',
+    opacity: 0.12,
+    description: 'Cool frost blue overlay',
+  },
+} as const;
+
+export type GroveColorName = keyof typeof GROVE_COLORS;
+export type GlassSchemeName = keyof typeof GLASS_SCHEMES;
+
+/**
+ * Get a Grove color by name
+ */
+export function getGroveColor(name: GroveColorName | string): string {
+  if (name in GROVE_COLORS) {
+    return GROVE_COLORS[name as GroveColorName];
+  }
+  // If it's already a hex color, return it
+  if (name.startsWith('#')) {
+    return name;
+  }
+  // Default to grove green
+  return GROVE_COLORS.grove;
+}
+
+/**
+ * Get a glass scheme by name
+ */
+export function getGlassScheme(name: GlassSchemeName | string): {
+  color: string;
+  background: string;
+  opacity: number;
+} {
+  if (name in GLASS_SCHEMES) {
+    const scheme = GLASS_SCHEMES[name as GlassSchemeName];
+    return {
+      color: scheme.color,
+      background: scheme.background,
+      opacity: scheme.opacity,
+    };
+  }
+  // Default to grove-mist
+  return {
+    color: GLASS_SCHEMES['grove-mist'].color,
+    background: GLASS_SCHEMES['grove-mist'].background,
+    opacity: GLASS_SCHEMES['grove-mist'].opacity,
+  };
+}
+
+/**
+ * List all Grove color names
+ */
+export function getGroveColorNames(): string[] {
+  return Object.keys(GROVE_COLORS);
+}
+
+/**
+ * List all glass scheme names
+ */
+export function getGlassSchemeNames(): string[] {
+  return Object.keys(GLASS_SCHEMES);
+}
+
+/**
+ * Apply opacity to a hex color, returning rgba string
+ */
+export function hexToRgba(hex: string, opacity: number): string {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `rgba(${r}, ${g}, ${b}, ${opacity})`;
+}

package/src/index.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Tests for core index functions
+ */
+import { describe, it, expect } from 'vitest';
+import {
+  calculateBrightness,
+  brightnessToChar,
+  DEFAULT_CHARACTERS,
+  DEFAULT_CONFIG,
+  VERSION,
+} from './index';
+
+describe('calculateBrightness', () => {
+  it('should return 0 for black', () => {
+    expect(calculateBrightness(0, 0, 0)).toBe(0);
+  });
+
+  it('should return 255 for white', () => {
+    expect(calculateBrightness(255, 255, 255)).toBeCloseTo(255, 5);
+  });
+
+  it('should weight green highest', () => {
+    // Green contributes 0.72, so pure green should be brighter than pure red
+    const greenBrightness = calculateBrightness(0, 255, 0);
+    const redBrightness = calculateBrightness(255, 0, 0);
+    const blueBrightness = calculateBrightness(0, 0, 255);
+
+    expect(greenBrightness).toBeGreaterThan(redBrightness);
+    expect(greenBrightness).toBeGreaterThan(blueBrightness);
+    expect(redBrightness).toBeGreaterThan(blueBrightness);
+  });
+
+  it('should calculate correct luminance values', () => {
+    // Pure red: 0.21 * 255 = 53.55
+    expect(calculateBrightness(255, 0, 0)).toBeCloseTo(53.55, 1);
+    // Pure green: 0.72 * 255 = 183.6
+    expect(calculateBrightness(0, 255, 0)).toBeCloseTo(183.6, 1);
+    // Pure blue: 0.07 * 255 = 17.85
+    expect(calculateBrightness(0, 0, 255)).toBeCloseTo(17.85, 1);
+  });
+
+  it('should handle mid-gray', () => {
+    const gray = calculateBrightness(128, 128, 128);
+    // 128 * (0.21 + 0.72 + 0.07) = 128
+    expect(gray).toBe(128);
+  });
+});
+
+describe('brightnessToChar', () => {
+  it('should return space for brightness 0', () => {
+    expect(brightnessToChar(0)).toBe(' ');
+  });
+
+  it('should return last character for brightness 255', () => {
+    expect(brightnessToChar(255)).toBe('@');
+  });
+
+  it('should map mid-brightness to middle character', () => {
+    // With ' .:-=+*#%@' (10 chars), brightness 127-128 should be around index 4-5
+    const char = brightnessToChar(127);
+    expect(['=', '+'].includes(char)).toBe(true);
+  });
+
+  it('should use custom character set', () => {
+    const customSet = ' abc';
+    expect(brightnessToChar(0, customSet)).toBe(' ');
+    expect(brightnessToChar(255, customSet)).toBe('c');
+  });
+
+  it('should handle two-character set', () => {
+    const binarySet = ' #';
+    expect(brightnessToChar(0, binarySet)).toBe(' ');
+    expect(brightnessToChar(127, binarySet)).toBe(' ');
+    expect(brightnessToChar(255, binarySet)).toBe('#');
+  });
+
+  it('should clamp to valid range', () => {
+    // Even with extreme values, should not crash
+    expect(() => brightnessToChar(-10)).not.toThrow();
+    expect(() => brightnessToChar(300)).not.toThrow();
+  });
+});
+
+describe('DEFAULT_CHARACTERS', () => {
+  it('should be standard ASCII art character set', () => {
+    expect(DEFAULT_CHARACTERS).toBe(' .:-=+*#%@');
+  });
+
+  it('should start with space', () => {
+    expect(DEFAULT_CHARACTERS[0]).toBe(' ');
+  });
+
+  it('should have 10 characters', () => {
+    expect(DEFAULT_CHARACTERS.length).toBe(10);
+  });
+});
+
+describe('DEFAULT_CONFIG', () => {
+  it('should have all required properties', () => {
+    expect(DEFAULT_CONFIG.characters).toBe(DEFAULT_CHARACTERS);
+    expect(DEFAULT_CONFIG.cellWidth).toBe(8);
+    expect(DEFAULT_CONFIG.cellHeight).toBe(12);
+    expect(DEFAULT_CONFIG.color).toBe('#ffffff');
+    expect(DEFAULT_CONFIG.backgroundColor).toBe('');
+    expect(DEFAULT_CONFIG.fontFamily).toBe('monospace');
+    expect(DEFAULT_CONFIG.animate).toBe(false);
+    expect(DEFAULT_CONFIG.fps).toBe(30);
+  });
+});
+
+describe('VERSION', () => {
+  it('should be a semver string', () => {
+    expect(VERSION).toMatch(/^\d+\.\d+\.\d+$/);
+  });
+});

package/src/index.ts

@@ -6,6 +6,10 @@
  * @packageDocumentation
  */
 
+// =============================================================================
+// Core Types
+// =============================================================================
+
 /**
  * Core configuration for ASCII rendering
  */
@@ -28,6 +32,32 @@ export interface GossamerConfig {
   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
  */
@@ -47,6 +77,10 @@ export const DEFAULT_CONFIG: Required<GossamerConfig> = {
   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
@@ -66,16 +100,135 @@ export function brightnessToChar(
   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 v0.0.1 - Placeholder release
- *
- * Full implementation coming soon. This package will provide:
- * - 2D Canvas ASCII rendering
- * - Ambient pattern generation
- * - Image-to-ASCII conversion
- * - Animation loops
- * - Framework adapters (Svelte, React, Vue)
- *
- * @see https://github.com/AutumnsGrove/Gossamer
+ * Gossamer version
  */
-export const VERSION = '0.0.1';
+export const VERSION = '0.1.0';