@difizen/libro-widget 0.0.2-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-present Difizen Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# libro-widget

package/es/base/comm.d.ts

@@ -0,0 +1,65 @@
+import type { JSONObject } from '@difizen/libro-common';
+import type { IComm, IKernelConnection, IShellFuture } from '@difizen/libro-kernel';
+import type { ICallbacks, IClassicComm } from './protocal.js';
+import { WidgetCommOption } from './protocal.js';
+/**
+ * Public constructor
+ * @param  {IComm} jsServicesComm - @jupyterlab/services IComm instance
+ */
+export declare class Comm implements IClassicComm {
+    constructor(options: WidgetCommOption);
+    /**
+     * Comm id
+     * @return {string}
+     */
+    get comm_id(): string;
+    /**
+     * Target name
+     * @return {string}
+     */
+    get target_name(): string;
+    /**
+     * Opens a sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @return msg id
+     */
+    open(data: JSONObject, callbacks?: ICallbacks, metadata?: JSONObject, buffers?: ArrayBuffer[] | ArrayBufferView[]): string;
+    /**
+     * Sends a message to the sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @param  buffers
+     * @return message id
+     */
+    send(data: JSONObject, callbacks?: ICallbacks, metadata?: JSONObject, buffers?: ArrayBuffer[] | ArrayBufferView[]): string;
+    /**
+     * Closes the sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @return msg id
+     */
+    close(data?: JSONObject, callbacks?: ICallbacks, metadata?: JSONObject, buffers?: ArrayBuffer[] | ArrayBufferView[]): string;
+    /**
+     * Register a message handler
+     * @param  callback, which is given a message
+     */
+    on_msg(callback: (x: any) => void): void;
+    /**
+     * Register a handler for when the comm is closed by the backend
+     * @param  callback, which is given a message
+     */
+    on_close(callback: (x: any) => void): void;
+    /**
+     * Hooks callback object up with @jupyterlab/services IKernelFuture
+     * @param  @jupyterlab/services IKernelFuture instance
+     * @param  callbacks
+     */
+    _hookupCallbacks(future: IShellFuture, callbacks?: ICallbacks): void;
+    jsServicesComm: IComm;
+    kernel: IKernelConnection;
+}
+//# sourceMappingURL=comm.d.ts.map

package/es/base/comm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comm.d.ts","sourceRoot":"","sources":["../../src/base/comm.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,KAAK,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGpF,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAEjD;;;GAGG;AACH,qBACa,IAAK,YAAW,YAAY;gBACD,OAAO,EAAE,gBAAgB;IAI/D;;;OAGG;IACH,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;;OAMG;IACH,IAAI,CACF,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,UAAU,EACrB,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,eAAe,EAAE,GAC1C,MAAM;IAMT;;;;;;;OAOG;IACH,IAAI,CACF,IAAI,EAAE,UAAU,EAChB,SAAS,CAAC,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,UAAU,EACrB,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,eAAe,EAAE,GAC1C,MAAM;IAMT;;;;;;OAMG;IACH,KAAK,CACH,IAAI,CAAC,EAAE,UAAU,EACjB,SAAS,CAAC,EAAE,UAAU,EACtB,QAAQ,CAAC,EAAE,UAAU,EACrB,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,eAAe,EAAE,GAC1C,MAAM;IAMT;;;OAGG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAIxC;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,IAAI,GAAG,IAAI;IAI1C;;;;OAIG;IACH,gBAAgB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,CAAC,EAAE,UAAU,GAAG,IAAI;IAwCpE,cAAc,EAAE,KAAK,CAAC;IACtB,MAAM,EAAE,iBAAiB,CAAC;CAC3B"}

package/es/base/comm.js

@@ -0,0 +1,151 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _dec, _class;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+import { inject, transient } from '@difizen/mana-app';
+import { WidgetCommOption } from "./protocal.js";
+
+/**
+ * Public constructor
+ * @param  {IComm} jsServicesComm - @jupyterlab/services IComm instance
+ */
+export var Comm = (_dec = transient(), _dec(_class = /*#__PURE__*/function () {
+  function Comm(options) {
+    _classCallCheck(this, Comm);
+    this.jsServicesComm = options.comm;
+  }
+
+  /**
+   * Comm id
+   * @return {string}
+   */
+  Comm = inject(WidgetCommOption)(Comm, undefined, 0) || Comm;
+  _createClass(Comm, [{
+    key: "comm_id",
+    get: function get() {
+      return this.jsServicesComm.commId;
+    }
+
+    /**
+     * Target name
+     * @return {string}
+     */
+  }, {
+    key: "target_name",
+    get: function get() {
+      return this.jsServicesComm.targetName;
+    }
+
+    /**
+     * Opens a sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @return msg id
+     */
+  }, {
+    key: "open",
+    value: function open(data, callbacks, metadata, buffers) {
+      var future = this.jsServicesComm.open(data, metadata, buffers);
+      this._hookupCallbacks(future, callbacks);
+      return future.msg.header.msg_id;
+    }
+
+    /**
+     * Sends a message to the sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @param  buffers
+     * @return message id
+     */
+  }, {
+    key: "send",
+    value: function send(data, callbacks, metadata, buffers) {
+      var future = this.jsServicesComm.send(data, metadata, buffers);
+      this._hookupCallbacks(future, callbacks);
+      return future.msg.header.msg_id;
+    }
+
+    /**
+     * Closes the sibling comm in the backend
+     * @param  data
+     * @param  callbacks
+     * @param  metadata
+     * @return msg id
+     */
+  }, {
+    key: "close",
+    value: function close(data, callbacks, metadata, buffers) {
+      var future = this.jsServicesComm.close(data, metadata, buffers);
+      this._hookupCallbacks(future, callbacks);
+      return future.msg.header.msg_id;
+    }
+
+    /**
+     * Register a message handler
+     * @param  callback, which is given a message
+     */
+  }, {
+    key: "on_msg",
+    value: function on_msg(callback) {
+      this.jsServicesComm.onMsg = callback.bind(this);
+    }
+
+    /**
+     * Register a handler for when the comm is closed by the backend
+     * @param  callback, which is given a message
+     */
+  }, {
+    key: "on_close",
+    value: function on_close(callback) {
+      this.jsServicesComm.onClose = callback.bind(this);
+    }
+
+    /**
+     * Hooks callback object up with @jupyterlab/services IKernelFuture
+     * @param  @jupyterlab/services IKernelFuture instance
+     * @param  callbacks
+     */
+  }, {
+    key: "_hookupCallbacks",
+    value: function _hookupCallbacks(future, callbacks) {
+      if (callbacks) {
+        future.onReply = function (msg) {
+          if (callbacks.shell && callbacks.shell['reply']) {
+            callbacks.shell['reply'](msg);
+          }
+        };
+        future.onStdin = function (msg) {
+          if (callbacks.input) {
+            callbacks.input(msg);
+          }
+        };
+        future.onIOPub = function (msg) {
+          if (callbacks.iopub) {
+            if (callbacks.iopub['status'] && msg.header.msg_type === 'status') {
+              callbacks.iopub['status'](msg);
+            } else if (callbacks.iopub['clear_output'] && msg.header.msg_type === 'clear_output') {
+              callbacks.iopub['clear_output'](msg);
+            } else if (callbacks.iopub['output']) {
+              switch (msg.header.msg_type) {
+                case 'display_data':
+                case 'execute_result':
+                case 'stream':
+                case 'error':
+                  callbacks.iopub['output'](msg);
+                  break;
+                default:
+                  break;
+              }
+            }
+          }
+        };
+      }
+    }
+  }]);
+  return Comm;
+}()) || _class);

package/es/base/index.d.ts

@@ -0,0 +1,7 @@
+export * from './libro-widgets.js';
+export * from './widget-view.js';
+export * from './protocal.js';
+export * from './widget-manager.js';
+export * from './comm.js';
+export * from './widget-view-contribution.js';
+//# sourceMappingURL=index.d.ts.map

package/es/base/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/base/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,eAAe,CAAC;AAC9B,cAAc,qBAAqB,CAAC;AACpC,cAAc,WAAW,CAAC;AAC1B,cAAc,+BAA+B,CAAC"}

package/es/base/index.js

@@ -0,0 +1,6 @@
+export * from "./libro-widgets.js";
+export * from "./widget-view.js";
+export * from "./protocal.js";
+export * from "./widget-manager.js";
+export * from "./comm.js";
+export * from "./widget-view-contribution.js";

package/es/base/libro-widgets.d.ts

@@ -0,0 +1,79 @@
+import type { JSONObject } from '@difizen/libro-common';
+import type { IKernelConnection, KernelMessage } from '@difizen/libro-kernel';
+import type { Contribution } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import type { Comm } from './comm.js';
+import type { IWidgets, IWidgetViewOptions, IClassicComm, WidgetCommOption } from './protocal.js';
+import { WidgetsOption, WidgetViewContribution } from './protocal.js';
+import type { WidgetView } from './widget-view.js';
+export declare class LibroWidgets implements IWidgets {
+    WidgetViewProvider: Contribution.Provider<WidgetViewContribution>;
+    widgetEmitter: Emitter<{
+        WidgetViewName: string;
+    }>;
+    widgetCommFactory: (options: WidgetCommOption) => Comm;
+    kernelConnection: IKernelConnection;
+    constructor(options: WidgetsOption, widgetCommFactory: (options: WidgetCommOption) => Comm);
+    get onWidgetRender(): import("@difizen/mana-app").Event<{
+        WidgetViewName: string;
+    }>;
+    protected findProvider(attributes: any): WidgetViewContribution;
+    /**
+     * Create a comm which can be used for communication for a widget.
+     *
+     * If the data/metadata is passed in, open the comm before returning (i.e.,
+     * send the comm_open message). If the data and metadata is undefined, we
+     * want to reconstruct a comm that already exists in the kernel, so do not
+     * open the comm by sending the comm_open message.
+     *
+     * @param comm_target_name Comm target name
+     * @param model_id The comm id
+     * @param data The initial data for the comm
+     * @param metadata The metadata in the open message
+     */
+    createComm(comm_target_name: string, model_id?: string, data?: JSONObject, metadata?: JSONObject, buffers?: ArrayBuffer[] | ArrayBufferView[]): Promise<IClassicComm>;
+    /**
+     * Get a model by model id.
+     *
+     * #### Notes
+     * If the model is not found, throw error.
+     *
+     * If you would like to synchronously test if a model exists, use .hasModel().
+     */
+    getModel(model_id: string): WidgetView;
+    /**
+     * Returns true if the given model is registered, otherwise false.
+     *
+     * #### Notes
+     * This is a synchronous way to check if a model is registered.
+     */
+    hasModel(model_id: string): boolean;
+    /**
+     * Handle when a comm is opened.
+     */
+    handleCommOpen(comm: IClassicComm, msg: KernelMessage.ICommOpenMsg): Promise<WidgetView>;
+    registerWidgetView(model_id: string, model: Promise<WidgetView>): void;
+    handleCommClose(msg: KernelMessage.ICommCloseMsg): void;
+    unregisterWidgetView(model_id: string): void;
+    newWidgetView(attributes: any, options: IWidgetViewOptions): Promise<WidgetView>;
+    /**
+     * Close all widgets and empty the widget state.
+     * @return Promise that resolves when the widget state is cleared.
+     */
+    clearState(): void;
+    /**
+     * Disconnect the widget manager from the kernel, setting each model's comm
+     * as dead.
+     */
+    disconnect(): void;
+    /**
+     * Dictionary of model ids and model instance promises
+     */
+    private models;
+    /**
+     * The comm target name to register
+     */
+    id: string;
+    readonly commTargetName = "jupyter.widget";
+}
+//# sourceMappingURL=libro-widgets.d.ts.map

package/es/base/libro-widgets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libro-widgets.d.ts","sourceRoot":"","sources":["../../src/base/libro-widgets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,KAAK,EAEV,QAAQ,EACR,kBAAkB,EAClB,YAAY,EACZ,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,aAAa,EACb,sBAAsB,EACvB,MAAM,eAAe,CAAC;AAGvB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,qBACa,YAAa,YAAW,QAAQ;IAE3C,kBAAkB,EAAE,YAAY,CAAC,QAAQ,CAAC,sBAAsB,CAAC,CAAC;IAClE,aAAa,EAAE,OAAO,CAAC;QAAE,cAAc,EAAE,MAAM,CAAA;KAAE,CAAC,CAAiB;IACnE,iBAAiB,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACvD,gBAAgB,EAAE,iBAAiB,CAAC;gBAGX,OAAO,EAAE,aAAa,EAE7C,iBAAiB,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI;IAUxD,IAAI,cAAc;;OAEjB;IAED,SAAS,CAAC,YAAY,CAAC,UAAU,EAAE,GAAG,GAAG,sBAAsB;IAS/D;;;;;;;;;;;;OAYG;IACG,UAAU,CACd,gBAAgB,EAAE,MAAM,EACxB,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,UAAU,EACjB,QAAQ,CAAC,EAAE,UAAU,EACrB,OAAO,CAAC,EAAE,WAAW,EAAE,GAAG,eAAe,EAAE,GAC1C,OAAO,CAAC,YAAY,CAAC;IAYxB;;;;;;;OAOG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU;IAQtC;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAInC;;OAEG;IACG,cAAc,CAClB,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,aAAa,CAAC,YAAY,GAC9B,OAAO,CAAC,UAAU,CAAC;IAkBtB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI;IAYtE,eAAe,CAAC,GAAG,EAAE,aAAa,CAAC,aAAa;IAMhD,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAMtC,aAAa,CACjB,UAAU,EAAE,GAAG,EACf,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,UAAU,CAAC;IActB;;;OAGG;IACH,UAAU;IAGV;;;OAGG;IACH,UAAU,IAAI,IAAI;IAGlB;;OAEG;IAEH,OAAO,CAAC,MAAM,CAAsC;IAEpD;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,CAAC,cAAc,oBAAoB;CAC5C"}

package/es/base/libro-widgets.js

@@ -0,0 +1,285 @@
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+var _dec, _dec2, _dec3, _class, _class2, _descriptor, _descriptor2;
+function _regeneratorRuntime() { "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */ _regeneratorRuntime = function _regeneratorRuntime() { return exports; }; var exports = {}, Op = Object.prototype, hasOwn = Op.hasOwnProperty, defineProperty = Object.defineProperty || function (obj, key, desc) { obj[key] = desc.value; }, $Symbol = "function" == typeof Symbol ? Symbol : {}, iteratorSymbol = $Symbol.iterator || "@@iterator", asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; function define(obj, key, value) { return Object.defineProperty(obj, key, { value: value, enumerable: !0, configurable: !0, writable: !0 }), obj[key]; } try { define({}, ""); } catch (err) { define = function define(obj, key, value) { return obj[key] = value; }; } function wrap(innerFn, outerFn, self, tryLocsList) { var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, generator = Object.create(protoGenerator.prototype), context = new Context(tryLocsList || []); return defineProperty(generator, "_invoke", { value: makeInvokeMethod(innerFn, self, context) }), generator; } function tryCatch(fn, obj, arg) { try { return { type: "normal", arg: fn.call(obj, arg) }; } catch (err) { return { type: "throw", arg: err }; } } exports.wrap = wrap; var ContinueSentinel = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var IteratorPrototype = {}; define(IteratorPrototype, iteratorSymbol, function () { return this; }); var getProto = Object.getPrototypeOf, NativeIteratorPrototype = getProto && getProto(getProto(values([]))); NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); function defineIteratorMethods(prototype) { ["next", "throw", "return"].forEach(function (method) { define(prototype, method, function (arg) { return this._invoke(method, arg); }); }); } function AsyncIterator(generator, PromiseImpl) { function invoke(method, arg, resolve, reject) { var record = tryCatch(generator[method], generator, arg); if ("throw" !== record.type) { var result = record.arg, value = result.value; return value && "object" == _typeof(value) && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { invoke("next", value, resolve, reject); }, function (err) { invoke("throw", err, resolve, reject); }) : PromiseImpl.resolve(value).then(function (unwrapped) { result.value = unwrapped, resolve(result); }, function (error) { return invoke("throw", error, resolve, reject); }); } reject(record.arg); } var previousPromise; defineProperty(this, "_invoke", { value: function value(method, arg) { function callInvokeWithMethodAndArg() { return new PromiseImpl(function (resolve, reject) { invoke(method, arg, resolve, reject); }); } return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(innerFn, self, context) { var state = "suspendedStart"; return function (method, arg) { if ("executing" === state) throw new Error("Generator is already running"); if ("completed" === state) { if ("throw" === method) throw arg; return doneResult(); } for (context.method = method, context.arg = arg;;) { var delegate = context.delegate; if (delegate) { var delegateResult = maybeInvokeDelegate(delegate, context); if (delegateResult) { if (delegateResult === ContinueSentinel) continue; return delegateResult; } } if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { if ("suspendedStart" === state) throw state = "completed", context.arg; context.dispatchException(context.arg); } else "return" === context.method && context.abrupt("return", context.arg); state = "executing"; var record = tryCatch(innerFn, self, context); if ("normal" === record.type) { if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; return { value: record.arg, done: context.done }; } "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); } }; } function maybeInvokeDelegate(delegate, context) { var methodName = context.method, method = delegate.iterator[methodName]; if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; var record = tryCatch(method, delegate.iterator, context.arg); if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; var info = record.arg; return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); } function pushTryEntry(locs) { var entry = { tryLoc: locs[0] }; 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); } function resetTryEntry(entry) { var record = entry.completion || {}; record.type = "normal", delete record.arg, entry.completion = record; } function Context(tryLocsList) { this.tryEntries = [{ tryLoc: "root" }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); } function values(iterable) { if (iterable) { var iteratorMethod = iterable[iteratorSymbol]; if (iteratorMethod) return iteratorMethod.call(iterable); if ("function" == typeof iterable.next) return iterable; if (!isNaN(iterable.length)) { var i = -1, next = function next() { for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; return next.value = undefined, next.done = !0, next; }; return next.next = next; } } return { next: doneResult }; } function doneResult() { return { value: undefined, done: !0 }; } return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), defineProperty(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { var ctor = "function" == typeof genFun && genFun.constructor; return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); }, exports.mark = function (genFun) { return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; }, exports.awrap = function (arg) { return { __await: arg }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { return this; }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { void 0 === PromiseImpl && (PromiseImpl = Promise); var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { return result.done ? result.value : iter.next(); }); }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { return this; }), define(Gp, "toString", function () { return "[object Generator]"; }), exports.keys = function (val) { var object = Object(val), keys = []; for (var key in object) keys.push(key); return keys.reverse(), function next() { for (; keys.length;) { var key = keys.pop(); if (key in object) return next.value = key, next.done = !1, next; } return next.done = !0, next; }; }, exports.values = values, Context.prototype = { constructor: Context, reset: function reset(skipTempReset) { if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); }, stop: function stop() { this.done = !0; var rootRecord = this.tryEntries[0].completion; if ("throw" === rootRecord.type) throw rootRecord.arg; return this.rval; }, dispatchException: function dispatchException(exception) { if (this.done) throw exception; var context = this; function handle(loc, caught) { return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; } for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i], record = entry.completion; if ("root" === entry.tryLoc) return handle("end"); if (entry.tryLoc <= this.prev) { var hasCatch = hasOwn.call(entry, "catchLoc"), hasFinally = hasOwn.call(entry, "finallyLoc"); if (hasCatch && hasFinally) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } else if (hasCatch) { if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); } else { if (!hasFinally) throw new Error("try statement without catch or finally"); if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); } } } }, abrupt: function abrupt(type, arg) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { var finallyEntry = entry; break; } } finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); var record = finallyEntry ? finallyEntry.completion : {}; return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); }, complete: function complete(record, afterLoc) { if ("throw" === record.type) throw record.arg; return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; }, finish: function finish(finallyLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; } }, catch: function _catch(tryLoc) { for (var i = this.tryEntries.length - 1; i >= 0; --i) { var entry = this.tryEntries[i]; if (entry.tryLoc === tryLoc) { var record = entry.completion; if ("throw" === record.type) { var thrown = record.arg; resetTryEntry(entry); } return thrown; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(iterable, resultName, nextLoc) { return this.delegate = { iterator: values(iterable), resultName: resultName, nextLoc: nextLoc }, "next" === this.method && (this.arg = undefined), ContinueSentinel; } }, exports; }
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
+function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
+import { contrib, inject, Priority, prop, transient } from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import { LibroWidgetCommFactory, WidgetsOption, WidgetViewContribution } from "./protocal.js";
+import { put_buffers, reject } from "./utils.js";
+import { PROTOCOL_VERSION } from "./version.js";
+var PROTOCOL_MAJOR_VERSION = PROTOCOL_VERSION.split('.', 1)[0];
+export var LibroWidgets = (_dec = transient(), _dec2 = contrib(WidgetViewContribution), _dec3 = prop(), _dec(_class = (_class2 = /*#__PURE__*/function () {
+  function LibroWidgets(options, widgetCommFactory) {
+    var _this = this;
+    _classCallCheck(this, LibroWidgets);
+    _initializerDefineProperty(this, "WidgetViewProvider", _descriptor, this);
+    this.widgetEmitter = new Emitter();
+    /**
+     * Dictionary of model ids and model instance promises
+     */
+    _initializerDefineProperty(this, "models", _descriptor2, this);
+    this.commTargetName = 'jupyter.widget';
+    this.kernelConnection = options.kc;
+    this.id = options.id;
+    this.widgetCommFactory = widgetCommFactory;
+    this.kernelConnection.registerCommTarget(this.commTargetName, /*#__PURE__*/function () {
+      var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(comm, msg) {
+        var widgetComm;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              widgetComm = _this.widgetCommFactory({
+                comm: comm
+              });
+              _context.next = 3;
+              return _this.handleCommOpen(widgetComm, msg);
+            case 3:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee);
+      }));
+      return function (_x, _x2) {
+        return _ref.apply(this, arguments);
+      };
+    }());
+  }
+  LibroWidgets = inject(LibroWidgetCommFactory)(LibroWidgets, undefined, 1) || LibroWidgets;
+  LibroWidgets = inject(WidgetsOption)(LibroWidgets, undefined, 0) || LibroWidgets;
+  _createClass(LibroWidgets, [{
+    key: "onWidgetRender",
+    get: function get() {
+      return this.widgetEmitter.event;
+    }
+  }, {
+    key: "findProvider",
+    value: function findProvider(attributes) {
+      var prioritized = Priority.sortSync(this.WidgetViewProvider.getContributions(), function (contribution) {
+        return contribution.canHandle(attributes);
+      });
+      var sorted = prioritized.map(function (c) {
+        return c.value;
+      });
+      return sorted[0];
+    }
+
+    /**
+     * Create a comm which can be used for communication for a widget.
+     *
+     * If the data/metadata is passed in, open the comm before returning (i.e.,
+     * send the comm_open message). If the data and metadata is undefined, we
+     * want to reconstruct a comm that already exists in the kernel, so do not
+     * open the comm by sending the comm_open message.
+     *
+     * @param comm_target_name Comm target name
+     * @param model_id The comm id
+     * @param data The initial data for the comm
+     * @param metadata The metadata in the open message
+     */
+  }, {
+    key: "createComm",
+    value: function () {
+      var _createComm = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(comm_target_name, model_id, data, metadata, buffers) {
+        var kernel, comm;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              kernel = this.kernelConnection;
+              if (kernel) {
+                _context2.next = 3;
+                break;
+              }
+              throw new Error('No current kernel');
+            case 3:
+              comm = kernel.createComm(comm_target_name, model_id);
+              if (data || metadata) {
+                comm.open(data, metadata, buffers);
+              }
+              return _context2.abrupt("return", this.widgetCommFactory({
+                comm: comm
+              }));
+            case 6:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function createComm(_x3, _x4, _x5, _x6, _x7) {
+        return _createComm.apply(this, arguments);
+      }
+      return createComm;
+    }()
+    /**
+     * Get a model by model id.
+     *
+     * #### Notes
+     * If the model is not found, throw error.
+     *
+     * If you would like to synchronously test if a model exists, use .hasModel().
+     */
+  }, {
+    key: "getModel",
+    value: function getModel(model_id) {
+      var model = this.models.get(model_id);
+      if (model === undefined) {
+        throw new Error('widget model not found');
+      }
+      return model;
+    }
+
+    /**
+     * Returns true if the given model is registered, otherwise false.
+     *
+     * #### Notes
+     * This is a synchronous way to check if a model is registered.
+     */
+  }, {
+    key: "hasModel",
+    value: function hasModel(model_id) {
+      return this.models.get(model_id) !== undefined;
+    }
+
+    /**
+     * Handle when a comm is opened.
+     */
+  }, {
+    key: "handleCommOpen",
+    value: function () {
+      var _handleCommOpen = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(comm, msg) {
+        var protocolVersion, error, data, buffer_paths, buffers;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              protocolVersion = (msg.metadata || {})['version'] || '';
+              if (!(protocolVersion.split('.', 1)[0] !== PROTOCOL_MAJOR_VERSION)) {
+                _context3.next = 5;
+                break;
+              }
+              error = "Wrong widget protocol version: received protocol version '".concat(protocolVersion, "', but was expecting major version '").concat(PROTOCOL_MAJOR_VERSION, "'");
+              console.error(error);
+              return _context3.abrupt("return", Promise.reject(error));
+            case 5:
+              data = msg.content.data;
+              buffer_paths = data.buffer_paths || [];
+              buffers = msg.buffers || [];
+              put_buffers(data.state, buffer_paths, buffers);
+              // this.createComm(msg.content.target_name, msg.content.comm_id, msg.content.data, msg.metadata);
+              return _context3.abrupt("return", this.newWidgetView(data.state, {
+                model_id: msg.content.comm_id,
+                comm: comm
+              }).catch(reject('Could not create a model.', true)));
+            case 10:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function handleCommOpen(_x8, _x9) {
+        return _handleCommOpen.apply(this, arguments);
+      }
+      return handleCommOpen;
+    }()
+  }, {
+    key: "registerWidgetView",
+    value: function registerWidgetView(model_id, model) {
+      var _this2 = this;
+      model.then(function (WidgetView) {
+        _this2.models.set(model_id, WidgetView);
+        _this2.widgetEmitter.fire({
+          WidgetViewName: WidgetView.model_name
+        });
+        return;
+      }).catch(function () {
+        //
+      });
+    }
+  }, {
+    key: "handleCommClose",
+    value: function handleCommClose(msg) {
+      var comm_id = msg.content.comm_id;
+      var model = this.getModel(comm_id);
+      model.isCommClosed = true;
+    }
+  }, {
+    key: "unregisterWidgetView",
+    value: function unregisterWidgetView(model_id) {
+      var model = this.models.get(model_id);
+      model === null || model === void 0 ? void 0 : model.dispose();
+      this.models.delete(model_id);
+    }
+  }, {
+    key: "newWidgetView",
+    value: function () {
+      var _newWidgetView = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(attributes, options) {
+        var model_id, provider, WidgetView;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              model_id = options.model_id;
+              if (model_id) {
+                _context4.next = 3;
+                break;
+              }
+              throw new Error('Neither comm nor model_id provided in options object. At least one must exist.');
+            case 3:
+              options.model_id = model_id;
+              provider = this.findProvider(attributes);
+              WidgetView = provider.factory({
+                attributes: attributes,
+                options: options
+              });
+              this.registerWidgetView(model_id, WidgetView);
+              return _context4.abrupt("return", WidgetView);
+            case 8:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function newWidgetView(_x10, _x11) {
+        return _newWidgetView.apply(this, arguments);
+      }
+      return newWidgetView;
+    }()
+    /**
+     * Close all widgets and empty the widget state.
+     * @return Promise that resolves when the widget state is cleared.
+     */
+  }, {
+    key: "clearState",
+    value: function clearState() {
+      this.models.clear();
+    }
+    /**
+     * Disconnect the widget manager from the kernel, setting each model's comm
+     * as dead.
+     */
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      // this.models.forEach(model => model.clear());
+    }
+  }]);
+  return LibroWidgets;
+}(), (_descriptor = _applyDecoratedDescriptor(_class2.prototype, "WidgetViewProvider", [_dec2], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: null
+}), _descriptor2 = _applyDecoratedDescriptor(_class2.prototype, "models", [_dec3], {
+  configurable: true,
+  enumerable: true,
+  writable: true,
+  initializer: function initializer() {
+    return new Map();
+  }
+})), _class2)) || _class);