@amirdaraee/namewise 0.5.3 → 0.5.4

package/tests/unit/utils/naming-conventions.test.ts

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { applyNamingConvention, getNamingInstructions, NamingConvention } from '../../../src/utils/naming-conventions.js';
-
-describe('Naming Conventions', () => {
-  describe('applyNamingConvention()', () => {
-    const testText = 'Project Requirements Document 2024';
-
-    it('should apply kebab-case convention', () => {
-      const result = applyNamingConvention(testText, 'kebab-case');
-      expect(result).toBe('project-requirements-document-2024');
-    });
-
-    it('should apply snake_case convention', () => {
-      const result = applyNamingConvention(testText, 'snake_case');
-      expect(result).toBe('project_requirements_document_2024');
-    });
-
-    it('should apply camelCase convention', () => {
-      const result = applyNamingConvention(testText, 'camelCase');
-      expect(result).toBe('projectRequirementsDocument2024');
-    });
-
-    it('should apply PascalCase convention', () => {
-      const result = applyNamingConvention(testText, 'PascalCase');
-      expect(result).toBe('ProjectRequirementsDocument2024');
-    });
-
-    it('should apply lowercase convention', () => {
-      const result = applyNamingConvention(testText, 'lowercase');
-      expect(result).toBe('projectrequirementsdocument2024');
-    });
-
-    it('should apply UPPERCASE convention', () => {
-      const result = applyNamingConvention(testText, 'UPPERCASE');
-      expect(result).toBe('PROJECTREQUIREMENTSDOCUMENT2024');
-    });
-
-    it('should handle text with special characters', () => {
-      const textWithSpecialChars = 'User@Guide & Manual (v2.1)';
-      
-      expect(applyNamingConvention(textWithSpecialChars, 'kebab-case')).toBe('userguide-manual-v21');
-      expect(applyNamingConvention(textWithSpecialChars, 'snake_case')).toBe('userguide_manual_v21');
-      expect(applyNamingConvention(textWithSpecialChars, 'camelCase')).toBe('userguideManualV21');
-      expect(applyNamingConvention(textWithSpecialChars, 'PascalCase')).toBe('UserguideManualV21');
-    });
-
-    it('should handle text with existing hyphens and underscores', () => {
-      const textWithSeparators = 'my-file_name document';
-      
-      expect(applyNamingConvention(textWithSeparators, 'kebab-case')).toBe('my-file-name-document');
-      expect(applyNamingConvention(textWithSeparators, 'snake_case')).toBe('my_file_name_document');
-      expect(applyNamingConvention(textWithSeparators, 'camelCase')).toBe('myFileNameDocument');
-    });
-
-    it('should handle empty and whitespace-only strings', () => {
-      expect(applyNamingConvention('', 'kebab-case')).toBe('');
-      expect(applyNamingConvention('   ', 'kebab-case')).toBe('');
-    });
-
-    it('should normalize multiple spaces', () => {
-      const textWithSpaces = 'Meeting   Notes    From   Today';
-      expect(applyNamingConvention(textWithSpaces, 'kebab-case')).toBe('meeting-notes-from-today');
-    });
-
-    it('should default to kebab-case for unknown convention', () => {
-      const result = applyNamingConvention(testText, 'unknown' as NamingConvention);
-      expect(result).toBe('project-requirements-document-2024');
-    });
-  });
-
-  describe('getNamingInstructions()', () => {
-    it('should return correct instructions for each convention', () => {
-      expect(getNamingInstructions('kebab-case')).toContain('lowercase with hyphens');
-      expect(getNamingInstructions('snake_case')).toContain('lowercase with underscores');
-      expect(getNamingInstructions('camelCase')).toContain('camelCase format starting with lowercase');
-      expect(getNamingInstructions('PascalCase')).toContain('PascalCase format starting with uppercase');
-      expect(getNamingInstructions('lowercase')).toContain('single lowercase word');
-      expect(getNamingInstructions('UPPERCASE')).toContain('single uppercase word');
-    });
-
-    it('should include examples in instructions', () => {
-      expect(getNamingInstructions('kebab-case')).toContain('meeting-notes-2024');
-      expect(getNamingInstructions('snake_case')).toContain('meeting_notes_2024');
-      expect(getNamingInstructions('camelCase')).toContain('meetingNotes2024');
-      expect(getNamingInstructions('PascalCase')).toContain('MeetingNotes2024');
-    });
-  });
-});

package/tests/unit/utils/pdf-to-image.test.ts

@@ -1,127 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { PDFToImageConverter } from '../../../src/utils/pdf-to-image.js';
-import fs from 'fs';
-import path from 'path';
-
-describe('PDFToImageConverter', () => {
-  let samplePdfBuffer: Buffer;
-  const testDataDir = path.join(process.cwd(), 'tests/data');
-
-  beforeAll(async () => {
-    // Load sample PDF for testing
-    const pdfPath = path.join(testDataDir, 'sample-pdf.pdf');
-    samplePdfBuffer = fs.readFileSync(pdfPath);
-  });
-
-  describe('Integration with PDF Parser', () => {
-    it('should successfully convert scanned PDF through parser workflow', async () => {
-      // This simulates what happens in the actual PDF parser
-      const { PDFParser } = await import('../../../src/parsers/pdf-parser.js');
-      const parser = new PDFParser();
-
-      // Create a minimal scanned PDF scenario
-      const pdfPath = path.join(testDataDir, 'sample-pdf.pdf');
-
-      // Parse the PDF (this will trigger conversion if detected as scanned)
-      const result = await parser.parse(pdfPath);
-
-      // The parser should complete without throwing errors
-      expect(result).toBeDefined();
-      expect(result.content).toBeDefined();
-    }, 15000);
-  });
-
-  describe('convertFirstPageToBase64()', () => {
-    it('should convert PDF first page to base64 JPEG image', async () => {
-      const result = await PDFToImageConverter.convertFirstPageToBase64(samplePdfBuffer);
-
-      // Verify it's a base64 data URL (always JPEG for size optimization)
-      expect(result).toMatch(/^data:image\/jpeg;base64,/);
-
-      // Verify it has actual content
-      expect(result.length).toBeGreaterThan(100);
-
-      // Verify base64 encoding is valid
-      const base64Data = result.split(',')[1];
-      expect(() => Buffer.from(base64Data, 'base64')).not.toThrow();
-    }, 10000); // 10 second timeout for PDF processing
-
-    it('should respect format option when specified', async () => {
-      const result = await PDFToImageConverter.convertFirstPageToBase64(samplePdfBuffer, {
-        format: 'jpeg'
-      });
-
-      // Verify it's a base64 data URL (always JPEG for size optimization)
-      expect(result).toMatch(/^data:image\/jpeg;base64,/);
-
-      // Verify it has actual content
-      expect(result.length).toBeGreaterThan(100);
-    }, 10000);
-
-    it('should use custom scale factor', async () => {
-      const resultScale1 = await PDFToImageConverter.convertFirstPageToBase64(samplePdfBuffer, {
-        scale: 1.0
-      });
-
-      const resultScale2 = await PDFToImageConverter.convertFirstPageToBase64(samplePdfBuffer, {
-        scale: 2.0
-      });
-
-      // Both should be JPEG format
-      expect(resultScale1).toMatch(/^data:image\/jpeg;base64,/);
-      expect(resultScale2).toMatch(/^data:image\/jpeg;base64,/);
-
-      // Higher scale should generally produce larger image (though compression may vary)
-      expect(resultScale2.length).toBeGreaterThan(0);
-      expect(resultScale1.length).toBeGreaterThan(0);
-    }, 15000);
-
-    it('should handle invalid PDF buffer', async () => {
-      const invalidBuffer = Buffer.from('This is not a PDF');
-
-      await expect(
-        PDFToImageConverter.convertFirstPageToBase64(invalidBuffer)
-      ).rejects.toThrow(/PDF to image conversion failed/);
-    });
-
-    it('should handle empty buffer', async () => {
-      const emptyBuffer = Buffer.from([]);
-
-      await expect(
-        PDFToImageConverter.convertFirstPageToBase64(emptyBuffer)
-      ).rejects.toThrow(/PDF to image conversion failed/);
-    });
-  });
-
-  describe('isScannedPDF()', () => {
-    it('should detect scanned PDF with very little text', () => {
-      const scannedText = 'abc';
-      expect(PDFToImageConverter.isScannedPDF(scannedText)).toBe(true);
-    });
-
-    it('should detect scanned PDF with few words', () => {
-      const scannedText = 'one two three four';
-      expect(PDFToImageConverter.isScannedPDF(scannedText)).toBe(true);
-    });
-
-    it('should detect scanned PDF with high non-alphabetic ratio', () => {
-      const scannedText = '### %%% $$$ ### %%%';
-      expect(PDFToImageConverter.isScannedPDF(scannedText)).toBe(true);
-    });
-
-    it('should not detect normal PDF as scanned', () => {
-      const normalText = 'This is a normal document with plenty of readable text content that was generated from a text-based PDF file.';
-      expect(PDFToImageConverter.isScannedPDF(normalText)).toBe(false);
-    });
-
-    it('should detect empty text as scanned', () => {
-      const emptyText = '';
-      expect(PDFToImageConverter.isScannedPDF(emptyText)).toBe(true);
-    });
-
-    it('should detect whitespace-only text as scanned', () => {
-      const whitespaceText = '   \n  \t  ';
-      expect(PDFToImageConverter.isScannedPDF(whitespaceText)).toBe(true);
-    });
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "allowSyntheticDefaultImports": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/vitest.config.ts

@@ -1,30 +0,0 @@
-import { defineConfig } from 'vitest/config';
-import path from 'path';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['tests/**/*.test.{ts,js}'],
-    exclude: ['node_modules', 'dist'],
-    coverage: {
-      provider: 'v8',
-      include: ['src/**/*.ts'],
-      exclude: ['src/types/**', 'src/**/*.d.ts'],
-      reporter: ['text', 'json', 'html'],
-      thresholds: {
-        global: {
-          branches: 80,
-          functions: 80,
-          lines: 80,
-          statements: 80
-        }
-      }
-    }
-  },
-  resolve: {
-    alias: {
-      '@': path.resolve(__dirname, 'src')
-    }
-  }
-});