@iebh/reflib 2.5.6 → 2.5.8

package/lib/formats.js

@@ -1,77 +1,77 @@
-/**
-* Lookup table of various citation file formats
-* @type {array<Object>} A collection of Reflib supported file formats
-* @property {string} title The long form title of the format
-* @property {string} titleShort Shorter title of the format
-* @property {string} input Input format required by parser
-* @property {string} output Output format required by formatter
-* @property {Array<String>} ext File extensions of this format, the first entry is generally used as the output default
-* @property {boolean} canRead Whether the format is supported when reading a citation library
-* @property {boolean} canWrite Whether the format is supported when writing a citation library
-*/
-export let formats = {
-	csv: {
-		id: 'csv',
-		title: 'Comma Seperated Values',
-		titleShort: 'CSV',
-		ext: ['.csv'],
-		canRead: false,
-		canWrite: false,
-	},
-	endnoteEnl: {
-		id: 'endnoteEnl',
-		title: 'EndNote ENL',
-		titleShort: 'EndNote',
-		ext: ['.enl'],
-		canRead: true,
-		canWrite: true,
-	},
-	endnoteEnlX: {
-		id: 'endnoteEnlX',
-		title: 'EndNote ENLX',
-		titleShort: 'EndNote ENLX',
-		ext: ['.enlx'],
-		canRead: true,
-		canWrite: false,
-	},
-	endnoteXml: {
-		id: 'endnoteXml',
-		title: 'EndNoteXML',
-		titleShort: 'EndNoteXML',
-		ext: ['.xml'],
-		canRead: true,
-		canWrite: true,
-	},
-	json: {
-		id: 'json',
-		title: 'JSON',
-		titleShort: 'JSON',
-		ext: ['.json'],
-		canRead: true,
-		canWrite: true,
-	},
-	medline: {
-		id: 'medline',
-		title: 'MEDLINE / PubMed',
-		titleShort: 'MEDLINE',
-		ext: ['.nbib'],
-		canRead: true,
-		canWrite: true,
-	},
-	ris: {
-		id: 'ris',
-		title: 'RIS',
-		titleShort: 'RIS',
-		ext: ['.ris','.txt','.cgi'],
-		canRead: true,
-		canWrite: true,
-	},
-	tsv: {
-		id: 'tsv',
-		title: 'Tab Seperated Values',
-		titleShort: 'TSV',
-		ext: ['.tsv'],
-		canRead: false,
-		canWrite: false,
-	},
-}
+/**
+* Lookup table of various citation file formats
+* @type {array<Object>} A collection of Reflib supported file formats
+* @property {string} title The long form title of the format
+* @property {string} titleShort Shorter title of the format
+* @property {string} input Input format required by parser
+* @property {string} output Output format required by formatter
+* @property {Array<String>} ext File extensions of this format, the first entry is generally used as the output default
+* @property {boolean} canRead Whether the format is supported when reading a citation library
+* @property {boolean} canWrite Whether the format is supported when writing a citation library
+*/
+export let formats = {
+	csv: {
+		id: 'csv',
+		title: 'Comma Seperated Values',
+		titleShort: 'CSV',
+		ext: ['.csv'],
+		canRead: false,
+		canWrite: false,
+	},
+	endnoteEnl: {
+		id: 'endnoteEnl',
+		title: 'EndNote ENL',
+		titleShort: 'EndNote',
+		ext: ['.enl'],
+		canRead: true,
+		canWrite: true,
+	},
+	endnoteEnlX: {
+		id: 'endnoteEnlX',
+		title: 'EndNote ENLX',
+		titleShort: 'EndNote ENLX',
+		ext: ['.enlx'],
+		canRead: true,
+		canWrite: false,
+	},
+	endnoteXml: {
+		id: 'endnoteXml',
+		title: 'EndNoteXML',
+		titleShort: 'EndNoteXML',
+		ext: ['.xml'],
+		canRead: true,
+		canWrite: true,
+	},
+	json: {
+		id: 'json',
+		title: 'JSON',
+		titleShort: 'JSON',
+		ext: ['.json'],
+		canRead: true,
+		canWrite: true,
+	},
+	medline: {
+		id: 'medline',
+		title: 'MEDLINE / PubMed',
+		titleShort: 'MEDLINE',
+		ext: ['.nbib'],
+		canRead: true,
+		canWrite: true,
+	},
+	ris: {
+		id: 'ris',
+		title: 'RIS',
+		titleShort: 'RIS',
+		ext: ['.ris','.txt','.cgi'],
+		canRead: true,
+		canWrite: true,
+	},
+	tsv: {
+		id: 'tsv',
+		title: 'Tab Seperated Values',
+		titleShort: 'TSV',
+		ext: ['.tsv'],
+		canRead: false,
+		canWrite: false,
+	},
+}

package/lib/getModule.js

@@ -1,39 +1,39 @@
-import * as modules from '../modules/default.js';
-
-let hasSetup = new Set(); // Modules we have already setup
-
-/**
-* Simple wrapper which loads the named module as a keyed lirary of functions
-*
-* @param {string} module The module ID as per `lib/formats.js`
-* @param {Object} [options] Additional options to use when fetching the module
-* @param {boolean} [options.setup=true] Call the `setup()` function on any module requested before use
-*
-* @returns {Object} The loaded module as an object of standardised functionality
-*/
-export function getModule(module, options) {
-	// Sanity checking
-	if (!module) throw new Error('No module provided');
-
-	// Argument mangling
-	let settings = {
-		setup: true,
-		...options,
-	};
-
-	// Try to find the module
-	let mod = modules[module];
-	if (!mod) throw new Error(`Unknown module "${module}"`);
-
-	// Should setup and module exposes a setup function?
-	if (
-		mod.setup // We should set up...
-		&& settings.setup // AND the module has a function to do so...
-		&& !hasSetup.has(module) // AND we've not setup before
-	) {
-		hasSetup.add(module);
-		mod.setup();
-	}
-
-	return mod;
-}
+import * as modules from '../modules/default.js';
+
+let hasSetup = new Set(); // Modules we have already setup
+
+/**
+* Simple wrapper which loads the named module as a keyed lirary of functions
+*
+* @param {string} module The module ID as per `lib/formats.js`
+* @param {Object} [options] Additional options to use when fetching the module
+* @param {boolean} [options.setup=true] Call the `setup()` function on any module requested before use
+*
+* @returns {Object} The loaded module as an object of standardised functionality
+*/
+export function getModule(module, options) {
+	// Sanity checking
+	if (!module) throw new Error('No module provided');
+
+	// Argument mangling
+	let settings = {
+		setup: true,
+		...options,
+	};
+
+	// Try to find the module
+	let mod = modules[module];
+	if (!mod) throw new Error(`Unknown module "${module}"`);
+
+	// Should setup and module exposes a setup function?
+	if (
+		mod.setup // We should set up...
+		&& settings.setup // AND the module has a function to do so...
+		&& !hasSetup.has(module) // AND we've not setup before
+	) {
+		hasSetup.add(module);
+		mod.setup();
+	}
+
+	return mod;
+}

package/lib/getRefDoi.js

@@ -1,16 +1,16 @@
-// @returns {Object} The modified ref object with the updated DOI
-/**
-* Identify DOI in the format(eg: 'https://dx.doi.org/10.1186/s40504-020-00106-2'), extract DOI number only(eg:'10.1186/s40504-020-00106-2')and return the ref object
-* @param {Object} ref The input object to identify and change DOI format
-*@returns {string|null} The modified DOI or null if no DOI is available
-*/
-export function getRefDoi(ref) {
-    if (ref.doi) {
-        const doiPrefix = 'https://dx.doi.org/';
-        if (ref.doi.startsWith(doiPrefix)) {
-            ref.doi = ref.doi.slice(doiPrefix.length);
-        }
-        return ref.doi;
-    }
-    return null;
-}
+// @returns {Object} The modified ref object with the updated DOI
+/**
+* Identify DOI in the format(eg: 'https://dx.doi.org/10.1186/s40504-020-00106-2'), extract DOI number only(eg:'10.1186/s40504-020-00106-2')and return the ref object
+* @param {Object} ref The input object to identify and change DOI format
+*@returns {string|null} The modified DOI or null if no DOI is available
+*/
+export function getRefDoi(ref) {
+    if (ref.doi) {
+        const doiPrefix = 'https://dx.doi.org/';
+        if (ref.doi.startsWith(doiPrefix)) {
+            ref.doi = ref.doi.slice(doiPrefix.length);
+        }
+        return ref.doi;
+    }
+    return null;
+}

package/lib/identifyFormat.js

@@ -1,13 +1,13 @@
-import {formats} from '../lib/formats.js';
-
-/**
-* Identify and return the Reflib format (from ./formats) to use for the given file name / path
-* @param {string} path The input path to identify
-* @returns {Object} A matching entry from ./formats or null if no matching format was found
-*/
-export function identifyFormat(path) {
-	let ext = /^.*(?<ext>\..+?)$/.exec(path)?.groups.ext.toLowerCase();
-	if (!ext) return null;
-
-	return Object.values(formats).find(format => format.ext.includes(ext));
-}
+import {formats} from '../lib/formats.js';
+
+/**
+* Identify and return the Reflib format (from ./formats) to use for the given file name / path
+* @param {string} path The input path to identify
+* @returns {Object} A matching entry from ./formats or null if no matching format was found
+*/
+export function identifyFormat(path) {
+	let ext = /^.*(?<ext>\..+?)$/.exec(path)?.groups.ext.toLowerCase();
+	if (!ext) return null;
+
+	return Object.values(formats).find(format => format.ext.includes(ext));
+}

package/lib/readFile.js

@@ -1,63 +1,63 @@
-import {createReadStream} from 'node:fs';
-import Emitter from '../shared/emitter.js';
-import {stat} from 'node:fs/promises';
-import {identifyFormat} from './identifyFormat.js';
-import {readStream} from './readStream.js';
-
-/**
-* Parse a file directly from a path
-* This function is a warpper around the readStream handler + some Promise magic
-* @param {string} path The file path to parse
-* @param {Object} [options] Additional options to pass to the parser
-* @param {string} [options.module] The module to use if overriding from the file path
-*
-* @returns {Promise<Array>} An eventual array of all references parsed from the file
-* @property {EventEmitter} emitter An event emitter which will fire the below events
-*
-* @emits progress Emitted as `({readBytes: Number, totalSize: Number, refsFound: Number})`
-* @emits end Emitted as `({refsFound: Number})` when the reading operation has completed
-*/
-export function readFile(path, options) {
-	let settings = {
-		progressTotal: false,
-		...options,
-	};
-	let module = options?.module || identifyFormat(path)?.id;
-	if (!module) throw new Error(`Unable to identify reference library format for file path "${path}"`);
-
-	let promiseEmitter = Promise.resolve()
-		.then(()=> stat(path))
-		.then(stats => new Promise((resolve, reject) => {
-			let refs = [];
-
-			readStream(
-				module,
-				createReadStream(path),
-				{
-					...settings,
-					size: stats.size,
-				},
-			)
-				.on('end', ()=> resolve(refs))
-				.on('error', reject)
-				.on('ref', ref => refs.push(ref))
-				.on('progress', readBytes => promiseEmitter.emitter.emit('progress', {
-					readBytes,
-					totalSize: stats.size,
-					refsFound: refs.length,
-				}))
-		}))
-		.then(refs => {
-			promiseEmitter.emitter.emit('end', {refsFound: refs.length})
-			return refs;
-		})
-
-	// Extend our base promise with an emitter subkey
-	return Object.defineProperties(promiseEmitter, {
-		emitter: {
-			value: Emitter(),
-			enumerable: true,
-			writable: false,
-		},
-	});
-}
+import {createReadStream} from 'node:fs';
+import Emitter from '../shared/emitter.js';
+import {stat} from 'node:fs/promises';
+import {identifyFormat} from './identifyFormat.js';
+import {readStream} from './readStream.js';
+
+/**
+* Parse a file directly from a path
+* This function is a warpper around the readStream handler + some Promise magic
+* @param {string} path The file path to parse
+* @param {Object} [options] Additional options to pass to the parser
+* @param {string} [options.module] The module to use if overriding from the file path
+*
+* @returns {Promise<Array>} An eventual array of all references parsed from the file
+* @property {EventEmitter} emitter An event emitter which will fire the below events
+*
+* @emits progress Emitted as `({readBytes: Number, totalSize: Number, refsFound: Number})`
+* @emits end Emitted as `({refsFound: Number})` when the reading operation has completed
+*/
+export function readFile(path, options) {
+	let settings = {
+		progressTotal: false,
+		...options,
+	};
+	let module = options?.module || identifyFormat(path)?.id;
+	if (!module) throw new Error(`Unable to identify reference library format for file path "${path}"`);
+
+	let promiseEmitter = Promise.resolve()
+		.then(()=> stat(path))
+		.then(stats => new Promise((resolve, reject) => {
+			let refs = [];
+
+			readStream(
+				module,
+				createReadStream(path),
+				{
+					...settings,
+					size: stats.size,
+				},
+			)
+				.on('end', ()=> resolve(refs))
+				.on('error', reject)
+				.on('ref', ref => refs.push(ref))
+				.on('progress', readBytes => promiseEmitter.emitter.emit('progress', {
+					readBytes,
+					totalSize: stats.size,
+					refsFound: refs.length,
+				}))
+		}))
+		.then(refs => {
+			promiseEmitter.emitter.emit('end', {refsFound: refs.length})
+			return refs;
+		})
+
+	// Extend our base promise with an emitter subkey
+	return Object.defineProperties(promiseEmitter, {
+		emitter: {
+			value: Emitter(),
+			enumerable: true,
+			writable: false,
+		},
+	});
+}

package/lib/readStream.js

@@ -1,21 +1,21 @@
-import {getModule} from './getModule.js';
-
-/**
-* Parse an input stream via a given format ID
-* This function is really just a multiplexor around each modules `readStream` export
-* @param {string} module The module ID as per `lib/formats.js`
-* @param {Stream.Readable} stream Input stream to parse
-* @param {Object} [options] Additional options to pass to the parser
-* @param {number} [options.size] Size of the input stream, if omitted `progress` events are not emitted
-* @returns {EventEmitter} An Event-Emitter compatible object which will fire various events while parsing
-*
-* @emits ref Emitted with an extracted reference object during parse
-* @emits end Emitted when the parsing has completed
-* @emits error Emitted with an Error object if any occured
-*/
-export function readStream(module, stream, options) {
-	if (!module) throw new Error('No module provided to parse with');
-	if (!stream) throw new Error('No stream provided to parse');
-
-	return getModule(module).readStream(stream, options);
-}
+import {getModule} from './getModule.js';
+
+/**
+* Parse an input stream via a given format ID
+* This function is really just a multiplexor around each modules `readStream` export
+* @param {string} module The module ID as per `lib/formats.js`
+* @param {Stream.Readable} stream Input stream to parse
+* @param {Object} [options] Additional options to pass to the parser
+* @param {number} [options.size] Size of the input stream, if omitted `progress` events are not emitted
+* @returns {EventEmitter} An Event-Emitter compatible object which will fire various events while parsing
+*
+* @emits ref Emitted with an extracted reference object during parse
+* @emits end Emitted when the parsing has completed
+* @emits error Emitted with an Error object if any occured
+*/
+export function readStream(module, stream, options) {
+	if (!module) throw new Error('No module provided to parse with');
+	if (!stream) throw new Error('No stream provided to parse');
+
+	return getModule(module).readStream(stream, options);
+}

package/lib/uploadFile.js

@@ -1,71 +1,71 @@
-import {formats} from './formats.js';
-import {identifyFormat} from './identifyFormat.js';
-import {readStream} from './readStream.js';
-import StreamEmitter from '../shared/streamEmitter.js';
-
-/**
-* Prompt the user for a file then read it as a Reflib event emitter
-* @param {Object} [options] Additional options when prompting the user
-* @param {File} [options.file] The File object to process, omitting this will prompt the user to select a file
-* @param {function} [options.onStart] Async function called as `(File)` when starting the read stage
-* @param {function} [options.onProgress] Function called as `(position, totalSize, refCount)` when processing the file
-* @param {function} [options.onEnd] Async function called as `()` when the read stage has completed
-* @param {...*} [options...] Additional settings to pass to `readStream()`
-* @returns {Promise} A promise which will resolve with an array of extracted citations
-*/
-export function uploadFile(options) {
-	let settings = {...options};
-
-	if (!settings.file) { // No file provided - prompt the user via the DOM
-		// Horrible kludge to create an upload element in the DOM + interact with it {{{
-		return new Promise(resolve => {
-			// Create hidden layer we will use to wrap the actual file upload input box
-			let fileWrapper = document.createElement('div');
-			fileWrapper.style.display = 'none';
-			document.body.appendChild(fileWrapper);
-
-			// Create upload input
-			let uploader = document.createElement('input');
-			uploader.type = 'file';
-			uploader.accept = Object.values(formats) // Allow only uploading supported file extensions
-				.flatMap(f => f.ext)
-				.join(',');
-
-			uploader.addEventListener('change', e => {
-				document.body.removeChild(fileWrapper);
-				resolve(uploadFile({
-					file: e.target.files[0],
-					...options,
-				}));
-			});
-			fileWrapper.appendChild(uploader);
-			uploader.dispatchEvent(new MouseEvent('click'));
-		});
-		// }}}
-	} else { // Read the File object and return an emitter
-		if (!(settings.file instanceof File)) throw new Error('Expected "file" setting to uploadFile() to be a File type');
-		let identifiedType = identifyFormat(settings.file.name);
-		if (!identifiedType) throw new Error(`Unidenfified file format from filename "${settings.file.name}"`);
-
-		let refs = [];
-		return Promise.resolve()
-			.then(()=> settings.onStart && settings.onStart(settings.file))
-			.then(()=> new Promise((resolve, reject) => {
-				let streamer = readStream(
-					identifiedType.id,
-					StreamEmitter(settings.file.stream()),
-					{
-						...settings,
-						size: settings.file.size,
-					},
-				)
-					.on('end', ()=> resolve(refs))
-					.on('error', e => reject(e))
-					.on('ref', ref => refs.push(ref))
-
-				if (settings.onProgress) streamer.on('progress', settings.onProgress);
-			}))
-			.then(()=> settings.onEnd && settings.onEnd())
-			.then(()=> refs)
-	}
-}
+import {formats} from './formats.js';
+import {identifyFormat} from './identifyFormat.js';
+import {readStream} from './readStream.js';
+import StreamEmitter from '../shared/streamEmitter.js';
+
+/**
+* Prompt the user for a file then read it as a Reflib event emitter
+* @param {Object} [options] Additional options when prompting the user
+* @param {File} [options.file] The File object to process, omitting this will prompt the user to select a file
+* @param {function} [options.onStart] Async function called as `(File)` when starting the read stage
+* @param {function} [options.onProgress] Function called as `(position, totalSize, refCount)` when processing the file
+* @param {function} [options.onEnd] Async function called as `()` when the read stage has completed
+* @param {...*} [options...] Additional settings to pass to `readStream()`
+* @returns {Promise} A promise which will resolve with an array of extracted citations
+*/
+export function uploadFile(options) {
+	let settings = {...options};
+
+	if (!settings.file) { // No file provided - prompt the user via the DOM
+		// Horrible kludge to create an upload element in the DOM + interact with it {{{
+		return new Promise(resolve => {
+			// Create hidden layer we will use to wrap the actual file upload input box
+			let fileWrapper = document.createElement('div');
+			fileWrapper.style.display = 'none';
+			document.body.appendChild(fileWrapper);
+
+			// Create upload input
+			let uploader = document.createElement('input');
+			uploader.type = 'file';
+			uploader.accept = Object.values(formats) // Allow only uploading supported file extensions
+				.flatMap(f => f.ext)
+				.join(',');
+
+			uploader.addEventListener('change', e => {
+				document.body.removeChild(fileWrapper);
+				resolve(uploadFile({
+					file: e.target.files[0],
+					...options,
+				}));
+			});
+			fileWrapper.appendChild(uploader);
+			uploader.dispatchEvent(new MouseEvent('click'));
+		});
+		// }}}
+	} else { // Read the File object and return an emitter
+		if (!(settings.file instanceof File)) throw new Error('Expected "file" setting to uploadFile() to be a File type');
+		let identifiedType = identifyFormat(settings.file.name);
+		if (!identifiedType) throw new Error(`Unidenfified file format from filename "${settings.file.name}"`);
+
+		let refs = [];
+		return Promise.resolve()
+			.then(()=> settings.onStart && settings.onStart(settings.file))
+			.then(()=> new Promise((resolve, reject) => {
+				let streamer = readStream(
+					identifiedType.id,
+					StreamEmitter(settings.file.stream()),
+					{
+						...settings,
+						size: settings.file.size,
+					},
+				)
+					.on('end', ()=> resolve(refs))
+					.on('error', e => reject(e))
+					.on('ref', ref => refs.push(ref))
+
+				if (settings.onProgress) streamer.on('progress', settings.onProgress);
+			}))
+			.then(()=> settings.onEnd && settings.onEnd())
+			.then(()=> refs)
+	}
+}