You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@couchdb.apache.org by mi...@apache.org on 2015/09/14 18:32:00 UTC
fauxton commit: updated refs/heads/master to f1a2027
Repository: couchdb-fauxton
Updated Branches:
refs/heads/master e41b78536 -> f1a20274b
Add papaparse.js library
http://papaparse.com/
Project: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/repo
Commit: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/commit/f1a20274
Tree: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/tree/f1a20274
Diff: http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/diff/f1a20274
Branch: refs/heads/master
Commit: f1a20274b24a3951af45e7ef70f41f54dfaff2bd
Parents: e41b785
Author: Michelle Phung <mi...@apache.org>
Authored: Fri Sep 11 17:04:36 2015 -0400
Committer: Michelle Phung <mi...@apache.org>
Committed: Mon Sep 14 12:29:12 2015 -0400
----------------------------------------------------------------------
assets/js/libs/papaparse.js | 1403 ++++++++++++++++++++++++++++++++++++++
1 file changed, 1403 insertions(+)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/couchdb-fauxton/blob/f1a20274/assets/js/libs/papaparse.js
----------------------------------------------------------------------
diff --git a/assets/js/libs/papaparse.js b/assets/js/libs/papaparse.js
new file mode 100755
index 0000000..809f33d
--- /dev/null
+++ b/assets/js/libs/papaparse.js
@@ -0,0 +1,1403 @@
+/*!
+ Papa Parse
+ v4.1.2
+ https://github.com/mholt/PapaParse
+*/
+(function(global)
+{
+ "use strict";
+
+ var IS_WORKER = !global.document && !!global.postMessage,
+ IS_PAPA_WORKER = IS_WORKER && /(\?|&)papaworker(=|&|$)/.test(global.location.search),
+ LOADED_SYNC = false, AUTO_SCRIPT_PATH;
+ var workers = {}, workerIdCounter = 0;
+
+ var Papa = {};
+
+ Papa.parse = CsvToJson;
+ Papa.unparse = JsonToCsv;
+
+ Papa.RECORD_SEP = String.fromCharCode(30);
+ Papa.UNIT_SEP = String.fromCharCode(31);
+ Papa.BYTE_ORDER_MARK = "\ufeff";
+ Papa.BAD_DELIMITERS = ["\r", "\n", "\"", Papa.BYTE_ORDER_MARK];
+ Papa.WORKERS_SUPPORTED = !IS_WORKER && !!global.Worker;
+ Papa.SCRIPT_PATH = null; // Must be set by your code if you use workers and this lib is loaded asynchronously
+
+ // Configurable chunk sizes for local and remote files, respectively
+ Papa.LocalChunkSize = 1024 * 1024 * 10; // 10 MB
+ Papa.RemoteChunkSize = 1024 * 1024 * 5; // 5 MB
+ Papa.DefaultDelimiter = ","; // Used if not specified and detection fails
+
+ // Exposed for testing and development only
+ Papa.Parser = Parser;
+ Papa.ParserHandle = ParserHandle;
+ Papa.NetworkStreamer = NetworkStreamer;
+ Papa.FileStreamer = FileStreamer;
+ Papa.StringStreamer = StringStreamer;
+
+ if (typeof module !== 'undefined' && module.exports)
+ {
+ // Export to Node...
+ module.exports = Papa;
+ }
+ else if (isFunction(global.define) && global.define.amd)
+ {
+ // Wireup with RequireJS
+ define(function() { return Papa; });
+ }
+ else
+ {
+ // ...or as browser global
+ global.Papa = Papa;
+ }
+
+ if (global.jQuery)
+ {
+ var $ = global.jQuery;
+ $.fn.parse = function(options)
+ {
+ var config = options.config || {};
+ var queue = [];
+
+ this.each(function(idx)
+ {
+ var supported = $(this).prop('tagName').toUpperCase() == "INPUT"
+ && $(this).attr('type').toLowerCase() == "file"
+ && global.FileReader;
+
+ if (!supported || !this.files || this.files.length == 0)
+ return true; // continue to next input element
+
+ for (var i = 0; i < this.files.length; i++)
+ {
+ queue.push({
+ file: this.files[i],
+ inputElem: this,
+ instanceConfig: $.extend({}, config)
+ });
+ }
+ });
+
+ parseNextFile(); // begin parsing
+ return this; // maintains chainability
+
+
+ function parseNextFile()
+ {
+ if (queue.length == 0)
+ {
+ if (isFunction(options.complete))
+ options.complete();
+ return;
+ }
+
+ var f = queue[0];
+
+ if (isFunction(options.before))
+ {
+ var returned = options.before(f.file, f.inputElem);
+
+ if (typeof returned === 'object')
+ {
+ if (returned.action == "abort")
+ {
+ error("AbortError", f.file, f.inputElem, returned.reason);
+ return; // Aborts all queued files immediately
+ }
+ else if (returned.action == "skip")
+ {
+ fileComplete(); // parse the next file in the queue, if any
+ return;
+ }
+ else if (typeof returned.config === 'object')
+ f.instanceConfig = $.extend(f.instanceConfig, returned.config);
+ }
+ else if (returned == "skip")
+ {
+ fileComplete(); // parse the next file in the queue, if any
+ return;
+ }
+ }
+
+ // Wrap up the user's complete callback, if any, so that ours also gets executed
+ var userCompleteFunc = f.instanceConfig.complete;
+ f.instanceConfig.complete = function(results)
+ {
+ if (isFunction(userCompleteFunc))
+ userCompleteFunc(results, f.file, f.inputElem);
+ fileComplete();
+ };
+
+ Papa.parse(f.file, f.instanceConfig);
+ }
+
+ function error(name, file, elem, reason)
+ {
+ if (isFunction(options.error))
+ options.error({name: name}, file, elem, reason);
+ }
+
+ function fileComplete()
+ {
+ queue.splice(0, 1);
+ parseNextFile();
+ }
+ }
+ }
+
+
+ if (IS_PAPA_WORKER)
+ {
+ global.onmessage = workerThreadReceivedMessage;
+ }
+ else if (Papa.WORKERS_SUPPORTED)
+ {
+ AUTO_SCRIPT_PATH = getScriptPath();
+
+ // Check if the script was loaded synchronously
+ if (!document.body)
+ {
+ // Body doesn't exist yet, must be synchronous
+ LOADED_SYNC = true;
+ }
+ else
+ {
+ document.addEventListener('DOMContentLoaded', function () {
+ LOADED_SYNC = true;
+ }, true);
+ }
+ }
+
+
+
+
+ function CsvToJson(_input, _config)
+ {
+ _config = _config || {};
+
+ if (_config.worker && Papa.WORKERS_SUPPORTED)
+ {
+ var w = newWorker();
+
+ w.userStep = _config.step;
+ w.userChunk = _config.chunk;
+ w.userComplete = _config.complete;
+ w.userError = _config.error;
+
+ _config.step = isFunction(_config.step);
+ _config.chunk = isFunction(_config.chunk);
+ _config.complete = isFunction(_config.complete);
+ _config.error = isFunction(_config.error);
+ delete _config.worker; // prevent infinite loop
+
+ w.postMessage({
+ input: _input,
+ config: _config,
+ workerId: w.id
+ });
+
+ return;
+ }
+
+ var streamer = null;
+ if (typeof _input === 'string')
+ {
+ if (_config.download)
+ streamer = new NetworkStreamer(_config);
+ else
+ streamer = new StringStreamer(_config);
+ }
+ else if ((global.File && _input instanceof File) || _input instanceof Object) // ...Safari. (see issue #106)
+ streamer = new FileStreamer(_config);
+
+ return streamer.stream(_input);
+ }
+
+
+
+
+
+
+ function JsonToCsv(_input, _config)
+ {
+ var _output = "";
+ var _fields = [];
+
+ // Default configuration
+
+ /** whether to surround every datum with quotes */
+ var _quotes = false;
+
+ /** delimiting character */
+ var _delimiter = ",";
+
+ /** newline character(s) */
+ var _newline = "\r\n";
+
+ unpackConfig();
+
+ if (typeof _input === 'string')
+ _input = JSON.parse(_input);
+
+ if (_input instanceof Array)
+ {
+ if (!_input.length || _input[0] instanceof Array)
+ return serialize(null, _input);
+ else if (typeof _input[0] === 'object')
+ return serialize(objectKeys(_input[0]), _input);
+ }
+ else if (typeof _input === 'object')
+ {
+ if (typeof _input.data === 'string')
+ _input.data = JSON.parse(_input.data);
+
+ if (_input.data instanceof Array)
+ {
+ if (!_input.fields)
+ _input.fields = _input.data[0] instanceof Array
+ ? _input.fields
+ : objectKeys(_input.data[0]);
+
+ if (!(_input.data[0] instanceof Array) && typeof _input.data[0] !== 'object')
+ _input.data = [_input.data]; // handles input like [1,2,3] or ["asdf"]
+ }
+
+ return serialize(_input.fields || [], _input.data || []);
+ }
+
+ // Default (any valid paths should return before this)
+ throw "exception: Unable to serialize unrecognized input";
+
+
+ function unpackConfig()
+ {
+ if (typeof _config !== 'object')
+ return;
+
+ if (typeof _config.delimiter === 'string'
+ && _config.delimiter.length == 1
+ && Papa.BAD_DELIMITERS.indexOf(_config.delimiter) == -1)
+ {
+ _delimiter = _config.delimiter;
+ }
+
+ if (typeof _config.quotes === 'boolean'
+ || _config.quotes instanceof Array)
+ _quotes = _config.quotes;
+
+ if (typeof _config.newline === 'string')
+ _newline = _config.newline;
+ }
+
+
+ /** Turns an object's keys into an array */
+ function objectKeys(obj)
+ {
+ if (typeof obj !== 'object')
+ return [];
+ var keys = [];
+ for (var key in obj)
+ keys.push(key);
+ return keys;
+ }
+
+ /** The double for loop that iterates the data and writes out a CSV string including header row */
+ function serialize(fields, data)
+ {
+ var csv = "";
+
+ if (typeof fields === 'string')
+ fields = JSON.parse(fields);
+ if (typeof data === 'string')
+ data = JSON.parse(data);
+
+ var hasHeader = fields instanceof Array && fields.length > 0;
+ var dataKeyedByField = !(data[0] instanceof Array);
+
+ // If there a header row, write it first
+ if (hasHeader)
+ {
+ for (var i = 0; i < fields.length; i++)
+ {
+ if (i > 0)
+ csv += _delimiter;
+ csv += safe(fields[i], i);
+ }
+ if (data.length > 0)
+ csv += _newline;
+ }
+
+ // Then write out the data
+ for (var row = 0; row < data.length; row++)
+ {
+ var maxCol = hasHeader ? fields.length : data[row].length;
+
+ for (var col = 0; col < maxCol; col++)
+ {
+ if (col > 0)
+ csv += _delimiter;
+ var colIdx = hasHeader && dataKeyedByField ? fields[col] : col;
+ csv += safe(data[row][colIdx], col);
+ }
+
+ if (row < data.length - 1)
+ csv += _newline;
+ }
+
+ return csv;
+ }
+
+ /** Encloses a value around quotes if needed (makes a value safe for CSV insertion) */
+ function safe(str, col)
+ {
+ if (typeof str === "undefined" || str === null)
+ return "";
+
+ str = str.toString().replace(/"/g, '""');
+
+ var needsQuotes = (typeof _quotes === 'boolean' && _quotes)
+ || (_quotes instanceof Array && _quotes[col])
+ || hasAny(str, Papa.BAD_DELIMITERS)
+ || str.indexOf(_delimiter) > -1
+ || str.charAt(0) == ' '
+ || str.charAt(str.length - 1) == ' ';
+
+ return needsQuotes ? '"' + str + '"' : str;
+ }
+
+ function hasAny(str, substrings)
+ {
+ for (var i = 0; i < substrings.length; i++)
+ if (str.indexOf(substrings[i]) > -1)
+ return true;
+ return false;
+ }
+ }
+
+ /** ChunkStreamer is the base prototype for various streamer implementations. */
+ function ChunkStreamer(config)
+ {
+ this._handle = null;
+ this._paused = false;
+ this._finished = false;
+ this._input = null;
+ this._baseIndex = 0;
+ this._partialLine = "";
+ this._rowCount = 0;
+ this._start = 0;
+ this._nextChunk = null;
+ this.isFirstChunk = true;
+ this._completeResults = {
+ data: [],
+ errors: [],
+ meta: {}
+ };
+ replaceConfig.call(this, config);
+
+ this.parseChunk = function(chunk)
+ {
+ // First chunk pre-processing
+ if (this.isFirstChunk && isFunction(this._config.beforeFirstChunk))
+ {
+ var modifiedChunk = this._config.beforeFirstChunk(chunk);
+ if (modifiedChunk !== undefined)
+ chunk = modifiedChunk;
+ }
+ this.isFirstChunk = false;
+
+ // Rejoin the line we likely just split in two by chunking the file
+ var aggregate = this._partialLine + chunk;
+ this._partialLine = "";
+
+ var results = this._handle.parse(aggregate, this._baseIndex, !this._finished);
+
+ if (this._handle.paused() || this._handle.aborted())
+ return;
+
+ var lastIndex = results.meta.cursor;
+
+ if (!this._finished)
+ {
+ this._partialLine = aggregate.substring(lastIndex - this._baseIndex);
+ this._baseIndex = lastIndex;
+ }
+
+ if (results && results.data)
+ this._rowCount += results.data.length;
+
+ var finishedIncludingPreview = this._finished || (this._config.preview && this._rowCount >= this._config.preview);
+
+ if (IS_PAPA_WORKER)
+ {
+ global.postMessage({
+ results: results,
+ workerId: Papa.WORKER_ID,
+ finished: finishedIncludingPreview
+ });
+ }
+ else if (isFunction(this._config.chunk))
+ {
+ this._config.chunk(results, this._handle);
+ if (this._paused)
+ return;
+ results = undefined;
+ this._completeResults = undefined;
+ }
+
+ if (!this._config.step && !this._config.chunk) {
+ this._completeResults.data = this._completeResults.data.concat(results.data);
+ this._completeResults.errors = this._completeResults.errors.concat(results.errors);
+ this._completeResults.meta = results.meta;
+ }
+
+ if (finishedIncludingPreview && isFunction(this._config.complete) && (!results || !results.meta.aborted))
+ this._config.complete(this._completeResults);
+
+ if (!finishedIncludingPreview && (!results || !results.meta.paused))
+ this._nextChunk();
+
+ return results;
+ };
+
+ this._sendError = function(error)
+ {
+ if (isFunction(this._config.error))
+ this._config.error(error);
+ else if (IS_PAPA_WORKER && this._config.error)
+ {
+ global.postMessage({
+ workerId: Papa.WORKER_ID,
+ error: error,
+ finished: false
+ });
+ }
+ };
+
+ function replaceConfig(config)
+ {
+ // Deep-copy the config so we can edit it
+ var configCopy = copy(config);
+ configCopy.chunkSize = parseInt(configCopy.chunkSize); // parseInt VERY important so we don't concatenate strings!
+ if (!config.step && !config.chunk)
+ configCopy.chunkSize = null; // disable Range header if not streaming; bad values break IIS - see issue #196
+ this._handle = new ParserHandle(configCopy);
+ this._handle.streamer = this;
+ this._config = configCopy; // persist the copy to the caller
+ }
+ }
+
+
+ function NetworkStreamer(config)
+ {
+ config = config || {};
+ if (!config.chunkSize)
+ config.chunkSize = Papa.RemoteChunkSize;
+ ChunkStreamer.call(this, config);
+
+ var xhr;
+
+ if (IS_WORKER)
+ {
+ this._nextChunk = function()
+ {
+ this._readChunk();
+ this._chunkLoaded();
+ };
+ }
+ else
+ {
+ this._nextChunk = function()
+ {
+ this._readChunk();
+ };
+ }
+
+ this.stream = function(url)
+ {
+ this._input = url;
+ this._nextChunk(); // Starts streaming
+ };
+
+ this._readChunk = function()
+ {
+ if (this._finished)
+ {
+ this._chunkLoaded();
+ return;
+ }
+
+ xhr = new XMLHttpRequest();
+
+ if (!IS_WORKER)
+ {
+ xhr.onload = bindFunction(this._chunkLoaded, this);
+ xhr.onerror = bindFunction(this._chunkError, this);
+ }
+
+ xhr.open("GET", this._input, !IS_WORKER);
+
+ if (this._config.chunkSize)
+ {
+ var end = this._start + this._config.chunkSize - 1; // minus one because byte range is inclusive
+ xhr.setRequestHeader("Range", "bytes="+this._start+"-"+end);
+ xhr.setRequestHeader("If-None-Match", "webkit-no-cache"); // https://bugs.webkit.org/show_bug.cgi?id=82672
+ }
+
+ try {
+ xhr.send();
+ }
+ catch (err) {
+ this._chunkError(err.message);
+ }
+
+ if (IS_WORKER && xhr.status == 0)
+ this._chunkError();
+ else
+ this._start += this._config.chunkSize;
+ }
+
+ this._chunkLoaded = function()
+ {
+ if (xhr.readyState != 4)
+ return;
+
+ if (xhr.status < 200 || xhr.status >= 400)
+ {
+ this._chunkError();
+ return;
+ }
+
+ this._finished = !this._config.chunkSize || this._start > getFileSize(xhr);
+ this.parseChunk(xhr.responseText);
+ }
+
+ this._chunkError = function(errorMessage)
+ {
+ var errorText = xhr.statusText || errorMessage;
+ this._sendError(errorText);
+ }
+
+ function getFileSize(xhr)
+ {
+ var contentRange = xhr.getResponseHeader("Content-Range");
+ return parseInt(contentRange.substr(contentRange.lastIndexOf("/") + 1));
+ }
+ }
+ NetworkStreamer.prototype = Object.create(ChunkStreamer.prototype);
+ NetworkStreamer.prototype.constructor = NetworkStreamer;
+
+
+ function FileStreamer(config)
+ {
+ config = config || {};
+ if (!config.chunkSize)
+ config.chunkSize = Papa.LocalChunkSize;
+ ChunkStreamer.call(this, config);
+
+ var reader, slice;
+
+ // FileReader is better than FileReaderSync (even in worker) - see http://stackoverflow.com/q/24708649/1048862
+ // But Firefox is a pill, too - see issue #76: https://github.com/mholt/PapaParse/issues/76
+ var usingAsyncReader = typeof FileReader !== 'undefined'; // Safari doesn't consider it a function - see issue #105
+
+ this.stream = function(file)
+ {
+ this._input = file;
+ slice = file.slice || file.webkitSlice || file.mozSlice;
+
+ if (usingAsyncReader)
+ {
+ reader = new FileReader(); // Preferred method of reading files, even in workers
+ reader.onload = bindFunction(this._chunkLoaded, this);
+ reader.onerror = bindFunction(this._chunkError, this);
+ }
+ else
+ reader = new FileReaderSync(); // Hack for running in a web worker in Firefox
+
+ this._nextChunk(); // Starts streaming
+ };
+
+ this._nextChunk = function()
+ {
+ if (!this._finished && (!this._config.preview || this._rowCount < this._config.preview))
+ this._readChunk();
+ }
+
+ this._readChunk = function()
+ {
+ var input = this._input;
+ if (this._config.chunkSize)
+ {
+ var end = Math.min(this._start + this._config.chunkSize, this._input.size);
+ input = slice.call(input, this._start, end);
+ }
+ var txt = reader.readAsText(input, this._config.encoding);
+ if (!usingAsyncReader)
+ this._chunkLoaded({ target: { result: txt } }); // mimic the async signature
+ }
+
+ this._chunkLoaded = function(event)
+ {
+ // Very important to increment start each time before handling results
+ this._start += this._config.chunkSize;
+ this._finished = !this._config.chunkSize || this._start >= this._input.size;
+ this.parseChunk(event.target.result);
+ }
+
+ this._chunkError = function()
+ {
+ this._sendError(reader.error);
+ }
+
+ }
+ FileStreamer.prototype = Object.create(ChunkStreamer.prototype);
+ FileStreamer.prototype.constructor = FileStreamer;
+
+
+ function StringStreamer(config)
+ {
+ config = config || {};
+ ChunkStreamer.call(this, config);
+
+ var string;
+ var remaining;
+ this.stream = function(s)
+ {
+ string = s;
+ remaining = s;
+ return this._nextChunk();
+ }
+ this._nextChunk = function()
+ {
+ if (this._finished) return;
+ var size = this._config.chunkSize;
+ var chunk = size ? remaining.substr(0, size) : remaining;
+ remaining = size ? remaining.substr(size) : '';
+ this._finished = !remaining;
+ return this.parseChunk(chunk);
+ }
+ }
+ StringStreamer.prototype = Object.create(StringStreamer.prototype);
+ StringStreamer.prototype.constructor = StringStreamer;
+
+
+
+ // Use one ParserHandle per entire CSV file or string
+ function ParserHandle(_config)
+ {
+ // One goal is to minimize the use of regular expressions...
+ var FLOAT = /^\s*-?(\d*\.?\d+|\d+\.?\d*)(e[-+]?\d+)?\s*$/i;
+
+ var self = this;
+ var _stepCounter = 0; // Number of times step was called (number of rows parsed)
+ var _input; // The input being parsed
+ var _parser; // The core parser being used
+ var _paused = false; // Whether we are paused or not
+ var _aborted = false; // Whether the parser has aborted or not
+ var _delimiterError; // Temporary state between delimiter detection and processing results
+ var _fields = []; // Fields are from the header row of the input, if there is one
+ var _results = { // The last results returned from the parser
+ data: [],
+ errors: [],
+ meta: {}
+ };
+
+ if (isFunction(_config.step))
+ {
+ var userStep = _config.step;
+ _config.step = function(results)
+ {
+ _results = results;
+
+ if (needsHeaderRow())
+ processResults();
+ else // only call user's step function after header row
+ {
+ processResults();
+
+ // It's possbile that this line was empty and there's no row here after all
+ if (_results.data.length == 0)
+ return;
+
+ _stepCounter += results.data.length;
+ if (_config.preview && _stepCounter > _config.preview)
+ _parser.abort();
+ else
+ userStep(_results, self);
+ }
+ };
+ }
+
+ /**
+ * Parses input. Most users won't need, and shouldn't mess with, the baseIndex
+ * and ignoreLastRow parameters. They are used by streamers (wrapper functions)
+ * when an input comes in multiple chunks, like from a file.
+ */
+ this.parse = function(input, baseIndex, ignoreLastRow)
+ {
+ if (!_config.newline)
+ _config.newline = guessLineEndings(input);
+
+ _delimiterError = false;
+ if (!_config.delimiter)
+ {
+ var delimGuess = guessDelimiter(input);
+ if (delimGuess.successful)
+ _config.delimiter = delimGuess.bestDelimiter;
+ else
+ {
+ _delimiterError = true; // add error after parsing (otherwise it would be overwritten)
+ _config.delimiter = Papa.DefaultDelimiter;
+ }
+ _results.meta.delimiter = _config.delimiter;
+ }
+
+ var parserConfig = copy(_config);
+ if (_config.preview && _config.header)
+ parserConfig.preview++; // to compensate for header row
+
+ _input = input;
+ _parser = new Parser(parserConfig);
+ _results = _parser.parse(_input, baseIndex, ignoreLastRow);
+ processResults();
+ return _paused ? { meta: { paused: true } } : (_results || { meta: { paused: false } });
+ };
+
+ this.paused = function()
+ {
+ return _paused;
+ };
+
+ this.pause = function()
+ {
+ _paused = true;
+ _parser.abort();
+ _input = _input.substr(_parser.getCharIndex());
+ };
+
+ this.resume = function()
+ {
+ _paused = false;
+ self.streamer.parseChunk(_input);
+ };
+
+ this.aborted = function () {
+ return _aborted;
+ }
+
+ this.abort = function()
+ {
+ _aborted = true;
+ _parser.abort();
+ _results.meta.aborted = true;
+ if (isFunction(_config.complete))
+ _config.complete(_results);
+ _input = "";
+ };
+
+ function processResults()
+ {
+ if (_results && _delimiterError)
+ {
+ addError("Delimiter", "UndetectableDelimiter", "Unable to auto-detect delimiting character; defaulted to '"+Papa.DefaultDelimiter+"'");
+ _delimiterError = false;
+ }
+
+ if (_config.skipEmptyLines)
+ {
+ for (var i = 0; i < _results.data.length; i++)
+ if (_results.data[i].length == 1 && _results.data[i][0] == "")
+ _results.data.splice(i--, 1);
+ }
+
+ if (needsHeaderRow())
+ fillHeaderFields();
+
+ return applyHeaderAndDynamicTyping();
+ }
+
+ function needsHeaderRow()
+ {
+ return _config.header && _fields.length == 0;
+ }
+
+ function fillHeaderFields()
+ {
+ if (!_results)
+ return;
+ for (var i = 0; needsHeaderRow() && i < _results.data.length; i++)
+ for (var j = 0; j < _results.data[i].length; j++)
+ _fields.push(_results.data[i][j]);
+ _results.data.splice(0, 1);
+ }
+
+ function applyHeaderAndDynamicTyping()
+ {
+ if (!_results || (!_config.header && !_config.dynamicTyping))
+ return _results;
+
+ for (var i = 0; i < _results.data.length; i++)
+ {
+ var row = {};
+
+ for (var j = 0; j < _results.data[i].length; j++)
+ {
+ if (_config.dynamicTyping)
+ {
+ var value = _results.data[i][j];
+ if (value == "true" || value == "TRUE")
+ _results.data[i][j] = true;
+ else if (value == "false" || value == "FALSE")
+ _results.data[i][j] = false;
+ else
+ _results.data[i][j] = tryParseFloat(value);
+ }
+
+ if (_config.header)
+ {
+ if (j >= _fields.length)
+ {
+ if (!row["__parsed_extra"])
+ row["__parsed_extra"] = [];
+ row["__parsed_extra"].push(_results.data[i][j]);
+ }
+ else
+ row[_fields[j]] = _results.data[i][j];
+ }
+ }
+
+ if (_config.header)
+ {
+ _results.data[i] = row;
+ if (j > _fields.length)
+ addError("FieldMismatch", "TooManyFields", "Too many fields: expected " + _fields.length + " fields but parsed " + j, i);
+ else if (j < _fields.length)
+ addError("FieldMismatch", "TooFewFields", "Too few fields: expected " + _fields.length + " fields but parsed " + j, i);
+ }
+ }
+
+ if (_config.header && _results.meta)
+ _results.meta.fields = _fields;
+ return _results;
+ }
+
+ function guessDelimiter(input)
+ {
+ var delimChoices = [",", "\t", "|", ";", Papa.RECORD_SEP, Papa.UNIT_SEP];
+ var bestDelim, bestDelta, fieldCountPrevRow;
+
+ for (var i = 0; i < delimChoices.length; i++)
+ {
+ var delim = delimChoices[i];
+ var delta = 0, avgFieldCount = 0;
+ fieldCountPrevRow = undefined;
+
+ var preview = new Parser({
+ delimiter: delim,
+ preview: 10
+ }).parse(input);
+
+ for (var j = 0; j < preview.data.length; j++)
+ {
+ var fieldCount = preview.data[j].length;
+ avgFieldCount += fieldCount;
+
+ if (typeof fieldCountPrevRow === 'undefined')
+ {
+ fieldCountPrevRow = fieldCount;
+ continue;
+ }
+ else if (fieldCount > 1)
+ {
+ delta += Math.abs(fieldCount - fieldCountPrevRow);
+ fieldCountPrevRow = fieldCount;
+ }
+ }
+
+ if (preview.data.length > 0)
+ avgFieldCount /= preview.data.length;
+
+ if ((typeof bestDelta === 'undefined' || delta < bestDelta)
+ && avgFieldCount > 1.99)
+ {
+ bestDelta = delta;
+ bestDelim = delim;
+ }
+ }
+
+ _config.delimiter = bestDelim;
+
+ return {
+ successful: !!bestDelim,
+ bestDelimiter: bestDelim
+ }
+ }
+
+ function guessLineEndings(input)
+ {
+ input = input.substr(0, 1024*1024); // max length 1 MB
+
+ var r = input.split('\r');
+
+ if (r.length == 1)
+ return '\n';
+
+ var numWithN = 0;
+ for (var i = 0; i < r.length; i++)
+ {
+ if (r[i][0] == '\n')
+ numWithN++;
+ }
+
+ return numWithN >= r.length / 2 ? '\r\n' : '\r';
+ }
+
+ function tryParseFloat(val)
+ {
+ var isNumber = FLOAT.test(val);
+ return isNumber ? parseFloat(val) : val;
+ }
+
+ function addError(type, code, msg, row)
+ {
+ _results.errors.push({
+ type: type,
+ code: code,
+ message: msg,
+ row: row
+ });
+ }
+ }
+
+
+
+
+
+ /** The core parser implements speedy and correct CSV parsing */
+ function Parser(config)
+ {
+ // Unpack the config object
+ config = config || {};
+ var delim = config.delimiter;
+ var newline = config.newline;
+ var comments = config.comments;
+ var step = config.step;
+ var preview = config.preview;
+ var fastMode = config.fastMode;
+
+ // Delimiter must be valid
+ if (typeof delim !== 'string'
+ || Papa.BAD_DELIMITERS.indexOf(delim) > -1)
+ delim = ",";
+
+ // Comment character must be valid
+ if (comments === delim)
+ throw "Comment character same as delimiter";
+ else if (comments === true)
+ comments = "#";
+ else if (typeof comments !== 'string'
+ || Papa.BAD_DELIMITERS.indexOf(comments) > -1)
+ comments = false;
+
+ // Newline must be valid: \r, \n, or \r\n
+ if (newline != '\n' && newline != '\r' && newline != '\r\n')
+ newline = '\n';
+
+ // We're gonna need these at the Parser scope
+ var cursor = 0;
+ var aborted = false;
+
+ this.parse = function(input, baseIndex, ignoreLastRow)
+ {
+ // For some reason, in Chrome, this speeds things up (!?)
+ if (typeof input !== 'string')
+ throw "Input must be a string";
+
+ // We don't need to compute some of these every time parse() is called,
+ // but having them in a more local scope seems to perform better
+ var inputLen = input.length,
+ delimLen = delim.length,
+ newlineLen = newline.length,
+ commentsLen = comments.length;
+ var stepIsFunction = typeof step === 'function';
+
+ // Establish starting state
+ cursor = 0;
+ var data = [], errors = [], row = [], lastCursor = 0;
+
+ if (!input)
+ return returnable();
+
+ if (fastMode || (fastMode !== false && input.indexOf('"') === -1))
+ {
+ var rows = input.split(newline);
+ for (var i = 0; i < rows.length; i++)
+ {
+ var row = rows[i];
+ cursor += row.length;
+ if (i !== rows.length - 1)
+ cursor += newline.length;
+ else if (ignoreLastRow)
+ return returnable();
+ if (comments && row.substr(0, commentsLen) == comments)
+ continue;
+ if (stepIsFunction)
+ {
+ data = [];
+ pushRow(row.split(delim));
+ doStep();
+ if (aborted)
+ return returnable();
+ }
+ else
+ pushRow(row.split(delim));
+ if (preview && i >= preview)
+ {
+ data = data.slice(0, preview);
+ return returnable(true);
+ }
+ }
+ return returnable();
+ }
+
+ var nextDelim = input.indexOf(delim, cursor);
+ var nextNewline = input.indexOf(newline, cursor);
+
+ // Parser loop
+ for (;;)
+ {
+ // Field has opening quote
+ if (input[cursor] == '"')
+ {
+ // Start our search for the closing quote where the cursor is
+ var quoteSearch = cursor;
+
+ // Skip the opening quote
+ cursor++;
+
+ for (;;)
+ {
+ // Find closing quote
+ var quoteSearch = input.indexOf('"', quoteSearch+1);
+
+ if (quoteSearch === -1)
+ {
+ if (!ignoreLastRow) {
+ // No closing quote... what a pity
+ errors.push({
+ type: "Quotes",
+ code: "MissingQuotes",
+ message: "Quoted field unterminated",
+ row: data.length, // row has yet to be inserted
+ index: cursor
+ });
+ }
+ return finish();
+ }
+
+ if (quoteSearch === inputLen-1)
+ {
+ // Closing quote at EOF
+ var value = input.substring(cursor, quoteSearch).replace(/""/g, '"');
+ return finish(value);
+ }
+
+ // If this quote is escaped, it's part of the data; skip it
+ if (input[quoteSearch+1] == '"')
+ {
+ quoteSearch++;
+ continue;
+ }
+
+ if (input[quoteSearch+1] == delim)
+ {
+ // Closing quote followed by delimiter
+ row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"'));
+ cursor = quoteSearch + 1 + delimLen;
+ nextDelim = input.indexOf(delim, cursor);
+ nextNewline = input.indexOf(newline, cursor);
+ break;
+ }
+
+ if (input.substr(quoteSearch+1, newlineLen) === newline)
+ {
+ // Closing quote followed by newline
+ row.push(input.substring(cursor, quoteSearch).replace(/""/g, '"'));
+ saveRow(quoteSearch + 1 + newlineLen);
+ nextDelim = input.indexOf(delim, cursor); // because we may have skipped the nextDelim in the quoted field
+
+ if (stepIsFunction)
+ {
+ doStep();
+ if (aborted)
+ return returnable();
+ }
+
+ if (preview && data.length >= preview)
+ return returnable(true);
+
+ break;
+ }
+ }
+
+ continue;
+ }
+
+ // Comment found at start of new line
+ if (comments && row.length === 0 && input.substr(cursor, commentsLen) === comments)
+ {
+ if (nextNewline == -1) // Comment ends at EOF
+ return returnable();
+ cursor = nextNewline + newlineLen;
+ nextNewline = input.indexOf(newline, cursor);
+ nextDelim = input.indexOf(delim, cursor);
+ continue;
+ }
+
+ // Next delimiter comes before next newline, so we've reached end of field
+ if (nextDelim !== -1 && (nextDelim < nextNewline || nextNewline === -1))
+ {
+ row.push(input.substring(cursor, nextDelim));
+ cursor = nextDelim + delimLen;
+ nextDelim = input.indexOf(delim, cursor);
+ continue;
+ }
+
+ // End of row
+ if (nextNewline !== -1)
+ {
+ row.push(input.substring(cursor, nextNewline));
+ saveRow(nextNewline + newlineLen);
+
+ if (stepIsFunction)
+ {
+ doStep();
+ if (aborted)
+ return returnable();
+ }
+
+ if (preview && data.length >= preview)
+ return returnable(true);
+
+ continue;
+ }
+
+ break;
+ }
+
+
+ return finish();
+
+
+ function pushRow(row)
+ {
+ data.push(row);
+ lastCursor = cursor;
+ }
+
+ /**
+ * Appends the remaining input from cursor to the end into
+ * row, saves the row, calls step, and returns the results.
+ */
+ function finish(value)
+ {
+ if (ignoreLastRow)
+ return returnable();
+ if (typeof value === 'undefined')
+ value = input.substr(cursor);
+ row.push(value);
+ cursor = inputLen; // important in case parsing is paused
+ pushRow(row);
+ if (stepIsFunction)
+ doStep();
+ return returnable();
+ }
+
+ /**
+ * Appends the current row to the results. It sets the cursor
+ * to newCursor and finds the nextNewline. The caller should
+ * take care to execute user's step function and check for
+ * preview and end parsing if necessary.
+ */
+ function saveRow(newCursor)
+ {
+ cursor = newCursor;
+ pushRow(row);
+ row = [];
+ nextNewline = input.indexOf(newline, cursor);
+ }
+
+ /** Returns an object with the results, errors, and meta. */
+ function returnable(stopped)
+ {
+ return {
+ data: data,
+ errors: errors,
+ meta: {
+ delimiter: delim,
+ linebreak: newline,
+ aborted: aborted,
+ truncated: !!stopped,
+ cursor: lastCursor + (baseIndex || 0)
+ }
+ };
+ }
+
+ /** Executes the user's step function and resets data & errors. */
+ function doStep()
+ {
+ step(returnable());
+ data = [], errors = [];
+ }
+ };
+
+ /** Sets the abort flag */
+ this.abort = function()
+ {
+ aborted = true;
+ };
+
+ /** Gets the cursor position */
+ this.getCharIndex = function()
+ {
+ return cursor;
+ };
+ }
+
+
+ // If you need to load Papa Parse asynchronously and you also need worker threads, hard-code
+ // the script path here. See: https://github.com/mholt/PapaParse/issues/87#issuecomment-57885358
+ function getScriptPath()
+ {
+ var scripts = document.getElementsByTagName('script');
+ return scripts.length ? scripts[scripts.length - 1].src : '';
+ }
+
+ function newWorker()
+ {
+ if (!Papa.WORKERS_SUPPORTED)
+ return false;
+ if (!LOADED_SYNC && Papa.SCRIPT_PATH === null)
+ throw new Error(
+ 'Script path cannot be determined automatically when Papa Parse is loaded asynchronously. ' +
+ 'You need to set Papa.SCRIPT_PATH manually.'
+ );
+ var workerUrl = Papa.SCRIPT_PATH || AUTO_SCRIPT_PATH;
+ // Append "papaworker" to the search string to tell papaparse that this is our worker.
+ workerUrl += (workerUrl.indexOf('?') !== -1 ? '&' : '?') + 'papaworker';
+ var w = new global.Worker(workerUrl);
+ w.onmessage = mainThreadReceivedMessage;
+ w.id = workerIdCounter++;
+ workers[w.id] = w;
+ return w;
+ }
+
+ /** Callback when main thread receives a message */
+ function mainThreadReceivedMessage(e)
+ {
+ var msg = e.data;
+ var worker = workers[msg.workerId];
+ var aborted = false;
+
+ if (msg.error)
+ worker.userError(msg.error, msg.file);
+ else if (msg.results && msg.results.data)
+ {
+ var abort = function() {
+ aborted = true;
+ completeWorker(msg.workerId, { data: [], errors: [], meta: { aborted: true } });
+ };
+
+ var handle = {
+ abort: abort,
+ pause: notImplemented,
+ resume: notImplemented
+ };
+
+ if (isFunction(worker.userStep))
+ {
+ for (var i = 0; i < msg.results.data.length; i++)
+ {
+ worker.userStep({
+ data: [msg.results.data[i]],
+ errors: msg.results.errors,
+ meta: msg.results.meta
+ }, handle);
+ if (aborted)
+ break;
+ }
+ delete msg.results; // free memory ASAP
+ }
+ else if (isFunction(worker.userChunk))
+ {
+ worker.userChunk(msg.results, handle, msg.file);
+ delete msg.results;
+ }
+ }
+
+ if (msg.finished && !aborted)
+ completeWorker(msg.workerId, msg.results);
+ }
+
+ function completeWorker(workerId, results) {
+ var worker = workers[workerId];
+ if (isFunction(worker.userComplete))
+ worker.userComplete(results);
+ worker.terminate();
+ delete workers[workerId];
+ }
+
+ function notImplemented() {
+ throw "Not implemented.";
+ }
+
+ /** Callback when worker thread receives a message */
+ function workerThreadReceivedMessage(e)
+ {
+ var msg = e.data;
+
+ if (typeof Papa.WORKER_ID === 'undefined' && msg)
+ Papa.WORKER_ID = msg.workerId;
+
+ if (typeof msg.input === 'string')
+ {
+ global.postMessage({
+ workerId: Papa.WORKER_ID,
+ results: Papa.parse(msg.input, msg.config),
+ finished: true
+ });
+ }
+ else if ((global.File && msg.input instanceof File) || msg.input instanceof Object) // thank you, Safari (see issue #106)
+ {
+ var results = Papa.parse(msg.input, msg.config);
+ if (results)
+ global.postMessage({
+ workerId: Papa.WORKER_ID,
+ results: results,
+ finished: true
+ });
+ }
+ }
+
+ /** Makes a deep copy of an array or object (mostly) */
+ function copy(obj)
+ {
+ if (typeof obj !== 'object')
+ return obj;
+ var cpy = obj instanceof Array ? [] : {};
+ for (var key in obj)
+ cpy[key] = copy(obj[key]);
+ return cpy;
+ }
+
+ function bindFunction(f, self)
+ {
+ return function() { f.apply(self, arguments); };
+ }
+
+ function isFunction(func)
+ {
+ return typeof func === 'function';
+ }
+})(typeof window !== 'undefined' ? window : this);
\ No newline at end of file