music-metadata 7.11.7 → 7.12.0

package/lib/common/MetadataCollector.js

@@ -1,276 +1,276 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.joinArtists = exports.MetadataCollector = void 0;
-const type_1 = require("../type");
-const _debug = require("debug");
-const GenericTagTypes_1 = require("./GenericTagTypes");
-const CombinedTagMapper_1 = require("./CombinedTagMapper");
-const GenericTagMapper_1 = require("./GenericTagMapper");
-const Util_1 = require("./Util");
-const FileType = require("file-type/core");
-const debug = _debug('music-metadata:collector');
-const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'ID3v1'];
-/**
- * Provided to the parser to uodate the metadata result.
- * Responsible for triggering async updates
- */
-class MetadataCollector {
-    constructor(opts) {
-        this.opts = opts;
-        this.format = {
-            tagTypes: [],
-            trackInfo: []
-        };
-        this.native = {};
-        this.common = {
-            track: { no: null, of: null },
-            disk: { no: null, of: null },
-            movementIndex: {}
-        };
-        this.quality = {
-            warnings: []
-        };
-        /**
-         * Keeps track of origin priority for each mapped id
-         */
-        this.commonOrigin = {};
-        /**
-         * Maps a tag type to a priority
-         */
-        this.originPriority = {};
-        this.tagMapper = new CombinedTagMapper_1.CombinedTagMapper();
-        let priority = 1;
-        for (const tagType of TagPriority) {
-            this.originPriority[tagType] = priority++;
-        }
-        this.originPriority.artificial = 500; // Filled using alternative tags
-        this.originPriority.id3v1 = 600; // Consider worst due to field length limit
-    }
-    /**
-     * @returns {boolean} true if one or more tags have been found
-     */
-    hasAny() {
-        return Object.keys(this.native).length > 0;
-    }
-    addStreamInfo(streamInfo) {
-        debug(`streamInfo: type=${type_1.TrackType[streamInfo.type]}, codec=${streamInfo.codecName}`);
-        this.format.trackInfo.push(streamInfo);
-    }
-    setFormat(key, value) {
-        debug(`format: ${key} = ${value}`);
-        this.format[key] = value; // as any to override readonly
-        if (this.opts.observer) {
-            this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
-        }
-    }
-    addTag(tagType, tagId, value) {
-        debug(`tag ${tagType}.${tagId} = ${value}`);
-        if (!this.native[tagType]) {
-            this.format.tagTypes.push(tagType);
-            this.native[tagType] = [];
-        }
-        this.native[tagType].push({ id: tagId, value });
-        this.toCommon(tagType, tagId, value);
-    }
-    addWarning(warning) {
-        this.quality.warnings.push({ message: warning });
-    }
-    postMap(tagType, tag) {
-        // Common tag (alias) found
-        // check if we need to do something special with common tag
-        // if the event has been aliased then we need to clean it before
-        // it is emitted to the user. e.g. genre (20) -> Electronic
-        switch (tag.id) {
-            case 'artist':
-                if (this.commonOrigin.artist === this.originPriority[tagType]) {
-                    // Assume the artist field is used as artists
-                    return this.postMap('artificial', { id: 'artists', value: tag.value });
-                }
-                if (!this.common.artists) {
-                    // Fill artists using artist source
-                    this.setGenericTag('artificial', { id: 'artists', value: tag.value });
-                }
-                break;
-            case 'artists':
-                if (!this.common.artist || this.commonOrigin.artist === this.originPriority.artificial) {
-                    if (!this.common.artists || this.common.artists.indexOf(tag.value) === -1) {
-                        // Fill artist using artists source
-                        const artists = (this.common.artists || []).concat([tag.value]);
-                        const value = joinArtists(artists);
-                        const artistTag = { id: 'artist', value };
-                        this.setGenericTag('artificial', artistTag);
-                    }
-                }
-                break;
-            case 'picture':
-                this.postFixPicture(tag.value).then(picture => {
-                    if (picture !== null) {
-                        tag.value = picture;
-                        this.setGenericTag(tagType, tag);
-                    }
-                });
-                return;
-            case 'totaltracks':
-                this.common.track.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
-                return;
-            case 'totaldiscs':
-                this.common.disk.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
-                return;
-            case 'movementTotal':
-                this.common.movementIndex.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
-                return;
-            case 'track':
-            case 'disk':
-            case 'movementIndex':
-                const of = this.common[tag.id].of; // store of value, maybe maybe overwritten
-                this.common[tag.id] = GenericTagMapper_1.CommonTagMapper.normalizeTrack(tag.value);
-                this.common[tag.id].of = of != null ? of : this.common[tag.id].of;
-                return;
-            case 'bpm':
-            case 'year':
-            case 'originalyear':
-                tag.value = parseInt(tag.value, 10);
-                break;
-            case 'date':
-                // ToDo: be more strict on 'YYYY...'
-                const year = parseInt(tag.value.substr(0, 4), 10);
-                if (!isNaN(year)) {
-                    this.common.year = year;
-                }
-                break;
-            case 'discogs_label_id':
-            case 'discogs_release_id':
-            case 'discogs_master_release_id':
-            case 'discogs_artist_id':
-            case 'discogs_votes':
-                tag.value = typeof tag.value === 'string' ? parseInt(tag.value, 10) : tag.value;
-                break;
-            case 'replaygain_track_gain':
-            case 'replaygain_track_peak':
-            case 'replaygain_album_gain':
-            case 'replaygain_album_peak':
-                tag.value = (0, Util_1.toRatio)(tag.value);
-                break;
-            case 'replaygain_track_minmax':
-                tag.value = tag.value.split(',').map(v => parseInt(v, 10));
-                break;
-            case 'replaygain_undo':
-                const minMix = tag.value.split(',').map(v => parseInt(v, 10));
-                tag.value = {
-                    leftChannel: minMix[0],
-                    rightChannel: minMix[1]
-                };
-                break;
-            case 'gapless': // iTunes gap-less flag
-            case 'compilation':
-            case 'podcast':
-            case 'showMovement':
-                tag.value = tag.value === '1' || tag.value === 1; // boolean
-                break;
-            case 'isrc': // Only keep unique values
-                if (this.common[tag.id] && this.common[tag.id].indexOf(tag.value) !== -1)
-                    return;
-                break;
-            default:
-            // nothing to do
-        }
-        if (tag.value !== null) {
-            this.setGenericTag(tagType, tag);
-        }
-    }
-    /**
-     * Convert native tags to common tags
-     * @returns {IAudioMetadata} Native + common tags
-     */
-    toCommonMetadata() {
-        return {
-            format: this.format,
-            native: this.native,
-            quality: this.quality,
-            common: this.common
-        };
-    }
-    /**
-     * Fix some common issues with picture object
-     * @param picture Picture
-     */
-    async postFixPicture(picture) {
-        if (picture.data && picture.data.length > 0) {
-            if (!picture.format) {
-                const fileType = await FileType.fromBuffer(picture.data);
-                if (fileType) {
-                    picture.format = fileType.mime;
-                }
-                else {
-                    return null;
-                }
-            }
-            picture.format = picture.format.toLocaleLowerCase();
-            switch (picture.format) {
-                case 'image/jpg':
-                    picture.format = 'image/jpeg'; // ToDo: register warning
-            }
-            return picture;
-        }
-        this.addWarning(`Empty picture tag found`);
-        return null;
-    }
-    /**
-     * Convert native tag to common tags
-     */
-    toCommon(tagType, tagId, value) {
-        const tag = { id: tagId, value };
-        const genericTag = this.tagMapper.mapTag(tagType, tag, this);
-        if (genericTag) {
-            this.postMap(tagType, genericTag);
-        }
-    }
-    /**
-     * Set generic tag
-     */
-    setGenericTag(tagType, tag) {
-        debug(`common.${tag.id} = ${tag.value}`);
-        const prio0 = this.commonOrigin[tag.id] || 1000;
-        const prio1 = this.originPriority[tagType];
-        if ((0, GenericTagTypes_1.isSingleton)(tag.id)) {
-            if (prio1 <= prio0) {
-                this.common[tag.id] = tag.value;
-                this.commonOrigin[tag.id] = prio1;
-            }
-            else {
-                return debug(`Ignore native tag (singleton): ${tagType}.${tag.id} = ${tag.value}`);
-            }
-        }
-        else {
-            if (prio1 === prio0) {
-                if (!(0, GenericTagTypes_1.isUnique)(tag.id) || this.common[tag.id].indexOf(tag.value) === -1) {
-                    this.common[tag.id].push(tag.value);
-                }
-                else {
-                    debug(`Ignore duplicate value: ${tagType}.${tag.id} = ${tag.value}`);
-                }
-                // no effect? this.commonOrigin[tag.id] = prio1;
-            }
-            else if (prio1 < prio0) {
-                this.common[tag.id] = [tag.value];
-                this.commonOrigin[tag.id] = prio1;
-            }
-            else {
-                return debug(`Ignore native tag (list): ${tagType}.${tag.id} = ${tag.value}`);
-            }
-        }
-        if (this.opts.observer) {
-            this.opts.observer({ metadata: this, tag: { type: 'common', id: tag.id, value: tag.value } });
-        }
-        // ToDo: trigger metadata event
-    }
-}
-exports.MetadataCollector = MetadataCollector;
-function joinArtists(artists) {
-    if (artists.length > 2) {
-        return artists.slice(0, artists.length - 1).join(', ') + ' & ' + artists[artists.length - 1];
-    }
-    return artists.join(' & ');
-}
-exports.joinArtists = joinArtists;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinArtists = exports.MetadataCollector = void 0;
+const type_1 = require("../type");
+const initDebug = require("debug");
+const GenericTagTypes_1 = require("./GenericTagTypes");
+const CombinedTagMapper_1 = require("./CombinedTagMapper");
+const GenericTagMapper_1 = require("./GenericTagMapper");
+const Util_1 = require("./Util");
+const FileType = require("file-type/core");
+const debug = initDebug('music-metadata:collector');
+const TagPriority = ['matroska', 'APEv2', 'vorbis', 'ID3v2.4', 'ID3v2.3', 'ID3v2.2', 'exif', 'asf', 'iTunes', 'ID3v1'];
+/**
+ * Provided to the parser to uodate the metadata result.
+ * Responsible for triggering async updates
+ */
+class MetadataCollector {
+    constructor(opts) {
+        this.opts = opts;
+        this.format = {
+            tagTypes: [],
+            trackInfo: []
+        };
+        this.native = {};
+        this.common = {
+            track: { no: null, of: null },
+            disk: { no: null, of: null },
+            movementIndex: {}
+        };
+        this.quality = {
+            warnings: []
+        };
+        /**
+         * Keeps track of origin priority for each mapped id
+         */
+        this.commonOrigin = {};
+        /**
+         * Maps a tag type to a priority
+         */
+        this.originPriority = {};
+        this.tagMapper = new CombinedTagMapper_1.CombinedTagMapper();
+        let priority = 1;
+        for (const tagType of TagPriority) {
+            this.originPriority[tagType] = priority++;
+        }
+        this.originPriority.artificial = 500; // Filled using alternative tags
+        this.originPriority.id3v1 = 600; // Consider worst due to field length limit
+    }
+    /**
+     * @returns {boolean} true if one or more tags have been found
+     */
+    hasAny() {
+        return Object.keys(this.native).length > 0;
+    }
+    addStreamInfo(streamInfo) {
+        debug(`streamInfo: type=${type_1.TrackType[streamInfo.type]}, codec=${streamInfo.codecName}`);
+        this.format.trackInfo.push(streamInfo);
+    }
+    setFormat(key, value) {
+        debug(`format: ${key} = ${value}`);
+        this.format[key] = value; // as any to override readonly
+        if (this.opts.observer) {
+            this.opts.observer({ metadata: this, tag: { type: 'format', id: key, value } });
+        }
+    }
+    addTag(tagType, tagId, value) {
+        debug(`tag ${tagType}.${tagId} = ${value}`);
+        if (!this.native[tagType]) {
+            this.format.tagTypes.push(tagType);
+            this.native[tagType] = [];
+        }
+        this.native[tagType].push({ id: tagId, value });
+        this.toCommon(tagType, tagId, value);
+    }
+    addWarning(warning) {
+        this.quality.warnings.push({ message: warning });
+    }
+    postMap(tagType, tag) {
+        // Common tag (alias) found
+        // check if we need to do something special with common tag
+        // if the event has been aliased then we need to clean it before
+        // it is emitted to the user. e.g. genre (20) -> Electronic
+        switch (tag.id) {
+            case 'artist':
+                if (this.commonOrigin.artist === this.originPriority[tagType]) {
+                    // Assume the artist field is used as artists
+                    return this.postMap('artificial', { id: 'artists', value: tag.value });
+                }
+                if (!this.common.artists) {
+                    // Fill artists using artist source
+                    this.setGenericTag('artificial', { id: 'artists', value: tag.value });
+                }
+                break;
+            case 'artists':
+                if (!this.common.artist || this.commonOrigin.artist === this.originPriority.artificial) {
+                    if (!this.common.artists || this.common.artists.indexOf(tag.value) === -1) {
+                        // Fill artist using artists source
+                        const artists = (this.common.artists || []).concat([tag.value]);
+                        const value = joinArtists(artists);
+                        const artistTag = { id: 'artist', value };
+                        this.setGenericTag('artificial', artistTag);
+                    }
+                }
+                break;
+            case 'picture':
+                this.postFixPicture(tag.value).then(picture => {
+                    if (picture !== null) {
+                        tag.value = picture;
+                        this.setGenericTag(tagType, tag);
+                    }
+                });
+                return;
+            case 'totaltracks':
+                this.common.track.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'totaldiscs':
+                this.common.disk.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'movementTotal':
+                this.common.movementIndex.of = GenericTagMapper_1.CommonTagMapper.toIntOrNull(tag.value);
+                return;
+            case 'track':
+            case 'disk':
+            case 'movementIndex':
+                const of = this.common[tag.id].of; // store of value, maybe maybe overwritten
+                this.common[tag.id] = GenericTagMapper_1.CommonTagMapper.normalizeTrack(tag.value);
+                this.common[tag.id].of = of != null ? of : this.common[tag.id].of;
+                return;
+            case 'bpm':
+            case 'year':
+            case 'originalyear':
+                tag.value = parseInt(tag.value, 10);
+                break;
+            case 'date':
+                // ToDo: be more strict on 'YYYY...'
+                const year = parseInt(tag.value.substr(0, 4), 10);
+                if (!isNaN(year)) {
+                    this.common.year = year;
+                }
+                break;
+            case 'discogs_label_id':
+            case 'discogs_release_id':
+            case 'discogs_master_release_id':
+            case 'discogs_artist_id':
+            case 'discogs_votes':
+                tag.value = typeof tag.value === 'string' ? parseInt(tag.value, 10) : tag.value;
+                break;
+            case 'replaygain_track_gain':
+            case 'replaygain_track_peak':
+            case 'replaygain_album_gain':
+            case 'replaygain_album_peak':
+                tag.value = (0, Util_1.toRatio)(tag.value);
+                break;
+            case 'replaygain_track_minmax':
+                tag.value = tag.value.split(',').map(v => parseInt(v, 10));
+                break;
+            case 'replaygain_undo':
+                const minMix = tag.value.split(',').map(v => parseInt(v, 10));
+                tag.value = {
+                    leftChannel: minMix[0],
+                    rightChannel: minMix[1]
+                };
+                break;
+            case 'gapless': // iTunes gap-less flag
+            case 'compilation':
+            case 'podcast':
+            case 'showMovement':
+                tag.value = tag.value === '1' || tag.value === 1; // boolean
+                break;
+            case 'isrc': // Only keep unique values
+                if (this.common[tag.id] && this.common[tag.id].indexOf(tag.value) !== -1)
+                    return;
+                break;
+            default:
+            // nothing to do
+        }
+        if (tag.value !== null) {
+            this.setGenericTag(tagType, tag);
+        }
+    }
+    /**
+     * Convert native tags to common tags
+     * @returns {IAudioMetadata} Native + common tags
+     */
+    toCommonMetadata() {
+        return {
+            format: this.format,
+            native: this.native,
+            quality: this.quality,
+            common: this.common
+        };
+    }
+    /**
+     * Fix some common issues with picture object
+     * @param picture Picture
+     */
+    async postFixPicture(picture) {
+        if (picture.data && picture.data.length > 0) {
+            if (!picture.format) {
+                const fileType = await FileType.fromBuffer(picture.data);
+                if (fileType) {
+                    picture.format = fileType.mime;
+                }
+                else {
+                    return null;
+                }
+            }
+            picture.format = picture.format.toLocaleLowerCase();
+            switch (picture.format) {
+                case 'image/jpg':
+                    picture.format = 'image/jpeg'; // ToDo: register warning
+            }
+            return picture;
+        }
+        this.addWarning(`Empty picture tag found`);
+        return null;
+    }
+    /**
+     * Convert native tag to common tags
+     */
+    toCommon(tagType, tagId, value) {
+        const tag = { id: tagId, value };
+        const genericTag = this.tagMapper.mapTag(tagType, tag, this);
+        if (genericTag) {
+            this.postMap(tagType, genericTag);
+        }
+    }
+    /**
+     * Set generic tag
+     */
+    setGenericTag(tagType, tag) {
+        debug(`common.${tag.id} = ${tag.value}`);
+        const prio0 = this.commonOrigin[tag.id] || 1000;
+        const prio1 = this.originPriority[tagType];
+        if ((0, GenericTagTypes_1.isSingleton)(tag.id)) {
+            if (prio1 <= prio0) {
+                this.common[tag.id] = tag.value;
+                this.commonOrigin[tag.id] = prio1;
+            }
+            else {
+                return debug(`Ignore native tag (singleton): ${tagType}.${tag.id} = ${tag.value}`);
+            }
+        }
+        else {
+            if (prio1 === prio0) {
+                if (!(0, GenericTagTypes_1.isUnique)(tag.id) || this.common[tag.id].indexOf(tag.value) === -1) {
+                    this.common[tag.id].push(tag.value);
+                }
+                else {
+                    debug(`Ignore duplicate value: ${tagType}.${tag.id} = ${tag.value}`);
+                }
+                // no effect? this.commonOrigin[tag.id] = prio1;
+            }
+            else if (prio1 < prio0) {
+                this.common[tag.id] = [tag.value];
+                this.commonOrigin[tag.id] = prio1;
+            }
+            else {
+                return debug(`Ignore native tag (list): ${tagType}.${tag.id} = ${tag.value}`);
+            }
+        }
+        if (this.opts.observer) {
+            this.opts.observer({ metadata: this, tag: { type: 'common', id: tag.id, value: tag.value } });
+        }
+        // ToDo: trigger metadata event
+    }
+}
+exports.MetadataCollector = MetadataCollector;
+function joinArtists(artists) {
+    if (artists.length > 2) {
+        return artists.slice(0, artists.length - 1).join(', ') + ' & ' + artists[artists.length - 1];
+    }
+    return artists.join(' & ');
+}
+exports.joinArtists = joinArtists;
 //# sourceMappingURL=MetadataCollector.js.map

package/lib/common/RandomFileReader.d.ts

@@ -1,20 +1,22 @@
-/// <reference types="node" />
-import { IRandomReader } from '../type';
-/**
- * Provides abstract file access via the IRandomRead interface
- */
-export declare class RandomFileReader implements IRandomReader {
-    fileSize: number;
-    private readonly fd;
-    constructor(filePath: string, fileSize: number);
-    /**
-     * Read from a given position of an abstracted file or buffer.
-     * @param buffer {Buffer} is the buffer that the data will be written to.
-     * @param offset {number} is the offset in the buffer to start writing at.
-     * @param length {number}is an integer specifying the number of bytes to read.
-     * @param position {number} is an argument specifying where to begin reading from in the file.
-     * @return {Promise<number>} bytes read
-     */
-    randomRead(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
-    close(): void;
-}
+/// <reference types="node" />
+import { IRandomReader } from '../type';
+/**
+ * Provides abstract file access via the IRandomRead interface
+ */
+export declare class RandomFileReader implements IRandomReader {
+    private readonly fileHandle;
+    filePath: string;
+    fileSize: number;
+    private constructor();
+    /**
+     * Read from a given position of an abstracted file or buffer.
+     * @param buffer {Buffer} is the buffer that the data will be written to.
+     * @param offset {number} is the offset in the buffer to start writing at.
+     * @param length {number}is an integer specifying the number of bytes to read.
+     * @param position {number} is an argument specifying where to begin reading from in the file.
+     * @return {Promise<number>} bytes read
+     */
+    randomRead(buffer: Buffer, offset: number, length: number, position: number): Promise<number>;
+    close(): Promise<void>;
+    static init(filePath: string, fileSize: number): Promise<RandomFileReader>;
+}