From 57e63718d66643434ec67f303070a647e1d74737 Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Tue, 28 Jan 2025 18:41:54 -0600
Subject: [PATCH 1/7] Workaround require.js for now by setting amd to false

---
 js/src/output.ts              | 2 +-
 shinywidgets/static/output.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/js/src/output.ts b/js/src/output.ts
index f844e56..6ef77db 100644
--- a/js/src/output.ts
+++ b/js/src/output.ts
@@ -37,7 +37,7 @@ const shinyRequireLoader = async function(moduleName: string, moduleVersion: str
   const oldAmd = (window as any).define.amd;
 
   // The is the original value for define.amd that require.js sets
-  (window as any).define.amd = {jQuery: true};
+  (window as any).define.amd = false;
 
   // Store jQuery global since loading we load a module, it may overwrite it
   // (qgrid is one good example)
diff --git a/shinywidgets/static/output.js b/shinywidgets/static/output.js
index 58531c7..af110e4 100644
--- a/shinywidgets/static/output.js
+++ b/shinywidgets/static/output.js
@@ -36,7 +36,7 @@ eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpac
   \***********************/
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides require.js and also sets `define.amd=false` to prevent <script>s\n    // with UMD loaders from triggering anonymous define() errors. shinywidgets should\n    // generally be able to avoid anonymous define errors though since there should only\n    // be one 'main' anonymous define() for the widget's module (located in a JS file that\n    // we've already require.config({paths: {...}})ed; and in that case, requirejs adds a\n    // data-requiremodule attribute to the <script> tag that shiny's custom define will\n    // recognize and use as the name).)\n    const oldAmd = window.define.amd;\n    // The is the original value for define.amd that require.js sets\n    window.define.amd = { jQuery: true };\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
+eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides require.js and also sets `define.amd=false` to prevent <script>s\n    // with UMD loaders from triggering anonymous define() errors. shinywidgets should\n    // generally be able to avoid anonymous define errors though since there should only\n    // be one 'main' anonymous define() for the widget's module (located in a JS file that\n    // we've already require.config({paths: {...}})ed; and in that case, requirejs adds a\n    // data-requiremodule attribute to the <script> tag that shiny's custom define will\n    // recognize and use as the name).)\n    const oldAmd = window.define.amd;\n    // The is the original value for define.amd that require.js sets\n    window.define.amd = false;\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
 
 /***/ }),
 

From 110f866e9eb2a088649255a3afc41997b5c64442 Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Tue, 28 Jan 2025 18:42:42 -0600
Subject: [PATCH 2/7] Be more lazy about initializing widget state on the
 front-end

---
 shinywidgets/_shinywidgets.py | 43 +++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 15 deletions(-)

diff --git a/shinywidgets/_shinywidgets.py b/shinywidgets/_shinywidgets.py
index 3b8f89d..2902dbd 100644
--- a/shinywidgets/_shinywidgets.py
+++ b/shinywidgets/_shinywidgets.py
@@ -96,9 +96,6 @@ def _cleanup_session_state():
 
         session.on_ended(_cleanup_session_state)
 
-    # Get the initial state of the widget
-    state, buffer_paths, buffers = _remove_buffers(w.get_state())
-
     # Make sure window.require() calls made by 3rd party widgets
     # (via handle_comm_open() -> new_model() -> loadClass() -> requireLoader())
     # actually point to directories served locally by shiny
@@ -114,18 +111,34 @@ def _cleanup_session_state():
 
     id = cast(str, w._model_id)
 
-    # Initialize the comm...this will also send the initial state of the widget
-    with widget_comm_patch():
-        w.comm = ShinyComm(
-            comm_id=id,
-            comm_manager=COMM_MANAGER,
-            target_name="jupyter.widgets",
-            data={"state": state, "buffer_paths": buffer_paths},
-            buffers=cast(BufferType, buffers),
-            # TODO: should this be hard-coded?
-            metadata={"version": __protocol_version__},
-            html_deps=session._process_ui(TagList(widget_dep))["deps"],
-        )
+    # Schedule the opening of the comm to happen sometime after this init function.
+    # This is important for widgets like plotly that do additional initialization that
+    # is required to get a valid widget state.
+    @reactive.effect(priority=99999)
+    def _open_comm():
+
+        # Call _repr_mimebundle_() before getting the state since it may modify the widget
+        # in an important way (unfortunately, plotly does this)
+        # # https://github.com/plotly/plotly.py/blob/0089f32/packages/python/plotly/plotly/basewidget.py#L734-L738
+        w._repr_mimebundle_()
+
+        # Now, get the state
+        state, buffer_paths, buffers = _remove_buffers(w.get_state())
+
+        # Initialize the comm -- this sends widget state to the frontend
+        with widget_comm_patch():
+            w.comm = ShinyComm(
+                comm_id=id,
+                comm_manager=COMM_MANAGER,
+                target_name="jupyter.widgets",
+                data={"state": state, "buffer_paths": buffer_paths},
+                buffers=cast(BufferType, buffers),
+                # TODO: should this be hard-coded?
+                metadata={"version": __protocol_version__},
+                html_deps=session._process_ui(TagList(widget_dep))["deps"],
+            )
+
+        _open_comm.destroy()
 
     # If we're in a reactive context, close this widget when the context is invalidated
     # TODO: this should probably only be done in an output context, but I'm pretty sure

From 66bfe47b39a584c67710f24133e5d371a753afcf Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Tue, 28 Jan 2025 19:05:18 -0600
Subject: [PATCH 3/7] Set responsive=True in config by default (without this,
 plotly won't fill it's container in v6)

---
 shinywidgets/_render_widget_base.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/shinywidgets/_render_widget_base.py b/shinywidgets/_render_widget_base.py
index bb5a345..7f80e5e 100644
--- a/shinywidgets/_render_widget_base.py
+++ b/shinywidgets/_render_widget_base.py
@@ -178,6 +178,9 @@ def set_layout_defaults(widget: Widget) -> Tuple[Widget, bool]:
             # so change that 60px default to 32px
             if layout.margin["t"] == 60:  # pyright: ignore
                 layout.margin["t"] = 32  # pyright: ignore
+            # In plotly >=v6.0, the plot won't actually fill unless it's responsive
+            if fill:
+                widget._config = {"responsive": True, **widget._config}  # type: ignore
 
     widget.layout = layout
 

From c2cc0fff5d6741013beeae7e74d59ff74c378dfc Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Tue, 28 Jan 2025 19:07:53 -0600
Subject: [PATCH 4/7] Update changelog

---
 CHANGELOG.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ef63a12..8fd1a6b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [UNRELEASED] - 2025-01-23
 
+* Updates to accomodate the new plotly v6.0.0 release. (#182)
 * Fixed an issue with plotly graphs sometimes not getting fully removed from the DOM. (#178)
 * Fixed an issue with ipyleaflet erroring out when attempting to read the `.model_id` property of a closed widget object. (#179)
 * Fixed an issue where altair charts would sometimes render to a 0 height after being shown, hidden, and then shown again. (#180)

From fafedbf0f0f10e8ed0ae8a4d96e104885f5374bb Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Wed, 29 Jan 2025 09:52:16 -0600
Subject: [PATCH 5/7] Update comment about AMD loaders

---
 js/src/output.ts              | 17 +++++++++--------
 shinywidgets/static/output.js |  2 +-
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/js/src/output.ts b/js/src/output.ts
index 6ef77db..9718967 100644
--- a/js/src/output.ts
+++ b/js/src/output.ts
@@ -27,16 +27,17 @@ class OutputManager extends HTMLManager {
 // Define our own custom module loader for Shiny
 const shinyRequireLoader = async function(moduleName: string, moduleVersion: string): Promise<any> {
 
-  // shiny provides require.js and also sets `define.amd=false` to prevent <script>s
-  // with UMD loaders from triggering anonymous define() errors. shinywidgets should
-  // generally be able to avoid anonymous define errors though since there should only
-  // be one 'main' anonymous define() for the widget's module (located in a JS file that
-  // we've already require.config({paths: {...}})ed; and in that case, requirejs adds a
-  // data-requiremodule attribute to the <script> tag that shiny's custom define will
-  // recognize and use as the name).)
+  // shiny provides a shim of require.js and also sets `define.amd=false` to
+  // allow <script>s with anonymous define()s to be loaded without error.
+  // Note that, when anonymous define()s are used, the shim will leverage the
+  // data-requiremodule attribute to determine the module name.
+  // In the context of shinywidgets, when a widget gets rendered, it should
+  // include another <script> tag that does `require.config({paths: {...}})`
+  // to map the module name to the URL of the widget's JS file.
   const oldAmd = (window as any).define.amd;
 
-  // The is the original value for define.amd that require.js sets
+  // This is probably not necessary, but just in case -- especially now in a
+  // anywidget/ES6 world, we probably don't want to load AMD modules
   (window as any).define.amd = false;
 
   // Store jQuery global since loading we load a module, it may overwrite it
diff --git a/shinywidgets/static/output.js b/shinywidgets/static/output.js
index af110e4..c930b5b 100644
--- a/shinywidgets/static/output.js
+++ b/shinywidgets/static/output.js
@@ -36,7 +36,7 @@ eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpac
   \***********************/
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides require.js and also sets `define.amd=false` to prevent <script>s\n    // with UMD loaders from triggering anonymous define() errors. shinywidgets should\n    // generally be able to avoid anonymous define errors though since there should only\n    // be one 'main' anonymous define() for the widget's module (located in a JS file that\n    // we've already require.config({paths: {...}})ed; and in that case, requirejs adds a\n    // data-requiremodule attribute to the <script> tag that shiny's custom define will\n    // recognize and use as the name).)\n    const oldAmd = window.define.amd;\n    // The is the original value for define.amd that require.js sets\n    window.define.amd = false;\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
+eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides a shim of require.js and also sets `define.amd=false` to\n    // allow <script>s with anonymous define()s to be loaded without error.\n    // Note that, when anonymous define()s are used, the shim will leverage the\n    // data-requiremodule attribute to determine the module name.\n    // In the context of shinywidgets, when a widget gets rendered, it should\n    // include another <script> tag that does `require.config({paths: {...}})`\n    // to map the module name to the URL of the widget's JS file.\n    const oldAmd = window.define.amd;\n    // This is probably not necessary, but just in case -- especially now in a\n    // anywidget/ES6 world, we probably don't want to load AMD modules\n    window.define.amd = false;\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
 
 /***/ }),
 

From 1d4d54c57545585c3a5c888c583f701a95c2fc4d Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Wed, 29 Jan 2025 10:07:18 -0600
Subject: [PATCH 6/7] Avoid the opening of an unknown/unnecessary comm

---
 shinywidgets/_shinywidgets.py | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/shinywidgets/_shinywidgets.py b/shinywidgets/_shinywidgets.py
index 2902dbd..51fe713 100644
--- a/shinywidgets/_shinywidgets.py
+++ b/shinywidgets/_shinywidgets.py
@@ -111,14 +111,19 @@ def _cleanup_session_state():
 
     id = cast(str, w._model_id)
 
+    # Since the actual ShinyComm() is initialized _after_ the Widget is initialized,
+    # and Widget.__init__() includes a call to Widget.open() which opens an unnecessary
+    # comm, we just set the comm to a dummy comm for now (to avoid unnecessary work)
+    w.comm = OrphanedShinyComm(id)
+
     # Schedule the opening of the comm to happen sometime after this init function.
     # This is important for widgets like plotly that do additional initialization that
     # is required to get a valid widget state.
     @reactive.effect(priority=99999)
-    def _open_comm():
+    def _open_shiny_comm():
 
-        # Call _repr_mimebundle_() before getting the state since it may modify the widget
-        # in an important way (unfortunately, plotly does this)
+        # Call _repr_mimebundle_() before get_state() since it may modify the widget
+        # in an important way (unfortunately, it does for plotly)
         # # https://github.com/plotly/plotly.py/blob/0089f32/packages/python/plotly/plotly/basewidget.py#L734-L738
         w._repr_mimebundle_()
 
@@ -138,7 +143,7 @@ def _open_comm():
                 html_deps=session._process_ui(TagList(widget_dep))["deps"],
             )
 
-        _open_comm.destroy()
+        _open_shiny_comm.destroy()
 
     # If we're in a reactive context, close this widget when the context is invalidated
     # TODO: this should probably only be done in an output context, but I'm pretty sure

From e880803327dca7389e03d9ae765dc48a09d0b204 Mon Sep 17 00:00:00 2001
From: Carson <cpsievert1@gmail.com>
Date: Wed, 29 Jan 2025 10:18:18 -0600
Subject: [PATCH 7/7] Cleanup comment

---
 js/src/output.ts              | 14 ++++++++------
 shinywidgets/static/output.js |  2 +-
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/js/src/output.ts b/js/src/output.ts
index 9718967..8ace1d6 100644
--- a/js/src/output.ts
+++ b/js/src/output.ts
@@ -27,17 +27,19 @@ class OutputManager extends HTMLManager {
 // Define our own custom module loader for Shiny
 const shinyRequireLoader = async function(moduleName: string, moduleVersion: string): Promise<any> {
 
-  // shiny provides a shim of require.js and also sets `define.amd=false` to
-  // allow <script>s with anonymous define()s to be loaded without error.
-  // Note that, when anonymous define()s are used, the shim will leverage the
-  // data-requiremodule attribute to determine the module name.
+  // shiny provides a shim of require.js which allows <script>s with anonymous
+  // define()s to be loaded without error. When an anonymous define() occurs,
+  // the shim uses the data-requiremodule attribute (set by require.js) on the script
+  // to determine the module name.
+  // https://github.com/posit-dev/py-shiny/blob/230940c/scripts/define-shims.js#L10-L16
   // In the context of shinywidgets, when a widget gets rendered, it should
-  // include another <script> tag that does `require.config({paths: {...}})`
-  // to map the module name to the URL of the widget's JS file.
+  // come with another <script> tag that does `require.config({paths: {...}})`
+  // which maps the module name to a URL of the widget's JS file.
   const oldAmd = (window as any).define.amd;
 
   // This is probably not necessary, but just in case -- especially now in a
   // anywidget/ES6 world, we probably don't want to load AMD modules
+  // (plotly is one example of a widget that will fail to load if AMD is enabled)
   (window as any).define.amd = false;
 
   // Store jQuery global since loading we load a module, it may overwrite it
diff --git a/shinywidgets/static/output.js b/shinywidgets/static/output.js
index c930b5b..3c8e298 100644
--- a/shinywidgets/static/output.js
+++ b/shinywidgets/static/output.js
@@ -36,7 +36,7 @@ eval("__webpack_require__.r(__webpack_exports__);\n/* harmony export */ __webpac
   \***********************/
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides a shim of require.js and also sets `define.amd=false` to\n    // allow <script>s with anonymous define()s to be loaded without error.\n    // Note that, when anonymous define()s are used, the shim will leverage the\n    // data-requiremodule attribute to determine the module name.\n    // In the context of shinywidgets, when a widget gets rendered, it should\n    // include another <script> tag that does `require.config({paths: {...}})`\n    // to map the module name to the URL of the widget's JS file.\n    const oldAmd = window.define.amd;\n    // This is probably not necessary, but just in case -- especially now in a\n    // anywidget/ES6 world, we probably don't want to load AMD modules\n    window.define.amd = false;\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
+eval("__webpack_require__.r(__webpack_exports__);\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @jupyter-widgets/html-manager */ \"@jupyter-widgets/html-manager\");\n/* harmony import */ var _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__);\n/* harmony import */ var _comm__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./comm */ \"./src/comm.ts\");\n/* harmony import */ var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./utils */ \"./src/utils.ts\");\nvar _a;\n\n\n\n/******************************************************************************\n * Define a custom HTMLManager for use with Shiny\n ******************************************************************************/\nclass OutputManager extends _jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.HTMLManager {\n    // In a soon-to-be-released version of @jupyter-widgets/html-manager,\n    // display_view()'s first \"dummy\" argument will be removed... this shim simply\n    // makes it so that our manager can work with either version\n    // https://github.com/jupyter-widgets/ipywidgets/commit/159bbe4#diff-45c126b24c3c43d2cee5313364805c025e911c4721d45ff8a68356a215bfb6c8R42-R43\n    async display_view(view, options) {\n        const n_args = super.display_view.length;\n        if (n_args === 3) {\n            return super.display_view({}, view, options);\n        }\n        else {\n            // @ts-ignore\n            return super.display_view(view, options);\n        }\n    }\n}\n// Define our own custom module loader for Shiny\nconst shinyRequireLoader = async function (moduleName, moduleVersion) {\n    // shiny provides a shim of require.js which allows <script>s with anonymous\n    // define()s to be loaded without error. When an anonymous define() occurs,\n    // the shim uses the data-requiremodule attribute (set by require.js) on the script\n    // to determine the module name.\n    // https://github.com/posit-dev/py-shiny/blob/230940c/scripts/define-shims.js#L10-L16\n    // In the context of shinywidgets, when a widget gets rendered, it should\n    // come with another <script> tag that does `require.config({paths: {...}})`\n    // which maps the module name to a URL of the widget's JS file.\n    const oldAmd = window.define.amd;\n    // This is probably not necessary, but just in case -- especially now in a\n    // anywidget/ES6 world, we probably don't want to load AMD modules\n    // (plotly is one example of a widget that will fail to load if AMD is enabled)\n    window.define.amd = false;\n    // Store jQuery global since loading we load a module, it may overwrite it\n    // (qgrid is one good example)\n    const old$ = window.$;\n    const oldJQ = window.jQuery;\n    if (moduleName === 'qgrid') {\n        // qgrid wants to use base/js/dialog (if it's available) for full-screen tables\n        // https://github.com/quantopian/qgrid/blob/877b420/js/src/qgrid.widget.js#L11-L16\n        // Maybe that's worth supporting someday, but for now, we define it to be nothing\n        // to avoid require('qgrid') from producing an error\n        window.define(\"base/js/dialog\", [], function () { return null; });\n    }\n    return (0,_jupyter_widgets_html_manager__WEBPACK_IMPORTED_MODULE_0__.requireLoader)(moduleName, moduleVersion).finally(() => {\n        window.define.amd = oldAmd;\n        window.$ = old$;\n        window.jQuery = oldJQ;\n    });\n};\nconst manager = new OutputManager({ loader: shinyRequireLoader });\n/******************************************************************************\n* Define the Shiny binding\n******************************************************************************/\n// Ideally we'd extend Shiny's HTMLOutputBinding, but the implementation isn't exported\nclass IPyWidgetOutput extends Shiny.OutputBinding {\n    find(scope) {\n        return $(scope).find(\".shiny-ipywidget-output\");\n    }\n    onValueError(el, err) {\n        Shiny.unbindAll(el);\n        this.renderError(el, err);\n    }\n    async renderValue(el, data) {\n        // Allow for a None/null value to hide the widget (css inspired by htmlwidgets)\n        if (!data) {\n            el.style.visibility = \"hidden\";\n            return;\n        }\n        else {\n            el.style.visibility = \"inherit\";\n        }\n        // Only forward the potential to fill if `output_widget(fillable=True)`\n        // _and_ the widget instance wants to fill\n        const fill = data.fill && el.classList.contains(\"html-fill-container\");\n        if (fill)\n            el.classList.add(\"forward-fill-potential\");\n        // At this time point, we should've already handled an 'open' message, and so\n        // the model should be ready to use\n        const model = await manager.get_model(data.model_id);\n        if (!model) {\n            throw new Error(`No model found for id ${data.model_id}`);\n        }\n        const view = await manager.create_view(model, {});\n        await manager.display_view(view, { el: el });\n        // The ipywidgets container (.lmWidget)\n        const lmWidget = el.children[0];\n        if (fill) {\n            this._onImplementation(lmWidget, () => this._doAddFillClasses(lmWidget));\n        }\n        this._onImplementation(lmWidget, this._doResize);\n    }\n    _onImplementation(lmWidget, callback) {\n        if (this._hasImplementation(lmWidget)) {\n            callback();\n            return;\n        }\n        // Some widget implementation (e.g., ipyleaflet, pydeck) won't actually\n        // have rendered to the DOM at this point, so wait until they do\n        const mo = new MutationObserver((mutations) => {\n            if (this._hasImplementation(lmWidget)) {\n                mo.disconnect();\n                callback();\n            }\n        });\n        mo.observe(lmWidget, { childList: true });\n    }\n    // In most cases, we can get widgets to fill through Python/CSS, but some widgets\n    // (e.g., quak) don't have a Python API and use shadow DOM, which can only access\n    // from JS\n    _doAddFillClasses(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        const isQuakWidget = impl && !!((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.querySelector(\".quak\"));\n        if (isQuakWidget) {\n            impl.classList.add(\"html-fill-container\", \"html-fill-item\");\n            const quakWidget = impl.shadowRoot.querySelector(\".quak\");\n            quakWidget.style.maxHeight = \"unset\";\n        }\n    }\n    _doResize() {\n        // Trigger resize event to force layout (setTimeout() is needed for altair)\n        // TODO: debounce this call?\n        setTimeout(() => {\n            window.dispatchEvent(new Event('resize'));\n        }, 0);\n    }\n    _hasImplementation(lmWidget) {\n        var _a;\n        const impl = lmWidget.children[0];\n        return impl && (impl.children.length > 0 || ((_a = impl.shadowRoot) === null || _a === void 0 ? void 0 : _a.children.length) > 0);\n    }\n}\nShiny.outputBindings.register(new IPyWidgetOutput(), \"shiny.IPyWidgetOutput\");\n// Due to the way HTMLManager (and widget implementations) get loaded (via\n// require.js), the binding registration above can happen _after_ Shiny has\n// already bound the DOM, especially in the dynamic UI case (i.e., output_binding()'s\n// dependencies don't come in until after initial page load). And, in the dynamic UI\n// case, UI is rendered asychronously via Shiny.shinyapp.taskQueue, so if it exists,\n// we probably need to re-bind the DOM after the taskQueue is done.\nconst taskQueue = (_a = Shiny === null || Shiny === void 0 ? void 0 : Shiny.shinyapp) === null || _a === void 0 ? void 0 : _a.taskQueue;\nif (taskQueue) {\n    taskQueue.enqueue(() => Shiny.bindAll(document.body));\n}\n/******************************************************************************\n* Handle messages from the server-side Widget\n******************************************************************************/\n// Initialize the comm and model when a new widget is created\n// This is basically our version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1144-L1176\nShiny.addCustomMessageHandler(\"shinywidgets_comm_open\", (msg_txt) => {\n    setBaseURL();\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    Shiny.renderDependencies(msg.content.html_deps);\n    const comm = new _comm__WEBPACK_IMPORTED_MODULE_1__.ShinyComm(msg.content.comm_id);\n    manager.handle_comm_open(comm, msg);\n});\n// Handle any mutation of the model (e.g., add a marker to a map, without a full redraw)\n// Basically out version of https://github.com/jupyterlab/jupyterlab/blob/d33de15/packages/services/src/kernel/default.ts#L1200-L1215\nShiny.addCustomMessageHandler(\"shinywidgets_comm_msg\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't handle message for model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // @ts-ignore for some reason IClassicComm doesn't have this method, but we do\n        m.comm.handle_msg(msg);\n    }\n    catch (err) {\n        console.error(\"Error handling message:\", err);\n    }\n});\n// Handle the closing of a widget/comm/model\nShiny.addCustomMessageHandler(\"shinywidgets_comm_close\", async (msg_txt) => {\n    const msg = (0,_utils__WEBPACK_IMPORTED_MODULE_2__.jsonParse)(msg_txt);\n    const id = msg.content.comm_id;\n    const model = manager.get_model(id);\n    if (!model) {\n        console.error(`Couldn't close model ${id} because it doesn't exist.`);\n        return;\n    }\n    try {\n        const m = await model;\n        // Before .close()ing the model (which will .remove() each view), do some\n        // additional cleanup that .remove() might miss\n        await Promise.all(Object.values(m.views).map(async (viewPromise) => {\n            try {\n                const v = await viewPromise;\n                // Old versions of plotly need a .destroy() to properly clean up\n                // https://github.com/plotly/plotly.py/pull/3805/files#diff-259c92d\n                if (hasMethod(v, 'destroy')) {\n                    v.destroy();\n                    // Also, empirically, when this destroy() is relevant, it also helps to\n                    // delete the view's reference to the model, I think this is the only\n                    // way to drop the resize event listener (see the diff in the link above)\n                    // https://github.com/posit-dev/py-shinywidgets/issues/166\n                    delete v.model;\n                    // Ensure sure the lm-Widget container is also removed\n                    v.remove();\n                }\n            }\n            catch (err) {\n                console.error(\"Error cleaning up view:\", err);\n            }\n        }));\n        // Close model after all views are cleaned up\n        await m.close();\n        // Trigger comm:close event to remove manager's reference\n        m.trigger(\"comm:close\");\n    }\n    catch (err) {\n        console.error(\"Error during model cleanup:\", err);\n    }\n});\n$(document).on(\"shiny:disconnected\", () => {\n    manager.clear_state();\n});\n// When in filling layout, some widgets (specifically, altair) incorrectly think their\n// height is 0 after it's shown, hidden, then shown again. As a workaround, trigger a\n// resize event when a tab is shown.\n// TODO: This covers the 95% use case, but it's definitely not an ideal way to handle\n// this situation. A more robust solution would use IntersectionObserver to detect when\n// the widget becomes visible. Or better yet, we'd get altair to handle this situation\n// better.\n// https://github.com/posit-dev/py-shinywidgets/issues/172\ndocument.addEventListener('shown.bs.tab', event => {\n    window.dispatchEvent(new Event('resize'));\n});\n// Our version of https://github.com/jupyter-widgets/widget-cookiecutter/blob/9694718/%7B%7Bcookiecutter.github_project_name%7D%7D/js/lib/extension.js#L8\nfunction setBaseURL(x = '') {\n    const base_url = document.querySelector('body').getAttribute('data-base-url');\n    if (!base_url) {\n        document.querySelector('body').setAttribute('data-base-url', x);\n    }\n}\n// TypeGuard to safely check if an object has a method\nfunction hasMethod(obj, methodName) {\n    return typeof obj[methodName] === 'function';\n}\n\n\n//# sourceURL=webpack://@jupyter-widgets/shiny-embed-manager/./src/output.ts?");
 
 /***/ }),