@shohojdhara/atomix 0.3.13 → 0.3.15

package/build-tools/__tests__/error-handler.test.js

@@ -0,0 +1,230 @@
+import { describe, it, expect, vi } from 'vitest';
+import { AtomixBuildError, Validator, ErrorHandler } from '../error-handler.js';
+
+describe('Atomix Build Error Handler', () => {
+  describe('AtomixBuildError', () => {
+    it('should create error with proper properties', () => {
+      const error = new AtomixBuildError(
+        'Test error message',
+        'TEST_ERROR',
+        { detail: 'test' },
+        ['Suggestion 1', 'Suggestion 2']
+      );
+
+      expect(error).toBeInstanceOf(Error);
+      expect(error.name).toBe('AtomixBuildError');
+      expect(error.message).toBe('Test error message');
+      expect(error.code).toBe('TEST_ERROR');
+      expect(error.details).toEqual({ detail: 'test' });
+      expect(error.suggestions).toEqual(['Suggestion 1', 'Suggestion 2']);
+      expect(error.timestamp).toBeDefined();
+    });
+
+    it('should format error message correctly', () => {
+      const error = new AtomixBuildError(
+        'Simple error',
+        'SIMPLE_ERROR'
+      );
+
+      const formatted = error.toString();
+      expect(formatted).toContain('[AtomixBuildError:SIMPLE_ERROR]');
+      expect(formatted).toContain('Simple error');
+    });
+  });
+
+  describe('Validator', () => {
+    describe('validateTheme', () => {
+      it('should validate valid theme', () => {
+        expect(() => {
+          Validator.validateTheme('default', ['default', 'dark']);
+        }).not.toThrow();
+      });
+
+      it('should throw error for invalid theme type', () => {
+        expect(() => {
+          Validator.validateTheme(123);
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should throw error for empty theme', () => {
+        expect(() => {
+          Validator.validateTheme('');
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should throw error for non-existent theme', () => {
+        expect(() => {
+          Validator.validateTheme('nonexistent', ['default', 'dark']);
+        }).toThrow(AtomixBuildError);
+      });
+    });
+
+    describe('validateComponents', () => {
+      it('should validate valid components array', () => {
+        expect(() => {
+          Validator.validateComponents(['Button', 'Card'], ['Button', 'Card', 'Input']);
+        }).not.toThrow();
+      });
+
+      it('should throw error for non-array components', () => {
+        expect(() => {
+          Validator.validateComponents('Button');
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should throw error for non-string component names', () => {
+        expect(() => {
+          Validator.validateComponents(['Button', 123]);
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should throw error for missing components', () => {
+        expect(() => {
+          Validator.validateComponents(['Button', 'Missing'], ['Button']);
+        }).toThrow(AtomixBuildError);
+      });
+    });
+
+    describe('validateBoolean', () => {
+      it('should validate valid boolean', () => {
+        expect(() => {
+          Validator.validateBoolean(true, 'testOption');
+        }).not.toThrow();
+      });
+
+      it('should throw error for non-boolean value', () => {
+        expect(() => {
+          Validator.validateBoolean('true', 'testOption');
+        }).toThrow(AtomixBuildError);
+      });
+    });
+
+    describe('validateString', () => {
+      it('should validate valid string', () => {
+        expect(() => {
+          Validator.validateString('test', 'testOption');
+        }).not.toThrow();
+      });
+
+      it('should throw error for non-string value', () => {
+        expect(() => {
+          Validator.validateString(123, 'testOption');
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should throw error for empty string when not allowed', () => {
+        expect(() => {
+          Validator.validateString('', 'testOption');
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should allow empty string when permitted', () => {
+        expect(() => {
+          Validator.validateString('', 'testOption', true);
+        }).not.toThrow();
+      });
+    });
+
+    describe('validateOptions', () => {
+      it('should validate complete options object', () => {
+        const options = {
+          theme: 'default',
+          components: ['Button'],
+          optimizeCss: true,
+          includeAtoms: false,
+          verbose: false
+        };
+
+        expect(() => {
+          Validator.validateOptions(options);
+        }).not.toThrow();
+      });
+
+      it('should throw error for invalid options object', () => {
+        expect(() => {
+          Validator.validateOptions('invalid');
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should warn about unknown options', () => {
+        const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        
+        const options = {
+          theme: 'default',
+          unknownOption: 'value'
+        };
+
+        Validator.validateOptions(options);
+        expect(consoleSpy).toHaveBeenCalledWith('[AtomixBuildWarning] Unknown options provided: unknownOption');
+        
+        consoleSpy.mockRestore();
+      });
+    });
+  });
+
+  describe('ErrorHandler', () => {
+    describe('withErrorHandling', () => {
+      it('should wrap function and handle errors', () => {
+        const failingFn = () => {
+          throw new Error('Original error');
+        };
+
+        const wrappedFn = ErrorHandler.withErrorHandling(failingFn, 'Test Context');
+
+        expect(() => {
+          wrappedFn();
+        }).toThrow(AtomixBuildError);
+      });
+
+      it('should preserve AtomixBuildError instances', () => {
+        const atomixError = new AtomixBuildError('Test', 'TEST_CODE');
+        const failingFn = () => {
+          throw atomixError;
+        };
+
+        const wrappedFn = ErrorHandler.withErrorHandling(failingFn, 'Test Context');
+
+        try {
+          wrappedFn();
+          expect.fail('Should have thrown');
+        } catch (error) {
+          expect(error).toBe(atomixError);
+        }
+      });
+    });
+
+    describe('logError', () => {
+      it('should log AtomixBuildError properly', () => {
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const error = new AtomixBuildError('Test error', 'TEST_CODE');
+
+        ErrorHandler.logError(error);
+        expect(consoleSpy).toHaveBeenCalled();
+        
+        consoleSpy.mockRestore();
+      });
+
+      it('should log regular Error properly', () => {
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        const error = new Error('Regular error');
+
+        ErrorHandler.logError(error);
+        expect(consoleSpy).toHaveBeenCalledWith('[Error] Regular error');
+        
+        consoleSpy.mockRestore();
+      });
+    });
+
+    describe('getErrorCode', () => {
+      it('should get error code from AtomixBuildError', () => {
+        const error = new AtomixBuildError('Test', 'TEST_CODE');
+        expect(ErrorHandler.getErrorCode(error)).toBe('TEST_CODE');
+      });
+
+      it('should return null for regular Error', () => {
+        const error = new Error('Test');
+        expect(ErrorHandler.getErrorCode(error)).toBeNull();
+      });
+    });
+  });
+});

package/build-tools/__tests__/index.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { detectBuildTool, getIntegration, initAutoIntegration } from '../index.js';
+import fs from 'fs';
+
+// Mock fs for detectBuildTool tests
+vi.mock('fs', async (importOriginal) => {
+  const actual = await importOriginal();
+  return {
+    ...actual,
+    default: {
+      ...actual.default,
+      existsSync: vi.fn(),
+      readFileSync: vi.fn(),
+    },
+    existsSync: vi.fn(),
+    readFileSync: vi.fn(),
+  };
+});
+
+describe('Build-Tools Index (index.js)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('detectBuildTool', () => {
+    it('should detect vite when it is in devDependencies', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        devDependencies: { vite: '^5.0.0' },
+      }));
+
+      expect(detectBuildTool()).toBe('vite');
+    });
+
+    it('should detect webpack when it is in dependencies', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: { webpack: '^5.0.0' },
+      }));
+
+      expect(detectBuildTool()).toBe('webpack');
+    });
+
+    it('should detect rollup', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        devDependencies: { rollup: '^4.0.0' },
+      }));
+
+      expect(detectBuildTool()).toBe('rollup');
+    });
+
+    it('should return null when no build tool is detected', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        dependencies: { react: '^18.0.0' },
+      }));
+
+      expect(detectBuildTool()).toBeNull();
+    });
+
+    it('should return null when package.json does not exist', () => {
+      fs.existsSync.mockReturnValue(false);
+
+      expect(detectBuildTool()).toBeNull();
+    });
+
+    it('should prioritize vite over webpack when both exist', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        devDependencies: { vite: '^5.0.0', webpack: '^5.0.0' },
+      }));
+
+      expect(detectBuildTool()).toBe('vite');
+    });
+
+    it('should handle malformed package.json gracefully', () => {
+      fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValue('not valid json');
+
+      const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      expect(detectBuildTool()).toBeNull();
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('getIntegration', () => {
+    it('should return a plugin object for "vite"', () => {
+      const result = getIntegration('vite');
+      expect(result).toBeDefined();
+      expect(result.name).toBe('atomix');
+    });
+
+    it('should return a function for "webpack"', () => {
+      const result = getIntegration('webpack');
+      expect(typeof result).toBe('function');
+    });
+
+    it('should return a plugin object for "rollup"', () => {
+      const result = getIntegration('rollup');
+      expect(result).toBeDefined();
+      expect(result.name).toBe('atomix');
+    });
+
+    it('should return null for unknown build tool', () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const result = getIntegration('parcel');
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+
+    it('should return null for null build tool', () => {
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+      const result = getIntegration(null);
+      expect(result).toBeNull();
+      consoleSpy.mockRestore();
+    });
+
+    it('should be case-insensitive', () => {
+      const result = getIntegration('VITE');
+      expect(result).toBeDefined();
+      expect(result.name).toBe('atomix');
+    });
+  });
+
+  describe('initAutoIntegration', () => {
+    it('should return null when no build tool detected', () => {
+      fs.existsSync.mockReturnValue(false);
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = initAutoIntegration();
+      expect(result).toBeNull();
+
+      warnSpy.mockRestore();
+    });
+  });
+});

package/build-tools/__tests__/rollup-plugin.test.js

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import atomixRollupPlugin, { getAvailableThemes, getAtomixPackageLocation } from '../rollup-plugin.js';
+
+describe('Atomix Rollup Plugin', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Plugin Creation', () => {
+    it('should create plugin with default options', () => {
+      const plugin = atomixRollupPlugin();
+      expect(plugin.name).toBe('atomix');
+      expect(typeof plugin.transform).toBe('function');
+      expect(typeof plugin.resolveId).toBe('function');
+      expect(typeof plugin.load).toBe('function');
+    });
+
+    it('should create plugin with custom options', () => {
+      const options = {
+        theme: 'dark-complementary',
+        components: ['Button', 'Card'],
+        optimize: false,
+        includeAtoms: true,
+        verbose: true
+      };
+      
+      const plugin = atomixRollupPlugin(options);
+      expect(plugin.name).toBe('atomix');
+    });
+
+    it('should throw error for invalid theme type', () => {
+      expect(() => {
+        atomixRollupPlugin({ theme: 123 });
+      }).toThrow('Theme must be a string');
+    });
+
+    it('should throw error for invalid components type', () => {
+      expect(() => {
+        atomixRollupPlugin({ components: 'Button' });
+      }).toThrow('Components must be an array');
+    });
+  });
+
+  describe('Transform Hook', () => {
+    it('should process Atomix files', () => {
+      const plugin = atomixRollupPlugin();
+      const testCode = `
+        import { Button, Card } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+        export default function Test() {
+          return <Button>Hello</Button>;
+        }
+      `;
+      
+      const result = plugin.transform(testCode, '/test/node_modules/@shohojdhara/atomix/Button.js');
+      
+      expect(result).toBeDefined();
+      expect(result.code).toContain('Button');
+      expect(result.map).toBeNull();
+    });
+
+    it('should filter components when specified', () => {
+      const plugin = atomixRollupPlugin({
+        components: ['Button'],
+        optimize: true
+      });
+      
+      const testCode = `
+        import { Button, Card, Input } from '@shohojdhara/atomix/components';
+        export default function Test() {
+          return <Button>Hello</Button>;
+        }
+      `;
+      
+      const result = plugin.transform(testCode, '/test/file.js');
+      expect(result.code).toContain('Button');
+      // Should filter out Card and Input
+    });
+
+    it('should remove atom imports when includeAtoms is false', () => {
+      const plugin = atomixRollupPlugin({
+        includeAtoms: false,
+        optimize: true
+      });
+      
+      const testCode = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+      `;
+      
+      const result = plugin.transform(testCode, '/test/file.js');
+      expect(result.code).not.toContain('AtomButton');
+    });
+
+    it('should return null for non-Atomix files', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.transform('console.log("hello");', '/test/other.js');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('ResolveId Hook', () => {
+    it('should resolve theme imports', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.resolveId('@shohojdhara/atomix/theme', '/test/importer.js');
+      // Should return null or the import path
+      expect(result === null || typeof result === 'string').toBe(true);
+    });
+
+    it('should resolve component imports', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.resolveId('@shohojdhara/atomix/components/Button', '/test/importer.js');
+      expect(result === null || typeof result === 'string').toBe(true);
+    });
+
+    it('should return null for non-Atomix imports', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.resolveId('react', '/test/importer.js');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Load Hook', () => {
+    it('should load virtual theme modules', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.load('virtual:atomix-theme');
+      expect(typeof result).toBe('string');
+    });
+
+    it('should return null for unknown virtual modules', () => {
+      const plugin = atomixRollupPlugin();
+      const result = plugin.load('virtual:unknown');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('GenerateBundle Hook', () => {
+    it('should process CSS assets', () => {
+      const plugin = atomixRollupPlugin({ optimize: true });
+      const bundle = {
+        'styles.css': {
+          type: 'asset',
+          fileName: 'atomix-styles.css',
+          source: 'body { color: red; }'
+        }
+      };
+      
+      // This should not throw an error
+      expect(() => {
+        plugin.generateBundle({}, bundle);
+      }).not.toThrow();
+    });
+
+    it('should skip non-CSS assets', () => {
+      const plugin = atomixRollupPlugin({ optimize: true });
+      const bundle = {
+        'script.js': {
+          type: 'chunk',
+          fileName: 'script.js',
+          code: 'console.log("hello");'
+        }
+      };
+      
+      expect(() => {
+        plugin.generateBundle({}, bundle);
+      }).not.toThrow();
+    });
+  });
+
+  describe('BuildStart Hook', () => {
+    it('should have buildStart function', () => {
+      const plugin = atomixRollupPlugin();
+      expect(typeof plugin.buildStart).toBe('function');
+    });
+  });
+
+  describe('Helper Functions', () => {
+    it('should get available themes', () => {
+      const themes = getAvailableThemes(null);
+      expect(Array.isArray(themes)).toBe(true);
+      expect(themes).toEqual([]);
+    });
+
+    it('should get Atomix package location', () => {
+      const location = getAtomixPackageLocation();
+      // Should return null or valid path
+      expect(location === null || typeof location === 'string').toBe(true);
+    });
+  });
+});