@autumnsgrove/gossamer 0.1.1 → 0.2.0

package/src/characters.ts

@@ -1,219 +0,0 @@
-/**
- * Gossamer Character Sets
- *
- * Predefined character sets for ASCII rendering, ordered from light to dark.
- * Character density determines which character represents each brightness level.
- */
-
-/**
- * Character set configuration
- */
-export interface CharacterSet {
-  /** Unique identifier for the character set */
-  name: string;
-  /** Description of the set's aesthetic */
-  description: string;
-  /** Characters ordered from lightest (space) to darkest */
-  characters: string;
-  /** Recommended use cases */
-  bestFor: string[];
-}
-
-/**
- * Standard character sets for ASCII rendering
- */
-export const CHARACTER_SETS: Record<string, CharacterSet> = {
-  standard: {
-    name: 'Standard',
-    description: 'Classic ASCII art character set',
-    characters: ' .:-=+*#%@',
-    bestFor: ['general', 'images', 'patterns'],
-  },
-
-  dense: {
-    name: 'Dense',
-    description: 'High detail character set with many gradations',
-    characters: " .'`^\",:;Il!i><~+_-?][}{1)(|\\/tfjrxnuvczXYUJCLQ0OZmwqpdbkhao*#MW&8%B@$",
-    bestFor: ['detailed images', 'portraits', 'high contrast'],
-  },
-
-  minimal: {
-    name: 'Minimal',
-    description: 'Clean and simple with few characters',
-    characters: ' .:*#',
-    bestFor: ['backgrounds', 'subtle effects', 'clean aesthetic'],
-  },
-
-  grove: {
-    name: 'Grove',
-    description: 'Organic, soft characters inspired by nature',
-    characters: ' ·∙•◦○◉●',
-    bestFor: ['organic patterns', 'soft backgrounds', 'nature themes'],
-  },
-
-  dots: {
-    name: 'Dots',
-    description: 'Braille-like dot patterns',
-    characters: ' ⋅∘∙●',
-    bestFor: ['stipple effects', 'pointillism', 'dotted textures'],
-  },
-
-  blocks: {
-    name: 'Blocks',
-    description: 'Block-based characters for sharp edges',
-    characters: ' ░▒▓█',
-    bestFor: ['retro effects', 'pixel art', 'bold patterns'],
-  },
-
-  lines: {
-    name: 'Lines',
-    description: 'Line-based characters for directional effects',
-    characters: ' -─═╌│┃',
-    bestFor: ['rain effects', 'streaks', 'motion blur'],
-  },
-
-  stars: {
-    name: 'Stars',
-    description: 'Star and sparkle characters',
-    characters: ' ·✧✦✫✬✯★',
-    bestFor: ['sparkle effects', 'night sky', 'magical themes'],
-  },
-
-  nature: {
-    name: 'Nature',
-    description: 'Nature-themed decorative characters',
-    characters: ' .~≈∿⌇☘',
-    bestFor: ['decorative', 'themed effects', 'organic patterns'],
-  },
-
-  weather: {
-    name: 'Weather',
-    description: 'Weather-related symbols',
-    characters: ' ·.:*❄❅❆',
-    bestFor: ['snow effects', 'weather simulations', 'seasonal themes'],
-  },
-
-  binary: {
-    name: 'Binary',
-    description: 'Digital-style binary characters',
-    characters: ' 01',
-    bestFor: ['digital effects', 'matrix style', 'tech themes'],
-  },
-
-  math: {
-    name: 'Math',
-    description: 'Mathematical symbols',
-    characters: ' +-×÷=≠≈∞',
-    bestFor: ['abstract patterns', 'tech themes', 'decorative'],
-  },
-
-  // ==========================================================================
-  // GLASS-OPTIMIZED CHARACTER SETS
-  // Designed for subtle overlays on Glass components
-  // More characters = more visible gradations
-  // ==========================================================================
-
-  'glass-dots': {
-    name: 'Glass Dots',
-    description: 'Soft dot gradations for glass overlays',
-    characters: ' ·∘∙○•●',
-    bestFor: ['glass overlays', 'subtle backgrounds', 'mist effects'],
-  },
-
-  'glass-mist': {
-    name: 'Glass Mist',
-    description: 'Ethereal mist effect for glass',
-    characters: ' .·∙•◦○◉●',
-    bestFor: ['glass overlays', 'fog effects', 'ambient backgrounds'],
-  },
-
-  'glass-dust': {
-    name: 'Glass Dust',
-    description: 'Floating dust particles',
-    characters: ' ˙·∘°•◦○',
-    bestFor: ['glass overlays', 'particle effects', 'light scatter'],
-  },
-
-  'glass-soft': {
-    name: 'Glass Soft',
-    description: 'Soft block gradations for glass',
-    characters: ' ·░▒▓',
-    bestFor: ['glass overlays', 'soft gradients', 'frosted effect'],
-  },
-
-  'glass-sparkle': {
-    name: 'Glass Sparkle',
-    description: 'Subtle sparkles for glass',
-    characters: ' ·.✧✦✫★',
-    bestFor: ['glass overlays', 'highlight effects', 'magical themes'],
-  },
-
-  'glass-wave': {
-    name: 'Glass Wave',
-    description: 'Flowing wave patterns for glass',
-    characters: ' .~∼≈≋',
-    bestFor: ['glass overlays', 'water effects', 'flowing motion'],
-  },
-
-  'glass-organic': {
-    name: 'Glass Organic',
-    description: 'Natural, organic feel for glass',
-    characters: ' .·:;∘○◦•●',
-    bestFor: ['glass overlays', 'nature themes', 'grove aesthetic'],
-  },
-};
-
-/**
- * Get a character set by name
- */
-export function getCharacterSet(name: string): CharacterSet | undefined {
-  return CHARACTER_SETS[name];
-}
-
-/**
- * Get just the characters string from a named set
- */
-export function getCharacters(name: string): string {
-  return CHARACTER_SETS[name]?.characters || CHARACTER_SETS.standard.characters;
-}
-
-/**
- * List all available character set names
- */
-export function getCharacterSetNames(): string[] {
-  return Object.keys(CHARACTER_SETS);
-}
-
-/**
- * Create a custom character set
- */
-export function createCharacterSet(
-  name: string,
-  characters: string,
-  description: string = '',
-  bestFor: string[] = []
-): CharacterSet {
-  return {
-    name,
-    description,
-    characters,
-    bestFor,
-  };
-}
-
-/**
- * Validate that a character string is suitable for ASCII rendering
- * (should start with space and have at least 2 characters)
- */
-export function validateCharacterSet(characters: string): boolean {
-  if (characters.length < 2) return false;
-  if (characters[0] !== ' ') return false;
-  return true;
-}
-
-/**
- * Reverse a character set (for inverted brightness mapping)
- */
-export function invertCharacters(characters: string): string {
-  return characters.split('').reverse().join('');
-}

package/src/colors.ts

@@ -1,234 +0,0 @@
-/**
- * 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

@@ -1,115 +0,0 @@
-/**
- * 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+$/);
-  });
-});