citeclaw 2.0.0

package/vendor/zotero/modules/translate/src/translation/translate_item.js

@@ -0,0 +1,120 @@
+/*
+    ***** BEGIN LICENSE BLOCK *****
+    
+    Copyright © 2011 Center for History and New Media
+                     George Mason University, Fairfax, Virginia, USA
+                     http://zotero.org
+    
+    This file is part of Zotero.
+    
+    Zotero is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+    
+    Zotero is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+    
+    You should have received a copy of the GNU Affero General Public License
+    along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+    
+    ***** END LICENSE BLOCK *****
+*/
+
+/**
+ * A class which will be passed the results of translation as Zotero items and collections.
+ *
+ * This is a virtual class for reference implementation purposes
+ * A consumer of the translation code should implement these functions
+ */
+Zotero.Translate.ItemSaver = function(libraryID, attachmentMode, forceTagType) {};
+Zotero.Translate.ItemSaver.ATTACHMENT_MODE_IGNORE = 0;
+Zotero.Translate.ItemSaver.ATTACHMENT_MODE_DOWNLOAD = 1;
+Zotero.Translate.ItemSaver.ATTACHMENT_MODE_FILE = 2;
+
+/**
+ * Only used by import translators and can remain a no-OP
+ * @param {Array} collections
+ */
+Zotero.Translate.ItemSaver.prototype.saveCollection = function(collections) {};
+
+/**
+ * Called by Zotero.Translate upon successful item translation
+ * @param {Object[]} jsonItems - Items in Zotero.Item.toArray() format
+ * @param {Function} [attachmentCallback] A callback that receives information about attachment
+ *     save progress. The callback will be called as attachmentCallback(attachment, false, error)
+ *     on failure or attachmentCallback(attachment, progressPercent) periodically during saving.
+ * @param {Function} [itemsDoneCallback] A callback that is called once all top-level items are
+ *     done saving with a list of items. Can include saved notes, but should exclude attachments.
+ */
+Zotero.Translate.ItemSaver.prototype.saveItems = async function (jsonItems, attachmentCallback, itemsDoneCallback) {
+	throw new Error(`Zotero.Translate.ItemSaver.prototype.saveItems: not implemented`);
+};
+
+// Used by export translators in Zotero
+Zotero.Translate.ItemGetter = function() {
+	this._itemsLeft = null;
+	this._itemID = 1;
+};
+
+Zotero.Translate.ItemGetter.prototype = {
+	get numItemsRemaining() {
+		return this._itemsLeft.length
+	},
+	
+	setItems: function(items) {
+		this._itemsLeft = items;
+		this.numItems = this._itemsLeft.length;
+	},
+
+	setCollection: function (collection, getChildCollections) {
+		throw new Error(`Zotero.Translate.ItemGetter.prototype.setCollection: not implemented`);
+	},
+
+	/**
+	 * NOTE: This function should use the Zotero.Promise.method wrapper which adds a
+	 * isResolved property to the returned promise for noWait translation.
+	 */
+	setAll: Zotero.Promise.method(function (libraryID, getChildCollections) {
+		throw new Error(`Zotero.Translate.ItemGetter.prototype.setAll: not implemented`);
+	}),
+	
+	/**
+	 * Retrieves the next available item
+	 */
+	nextItem: function() {
+		if(!this._itemsLeft.length) return false;
+		var item = this._itemsLeft.shift();
+		if (this.legacy) {
+			item = Zotero.Utilities.Item.itemToLegacyExportFormat(item);
+		}
+		if (!item.attachments) {
+			item.attachments = [];
+		}
+		if (!item.notes) {
+			item.notes = [];
+		}
+
+		// convert single field creators to format expected by export
+		if(item.creators) {
+			for(var i=0; i<item.creators.length; i++) {
+				var creator = item.creators[i];
+				if(creator.name) {
+					creator.lastName = creator.name;
+					creator.firstName = "";
+					delete creator.name;
+					creator.fieldMode = 1;
+				}
+			}
+		}
+		
+		item.itemID = this._itemID++;
+		return item;
+	},
+	
+	nextCollection: function() {
+		return false;
+	}
+}

package/vendor/zotero/modules/translate/src/translator.js

@@ -0,0 +1,186 @@
+/*
+    ***** BEGIN LICENSE BLOCK *****
+    
+    Copyright © 2013 Center for History and New Media
+                     George Mason University, Fairfax, Virginia, USA
+                     http://zotero.org
+    
+    This file is part of Zotero.
+    
+    Zotero is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+    
+    Zotero is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+    
+    You should have received a copy of the GNU Affero General Public License
+    along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+    
+    ***** END LICENSE BLOCK *****
+*/
+
+// Enumeration of types of translators
+var TRANSLATOR_TYPES = {"import":1, "export":2, "web":4, "search":8};
+
+// Properties required for every translator
+var TRANSLATOR_REQUIRED_PROPERTIES = ["translatorID", "translatorType", "label", "creator",
+	"target", "priority", "lastUpdated"];
+// Properties that are preserved if present
+var TRANSLATOR_OPTIONAL_PROPERTIES = ["targetAll", "browserSupport", "minVersion", "maxVersion",
+	"inRepository", "configOptions", "displayOptions",
+	"hiddenPrefs", "itemType"];
+// Properties that are passed from background to inject page in connector
+var TRANSLATOR_PASSING_PROPERTIES = TRANSLATOR_REQUIRED_PROPERTIES
+	.concat(["targetAll", "browserSupport", "code", "runMode", "itemType", "inRepository"]);
+
+var TRANSLATOR_CACHING_PROPERTIES = TRANSLATOR_REQUIRED_PROPERTIES
+	.concat(["browserSupport", "targetAll"]);
+
+/**
+ * @class Represents an individual translator
+ * @constructor
+ * @property {String} translatorID Unique GUID of the translator
+ * @property {Integer} translatorType Type of the translator (use bitwise & with TRANSLATOR_TYPES to read)
+ * @property {String} label Human-readable name of the translator
+ * @property {String} creator Author(s) of the translator
+ * @property {String} target Location that the translator processes
+ * @property {String} minVersion Minimum Zotero version
+ * @property {String} maxVersion Minimum Zotero version
+ * @property {Integer} priority Lower-priority translators will be selected first
+ * @property {String} browserSupport String indicating browser supported by the translator
+ *     g = Gecko (Firefox)
+ *     c = Google Chrome (WebKit & V8)
+ *     s = Safari (WebKit & Nitro/Squirrelfish Extreme)
+ *     i = Internet Explorer
+ *     b = Bookmarklet
+ *     v = Server
+ * @property {Object} configOptions Configuration options for import/export
+ * @property {Object} displayOptions Display options for export
+ * @property {Object} hiddenPrefs Hidden preferences configurable through about:config
+ * @property {Boolean} inRepository Whether the translator may be found in the repository
+ * @property {String} lastUpdated SQL-style date and time of translator's last update
+ * @property {Object} metadata - Metadata block as object
+ * @property {String} code The executable JavaScript for the translator
+ * @property {Boolean} cacheCode Whether to cache code for this session (non-connector only)
+ * @property {String} [path] File path corresponding to this translator (non-connector only)
+ * @property {String} [fileName] File name corresponding to this translator (non-connector only)
+ */
+Zotero.Translator = function(info) {
+	this.init(info);
+}
+
+/**
+ * Initializes a translator from a set of info, clearing code if it is set
+ */
+Zotero.Translator.prototype.init = function(info) {
+	// make sure we have all the properties
+	for (let property of TRANSLATOR_REQUIRED_PROPERTIES) {
+		if (info[property] === undefined) {
+			this.logError(new Error('Missing property "'+property+'" in translator metadata JSON object in ' + info.label));
+			break;
+		} else {
+			this[property] = info[property];
+		}
+	}
+	for (let property of TRANSLATOR_OPTIONAL_PROPERTIES) {
+		if(info[property] !== undefined) {
+			this[property] = info[property];
+		}
+	}
+
+	this.browserSupport = info["browserSupport"] ? info["browserSupport"] : "g";
+
+	var supported = !Zotero.isBookmarklet || this.browserSupport.includes("b") ||
+		/(?:^|; ?)bookmarklet-debug-mode=1(?:$|; ?)/.test(document.cookie);
+
+	if (supported) {
+		this.runMode = Zotero.Translator.RUN_MODE_IN_BROWSER;
+	} else {
+		this.runMode = Zotero.Translator.RUN_MODE_ZOTERO_STANDALONE;
+	}
+
+	if (this.translatorType & TRANSLATOR_TYPES["import"]) {
+		// compile import regexp to match only file extension
+		this.importRegexp = this.target ? new RegExp("\\."+this.target+"$", "i") : null;
+	} else if (this.hasOwnProperty("importRegexp")) {
+		delete this.importRegexp;
+	}
+
+	// Always cache in the connector. Cache if property is set
+	this.cacheCode = Zotero.isConnector || info.cacheCode;
+	if (this.translatorType & TRANSLATOR_TYPES["web"]) {
+		// Also cache if there is no regexp target -- generic translator
+		this.cacheCode |= !this.target;
+		this.webRegexp = {
+			root: this.target ? new RegExp(this.target, "i") : null,
+			all: this.targetAll ? new RegExp(this.targetAll, "i") : null
+		};
+	} else if (this.hasOwnProperty("webRegexp")) {
+		delete this.webRegexp;
+	}
+
+	if (info.path) {
+		this.path = info.path;
+		this.fileName = OS.Path.basename(info.path);
+	}
+	if (info.code && this.cacheCode) {
+		this.code = info.code;
+	} else if (this.hasOwnProperty("code")) {
+		delete this.code;
+	}
+	// Save a copy of the metadata block
+	delete info.path;
+	delete info.code;
+	this.metadata = info;
+
+};
+
+/**
+ * Get metadata block for a translator
+ */
+Zotero.Translator.prototype.serialize = function(properties) {
+	var info = {};
+	for(var i in properties) {
+		var property = properties[i];
+		info[property] = this[property];
+	}
+	return info;
+}
+
+/**
+ * Log a translator-related error
+ * @param {String} message The error message
+ * @param {String} [type] The error type ("error", "warning", "exception", or "strict")
+ * @param {String} [line] The text of the line on which the error occurred
+ * @param {Integer} lineNumber
+ * @param {Integer} colNumber
+ */
+Zotero.Translator.prototype.logError = function(message, type, line, lineNumber, colNumber) {
+	if (Zotero.isFx && this.path) {
+		Components.utils.import("resource://gre/modules/FileUtils.jsm");
+		var file = new FileUtils.File(this.path);
+		var ios = Components.classes["@mozilla.org/network/io-service;1"].
+		getService(Components.interfaces.nsIIOService);
+		Zotero.log(message, type ? type : "error", ios.newFileURI(file).spec);
+		Zotero.debug(message, 1);
+	} else {
+		Zotero.logError(message);
+	}
+}
+
+Zotero.Translator.RUN_MODE_IN_BROWSER = 1;
+Zotero.Translator.RUN_MODE_ZOTERO_STANDALONE = 2;
+Zotero.Translator.RUN_MODE_ZOTERO_SERVER = 4;
+Zotero.Translator.TRANSLATOR_TYPES = TRANSLATOR_TYPES;
+Zotero.Translator.TRANSLATOR_REQUIRED_PROPERTIES = TRANSLATOR_REQUIRED_PROPERTIES;
+Zotero.Translator.TRANSLATOR_OPTIONAL_PROPERTIES = TRANSLATOR_OPTIONAL_PROPERTIES;
+Zotero.Translator.TRANSLATOR_PASSING_PROPERTIES = TRANSLATOR_PASSING_PROPERTIES;
+Zotero.Translator.TRANSLATOR_CACHING_PROPERTIES = TRANSLATOR_CACHING_PROPERTIES;
+
+if (typeof process === 'object' && process + '' === '[object process]'){
+	module.exports = Zotero.Translator;
+}

package/vendor/zotero/modules/translate/src/translators.js

@@ -0,0 +1,174 @@
+/*
+    ***** BEGIN LICENSE BLOCK *****
+    
+    Copyright © 2009 Center for History and New Media
+                     George Mason University, Fairfax, Virginia, USA
+                     http://zotero.org
+    
+    This file is part of Zotero.
+    
+    Zotero is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+    
+    Zotero is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+    
+    You should have received a copy of the GNU Affero General Public License
+    along with Zotero.  If not, see <http://www.gnu.org/licenses/>.
+    
+    ***** END LICENSE BLOCK *****
+*/
+
+
+/**
+ * Singleton to handle loading and caching of translators
+ * This is a virtual class for reference implementation purposes
+ * A consumer of the translation code should implement these functions
+ */
+Zotero.Translators = new function() {
+	// Should be populated on this.init()
+	this._cache = {"import":[], "export":[], "web":[], "search":[]};
+	// Should set to true after translators are loaded into memory
+	this._initialized = false;
+	
+	/**
+	 * Gets the translator that corresponds to a given ID with code set
+	 * @param {String} id The ID of the translator
+	 */
+	this.get = function (id) {
+		throw new Error(`Zotero.Translators.get(): not implemented`);
+	};
+
+	/**
+	 * Gets the translator code that corresponds to a given ID
+	 * This function is only necessary if translators are not loaded with
+	 * code already during init(). If retrieving from repo you may want to
+	 * cache updated translator info if metadata.lastUpdated > localTranslator.lastUpdated
+	 * 
+	 * NOTE: This function should use the Zotero.Promise.method wrapper which adds a
+	 * isResolved property to the returned promise for noWait translation.
+	 *
+	 * @param {Zotero.Translator} translator
+	 * @return {String} translator code
+	 */
+	this.getCodeForTranslator = Zotero.Promise.method(async function (translator) {
+		throw new Error(`Zotero.Translators.getCodeForTranslator(): not implemented`);
+	});
+
+	/**
+	 * Gets all translators for a specific type of translation
+	 * @param {String} type The type of translators to get (import, export, web, or search)
+	 */
+	this.getAllForType = async function (type) {
+		throw new Error(`Zotero.Translators.getAllForType(): not implemented`);
+	};
+
+	/**
+	 * Gets web translators for a specific location
+	 *
+	 * @param {String} URI The URI where translation will run
+	 * @param {String} rootURI The root URI of the page of translation if URI is a frame location
+	 * @return {Promise<Array[]>} - A promise for a 2-item array containing an array of translators and
+	 *     an array of functions for converting URLs from proper to proxied forms
+	 */
+	this.getWebTranslatorsForLocation = async function (URI, rootURI) {
+		var isFrame = URI !== rootURI;
+		if (!this._initialized) {
+			if (this.init) {
+				await this.init();
+			}
+			else {
+				throw new Error('Zotero.Translators.getWebTranslatorsForLocation(): Zotero.Translators is not not initialized');
+			}
+		}
+		var allTranslators = this._cache["web"];
+		var potentialTranslators = [];
+		var proxies = [];
+		
+		var rootSearchURIs = Zotero.Proxies.getPotentialProxies(rootURI);
+		var frameSearchURIs = isFrame ? Zotero.Proxies.getPotentialProxies(URI) : rootSearchURIs;
+
+		Zotero.debug("Translators: Looking for translators for "+Object.keys(frameSearchURIs).join(', '));
+
+		for(var i=0; i<allTranslators.length; i++) {
+			var translator = allTranslators[i];
+			if (isFrame && !translator.webRegexp.all) {
+				continue;
+			}
+			rootURIsLoop:
+			for(var rootSearchURI in rootSearchURIs) {
+				var isGeneric = !allTranslators[i].webRegexp.root;
+				// don't attempt to use generic translators that can't be run in this browser
+				// since that would require transmitting every page to Zotero host
+				if(isGeneric && allTranslators[i].runMode !== Zotero.Translator.RUN_MODE_IN_BROWSER) {
+					continue;
+				}
+
+				var rootURIMatches = isGeneric || rootSearchURI.length < 8192 && translator.webRegexp.root.test(rootSearchURI);
+				if (translator.webRegexp.all && rootURIMatches) {
+					for (var frameSearchURI in frameSearchURIs) {
+						var frameURIMatches = frameSearchURI.length < 8192 && translator.webRegexp.all.test(frameSearchURI);
+							
+						if (frameURIMatches) {
+							potentialTranslators.push(translator);
+							proxies.push(frameSearchURIs[frameSearchURI]);
+							// prevent adding the translator multiple times
+							break rootURIsLoop;
+						}
+					}
+				} else if(!isFrame && (isGeneric || rootURIMatches)) {
+					potentialTranslators.push(translator);
+					proxies.push(rootSearchURIs[rootSearchURI]);
+					break;
+				}
+			}
+		}
+
+		let codeGetter = new Zotero.Translators.CodeGetter(potentialTranslators);
+		await codeGetter.getAll();
+		return [potentialTranslators, proxies];
+	};
+};
+
+
+/**
+ * A class to get the code for a set of translators at once
+ *
+ * @param {Zotero.Translator[]} translators Translators for which to retrieve code
+ */
+Zotero.Translators.CodeGetter = function(translators) {
+	this._translators = translators;
+	this._concurrency = 2;
+};
+
+Zotero.Translators.CodeGetter.prototype.getCodeFor = async function(i) {
+	let translator = this._translators[i];
+	try {
+		translator.code = await Zotero.Translators.getCodeForTranslator(translator);
+	} catch (e) {
+		Zotero.debug(`Failed to retrieve code for ${translator.translatorID}`)
+	}
+	return translator.code;
+};
+
+Zotero.Translators.CodeGetter.prototype.getAll = async function () {
+	let codes = [];
+	// Chain promises with some level of concurrency. If unchained, fires 
+	// off hundreds of xhttprequests on connectors and crashes the extension
+	for (let i = 0; i < this._translators.length; i++) {
+		if (i < this._concurrency) {
+			codes.push(this.getCodeFor(i));
+		} else {
+			codes.push(codes[i-this._concurrency].then(() => this.getCodeFor(i)));
+		}
+	}
+	return Promise.all(codes);
+};
+
+if (typeof process === 'object' && process + '' === '[object process]'){
+	module.exports = Zotero.Translators;
+}