@iebh/reflib 2.0.2 → 2.0.5

package/README.md

@@ -18,7 +18,7 @@ Compatibility
 | EndNote ENLX           | `.enlx`         | :x:                | :x:                |
 | EndNote XML            | `.xml`          | :heavy_check_mark: | :heavy_check_mark: |
 | JSON                   | `.json`         | :heavy_check_mark: | :heavy_check_mark: |
-| Medline                | `.nbib`         | :x:                | :x:                |
+| Medline                | `.nbib`         | :heavy_check_mark: | :heavy_check_mark: |
 | RIS                    | `.ris` / `.txt` | :heavy_check_mark: | :heavy_check_mark: |
 | Tab Separated Values   | `.tsv`          | :x:                | :x:                |
 

package/lib/browser.js

@@ -5,4 +5,5 @@ import {readStream} from './readStream.js';
 import {uploadFile} from './uploadFile.js';
 import {writeStream} from './writeStream.js';
 
+export {identifyFormat, formats, getModule, readStream, uploadFile, writeStream};
 export default {identifyFormat, formats, getModule, readStream, uploadFile, writeStream};

package/lib/default.js

@@ -6,4 +6,5 @@ import {readFile} from './readFile.js';
 import {writeStream} from './writeStream.js';
 import {writeFile} from './writeFile.js';
 
-export default {identifyFormat, formats, getModule, readStream, readFile, writeStream, writeFile};
+export {identifyFormat, formats, getModule, readStream, readFile, writeStream, writeFile};
+export default {identifyFormat, formats, getModule, readStream, readFile, writeStream, writeFile};

package/lib/formats.js

@@ -39,8 +39,8 @@ export let formats = {
 		title: 'MEDLINE / PubMed',
 		titleShort: 'MEDLINE',
 		ext: ['.nbib'],
-		canRead: false,
-		canWrite: false,
+		canRead: true,
+		canWrite: true,
 	},
 	ris: {
 		id: 'ris',

package/lib/uploadFile.js

@@ -6,7 +6,7 @@ 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.files] The File object to process, omitting this will prompt the user to select a file
+* @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)` when processing the file
 * @param {function} [options.onEnd] Async function called as `()` when the read stage has completed
@@ -49,9 +49,10 @@ export function uploadFile(options) {
 		return Promise.resolve()
 			.then(()=> settings.onStart && settings.onStart(settings.file))
 			.then(()=> new Promise((resolve, reject) => {
+
 				let streamer = readStream(
 					identifiedType.id,
-					StreamEmitter(settings.file.stream().getReader()),
+					StreamEmitter(settings.file.stream()),
 					{
 						...settings,
 						size: settings.file.size,

package/modules/endnoteXml.js

@@ -1,7 +1,9 @@
 import camelCase from '../shared/camelCase.js';
 import Emitter from '../shared/emitter.js';
-import {WritableStream as XMLParser} from 'htmlparser2/lib/WritableStream';
 
+// TODO: CF: Don't need to import both, it depends if we are on browser or node
+import * as htmlparser2 from "htmlparser2";
+import {WritableStream as XMLParser} from 'htmlparser2/lib/WritableStream';
 
 /**
 * @see modules/interface.js
@@ -30,75 +32,111 @@ export function readStream(stream) {
 	*/
 	let textAppend = false;
 
+	/**
+	 * The options/callbacks for the parser
+	 * @type {Object}
+	 */
+	let parserOptions = {
+		xmlMode: true,
+		decodeEntities: false, // Handled below
+		onopentag(name, attrs) {
+			textAppend = false;
+			stack.push({
+				name: camelCase(name),
+				attrs,
+			});
+		},
+		onclosetag(name) {
+			if (name == 'record') {
+				if (ref.title) ref.title = ref.title // htmlparser2 handles the '<title>' tag in a really bizare way so we have to pull apart the <style> bits when parsing
+					.replace(/^.*<style.*>(.*)<\/style>.*$/m, '$1')
+					.replace(/^\s+/, '')
+					.replace(/\s+$/, '')
+				emitter.emit('ref', translateRawToRef(ref));
+				stack = []; // Trash entire stack when hitting end of <record/> node
+				ref = {}; // Reset the ref state
+			} else {
+				stack.pop();
+			}
+		},
+		ontext(text) {
+			let parentName = stack[stack.length - 1]?.name;
+			let gParentName = stack[stack.length - 2]?.name;
+			if (parentName == 'title') {
+				if (textAppend) {
+					ref.title += text;
+				} else {
+					ref.title = text;
+				}
+			} else if (parentName == 'style' && gParentName == 'author') {
+				if (!ref.authors) ref.authors = [];
+				if (textAppend) {
+					ref.authors[ref.authors.length - 1] += xmlUnescape(text);
+				} else {
+					ref.authors.push(xmlUnescape(text));
+				}
+			} else if (parentName == 'style' && gParentName == 'keyword') {
+				if (!ref.keywords) ref.keywords = [];
+				if (textAppend) {
+					ref.keywords[ref.keywords.length - 1] += xmlUnescape(text);
+				} else {
+					ref.keywords.push(xmlUnescape(text));
+				}
+			} else if (parentName == 'style') { // Text within <style/> tag
+				if (textAppend || ref[gParentName]) { // Text already exists? Append (handles node-expats silly multi-text per escape character "feature")
+					ref[gParentName] += xmlUnescape(text);
+				} else {
+					ref[gParentName] = xmlUnescape(text);
+				}
+			} else if (['recNumber', 'refType'].includes(parentName)) { // Simple setters like <rec-number/>
+				if (textAppend || ref[parentName]) {
+					ref[parentName] += xmlUnescape(text);
+				} else {
+					ref[parentName] = xmlUnescape(text);
+				}
+			}
+			textAppend = true; // Always set the next call to the text emitter handler as an append operation
+		},
+		onend() {
+			emitter.emit('end');
+		}
+	}
 
 	// Queue up the parser in the next tick (so we can return the emitter first)
-	setTimeout(()=> {
-		let parser = new XMLParser({
-			xmlMode: true,
-			decodeEntities: false, // Handled below
-			onopentag(name, attrs) {
-				textAppend = false;
-				stack.push({
-					name: camelCase(name),
-					attrs,
-				});
-			},
-			onclosetag(name) {
-				if (name == 'record') {
-					if (ref.title) ref.title = ref.title // htmlparser2 handles the '<title>' tag in a really bizare way so we have to pull apart the <style> bits when parsing
-						.replace(/^.*<style.*>(.*)<\/style>.*$/m, '$1')
-						.replace(/^\s+/, '')
-						.replace(/\s+$/, '')
-					emitter.emit('ref', translateRawToRef(ref));
-					stack = []; // Trash entire stack when hitting end of <record/> node
-					ref = {}; // Reset the ref state
+	setTimeout(() => {
+
+		if (typeof stream.pipe === 'function') {
+			// We are on the node.js client
+			let parser = new XMLParser(parserOptions);
+			stream.pipe(parser)
+			return;
+		}
+
+		// TODO: CF: We may want to consider moving to a DIY parser for speed and memory efficiency
+		if (typeof stream.getReader === 'function') {
+			// We are on the browser
+			var reader = stream.getReader();
+			var parser = new htmlparser2.Parser(parserOptions);
+			parseXMLOnBrowser();
+			return;
+		}
+
+		function parseXMLOnBrowser() {
+			reader.read().then(({done, value}) => {
+				if (done) {
+					parser.end();
 				} else {
-					stack.pop();
-				}
-			},
-			ontext(text) {
-				let parentName = stack[stack.length - 1]?.name;
-				let gParentName = stack[stack.length - 2]?.name;
-				if (parentName == 'title') {
-					if (textAppend) {
-						ref.title += text;
-					} else {
-						ref.title = text;
-					}
-				} else if (parentName == 'style' && gParentName == 'author') {
-					if (!ref.authors) ref.authors = [];
-					if (textAppend) {
-						ref.authors[ref.authors.length - 1] += xmlUnescape(text);
-					} else {
-						ref.authors.push(xmlUnescape(text));
-					}
-				} else if (parentName == 'style' && gParentName == 'keyword') {
-					if (!ref.keywords) ref.keywords = [];
-					if (textAppend) {
-						ref.keywords[ref.keywords.length - 1] += xmlUnescape(text);
-					} else {
-						ref.keywords.push(xmlUnescape(text));
-					}
-				} else if (parentName == 'style') { // Text within <style/> tag
-					if (textAppend || ref[gParentName]) { // Text already exists? Append (handles node-expats silly multi-text per escape character "feature")
-						ref[gParentName] += xmlUnescape(text);
-					} else {
-						ref[gParentName] = xmlUnescape(text);
-					}
-				} else if (['recNumber', 'refType'].includes(parentName)) { // Simple setters like <rec-number/>
-					if (textAppend || ref[parentName]) {
-						ref[parentName] += xmlUnescape(text);
-					} else {
-						ref[parentName] = xmlUnescape(text);
-					}
+					var text = new TextDecoder().decode(value);
+					parser.write(text);
+					text = null; // Free up memory
+					parseXMLOnBrowser();
 				}
-				textAppend = true; // Always set the next call to the text emitter handler as an append operation
-			},
-		})
+			})
+		}
 
-		stream.pipe(parser)
-			.on('finish', ()=> emitter.emit('end'))
-	});
+		console.error("This line should not be hit!");
+
+	})
 
 	return emitter;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iebh/reflib",
-  "version": "2.0.2",
+  "version": "2.0.5",
   "description": "Reference / Citation reference library utilities",
   "scripts": {
     "lint": "eslint lib modules shared test",

package/shared/streamEmitter.js

@@ -3,7 +3,7 @@ import Emitter from '../shared/emitter.js';
 /**
 * Wrapper for streams which transforms a given input into an emitter pattern
 * This is designed to let regular `node:stream.Readable` objects pass through without alteration but browser based stream objects get wrapped
-* @param {stream.Readable|ReadableStreamDefaultReader} inStream The input stream to wrap
+* @param {stream.Readable|ReadableStream} inStream The input stream to wrap
 * @returns {stream.Readable|Emitter} Either the unedited node compatible stream or an event emitter with the same behaviour
 *
 * @emits data Emitted as `(chunk)` on each data chunk
@@ -11,27 +11,8 @@ import Emitter from '../shared/emitter.js';
 * @emits error Emitted as `(Error)` on any read error
 */
 export default function streamEmitter(inStream) {
-	if (inStream.on) return inStream; // inStream already supports event emitters - do nothing
-
-	let emitter = Emitter();
-	let utf8Decoder = new TextDecoder('utf-8');
-	let readCycle = ()=> {
-		inStream
-			.read()
-			.then(({value, done}) => {
-				if (done) {
-					emitter.emit('end');
-				} else {
-					emitter.emit('data', utf8Decoder.decode(value, {stream: true}));
-					setTimeout(readCycle); // Loop into next read if not already finished
-				}
-			})
-			.catch(e => emitter.emit('error', e))
-	};
-
-	// Keep downstream libraries happy by stubbing stream-like functions
-	emitter.setEncoding = ()=> {};
-
-	setTimeout(readCycle); // Queue up initial read cycle on next tick
-	return emitter;
+	// FIXME: Need to examine inStream and multiplex
+	//        inStream.pipeTo - a browser stream - passthru
+	//        !inStream.pipeTo - probably Node stream - need to glue pipeTo as a promiseable
+	return inStream;
 }