@iebh/reflib 2.7.2 → 2.8.1

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)
+	}
+}

package/lib/writeFile.js

@@ -1,32 +1,32 @@
-import {createWriteStream} from 'node:fs';
-import {finished as streamFinished} from 'node:stream/promises';
-import {identifyFormat} from './identifyFormat.js';
-import {writeStream} from './writeStream.js';
-
-/**
-* Write a file to disk via the appropriate module
-*
-* @param {string} path The file path to write, the module to use will be determined from this
-* @param {Array<ReflibRef>} refs Collection of references to write
-* @param {Object} [options] Additional options to pass to the file writer
-* @param {string} [options.module] The module to use if overriding from the file path
-*
-* @returns {Promise} A promise which resolves when the operation has completed
-*/
-export function writeFile(path, refs, options) {
-	let format = options?.module || identifyFormat(path)?.id;
-	if (!format) throw new Error(`Unable to identify reference library format when saving file "${path}"`);
-
-	let fileStream = createWriteStream(path);
-	let writer = writeStream(format, fileStream, options);
-
-	return Promise.resolve()
-		.then(()=> writer.start())
-		.then(()=> refs.reduce((chain, ref, refIndex, refs) => chain // Write all refs as a series of promises
-			.then(()=> writer.write(ref))
-			.then(()=> refIndex < refs.length && writer.middle && writer.middle(ref))
-		, Promise.resolve()))
-		.then(()=> writer.end())
-		.then(()=> fileStream.close())
-		.then(()=> streamFinished(fileStream))
-}
+import {createWriteStream} from 'node:fs';
+import {finished as streamFinished} from 'node:stream/promises';
+import {identifyFormat} from './identifyFormat.js';
+import {writeStream} from './writeStream.js';
+
+/**
+* Write a file to disk via the appropriate module
+*
+* @param {string} path The file path to write, the module to use will be determined from this
+* @param {Array<ReflibRef>} refs Collection of references to write
+* @param {Object} [options] Additional options to pass to the file writer
+* @param {string} [options.module] The module to use if overriding from the file path
+*
+* @returns {Promise} A promise which resolves when the operation has completed
+*/
+export function writeFile(path, refs, options) {
+	let format = options?.module || identifyFormat(path)?.id;
+	if (!format) throw new Error(`Unable to identify reference library format when saving file "${path}"`);
+
+	let fileStream = createWriteStream(path);
+	let writer = writeStream(format, fileStream, options);
+
+	return Promise.resolve()
+		.then(()=> writer.start())
+		.then(()=> refs.reduce((chain, ref, refIndex, refs) => chain // Write all refs as a series of promises
+			.then(()=> writer.write(ref))
+			.then(()=> refIndex < refs.length && writer.middle && writer.middle(ref))
+		, Promise.resolve()))
+		.then(()=> writer.end())
+		.then(()=> fileStream.close())
+		.then(()=> streamFinished(fileStream))
+}

package/lib/writeStream.js

@@ -1,16 +1,16 @@
-import {getModule} from './getModule.js';
-
-/**
-* Write an output stream via a given format ID
-* This function is really just a multiplexor around each modules `writeStream` export
-* @param {string} module The module ID as per `lib/formats.js`
-* @param {Stream.Writable} stream Output stream to write to
-* @param {Object} [options] Additional options to pass to the stream writer
-* @returns {Object} An object composed of `{start, write, end}` functions
-*/
-export function writeStream(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).writeStream(stream, options);
-}
+import {getModule} from './getModule.js';
+
+/**
+* Write an output stream via a given format ID
+* This function is really just a multiplexor around each modules `writeStream` export
+* @param {string} module The module ID as per `lib/formats.js`
+* @param {Stream.Writable} stream Output stream to write to
+* @param {Object} [options] Additional options to pass to the stream writer
+* @returns {Object} An object composed of `{start, write, end}` functions
+*/
+export function writeStream(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).writeStream(stream, options);
+}