").addClass(errClass);
344 | errorSpan.text(err.message);
345 | $el.after(errorSpan);
346 | }
347 | } else if (display === "block") {
348 | // If block, add an error just after the el, set visibility:none on the
349 | // el, and position the error to be on top of the el.
350 | // Mark it with a unique ID and CSS class so we can remove it later.
351 | $el.css("visibility", "hidden");
352 | if (err.message !== "") {
353 | var errorDiv = $("").addClass(errClass).css("position", "absolute")
354 | .css("top", el.offsetTop)
355 | .css("left", el.offsetLeft)
356 | // setting width can push out the page size, forcing otherwise
357 | // unnecessary scrollbars to appear and making it impossible for
358 | // the element to shrink; so use max-width instead
359 | .css("maxWidth", el.offsetWidth)
360 | .css("height", el.offsetHeight);
361 | errorDiv.text(err.message);
362 | $el.after(errorDiv);
363 |
364 | // Really dumb way to keep the size/position of the error in sync with
365 | // the parent element as the window is resized or whatever.
366 | var intId = setInterval(function() {
367 | if (!errorDiv[0].parentElement) {
368 | clearInterval(intId);
369 | return;
370 | }
371 | errorDiv
372 | .css("top", el.offsetTop)
373 | .css("left", el.offsetLeft)
374 | .css("maxWidth", el.offsetWidth)
375 | .css("height", el.offsetHeight);
376 | }, 500);
377 | }
378 | }
379 | },
380 | clearError: function(el) {
381 | var $el = $(el);
382 | var display = $el.data("restore-display-mode");
383 | $el.data("restore-display-mode", null);
384 |
385 | if (display === "inline" || display === "inline-block") {
386 | if (display)
387 | $el.css("display", display);
388 | $(el.nextSibling).filter(".htmlwidgets-error").remove();
389 | } else if (display === "block"){
390 | $el.css("visibility", "inherit");
391 | $(el.nextSibling).filter(".htmlwidgets-error").remove();
392 | }
393 | },
394 | sizing: {}
395 | };
396 |
397 | // Called by widget bindings to register a new type of widget. The definition
398 | // object can contain the following properties:
399 | // - name (required) - A string indicating the binding name, which will be
400 | // used by default as the CSS classname to look for.
401 | // - initialize (optional) - A function(el) that will be called once per
402 | // widget element; if a value is returned, it will be passed as the third
403 | // value to renderValue.
404 | // - renderValue (required) - A function(el, data, initValue) that will be
405 | // called with data. Static contexts will cause this to be called once per
406 | // element; Shiny apps will cause this to be called multiple times per
407 | // element, as the data changes.
408 | window.HTMLWidgets.widget = function(definition) {
409 | if (!definition.name) {
410 | throw new Error("Widget must have a name");
411 | }
412 | if (!definition.type) {
413 | throw new Error("Widget must have a type");
414 | }
415 | // Currently we only support output widgets
416 | if (definition.type !== "output") {
417 | throw new Error("Unrecognized widget type '" + definition.type + "'");
418 | }
419 | // TODO: Verify that .name is a valid CSS classname
420 |
421 | // Support new-style instance-bound definitions. Old-style class-bound
422 | // definitions have one widget "object" per widget per type/class of
423 | // widget; the renderValue and resize methods on such widget objects
424 | // take el and instance arguments, because the widget object can't
425 | // store them. New-style instance-bound definitions have one widget
426 | // object per widget instance; the definition that's passed in doesn't
427 | // provide renderValue or resize methods at all, just the single method
428 | // factory(el, width, height)
429 | // which returns an object that has renderValue(x) and resize(w, h).
430 | // This enables a far more natural programming style for the widget
431 | // author, who can store per-instance state using either OO-style
432 | // instance fields or functional-style closure variables (I guess this
433 | // is in contrast to what can only be called C-style pseudo-OO which is
434 | // what we required before).
435 | if (definition.factory) {
436 | definition = createLegacyDefinitionAdapter(definition);
437 | }
438 |
439 | if (!definition.renderValue) {
440 | throw new Error("Widget must have a renderValue function");
441 | }
442 |
443 | // For static rendering (non-Shiny), use a simple widget registration
444 | // scheme. We also use this scheme for Shiny apps/documents that also
445 | // contain static widgets.
446 | window.HTMLWidgets.widgets = window.HTMLWidgets.widgets || [];
447 | // Merge defaults into the definition; don't mutate the original definition.
448 | var staticBinding = extend({}, defaults, definition);
449 | overrideMethod(staticBinding, "find", function(superfunc) {
450 | return function(scope) {
451 | var results = superfunc(scope);
452 | // Filter out Shiny outputs, we only want the static kind
453 | return filterByClass(results, "html-widget-output", false);
454 | };
455 | });
456 | window.HTMLWidgets.widgets.push(staticBinding);
457 |
458 | if (shinyMode) {
459 | // Shiny is running. Register the definition with an output binding.
460 | // The definition itself will not be the output binding, instead
461 | // we will make an output binding object that delegates to the
462 | // definition. This is because we foolishly used the same method
463 | // name (renderValue) for htmlwidgets definition and Shiny bindings
464 | // but they actually have quite different semantics (the Shiny
465 | // bindings receive data that includes lots of metadata that it
466 | // strips off before calling htmlwidgets renderValue). We can't
467 | // just ignore the difference because in some widgets it's helpful
468 | // to call this.renderValue() from inside of resize(), and if
469 | // we're not delegating, then that call will go to the Shiny
470 | // version instead of the htmlwidgets version.
471 |
472 | // Merge defaults with definition, without mutating either.
473 | var bindingDef = extend({}, defaults, definition);
474 |
475 | // This object will be our actual Shiny binding.
476 | var shinyBinding = new Shiny.OutputBinding();
477 |
478 | // With a few exceptions, we'll want to simply use the bindingDef's
479 | // version of methods if they are available, otherwise fall back to
480 | // Shiny's defaults. NOTE: If Shiny's output bindings gain additional
481 | // methods in the future, and we want them to be overrideable by
482 | // HTMLWidget binding definitions, then we'll need to add them to this
483 | // list.
484 | delegateMethod(shinyBinding, bindingDef, "getId");
485 | delegateMethod(shinyBinding, bindingDef, "onValueChange");
486 | delegateMethod(shinyBinding, bindingDef, "onValueError");
487 | delegateMethod(shinyBinding, bindingDef, "renderError");
488 | delegateMethod(shinyBinding, bindingDef, "clearError");
489 | delegateMethod(shinyBinding, bindingDef, "showProgress");
490 |
491 | // The find, renderValue, and resize are handled differently, because we
492 | // want to actually decorate the behavior of the bindingDef methods.
493 |
494 | shinyBinding.find = function(scope) {
495 | var results = bindingDef.find(scope);
496 |
497 | // Only return elements that are Shiny outputs, not static ones
498 | var dynamicResults = results.filter(".html-widget-output");
499 |
500 | // It's possible that whatever caused Shiny to think there might be
501 | // new dynamic outputs, also caused there to be new static outputs.
502 | // Since there might be lots of different htmlwidgets bindings, we
503 | // schedule execution for later--no need to staticRender multiple
504 | // times.
505 | if (results.length !== dynamicResults.length)
506 | scheduleStaticRender();
507 |
508 | return dynamicResults;
509 | };
510 |
511 | // Wrap renderValue to handle initialization, which unfortunately isn't
512 | // supported natively by Shiny at the time of this writing.
513 |
514 | shinyBinding.renderValue = function(el, data) {
515 | Shiny.renderDependencies(data.deps);
516 | // Resolve strings marked as javascript literals to objects
517 | if (!(data.evals instanceof Array)) data.evals = [data.evals];
518 | for (var i = 0; data.evals && i < data.evals.length; i++) {
519 | window.HTMLWidgets.evaluateStringMember(data.x, data.evals[i]);
520 | }
521 | if (!bindingDef.renderOnNullValue) {
522 | if (data.x === null) {
523 | el.style.visibility = "hidden";
524 | return;
525 | } else {
526 | el.style.visibility = "inherit";
527 | }
528 | }
529 | if (!elementData(el, "initialized")) {
530 | initSizing(el);
531 |
532 | elementData(el, "initialized", true);
533 | if (bindingDef.initialize) {
534 | var rect = el.getBoundingClientRect();
535 | var result = bindingDef.initialize(el, rect.width, rect.height);
536 | elementData(el, "init_result", result);
537 | }
538 | }
539 | bindingDef.renderValue(el, data.x, elementData(el, "init_result"));
540 | evalAndRun(data.jsHooks.render, elementData(el, "init_result"), [el, data.x]);
541 | };
542 |
543 | // Only override resize if bindingDef implements it
544 | if (bindingDef.resize) {
545 | shinyBinding.resize = function(el, width, height) {
546 | // Shiny can call resize before initialize/renderValue have been
547 | // called, which doesn't make sense for widgets.
548 | if (elementData(el, "initialized")) {
549 | bindingDef.resize(el, width, height, elementData(el, "init_result"));
550 | }
551 | };
552 | }
553 |
554 | Shiny.outputBindings.register(shinyBinding, bindingDef.name);
555 | }
556 | };
557 |
558 | var scheduleStaticRenderTimerId = null;
559 | function scheduleStaticRender() {
560 | if (!scheduleStaticRenderTimerId) {
561 | scheduleStaticRenderTimerId = setTimeout(function() {
562 | scheduleStaticRenderTimerId = null;
563 | window.HTMLWidgets.staticRender();
564 | }, 1);
565 | }
566 | }
567 |
568 | // Render static widgets after the document finishes loading
569 | // Statically render all elements that are of this widget's class
570 | window.HTMLWidgets.staticRender = function() {
571 | var bindings = window.HTMLWidgets.widgets || [];
572 | forEach(bindings, function(binding) {
573 | var matches = binding.find(document.documentElement);
574 | forEach(matches, function(el) {
575 | var sizeObj = initSizing(el, binding);
576 |
577 | var getSize = function(el) {
578 | if (sizeObj) {
579 | return {w: sizeObj.getWidth(), h: sizeObj.getHeight()}
580 | } else {
581 | var rect = el.getBoundingClientRect();
582 | return {w: rect.width, h: rect.height}
583 | }
584 | };
585 |
586 | if (hasClass(el, "html-widget-static-bound"))
587 | return;
588 | el.className = el.className + " html-widget-static-bound";
589 |
590 | var initResult;
591 | if (binding.initialize) {
592 | var size = getSize(el);
593 | initResult = binding.initialize(el, size.w, size.h);
594 | elementData(el, "init_result", initResult);
595 | }
596 |
597 | if (binding.resize) {
598 | var lastSize = getSize(el);
599 | var resizeHandler = function(e) {
600 | var size = getSize(el);
601 | if (size.w === 0 && size.h === 0)
602 | return;
603 | if (size.w === lastSize.w && size.h === lastSize.h)
604 | return;
605 | lastSize = size;
606 | binding.resize(el, size.w, size.h, initResult);
607 | };
608 |
609 | on(window, "resize", resizeHandler);
610 |
611 | // This is needed for cases where we're running in a Shiny
612 | // app, but the widget itself is not a Shiny output, but
613 | // rather a simple static widget. One example of this is
614 | // an rmarkdown document that has runtime:shiny and widget
615 | // that isn't in a render function. Shiny only knows to
616 | // call resize handlers for Shiny outputs, not for static
617 | // widgets, so we do it ourselves.
618 | if (window.jQuery) {
619 | window.jQuery(document).on(
620 | "shown.htmlwidgets shown.bs.tab.htmlwidgets shown.bs.collapse.htmlwidgets",
621 | resizeHandler
622 | );
623 | window.jQuery(document).on(
624 | "hidden.htmlwidgets hidden.bs.tab.htmlwidgets hidden.bs.collapse.htmlwidgets",
625 | resizeHandler
626 | );
627 | }
628 |
629 | // This is needed for the specific case of ioslides, which
630 | // flips slides between display:none and display:block.
631 | // Ideally we would not have to have ioslide-specific code
632 | // here, but rather have ioslides raise a generic event,
633 | // but the rmarkdown package just went to CRAN so the
634 | // window to getting that fixed may be long.
635 | if (window.addEventListener) {
636 | // It's OK to limit this to window.addEventListener
637 | // browsers because ioslides itself only supports
638 | // such browsers.
639 | on(document, "slideenter", resizeHandler);
640 | on(document, "slideleave", resizeHandler);
641 | }
642 | }
643 |
644 | var scriptData = document.querySelector("script[data-for='" + el.id + "'][type='application/json']");
645 | if (scriptData) {
646 | var data = JSON.parse(scriptData.textContent || scriptData.text);
647 | // Resolve strings marked as javascript literals to objects
648 | if (!(data.evals instanceof Array)) data.evals = [data.evals];
649 | for (var k = 0; data.evals && k < data.evals.length; k++) {
650 | window.HTMLWidgets.evaluateStringMember(data.x, data.evals[k]);
651 | }
652 | binding.renderValue(el, data.x, initResult);
653 | evalAndRun(data.jsHooks.render, initResult, [el, data.x]);
654 | }
655 | });
656 | });
657 |
658 | invokePostRenderHandlers();
659 | }
660 |
661 |
662 | function has_jQuery3() {
663 | if (!window.jQuery) {
664 | return false;
665 | }
666 | var $version = window.jQuery.fn.jquery;
667 | var $major_version = parseInt($version.split(".")[0]);
668 | return $major_version >= 3;
669 | }
670 |
671 | /*
672 | / Shiny 1.4 bumped jQuery from 1.x to 3.x which means jQuery's
673 | / on-ready handler (i.e., $(fn)) is now asyncronous (i.e., it now
674 | / really means $(setTimeout(fn)).
675 | / https://jquery.com/upgrade-guide/3.0/#breaking-change-document-ready-handlers-are-now-asynchronous
676 | /
677 | / Since Shiny uses $() to schedule initShiny, shiny>=1.4 calls initShiny
678 | / one tick later than it did before, which means staticRender() is
679 | / called renderValue() earlier than (advanced) widget authors might be expecting.
680 | / https://github.com/rstudio/shiny/issues/2630
681 | /
682 | / For a concrete example, leaflet has some methods (e.g., updateBounds)
683 | / which reference Shiny methods registered in initShiny (e.g., setInputValue).
684 | / Since leaflet is privy to this life-cycle, it knows to use setTimeout() to
685 | / delay execution of those methods (until Shiny methods are ready)
686 | / https://github.com/rstudio/leaflet/blob/18ec981/javascript/src/index.js#L266-L268
687 | /
688 | / Ideally widget authors wouldn't need to use this setTimeout() hack that
689 | / leaflet uses to call Shiny methods on a staticRender(). In the long run,
690 | / the logic initShiny should be broken up so that method registration happens
691 | / right away, but binding happens later.
692 | */
693 | function maybeStaticRenderLater() {
694 | if (shinyMode && has_jQuery3()) {
695 | window.jQuery(window.HTMLWidgets.staticRender);
696 | } else {
697 | window.HTMLWidgets.staticRender();
698 | }
699 | }
700 |
701 | if (document.addEventListener) {
702 | document.addEventListener("DOMContentLoaded", function() {
703 | document.removeEventListener("DOMContentLoaded", arguments.callee, false);
704 | maybeStaticRenderLater();
705 | }, false);
706 | } else if (document.attachEvent) {
707 | document.attachEvent("onreadystatechange", function() {
708 | if (document.readyState === "complete") {
709 | document.detachEvent("onreadystatechange", arguments.callee);
710 | maybeStaticRenderLater();
711 | }
712 | });
713 | }
714 |
715 |
716 | window.HTMLWidgets.getAttachmentUrl = function(depname, key) {
717 | // If no key, default to the first item
718 | if (typeof(key) === "undefined")
719 | key = 1;
720 |
721 | var link = document.getElementById(depname + "-" + key + "-attachment");
722 | if (!link) {
723 | throw new Error("Attachment " + depname + "/" + key + " not found in document");
724 | }
725 | return link.getAttribute("href");
726 | };
727 |
728 | window.HTMLWidgets.dataframeToD3 = function(df) {
729 | var names = [];
730 | var length;
731 | for (var name in df) {
732 | if (df.hasOwnProperty(name))
733 | names.push(name);
734 | if (typeof(df[name]) !== "object" || typeof(df[name].length) === "undefined") {
735 | throw new Error("All fields must be arrays");
736 | } else if (typeof(length) !== "undefined" && length !== df[name].length) {
737 | throw new Error("All fields must be arrays of the same length");
738 | }
739 | length = df[name].length;
740 | }
741 | var results = [];
742 | var item;
743 | for (var row = 0; row < length; row++) {
744 | item = {};
745 | for (var col = 0; col < names.length; col++) {
746 | item[names[col]] = df[names[col]][row];
747 | }
748 | results.push(item);
749 | }
750 | return results;
751 | };
752 |
753 | window.HTMLWidgets.transposeArray2D = function(array) {
754 | if (array.length === 0) return array;
755 | var newArray = array[0].map(function(col, i) {
756 | return array.map(function(row) {
757 | return row[i]
758 | })
759 | });
760 | return newArray;
761 | };
762 | // Split value at splitChar, but allow splitChar to be escaped
763 | // using escapeChar. Any other characters escaped by escapeChar
764 | // will be included as usual (including escapeChar itself).
765 | function splitWithEscape(value, splitChar, escapeChar) {
766 | var results = [];
767 | var escapeMode = false;
768 | var currentResult = "";
769 | for (var pos = 0; pos < value.length; pos++) {
770 | if (!escapeMode) {
771 | if (value[pos] === splitChar) {
772 | results.push(currentResult);
773 | currentResult = "";
774 | } else if (value[pos] === escapeChar) {
775 | escapeMode = true;
776 | } else {
777 | currentResult += value[pos];
778 | }
779 | } else {
780 | currentResult += value[pos];
781 | escapeMode = false;
782 | }
783 | }
784 | if (currentResult !== "") {
785 | results.push(currentResult);
786 | }
787 | return results;
788 | }
789 | // Function authored by Yihui/JJ Allaire
790 | window.HTMLWidgets.evaluateStringMember = function(o, member) {
791 | var parts = splitWithEscape(member, '.', '\\');
792 | for (var i = 0, l = parts.length; i < l; i++) {
793 | var part = parts[i];
794 | // part may be a character or 'numeric' member name
795 | if (o !== null && typeof o === "object" && part in o) {
796 | if (i == (l - 1)) { // if we are at the end of the line then evalulate
797 | if (typeof o[part] === "string")
798 | o[part] = tryEval(o[part]);
799 | } else { // otherwise continue to next embedded object
800 | o = o[part];
801 | }
802 | }
803 | }
804 | };
805 |
806 | // Retrieve the HTMLWidget instance (i.e. the return value of an
807 | // HTMLWidget binding's initialize() or factory() function)
808 | // associated with an element, or null if none.
809 | window.HTMLWidgets.getInstance = function(el) {
810 | return elementData(el, "init_result");
811 | };
812 |
813 | // Finds the first element in the scope that matches the selector,
814 | // and returns the HTMLWidget instance (i.e. the return value of
815 | // an HTMLWidget binding's initialize() or factory() function)
816 | // associated with that element, if any. If no element matches the
817 | // selector, or the first matching element has no HTMLWidget
818 | // instance associated with it, then null is returned.
819 | //
820 | // The scope argument is optional, and defaults to window.document.
821 | window.HTMLWidgets.find = function(scope, selector) {
822 | if (arguments.length == 1) {
823 | selector = scope;
824 | scope = document;
825 | }
826 |
827 | var el = scope.querySelector(selector);
828 | if (el === null) {
829 | return null;
830 | } else {
831 | return window.HTMLWidgets.getInstance(el);
832 | }
833 | };
834 |
835 | // Finds all elements in the scope that match the selector, and
836 | // returns the HTMLWidget instances (i.e. the return values of
837 | // an HTMLWidget binding's initialize() or factory() function)
838 | // associated with the elements, in an array. If elements that
839 | // match the selector don't have an associated HTMLWidget
840 | // instance, the returned array will contain nulls.
841 | //
842 | // The scope argument is optional, and defaults to window.document.
843 | window.HTMLWidgets.findAll = function(scope, selector) {
844 | if (arguments.length == 1) {
845 | selector = scope;
846 | scope = document;
847 | }
848 |
849 | var nodes = scope.querySelectorAll(selector);
850 | var results = [];
851 | for (var i = 0; i < nodes.length; i++) {
852 | results.push(window.HTMLWidgets.getInstance(nodes[i]));
853 | }
854 | return results;
855 | };
856 |
857 | var postRenderHandlers = [];
858 | function invokePostRenderHandlers() {
859 | while (postRenderHandlers.length) {
860 | var handler = postRenderHandlers.shift();
861 | if (handler) {
862 | handler();
863 | }
864 | }
865 | }
866 |
867 | // Register the given callback function to be invoked after the
868 | // next time static widgets are rendered.
869 | window.HTMLWidgets.addPostRenderHandler = function(callback) {
870 | postRenderHandlers.push(callback);
871 | };
872 |
873 | // Takes a new-style instance-bound definition, and returns an
874 | // old-style class-bound definition. This saves us from having
875 | // to rewrite all the logic in this file to accomodate both
876 | // types of definitions.
877 | function createLegacyDefinitionAdapter(defn) {
878 | var result = {
879 | name: defn.name,
880 | type: defn.type,
881 | initialize: function(el, width, height) {
882 | return defn.factory(el, width, height);
883 | },
884 | renderValue: function(el, x, instance) {
885 | return instance.renderValue(x);
886 | },
887 | resize: function(el, width, height, instance) {
888 | return instance.resize(width, height);
889 | }
890 | };
891 |
892 | if (defn.find)
893 | result.find = defn.find;
894 | if (defn.renderError)
895 | result.renderError = defn.renderError;
896 | if (defn.clearError)
897 | result.clearError = defn.clearError;
898 |
899 | return result;
900 | }
901 | })();
902 |
--------------------------------------------------------------------------------