@atlaskit/editor-plugin-autocomplete 3.3.0 → 3.4.1

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @atlaskit/editor-plugin-autocomplete
 
+## 3.4.1
+
+### Patch Changes
+
+- [`4129a00a1ae04`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/4129a00a1ae04) -
+  Add `completionSource` attribute to contextual typeahead analytics events to distinguish between
+  cold (frequency-only), server slow-lane, and on-device local LLM scoring paths
+- Updated dependencies
+
+## 3.4.0
+
+### Minor Changes
+
+- [`b6fb60030b3b9`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/b6fb60030b3b9) -
+  Improve local autocomplete scheduling latency
+
 ## 3.3.0
 
 ### Minor Changes

package/dist/cjs/pm-plugins/autocomplete-plugin.js

@@ -6,20 +6,38 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createAutocompletePlugin = exports.autocompletePluginKey = void 0;
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _analytics = require("@atlaskit/editor-common/analytics");
 var _monitoring = require("@atlaskit/editor-common/monitoring");
 var _safePlugin = require("@atlaskit/editor-common/safe-plugin");
 var _keymap = require("@atlaskit/editor-prosemirror/keymap");
 var _state = require("@atlaskit/editor-prosemirror/state");
 var _view = require("@atlaskit/editor-prosemirror/view");
+var _debugMode = require("./debug-mode");
 var _ghostTextDecoration = require("./ghost-text-decoration");
 var _localSlowLaneClient = require("./local-slow-lane-client");
 var _slowLaneClient = require("./slow-lane-client");
 var _textPredictor = require("./text-predictor");
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 var autocompletePluginKey = exports.autocompletePluginKey = new _state.PluginKey('autocomplete');
 var DEBOUNCE_MS = 150;
+var NETWORK_SLOW_LANE_DEBOUNCE_MS = 300;
+var LOCAL_SLOW_LANE_DEBOUNCE_MS = 100;
+var CONTEXT_REFRESH_THROTTLE_MS = 1000;
+// Caps the dedup Set so long editing sessions don't retain every distinct
+// version of the (potentially hundreds-of-KB) page content for the plugin's
+// lifetime. Eviction is FIFO; a re-ingest of an evicted text is harmless.
+var MAX_INGESTED_CONTEXT_TEXTS = 50;
+// Caps how many times the word-boundary path will retry getContext() while the
+// parent comment is still missing. Combined with the 1s throttle this gives a
+// ~5s window to cover a still-loading comment thread, then stops permanently so
+// non-comment editors (where parentCommentContent never arrives) don't refetch
+// on every word boundary for the plugin's lifetime.
+var MAX_CONTEXT_REFRESH_ATTEMPTS = 5;
 var hasDestroy = function hasDestroy(client) {
   return 'destroy' in client && typeof client.destroy === 'function';
 };
@@ -184,6 +202,12 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
   var debounceTimer = null;
   var hasIngestedPage = false;
   var resolvedContext;
+  /**
+   * Kept in sync with the live EditorView so the async getContext() promise
+   * can re-trigger a slow-lane update the moment context arrives, even if the
+   * user has already typed several words before the promise resolved.
+   */
+  var currentView = null;
   /**
    * Set after accepting a suggestion so the next doc-change update
    * skips scheduling a new prediction for the just-inserted text.
@@ -199,6 +223,18 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
   var dismissedContext = null;
   var lastSuggestionTypedLength = 0;
   var lastSuggestionLength = 0;
+
+  /**
+   * cold  → no slow-lane vector received yet; frequency-only trie scoring
+   * server → server slow-lane API returned the context vector
+   * localLlm → on-device WebGPU/MLC model returned the context vector
+   */
+  var getCompletionSource = function getCompletionSource() {
+    if (!slowLaneClient.getContextVector()) {
+      return 'cold';
+    }
+    return options !== null && options !== void 0 && options.useLocalModel ? 'localLlm' : 'server';
+  };
   var fireSuggestionDismissedAnalytics = function fireSuggestionDismissedAnalytics(reason) {
     var _api$analytics;
     api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.fireAnalyticsEvent({
@@ -206,6 +242,7 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
       actionSubject: _analytics.ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: _analytics.EVENT_TYPE.TRACK,
       attributes: {
+        completionSource: getCompletionSource(),
         reason: reason
       }
     });
@@ -220,6 +257,7 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
       actionSubject: _analytics.ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: _analytics.EVENT_TYPE.TRACK,
       attributes: {
+        completionSource: getCompletionSource(),
         suggestionLength: suggestionLength,
         typedLength: typedLength,
         kssDelta: kssDelta
@@ -227,12 +265,125 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
     });
   };
   var slowLaneClient = options !== null && options !== void 0 && options.useLocalModel ? (0, _localSlowLaneClient.createLocalSlowLaneClient)({
-    debounceMs: 300
+    debounceMs: LOCAL_SLOW_LANE_DEBOUNCE_MS
   }) : (0, _slowLaneClient.createSlowLaneClient)({
     baseUrl: '',
-    debounceMs: 300
+    debounceMs: NETWORK_SLOW_LANE_DEBOUNCE_MS
   });
   (0, _slowLaneClient.setDefaultSlowLaneClient)(slowLaneClient);
+  var contextRequestInFlight = false;
+  var lastContextRefreshAt = 0;
+  // Bounds the word-boundary retry loop so it terminates even when the editor is
+  // not in a comment thread (parentCommentContent never resolves).
+  var wordBoundaryRefreshAttempts = 0;
+  // Set when the plugin is torn down so in-flight getContext() resolutions don't
+  // mutate the global text-predictor state after destruction.
+  var destroyed = false;
+  var ingestedContextTexts = new Set();
+  var logContextResolved = function logContextResolved(source, context) {
+    var _context$parentCommen, _context$siblingComme4, _context$siblingComme5;
+    if (!(0, _debugMode.isAutocompleteDebugEnabled)()) {
+      return;
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('%c[Autocomplete] %cgetContext resolved', 'color: #00b8d9; font-weight: bold;', 'color: inherit;', {
+      source: source,
+      hasParentComment: !!(context !== null && context !== void 0 && context.parentCommentContent),
+      parentCommentPreview: context === null || context === void 0 || (_context$parentCommen = context.parentCommentContent) === null || _context$parentCommen === void 0 ? void 0 : _context$parentCommen.slice(0, 80),
+      siblingCount: (_context$siblingComme4 = context === null || context === void 0 || (_context$siblingComme5 = context.siblingCommentsContents) === null || _context$siblingComme5 === void 0 ? void 0 : _context$siblingComme5.length) !== null && _context$siblingComme4 !== void 0 ? _context$siblingComme4 : 0,
+      hasFullPage: !!(context !== null && context !== void 0 && context.fullPageContent)
+    });
+  };
+  var applyContext = function applyContext(context) {
+    var _context$siblingComme6;
+    // Merge rather than replace: the word-boundary retry may resolve only a
+    // late-arriving field (e.g. parentCommentContent) without re-sending
+    // fullPageContent, so replacing would drop previously resolved context.
+    // Strip undefined values first so a field explicitly set to undefined by
+    // getContext doesn't overwrite a previously resolved value.
+    var definedContext = Object.fromEntries(Object.entries(context).filter(function (_ref) {
+      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        value = _ref2[1];
+      return value !== undefined;
+    }));
+    resolvedContext = _objectSpread(_objectSpread({}, resolvedContext), definedContext);
+    var ingestContextText = function ingestContextText(text) {
+      if (!text || ingestedContextTexts.has(text)) {
+        return;
+      }
+      ingestedContextTexts.add(text);
+      // Evict oldest entries (Set preserves insertion order) to bound memory.
+      while (ingestedContextTexts.size > MAX_INGESTED_CONTEXT_TEXTS) {
+        var oldest = ingestedContextTexts.values().next().value;
+        if (oldest === undefined) {
+          break;
+        }
+        ingestedContextTexts.delete(oldest);
+      }
+      (0, _textPredictor.ingestDocumentPage)(text);
+    };
+    ingestContextText(context.fullPageContent);
+    ingestContextText(context.parentCommentContent);
+    var _iterator = _createForOfIteratorHelper((_context$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var siblingCommentContent = _step.value;
+        ingestContextText(siblingCommentContent);
+      }
+
+      // Context arrived after word boundaries may already have fired. Re-send
+      // slow-lane context immediately so the next inference includes the thread.
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    if (currentView) {
+      slowLaneClient.updateContext(buildSlowLaneText(currentView.state.doc.textContent, resolvedContext));
+    }
+  };
+
+  /**
+   * Returns true when a fetch was actually started, false when it was skipped
+   * (no getContext, a request already in flight, or throttled). Callers that
+   * track a retry budget should only count attempts where this returns true.
+   */
+  var refreshContext = function refreshContext(_ref3) {
+    var source = _ref3.source,
+      _ref3$allowThrottle = _ref3.allowThrottle,
+      allowThrottle = _ref3$allowThrottle === void 0 ? true : _ref3$allowThrottle;
+    if (!(options !== null && options !== void 0 && options.getContext) || contextRequestInFlight) {
+      return false;
+    }
+    var now = Date.now();
+    if (allowThrottle && now - lastContextRefreshAt < CONTEXT_REFRESH_THROTTLE_MS) {
+      return false;
+    }
+    contextRequestInFlight = true;
+    lastContextRefreshAt = now;
+    options.getContext().then(function (context) {
+      // Bail if the plugin was destroyed while the fetch was in flight —
+      // applyContext mutates global text-predictor state we must not touch
+      // after teardown.
+      if (destroyed) {
+        return;
+      }
+      logContextResolved(source, context);
+      if (!context) {
+        return;
+      }
+      applyContext(context);
+    }).catch(function (error) {
+      (0, _monitoring.logException)(error, {
+        location: 'editor-plugin-autocomplete/getContext'
+      });
+    }).finally(function () {
+      contextRequestInFlight = false;
+    });
+    return true;
+  };
 
   /**
    * Schedule a prediction after a short debounce.
@@ -273,7 +424,10 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
             api === null || api === void 0 || (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 || _api$analytics3.actions.fireAnalyticsEvent({
               action: _analytics.ACTION.SUGGESTION_VIEWED,
               actionSubject: _analytics.ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
-              eventType: _analytics.EVENT_TYPE.TRACK
+              eventType: _analytics.EVENT_TYPE.TRACK,
+              attributes: {
+                completionSource: getCompletionSource()
+              }
             });
           }
         }
@@ -404,26 +558,10 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
           });
           if (!hasIngestedPage) {
             hasIngestedPage = true;
-            if (options !== null && options !== void 0 && options.getContext) {
-              options.getContext().then(function (context) {
-                var _context$siblingComme4;
-                if (!context) {
-                  return;
-                }
-                resolvedContext = context;
-                if (context.fullPageContent) {
-                  (0, _textPredictor.ingestDocumentPage)(context.fullPageContent);
-                }
-                if (context.parentCommentContent) {
-                  (0, _textPredictor.ingestDocumentPage)(context.parentCommentContent);
-                }
-                (_context$siblingComme4 = context.siblingCommentsContents) === null || _context$siblingComme4 === void 0 || _context$siblingComme4.forEach(_textPredictor.ingestDocumentPage);
-              }).catch(function (error) {
-                (0, _monitoring.logException)(error, {
-                  location: 'editor-plugin-autocomplete/getContext'
-                });
-              });
-            }
+            refreshContext({
+              source: 'focus',
+              allowThrottle: false
+            });
           }
           return false;
         }
@@ -432,6 +570,7 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
     view: function view() {
       return {
         update: function update(view, prevState) {
+          currentView = view;
           if (!prevState.doc.eq(view.state.doc)) {
             if (justAccepted) {
               justAccepted = false;
@@ -447,18 +586,36 @@ var createAutocompletePlugin = exports.createAutocompletePlugin = function creat
             maybeUpdateSessionFrequency(view, prevState);
             var textBefore = getTextBeforeCursor(view.state);
             if ((0, _slowLaneClient.isWordBoundary)(textBefore)) {
+              var _resolvedContext;
               slowLaneClient.updateContext(buildSlowLaneText(view.state.doc.textContent, resolvedContext));
+
+              // Context may not have resolved on first focus (e.g. comment
+              // thread still loading). Retry on word boundaries until we have
+              // the parent comment, throttled so we don't refetch constantly
+              // and capped so non-comment editors stop retrying entirely.
+              if (!((_resolvedContext = resolvedContext) !== null && _resolvedContext !== void 0 && _resolvedContext.parentCommentContent) && wordBoundaryRefreshAttempts < MAX_CONTEXT_REFRESH_ATTEMPTS) {
+                // Only count the attempt when a fetch actually started, so an
+                // in-flight or throttled no-op doesn't burn the retry budget.
+                if (refreshContext({
+                  source: 'word-boundary'
+                })) {
+                  wordBoundaryRefreshAttempts++;
+                }
+              }
             }
             schedulePrediction(view);
           }
         },
         destroy: function destroy() {
+          destroyed = true;
+          currentView = null;
           if (debounceTimer) {
             clearTimeout(debounceTimer);
           }
           if (hasDestroy(slowLaneClient)) {
             slowLaneClient.destroy();
           }
+          ingestedContextTexts.clear();
           (0, _slowLaneClient.setDefaultSlowLaneClient)(null);
         }
       };

package/dist/cjs/pm-plugins/local-slow-lane-client.js

@@ -622,6 +622,14 @@ var createLocalSlowLaneClient = exports.createLocalSlowLaneClient = function cre
   var lastRequestedText = '';
   var requestCounter = 0;
   var latestRequestId = -1;
+  var inferenceInFlight = false;
+  var activeInferenceText = null;
+  // The requestId of the inference currently in flight. Tracked so the
+  // in-flight dedup path can restore `latestRequestId` to it — otherwise an
+  // intermediate keystroke that bumped `latestRequestId` would cause the
+  // in-flight (still-current) result to be discarded as stale.
+  var activeInferenceRequestId = -1;
+  var pendingInference = null;
   var ready = false;
   var destroyed = false;
   var initFailed = false;
@@ -902,7 +910,7 @@ var createLocalSlowLaneClient = exports.createLocalSlowLaneClient = function cre
           case 5:
             _context3.prev = 5;
             _t2 = _context3["catch"](2);
-            if (!(requestId < latestRequestId)) {
+            if (!(requestId < latestRequestId || destroyed)) {
               _context3.next = 6;
               break;
             }
@@ -933,10 +941,48 @@ var createLocalSlowLaneClient = exports.createLocalSlowLaneClient = function cre
 
   // ── Context update (debounced) ─────────────────────────────────────────
 
+  var _startInference = function startInference(text, requestId) {
+    // Self-contained guard: never start a new inference cycle after teardown,
+    // regardless of caller discipline.
+    if (destroyed) {
+      return;
+    }
+    inferenceInFlight = true;
+    activeInferenceText = text;
+    activeInferenceRequestId = requestId;
+    void ensureEngineInitialized().then(function () {
+      return runInference(text, requestId);
+    }).catch(function () {}).finally(function () {
+      inferenceInFlight = false;
+      activeInferenceText = null;
+      activeInferenceRequestId = -1;
+      var next = pendingInference;
+      pendingInference = null;
+      if (next && !destroyed) {
+        _startInference(next.text, next.requestId);
+      }
+    });
+  };
   var doUpdateContext = function doUpdateContext(text) {
+    var _pendingInference;
     if (destroyed || !text || text.trim().length === 0) {
       return;
     }
+    if (inferenceInFlight && text === activeInferenceText) {
+      // The latest desired text already matches the in-flight inference, so
+      // re-running it would be wasted work. But an intermediate keystroke may
+      // have bumped `latestRequestId` past the in-flight request (and then been
+      // coalesced away), which would cause runInference to discard the
+      // still-current result as stale. Pin `latestRequestId` back to the active
+      // request so its result is accepted, and drop any now-superseded pending
+      // request.
+      latestRequestId = activeInferenceRequestId;
+      pendingInference = null;
+      return;
+    }
+    if (inferenceInFlight && ((_pendingInference = pendingInference) === null || _pendingInference === void 0 ? void 0 : _pendingInference.text) === text) {
+      return;
+    }
     var requestId = ++requestCounter;
     latestRequestId = requestId;
     if ((0, _debugMode.isAutocompleteDebugEnabled)()) {
@@ -950,14 +996,27 @@ var createLocalSlowLaneClient = exports.createLocalSlowLaneClient = function cre
       // eslint-disable-next-line no-console
       console.groupEnd();
     }
-    void ensureEngineInitialized().then(function () {
-      return runInference(text, requestId);
-    }).catch(function () {});
+    if (inferenceInFlight) {
+      pendingInference = {
+        text: text,
+        requestId: requestId
+      };
+      return;
+    }
+    _startInference(text, requestId);
   };
   var updateContextDebounced = function updateContextDebounced(text) {
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
+    if (inferenceInFlight) {
+      pendingInference = null;
+      if (text === activeInferenceText) {
+        latestRequestId = activeInferenceRequestId;
+        lastRequestedText = text;
+        return;
+      }
+    }
     lastRequestedText = text;
     debounceTimer = setTimeout(function () {
       debounceTimer = null;
@@ -996,6 +1055,10 @@ var createLocalSlowLaneClient = exports.createLocalSlowLaneClient = function cre
         unloadEngine(engineToUnload);
       }
       engineInitPromise = null;
+      inferenceInFlight = false;
+      activeInferenceText = null;
+      activeInferenceRequestId = -1;
+      pendingInference = null;
       storedContextVector = null;
       storedLmLogits = null;
     }