904 lines
32 KiB
JavaScript
904 lines
32 KiB
JavaScript
(function() {
|
|
// If window.HTMLWidgets is already defined, then use it; otherwise create a
|
|
// new object. This allows preceding code to set options that affect the
|
|
// initialization process (though none currently exist).
|
|
window.HTMLWidgets = window.HTMLWidgets || {};
|
|
|
|
// See if we're running in a viewer pane. If not, we're in a web browser.
|
|
var viewerMode = window.HTMLWidgets.viewerMode =
|
|
/\bviewer_pane=1\b/.test(window.location);
|
|
|
|
// See if we're running in Shiny mode. If not, it's a static document.
|
|
// Note that static widgets can appear in both Shiny and static modes, but
|
|
// obviously, Shiny widgets can only appear in Shiny apps/documents.
|
|
var shinyMode = window.HTMLWidgets.shinyMode =
|
|
typeof(window.Shiny) !== "undefined" && !!window.Shiny.outputBindings;
|
|
|
|
// We can't count on jQuery being available, so we implement our own
|
|
// version if necessary.
|
|
function querySelectorAll(scope, selector) {
|
|
if (typeof(jQuery) !== "undefined" && scope instanceof jQuery) {
|
|
return scope.find(selector);
|
|
}
|
|
if (scope.querySelectorAll) {
|
|
return scope.querySelectorAll(selector);
|
|
}
|
|
}
|
|
|
|
function asArray(value) {
|
|
if (value === null)
|
|
return [];
|
|
if ($.isArray(value))
|
|
return value;
|
|
return [value];
|
|
}
|
|
|
|
// Implement jQuery's extend
|
|
function extend(target /*, ... */) {
|
|
if (arguments.length == 1) {
|
|
return target;
|
|
}
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source = arguments[i];
|
|
for (var prop in source) {
|
|
if (source.hasOwnProperty(prop)) {
|
|
target[prop] = source[prop];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
// IE8 doesn't support Array.forEach.
|
|
function forEach(values, callback, thisArg) {
|
|
if (values.forEach) {
|
|
values.forEach(callback, thisArg);
|
|
} else {
|
|
for (var i = 0; i < values.length; i++) {
|
|
callback.call(thisArg, values[i], i, values);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Replaces the specified method with the return value of funcSource.
|
|
//
|
|
// Note that funcSource should not BE the new method, it should be a function
|
|
// that RETURNS the new method. funcSource receives a single argument that is
|
|
// the overridden method, it can be called from the new method. The overridden
|
|
// method can be called like a regular function, it has the target permanently
|
|
// bound to it so "this" will work correctly.
|
|
function overrideMethod(target, methodName, funcSource) {
|
|
var superFunc = target[methodName] || function() {};
|
|
var superFuncBound = function() {
|
|
return superFunc.apply(target, arguments);
|
|
};
|
|
target[methodName] = funcSource(superFuncBound);
|
|
}
|
|
|
|
// Add a method to delegator that, when invoked, calls
|
|
// delegatee.methodName. If there is no such method on
|
|
// the delegatee, but there was one on delegator before
|
|
// delegateMethod was called, then the original version
|
|
// is invoked instead.
|
|
// For example:
|
|
//
|
|
// var a = {
|
|
// method1: function() { console.log('a1'); }
|
|
// method2: function() { console.log('a2'); }
|
|
// };
|
|
// var b = {
|
|
// method1: function() { console.log('b1'); }
|
|
// };
|
|
// delegateMethod(a, b, "method1");
|
|
// delegateMethod(a, b, "method2");
|
|
// a.method1();
|
|
// a.method2();
|
|
//
|
|
// The output would be "b1", "a2".
|
|
function delegateMethod(delegator, delegatee, methodName) {
|
|
var inherited = delegator[methodName];
|
|
delegator[methodName] = function() {
|
|
var target = delegatee;
|
|
var method = delegatee[methodName];
|
|
|
|
// The method doesn't exist on the delegatee. Instead,
|
|
// call the method on the delegator, if it exists.
|
|
if (!method) {
|
|
target = delegator;
|
|
method = inherited;
|
|
}
|
|
|
|
if (method) {
|
|
return method.apply(target, arguments);
|
|
}
|
|
};
|
|
}
|
|
|
|
// Implement a vague facsimilie of jQuery's data method
|
|
function elementData(el, name, value) {
|
|
if (arguments.length == 2) {
|
|
return el["htmlwidget_data_" + name];
|
|
} else if (arguments.length == 3) {
|
|
el["htmlwidget_data_" + name] = value;
|
|
return el;
|
|
} else {
|
|
throw new Error("Wrong number of arguments for elementData: " +
|
|
arguments.length);
|
|
}
|
|
}
|
|
|
|
// http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex
|
|
function escapeRegExp(str) {
|
|
return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&");
|
|
}
|
|
|
|
function hasClass(el, className) {
|
|
var re = new RegExp("\\b" + escapeRegExp(className) + "\\b");
|
|
return re.test(el.className);
|
|
}
|
|
|
|
// elements - array (or array-like object) of HTML elements
|
|
// className - class name to test for
|
|
// include - if true, only return elements with given className;
|
|
// if false, only return elements *without* given className
|
|
function filterByClass(elements, className, include) {
|
|
var results = [];
|
|
for (var i = 0; i < elements.length; i++) {
|
|
if (hasClass(elements[i], className) == include)
|
|
results.push(elements[i]);
|
|
}
|
|
return results;
|
|
}
|
|
|
|
function on(obj, eventName, func) {
|
|
if (obj.addEventListener) {
|
|
obj.addEventListener(eventName, func, false);
|
|
} else if (obj.attachEvent) {
|
|
obj.attachEvent(eventName, func);
|
|
}
|
|
}
|
|
|
|
function off(obj, eventName, func) {
|
|
if (obj.removeEventListener)
|
|
obj.removeEventListener(eventName, func, false);
|
|
else if (obj.detachEvent) {
|
|
obj.detachEvent(eventName, func);
|
|
}
|
|
}
|
|
|
|
// Translate array of values to top/right/bottom/left, as usual with
|
|
// the "padding" CSS property
|
|
// https://developer.mozilla.org/en-US/docs/Web/CSS/padding
|
|
function unpackPadding(value) {
|
|
if (typeof(value) === "number")
|
|
value = [value];
|
|
if (value.length === 1) {
|
|
return {top: value[0], right: value[0], bottom: value[0], left: value[0]};
|
|
}
|
|
if (value.length === 2) {
|
|
return {top: value[0], right: value[1], bottom: value[0], left: value[1]};
|
|
}
|
|
if (value.length === 3) {
|
|
return {top: value[0], right: value[1], bottom: value[2], left: value[1]};
|
|
}
|
|
if (value.length === 4) {
|
|
return {top: value[0], right: value[1], bottom: value[2], left: value[3]};
|
|
}
|
|
}
|
|
|
|
// Convert an unpacked padding object to a CSS value
|
|
function paddingToCss(paddingObj) {
|
|
return paddingObj.top + "px " + paddingObj.right + "px " + paddingObj.bottom + "px " + paddingObj.left + "px";
|
|
}
|
|
|
|
// Makes a number suitable for CSS
|
|
function px(x) {
|
|
if (typeof(x) === "number")
|
|
return x + "px";
|
|
else
|
|
return x;
|
|
}
|
|
|
|
// Retrieves runtime widget sizing information for an element.
|
|
// The return value is either null, or an object with fill, padding,
|
|
// defaultWidth, defaultHeight fields.
|
|
function sizingPolicy(el) {
|
|
var sizingEl = document.querySelector("script[data-for='" + el.id + "'][type='application/htmlwidget-sizing']");
|
|
if (!sizingEl)
|
|
return null;
|
|
var sp = JSON.parse(sizingEl.textContent || sizingEl.text || "{}");
|
|
if (viewerMode) {
|
|
return sp.viewer;
|
|
} else {
|
|
return sp.browser;
|
|
}
|
|
}
|
|
|
|
// @param tasks Array of strings (or falsy value, in which case no-op).
|
|
// Each element must be a valid JavaScript expression that yields a
|
|
// function. Or, can be an array of objects with "code" and "data"
|
|
// properties; in this case, the "code" property should be a string
|
|
// of JS that's an expr that yields a function, and "data" should be
|
|
// an object that will be added as an additional argument when that
|
|
// function is called.
|
|
// @param target The object that will be "this" for each function
|
|
// execution.
|
|
// @param args Array of arguments to be passed to the functions. (The
|
|
// same arguments will be passed to all functions.)
|
|
function evalAndRun(tasks, target, args) {
|
|
if (tasks) {
|
|
forEach(tasks, function(task) {
|
|
var theseArgs = args;
|
|
if (typeof(task) === "object") {
|
|
theseArgs = theseArgs.concat([task.data]);
|
|
task = task.code;
|
|
}
|
|
var taskFunc = tryEval(task);
|
|
if (typeof(taskFunc) !== "function") {
|
|
throw new Error("Task must be a function! Source:\n" + task);
|
|
}
|
|
taskFunc.apply(target, theseArgs);
|
|
});
|
|
}
|
|
}
|
|
|
|
// Attempt eval() both with and without enclosing in parentheses.
|
|
// Note that enclosing coerces a function declaration into
|
|
// an expression that eval() can parse
|
|
// (otherwise, a SyntaxError is thrown)
|
|
function tryEval(code) {
|
|
var result = null;
|
|
try {
|
|
result = eval("(" + code + ")");
|
|
} catch(error) {
|
|
if (!(error instanceof SyntaxError)) {
|
|
throw error;
|
|
}
|
|
try {
|
|
result = eval(code);
|
|
} catch(e) {
|
|
if (e instanceof SyntaxError) {
|
|
throw error;
|
|
} else {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function initSizing(el) {
|
|
var sizing = sizingPolicy(el);
|
|
if (!sizing)
|
|
return;
|
|
|
|
var cel = document.getElementById("htmlwidget_container");
|
|
if (!cel)
|
|
return;
|
|
|
|
if (typeof(sizing.padding) !== "undefined") {
|
|
document.body.style.margin = "0";
|
|
document.body.style.padding = paddingToCss(unpackPadding(sizing.padding));
|
|
}
|
|
|
|
if (sizing.fill) {
|
|
document.body.style.overflow = "hidden";
|
|
document.body.style.width = "100%";
|
|
document.body.style.height = "100%";
|
|
document.documentElement.style.width = "100%";
|
|
document.documentElement.style.height = "100%";
|
|
if (cel) {
|
|
cel.style.position = "absolute";
|
|
var pad = unpackPadding(sizing.padding);
|
|
cel.style.top = pad.top + "px";
|
|
cel.style.right = pad.right + "px";
|
|
cel.style.bottom = pad.bottom + "px";
|
|
cel.style.left = pad.left + "px";
|
|
el.style.width = "100%";
|
|
el.style.height = "100%";
|
|
}
|
|
|
|
return {
|
|
getWidth: function() { return cel.offsetWidth; },
|
|
getHeight: function() { return cel.offsetHeight; }
|
|
};
|
|
|
|
} else {
|
|
el.style.width = px(sizing.width);
|
|
el.style.height = px(sizing.height);
|
|
|
|
return {
|
|
getWidth: function() { return el.offsetWidth; },
|
|
getHeight: function() { return el.offsetHeight; }
|
|
};
|
|
}
|
|
}
|
|
|
|
// Default implementations for methods
|
|
var defaults = {
|
|
find: function(scope) {
|
|
return querySelectorAll(scope, "." + this.name);
|
|
},
|
|
renderError: function(el, err) {
|
|
var $el = $(el);
|
|
|
|
this.clearError(el);
|
|
|
|
// Add all these error classes, as Shiny does
|
|
var errClass = "shiny-output-error";
|
|
if (err.type !== null) {
|
|
// use the classes of the error condition as CSS class names
|
|
errClass = errClass + " " + $.map(asArray(err.type), function(type) {
|
|
return errClass + "-" + type;
|
|
}).join(" ");
|
|
}
|
|
errClass = errClass + " htmlwidgets-error";
|
|
|
|
// Is el inline or block? If inline or inline-block, just display:none it
|
|
// and add an inline error.
|
|
var display = $el.css("display");
|
|
$el.data("restore-display-mode", display);
|
|
|
|
if (display === "inline" || display === "inline-block") {
|
|
$el.hide();
|
|
if (err.message !== "") {
|
|
var errorSpan = $("<span>").addClass(errClass);
|
|
errorSpan.text(err.message);
|
|
$el.after(errorSpan);
|
|
}
|
|
} else if (display === "block") {
|
|
// If block, add an error just after the el, set visibility:none on the
|
|
// el, and position the error to be on top of the el.
|
|
// Mark it with a unique ID and CSS class so we can remove it later.
|
|
$el.css("visibility", "hidden");
|
|
if (err.message !== "") {
|
|
var errorDiv = $("<div>").addClass(errClass).css("position", "absolute")
|
|
.css("top", el.offsetTop)
|
|
.css("left", el.offsetLeft)
|
|
// setting width can push out the page size, forcing otherwise
|
|
// unnecessary scrollbars to appear and making it impossible for
|
|
// the element to shrink; so use max-width instead
|
|
.css("maxWidth", el.offsetWidth)
|
|
.css("height", el.offsetHeight);
|
|
errorDiv.text(err.message);
|
|
$el.after(errorDiv);
|
|
|
|
// Really dumb way to keep the size/position of the error in sync with
|
|
// the parent element as the window is resized or whatever.
|
|
var intId = setInterval(function() {
|
|
if (!errorDiv[0].parentElement) {
|
|
clearInterval(intId);
|
|
return;
|
|
}
|
|
errorDiv
|
|
.css("top", el.offsetTop)
|
|
.css("left", el.offsetLeft)
|
|
.css("maxWidth", el.offsetWidth)
|
|
.css("height", el.offsetHeight);
|
|
}, 500);
|
|
}
|
|
}
|
|
},
|
|
clearError: function(el) {
|
|
var $el = $(el);
|
|
var display = $el.data("restore-display-mode");
|
|
$el.data("restore-display-mode", null);
|
|
|
|
if (display === "inline" || display === "inline-block") {
|
|
if (display)
|
|
$el.css("display", display);
|
|
$(el.nextSibling).filter(".htmlwidgets-error").remove();
|
|
} else if (display === "block"){
|
|
$el.css("visibility", "inherit");
|
|
$(el.nextSibling).filter(".htmlwidgets-error").remove();
|
|
}
|
|
},
|
|
sizing: {}
|
|
};
|
|
|
|
// Called by widget bindings to register a new type of widget. The definition
|
|
// object can contain the following properties:
|
|
// - name (required) - A string indicating the binding name, which will be
|
|
// used by default as the CSS classname to look for.
|
|
// - initialize (optional) - A function(el) that will be called once per
|
|
// widget element; if a value is returned, it will be passed as the third
|
|
// value to renderValue.
|
|
// - renderValue (required) - A function(el, data, initValue) that will be
|
|
// called with data. Static contexts will cause this to be called once per
|
|
// element; Shiny apps will cause this to be called multiple times per
|
|
// element, as the data changes.
|
|
window.HTMLWidgets.widget = function(definition) {
|
|
if (!definition.name) {
|
|
throw new Error("Widget must have a name");
|
|
}
|
|
if (!definition.type) {
|
|
throw new Error("Widget must have a type");
|
|
}
|
|
// Currently we only support output widgets
|
|
if (definition.type !== "output") {
|
|
throw new Error("Unrecognized widget type '" + definition.type + "'");
|
|
}
|
|
// TODO: Verify that .name is a valid CSS classname
|
|
|
|
// Support new-style instance-bound definitions. Old-style class-bound
|
|
// definitions have one widget "object" per widget per type/class of
|
|
// widget; the renderValue and resize methods on such widget objects
|
|
// take el and instance arguments, because the widget object can't
|
|
// store them. New-style instance-bound definitions have one widget
|
|
// object per widget instance; the definition that's passed in doesn't
|
|
// provide renderValue or resize methods at all, just the single method
|
|
// factory(el, width, height)
|
|
// which returns an object that has renderValue(x) and resize(w, h).
|
|
// This enables a far more natural programming style for the widget
|
|
// author, who can store per-instance state using either OO-style
|
|
// instance fields or functional-style closure variables (I guess this
|
|
// is in contrast to what can only be called C-style pseudo-OO which is
|
|
// what we required before).
|
|
if (definition.factory) {
|
|
definition = createLegacyDefinitionAdapter(definition);
|
|
}
|
|
|
|
if (!definition.renderValue) {
|
|
throw new Error("Widget must have a renderValue function");
|
|
}
|
|
|
|
// For static rendering (non-Shiny), use a simple widget registration
|
|
// scheme. We also use this scheme for Shiny apps/documents that also
|
|
// contain static widgets.
|
|
window.HTMLWidgets.widgets = window.HTMLWidgets.widgets || [];
|
|
// Merge defaults into the definition; don't mutate the original definition.
|
|
var staticBinding = extend({}, defaults, definition);
|
|
overrideMethod(staticBinding, "find", function(superfunc) {
|
|
return function(scope) {
|
|
var results = superfunc(scope);
|
|
// Filter out Shiny outputs, we only want the static kind
|
|
return filterByClass(results, "html-widget-output", false);
|
|
};
|
|
});
|
|
window.HTMLWidgets.widgets.push(staticBinding);
|
|
|
|
if (shinyMode) {
|
|
// Shiny is running. Register the definition with an output binding.
|
|
// The definition itself will not be the output binding, instead
|
|
// we will make an output binding object that delegates to the
|
|
// definition. This is because we foolishly used the same method
|
|
// name (renderValue) for htmlwidgets definition and Shiny bindings
|
|
// but they actually have quite different semantics (the Shiny
|
|
// bindings receive data that includes lots of metadata that it
|
|
// strips off before calling htmlwidgets renderValue). We can't
|
|
// just ignore the difference because in some widgets it's helpful
|
|
// to call this.renderValue() from inside of resize(), and if
|
|
// we're not delegating, then that call will go to the Shiny
|
|
// version instead of the htmlwidgets version.
|
|
|
|
// Merge defaults with definition, without mutating either.
|
|
var bindingDef = extend({}, defaults, definition);
|
|
|
|
// This object will be our actual Shiny binding.
|
|
var shinyBinding = new Shiny.OutputBinding();
|
|
|
|
// With a few exceptions, we'll want to simply use the bindingDef's
|
|
// version of methods if they are available, otherwise fall back to
|
|
// Shiny's defaults. NOTE: If Shiny's output bindings gain additional
|
|
// methods in the future, and we want them to be overrideable by
|
|
// HTMLWidget binding definitions, then we'll need to add them to this
|
|
// list.
|
|
delegateMethod(shinyBinding, bindingDef, "getId");
|
|
delegateMethod(shinyBinding, bindingDef, "onValueChange");
|
|
delegateMethod(shinyBinding, bindingDef, "onValueError");
|
|
delegateMethod(shinyBinding, bindingDef, "renderError");
|
|
delegateMethod(shinyBinding, bindingDef, "clearError");
|
|
delegateMethod(shinyBinding, bindingDef, "showProgress");
|
|
|
|
// The find, renderValue, and resize are handled differently, because we
|
|
// want to actually decorate the behavior of the bindingDef methods.
|
|
|
|
shinyBinding.find = function(scope) {
|
|
var results = bindingDef.find(scope);
|
|
|
|
// Only return elements that are Shiny outputs, not static ones
|
|
var dynamicResults = results.filter(".html-widget-output");
|
|
|
|
// It's possible that whatever caused Shiny to think there might be
|
|
// new dynamic outputs, also caused there to be new static outputs.
|
|
// Since there might be lots of different htmlwidgets bindings, we
|
|
// schedule execution for later--no need to staticRender multiple
|
|
// times.
|
|
if (results.length !== dynamicResults.length)
|
|
scheduleStaticRender();
|
|
|
|
return dynamicResults;
|
|
};
|
|
|
|
// Wrap renderValue to handle initialization, which unfortunately isn't
|
|
// supported natively by Shiny at the time of this writing.
|
|
|
|
shinyBinding.renderValue = function(el, data) {
|
|
Shiny.renderDependencies(data.deps);
|
|
// Resolve strings marked as javascript literals to objects
|
|
if (!(data.evals instanceof Array)) data.evals = [data.evals];
|
|
for (var i = 0; data.evals && i < data.evals.length; i++) {
|
|
window.HTMLWidgets.evaluateStringMember(data.x, data.evals[i]);
|
|
}
|
|
if (!bindingDef.renderOnNullValue) {
|
|
if (data.x === null) {
|
|
el.style.visibility = "hidden";
|
|
return;
|
|
} else {
|
|
el.style.visibility = "inherit";
|
|
}
|
|
}
|
|
if (!elementData(el, "initialized")) {
|
|
initSizing(el);
|
|
|
|
elementData(el, "initialized", true);
|
|
if (bindingDef.initialize) {
|
|
var result = bindingDef.initialize(el, el.offsetWidth,
|
|
el.offsetHeight);
|
|
elementData(el, "init_result", result);
|
|
}
|
|
}
|
|
bindingDef.renderValue(el, data.x, elementData(el, "init_result"));
|
|
evalAndRun(data.jsHooks.render, elementData(el, "init_result"), [el, data.x]);
|
|
};
|
|
|
|
// Only override resize if bindingDef implements it
|
|
if (bindingDef.resize) {
|
|
shinyBinding.resize = function(el, width, height) {
|
|
// Shiny can call resize before initialize/renderValue have been
|
|
// called, which doesn't make sense for widgets.
|
|
if (elementData(el, "initialized")) {
|
|
bindingDef.resize(el, width, height, elementData(el, "init_result"));
|
|
}
|
|
};
|
|
}
|
|
|
|
Shiny.outputBindings.register(shinyBinding, bindingDef.name);
|
|
}
|
|
};
|
|
|
|
var scheduleStaticRenderTimerId = null;
|
|
function scheduleStaticRender() {
|
|
if (!scheduleStaticRenderTimerId) {
|
|
scheduleStaticRenderTimerId = setTimeout(function() {
|
|
scheduleStaticRenderTimerId = null;
|
|
window.HTMLWidgets.staticRender();
|
|
}, 1);
|
|
}
|
|
}
|
|
|
|
// Render static widgets after the document finishes loading
|
|
// Statically render all elements that are of this widget's class
|
|
window.HTMLWidgets.staticRender = function() {
|
|
var bindings = window.HTMLWidgets.widgets || [];
|
|
forEach(bindings, function(binding) {
|
|
var matches = binding.find(document.documentElement);
|
|
forEach(matches, function(el) {
|
|
var sizeObj = initSizing(el, binding);
|
|
|
|
if (hasClass(el, "html-widget-static-bound"))
|
|
return;
|
|
el.className = el.className + " html-widget-static-bound";
|
|
|
|
var initResult;
|
|
if (binding.initialize) {
|
|
initResult = binding.initialize(el,
|
|
sizeObj ? sizeObj.getWidth() : el.offsetWidth,
|
|
sizeObj ? sizeObj.getHeight() : el.offsetHeight
|
|
);
|
|
elementData(el, "init_result", initResult);
|
|
}
|
|
|
|
if (binding.resize) {
|
|
var lastSize = {
|
|
w: sizeObj ? sizeObj.getWidth() : el.offsetWidth,
|
|
h: sizeObj ? sizeObj.getHeight() : el.offsetHeight
|
|
};
|
|
var resizeHandler = function(e) {
|
|
var size = {
|
|
w: sizeObj ? sizeObj.getWidth() : el.offsetWidth,
|
|
h: sizeObj ? sizeObj.getHeight() : el.offsetHeight
|
|
};
|
|
if (size.w === 0 && size.h === 0)
|
|
return;
|
|
if (size.w === lastSize.w && size.h === lastSize.h)
|
|
return;
|
|
lastSize = size;
|
|
binding.resize(el, size.w, size.h, initResult);
|
|
};
|
|
|
|
on(window, "resize", resizeHandler);
|
|
|
|
// This is needed for cases where we're running in a Shiny
|
|
// app, but the widget itself is not a Shiny output, but
|
|
// rather a simple static widget. One example of this is
|
|
// an rmarkdown document that has runtime:shiny and widget
|
|
// that isn't in a render function. Shiny only knows to
|
|
// call resize handlers for Shiny outputs, not for static
|
|
// widgets, so we do it ourselves.
|
|
if (window.jQuery) {
|
|
window.jQuery(document).on(
|
|
"shown.htmlwidgets shown.bs.tab.htmlwidgets shown.bs.collapse.htmlwidgets",
|
|
resizeHandler
|
|
);
|
|
window.jQuery(document).on(
|
|
"hidden.htmlwidgets hidden.bs.tab.htmlwidgets hidden.bs.collapse.htmlwidgets",
|
|
resizeHandler
|
|
);
|
|
}
|
|
|
|
// This is needed for the specific case of ioslides, which
|
|
// flips slides between display:none and display:block.
|
|
// Ideally we would not have to have ioslide-specific code
|
|
// here, but rather have ioslides raise a generic event,
|
|
// but the rmarkdown package just went to CRAN so the
|
|
// window to getting that fixed may be long.
|
|
if (window.addEventListener) {
|
|
// It's OK to limit this to window.addEventListener
|
|
// browsers because ioslides itself only supports
|
|
// such browsers.
|
|
on(document, "slideenter", resizeHandler);
|
|
on(document, "slideleave", resizeHandler);
|
|
}
|
|
}
|
|
|
|
var scriptData = document.querySelector("script[data-for='" + el.id + "'][type='application/json']");
|
|
if (scriptData) {
|
|
var data = JSON.parse(scriptData.textContent || scriptData.text);
|
|
// Resolve strings marked as javascript literals to objects
|
|
if (!(data.evals instanceof Array)) data.evals = [data.evals];
|
|
for (var k = 0; data.evals && k < data.evals.length; k++) {
|
|
window.HTMLWidgets.evaluateStringMember(data.x, data.evals[k]);
|
|
}
|
|
binding.renderValue(el, data.x, initResult);
|
|
evalAndRun(data.jsHooks.render, initResult, [el, data.x]);
|
|
}
|
|
});
|
|
});
|
|
|
|
invokePostRenderHandlers();
|
|
}
|
|
|
|
|
|
function has_jQuery3() {
|
|
if (!window.jQuery) {
|
|
return false;
|
|
}
|
|
var $version = window.jQuery.fn.jquery;
|
|
var $major_version = parseInt($version.split(".")[0]);
|
|
return $major_version >= 3;
|
|
}
|
|
|
|
/*
|
|
/ Shiny 1.4 bumped jQuery from 1.x to 3.x which means jQuery's
|
|
/ on-ready handler (i.e., $(fn)) is now asyncronous (i.e., it now
|
|
/ really means $(setTimeout(fn)).
|
|
/ https://jquery.com/upgrade-guide/3.0/#breaking-change-document-ready-handlers-are-now-asynchronous
|
|
/
|
|
/ Since Shiny uses $() to schedule initShiny, shiny>=1.4 calls initShiny
|
|
/ one tick later than it did before, which means staticRender() is
|
|
/ called renderValue() earlier than (advanced) widget authors might be expecting.
|
|
/ https://github.com/rstudio/shiny/issues/2630
|
|
/
|
|
/ For a concrete example, leaflet has some methods (e.g., updateBounds)
|
|
/ which reference Shiny methods registered in initShiny (e.g., setInputValue).
|
|
/ Since leaflet is privy to this life-cycle, it knows to use setTimeout() to
|
|
/ delay execution of those methods (until Shiny methods are ready)
|
|
/ https://github.com/rstudio/leaflet/blob/18ec981/javascript/src/index.js#L266-L268
|
|
/
|
|
/ Ideally widget authors wouldn't need to use this setTimeout() hack that
|
|
/ leaflet uses to call Shiny methods on a staticRender(). In the long run,
|
|
/ the logic initShiny should be broken up so that method registration happens
|
|
/ right away, but binding happens later.
|
|
*/
|
|
function maybeStaticRenderLater() {
|
|
if (shinyMode && has_jQuery3()) {
|
|
window.jQuery(window.HTMLWidgets.staticRender);
|
|
} else {
|
|
window.HTMLWidgets.staticRender();
|
|
}
|
|
}
|
|
|
|
if (document.addEventListener) {
|
|
document.addEventListener("DOMContentLoaded", function() {
|
|
document.removeEventListener("DOMContentLoaded", arguments.callee, false);
|
|
maybeStaticRenderLater();
|
|
}, false);
|
|
} else if (document.attachEvent) {
|
|
document.attachEvent("onreadystatechange", function() {
|
|
if (document.readyState === "complete") {
|
|
document.detachEvent("onreadystatechange", arguments.callee);
|
|
maybeStaticRenderLater();
|
|
}
|
|
});
|
|
}
|
|
|
|
|
|
window.HTMLWidgets.getAttachmentUrl = function(depname, key) {
|
|
// If no key, default to the first item
|
|
if (typeof(key) === "undefined")
|
|
key = 1;
|
|
|
|
var link = document.getElementById(depname + "-" + key + "-attachment");
|
|
if (!link) {
|
|
throw new Error("Attachment " + depname + "/" + key + " not found in document");
|
|
}
|
|
return link.getAttribute("href");
|
|
};
|
|
|
|
window.HTMLWidgets.dataframeToD3 = function(df) {
|
|
var names = [];
|
|
var length;
|
|
for (var name in df) {
|
|
if (df.hasOwnProperty(name))
|
|
names.push(name);
|
|
if (typeof(df[name]) !== "object" || typeof(df[name].length) === "undefined") {
|
|
throw new Error("All fields must be arrays");
|
|
} else if (typeof(length) !== "undefined" && length !== df[name].length) {
|
|
throw new Error("All fields must be arrays of the same length");
|
|
}
|
|
length = df[name].length;
|
|
}
|
|
var results = [];
|
|
var item;
|
|
for (var row = 0; row < length; row++) {
|
|
item = {};
|
|
for (var col = 0; col < names.length; col++) {
|
|
item[names[col]] = df[names[col]][row];
|
|
}
|
|
results.push(item);
|
|
}
|
|
return results;
|
|
};
|
|
|
|
window.HTMLWidgets.transposeArray2D = function(array) {
|
|
if (array.length === 0) return array;
|
|
var newArray = array[0].map(function(col, i) {
|
|
return array.map(function(row) {
|
|
return row[i]
|
|
})
|
|
});
|
|
return newArray;
|
|
};
|
|
// Split value at splitChar, but allow splitChar to be escaped
|
|
// using escapeChar. Any other characters escaped by escapeChar
|
|
// will be included as usual (including escapeChar itself).
|
|
function splitWithEscape(value, splitChar, escapeChar) {
|
|
var results = [];
|
|
var escapeMode = false;
|
|
var currentResult = "";
|
|
for (var pos = 0; pos < value.length; pos++) {
|
|
if (!escapeMode) {
|
|
if (value[pos] === splitChar) {
|
|
results.push(currentResult);
|
|
currentResult = "";
|
|
} else if (value[pos] === escapeChar) {
|
|
escapeMode = true;
|
|
} else {
|
|
currentResult += value[pos];
|
|
}
|
|
} else {
|
|
currentResult += value[pos];
|
|
escapeMode = false;
|
|
}
|
|
}
|
|
if (currentResult !== "") {
|
|
results.push(currentResult);
|
|
}
|
|
return results;
|
|
}
|
|
// Function authored by Yihui/JJ Allaire
|
|
window.HTMLWidgets.evaluateStringMember = function(o, member) {
|
|
var parts = splitWithEscape(member, '.', '\\');
|
|
for (var i = 0, l = parts.length; i < l; i++) {
|
|
var part = parts[i];
|
|
// part may be a character or 'numeric' member name
|
|
if (o !== null && typeof o === "object" && part in o) {
|
|
if (i == (l - 1)) { // if we are at the end of the line then evalulate
|
|
if (typeof o[part] === "string")
|
|
o[part] = tryEval(o[part]);
|
|
} else { // otherwise continue to next embedded object
|
|
o = o[part];
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// Retrieve the HTMLWidget instance (i.e. the return value of an
|
|
// HTMLWidget binding's initialize() or factory() function)
|
|
// associated with an element, or null if none.
|
|
window.HTMLWidgets.getInstance = function(el) {
|
|
return elementData(el, "init_result");
|
|
};
|
|
|
|
// Finds the first element in the scope that matches the selector,
|
|
// and returns the HTMLWidget instance (i.e. the return value of
|
|
// an HTMLWidget binding's initialize() or factory() function)
|
|
// associated with that element, if any. If no element matches the
|
|
// selector, or the first matching element has no HTMLWidget
|
|
// instance associated with it, then null is returned.
|
|
//
|
|
// The scope argument is optional, and defaults to window.document.
|
|
window.HTMLWidgets.find = function(scope, selector) {
|
|
if (arguments.length == 1) {
|
|
selector = scope;
|
|
scope = document;
|
|
}
|
|
|
|
var el = scope.querySelector(selector);
|
|
if (el === null) {
|
|
return null;
|
|
} else {
|
|
return window.HTMLWidgets.getInstance(el);
|
|
}
|
|
};
|
|
|
|
// Finds all elements in the scope that match the selector, and
|
|
// returns the HTMLWidget instances (i.e. the return values of
|
|
// an HTMLWidget binding's initialize() or factory() function)
|
|
// associated with the elements, in an array. If elements that
|
|
// match the selector don't have an associated HTMLWidget
|
|
// instance, the returned array will contain nulls.
|
|
//
|
|
// The scope argument is optional, and defaults to window.document.
|
|
window.HTMLWidgets.findAll = function(scope, selector) {
|
|
if (arguments.length == 1) {
|
|
selector = scope;
|
|
scope = document;
|
|
}
|
|
|
|
var nodes = scope.querySelectorAll(selector);
|
|
var results = [];
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
results.push(window.HTMLWidgets.getInstance(nodes[i]));
|
|
}
|
|
return results;
|
|
};
|
|
|
|
var postRenderHandlers = [];
|
|
function invokePostRenderHandlers() {
|
|
while (postRenderHandlers.length) {
|
|
var handler = postRenderHandlers.shift();
|
|
if (handler) {
|
|
handler();
|
|
}
|
|
}
|
|
}
|
|
|
|
// Register the given callback function to be invoked after the
|
|
// next time static widgets are rendered.
|
|
window.HTMLWidgets.addPostRenderHandler = function(callback) {
|
|
postRenderHandlers.push(callback);
|
|
};
|
|
|
|
// Takes a new-style instance-bound definition, and returns an
|
|
// old-style class-bound definition. This saves us from having
|
|
// to rewrite all the logic in this file to accomodate both
|
|
// types of definitions.
|
|
function createLegacyDefinitionAdapter(defn) {
|
|
var result = {
|
|
name: defn.name,
|
|
type: defn.type,
|
|
initialize: function(el, width, height) {
|
|
return defn.factory(el, width, height);
|
|
},
|
|
renderValue: function(el, x, instance) {
|
|
return instance.renderValue(x);
|
|
},
|
|
resize: function(el, width, height, instance) {
|
|
return instance.resize(width, height);
|
|
}
|
|
};
|
|
|
|
if (defn.find)
|
|
result.find = defn.find;
|
|
if (defn.renderError)
|
|
result.renderError = defn.renderError;
|
|
if (defn.clearError)
|
|
result.clearError = defn.clearError;
|
|
|
|
return result;
|
|
}
|
|
})();
|
|
|