@natlibfi/marc-record-validators-melinda 11.6.7 → 12.0.0-alpha.12

package/src/{field-exclusion.spec.js → field-exclusion.test.js}

@@ -1,10 +1,7 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/field-exclusion';
-
-const {expect} = chai;
-chai.use(chaiAsPromised);
+import validatorFactory from '../src/field-exclusion.js';
+import {describe, it} from 'node:test';
 
 // Factory validation
 describe('field-exclusion', () => {
@@ -13,12 +10,9 @@ describe('field-exclusion', () => {
       const config = [/^500$/u];
 
       const validator = await validatorFactory(config);
-      expect(validator)
-        .to.be.an('object')
-        .that.has.any.keys('description', 'validate');
-
-      expect(validator.description).to.be.a('string');
-      expect(validator.validate).to.be.a('function');
+      assert.equal(typeof validator, 'object');
+      assert.equal(typeof validator.description, 'string');
+      assert.equal(typeof validator.validate, 'function');
     });
 
     it('Creates a validator from complex config', async () => {
@@ -30,12 +24,11 @@ describe('field-exclusion', () => {
       ];
 
       const validator = await validatorFactory(config);
-      expect(validator)
-        .to.be.an('object')
-        .that.has.any.keys('description', 'validate');
 
-      expect(validator.description).to.be.a('string');
-      expect(validator.validate).to.be.a('function');
+      assert.equal(typeof validator, 'object');
+      assert.equal(typeof validator.description, 'string');
+      assert.equal(typeof validator.validate, 'function');
+
     });
 
     it('Fails to create a validator from invalid config - tag', async () => {
@@ -49,7 +42,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: tag');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: tag');
       }
     });
 
@@ -62,7 +56,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration array not provided');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration array not provided');
       }
     });
 
@@ -77,7 +72,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: code');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: code');
       }
     });
 
@@ -92,7 +88,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: value');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: value');
       }
     });
 
@@ -109,7 +106,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - excluded element');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - excluded element');
       }
     });
 
@@ -124,7 +122,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - missing mandatory element: tag');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - missing mandatory element: tag');
       }
     });
 
@@ -142,7 +141,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - subfield: /9/,/^(?!FENNI<KEEP>).*$/ not object');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - subfield: /9/,/^(?!FENNI<KEEP>).*$/ not object');
       }
     });
 
@@ -161,7 +161,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - subfield: /9/ not object');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - subfield: /9/ not object');
       }
     });
 
@@ -179,7 +180,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - missing mandatory element: code');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - missing mandatory element: code');
       }
     });
 
@@ -198,7 +200,8 @@ describe('field-exclusion', () => {
       try {
         await validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - unidentified value: unidentified');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - unidentified value: unidentified');
       }
     });
   });
@@ -286,31 +289,31 @@ describe('field-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Finds the record invalid - double', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalidDouble);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded', 'Field $500 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $500 should be excluded', 'Field $500 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
 
     it('Repairs invalid record - double', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalidDouble);
-      expect(recordInvalidDouble.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalidDouble.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -397,31 +400,31 @@ describe('field-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $648 should be excluded']});
     });
 
     it('Finds the record invalid - double', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalidDouble);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
 
     it('Repairs invalid record - double', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalidDouble);
-      expect(recordInvalidDouble.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalidDouble.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -504,31 +507,31 @@ describe('field-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $648 should be excluded']});
     });
 
     it('Finds the record invalid - double', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalidDouble);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $648 should be excluded', 'Field $650 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.deepEqual(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
 
     it('Repairs invalid record - double', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalidDouble);
-      expect(recordInvalidDouble.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalidDouble.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -597,19 +600,19 @@ describe('field-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -714,19 +717,19 @@ describe('field-exclusion', () => {
     it('Finds the record valid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $650 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $650 should be excluded']});
     });
 
     it('Finds the record invalid (spec)', async () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(recordInvalidMulti);
-      expect({valid, message}).to.eql({valid: false, message: [
+      assert.deepEqual({valid, message}, {valid: false, message: [
         'Field $648 should be excluded',
         'Field $650 should be excluded',
         'Field $650 should be excluded',
@@ -738,13 +741,13 @@ describe('field-exclusion', () => {
     it('Repairs invalid multi record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalidMulti);
-      expect(recordInvalidMulti.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalidMulti.equalsTo(recordInvalidFixed), true);
     });
 
     it('Repairs invalid record', async () => {
       const validator = await validatorFactory(config);
       await validator.fix(recordInvalid);
-      expect(recordInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordInvalid.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -830,37 +833,37 @@ describe('field-exclusion', () => {
     it('Finds the record valid - Ind1&Ind2', async () => {
       const validator = await validatorFactory(configInd);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record valid - Value', async () => {
       const validator = await validatorFactory(configValue);
       const {valid, message} = await validator.validate(recordValid);
-      expect({valid, message}).to.eql({valid: true, message: []});
+      assert.deepEqual({valid, message}, {valid: true, message: []});
     });
 
     it('Finds the record invalid - Ind', async () => {
       const validator = await validatorFactory(configInd);
       const {valid, message} = await validator.validate(recordIndInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Finds the record invalid - Value', async () => {
       const validator = await validatorFactory(configValue);
       const {valid, message} = await validator.validate(recordValueInvalid);
-      expect({valid, message}).to.eql({valid: false, message: ['Field $500 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $500 should be excluded']});
     });
 
     it('Repairs invalid record - Ind', async () => {
       const validator = await validatorFactory(configInd);
       await validator.fix(recordIndInvalid);
-      expect(recordIndInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordIndInvalid.equalsTo(recordInvalidFixed), true);
     });
 
     it('Repairs invalid record - Value', async () => {
       const validator = await validatorFactory(configValue);
       await validator.fix(recordValueInvalid);
-      expect(recordValueInvalid.equalsTo(recordInvalidFixed)).to.eql(true);
+      assert.equal(recordValueInvalid.equalsTo(recordInvalidFixed), true);
     });
   });
 
@@ -888,7 +891,7 @@ describe('field-exclusion', () => {
       const validator = await validatorFactory(config);
       const {valid, message} = await validator.validate(record);
 
-      expect({valid, message}).to.eql({valid: false, message: ['Field $041 should be excluded']});
+      assert.deepEqual({valid, message}, {valid: false, message: ['Field $041 should be excluded']});
     });
   });
 });

package/src/{field-structure.spec.js → field-structure.test.js}

@@ -1,10 +1,8 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/field-structure';
+import validatorFactory from './field-structure.js';
 
-const {expect} = chai;
-chai.use(chaiAsPromised);
 
 // Factory validation
 describe('field-structure', () => {
@@ -24,12 +22,9 @@ describe('field-structure', () => {
 
     const validator = await validatorFactory(config);
 
-    expect(validator)
-      .to.be.an('object')
-      .that.has.any.keys('description', 'validate');
-
-    expect(validator.description).to.be.a('string');
-    expect(validator.validate).to.be.a('function');
+    assert.equal(typeof validator, 'object');
+    assert.equal(typeof validator.description, 'string');
+    assert.equal(typeof validator.validate, 'function');
   });
 
   describe('#configuration', () => {
@@ -37,7 +32,8 @@ describe('field-structure', () => {
       try {
         validatorFactory();
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration array not provided');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration array not provided');
       }
     });
 
@@ -52,7 +48,8 @@ describe('field-structure', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - unidentified value: tags');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - unidentified value: tags');
       }
     });
 
@@ -67,7 +64,8 @@ describe('field-structure', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - invalid data type for: tag');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - invalid data type for: tag');
       }
     });
 
@@ -82,7 +80,8 @@ describe('field-structure', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - excluded element');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - excluded element');
       }
     });
 
@@ -101,7 +100,8 @@ describe('field-structure', () => {
       try {
         validatorFactory(config);
       } catch (error) {
-        expect(error).to.be.an('error').with.property('message', 'Configuration not valid - subfields not object');
+        assert.equal(error instanceof Error, true);
+        assert.equal(error.message, 'Configuration not valid - subfields not object');
       }
     });
   });
@@ -127,7 +127,7 @@ describe('field-structure', () => {
     const validator = await validatorFactory(config);
     const result = await validator.validate(record);
 
-    expect(result).to.eql({valid: true});
+    assert.deepEqual(result, {valid: true});
   });
 
   // Indicators and subfields validation
@@ -218,14 +218,14 @@ describe('field-structure', () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordValid);
 
-      expect(result).to.eql({valid: true});
+      assert.deepEqual(result, {valid: true});
     });
 
     it('Finds the record invalid: Too many subfields', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidMany);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
   });
 
@@ -447,41 +447,41 @@ describe('field-structure', () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordValid);
 
-      expect(result).to.eql({valid: true});
+      assert.deepEqual(result, {valid: true});
     });
 
     it('Finds the record invalid: Extra field in strict', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidExtra);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
 
     it('Finds the record invalid: Too many occurances', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidTooMany);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
 
     it('Finds the record invalid: Invalid RegExp', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidRegExp);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
 
     it('Finds the record invalid: Missing field', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidMissing);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
     it('Finds the record invalid: Missing subfield', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalidMissingSubfield);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
   });
 
@@ -569,14 +569,14 @@ describe('field-structure', () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordValid);
 
-      expect(result).to.eql({valid: true});
+      assert.deepEqual(result, {valid: true});
     });
 
     it('Finds the record invalid', async () => {
       const validator = await validatorFactory(config);
       const result = await validator.validate(recordInvalid);
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
 
     it('Find the record valid (Dependency on leader)', async () => {
@@ -589,7 +589,7 @@ describe('field-structure', () => {
         ]
       }));
 
-      expect(result).to.eql({valid: true});
+      assert.deepEqual(result, {valid: true});
     });
 
     it('Find the record invalid (Dependency on leader)', async () => {
@@ -602,7 +602,7 @@ describe('field-structure', () => {
         ]
       }));
 
-      expect(result).to.eql({valid: false});
+      assert.deepEqual(result, {valid: false});
     });
   });
 });

package/src/{fields-present.spec.js → fields-present.test.js}

@@ -1,28 +1,25 @@
-import chai from 'chai';
-import chaiAsPromised from 'chai-as-promised';
+import {describe, it} from 'node:test';
+import assert from 'node:assert';
 import {MarcRecord} from '@natlibfi/marc-record';
-import validatorFactory from '../src/fields-present';
+import validatorFactory from '../src/fields-present.js';
+
 
-const {expect} = chai;
-chai.use(chaiAsPromised);
 
 describe('fields-present', () => {
   it('Creates a validator', async () => {
     const validator = await validatorFactory([/^500$/u, /^400$/u]);
 
-    expect(validator)
-      .to.be.an('object')
-      .that.has.any.keys('description', 'validate');
-
-    expect(validator.description).to.be.a('string');
-    expect(validator.validate).to.be.a('function');
+    assert.equal(typeof validator, 'object');
+    assert.equal(typeof validator.description, 'string');
+    assert.equal(typeof validator.validate, 'function');
   });
 
   it('Throws an error when tagPatterns not provided', () => {
     try {
       validatorFactory();
     } catch (error) {
-      expect(error).to.be.an('error').with.property('message', 'No tag pattern array provided');
+      assert.equal(error instanceof Error, true);
+      assert.equal(error.message, 'No tag pattern array provided');
     }
   });
 
@@ -48,7 +45,7 @@ describe('fields-present', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true, messages: []});
+      assert.deepEqual(result, {valid: true, messages: []});
     });
     it('Finds the record valid', async () => {
       const tagPatterns = [/^(020|022|024)$/u];
@@ -71,7 +68,7 @@ describe('fields-present', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: true, messages: []});
+      assert.deepEqual(result, {valid: true, messages: []});
     });
     it('Finds the record invalid', async () => {
       const tagPatterns = [/^5..$/u, /^FOO$/u];
@@ -100,7 +97,7 @@ describe('fields-present', () => {
       });
       const result = await validator.validate(record);
 
-      expect(result).to.eql({valid: false, messages: ['The following tag patterns are not present in the record tag field:   /^FOO$/u']});
+      assert.deepEqual(result, {valid: false, messages: ['The following tag patterns are not present in the record tag field:   /^FOO$/u']});
     });
   });
 });

package/src/fix-33X.js

@@ -1,7 +1,7 @@
 //import createDebugLogger from 'debug';
 import clone from 'clone';
-import {fieldToString, getCatalogingLanguage, nvdebug} from './utils';
-import {map336CodeToTerm, map337CodeToTerm, map338CodeToTerm} from './field33XUtils';
+import {fieldToString, getCatalogingLanguage, nvdebug} from './utils.js';
+import {map336CodeToTerm, map337CodeToTerm, map338CodeToTerm} from './field33XUtils.js';
 
 const description = 'Fix non-RDA 33X field(s)';
 
@@ -376,7 +376,7 @@ export default function () {
     nvdebug(`FIX ${description}...`);
     const catLang = getCatalogingLanguage(record) || 'fin';
     const fields = getRelevantFields(record);
-    fields.forEach(f => fixField(f, catLang)); // eslint-disable-line array-callback-return
+    fields.forEach(f => fixField(f, catLang));
     nvdebug(` GOT ${fields.length}...`);
     // FFS: we actually need newFields array here! Videogame, for example, might be
     // 336 ## ‡a kaksiulotteinen liikkuva kuva ‡b tdi ‡2 rdacontent
@@ -395,7 +395,7 @@ export default function () {
     }
     const originalStrings = fields.map(f => fieldToString(f));
     const clonedFields = fields.map(f => clone(f));
-    clonedFields.forEach(f => fixField(f, catLang)); // eslint-disable-line array-callback-return
+    clonedFields.forEach(f => fixField(f, catLang));
     const modifiedStrings = clonedFields.map(f => fieldToString(f));
 
     const changes = originalStrings.map((str, i) => `'${str}' => '${modifiedStrings[i]}'`);