pgwidgets-js 0.2.3__tar.gz → 0.3.0__tar.gz

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgwidgets-js
-Version: 0.2.3
+Version: 0.3.0
 Summary: pgwidgets JavaScript widget library — static assets for use with Python servers
 Author: PGWidgets Developers
 License: BSD-3-Clause

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/docs/WhatsNew.rst

@@ -1,6 +1,108 @@
 What's New
 ==========
 
+Recent changes — since ``v0.2.3``
+---------------------------------
+
+Chunked binary transport (both directions, raw frames)
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The remote interface gained a unified chunked binary transport
+that works in both directions and ships raw binary WebSocket
+frames by default.  A new ``binary-call-chunked`` announce opens
+a transfer; subsequent ``binary-chunk`` messages each carry a
+JSON header plus one raw binary frame (or, optionally, an
+inline base64 payload).  Optional ``shape`` + ``dtype`` fields on
+the announce promote the reassembled payload from a raw
+``ArrayBuffer`` to a typed array (``Uint8Array``,
+``Float32Array``, …) before dispatch — the JS-side companion to
+pgwidgets-python's new :class:`pgwidgets.Buffer` descriptor.
+
+The browser-side file upload path was migrated to the same
+envelope.  Drag-and-drop and ``FileDialog`` now read files with
+``readAsArrayBuffer`` instead of ``readAsDataURL`` and ship the
+bytes via binary frames; the ``payload.files[i].data`` field is
+now an ``ArrayBuffer`` (JavaScript side) / ``bytes`` (Python
+side) rather than a ``"data:<mime>;base64,…"`` string.  Each
+file dict carries an explicit ``encoding`` field (currently
+always ``"bytes"``; reserved for future ``"base64"``) so
+receivers can branch on it.
+
+**Pre-1.0 API break**: any drop or FileDialog handler that did
+``base64.b64decode(data.split(",", 1)[1])`` should now just use
+``data`` directly.
+
+Constructor-bind hack removed
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The legacy ``this.foo = this.foo.bind(this)`` constructor lines
+were removed from every widget module — 443 line deletions
+across 48 files.  The codebase never relied on bare method
+references (DOM handlers etc. use arrow wrappers), so the
+preemptive binding was redundant.  A handful of places that
+*did* register handlers via ``addEventListener("event",
+this.method)`` were converted to class-field arrow methods
+(``onMouseMove = (e) => { ... }``) so the handler identity is
+stable per instance — critical for the paired
+``removeEventListener`` to find the same function.
+
+**Pre-1.0 API break**: code outside the library that passed a
+pgwidgets method as a bare reference (``setTimeout(button.set_text,
+0)``, ``el.addEventListener("click", widget.foo)``, etc.) must
+now wrap with an arrow at the call site (``() =>
+button.set_text(s)``) or apply ``.bind`` itself.
+
+Wid-collision fix in ``_handleCreate``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+When a class registered in ``classMap`` doesn't extend
+``Callback`` (e.g. a plain JS class layered on top of
+pgwidgets-js — gingajs's ``Controller`` is one), its constructor
+doesn't allocate a wid.  The next widget's ``super()`` would
+then auto-assign a wid that the previous Python-allocated widget
+was sitting at, silently overwriting it in the registry.
+Two complementary safeguards:
+
+- ``_handleCreate`` now bumps ``Callback._nextId`` past
+  ``msg.wid`` *before* calling ``new cls(...)``.
+- ``Callback``'s constructor skips occupied registry slots when
+  allocating, as a defensive backstop.
+
+A binding that only ever uses classes which extend ``Callback``
+is safe without either mitigation, but having both removes a
+whole class of mysterious "Unknown widget id" errors.
+
+TreeView: per-column ``colwidth``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Column descriptors accept an optional ``colwidth`` field set
+initial column widths declaratively::
+
+    tree.set_columns([
+        {label: "Name", key: "NAME", type: "string", colwidth: 240},
+        {label: "Type", key: "TYPE", type: "string", colwidth: "10em"},
+        {label: "Size", key: "SIZE", type: "integer"},   // -> 1fr
+    ])
+
+Numbers are treated as pixels; strings pass through as CSS grid
+track values.  Columns without ``colwidth`` keep the previous
+default of ``"1fr"``.  ``set_column_width(key, w)`` continues to
+work for runtime adjustments.
+
+Other improvements
+~~~~~~~~~~~~~~~~~~
+
+- ``TextSource`` gained internal ``_setCursorOffset`` /
+  ``_setSelectionOffsets`` helpers used by the ref-binding
+  machinery on reconstruction.
+- For-developers documentation expanded: the "Things That Will
+  Bite You" section now covers the wid-collision rule, the
+  ``encoding`` field on chunks, atomic chunk emission, indexed
+  reassembly, dtype-falls-back-to-ArrayBuffer, and the
+  ``f.data``-is-bytes API break.
+
+----
+
 Recent changes — since ``v0.2.1``
 ---------------------------------
 

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/docs/for-developers.rst

@@ -92,10 +92,34 @@ Server → Browser
 
 ``{type: "binary-call", id, wid, method, args}`` (followed by a raw binary WebSocket frame)
    Identical to ``call`` except the binary frame becomes the *first*
-   argument to the method. Used for image bytes, so a JPEG isn't
-   base64-inflated through JSON. Order matters: the JSON header is
-   queued FIFO; the next binary frame is paired with the head of the
-   queue.
+   argument to the method. Used for small image bytes (JPEG/PNG etc.)
+   so the payload isn't base64-inflated through JSON. Order matters:
+   the JSON header is queued FIFO; the next binary frame is paired
+   with the head of the queue.
+
+``{type: "binary-call-chunked", id, wid, method, args, transfer_id, num_chunks}`` (announce; followed by N binary-chunk pairs)
+   Opens a chunked transfer for payloads too large to ship in one
+   frame.  The announce reserves a ``transfer_id``; the receiver
+   accumulates exactly ``num_chunks`` paired ``binary-chunk`` messages
+   and then dispatches ``widget[method](payload, ...args)``.  Optional
+   fields ``shape`` (array of ints) and ``dtype`` (one of
+   ``"uint8"``, ``"uint16"``, ``"uint32"``, ``"int8"``, ``"int16"``,
+   ``"int32"``, ``"float32"``, ``"float64"``) promote the delivered
+   payload from a raw ``ArrayBuffer`` to a typed array of that dtype.
+   See *Chunked binary transport* below.
+
+``{type: "binary-chunk", transfer_id, chunk_index, num_chunks, encoding, [file_index, file_count, data]}`` (one chunk)
+   One chunk of an in-flight transfer.  ``encoding`` is per-chunk:
+
+   * ``"binary"`` (default): the **next** WebSocket frame is the
+     chunk's raw bytes.  Zero protocol overhead.
+   * ``"base64"``: the ``data`` field on this JSON message **is** the
+     chunk, base64-encoded.  No following binary frame.  Useful when
+     the transport can't carry raw binary cleanly.
+
+   The optional ``file_index`` / ``file_count`` fields scope a chunk
+   to one file within a multi-file upload; without them the chunks
+   belong to a single payload.
 
 ``{type: "listen", id, wid, action}``
    Subscribe to a callback. The browser wires up a forwarder on the
@@ -134,8 +158,10 @@ Browser → Server
    Sent at session-info time and on every window resize, so the server
    can answer ``get_screen_size()`` locally without a round-trip.
 
-``{type: "file-chunk", wid, transfer_id, file_index, file_count, chunk_index, num_chunks, data}``
-   See *File uploads* below.
+``{type: "binary-chunk", wid, transfer_id, file_index, file_count, chunk_index, num_chunks, encoding}`` (followed by a raw binary frame, unless ``encoding == "base64"``)
+   Same shape as the server-side ``binary-chunk``; used by the
+   browser to upload dropped files / picker selections.  See *File
+   uploads* below.
 
 
 Serialization Rules
@@ -163,9 +189,13 @@ Serialization Rules
   reconstruction can re-spread it as ``method(*tuple)``.
 
 * **Binary payloads** travel out of band. Build the JSON header
-  describing the call, send it, then send the raw binary frame
-  immediately after. Do not interleave other binary frames between
-  header and payload — the browser pairs them FIFO.
+  describing the call (``binary-call`` for one frame,
+  ``binary-call-chunked`` + N ``binary-chunk`` for multi-frame
+  transfers), send it, then send the raw binary frame(s).  Receivers
+  pair them by FIFO order on a single connection; ``transfer_id``
+  in chunked transfers groups frames belonging to the same payload.
+  Do not interleave other binary frames between a chunk header and
+  its payload.
 
 
 Widget Definitions: ``defs.py``
@@ -532,24 +562,68 @@ deciding which actions to forward; see ``STATE_SYNC_CALLBACKS`` and
 ``WIDGET_CALLBACK_SYNC`` in ``method_types.py`` for the policy table.
 
 
-File Uploads
-------------
-
-Drag-and-drop file payloads can be large, and a single WebSocket
-``send`` would block the channel. The protocol splits them:
-
-1. The browser sends a metadata-only ``callback`` (file list with
-   sizes/types but no data), tagged with a ``transfer_id``.
-2. It follows with one or more ``file-chunk`` messages, each carrying
-   ``transfer_id, file_index, file_count, chunk_index, num_chunks,
-   data`` (base64). Chunks yield between sends via ``setTimeout(0)``
-   so other messages can interleave.
-3. The server reassembles by ``(transfer_id, file_index, chunk_index)``
-   and, when ``chunk_index + 1 == num_chunks`` for every file, fires
-   the user's callback with the full payload.
-
-If your binding doesn't care about file uploads you can ignore this
-section — nothing else uses ``file-chunk``.
+Chunked Binary Transport
+------------------------
+
+Used in both directions for payloads too large to ship in a single
+WebSocket frame, or when the sender wants to interleave control
+messages with a long transfer.  The same ``binary-chunk`` envelope
+is symmetric: server → browser (for ``binary-call-chunked`` —
+e.g. an Image's pixel buffer) and browser → server (for file
+uploads).
+
+Wire layout::
+
+   server→browser (binary-call-chunked):
+
+      → {"type": "binary-call-chunked",
+         "id": 42, "wid": 7, "method": "load_buffer",
+         "args": [[2048, 2048], {...}],
+         "transfer_id": 17, "num_chunks": 32,
+         "shape": [2048, 2048, 4], "dtype": "uint8"}    ← optional
+      → {"type": "binary-chunk", "transfer_id": 17,
+         "chunk_index": 0, "num_chunks": 32, "encoding": "binary"}
+      → <raw 524288-byte binary frame>
+      → {"type": "binary-chunk", ..., "chunk_index": 1, ...}
+      → <raw 524288-byte binary frame>
+        ⋮
+      → {"type": "binary-chunk", ..., "chunk_index": 31, ...}
+      → <raw <=524288-byte binary frame>
+
+   browser→server (file upload):
+
+      → {"type": "callback", "wid": 7, "action": "drop-end",
+         "args": [{"transfer_id": 17,
+                   "files": [{"name": "...", "size": ..., "type": ...}],
+                   ...}]}
+      → {"type": "binary-chunk", "wid": 7,
+         "transfer_id": 17, "file_index": 0, "file_count": 1,
+         "chunk_index": 0, "num_chunks": N, "encoding": "binary"}
+      → <raw binary frame>
+        ⋮
+
+Per-chunk ``encoding`` lets a sender choose ``"binary"`` (next
+frame is the chunk) or ``"base64"`` (the chunk rides in this JSON
+message's ``data`` field, no following binary frame).  Default is
+``"binary"``; both pgwidgets-js and pgwidgets-python only emit the
+binary form, but receivers must accept either.
+
+When the announce includes ``shape`` and ``dtype``, the receiver
+constructs a typed array of that dtype (``Uint8Array``,
+``Float32Array``, …) before dispatch instead of a raw
+``ArrayBuffer``.  The supported dtypes mirror pgwidgets-python's
+:class:`pgwidgets.Buffer` (``uint8`` / ``uint16`` / ``uint32`` /
+``int8`` / ``int16`` / ``int32`` / ``float32`` / ``float64``).
+
+Chunks may arrive out-of-order in principle (a single TCP/WS
+stream preserves order in practice, but receivers should still
+write into indexed slots by ``chunk_index``, not append).  The
+transfer completes when every slot is filled; the receiver
+reassembles, dispatches, and discards the transfer.
+
+A binding can opt to ignore the chunked path and only support
+single-frame ``binary-call`` if it doesn't need large payloads or
+file uploads.
 
 
 Session Identity and Reconnection
@@ -580,31 +654,96 @@ Things That Will Bite You
 
 In rough order of how easy they are to miss:
 
-* **Wid collisions.** Always advance your allocator past any
-  ``next_wid`` you see in a ``result``, not just the wid you sent.
+* **Wid collisions and classMap classes that don't extend Callback.**
+  Advancing your allocator past ``next_wid`` (from every ``result``,
+  not just the latest) is necessary but not sufficient.  If the
+  receiving side has a class in ``classMap`` whose constructor
+  doesn't call ``super()`` (e.g. a plain JS class layered on top of
+  pgwidgets-js — gingajs's ``Controller`` is one), then ``_nextId``
+  doesn't advance during that widget's construction.  The **next**
+  widget's ``super()`` will then auto-assign a wid that the previous
+  Python-allocated widget is already sitting at, silently
+  overwriting it in the registry.  Symptom: subsequent
+  ``add_widget`` / ``listen`` calls fail with "Unknown widget id".
+  Mitigations in the reference implementation (do at least one):
+
+  - ``_handleCreate`` bumps ``Callback._nextId`` past ``msg.wid``
+    *before* calling ``new cls(...)``, so the auto-wid is guaranteed
+    to land in unoccupied territory.
+  - The ``Callback`` constructor skips occupied registry slots when
+    allocating, as a defensive backstop.
+
+  A binding that only ever uses classes which extend ``Callback`` is
+  safe without either mitigation, but it's worth having both.
+
 * **Tuple vs single-arg setters.** ``set_position(x, y)`` stores a
   tuple but ``set_text(s)`` stores a string. Your binding must
   normalize so reconstruction can re-spread tuples as multiple args
   and singles as one arg.
+
 * **Suppressing callbacks.** Forget to set ``_syncing`` /
   ``_reconstructing`` and you'll get echo loops or duplicate state
   updates.
+
 * **The ``map`` exception.** Don't apply ``_reconstructing``
   suppression to ``map``. The observers fire once and disconnect; if
   you swallow ``map`` the user's handler is dead until something
   else re-fires it.
+
 * **Replaying passively-captured size.** This is the silent killer.
   Capture must be unconditional (for getters), replay must be
   conditional (or you pin every widget to whatever pixel size the
   layout happened to settle at on capture). The same guard applies
   in both the top-level state replay AND ``_transfer_proxy``.
+
 * **Order in ``_replay_interleaved``.** ``_children`` and
   ``_replay_calls`` carry their own sequence numbers for exactly
   this reason. Replay them merged in seq order.
+
 * **Constructor args that are widgets.** Reconstruct them first
   (``_ensure_reconstructed``) before sending the parent's ``create``.
-* **Binary frames are FIFO-paired with headers.** If you reorder
-  outgoing messages, pair up header and binary frames first.
+
+* **Binary frames are FIFO-paired with headers.** A single
+  ``binary-call`` JSON header followed by anything other than the
+  expected binary frame breaks the pairing for every following
+  binary call on that connection.  Same applies to chunked
+  ``binary-chunk`` headers with ``encoding == "binary"``.
+
+* **Atomic emission of a chunked transfer.** On the sender side,
+  all chunks for one transfer should ship under a single
+  coroutine / lock on the WebSocket so other binary calls can't
+  splice frames in between.  Receivers use ``transfer_id`` to
+  disambiguate, so out-of-band interleaving is technically OK —
+  but the reference implementation chooses atomic emission anyway
+  to keep failure modes simpler.
+
+* **Chunk reassembly by index, not append.** WebSocket frames over
+  a single TCP stream do arrive in order, so a naive append-based
+  reassembler will *work* in practice — but ``chunk_index`` is on
+  every chunk header for a reason.  Writing chunks into a slotted
+  array indexed by ``chunk_index`` is one extra line and bullet-
+  proofs you against any future transport that doesn't preserve
+  order.
+
+* **Mixing encodings within a transfer.** ``"binary"`` and
+  ``"base64"`` chunks are interchangeable per the protocol, but
+  doing both in one transfer is surprising.  Pick one per transfer
+  and stay consistent.
+
+* **Unknown dtypes degrade to raw ArrayBuffer.** If an announce
+  carries ``dtype: "float16"`` (or anything else not in the
+  standard set), the JS side has no matching TypedArray
+  constructor and logs a warning, then delivers the raw
+  ``ArrayBuffer`` instead.  Stick to the documented dtypes
+  (``uint8`` / ``uint16`` / ``uint32`` / ``int8`` / ``int16`` /
+  ``int32`` / ``float32`` / ``float64``).
+
+* **API shape: ``f.data`` is bytes.** As of the binary-transport
+  unification, ``payload.files[i].data`` in drop / FileDialog
+  callbacks is raw bytes (``ArrayBuffer`` on the JS side, ``bytes``
+  on the Python side) — not a ``"data:<mime>;base64,…"`` string.
+  Old code that did ``base64.b64decode(data.split(",", 1)[1])`` is
+  now wrong; just use ``data`` directly.
 
 
 Where to Look in the Code

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgwidgets",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "A native JavaScript widget library with Qt/GTK-style layout and controls",
   "type": "module",
   "main": "Widgets.js",

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/defs.py

@@ -548,6 +548,8 @@ WIDGETS = {
             # browser reconnect).  Not part of the user-facing API.
             "_restoreTagIntervals": ["intervals"],
             "_bindNamedRef": ["name", "ref"],
+            "_setCursorOffset": ["offset"],
+            "_setSelectionOffsets": ["start", "end"],
             "get_ref_start": [],
             "get_ref_end": [],
             "get_ref_bounds": [],

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/AbstractScrollArea.js

@@ -63,12 +63,6 @@ class AbstractScrollArea extends ContainerWidget {
         this._vVisibility = 'auto';
 
         // bind public methods
-        this.set_widget = this.set_widget.bind(this);
-        this.set_thumb_percent = this.set_thumb_percent.bind(this);
-        this.get_thumb_percent = this.get_thumb_percent.bind(this);
-        this.set_scroll_percent = this.set_scroll_percent.bind(this);
-        this.get_scroll_percent = this.get_scroll_percent.bind(this);
-        this.set_scroll_bar_visibility = this.set_scroll_bar_visibility.bind(this);
 
         // scrollbar user interaction -> 'scrolled' callback
         this._hScrollBar.add_callback('activated', (w, pct) => {

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Box.js

@@ -24,12 +24,6 @@ class Box extends ContainerWidget {
         this.element.className = 'box-widget';
         this.orientation = this.get_option(options, 'orientation', 'horizontal');
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.add_widget = this.add_widget.bind(this);
-        this.insert_widget = this.insert_widget.bind(this);
-        this.set_spacing = this.set_spacing.bind(this);
-        this.init_style = this.init_style.bind(this);
-
         this.init_style();
     }
 
@@ -183,7 +177,6 @@ class ButtonBox extends Box {
         this._halign = this.get_option(options, 'halign', 'center');
         this._applyAlign();
 
-        this.set_halign = this.set_halign.bind(this);
     }
 
     /** @private */

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Button.js

@@ -31,14 +31,6 @@ class Button extends Widget {
             this.element.appendChild(this.textElement);
         }
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.set_text = this.set_text.bind(this);
-        this.get_text = this.get_text.bind(this);
-        this.set_icon = this.set_icon.bind(this);
-        this.get_icon = this.get_icon.bind(this);
-        this.set_color = this.set_color.bind(this);
-        this._cb_redirect = this._cb_redirect.bind(this);
-
         super.init_style();
 
         this.element.onclick = () => this._cb_redirect('clicked');

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Callback.js

@@ -14,18 +14,23 @@ class Callback {
     static _registry = new Map();
 
     constructor() {
+        // Skip over any registry slot that's already occupied so we
+        // never silently overwrite a widget at an in-use wid.  This
+        // matters under the remote interface: a class in the classMap
+        // that doesn't call super() (e.g. a plain JS class layered on
+        // top) leaves _nextId behind the Python-assigned wid range,
+        // and the next super() call would otherwise clobber a real
+        // widget there.  RemoteInterface._handleCreate also bumps
+        // _nextId past msg.wid, this is a defensive backstop.
+        while (Callback._registry.has(Callback._nextId)) {
+            Callback._nextId++;
+        }
         this.wid = Callback._nextId++;
         Callback._registry.set(this.wid, this);
 
         this.cb = {};
         this._destroyed = false;
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.enable_callback = this.enable_callback.bind(this);
-        this.add_callback = this.add_callback.bind(this);
-        this.clear_callback = this.clear_callback.bind(this);
-        this.remove_callback = this.remove_callback.bind(this);
-        this.make_callback = this.make_callback.bind(this);
     }
 
     /* CALLBACK HANDLING */

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Canvas.js

@@ -41,11 +41,6 @@ class Canvas extends Widget {
             this._offscreen.height = this.element.height;
         }
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.draw_image = this.draw_image.bind(this);
-        this.get_draw_context = this.get_draw_context.bind(this);
-        this.update = this.update.bind(this);
-
         super.init_style();
         if (this.get_option(options, 'interactive', false)) {
             this._initInteractiveEvents({focusable: true, cursor: 'crosshair'});

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/CheckBox.js

@@ -30,11 +30,6 @@ class CheckBox extends Widget {
         this.label = document.createTextNode(text);
         this.element.appendChild(this.label);
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.set_state = this.set_state.bind(this);
-        this.get_state = this.get_state.bind(this);
-        this._cb_redirect = this._cb_redirect.bind(this);
-
         this.checkbox.onclick = () => this._cb_redirect('clicked');
 
         this.enable_callback('activated');

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/ColorDialog.js

@@ -32,10 +32,6 @@ class ColorDialog extends Dialog {
 
         this.element.classList.add('colordialog-widget');
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.get_color = this.get_color.bind(this);
-        this.set_color = this.set_color.bind(this);
-
         // Create the embedded color picker widget
         this._colorWidget = new ColorWidget({
             color: options.color || '#ff0000'

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/ColorWidget.js

@@ -28,9 +28,6 @@ class ColorWidget extends Widget {
         this.element = document.createElement('div');
         this.element.className = 'colorwidget';
 
-        this.get_color = this.get_color.bind(this);
-        this.set_color = this.set_color.bind(this);
-
         // internal HSV state (h: 0-360, s: 0-1, v: 0-1)
         this._h = 0;
         this._s = 1;

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/ComboBox.js

@@ -57,24 +57,6 @@ class ComboBox extends Widget {
         // user-driven selections set this to true; clear() resets it.
         this._indexExplicit = false;
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.append_text = this.append_text.bind(this);
-        this.insert_alpha = this.insert_alpha.bind(this);
-        this.delete_alpha = this.delete_alpha.bind(this);
-        this.set_text = this.set_text.bind(this);
-        this.get_text = this.get_text.bind(this);
-        this.set_index = this.set_index.bind(this);
-        this.get_index = this.get_index.bind(this);
-        this.get_alpha = this.get_alpha.bind(this);
-        this.show_text = this.show_text.bind(this);
-        this.clear = this.clear.bind(this);
-        this.set_length = this.set_length.bind(this);
-        this._autoSize = this._autoSize.bind(this);
-        this._buildDropdown = this._buildDropdown.bind(this);
-        this._showDropdown = this._showDropdown.bind(this);
-        this._hideDropdown = this._hideDropdown.bind(this);
-        this._toggleDropdown = this._toggleDropdown.bind(this);
-
         // toggle dropdown on button or input click (input click only for non-editable)
         this._button.addEventListener('mousedown', (e) => {
             e.preventDefault();

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/ComboBoxNative.js

@@ -23,17 +23,6 @@ class ComboBoxNative extends Widget {
         
         this.element.className = 'combobox-native-widget';
         
-        // JavaScript hack to bind "this" correctly for our methods
-        this.append_text = this.append_text.bind(this);
-        this.insert_alpha = this.insert_alpha.bind(this);
-        this.delete_alpha = this.delete_alpha.bind(this);
-        this.set_text = this.set_text.bind(this);
-        this.get_text = this.get_text.bind(this);
-        this.get_alpha = this.get_alpha.bind(this);
-        this.show_text = this.show_text.bind(this);
-        this.clear = this.clear.bind(this);
-        this._cb_redirect = this._cb_redirect.bind(this);
-
         this.element.onclick = () => this._cb_redirect('clicked');
         this.element.addEventListener('wheel', (e) => {
             e.preventDefault();

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Dial.js

@@ -115,18 +115,6 @@ class Dial extends Widget {
             this._applyValuePosition();
         }
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.set_value = this.set_value.bind(this);
-        this.get_value = this.get_value.bind(this);
-        this.set_limits = this.set_limits.bind(this);
-        this.set_tracking = this.set_tracking.bind(this);
-        this.set_decimals = this.set_decimals.bind(this);
-        this.set_knob_diameter = this.set_knob_diameter.bind(this);
-        this.set_icon = this.set_icon.bind(this);
-        this._onMouseDown = this._onMouseDown.bind(this);
-        this._onMouseMove = this._onMouseMove.bind(this);
-        this._onMouseUp = this._onMouseUp.bind(this);
-
         this._svg.addEventListener('mousedown', this._onMouseDown);
         this._svg.addEventListener('wheel', (e) => {
             e.preventDefault();
@@ -416,7 +404,7 @@ class Dial extends Widget {
     }
 
     /** @private */
-    _onMouseDown(e) {
+    _onMouseDown = (e) => {
         e.preventDefault();
         this.value = this._eventToValue(e);
         this._updateVisual();
@@ -428,7 +416,7 @@ class Dial extends Widget {
     }
 
     /** @private */
-    _onMouseMove(e) {
+    _onMouseMove = (e) => {
         this.value = this._eventToValue(e);
         this._updateVisual();
         if (this.track) {
@@ -437,7 +425,7 @@ class Dial extends Widget {
     }
 
     /** @private */
-    _onMouseUp(e) {
+    _onMouseUp = (e) => {
         document.removeEventListener('mousemove', this._onMouseMove);
         document.removeEventListener('mouseup', this._onMouseUp);
         this.value = this._eventToValue(e);

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/Dialog.js

@@ -39,13 +39,6 @@ class Dialog extends TopLevel {
             this.element.classList.add('dialog-modal');
         }
 
-        // JavaScript hack to bind "this" correctly for our methods
-        this.get_content_area = this.get_content_area.bind(this);
-        this.add_widget = this.add_widget.bind(this);
-        this.insert_widget = this.insert_widget.bind(this);
-        this.add_button = this.add_button.bind(this);
-        this.set_spacing = this.set_spacing.bind(this);
-
         // main layout: content area + button bar
         this._vbox = new VBox();
         this._vbox.set_spacing(4);

{pgwidgets_js-0.2.3 → pgwidgets_js-0.3.0}/pgwidgets_js/static/modules/ExternalWidget.js

@@ -33,10 +33,6 @@ class ExternalWidget extends Widget {
         }
         this.element.className = 'external-widget';
 
-        this.set_content = this.set_content.bind(this);
-        this.get_content_element = this.get_content_element.bind(this);
-        this.clear = this.clear.bind(this);
-
         // Inner div where external content is rendered.
         this._content = document.createElement('div');
         this._content.className = 'external-widget-content';