@shohojdhara/atomix 0.3.3 → 0.3.4

package/src/lib/theme/errors.test.ts

@@ -1,207 +0,0 @@
-/**
- * Theme Error Handling Tests
- * 
- * Tests for ThemeError class and ThemeLogger
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import {
-  ThemeError,
-  ThemeErrorCode,
-  ThemeLogger,
-  LogLevel,
-  getLogger,
-  setLogger,
-  createLogger,
-} from './errors';
-
-describe('ThemeError', () => {
-  it('should create an error with message', () => {
-    const error = new ThemeError('Test error');
-    expect(error.message).toBe('Test error');
-    expect(error.name).toBe('ThemeError');
-    expect(error.code).toBe(ThemeErrorCode.UNKNOWN_ERROR);
-  });
-
-  it('should create an error with code', () => {
-    const error = new ThemeError(
-      'Theme not found',
-      ThemeErrorCode.THEME_NOT_FOUND
-    );
-    expect(error.code).toBe(ThemeErrorCode.THEME_NOT_FOUND);
-  });
-
-  it('should create an error with context', () => {
-    const context = { themeId: 'test-theme', reason: 'not found' };
-    const error = new ThemeError('Error', ThemeErrorCode.THEME_NOT_FOUND, context);
-    expect(error.context).toEqual(context);
-  });
-
-  it('should have a timestamp', () => {
-    const before = Date.now();
-    const error = new ThemeError('Test');
-    const after = Date.now();
-    expect(error.timestamp).toBeGreaterThanOrEqual(before);
-    expect(error.timestamp).toBeLessThanOrEqual(after);
-  });
-
-  it('should convert to JSON', () => {
-    const context = { themeId: 'test' };
-    const error = new ThemeError('Test', ThemeErrorCode.THEME_NOT_FOUND, context);
-    const json = error.toJSON();
-    expect(json).toHaveProperty('name', 'ThemeError');
-    expect(json).toHaveProperty('message', 'Test');
-    expect(json).toHaveProperty('code', ThemeErrorCode.THEME_NOT_FOUND);
-    expect(json).toHaveProperty('context', context);
-    expect(json).toHaveProperty('timestamp');
-    expect(json).toHaveProperty('stack');
-  });
-
-  it('should be an instance of Error', () => {
-    const error = new ThemeError('Test');
-    expect(error).toBeInstanceOf(Error);
-    expect(error).toBeInstanceOf(ThemeError);
-  });
-});
-
-describe('ThemeLogger', () => {
-  let logger: ThemeLogger;
-  let consoleErrorSpy: ReturnType<typeof vi.spyOn>;
-  let consoleWarnSpy: ReturnType<typeof vi.spyOn>;
-  let consoleInfoSpy: ReturnType<typeof vi.spyOn>;
-  let consoleDebugSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
-    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    consoleInfoSpy = vi.spyOn(console, 'info').mockImplementation(() => {});
-    consoleDebugSpy = vi.spyOn(console, 'debug').mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('error', () => {
-    it('should log errors at ERROR level', () => {
-      logger = new ThemeLogger({ level: LogLevel.ERROR });
-      const error = new Error('Test error');
-      logger.error('Test message', error);
-      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not log errors below ERROR level', () => {
-      logger = new ThemeLogger({ level: LogLevel.WARN });
-      const error = new Error('Test error');
-      logger.error('Test message', error);
-      expect(consoleErrorSpy).not.toHaveBeenCalled();
-    });
-
-    it('should include context in error logs', () => {
-      logger = new ThemeLogger({ level: LogLevel.ERROR });
-      const error = new Error('Test');
-      const context = { themeId: 'test' };
-      logger.error('Test', error, context);
-      expect(consoleErrorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('[ThemeError]'),
-        expect.objectContaining({
-          error,
-          context: expect.objectContaining(context),
-        })
-      );
-    });
-
-    it('should call custom error handler', () => {
-      const onError = vi.fn();
-      logger = new ThemeLogger({ level: LogLevel.ERROR, onError });
-      const error = new Error('Test');
-      logger.error('Test', error);
-      expect(onError).toHaveBeenCalledWith(
-        expect.any(ThemeError),
-        undefined
-      );
-    });
-  });
-
-  describe('warn', () => {
-    it('should log warnings at WARN level', () => {
-      logger = new ThemeLogger({ level: LogLevel.WARN });
-      logger.warn('Warning message');
-      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not log warnings below WARN level', () => {
-      logger = new ThemeLogger({ level: LogLevel.ERROR });
-      logger.warn('Warning message');
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-    });
-
-    it('should call custom warn handler', () => {
-      const onWarn = vi.fn();
-      logger = new ThemeLogger({ level: LogLevel.WARN, onWarn });
-      logger.warn('Warning', { context: 'data' });
-      expect(onWarn).toHaveBeenCalledWith('Warning', { context: 'data' });
-    });
-  });
-
-  describe('info', () => {
-    it('should log info at INFO level', () => {
-      logger = new ThemeLogger({ level: LogLevel.INFO });
-      logger.info('Info message');
-      expect(consoleInfoSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not log info below INFO level', () => {
-      logger = new ThemeLogger({ level: LogLevel.WARN });
-      logger.info('Info message');
-      expect(consoleInfoSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('debug', () => {
-    it('should log debug at DEBUG level', () => {
-      logger = new ThemeLogger({ level: LogLevel.DEBUG });
-      logger.debug('Debug message');
-      expect(consoleDebugSpy).toHaveBeenCalledTimes(1);
-    });
-
-    it('should not log debug below DEBUG level', () => {
-      logger = new ThemeLogger({ level: LogLevel.INFO });
-      logger.debug('Debug message');
-      expect(consoleDebugSpy).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('console control', () => {
-    it('should not log to console when disabled', () => {
-      logger = new ThemeLogger({ level: LogLevel.DEBUG, enableConsole: false });
-      logger.error('Error');
-      logger.warn('Warning');
-      logger.info('Info');
-      logger.debug('Debug');
-      expect(consoleErrorSpy).not.toHaveBeenCalled();
-      expect(consoleWarnSpy).not.toHaveBeenCalled();
-      expect(consoleInfoSpy).not.toHaveBeenCalled();
-      expect(consoleDebugSpy).not.toHaveBeenCalled();
-    });
-  });
-});
-
-describe('Logger utilities', () => {
-  it('should get default logger', () => {
-    const logger = getLogger();
-    expect(logger).toBeInstanceOf(ThemeLogger);
-  });
-
-  it('should set custom logger', () => {
-    const customLogger = new ThemeLogger({ level: LogLevel.DEBUG });
-    setLogger(customLogger);
-    const retrieved = getLogger();
-    expect(retrieved).toBe(customLogger);
-  });
-
-  it('should create logger with config', () => {
-    const logger = createLogger({ level: LogLevel.WARN });
-    expect(logger).toBeInstanceOf(ThemeLogger);
-  });
-});

package/src/lib/theme/generators/CSSGenerator.ts

@@ -1,311 +0,0 @@
-/**
- * CSS Generator
- * 
- * Optimized CSS variable generation from theme objects
- */
-
-import type { Theme } from '../types';
-
-/**
- * CSS generation options
- */
-export interface CSSGeneratorOptions {
-  /** CSS selector (default: ':root') */
-  selector?: string;
-  /** CSS variable prefix (default: 'atomix') */
-  prefix?: string;
-  /** Include comments */
-  includeComments?: boolean;
-  /** Minify output */
-  minify?: boolean;
-  /** Custom property formatter */
-  formatProperty?: (path: string[], value: any) => string;
-}
-
-/**
- * CSS Generator
- * 
- * Generates optimized CSS custom properties from theme objects
- */
-export class CSSGenerator {
-  private options: Required<Omit<CSSGeneratorOptions, 'formatProperty'>> & {
-    formatProperty?: CSSGeneratorOptions['formatProperty'];
-  };
-
-  constructor(options: CSSGeneratorOptions = {}) {
-    this.options = {
-      selector: options.selector || ':root',
-      prefix: options.prefix || 'atomix',
-      includeComments: options.includeComments ?? true,
-      minify: options.minify ?? false,
-      formatProperty: options.formatProperty,
-    };
-  }
-
-  /**
-   * Generate CSS from theme
-   */
-  generate(theme: Theme): string {
-    const variables = this.extractVariables(theme);
-    return this.formatCSS(variables);
-  }
-
-  /**
-   * Extract CSS variables from theme
-   */
-  private extractVariables(theme: Theme): Map<string, string> {
-    const variables = new Map<string, string>();
-
-    // Palette
-    this.extractPalette(theme.palette, variables);
-
-    // Typography
-    this.extractTypography(theme.typography, variables);
-
-    // Spacing (generate common values)
-    this.extractSpacing(theme.spacing, variables);
-
-    // Breakpoints
-    this.extractBreakpoints(theme.breakpoints, variables);
-
-    // Shadows
-    this.extractShadows(theme.shadows, variables);
-
-    // Transitions
-    this.extractTransitions(theme.transitions, variables);
-
-    // Z-index
-    this.extractZIndex(theme.zIndex, variables);
-
-    // Border radius
-    this.extractBorderRadius(theme.borderRadius, variables);
-
-    // Custom properties
-    this.extractCustom(theme.custom, variables);
-
-    return variables;
-  }
-
-  /**
-   * Extract palette variables
-   */
-  private extractPalette(palette: Theme['palette'], variables: Map<string, string>): void {
-    const colors = ['primary', 'secondary', 'error', 'warning', 'info', 'success'] as const;
-
-    for (const color of colors) {
-      const colorObj = palette[color];
-      if (colorObj) {
-        variables.set(`palette-${color}-main`, colorObj.main);
-        if (colorObj.light) variables.set(`palette-${color}-light`, colorObj.light);
-        if (colorObj.dark) variables.set(`palette-${color}-dark`, colorObj.dark);
-        if (colorObj.contrastText) variables.set(`palette-${color}-contrast-text`, colorObj.contrastText);
-      }
-    }
-
-    // Background
-    if (palette.background) {
-      variables.set('background-default', palette.background.default);
-      variables.set('background-paper', palette.background.paper);
-      variables.set('background-subtle', palette.background.subtle);
-    }
-
-    // Text
-    if (palette.text) {
-      variables.set('text-primary', palette.text.primary);
-      variables.set('text-secondary', palette.text.secondary);
-      variables.set('text-disabled', palette.text.disabled);
-    }
-  }
-
-  /**
-   * Extract typography variables
-   */
-  private extractTypography(typography: Theme['typography'], variables: Map<string, string>): void {
-    variables.set('font-family', typography.fontFamily);
-    variables.set('font-size', `${typography.fontSize}px`);
-
-    // Font weights
-    if (typography.fontWeightLight) variables.set('font-weight-light', String(typography.fontWeightLight));
-    if (typography.fontWeightRegular) variables.set('font-weight-regular', String(typography.fontWeightRegular));
-    if (typography.fontWeightMedium) variables.set('font-weight-medium', String(typography.fontWeightMedium));
-    if (typography.fontWeightSemiBold) variables.set('font-weight-semibold', String(typography.fontWeightSemiBold));
-    if (typography.fontWeightBold) variables.set('font-weight-bold', String(typography.fontWeightBold));
-
-    // Headings
-    const headings = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] as const;
-    for (const heading of headings) {
-      const h = typography[heading];
-      if (h) {
-        if (h.fontSize) variables.set(`typography-${heading}-font-size`, String(h.fontSize));
-        if (h.fontWeight) variables.set(`typography-${heading}-font-weight`, String(h.fontWeight));
-        if (h.lineHeight) variables.set(`typography-${heading}-line-height`, String(h.lineHeight));
-      }
-    }
-
-    // Body
-    if (typography.body1) {
-      if (typography.body1.fontSize) variables.set('typography-body1-font-size', String(typography.body1.fontSize));
-      if (typography.body1.fontWeight) variables.set('typography-body1-font-weight', String(typography.body1.fontWeight));
-      if (typography.body1.lineHeight) variables.set('typography-body1-line-height', String(typography.body1.lineHeight));
-    }
-
-    if (typography.body2) {
-      if (typography.body2.fontSize) variables.set('typography-body2-font-size', String(typography.body2.fontSize));
-      if (typography.body2.fontWeight) variables.set('typography-body2-font-weight', String(typography.body2.fontWeight));
-      if (typography.body2.lineHeight) variables.set('typography-body2-line-height', String(typography.body2.lineHeight));
-    }
-  }
-
-  /**
-   * Extract spacing variables
-   */
-  private extractSpacing(spacing: Theme['spacing'], variables: Map<string, string>): void {
-    // Generate common spacing values
-    for (let i = 0; i <= 12; i++) {
-      try {
-        const value = spacing(i);
-        variables.set(`spacing-${i}`, value);
-      } catch {
-        // Ignore errors
-      }
-    }
-  }
-
-  /**
-   * Extract breakpoint variables
-   */
-  private extractBreakpoints(breakpoints: Theme['breakpoints'], variables: Map<string, string>): void {
-    const keys = ['xs', 'sm', 'md', 'lg', 'xl'] as const;
-    for (const key of keys) {
-      const value = breakpoints.values[key];
-      if (value !== undefined) {
-        variables.set(`breakpoint-${key}`, `${value}px`);
-      }
-    }
-  }
-
-  /**
-   * Extract shadow variables
-   */
-  private extractShadows(shadows: Theme['shadows'], variables: Map<string, string>): void {
-    const keys = ['xs', 'sm', 'md', 'lg', 'xl'] as const;
-    for (const key of keys) {
-      const shadow = shadows[key];
-      if (shadow) {
-        variables.set(`shadow-${key}`, shadow);
-      }
-    }
-  }
-
-  /**
-   * Extract transition variables
-   */
-  private extractTransitions(transitions: Theme['transitions'], variables: Map<string, string>): void {
-    if (transitions.duration) {
-      const durations = ['shortest', 'shorter', 'short', 'standard', 'complex'] as const;
-      for (const key of durations) {
-        const value = transitions.duration[key];
-        if (value !== undefined) {
-          variables.set(`transition-duration-${key}`, `${value}ms`);
-        }
-      }
-    }
-
-    if (transitions.easing) {
-      const easings = ['easeInOut', 'easeOut', 'easeIn', 'sharp'] as const;
-      for (const key of easings) {
-        const value = transitions.easing[key];
-        if (value) {
-          variables.set(`transition-easing-${key}`, value);
-        }
-      }
-    }
-  }
-
-  /**
-   * Extract z-index variables
-   */
-  private extractZIndex(zIndex: Theme['zIndex'], variables: Map<string, string>): void {
-    const keys = ['mobileStepper', 'speedDial', 'appBar', 'drawer', 'modal', 'snackbar', 'tooltip'] as const;
-    for (const key of keys) {
-      const value = zIndex[key];
-      if (value !== undefined) {
-        variables.set(`z-index-${key}`, String(value));
-      }
-    }
-  }
-
-  /**
-   * Extract border radius variables
-   */
-  private extractBorderRadius(borderRadius: Theme['borderRadius'], variables: Map<string, string>): void {
-    const keys = ['base', 'sm', 'md', 'lg', 'xl', 'xxl', '3xl', '4xl', 'pill'] as const;
-    for (const key of keys) {
-      const value = borderRadius[key];
-      if (value !== undefined) {
-        variables.set(`border-radius-${key}`, String(value));
-      }
-    }
-  }
-
-  /**
-   * Extract custom properties
-   */
-  private extractCustom(custom: Theme['custom'], variables: Map<string, string>): void {
-    for (const [key, value] of Object.entries(custom)) {
-      if (value !== undefined && value !== null) {
-        variables.set(`custom-${key}`, String(value));
-      }
-    }
-  }
-
-  /**
-   * Format CSS from variables
-   */
-  private formatCSS(variables: Map<string, string>): string {
-    const { selector, prefix, includeComments, minify } = this.options;
-    const indent = minify ? '' : '  ';
-    const newline = minify ? '' : '\n';
-    const space = minify ? '' : ' ';
-
-    let css = '';
-
-    if (includeComments && !minify) {
-      css += `/* Atomix Theme CSS Variables */${newline}`;
-      css += `/* Generated from theme configuration */${newline}${newline}`;
-    }
-
-    css += `${selector}${space}{${newline}`;
-
-    for (const [key, value] of variables.entries()) {
-      const property = this.formatPropertyName(key);
-      css += `${indent}--${prefix}-${property}:${space}${value};${newline}`;
-    }
-
-    css += `}${newline}`;
-
-    return css;
-  }
-
-  /**
-   * Format property name
-   */
-  private formatPropertyName(key: string): string {
-    if (this.options.formatProperty) {
-      return this.options.formatProperty(key.split('-'), key);
-    }
-    return key;
-  }
-}
-
-/**
- * Generate CSS variables from theme
- * 
- * @param theme - Theme object
- * @param options - Generation options
- * @returns CSS string
- */
-export function generateCSS(theme: Theme, options: CSSGeneratorOptions = {}): string {
-  const generator = new CSSGenerator(options);
-  return generator.generate(theme);
-}