From f11283de83195d2aee4bbbdc9651305bcdba478e Mon Sep 17 00:00:00 2001 From: Dan Vanderkam Date: Fri, 23 Nov 2012 21:17:26 -0500 Subject: [PATCH] lots of type defintions in dygraph-utils.js; down to 8 compiler warnings --- dygraph-externs.js | 34 ++++++ dygraph-utils.js | 333 +++++++++++++++++++++++++++++++++-------------------- 2 files changed, 245 insertions(+), 122 deletions(-) create mode 100644 dygraph-externs.js diff --git a/dygraph-externs.js b/dygraph-externs.js new file mode 100644 index 0000000..71515cd --- /dev/null +++ b/dygraph-externs.js @@ -0,0 +1,34 @@ +/** + * @param {Object} dict + * @return {!Array.} + */ +function printStackTrace(dict) {} + + +/** + * @constructor + */ +function G_vmlCanvasManager() {} + +/** + * @param {!HTMLCanvasElement} canvas + */ +G_vmlCanvasManager.initElement = function(canvas) {}; + +// For IE +/** + * @param {string} type + * @param {Object} fn + */ +Element.prototype.detachEvent = function(type, fn) {}; + + +// TODO(danvk): move the Dygraph definitions out of here once I closure-ify dygraphs.js + +/** + * @constructor + */ +function Dygraph() {} + +/** @type {Array.<{elem:Element,type:string,fn:function(!Event):(boolean|undefined|null)}>} */ +Dygraph.prototype.registeredEvents_; diff --git a/dygraph-utils.js b/dygraph-utils.js index 04d2ae3..2a86b24 100644 --- a/dygraph-utils.js +++ b/dygraph-utils.js @@ -18,7 +18,11 @@ Dygraph.LOG_SCALE = 10; Dygraph.LN_TEN = Math.log(Dygraph.LOG_SCALE); -/** @private */ +/** + * @private + * @param {number} x + * @return {number} + */ Dygraph.log10 = function(x) { return Math.log(x) / Dygraph.LN_TEN; }; @@ -43,10 +47,10 @@ Dygraph.DASHED_LINE = [7, 3]; Dygraph.DOT_DASH_LINE = [7, 2, 2, 2]; /** - * @private * Log an error on the JS console at the given severity. - * @param { Integer } severity One of Dygraph.{DEBUG,INFO,WARNING,ERROR} - * @param { String } The message to log. + * @param {number} severity One of Dygraph.{DEBUG,INFO,WARNING,ERROR} + * @param {string} message The message to log. + * @private */ Dygraph.log = function(severity, message) { var st; @@ -71,51 +75,68 @@ Dygraph.log = function(severity, message) { } } - if (typeof(console) != 'undefined') { + if (typeof(window.console) != 'undefined') { switch (severity) { case Dygraph.DEBUG: - console.debug('dygraphs: ' + message); + window.console.debug('dygraphs: ' + message); break; case Dygraph.INFO: - console.info('dygraphs: ' + message); + window.console.info('dygraphs: ' + message); break; case Dygraph.WARNING: - console.warn('dygraphs: ' + message); + window.console.warn('dygraphs: ' + message); break; case Dygraph.ERROR: - console.error('dygraphs: ' + message); + window.console.error('dygraphs: ' + message); break; } } if (Dygraph.LOG_STACK_TRACES) { - console.log(st.join('\n')); + window.console.log(st.join('\n')); } }; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.info = function(message) { Dygraph.log(Dygraph.INFO, message); }; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.prototype.info = Dygraph.info; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.warn = function(message) { Dygraph.log(Dygraph.WARNING, message); }; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.prototype.warn = Dygraph.warn; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.error = function(message) { Dygraph.log(Dygraph.ERROR, message); }; -/** @private */ +/** + * @param {string} message + * @private + */ Dygraph.prototype.error = Dygraph.error; /** - * @private * Return the 2d context for a dygraph canvas. * * This method is only exposed for the sake of replacing the function in @@ -126,19 +147,22 @@ Dygraph.prototype.error = Dygraph.error; * var realContext = oldFunc(canvas); * return new Proxy(realContext); * }; + * @param {!HTMLCanvasElement} canvas + * @return {!CanvasRenderingContext2D} + * @private */ Dygraph.getContext = function(canvas) { - return canvas.getContext("2d"); + return /** @type{!CanvasRenderingContext2D}*/(canvas.getContext("2d")); }; /** - * @private * Add an event handler. This smooths a difference between IE and the rest of * the world. - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. + * @param { !Element } elem The element to add the event to. + * @param { string } type The type of the event, e.g. 'click' or 'mousemove'. + * @param { function(Event):(boolean|undefined) } fn The function to call + * on the event. The function takes one parameter: the event object. + * @private */ Dygraph.addEvent = function addEvent(elem, type, fn) { if (elem.addEventListener) { @@ -150,14 +174,14 @@ Dygraph.addEvent = function addEvent(elem, type, fn) { }; /** - * @private * Add an event handler. This event handler is kept until the graph is * destroyed with a call to graph.destroy(). * - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. + * @param { !Element } elem The element to add the event to. + * @param { string } type The type of the event, e.g. 'click' or 'mousemove'. + * @param { function(Event):(boolean|undefined) } fn The function to call + * on the event. The function takes one parameter: the event object. + * @private */ Dygraph.prototype.addEvent = function addEvent(elem, type, fn) { Dygraph.addEvent(elem, type, fn); @@ -165,13 +189,13 @@ Dygraph.prototype.addEvent = function addEvent(elem, type, fn) { }; /** + * Remove an event handler. This smooths a difference between IE and the rest + * of the world. + * @param {!Element} elem The element to add the event to. + * @param {string} type The type of the event, e.g. 'click' or 'mousemove'. + * @param {function(Event):(boolean|undefined)} fn The function to call + * on the event. The function takes one parameter: the event object. * @private - * Remove an event handler. This smooths a difference between IE and the rest of - * the world. - * @param { DOM element } elem The element to add the event to. - * @param { String } type The type of the event, e.g. 'click' or 'mousemove'. - * @param { Function } fn The function to call on the event. The function takes - * one parameter: the event object. */ Dygraph.removeEvent = function addEvent(elem, type, fn) { if (elem.removeEventListener) { @@ -188,12 +212,12 @@ Dygraph.removeEvent = function addEvent(elem, type, fn) { }; /** - * @private * Cancels further processing of an event. This is useful to prevent default * browser actions, e.g. highlighting text on a double-click. * Based on the article at * http://www.switchonthecode.com/tutorials/javascript-tutorial-the-scroll-wheel - * @param { Event } e The event whose normal behavior should be canceled. + * @param { !Event } e The event whose normal behavior should be canceled. + * @private */ Dygraph.cancelEvent = function(e) { e = e ? e : window.event; @@ -213,10 +237,10 @@ Dygraph.cancelEvent = function(e) { * Convert hsv values to an rgb(r,g,b) string. Taken from MochiKit.Color. This * is used to generate default series colors which are evenly spaced on the * color wheel. - * @param { Number } hue Range is 0.0-1.0. - * @param { Number } saturation Range is 0.0-1.0. - * @param { Number } value Range is 0.0-1.0. - * @return { String } "rgb(r,g,b)" where r, g and b range from 0-255. + * @param { number } hue Range is 0.0-1.0. + * @param { number } saturation Range is 0.0-1.0. + * @param { number } value Range is 0.0-1.0. + * @return { string } "rgb(r,g,b)" where r, g and b range from 0-255. * @private */ Dygraph.hsvToRGB = function (hue, saturation, value) { @@ -257,6 +281,9 @@ Dygraph.hsvToRGB = function (hue, saturation, value) { /** * Find the x-coordinate of the supplied object relative to the left side * of the page. + * TODO(danvk): change obj type from Node -> !Node + * @param {Node} obj + * @return {number} * @private */ Dygraph.findPosX = function(obj) { @@ -284,6 +311,10 @@ Dygraph.findPosX = function(obj) { /** * Find the y-coordinate of the supplied object relative to the top of the * page. + * TODO(danvk): change obj type from Node -> !Node + * TODO(danvk): consolidate with findPosX and return an {x, y} object. + * @param {Node} obj + * @return {number} * @private */ Dygraph.findPosY = function(obj) { @@ -309,16 +340,18 @@ Dygraph.findPosY = function(obj) { }; /** - * @private * Returns the x-coordinate of the event in a coordinate system where the * top-left corner of the page (not the window) is (0,0). * Taken from MochiKit.Signal + * @param {!Event} e + * @return {number} + * @private */ Dygraph.pageX = function(e) { if (e.pageX) { return (!e.pageX || e.pageX < 0) ? 0 : e.pageX; } else { - var de = document; + var de = document.documentElement; var b = document.body; return e.clientX + (de.scrollLeft || b.scrollLeft) - @@ -327,16 +360,18 @@ Dygraph.pageX = function(e) { }; /** - * @private * Returns the y-coordinate of the event in a coordinate system where the * top-left corner of the page (not the window) is (0,0). * Taken from MochiKit.Signal + * @param {!Event} e + * @return {number} + * @private */ Dygraph.pageY = function(e) { if (e.pageY) { return (!e.pageY || e.pageY < 0) ? 0 : e.pageY; } else { - var de = document; + var de = document.documentElement; var b = document.body; return e.clientY + (de.scrollTop || b.scrollTop) - @@ -345,25 +380,27 @@ Dygraph.pageY = function(e) { }; /** + * This returns true unless the parameter is 0, null, undefined or NaN. + * TODO(danvk): rename this function to something like 'isNonZeroNan'. + * + * @param {number} x The number to consider. + * @return {boolean} Whether the number is zero or NaN. * @private - * @param { Number } x The number to consider. - * @return { Boolean } Whether the number is zero or NaN. */ -// TODO(danvk): rename this function to something like 'isNonZeroNan'. -// TODO(danvk): determine when else this returns false (e.g. for undefined or null) Dygraph.isOK = function(x) { - return x && !isNaN(x); + return !!x && !isNaN(x); }; /** + * @param { {x:?number,y:?number,yval:?number} } p The point to consider, valid + * points are {x, y} objects + * @param { boolean } allowNaNY Treat point with y=NaN as valid + * @return { boolean } Whether the point has numeric x and y. * @private - * @param { Object } p The point to consider, valid points are {x, y} objects - * @param { Boolean } allowNaNY Treat point with y=NaN as valid - * @return { Boolean } Whether the point has numeric x and y. */ Dygraph.isValidPoint = function(p, allowNaNY) { - if (!p) return false; // null or undefined object - if (p.yval === null) return false; // missing point + if (!p) return false; // null or undefined object + if (p.yval === null) return false; // missing point if (p.x === null || p.x === undefined) return false; if (p.y === null || p.y === undefined) return false; if (isNaN(p.x) || (!allowNaNY && isNaN(p.y))) return false; @@ -383,9 +420,9 @@ Dygraph.isValidPoint = function(p, allowNaNY) { * 10^-6, e.g. '0.00001' instead of '1e-5'. See tests/number-format.html for * output examples. * - * @param {Number} x The number to format - * @param {Number} opt_precision The precision to use, default 2. - * @return {String} A string formatted like %g in printf. The max generated + * @param {number} x The number to format + * @param {number=} opt_precision The precision to use, default 2. + * @return {string} A string formatted like %g in printf. The max generated * string length should be precision + 6 (e.g 1.123e+300). */ Dygraph.floatFormat = function(x, opt_precision) { @@ -413,8 +450,10 @@ Dygraph.floatFormat = function(x, opt_precision) { }; /** - * @private * Converts '9' to '09' (useful for dates) + * @param {number} x + * @return {string} + * @private */ Dygraph.zeropad = function(x) { if (x < 10) return "0" + x; else return "" + x; @@ -422,8 +461,9 @@ Dygraph.zeropad = function(x) { /** * Return a string version of the hours, minutes and seconds portion of a date. - * @param {Number} date The JavaScript date (ms since epoch) - * @return {String} A time of the form "HH:MM:SS" + * + * @param {number} date The JavaScript date (ms since epoch) + * @return {string} A time of the form "HH:MM:SS" * @private */ Dygraph.hmsString_ = function(date) { @@ -440,9 +480,9 @@ Dygraph.hmsString_ = function(date) { /** * Round a number to the specified number of digits past the decimal point. - * @param {Number} num The number to round - * @param {Number} places The number of decimals to which to round - * @return {Number} The rounded number + * @param {number} num The number to round + * @param {number} places The number of decimals to which to round + * @return {number} The rounded number * @private */ Dygraph.round_ = function(num, places) { @@ -451,16 +491,17 @@ Dygraph.round_ = function(num, places) { }; /** - * @private * Implementation of binary search over an array. * Currently does not work when val is outside the range of arry's values. - * @param { Integer } val the value to search for - * @param { Integer[] } arry is the value over which to search - * @param { Integer } abs If abs > 0, find the lowest entry greater than val - * If abs < 0, find the highest entry less than val. - * if abs == 0, find the entry that equals val. - * @param { Integer } [low] The first index in arry to consider (optional) - * @param { Integer } [high] The last index in arry to consider (optional) + * @param {number} val the value to search for + * @param {Array.} arry is the value over which to search + * @param {number} abs If abs > 0, find the lowest entry greater than val + * If abs < 0, find the highest entry less than val. + * If abs == 0, find the entry that equals val. + * @param {number=} low The first index in arry to consider (optional) + * @param {number=} high The last index in arry to consider (optional) + * @return {number} Index of the element, or -1 if it isn't found. + * @private */ Dygraph.binarySearch = function(val, arry, abs, low, high) { if (low === null || low === undefined || @@ -479,12 +520,10 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { }; var mid = parseInt((low + high) / 2, 10); var element = arry[mid]; + var idx; if (element == val) { return mid; - } - - var idx; - if (element > val) { + } else if (element > val) { if (abs > 0) { // Accept if element > val, but also if prior element < val. idx = mid - 1; @@ -493,8 +532,7 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { } } return Dygraph.binarySearch(val, arry, abs, low, mid - 1); - } - if (element < val) { + } else if (element < val) { if (abs < 0) { // Accept if element < val, but also if prior element > val. idx = mid + 1; @@ -504,15 +542,17 @@ Dygraph.binarySearch = function(val, arry, abs, low, high) { } return Dygraph.binarySearch(val, arry, abs, mid + 1, high); } + return -1; // can't actually happen, but makes closure compiler happy }; /** - * @private * Parses a date, returning the number of milliseconds since epoch. This can be * passed in as an xValueParser in the Dygraph constructor. * TODO(danvk): enumerate formats that this understands. - * @param {String} A date in YYYYMMDD format. - * @return {Number} Milliseconds since epoch. + * + * @param {string} dateStr A date in a variety of possible string formats. + * @return {number} Milliseconds since epoch. + * @private */ Dygraph.dateParser = function(dateStr) { var dateStrSlashed; @@ -554,12 +594,12 @@ Dygraph.dateParser = function(dateStr) { }; /** - * @private * This is identical to JavaScript's built-in Date.parse() method, except that * it doesn't get replaced with an incompatible method by aggressive JS * libraries like MooTools or Joomla. - * @param { String } str The date string, e.g. "2011/05/06" - * @return { Integer } millis since epoch + * @param {string} str The date string, e.g. "2011/05/06" + * @return {number} millis since epoch + * @private */ Dygraph.dateStrToMillis = function(str) { return new Date(str).getTime(); @@ -569,9 +609,12 @@ Dygraph.dateStrToMillis = function(str) { /** * Copies all the properties from o to self. * + * @param {!Object} self + * @param {!Object} o + * @return {!Object} * @private */ -Dygraph.update = function (self, o) { +Dygraph.update = function(self, o) { if (typeof(o) != 'undefined' && o !== null) { for (var k in o) { if (o.hasOwnProperty(k)) { @@ -585,6 +628,9 @@ Dygraph.update = function (self, o) { /** * Copies all the properties from o to self. * + * @param {!Object} self + * @param {!Object} o + * @return {!Object} * @private */ Dygraph.updateDeep = function (self, o) { @@ -621,9 +667,11 @@ Dygraph.updateDeep = function (self, o) { }; /** + * @param {Object} o + * @return {boolean} * @private */ -Dygraph.isArrayLike = function (o) { +Dygraph.isArrayLike = function(o) { var typ = typeof(o); if ( (typ != 'object' && !(typ == 'function' && @@ -638,6 +686,8 @@ Dygraph.isArrayLike = function (o) { }; /** + * @param {Object} o + * @return {boolean} * @private */ Dygraph.isDateLike = function (o) { @@ -650,6 +700,8 @@ Dygraph.isDateLike = function (o) { /** * Note: this only seems to work for arrays. + * @param {!Array} o + * @return {!Array} * @private */ Dygraph.clone = function(o) { @@ -666,30 +718,43 @@ Dygraph.clone = function(o) { }; /** - * @private * Create a new canvas element. This is more complex than a simple * document.createElement("canvas") because of IE and excanvas. + * + * @return {!HTMLCanvasElement} + * @private */ Dygraph.createCanvas = function() { var canvas = document.createElement("canvas"); var isIE = (/MSIE/.test(navigator.userAgent) && !window.opera); if (isIE && (typeof(G_vmlCanvasManager) != 'undefined')) { - canvas = G_vmlCanvasManager.initElement(canvas); + canvas = G_vmlCanvasManager.initElement( + /**@type{!HTMLCanvasElement}*/(canvas)); } return canvas; }; /** - * @private * Checks whether the user is on an Android browser. * Android does not fully support the tag, e.g. w/r/t/ clipping. + * @return {boolean} + * @private */ Dygraph.isAndroid = function() { return (/Android/).test(navigator.userAgent); }; + +/** + * TODO(danvk): use @template here when it's better supported for classes. + * @param {!Array} array + * @param {number} start + * @param {number} length + * @param {function(!Array,Object):boolean=} predicate + * @constructor + */ Dygraph.Iterator = function(array, start, length, predicate) { start = start || 0; length = length || array.length; @@ -703,6 +768,9 @@ Dygraph.Iterator = function(array, start, length, predicate) { this.next(); // ignoring result. }; +/** + * @return {Object} + */ Dygraph.Iterator.prototype.next = function() { if (!this.hasNext) { return null; @@ -728,34 +796,33 @@ Dygraph.Iterator.prototype.next = function() { }; /** - * @private * Returns a new iterator over array, between indexes start and * start + length, and only returns entries that pass the accept function * - * @param array the array to iterate over. - * @param start the first index to iterate over, 0 if absent. - * @param length the number of elements in the array to iterate over. - * This, along with start, defines a slice of the array, and so length - * doesn't imply the number of elements in the iterator when accept - * doesn't always accept all values. array.length when absent. - * @param predicate a function that takes parameters array and idx, which - * returns true when the element should be returned. If omitted, all - * elements are accepted. + * @param {!Array} array the array to iterate over. + * @param {number} start the first index to iterate over, 0 if absent. + * @param {number} length the number of elements in the array to iterate over. + * This, along with start, defines a slice of the array, and so length + * doesn't imply the number of elements in the iterator when accept doesn't + * always accept all values. array.length when absent. + * @param {function(Object):boolean=} opt_predicate a function that takes + * parameters array and idx, which returns true when the element should be + * returned. If omitted, all elements are accepted. + * @private */ -Dygraph.createIterator = function(array, start, length, predicate) { - return new Dygraph.Iterator(array, start, length, predicate); +Dygraph.createIterator = function(array, start, length, opt_predicate) { + return new Dygraph.Iterator(array, start, length, opt_predicate); }; /** - * @private * Call a function N times at a given interval, then call a cleanup function * once. repeat_fn is called once immediately, then (times - 1) times * asynchronously. If times=1, then cleanup_fn() is also called synchronously. - * @param repeat_fn {Function} Called repeatedly -- takes the number of calls - * (from 0 to times-1) as an argument. - * @param times {number} The number of times to call repeat_fn - * @param every_ms {number} Milliseconds between calls - * @param cleanup_fn {Function} A function to call after all repeat_fn calls. + * @param {function(number)} repeat_fn Called repeatedly -- takes the number of + * calls (from 0 to times-1) as an argument. + * @param {number} times The number of times to call repeat_fn + * @param {number} every_ms Milliseconds between calls + * @param {function()} cleanup_fn A function to call after all repeat_fn calls. * @private */ Dygraph.repeatAndCleanup = function(repeat_fn, times, every_ms, cleanup_fn) { @@ -784,11 +851,12 @@ Dygraph.repeatAndCleanup = function(repeat_fn, times, every_ms, cleanup_fn) { }; /** - * @private * This function will scan the option list and determine if they * require us to recalculate the pixel positions of each point. - * @param { List } a list of options to check. - * @return { Boolean } true if the graph needs new points else false. + * @param {!Array.} labels a list of options to check. + * @param {!Object} attrs + * @return {boolean} true if the graph needs new points else false. + * @private */ Dygraph.isPixelChangingOptionList = function(labels, attrs) { // A whitelist of options that do not change pixel positions. @@ -892,9 +960,10 @@ Dygraph.isPixelChangingOptionList = function(labels, attrs) { * Compares two arrays to see if they are equal. If either parameter is not an * array it will return false. Does a shallow compare * Dygraph.compareArrays([[1,2], [3, 4]], [[1,2], [3,4]]) === false. - * @param array1 first array - * @param array2 second array - * @return True if both parameters are arrays, and contents are equal. + * @param {!Array.} array1 first array + * @param {!Array.} array2 second array + * @return {boolean} True if both parameters are arrays, and contents are equal. + * @template T */ Dygraph.compareArrays = function(array1, array2) { if (!Dygraph.isArrayLike(array1) || !Dygraph.isArrayLike(array2)) { @@ -912,14 +981,15 @@ Dygraph.compareArrays = function(array1, array2) { }; /** - * ctx: the canvas context - * sides: the number of sides in the shape. - * radius: the radius of the image. - * cx: center x coordate - * cy: center y coordinate - * rotationRadians: the shift of the initial angle, in radians. - * delta: the angle shift for each line. If missing, creates a regular - * polygon. + * @param {!CanvasRenderingContext2D} ctx the canvas context + * @param {number} sides the number of sides in the shape. + * @param {number} radius the radius of the image. + * @param {number} cx center x coordate + * @param {number} cy center y coordinate + * @param {number} rotationRadians the shift of the initial angle, in radians. + * @param {number} delta the angle shift for each line. If missing, creates a + * regular polygon. + * @private */ Dygraph.regularShape_ = function( ctx, sides, radius, cx, cy, rotationRadians, delta) { @@ -951,6 +1021,14 @@ Dygraph.regularShape_ = function( ctx.stroke(); }; +/** + * TODO(danvk): be more specific on the return type. + * @param {number} sides + * @param {number} rotationRadians + * @param {number} delta + * @return {Function} + * @private + */ Dygraph.shapeFunction_ = function(sides, rotationRadians, delta) { return function(g, name, ctx, cx, cy, color, radius) { ctx.strokeStyle = color; @@ -959,6 +1037,17 @@ Dygraph.shapeFunction_ = function(sides, rotationRadians, delta) { }; }; +/** + * @param {number} sides the number of sides in the shape. + * @param {number} rotationRadians the shift of the initial angle, in radians. + * @param {!CanvasRenderingContext2D} ctx the canvas context + * @param {number} cx center x coordate + * @param {number} cy center y coordinate + * @param {string} color stroke color + * @param {number} radius the radius of the image. + * @param {number} delta the angle shift for each line. If missing, creates a + * regular polygon. + */ Dygraph.DrawPolygon_ = function(sides, rotationRadians, ctx, cx, cy, color, radius, delta) { new Dygraph.RegularShape_(sides, rotationRadians, delta).draw(ctx, cx, cy, radius); }; @@ -1039,10 +1128,10 @@ Dygraph.Circles = { * window.addEventListener('mouseup', mouseUpHandler); * }; * - * * @constructor */ Dygraph.IFrameTarp = function() { + /** @type {Array.} */ this.tarps = []; }; @@ -1084,7 +1173,7 @@ Dygraph.IFrameTarp.prototype.uncover = function() { /** * Determine whether |data| is delimited by CR, CRLF, LF, LFCR. * @param {string} data - * @return {string|null} the delimiter that was detected. + * @return {?string} the delimiter that was detected (or null on failure). */ Dygraph.detectLineDelimiter = function(data) { for (var i = 0; i < data.length; i++) { -- 2.7.4