10324993640

Committed 09 Aug 2024 07:59PM UTC coverage: 97.079% (-0.1%) from 97.22%

Build # 10324993640

Build Type

Pull #2205

github

Committed by

Borewit

Commit Message

Enable TypeScript options `strict` & `verbatimModuleSyntax`

Pull Request Pull Request #2205: Enable TypeScript options `strict` & `verbatimModuleSyntax`

Run Details

1309 of 1480 branches covered (88.45%)

Branch coverage included in aggregate %.

219 of 225 new or added lines in 25 files covered. (97.33%)

6 existing lines in 3 files now uncovered.

11322 of 11531 relevant lines covered (98.19%)

16384.22 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.53

/lib/ParserFactory.ts

import { fileTypeFromBuffer } from 'file-type';
import ContentType from 'content-type';
import {parse as mimeTypeParse, type MediaType} from 'media-typer';
import initDebug from 'debug';

import { type INativeMetadataCollector, MetadataCollector } from './common/MetadataCollector.js';
import { AIFFParser } from './aiff/AiffParser.js';
import { APEv2Parser } from './apev2/APEv2Parser.js';
import { AsfParser } from './asf/AsfParser.js';
import { FlacParser } from './flac/FlacParser.js';
import { MP4Parser } from './mp4/MP4Parser.js';
import { MpegParser } from './mpeg/MpegParser.js';
import MusepackParser from './musepack/index.js';
import { OggParser } from './ogg/OggParser.js';
import { WaveParser } from './wav/WaveParser.js';
import { WavPackParser } from './wavpack/WavPackParser.js';
import { DsfParser } from './dsf/DsfParser.js';
import { DsdiffParser } from './dsdiff/DsdiffParser.js';
import { MatroskaParser } from './matroska/MatroskaParser.js';

import type { IOptions, IAudioMetadata, ParserType } from './type.js';
import type { ITokenizer } from 'strtok3';

const debug = initDebug('music-metadata:parser:factory');

export interface ITokenParser {

  /**
   * Initialize parser with output (metadata), input (tokenizer) & parsing options (options).
   * @param metadata - Output
   * @param tokenizer - Input
   * @param options - Parsing options
   */
  init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;

  /**
   * Parse audio track.
   * Called after init(...).
   * @returns Promise
   */
  parse(): Promise<void>;
}

interface IContentType extends MediaType {
  parameters: { [id: string]: string; };
}

export function parseHttpContentType(contentType: string): IContentType {
  const type = ContentType.parse(contentType);
  const mime = mimeTypeParse(type.type);
  return {
    type: mime.type,
    subtype: mime.subtype,
    suffix: mime.suffix,
    parameters: type.parameters
  } as IContentType;
}

/**
 * Parse metadata from tokenizer
 * @param tokenizer - Tokenizer
 * @param opts - Options
 * @returns Native metadata
 */
export async function parseOnContentType(tokenizer: ITokenizer, opts?: IOptions): Promise<IAudioMetadata> {

  const { mimeType, path, url } = tokenizer.fileInfo;

  // Resolve parser based on MIME-type or file extension
  const parserId = getParserIdForMimeType(mimeType) || getParserIdForExtension(path) || getParserIdForExtension(url);

  if (!parserId) {
    debug(`No parser found for MIME-type / extension: ${mimeType}`);
  }

  return parse(tokenizer, parserId, opts);
}

export async function parse(tokenizer: ITokenizer, parserId?: ParserType, opts?: IOptions): Promise<IAudioMetadata> {

  if (!parserId) {
    // Parser could not be determined on MIME-type or extension
    debug('Guess parser on content...');

    const buf = new Uint8Array(4100);
    await tokenizer.peekBuffer(buf, {mayBeLess: true});
    if (tokenizer.fileInfo.path) {
      parserId = getParserIdForExtension(tokenizer.fileInfo.path);
    }
    if (!parserId) {
      const guessedType = await fileTypeFromBuffer(buf);
      if (!guessedType) {
        throw new Error('Failed to determine audio format');
      }
      debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);
      parserId = getParserIdForMimeType(guessedType.mime);
      if (!parserId) {
        throw new Error(`Guessed MIME-type not supported: ${guessedType.mime}`);
      }
    }
  }
  // Parser found, execute parser
  const parser = await loadParser(parserId);
  const metadata = new MetadataCollector(opts);
  await parser.init(metadata, tokenizer, opts ?? {}).parse();
  return metadata.toCommonMetadata();
}

/**
 * @param filePath - Path, filename or extension to audio file
 * @return Parser submodule name
 */
export function getParserIdForExtension(filePath: string | undefined): ParserType | undefined {
  if (!filePath)
    return;

  const extension = getExtension(filePath).toLocaleLowerCase() || filePath;

  switch (extension) {

    case '.mp2':
    case '.mp3':
    case '.m2a':
    case '.aac': // Assume it is ADTS-container
      return 'mpeg';

    case '.ape':
      return 'apev2';

    case '.mp4':
    case '.m4a':
    case '.m4b':
    case '.m4pa':
    case '.m4v':
    case '.m4r':
    case '.3gp':
      return 'mp4';

    case '.wma':
    case '.wmv':
    case '.asf':
      return 'asf';

    case '.flac':
      return 'flac';

    case '.ogg':
    case '.ogv':
    case '.oga':
    case '.ogm':
    case '.ogx':
    case '.opus': // recommended filename extension for Ogg Opus
    case '.spx': // recommended filename extension for Ogg Speex
      return 'ogg';

    case '.aif':
    case '.aiff':
    case '.aifc':
      return 'aiff';

    case '.wav':
    case '.bwf': // Broadcast Wave Format
      return 'riff';

    case '.wv':
    case '.wvp':
      return 'wavpack';

    case '.mpc':
      return 'musepack';

    case '.dsf':
      return 'dsf';

    case '.dff':
      return 'dsdiff';

    case '.mka':
    case '.mkv':
    case '.mk3d':
    case '.mks':
    case '.webm':
      return 'matroska';
  }
}

export async function loadParser(moduleName: ParserType): Promise<ITokenParser> {
  switch (moduleName) {
    case 'aiff': return new AIFFParser();
    case 'adts':
    case 'mpeg':
      return new MpegParser();
    case 'apev2': return new APEv2Parser();
    case 'asf': return new AsfParser();
    case 'dsf': return new DsfParser();
    case 'dsdiff': return new DsdiffParser();
    case 'flac': return new FlacParser();
    case 'mp4': return new MP4Parser();
    case 'musepack': return new MusepackParser();
    case 'ogg': return new OggParser();
    case 'riff': return new WaveParser();
    case 'wavpack': return new WavPackParser();
    case 'matroska': return new MatroskaParser();
    default:
      throw new Error(`Unknown parser type: ${moduleName}`);
  }
}

function getExtension(fname: string): string {
  const i = fname.lastIndexOf('.');
  return i === -1 ? '' : fname.slice(i);
}

/**
 * @param httpContentType - HTTP Content-Type, extension, path or filename
 * @returns Parser submodule name
 */
function getParserIdForMimeType(httpContentType: string | undefined): ParserType | undefined{

  let mime: IContentType;
  if (!httpContentType) return;
  try {
    mime = parseHttpContentType(httpContentType);
  } catch (err) {
    debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);
    return;
  }

  const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;

  switch (mime.type) {

    case 'audio':
      switch (subType) {

        case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object
        case 'mpeg':
          return 'mpeg';

        case 'aac':
        case 'aacp':
          return 'adts';

        case 'flac':
          return 'flac';

        case 'ape':
        case 'monkeys-audio':
          return 'apev2';

        case 'mp4':
        case 'm4a':
          return 'mp4';

        case 'ogg': // RFC 7845
        case 'opus': // RFC 6716
        case 'speex': // RFC 5574
          return 'ogg';

        case 'ms-wma':
        case 'ms-wmv':
        case 'ms-asf':
          return 'asf';

        case 'aiff':
        case 'aif':
        case 'aifc':
          return 'aiff';

        case 'vnd.wave':
        case 'wav':
        case 'wave':
          return 'riff';

        case 'wavpack':
          return 'wavpack';

        case 'musepack':
          return 'musepack';

        case 'matroska':
        case 'webm':
          return 'matroska';

        case 'dsf':
          return 'dsf';
      }
      break;

    case 'video':
      switch (subType) {

        case 'ms-asf':
        case 'ms-wmv':
          return 'asf';

        case 'm4v':
        case 'mp4':
          return 'mp4';

        case 'ogg':
          return 'ogg';

        case 'matroska':
        case 'webm':
          return 'matroska';
      }
      break;

    case 'application':
      switch (subType) {

        case 'vnd.ms-asf':
          return 'asf';

        case 'ogg':
          return 'ogg';
      }
      break;
  }
}

1	import { fileTypeFromBuffer } from 'file-type';	4✔
2	import ContentType from 'content-type';	4✔
3	import {parse as mimeTypeParse, type MediaType} from 'media-typer';	4✔
4	import initDebug from 'debug';	4✔
5		4✔
6	import { type INativeMetadataCollector, MetadataCollector } from './common/MetadataCollector.js';	4✔
7	import { AIFFParser } from './aiff/AiffParser.js';	4✔
8	import { APEv2Parser } from './apev2/APEv2Parser.js';	4✔
9	import { AsfParser } from './asf/AsfParser.js';	4✔
10	import { FlacParser } from './flac/FlacParser.js';	4✔
11	import { MP4Parser } from './mp4/MP4Parser.js';	4✔
12	import { MpegParser } from './mpeg/MpegParser.js';	4✔
13	import MusepackParser from './musepack/index.js';	4✔
14	import { OggParser } from './ogg/OggParser.js';	4✔
15	import { WaveParser } from './wav/WaveParser.js';	4✔
16	import { WavPackParser } from './wavpack/WavPackParser.js';	4✔
17	import { DsfParser } from './dsf/DsfParser.js';	4✔
18	import { DsdiffParser } from './dsdiff/DsdiffParser.js';	4✔
19	import { MatroskaParser } from './matroska/MatroskaParser.js';	4✔
20		4✔
21	import type { IOptions, IAudioMetadata, ParserType } from './type.js';	4✔
22	import type { ITokenizer } from 'strtok3';	4✔
23		4✔
24	const debug = initDebug('music-metadata:parser:factory');	4✔
25		4✔
26	export interface ITokenParser {	4✔
27		4✔
28	/**	4✔
29	* Initialize parser with output (metadata), input (tokenizer) & parsing options (options).	4✔
30	* @param metadata - Output	4✔
31	* @param tokenizer - Input	4✔
32	* @param options - Parsing options	4✔
33	*/	4✔
34	init(metadata: INativeMetadataCollector, tokenizer: ITokenizer, options: IOptions): ITokenParser;	4✔
35		4✔
36	/**	4✔
37	* Parse audio track.	4✔
38	* Called after init(...).	4✔
39	* @returns Promise	4✔
40	*/	4✔
41	parse(): Promise<void>;	4✔
42	}	4✔
43		4✔
44	interface IContentType extends MediaType {	4✔
45	parameters: { [id: string]: string; };	4✔
46	}	4✔
47		4✔
48	export function parseHttpContentType(contentType: string): IContentType {	4✔
49	const type = ContentType.parse(contentType);	498✔
50	const mime = mimeTypeParse(type.type);	498✔
51	return {	498✔
52	type: mime.type,	498✔
53	subtype: mime.subtype,	498✔
54	suffix: mime.suffix,	498✔
55	parameters: type.parameters	498✔
56	} as IContentType;	498✔
57	}	498✔
58		4✔
59	/**	4✔
60	* Parse metadata from tokenizer	4✔
61	* @param tokenizer - Tokenizer	4✔
62	* @param opts - Options	4✔
63	* @returns Native metadata	4✔
64	*/	4✔
65	export async function parseOnContentType(tokenizer: ITokenizer, opts?: IOptions): Promise<IAudioMetadata> {	4✔
66		536✔
67	const { mimeType, path, url } = tokenizer.fileInfo;	536✔
68		536✔
69	// Resolve parser based on MIME-type or file extension	536✔
70	const parserId = getParserIdForMimeType(mimeType) \|\| getParserIdForExtension(path) \|\| getParserIdForExtension(url);	536✔
71		536✔
72	if (!parserId) {	536✔
73	debug(`No parser found for MIME-type / extension: ${mimeType}`);	34✔
74	}	34✔
75		536✔
76	return parse(tokenizer, parserId, opts);	536✔
77	}	536✔
78		4✔
79	export async function parse(tokenizer: ITokenizer, parserId?: ParserType, opts?: IOptions): Promise<IAudioMetadata> {	4✔
80		1,684✔
81	if (!parserId) {	1,684✔
82	// Parser could not be determined on MIME-type or extension	50✔
83	debug('Guess parser on content...');	50✔
84		50✔
85	const buf = new Uint8Array(4100);	50✔
86	await tokenizer.peekBuffer(buf, {mayBeLess: true});	50✔
87	if (tokenizer.fileInfo.path) {	50✔
88	parserId = getParserIdForExtension(tokenizer.fileInfo.path);	16✔
89	}	16✔
90	if (!parserId) {	50✔
91	const guessedType = await fileTypeFromBuffer(buf);	50✔
92	if (!guessedType) {	50✔
93	throw new Error('Failed to determine audio format');	4✔
94	}	4✔
95	debug(`Guessed file type is mime=${guessedType.mime}, extension=${guessedType.ext}`);	46✔
96	parserId = getParserIdForMimeType(guessedType.mime);	46✔
97	if (!parserId) {	50✔
98	throw new Error(`Guessed MIME-type not supported: ${guessedType.mime}`);	12✔
99	}	12✔
100	}	50✔
101	}	50✔
102	// Parser found, execute parser	1,668✔
103	const parser = await loadParser(parserId);	1,668✔
104	const metadata = new MetadataCollector(opts);	1,668✔
105	await parser.init(metadata, tokenizer, opts ?? {}).parse();	1,684!
106	return metadata.toCommonMetadata();	1,656✔
107	}	1,656✔
108		4✔
109	/**	4✔
110	* @param filePath - Path, filename or extension to audio file	4✔
111	* @return Parser submodule name	4✔
112	*/	4✔
113	export function getParserIdForExtension(filePath: string \| undefined): ParserType \| undefined {	4✔
114	if (!filePath)	1,336✔
115	return;	1,336✔
116		1,268✔
117	const extension = getExtension(filePath).toLocaleLowerCase() \|\| filePath;	1,336✔
118		1,336✔
119	switch (extension) {	1,336✔
120		1,336✔
121	case '.mp2':	1,336✔
122	case '.mp3':	1,336✔
123	case '.m2a':	1,336✔
124	case '.aac': // Assume it is ADTS-container	1,336✔
125	return 'mpeg';	584✔
126		1,336✔
127	case '.ape':	1,336✔
128	return 'apev2';	36✔
129		1,336✔
130	case '.mp4':	1,336✔
131	case '.m4a':	1,336✔
132	case '.m4b':	1,336✔
133	case '.m4pa':	1,336✔
134	case '.m4v':	1,336✔
135	case '.m4r':	1,336✔
136	case '.3gp':	1,336✔
137	return 'mp4';	188✔
138		1,336✔
139	case '.wma':	1,336✔
140	case '.wmv':	1,336✔
141	case '.asf':	1,336✔
142	return 'asf';	36✔
143		1,336✔
144	case '.flac':	1,336✔
145	return 'flac';	88✔
146		1,336✔
147	case '.ogg':	1,336✔
148	case '.ogv':	1,336✔
149	case '.oga':	1,336✔
150	case '.ogm':	1,336✔
151	case '.ogx':	1,336✔
152	case '.opus': // recommended filename extension for Ogg Opus	1,336✔
153	case '.spx': // recommended filename extension for Ogg Speex	1,336✔
154	return 'ogg';	68✔
155		1,336✔
156	case '.aif':	1,336✔
157	case '.aiff':	1,336✔
158	case '.aifc':	1,336✔
159	return 'aiff';	60✔
160		1,336✔
161	case '.wav':	1,336✔
162	case '.bwf': // Broadcast Wave Format	1,336✔
163	return 'riff';	60✔
164		1,336✔
165	case '.wv':	1,336✔
166	case '.wvp':	1,336✔
167	return 'wavpack';	24✔
168		1,336✔
169	case '.mpc':	1,336✔
170	return 'musepack';	32✔
171		1,336✔
172	case '.dsf':	1,336✔
173	return 'dsf';	8✔
174		1,336✔
175	case '.dff':	1,336✔
176	return 'dsdiff';	4✔
177		1,336✔
178	case '.mka':	1,336✔
179	case '.mkv':	1,336✔
180	case '.mk3d':	1,336✔
181	case '.mks':	1,336✔
182	case '.webm':	1,336✔
183	return 'matroska';	48✔
184	}	1,336✔
185	}	1,336✔
186		4✔
187	export async function loadParser(moduleName: ParserType): Promise<ITokenParser> {	4✔
188	switch (moduleName) {	1,668✔
189	case 'aiff': return new AIFFParser();	1,668✔
190	case 'adts':	1,668✔
191	case 'mpeg':	1,668✔
192	return new MpegParser();	702✔
193	case 'apev2': return new APEv2Parser();	1,668✔
194	case 'asf': return new AsfParser();	1,668✔
195	case 'dsf': return new DsfParser();	1,668✔
196	case 'dsdiff': return new DsdiffParser();	1,668✔
197	case 'flac': return new FlacParser();	1,668✔
198	case 'mp4': return new MP4Parser();	1,668✔
199	case 'musepack': return new MusepackParser();	1,668✔
200	case 'ogg': return new OggParser();	1,668✔
201	case 'riff': return new WaveParser();	1,668✔
202	case 'wavpack': return new WavPackParser();	1,668✔
203	case 'matroska': return new MatroskaParser();	1,668✔
204	default:	1,668!
205	throw new Error(`Unknown parser type: ${moduleName}`);	×
206	}	1,668✔
207	}	1,668✔
208		4✔
209	function getExtension(fname: string): string {	1,268✔
210	const i = fname.lastIndexOf('.');	1,268✔
211	return i === -1 ? '' : fname.slice(i);	1,268✔
212	}	1,268✔
213		4✔
214	/**	4✔
215	* @param httpContentType - HTTP Content-Type, extension, path or filename	4✔
216	* @returns Parser submodule name	4✔
217	*/	4✔
218	function getParserIdForMimeType(httpContentType: string \| undefined): ParserType \| undefined{	582✔
219		582✔
220	let mime: IContentType;	582✔
221	if (!httpContentType) return;	582✔
222	try {	482✔
223	mime = parseHttpContentType(httpContentType);	482✔
224	} catch (err) {	582!
UNCOV 225	debug(`Invalid HTTP Content-Type header value: ${httpContentType}`);	×
UNCOV 226	return;	×
UNCOV 227	}	×
228		482✔
229	const subType = mime.subtype.indexOf('x-') === 0 ? mime.subtype.substring(2) : mime.subtype;	582✔
230		582✔
231	switch (mime.type) {	582✔
232		582✔
233	case 'audio':	582✔
234	switch (subType) {	436✔
235		436✔
236	case 'mp3': // Incorrect MIME-type, Chrome, in Web API File object	436!
237	case 'mpeg':	436✔
238	return 'mpeg';	96✔
239		436✔
240	case 'aac':	436✔
241	case 'aacp':	436✔
242	return 'adts';	22✔
243		436✔
244	case 'flac':	436✔
245	return 'flac';	14✔
246		436✔
247	case 'ape':	436✔
248	case 'monkeys-audio':	436✔
249	return 'apev2';	10✔
250		436✔
251	case 'mp4':	436✔
252	case 'm4a':	436✔
253	return 'mp4';	66✔
254		436✔
255	case 'ogg': // RFC 7845	436✔
256	case 'opus': // RFC 6716	436✔
257	case 'speex': // RFC 5574	436✔
258	return 'ogg';	34✔
259		436✔
260	case 'ms-wma':	436✔
261	case 'ms-wmv':	436✔
262	case 'ms-asf':	436✔
263	return 'asf';	20✔
264		436✔
265	case 'aiff':	436✔
266	case 'aif':	436✔
267	case 'aifc':	436✔
268	return 'aiff';	80✔
269		436✔
270	case 'vnd.wave':	436!
271	case 'wav':	436✔
272	case 'wave':	436✔
273	return 'riff';	8✔
274		436✔
275	case 'wavpack':	436✔
276	return 'wavpack';	30✔
277		436✔
278	case 'musepack':	436✔
279	return 'musepack';	18✔
280		436✔
281	case 'matroska':	436!
282	case 'webm':	436!
283	return 'matroska';	×
284		436✔
285	case 'dsf':	436!
286	return 'dsf';	×
287	}	436✔
288	break;	38✔
289		582✔
290	case 'video':	582✔
291	switch (subType) {	34✔
292		34✔
293	case 'ms-asf':	34!
294	case 'ms-wmv':	34!
295	return 'asf';	×
296		34✔
297	case 'm4v':	34!
298	case 'mp4':	34✔
299	return 'mp4';	30✔
300		34✔
301	case 'ogg':	34!
302	return 'ogg';	×
303		34✔
304	case 'matroska':	34!
305	case 'webm':	34✔
306	return 'matroska';	4✔
307	}	34✔
308	break;	×
309		582✔
310	case 'application':	582!
311	switch (subType) {	×
312		×
313	case 'vnd.ms-asf':	×
314	return 'asf';	×
315		×
316	case 'ogg':	×
317	return 'ogg';	×
318	}	×
319	break;	×
320	}	582✔
321	}	582✔

Borewit / music-metadata / 10324993640

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous