Upgrade TypeScript to 6.0.3 and add node types in tsconfig files

doc-gen/tsconfig.json

@@ -1,4 +1,7 @@
 {
-  "extends": "../tsconfig.json"
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "types": ["node"]
+  }
 }
 

lib/tsconfig.json

@@ -1,6 +1,7 @@
 {
   "extends": "../tsconfig.json",
   "compilerOptions": {
+    "types": ["node"],
     "sourceMap": true,
     "inlineSources": true,
     "declaration": true,

package.json

@@ -142,7 +142,7 @@
     "remark-cli": "^12.0.1",
     "remark-preset-lint-consistent": "^6.0.1",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.3"
   },
   "engines": {
     "node": ">=18"

test/test-common.ts

@@ -94,7 +94,7 @@ describe('function selectCover()', () => {
         if (cover.type) {
           assert.equal(cover.type, 'Cover (front)', 'cover.type');
         } else {
-          assert.equal(cover.data, common.picture[0].data, 'First picture if no type is defined');
+          assert.equal(cover.data, common.picture![0].data, 'First picture if no type is defined');
         }
       }
     }

test/test-concurrent-picture.ts

@@ -13,7 +13,7 @@ it("should handle concurrent parsing of pictures", () => {
   return Promise.all<void>(files.map(file => {
     return mm.parseFile(file).then(result => {
       const data = fs.readFileSync(`${file}.jpg`);
-      t.deepEqual(result.common.picture[0].data, data, 'check picture');
+      t.deepEqual(result.common.picture![0].data, data, 'check picture');
     });
   }));
 });

test/test-discogs.ts

@@ -50,7 +50,7 @@ describe('Discogs mappings', () => {
 
   describe('Track mapping: Beth Hart - Sinner\'s Prayer', () => {
 
-    function checkTags(metadata: mm.IAudioMetadata, tagType, getTagName: (tag: string) => string) {
+    function checkTags(metadata: mm.IAudioMetadata, tagType: string, getTagName: (tag: string) => string) {
 
       const native = mm.orderTags(metadata.native[tagType]);
       const common = metadata.common;
@@ -117,7 +117,7 @@ describe('Discogs mappings', () => {
       // t.deepEqual(format.numberOfSamples, 93624, "format.numberOfSamples");
       assert.deepEqual(format.sampleRate, 44100, 'format.sampleRate');
       assert.deepEqual(format.duration, 2.1681632653061222, 'format.duration');
-      assert.approximately(format.bitrate, 156000, 1000, 'format.bitrate');
+      assert.approximately(format.bitrate as number, 156000, 1000, 'format.bitrate');
       assert.deepEqual(format.numberOfChannels, 2, 'format.numberOfChannels');
 
       // Expect basic common tags
@@ -143,11 +143,6 @@ describe('Discogs mappings', () => {
       const filename = 'Discogs - Beth Hart - Sinner\'s Prayer [APEv2].flac';
       const filePath = path.join(samplePath, filename);
 
-      function _checkNative(id3v23) {
-        // Compare expectedCommonTags with result.common
-        assert.deepEqual(id3v23['TXXX:CATALOGID'], 'PRAR931391');
-      }
-
       // Run with default options
       const metadata = await mm.parseFile(filePath);
 
@@ -167,7 +162,7 @@ describe('Discogs mappings', () => {
 
   describe('Track mapping: Yasmin Levy - Mi Korasón.flac\'', () => {
 
-    function checkTags(metadata: mm.IAudioMetadata, tagType, getTagName: (tag: string) => string) {
+    function checkTags(metadata: mm.IAudioMetadata, tagType: string, getTagName: (tag: string) => string) {
 
       const native = mm.orderTags(metadata.native[tagType]);
       const common = metadata.common;

test/test-file-aac.ts

@@ -13,13 +13,13 @@ describe('Parse ADTS/AAC', () => {
   function checkFormat(format: IFormat, dataFormat: string, codec: string, codecProfile: string, sampleRate: number, channels: number, bitrate: number, samples: number) {
     assert.strictEqual(format.container, dataFormat, 'format.container');
     assert.strictEqual(format.codec, codec, 'format.codec');
-    assert.strictEqual(format.codecProfile, codecProfile, 'format.codecProfile');
+    assert.strictEqual(format.codecProfile!, codecProfile, 'format.codecProfile');
     assert.strictEqual(format.lossless, false, 'format.lossless');
     assert.strictEqual(format.sampleRate, sampleRate, 'format.sampleRate');
     assert.strictEqual(format.numberOfChannels, channels, 'format.numberOfChannels');
-    assert.approximately(format.bitrate, bitrate, 500, 'format.bitrate');
+    assert.approximately(format.bitrate!, bitrate, 500, 'format.bitrate');
     assert.strictEqual(format.numberOfSamples, samples, `format.numberOfSamples = ${samples} samples`);
-    assert.approximately(format.duration, samples / sampleRate, 0.1, 'format.duration');
+    assert.approximately(format.duration!, samples / sampleRate, 0.1, 'format.duration');
     assert.isTrue(format.hasAudio, 'format.hasAudio');
     assert.isFalse(format.hasVideo, 'format.hasAudio');
   }

test/test-file-aiff.ts

@@ -13,6 +13,7 @@ describe('Parse AIFF (Audio Interchange File Format)', () => {
   function checkFormat(format: mm.IFormat, compressionType: string, sampleRate: number, channels: number, bitsPerSample: number, samples: number) {
     const lossless = compressionType === 'PCM';
     const dataFormat = lossless ? 'AIFF' : 'AIFF-C';
+    assert.isDefined(format.sampleRate, 'format.sampleRate should be defined');
     const duration = samples / format.sampleRate;
     assert.strictEqual(format.container, dataFormat, `format.container = '${dataFormat}'`);
     assert.strictEqual(format.lossless, lossless, `format.lossless = ${lossless}`);

test/test-file-ape.ts

@@ -8,7 +8,7 @@ import type { IPicture } from '../lib/index.js';
 
 describe('Parse APE (Monkey\'s Audio)', () => {
 
-  function checkFormat(format) {
+  function checkFormat(format: mm.IFormat) {
     assert.strictEqual(format.bitsPerSample, 16, 'format.bitsPerSample');
     assert.strictEqual(format.sampleRate, 44100, 'format.sampleRate = 44.1 [kHz]');
     assert.strictEqual(format.numberOfChannels, 2, 'format.numberOfChannels 2 (stereo)');
@@ -17,7 +17,7 @@ describe('Parse APE (Monkey\'s Audio)', () => {
     assert.isFalse(format.hasVideo, 'format.hasAudio');
   }
 
-  function checkCommon(common) {
+  function checkCommon(common: mm.ICommonTagsResult) {
     assert.strictEqual(common.title, '07. Shadow On The Sun', 'common.title');
     assert.strictEqual(common.artist, 'Audioslave', 'common.artist');
     assert.deepEqual(common.artists, ['Audioslave', 'Chris Cornell'], 'common.artists');
@@ -28,10 +28,10 @@ describe('Parse APE (Monkey\'s Audio)', () => {
     assert.deepEqual(common.genre, ['Alternative'], 'common.genre');
     assert.deepEqual(common.track, {no: 7, of: null}, 'common.track');
     assert.deepEqual(common.disk, {no: 3, of: null}, 'common.disk');
-    assert.strictEqual(common.picture[0].format, 'image/jpeg', 'common.picture 0 format');
-    assert.strictEqual(common.picture[0].data.length, 48658, 'common.picture 0 length');
-    assert.strictEqual(common.picture[1].format, 'image/jpeg', 'common.picture 1 format');
-    assert.strictEqual(common.picture[1].data.length, 48658, 'common.picture 1 length');
+    assert.strictEqual(common.picture![0].format, 'image/jpeg', 'common.picture 0 format');
+    assert.strictEqual(common.picture![0].data.length, 48658, 'common.picture 0 length');
+    assert.strictEqual(common.picture![1].format, 'image/jpeg', 'common.picture 1 format');
+    assert.strictEqual(common.picture![1].data.length, 48658, 'common.picture 1 length');
   }
 
   function checkNative(ape: mm.INativeTagDict) {
@@ -68,7 +68,7 @@ describe('Parse APEv2 header', () => {
     assert.strictEqual(format.codec, 'MPEG 1 Layer 3', 'format.codec');
     assert.strictEqual(format.codecProfile, 'CBR', 'format.codecProfile');
     assert.strictEqual(format.tool, 'LAME 3.99r', 'format.codecProfile');
-    assert.approximately(format.duration, 348.421, 1 / 500, 'format.duration');
+    assert.approximately(format.duration!, 348.421, 1 / 500, 'format.duration');
     assert.deepEqual(format.sampleRate, 44100, 'format.sampleRate');
     assert.deepEqual(format.tagTypes, ['ID3v2.4', 'APEv2', 'ID3v1'], 'format.tagTypes');
     assert.strictEqual(format.bitrate, 320000, 'format.bitrate');

test/test-file-asf.ts

@@ -79,16 +79,16 @@ describe('Parse ASF', () => {
 
   describe('parse', () => {
 
-    function checkFormat(format) {
+    function checkFormat(format: mm.IFormat) {
       assert.strictEqual(format.container, 'ASF/audio', 'format.container');
       assert.strictEqual(format.codec, 'Windows Media Audio 9.1', 'format.codec');
-      assert.approximately(format.duration, 243.306, 1 / 10000, 'format.duration');
+      assert.approximately(format.duration!, 243.306, 1 / 10000, 'format.duration');
       assert.strictEqual(format.bitrate, 192639, 'format.bitrate');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
       assert.isFalse(format.hasVideo, 'format.hasVideo');
     }
 
-    function checkCommon(common) {
+    function checkCommon(common: mm.ICommonTagsResult) {
       assert.strictEqual(common.title, 'Don\'t Bring Me Down', 'common.title');
       assert.deepEqual(common.artist, 'Electric Light Orchestra', 'common.artist');
       assert.deepEqual(common.albumartist, 'Electric Light Orchestra', 'common.albumartist');
@@ -147,8 +147,8 @@ describe('Parse ASF', () => {
 
       assert.strictEqual(format.container, 'ASF/audio', 'format.container');
       assert.strictEqual(format.codec, 'Windows Media Audio 9', 'format.codec');
-      assert.approximately(format.duration, 14.466, 1 / 10000, 'format.duration');
-      assert.approximately(format.bitrate, 128639, 1, 'format.bitrate');
+      assert.approximately(format.duration!, 14.466, 1 / 10000, 'format.duration');
+      assert.approximately(format.bitrate!, 128639, 1, 'format.bitrate');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
       assert.isFalse(format.hasVideo, 'format.hasVideo');  });
 

test/test-file-flac.ts

@@ -4,14 +4,15 @@ import * as path from 'node:path';
 
 import * as mm from '../lib/index.js';
 import { LyricsContentType, TimestampFormat } from '../lib/index.js';
+import type { IVorbisPicture } from '../lib/ogg/vorbis/Vorbis.js';
 import { Parsers } from './metadata-parsers.js';
 import { samplePath } from './util.js';
 
 describe('Parse FLAC Vorbis comment', () => {
 
   const flacFilePath = path.join(samplePath, 'flac');
 
-  function checkFormat(format) {
+  function checkFormat(format: mm.IFormat) {
     assert.strictEqual(format.container, 'FLAC', 'format.container');
     assert.strictEqual(format.codec, 'FLAC', 'format.codec');
     assert.deepEqual(format.tagTypes, ['vorbis'], 'format.tagTypes');
@@ -23,7 +24,7 @@ describe('Parse FLAC Vorbis comment', () => {
     assert.isFalse(format.hasVideo, 'format.hasAudio');
   }
 
-  function checkCommon(common) {
+  function checkCommon(common: mm.ICommonTagsResult) {
     assert.strictEqual(common.title, 'Brian Eno', 'common.title');
     assert.deepEqual(common.artists, ['MGMT'], 'common.artists');
     assert.strictEqual(common.albumartist, undefined, 'common.albumartist');
@@ -32,19 +33,19 @@ describe('Parse FLAC Vorbis comment', () => {
     assert.deepEqual(common.track, {no: 7, of: null}, 'common.track');
     assert.deepEqual(common.disk, {no: null, of: null}, 'common.disk');
     assert.deepEqual(common.genre, ['Alt. Rock'], 'genre');
-    assert.strictEqual(common.picture[0].format, 'image/jpeg', 'common.picture format');
-    assert.strictEqual(common.picture[0].data.length, 175668, 'common.picture length');
+    assert.strictEqual(common.picture![0].format, 'image/jpeg', 'common.picture format');
+    assert.strictEqual(common.picture![0].data.length, 175668, 'common.picture length');
   }
 
-  function checkNative(vorbis) {
+  function checkNative(vorbis: mm.INativeTagDict) {
     // Compare expectedCommonTags with result.common
     assert.deepEqual(vorbis.TITLE, ['Brian Eno'], 'vorbis.TITLE');
     assert.deepEqual(vorbis.ARTIST, ['MGMT'], 'vorbis.ARTIST');
     assert.deepEqual(vorbis.DATE, ['2010'], 'vorbis.DATE');
     assert.deepEqual(vorbis.TRACKNUMBER, ['07'], 'vorbis.TRACKNUMBER');
     assert.deepEqual(vorbis.GENRE, ['Alt. Rock'], 'vorbis.GENRE');
     assert.deepEqual(vorbis.COMMENT, ['EAC-Secure Mode=should ignore equal sign'], 'vorbis.COMMENT');
-    const pic = vorbis.METADATA_BLOCK_PICTURE[0];
+    const pic = vorbis.METADATA_BLOCK_PICTURE[0] as IVorbisPicture;
 
     assert.strictEqual(pic.type, 'Cover (front)', 'raw METADATA_BLOCK_PICTUREtype');
     assert.strictEqual(pic.format, 'image/jpeg', 'raw METADATA_BLOCK_PICTURE format');
@@ -97,7 +98,7 @@ describe('Parse FLAC Vorbis comment', () => {
     Parsers.forEach(parser => {
       it(parser.description, async function(){
         const {format} = await parser.parse(() => this.skip(), filePath, 'audio/flac');
-        assert.approximately(496000, format.bitrate, 500);
+        assert.approximately(496000, format.bitrate!, 500);
       });
     });
 
@@ -195,8 +196,8 @@ describe('Parse FLAC Vorbis comment', () => {
     assert.isFalse(format.hasVideo, 'format.hasAudio');
 
     assert.isArray(common.lyrics, 'common.lyrics');
-    assert.strictEqual(common.lyrics.length, 1, 'common.lyrics.length');
-    const lrcLyrics = common.lyrics[0];
+    assert.strictEqual(common.lyrics!.length, 1, 'common.lyrics.length');
+    const lrcLyrics = common.lyrics![0];
     assert.strictEqual(lrcLyrics.contentType, LyricsContentType.lyrics, 'lrcLyrics.contentType');
     assert.strictEqual(lrcLyrics.timeStampFormat, TimestampFormat.milliseconds, 'lrcLyrics.timeStampFormat');
     assert.isArray(lrcLyrics.syncText, 'lrcLyrics.syncText');
@@ -227,7 +228,7 @@ describe('Parse FLAC Vorbis comment', () => {
     assert.isArray(common.lyrics, 'common.lyrics');
     assert.isNotEmpty(common.lyrics, 'common.lyrics');
 
-    const unsyncedLyrics = common.lyrics[0].text;
+    const unsyncedLyrics = common.lyrics![0].text;
     assert.strictEqual(
       unsyncedLyrics,
       "Run away, run away, run away\r\n" +

test/test-file-matroska.ts

@@ -35,7 +35,7 @@ describe('Matroska formats', () => {
       // format chunk information
       assert.strictEqual(format.container, 'EBML/matroska', 'format.container');
       assert.strictEqual(format.codec, 'ALAC', 'format.codec');
-      assert.approximately(format.duration, 196608 / 41000, 1 / 100000, 'format.duration');
+      assert.approximately(format.duration!, 196608 / 41000, 1 / 100000, 'format.duration');
       assert.strictEqual(format.sampleRate, 41000, 'format.sampleRate');
       assert.strictEqual(format.numberOfChannels, 2, 'format.numberOfChannels');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
@@ -51,7 +51,7 @@ describe('Matroska formats', () => {
       // format chunk information
       assert.strictEqual(format.container, 'EBML/matroska', 'format.container');
       assert.strictEqual(format.codec, 'AAC', 'format.codec');
-      assert.approximately(format.duration, 221184 / 44100, 1 / 100000, 'format.duration');
+      assert.approximately(format.duration!, 221184 / 44100, 1 / 100000, 'format.duration');
       assert.strictEqual(format.sampleRate, 44100, 'format.sampleRate');
       assert.strictEqual(format.numberOfChannels, 2, 'format.numberOfChannels');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
@@ -80,7 +80,7 @@ describe('Matroska formats', () => {
       // format chunk information
       assert.strictEqual(format.container, 'EBML/webm', 'format.container');
       assert.strictEqual(format.codec, 'VORBIS', 'format.codec');
-      assert.approximately(format.duration, 7.143, 1 / 100000, 'format.duration');
+      assert.approximately(format.duration!, 7.143, 1 / 100000, 'format.duration');
       assert.strictEqual(format.sampleRate, 44100, 'format.sampleRate');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
       assert.isTrue(format.hasVideo, 'format.hasVideo');
@@ -102,7 +102,7 @@ describe('Matroska formats', () => {
       // format chunk information
       assert.strictEqual(format.container, 'EBML/webm', 'format.container');
       assert.strictEqual(format.codec, 'OPUS', 'format.codec');
-      assert.approximately(format.duration, 5.006509896, 1 / 100000, 'format.duration');
+      assert.approximately(format.duration!, 5.006509896, 1 / 100000, 'format.duration');
       assert.strictEqual(format.sampleRate, 44100, 'format.sampleRate');
       assert.isTrue(format.hasAudio, 'format.hasAudio');
       assert.isFalse(format.hasVideo, 'format.hasVideo');
@@ -154,7 +154,7 @@ describe('Matroska formats', () => {
       assert.deepEqual(format.tagTypes, [ 'matroska' ], 'format.tagTypes');
 
       assert.deepEqual(format.codec, 'AAC', 'format.codec');
-      assert.approximately(format.duration, 3.417, 1 / 100000, 'format.duration');
+      assert.approximately(format.duration!, 3.417, 1 / 100000, 'format.duration');
       assert.strictEqual(format.sampleRate, 48000, 'format.sampleRate');
       assert.strictEqual(format.numberOfChannels, 2, 'format.numberOfChannels');