@shohojdhara/atomix 0.3.14 → 0.4.0

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

@@ -0,0 +1,161 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import {
+  filterComponents,
+  removeAtomImports,
+  shouldProcessFile,
+  getAvailableThemes,
+  createLogger,
+  generateThemeModule,
+  applyThemeToCSS,
+} from '../utils.js';
+
+describe('Shared Utilities (utils.js)', () => {
+  describe('filterComponents', () => {
+    const sampleCode = `
+      import { Button, Card, Input } from '@shohojdhara/atomix/components';
+      export default function App() {}
+    `;
+
+    it('should keep only selected components', () => {
+      const result = filterComponents(sampleCode, ['Button'], false);
+      expect(result).toContain('Button');
+      expect(result).not.toContain('Card');
+      expect(result).not.toContain('Input');
+    });
+
+    it('should keep Atom-prefixed imports when includeAtoms is true', () => {
+      const code = `import { Button, AtomIcon } from '@shohojdhara/atomix/components';`;
+      const result = filterComponents(code, ['Button'], true);
+      expect(result).toContain('Button');
+      expect(result).toContain('AtomIcon');
+    });
+
+    it('should return empty string when no components match', () => {
+      const result = filterComponents(sampleCode, ['NonExistent'], false);
+      expect(result).not.toContain('import');
+      expect(result).not.toContain('Button');
+    });
+
+    it('should not modify non-Atomix imports', () => {
+      const code = `import { useState } from 'react';`;
+      const result = filterComponents(code, ['Button'], false);
+      expect(result).toBe(code);
+    });
+
+    it('should handle multiple import statements', () => {
+      const code = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { Card } from '@shohojdhara/atomix/components';
+      `;
+      const result = filterComponents(code, ['Button'], false);
+      expect(result).toContain('Button');
+      expect(result).not.toContain('Card');
+    });
+  });
+
+  describe('removeAtomImports', () => {
+    it('should remove atom imports', () => {
+      const code = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+      `;
+      const result = removeAtomImports(code);
+      expect(result).toContain('Button');
+      expect(result).not.toContain('AtomButton');
+    });
+
+    it('should leave non-atom imports intact', () => {
+      const code = `import { Button } from '@shohojdhara/atomix/components';`;
+      const result = removeAtomImports(code);
+      expect(result).toContain('Button');
+    });
+  });
+
+  describe('shouldProcessFile', () => {
+    it('should return true for files importing @shohojdhara/atomix', () => {
+      expect(shouldProcessFile('/src/App.js', "import { Button } from '@shohojdhara/atomix';")).toBe(true);
+    });
+
+    it('should return true for files inside atomix node_modules', () => {
+      expect(shouldProcessFile('/project/node_modules/@shohojdhara/atomix/Button.js', '')).toBe(true);
+    });
+
+    it('should return false for unrelated files', () => {
+      expect(shouldProcessFile('/src/App.js', 'console.log("hello");')).toBe(false);
+    });
+
+    it('should NOT match files that merely contain "atomix" in their path', () => {
+      // This was a bug in the old implementation
+      expect(shouldProcessFile('/my-atomix-app/src/App.js', 'console.log("hello");')).toBe(false);
+    });
+  });
+
+  describe('getAvailableThemes', () => {
+    it('should return empty array when path is null', () => {
+      expect(getAvailableThemes(null)).toEqual([]);
+    });
+
+    it('should return empty array when path is undefined', () => {
+      expect(getAvailableThemes(undefined)).toEqual([]);
+    });
+
+    it('should return empty array for non-existent path', () => {
+      expect(getAvailableThemes('/nonexistent/path')).toEqual([]);
+    });
+  });
+
+  describe('createLogger', () => {
+    let consoleSpy;
+
+    beforeEach(() => {
+      consoleSpy = {
+        log: vi.spyOn(console, 'log').mockImplementation(() => {}),
+        warn: vi.spyOn(console, 'warn').mockImplementation(() => {}),
+        error: vi.spyOn(console, 'error').mockImplementation(() => {}),
+      };
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it('should log messages when verbose is true', () => {
+      const log = createLogger('[Test]', true);
+      log.log('hello');
+      expect(consoleSpy.log).toHaveBeenCalledWith('[Test] hello');
+    });
+
+    it('should NOT log messages when verbose is false', () => {
+      const log = createLogger('[Test]', false);
+      log.log('hello');
+      expect(consoleSpy.log).not.toHaveBeenCalled();
+    });
+
+    it('should always emit warnings regardless of verbose flag', () => {
+      const log = createLogger('[Test]', false);
+      log.warn('danger');
+      expect(consoleSpy.warn).toHaveBeenCalledWith('[Test] danger');
+    });
+
+    it('should always emit errors regardless of verbose flag', () => {
+      const log = createLogger('[Test]', false);
+      log.error('failure');
+      expect(consoleSpy.error).toHaveBeenCalled();
+    });
+  });
+
+  describe('generateThemeModule', () => {
+    it('should return error module when atomixRoot is null', () => {
+      const result = generateThemeModule('dark', null);
+      expect(result).toContain('Error generating theme module');
+    });
+  });
+
+  describe('applyThemeToCSS', () => {
+    it('should return comment fallback when theme cannot be loaded', () => {
+      const result = applyThemeToCSS('body { color: red; }', 'missing', null);
+      expect(result).toContain('Error loading theme CSS');
+      expect(result).toContain('body { color: red; }');
+    });
+  });
+});

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

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import atomixVitePlugin, { getAtomixPackageLocation, getAvailableThemes } from '../vite-plugin.js';
+
+describe('Atomix Vite Plugin', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Plugin Creation', () => {
+    it('should create plugin with default options', () => {
+      const plugin = atomixVitePlugin();
+      expect(plugin.name).toBe('atomix');
+      expect(typeof plugin.transform).toBe('function');
+      expect(typeof plugin.configureServer).toBe('function');
+    });
+
+    it('should create plugin with custom options', () => {
+      const options = {
+        theme: 'dark-complementary',
+        components: ['Button', 'Card'],
+        optimizeCss: false,
+        includeAtoms: true,
+        verbose: true
+      };
+      
+      const plugin = atomixVitePlugin(options);
+      expect(plugin.name).toBe('atomix');
+    });
+
+    it('should throw error for invalid theme type', () => {
+      expect(() => {
+        atomixVitePlugin({ theme: 123 });
+      }).toThrow('Theme must be a string');
+    });
+
+    it('should throw error for invalid components type', () => {
+      expect(() => {
+        atomixVitePlugin({ components: 'Button' });
+      }).toThrow('Components must be an array');
+    });
+  });
+
+  describe('Transform Hook', () => {
+    it('should process Atomix imports', async () => {
+      const plugin = atomixVitePlugin();
+      
+      // Mock configResolved to set atomixRoot
+      plugin.configResolved({ 
+        root: '/test/project' 
+      });
+      
+      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 = await plugin.transform(testCode, '/test/file.js');
+      
+      expect(result).toBeDefined();
+      expect(result.code).toContain('Button');
+      expect(result.map).toBeNull();
+    });
+
+    it('should filter components when specified', async () => {
+      const plugin = atomixVitePlugin({
+        components: ['Button']
+      });
+      
+      const testCode = `
+        import { Button, Card, Input } from '@shohojdhara/atomix/components';
+        export default function Test() {
+          return <Button>Hello</Button>;
+        }
+      `;
+      
+      const result = await 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', async () => {
+      const plugin = atomixVitePlugin({
+        includeAtoms: false
+      });
+      
+      const testCode = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+      `;
+      
+      const result = await plugin.transform(testCode, '/test/file.js');
+      expect(result.code).not.toContain('AtomButton');
+    });
+
+    it('should return null for non-Atomix files', async () => {
+      const plugin = atomixVitePlugin();
+      const result = await plugin.transform('console.log("hello");', '/test/other.js');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('Helper Functions', () => {
+    it('should get Atomix package location', () => {
+      const location = getAtomixPackageLocation();
+      // Should return null or valid path
+      expect(location === null || typeof location === 'string').toBe(true);
+    });
+
+    it('should get available themes', () => {
+      const themes = getAvailableThemes(null);
+      expect(Array.isArray(themes)).toBe(true);
+      expect(themes).toEqual([]);
+    });
+  });
+
+  describe('Build Hooks', () => {
+    it('should have buildStart hook', () => {
+      const plugin = atomixVitePlugin();
+      expect(typeof plugin.buildStart).toBe('function');
+    });
+  });
+});

package/build-tools/__tests__/webpack-loader.test.js

@@ -0,0 +1,190 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import atomixLoader, { pitch, getAtomixConfig, getAvailableThemes } from '../webpack-loader.js';
+
+// Mock Webpack loader context
+const createMockContext = (options = {}, resourcePath = '/test/file.js') => {
+  return {
+    getOptions: () => options,
+    resourcePath: resourcePath,
+    async: () => (err, result) => {
+      if (err) throw err;
+      return result;
+    }
+  };
+};
+
+describe('Atomix Webpack Loader', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('Loader Function', () => {
+    it('should process files with Atomix imports', () => {
+      const context = createMockContext({}, '/test/component.js');
+      const source = `
+        import { Button, Card } from '@shohojdhara/atomix/components';
+        export default function Test() {
+          return <Button>Test</Button>;
+        }
+      `;
+      
+      const result = atomixLoader.call(context, source);
+      
+      expect(result).toContain('Button');
+      expect(result).toContain('Card');
+    });
+
+    it('should filter components when specified', () => {
+      const context = createMockContext({
+        components: ['Button']
+      }, '/test/component.js');
+      
+      const source = `
+        import { Button, Card, Input } from '@shohojdhara/atomix/components';
+        export default function Test() {
+          return <Button>Test</Button>;
+        }
+      `;
+      
+      const result = atomixLoader.call(context, source);
+      
+      expect(result).toContain('Button');
+      expect(result).not.toContain('Card');
+      expect(result).not.toContain('Input');
+    });
+
+    it('should remove atom imports when includeAtoms is false', () => {
+      const context = createMockContext({
+        includeAtoms: false
+      }, '/test/component.js');
+      
+      const source = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+        export default function Test() {
+          return <Button>Test</Button>;
+        }
+      `;
+      
+      const result = atomixLoader.call(context, source);
+      
+      expect(result).toContain('Button');
+      expect(result).not.toContain('AtomButton');
+    });
+
+    it('should keep atom imports when includeAtoms is true', () => {
+      const context = createMockContext({
+        includeAtoms: true
+      }, '/test/component.js');
+      
+      const source = `
+        import { Button } from '@shohojdhara/atomix/components';
+        import { AtomButton } from '@shohojdhara/atomix/atoms';
+        export default function Test() {
+          return <Button>Test</Button>;
+        }
+      `;
+      
+      const result = atomixLoader.call(context, source);
+      
+      expect(result).toContain('Button');
+      expect(result).toContain('AtomButton');
+    });
+
+    it('should return source unchanged for non-Atomix files', () => {
+      const context = createMockContext({}, '/test/regular.js');
+      const source = 'console.log("hello world");';
+      
+      const result = atomixLoader.call(context, source);
+      
+      expect(result).toBe(source);
+    });
+
+    it('should throw error for invalid components type', () => {
+      const context = createMockContext({
+        components: 'Button' // Should be array
+      }, '/test/component.js');
+      
+      const source = 'import { Button } from "@shohojdhara/atomix/components";';
+      
+      expect(() => {
+        atomixLoader.call(context, source);
+      }).toThrow('Components must be an array');
+    });
+
+    it('should handle verbose logging', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const context = createMockContext({
+        verbose: true,
+        components: ['Button']
+      }, '/test/component.js');
+      
+      const source = `
+        import { Button, Card } from '@shohojdhara/atomix/components';
+        export default function Test() {
+          return <Button>Test</Button>;
+        }
+      `;
+      
+      atomixLoader.call(context, source);
+      
+      expect(consoleSpy).toHaveBeenCalledWith('[Atomix Webpack Loader] Processing: /test/component.js');
+      expect(consoleSpy).toHaveBeenCalledWith('[Atomix Webpack Loader] Selected components: Button');
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Pitch Function', () => {
+    it('should process Atomix files in pitch phase', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const context = createMockContext({
+        verbose: true
+      }, '/project/node_modules/@shohojdhara/atomix/Button.js');
+      
+      pitch.call(context);
+      
+      expect(consoleSpy).toHaveBeenCalledWith('[Atomix Webpack Loader - Pitch] Will process: /project/node_modules/@shohojdhara/atomix/Button.js');
+      
+      consoleSpy.mockRestore();
+    });
+
+    it('should skip non-Atomix files in pitch phase', () => {
+      const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const context = createMockContext({
+        verbose: true
+      }, '/project/src/App.js');
+      
+      const result = pitch.call(context);
+      
+      expect(result).toBeUndefined();
+      expect(consoleSpy).not.toHaveBeenCalled();
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Helper Functions', () => {
+    it('should get Atomix configuration with defaults', () => {
+      const config = getAtomixConfig('/test/project');
+      
+      expect(config).toEqual({
+        theme: 'default',
+        optimize: true,
+        includeAtoms: false,
+        components: []
+      });
+    });
+
+    it('should get available themes', () => {
+      const themes = getAvailableThemes('/test/project');
+      
+      expect(Array.isArray(themes)).toBe(true);
+      expect(themes).toEqual([]);
+    });
+  });
+});