jexidb 2.1.0 → 2.1.2

package/test/query-operators.test.js

@@ -1,238 +0,0 @@
-/**
- * Comprehensive tests for query operators
- * Tests the fixes for the $not operator and default operator behavior bugs
- */
-
-import { describe, it, expect, beforeEach, afterEach } from '@jest/globals';
-import Database from '../src/Database.mjs';
-import fs from 'fs';
-import path from 'path';
-
-describe('Query Operators', () => {
-  let db;
-  const testDbPath = 'test-query-operators-comprehensive';
-
-  beforeEach(async () => {
-    // Clean up any existing test database
-    if (fs.existsSync(testDbPath + '.jdb')) {
-      fs.unlinkSync(testDbPath + '.jdb');
-    }
-    if (fs.existsSync(testDbPath + '.terms.jdb')) {
-      fs.unlinkSync(testDbPath + '.terms.jdb');
-    }
-
-    db = new Database(testDbPath, {
-      debugMode: false,
-      termMapping: true,
-      termMappingFields: ['nameTerms', 'tags']
-    });
-
-    await db.init();
-
-    // Insert comprehensive test data
-    const testData = [
-      { id: 1, name: 'TV Câmara', nameTerms: ['tv', 'câmara'], tags: ['news', 'politics'], group: 'Brazil', rating: 4.5 },
-      { id: 2, name: 'TV Cultura', nameTerms: ['tv', 'cultura'], tags: ['culture', 'education'], group: 'Brazil', rating: 4.2 },
-      { id: 3, name: 'SBT', nameTerms: ['sbt'], tags: ['entertainment'], group: 'Brazil', rating: 3.8 },
-      { id: 4, name: 'Record News', nameTerms: ['record', 'news'], tags: ['news'], group: 'Brazil', rating: 4.0 },
-      { id: 5, name: 'CNN', nameTerms: ['cnn'], tags: ['news', 'international'], group: 'International', rating: 4.7 },
-      { id: 6, name: 'BBC', nameTerms: ['bbc'], tags: ['news', 'international'], group: 'International', rating: 4.6 },
-      { id: 7, name: 'TV Globo', nameTerms: ['tv', 'globo'], tags: ['entertainment', 'news'], group: 'Brazil', rating: 4.3 },
-      { id: 8, name: 'TV Record', nameTerms: ['tv', 'record'], tags: ['entertainment'], group: 'Brazil', rating: 3.9 },
-      { id: 9, name: 'Discovery', nameTerms: ['discovery'], tags: ['documentary', 'education'], group: 'International', rating: 4.4 },
-      { id: 10, name: 'National Geographic', nameTerms: ['national', 'geographic'], tags: ['documentary', 'nature'], group: 'International', rating: 4.8 }
-    ];
-
-    for (const record of testData) {
-      await db.insert(record);
-    }
-  });
-
-  afterEach(async () => {
-    if (db) {
-      await db.close();
-    }
-    
-    // Clean up test files
-    const files = [testDbPath + '.jdb', testDbPath + '.terms.jdb'];
-    for (const file of files) {
-      if (fs.existsSync(file)) {
-        fs.unlinkSync(file);
-      }
-    }
-  });
-
-  describe('$not Operator Fixes', () => {
-    it('should handle $not operator consistently with or without explicit $and', async () => {
-      // Test 1: $not without explicit $and (the bug case)
-      const result1 = await db.find({nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura'] }}});
-      expect(result1).toHaveLength(3); // TV Câmara, TV Globo, TV Record
-      expect(result1.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo', 'TV Record']));
-      expect(result1.map(r => r.name)).not.toContain('TV Cultura');
-
-      // Test 2: $not with explicit $and (should give same result)
-      const result2 = await db.find({"$and": [{nameTerms: 'tv'}, {$not: {nameTerms: { $in: ['cultura'] }}}]});
-      expect(result2).toHaveLength(3);
-      expect(result2.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo', 'TV Record']));
-      expect(result2.map(r => r.name)).not.toContain('TV Cultura');
-
-      // Both results should be identical
-      expect(result1.map(r => r.id).sort()).toEqual(result2.map(r => r.id).sort());
-    });
-
-    it('should handle $not with different fields', async () => {
-      const result = await db.find({group: 'Brazil', $not: {nameTerms: { $in: ['globo'] }}});
-      expect(result).toHaveLength(5); // All Brazil channels except TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'SBT', 'Record News', 'TV Record']));
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-    });
-
-    it('should handle complex $not queries', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura', 'globo'] }}});
-      expect(result).toHaveLength(2); // TV Câmara, TV Record
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Record']));
-      expect(result.map(r => r.name)).not.toContain('TV Cultura');
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-    });
-
-    it('should handle $not with numeric comparisons', async () => {
-      const result = await db.find({group: 'Brazil', $not: {rating: { $gte: 4.0 }}});
-      expect(result).toHaveLength(2); // SBT (3.8), TV Record (3.9)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['SBT', 'TV Record']));
-    });
-
-    it('should handle nested $not operators', async () => {
-      const result = await db.find({$not: {nameTerms: { $in: ['tv'] }}});
-      expect(result).toHaveLength(6); // All channels without 'tv' in nameTerms
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['SBT', 'Record News', 'CNN', 'BBC', 'Discovery', 'National Geographic']));
-      expect(result.map(r => r.name)).not.toContain('TV Câmara');
-      expect(result.map(r => r.name)).not.toContain('TV Cultura');
-      expect(result.map(r => r.name)).not.toContain('TV Globo');
-      expect(result.map(r => r.name)).not.toContain('TV Record');
-    });
-  });
-
-  describe('Default Operator Behavior (AND Logic)', () => {
-    it('should use AND logic for multiple conditions at root level', async () => {
-      const result = await db.find({nameTerms: 'tv', group: 'Brazil'});
-      expect(result).toHaveLength(4); // All TV channels in Brazil
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should use AND logic for multiple field conditions', async () => {
-      const result = await db.find({group: 'International', rating: { $gte: 4.5 }});
-      expect(result).toHaveLength(3); // CNN, BBC, National Geographic
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['CNN', 'BBC', 'National Geographic']));
-    });
-
-    it('should use AND logic with array field conditions', async () => {
-      const result = await db.find({tags: { $in: ['news'] }, group: 'Brazil'});
-      expect(result).toHaveLength(3); // TV Câmara, Record News, TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'Record News', 'TV Globo']));
-    });
-
-    it('should use AND logic with mixed operators', async () => {
-      const result = await db.find({
-        nameTerms: 'tv',
-        group: 'Brazil',
-        rating: { $gte: 4.0 },
-        tags: { $in: ['news'] }
-      });
-      expect(result).toHaveLength(2); // TV Câmara, TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Globo']));
-    });
-  });
-
-  describe('Complex Query Combinations', () => {
-    it('should handle $and with $not', async () => {
-      const result = await db.find({
-        "$and": [
-          {group: 'Brazil'},
-          {$not: {nameTerms: { $in: ['cultura', 'globo'] }}}
-        ]
-      });
-      expect(result).toHaveLength(4); // All Brazil channels except TV Cultura and TV Globo
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'SBT', 'Record News', 'TV Record']));
-    });
-
-    it('should handle $or with $not', async () => {
-      const result = await db.find({
-        "$or": [
-          {nameTerms: 'tv'},
-          {group: 'International'}
-        ],
-        $not: {rating: { $lt: 4.0 }}
-      });
-      // Should include TV channels with rating >= 4.0 OR International channels with rating >= 4.0
-      expect(result.length).toBeGreaterThan(0);
-      result.forEach(record => {
-        expect(record.rating).toBeGreaterThanOrEqual(4.0);
-      });
-    });
-
-    it('should handle multiple $not conditions', async () => {
-      // Note: Multiple $not conditions with the same key will overwrite each other
-      // This is expected JavaScript behavior. For multiple conditions, use $and
-      const result = await db.find({
-        "$and": [
-          {group: 'Brazil'},
-          {$not: {nameTerms: { $in: ['cultura'] }}},
-          {$not: {rating: { $lt: 4.0 }}}
-        ]
-      });
-      // This should be equivalent to: Brazil AND NOT cultura AND NOT rating < 4.0
-      expect(result.length).toBeGreaterThan(0);
-      result.forEach(record => {
-        expect(record.group).toBe('Brazil');
-        expect(record.nameTerms).not.toContain('cultura');
-        expect(record.rating).toBeGreaterThanOrEqual(4.0);
-      });
-    });
-  });
-
-  describe('Edge Cases', () => {
-    it('should handle empty $not condition', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {}});
-      expect(result).toHaveLength(4); // All TV channels (empty $not matches nothing, so excludes nothing)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should handle $not with non-existent field', async () => {
-      const result = await db.find({nameTerms: 'tv', $not: {nonExistentField: 'value'}});
-      expect(result).toHaveLength(4); // All TV channels (non-existent field never matches)
-      expect(result.map(r => r.name)).toEqual(expect.arrayContaining(['TV Câmara', 'TV Cultura', 'TV Globo', 'TV Record']));
-    });
-
-    it('should handle $not with null values', async () => {
-      // Insert a record with null value
-      await db.insert({ id: 99, name: 'Test Channel', nameTerms: null, group: 'Test' });
-      
-      const result = await db.find({group: 'Test', $not: {nameTerms: null}});
-      expect(result).toHaveLength(0); // No records match (the only Test record has null nameTerms)
-    });
-  });
-
-  describe('Performance and Consistency', () => {
-    it('should produce consistent results across multiple queries', async () => {
-      const query = {nameTerms: 'tv', $not: {nameTerms: { $in: ['cultura'] }}};
-      
-      // Run the same query multiple times
-      const results = [];
-      for (let i = 0; i < 5; i++) {
-        const result = await db.find(query);
-        results.push(result.map(r => r.id).sort());
-      }
-      
-      // All results should be identical
-      for (let i = 1; i < results.length; i++) {
-        expect(results[i]).toEqual(results[0]);
-      }
-    });
-
-    it('should handle large result sets with $not', async () => {
-      // This test ensures the fix works with larger datasets
-      const result = await db.find({$not: {group: 'NonExistent'}});
-      expect(result).toHaveLength(10); // All records (since no records have group 'NonExistent')
-    });
-  });
-});

package/test/regex-array-fields.test.js

@@ -1,129 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from '@jest/globals'
-import { Database } from '../src/Database.mjs'
-import path from 'path'
-
-describe('RegExp Queries on Array Fields', () => {
-  let testDir
-  let db
-
-  beforeEach(async () => {
-    testDir = path.join(process.cwd(), 'test-dbs')
-  })
-
-  afterEach(async () => {
-    if (db) {
-      await db.save()
-      await db.destroy()
-      db = null
-    }
-  })
-
-  describe('Bug Fix: RegExp on Array Fields', () => {
-    test('should correctly filter array fields with RegExp queries', async () => {
-      const dbPath = path.join(testDir, 'regex-array-fields.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data
-      await db.insert({ name: 'Globo', nameTerms: ['globo'] })
-      await db.insert({ name: 'FlixHD', nameTerms: ['flixhd'] })
-      await db.insert({ name: 'Netflix', nameTerms: ['netflix'] })
-      await db.insert({ name: 'Global News', nameTerms: ['global', 'news'] })
-
-      // Test 1: RegExp query that should match multiple records
-      const results1 = await db.find({ nameTerms: new RegExp('glob', 'i') })
-      expect(results1.length).toBe(2)
-      expect(results1.some(r => r.name === 'Globo')).toBe(true)
-      expect(results1.some(r => r.name === 'Global News')).toBe(true)
-
-      // Test 2: RegExp query with impossible pattern
-      const results2 = await db.find({ nameTerms: new RegExp('IMPOSSIBLE_PATTERN_12345', 'i') })
-      expect(results2.length).toBe(0)
-
-      // Test 3: RegExp query that matches multiple records with "flix"
-      const results3 = await db.find({ nameTerms: new RegExp('flix', 'i') })
-      expect(results3.length).toBe(2)
-      expect(results3.some(r => r.name === 'FlixHD')).toBe(true)
-      expect(results3.some(r => r.name === 'Netflix')).toBe(true)
-
-      // Test 4: RegExp query with anchor (start of string)
-      const results4 = await db.find({ nameTerms: new RegExp('^flix', 'i') })
-      expect(results4.length).toBe(1)
-      expect(results4[0].name).toBe('FlixHD')
-
-      // Test 5: RegExp query with case sensitivity
-      const results5 = await db.find({ nameTerms: new RegExp('GLOBO') })
-      expect(results5.length).toBe(0) // Should not match because it's case-sensitive
-
-      const results6 = await db.find({ nameTerms: new RegExp('GLOBO', 'i') })
-      expect(results6.length).toBe(1) // Should match because it's case-insensitive
-      expect(results6[0].name).toBe('Globo')
-    })
-
-    test('should correctly handle RegExp queries with multi-element arrays', async () => {
-      const dbPath = path.join(testDir, 'regex-multi-array.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data with multi-element arrays
-      await db.insert({ name: 'Test 1', tags: ['javascript', 'nodejs', 'backend'] })
-      await db.insert({ name: 'Test 2', tags: ['python', 'django', 'backend'] })
-      await db.insert({ name: 'Test 3', tags: ['javascript', 'react', 'frontend'] })
-      await db.insert({ name: 'Test 4', tags: ['ruby', 'rails', 'backend'] })
-
-      // Test: RegExp query that matches first element
-      const results1 = await db.find({ tags: new RegExp('java', 'i') })
-      expect(results1.length).toBe(2)
-      expect(results1.some(r => r.name === 'Test 1')).toBe(true)
-      expect(results1.some(r => r.name === 'Test 3')).toBe(true)
-
-      // Test: RegExp query that matches middle element
-      const results2 = await db.find({ tags: new RegExp('react', 'i') })
-      expect(results2.length).toBe(1)
-      expect(results2[0].name).toBe('Test 3')
-
-      // Test: RegExp query that matches last element
-      const results3 = await db.find({ tags: new RegExp('backend', 'i') })
-      expect(results3.length).toBe(3)
-      expect(results3.some(r => r.name === 'Test 1')).toBe(true)
-      expect(results3.some(r => r.name === 'Test 2')).toBe(true)
-      expect(results3.some(r => r.name === 'Test 4')).toBe(true)
-    })
-
-    test('should correctly handle $regex operator on array fields', async () => {
-      const dbPath = path.join(testDir, 'regex-operator-array.jdb')
-      
-      db = new Database(dbPath, {
-        clear: true,
-        create: true,
-        debugMode: false
-      })
-
-      await db.init()
-
-      // Insert test data
-      await db.insert({ name: 'Globo', nameTerms: ['globo'] })
-      await db.insert({ name: 'FlixHD', nameTerms: ['flixhd'] })
-      await db.insert({ name: 'Netflix', nameTerms: ['netflix'] })
-      await db.insert({ name: 'Global News', nameTerms: ['global', 'news'] })
-
-      // Test: $regex operator query
-      const results = await db.find({ nameTerms: { $regex: 'glob' } })
-      expect(results.length).toBe(2)
-      expect(results.some(r => r.name === 'Globo')).toBe(true)
-      expect(results.some(r => r.name === 'Global News')).toBe(true)
-    })
-  })
-})

package/test/score-method.test.js

@@ -1,238 +0,0 @@
-import fs from 'fs'
-import path from 'path'
-import { Database } from '../src/Database.mjs'
-
-// Clean up test files
-const cleanUp = (filePath) => {
-  try {
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath)
-    }
-  } catch (error) {
-    // Ignore cleanup errors
-  }
-}
-
-describe('Score Method Tests', () => {
-  let db
-  let testDbPath
-  let testIdxPath
-
-  beforeEach(async () => {
-    const testId = Math.random().toString(36).substring(7)
-    testDbPath = path.join(process.cwd(), `test-score-${testId}.jdb`)
-    testIdxPath = path.join(process.cwd(), `test-score-${testId}.idx.jdb`)
-    
-    // Clean up any existing files
-    cleanUp(testDbPath)
-    cleanUp(testIdxPath)
-    
-    // Create and initialize database
-    db = new Database(testDbPath, {
-      indexes: {
-        'terms': 'array:string'
-      }
-    })
-    await db.init()
-  })
-
-  afterEach(async () => {
-    if (db) {
-      await db.close()
-      db = null
-    }
-    
-    // Clean up test files
-    cleanUp(testDbPath)
-    cleanUp(testIdxPath)
-  })
-
-  describe('Basic Score Functionality', () => {
-    test('should score records based on terms in array field', async () => {
-      // Insert test data
-      await db.insert({ id: 1, title: 'Action Movie', terms: ['action', 'movie'] })
-      await db.insert({ id: 2, title: 'Comedy Show', terms: ['comedy', 'show'] })
-      await db.insert({ id: 3, title: 'Action Comedy', terms: ['action', 'comedy'] })
-      await db.insert({ id: 4, title: 'Documentary', terms: ['documentary'] })
-      await db.save()
-
-      // Score records
-      const results = await db.score('terms', {
-        'action': 1.0,
-        'comedy': 0.8
-      })
-
-      expect(results).toHaveLength(3)
-      
-      // Check first result (Action Comedy - highest score: 1.8)
-      expect(results[0].title).toBe('Action Comedy')
-      expect(results[0].score).toBe(1.8)
-      expect(results[0]._).toBeDefined()
-      
-      // Check second result (Action Movie - score: 1.0)
-      expect(results[1].title).toBe('Action Movie')
-      expect(results[1].score).toBe(1.0)
-      
-      // Check third result (Comedy Show - score: 0.8)
-      expect(results[2].title).toBe('Comedy Show')
-      expect(results[2].score).toBe(0.8)
-    })
-
-    test('should exclude records with zero scores', async () => {
-      await db.insert({ id: 1, title: 'Item 1', terms: ['tech'] })
-      await db.insert({ id: 2, title: 'Item 2', terms: ['science'] })
-      await db.insert({ id: 3, title: 'Item 3', terms: ['news'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'tech': 1.0
-      })
-
-      expect(results).toHaveLength(1)
-      expect(results[0].title).toBe('Item 1')
-    })
-
-    test('should handle decimal weights', async () => {
-      await db.insert({ id: 1, title: 'High Priority', terms: ['urgent', 'important'] })
-      await db.insert({ id: 2, title: 'Normal Priority', terms: ['normal'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'urgent': 0.9,
-        'important': 0.7,
-        'normal': 0.3
-      })
-
-      expect(results).toHaveLength(2)
-      expect(results[0].title).toBe('High Priority')
-      expect(results[0].score).toBe(1.6)
-      expect(results[1].title).toBe('Normal Priority')
-      expect(results[1].score).toBe(0.3)
-    })
-  })
-
-  describe('Options Tests', () => {
-    test('should respect limit option', async () => {
-      await db.insert({ id: 1, title: 'Item 1', terms: ['a'] })
-      await db.insert({ id: 2, title: 'Item 2', terms: ['a', 'b'] })
-      await db.insert({ id: 3, title: 'Item 3', terms: ['a', 'b', 'c'] })
-      await db.insert({ id: 4, title: 'Item 4', terms: ['a'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'a': 1.0,
-        'b': 2.0,
-        'c': 3.0
-      }, { limit: 2 })
-
-      expect(results).toHaveLength(2)
-    })
-
-    test('should respect sort ascending option', async () => {
-      await db.insert({ id: 1, title: 'High', terms: ['high'] })
-      await db.insert({ id: 2, title: 'Medium', terms: ['medium'] })
-      await db.insert({ id: 3, title: 'Low', terms: ['low'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'high': 3.0,
-        'medium': 2.0,
-        'low': 1.0
-      }, { sort: 'asc' })
-
-      expect(results).toHaveLength(3)
-      expect(results[0].title).toBe('Low')
-      expect(results[1].title).toBe('Medium')
-      expect(results[2].title).toBe('High')
-    })
-
-    test('should not include score when includeScore is false', async () => {
-      await db.insert({ id: 1, title: 'Test', terms: ['a'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'a': 1.0
-      }, { includeScore: false })
-
-      expect(results).toHaveLength(1)
-      expect(results[0].score).toBeUndefined()
-      expect(results[0]._).toBeDefined()
-    })
-
-    test('should default to including score', async () => {
-      await db.insert({ id: 1, title: 'Test', terms: ['a'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'a': 1.0
-      })
-
-      expect(results).toHaveLength(1)
-      expect(results[0].score).toBe(1.0)
-    })
-  })
-
-  describe('Edge Cases', () => {
-    test('should return empty array for empty scores', async () => {
-      await db.insert({ id: 1, title: 'Test', terms: ['a'] })
-      await db.save()
-
-      const results = await db.score('terms', {})
-      expect(results).toHaveLength(0)
-    })
-
-    test('should return empty array when no terms match', async () => {
-      await db.insert({ id: 1, title: 'Test', terms: ['a'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'nonexistent': 1.0
-      })
-      
-      expect(results).toHaveLength(0)
-    })
-
-    test('should handle empty database', async () => {
-      const results = await db.score('terms', {
-        'a': 1.0
-      })
-
-      expect(results).toHaveLength(0)
-    })
-
-    test('should handle multiple occurrences of same term', async () => {
-      await db.insert({ id: 1, title: 'Test 1', terms: ['important', 'important'] })
-      await db.insert({ id: 2, title: 'Test 2', terms: ['important'] })
-      await db.save()
-
-      const results = await db.score('terms', {
-        'important': 1.0
-      })
-
-      // Both should have score 1.0 (duplicates in array don't multiply score)
-      expect(results).toHaveLength(2)
-    })
-  })
-
-  describe('Error Handling', () => {
-    test('should throw error for invalid fieldName', async () => {
-      await expect(db.score('', { 'a': 1.0 })).rejects.toThrow('non-empty string')
-      await expect(db.score(null, { 'a': 1.0 })).rejects.toThrow('non-empty string')
-    })
-
-    test('should throw error for non-indexed field', async () => {
-      await expect(db.score('nonexistent', { 'a': 1.0 }))
-        .rejects.toThrow('not indexed')
-    })
-
-    test('should throw error for invalid scores object', async () => {
-      await expect(db.score('terms', null)).rejects.toThrow('must be an object')
-      await expect(db.score('terms', [])).rejects.toThrow('must be an object')
-    })
-
-    test('should throw error for non-numeric scores', async () => {
-      await expect(db.score('terms', { 'a': 'invalid' }))
-        .rejects.toThrow('must be a number')
-    })
-  })
-})

package/test/setup.js

@@ -1,17 +0,0 @@
-// Setup file to add Mocha-style matchers to Jest
-import { expect } from '@jest/globals'
-
-// Add the chai-style API to expect
-expect.to = {
-  deep: {
-    equal: (received, expected) => {
-      return expect(received).toEqual(expected)
-    }
-  },
-  equal: (received, expected) => {
-    return expect(received).toBe(expected)
-  }
-}
-
-// Also add to global expect
-global.expect = expect