@atlaskit/editor-plugin-autocomplete 3.2.0 → 3.4.0

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

@@ -4,12 +4,26 @@ import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { keydownHandler } from '@atlaskit/editor-prosemirror/keymap';
 import { PluginKey } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
+import { isAutocompleteDebugEnabled } from './debug-mode';
 import { createGhostTextDecorationSet } from './ghost-text-decoration';
 import { createLocalSlowLaneClient } from './local-slow-lane-client';
 import { createSlowLaneClient, setDefaultSlowLaneClient, isWordBoundary } from './slow-lane-client';
 import { predict, loadDefaultVocabulary, loadVectorsAsync, incrementSessionFreq, ingestDocumentPage } from './text-predictor';
 export const autocompletePluginKey = new PluginKey('autocomplete');
 const DEBOUNCE_MS = 150;
+const NETWORK_SLOW_LANE_DEBOUNCE_MS = 300;
+const LOCAL_SLOW_LANE_DEBOUNCE_MS = 100;
+const 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.
+const 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.
+const MAX_CONTEXT_REFRESH_ATTEMPTS = 5;
 const hasDestroy = client => 'destroy' in client && typeof client.destroy === 'function';
 const createInitialState = () => ({
   ghostText: '',
@@ -176,6 +190,12 @@ export const createAutocompletePlugin = (options, api) => {
   let debounceTimer = null;
   let hasIngestedPage = false;
   let 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.
+   */
+  let currentView = null;
   /**
    * Set after accepting a suggestion so the next doc-change update
    * skips scheduling a new prediction for the just-inserted text.
@@ -219,12 +239,115 @@ export const createAutocompletePlugin = (options, api) => {
     });
   };
   const slowLaneClient = options !== null && options !== void 0 && options.useLocalModel ? createLocalSlowLaneClient({
-    debounceMs: 300
+    debounceMs: LOCAL_SLOW_LANE_DEBOUNCE_MS
   }) : createSlowLaneClient({
     baseUrl: '',
-    debounceMs: 300
+    debounceMs: NETWORK_SLOW_LANE_DEBOUNCE_MS
   });
   setDefaultSlowLaneClient(slowLaneClient);
+  let contextRequestInFlight = false;
+  let lastContextRefreshAt = 0;
+  // Bounds the word-boundary retry loop so it terminates even when the editor is
+  // not in a comment thread (parentCommentContent never resolves).
+  let wordBoundaryRefreshAttempts = 0;
+  // Set when the plugin is torn down so in-flight getContext() resolutions don't
+  // mutate the global text-predictor state after destruction.
+  let destroyed = false;
+  const ingestedContextTexts = new Set();
+  const logContextResolved = (source, context) => {
+    var _context$parentCommen, _context$siblingComme4, _context$siblingComme5;
+    if (!isAutocompleteDebugEnabled()) {
+      return;
+    }
+
+    // eslint-disable-next-line no-console
+    console.log('%c[Autocomplete] %cgetContext resolved', 'color: #00b8d9; font-weight: bold;', 'color: inherit;', {
+      source,
+      hasParentComment: !!(context !== null && context !== void 0 && context.parentCommentContent),
+      parentCommentPreview: context === null || context === void 0 ? 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 ? 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)
+    });
+  };
+  const applyContext = context => {
+    // 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.
+    const definedContext = Object.fromEntries(Object.entries(context).filter(([, value]) => value !== undefined));
+    resolvedContext = {
+      ...resolvedContext,
+      ...definedContext
+    };
+    const 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) {
+        const oldest = ingestedContextTexts.values().next().value;
+        if (oldest === undefined) {
+          break;
+        }
+        ingestedContextTexts.delete(oldest);
+      }
+      ingestDocumentPage(text);
+    };
+    ingestContextText(context.fullPageContent);
+    ingestContextText(context.parentCommentContent);
+    for (const siblingCommentContent of (_context$siblingComme6 = context.siblingCommentsContents) !== null && _context$siblingComme6 !== void 0 ? _context$siblingComme6 : []) {
+      var _context$siblingComme6;
+      ingestContextText(siblingCommentContent);
+    }
+
+    // Context arrived after word boundaries may already have fired. Re-send
+    // slow-lane context immediately so the next inference includes the thread.
+    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.
+   */
+  const refreshContext = ({
+    source,
+    allowThrottle = true
+  }) => {
+    if (!(options !== null && options !== void 0 && options.getContext) || contextRequestInFlight) {
+      return false;
+    }
+    const now = Date.now();
+    if (allowThrottle && now - lastContextRefreshAt < CONTEXT_REFRESH_THROTTLE_MS) {
+      return false;
+    }
+    contextRequestInFlight = true;
+    lastContextRefreshAt = now;
+    options.getContext().then(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(error => {
+      logException(error, {
+        location: 'editor-plugin-autocomplete/getContext'
+      });
+    }).finally(() => {
+      contextRequestInFlight = false;
+    });
+    return true;
+  };
 
   /**
    * Schedule a prediction after a short debounce.
@@ -403,26 +526,10 @@ export const createAutocompletePlugin = (options, api) => {
           });
           if (!hasIngestedPage) {
             hasIngestedPage = true;
-            if (options !== null && options !== void 0 && options.getContext) {
-              options.getContext().then(context => {
-                var _context$siblingComme4;
-                if (!context) {
-                  return;
-                }
-                resolvedContext = context;
-                if (context.fullPageContent) {
-                  ingestDocumentPage(context.fullPageContent);
-                }
-                if (context.parentCommentContent) {
-                  ingestDocumentPage(context.parentCommentContent);
-                }
-                (_context$siblingComme4 = context.siblingCommentsContents) === null || _context$siblingComme4 === void 0 ? void 0 : _context$siblingComme4.forEach(ingestDocumentPage);
-              }).catch(error => {
-                logException(error, {
-                  location: 'editor-plugin-autocomplete/getContext'
-                });
-              });
-            }
+            refreshContext({
+              source: 'focus',
+              allowThrottle: false
+            });
           }
           return false;
         }
@@ -430,6 +537,7 @@ export const createAutocompletePlugin = (options, api) => {
     },
     view: () => ({
       update: (view, prevState) => {
+        currentView = view;
         if (!prevState.doc.eq(view.state.doc)) {
           if (justAccepted) {
             justAccepted = false;
@@ -445,18 +553,36 @@ export const createAutocompletePlugin = (options, api) => {
           maybeUpdateSessionFrequency(view, prevState);
           const textBefore = getTextBeforeCursor(view.state);
           if (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: () => {
+        destroyed = true;
+        currentView = null;
         if (debounceTimer) {
           clearTimeout(debounceTimer);
         }
         if (hasDestroy(slowLaneClient)) {
           slowLaneClient.destroy();
         }
+        ingestedContextTexts.clear();
         setDefaultSlowLaneClient(null);
       }
     })

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

@@ -109,13 +109,37 @@ export const BE_PARITY = {
    */
   MAX_CONTEXT_WORDS: 100
 };
+const splitOnWhitespace = text => {
+  const trimmed = text.trim();
+  if (trimmed === '') {
+    return [];
+  }
+  const words = [];
+  let wordStart = -1;
+  for (let i = 0; i < trimmed.length; i++) {
+    if (trimmed[i].trim() === '') {
+      if (wordStart !== -1) {
+        words.push(trimmed.slice(wordStart, i));
+        wordStart = -1;
+      }
+      continue;
+    }
+    if (wordStart === -1) {
+      wordStart = i;
+    }
+  }
+  if (wordStart !== -1) {
+    words.push(trimmed.slice(wordStart));
+  }
+  return words;
+};
 
 /**
  * Return the last `n` whitespace-separated words of `text`, joined by spaces.
  * Mirrors the BE rolling-window truncation applied before both encoders.
  */
 const truncateToLastNWords = (text, n) => {
-  const words = text.trim().split(/\s+/u);
+  const words = splitOnWhitespace(text);
   return words.length <= n ? text : words.slice(-n).join(' ');
 };
 
@@ -457,6 +481,14 @@ export const createLocalSlowLaneClient = (config = {}) => {
   let lastRequestedText = '';
   let requestCounter = 0;
   let latestRequestId = -1;
+  let inferenceInFlight = false;
+  let 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.
+  let activeInferenceRequestId = -1;
+  let pendingInference = null;
   let ready = false;
   let destroyed = false;
   let initFailed = false;
@@ -600,32 +632,34 @@ export const createLocalSlowLaneClient = (config = {}) => {
     const lmText = truncateToLastNWords(text, BE_PARITY.MAX_CONTEXT_TOKENS);
     const semanticText = truncateToLastNWords(text, BE_PARITY.MAX_CONTEXT_WORDS);
     const arcticInput = wrapForArctic(semanticText);
+    const captureCompletionTime = (promise, onResolved) => promise.then(value => {
+      onResolved(performance.now());
+      return value;
+    });
     if (isAutocompleteDebugEnabled()) {
       // eslint-disable-next-line no-console
-      console.log(`%c[LocalSlowLane] %c🔢 Arctic input (${arcticInput.length} chars, ${semanticText.split(/\s+/u).length} words): "${arcticInput.length > 100 ? `${arcticInput.slice(0, 100)}…` : arcticInput}"`, 'color: #9c27b0; font-weight: bold;', 'color: #009688;');
+      console.log(`%c[LocalSlowLane] %c🔢 Arctic input (${arcticInput.length} chars, ${splitOnWhitespace(semanticText).length} words): "${arcticInput.length > 100 ? `${arcticInput.slice(0, 100)}…` : arcticInput}"`, 'color: #9c27b0; font-weight: bold;', 'color: #009688;');
       // eslint-disable-next-line no-console
-      console.log(`%c[LocalSlowLane] %c🧠 LM input (${lmText.length} chars, ${lmText.split(/\s+/u).length} words): "${lmText.length > 100 ? `${lmText.slice(0, 100)}…` : lmText}"`, 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
+      console.log(`%c[LocalSlowLane] %c🧠 LM input (${lmText.length} chars, ${splitOnWhitespace(lmText).length} words): "${lmText.length > 100 ? `${lmText.slice(0, 100)}…` : lmText}"`, 'color: #9c27b0; font-weight: bold;', 'color: #2196f3;');
     }
     try {
-      var _embeddingResponse$da, _embeddingResponse$da2;
+      var _data, _data$;
       const tStart = performance.now();
       let tLmDone = 0;
       let tEmbDone = 0;
-      const [, embeddingResponse] = await Promise.all([engine.completions.create({
+      const [, embeddingResponse] = await Promise.all([captureCompletionTime(engine.completions.create({
         model: modelId,
         prompt: lmText,
         max_tokens: 1,
         temperature: 0,
         logprobs: false
-      }).then(r => {
-        tLmDone = performance.now();
-        return r;
-      }), engine.embeddings.create({
+      }), resolvedAt => {
+        tLmDone = resolvedAt;
+      }), captureCompletionTime(engine.embeddings.create({
         model: LOCAL_MLC_EMBEDDING_MODEL_ID,
         input: arcticInput
-      }).then(r => {
-        tEmbDone = performance.now();
-        return r;
+      }), resolvedAt => {
+        tEmbDone = resolvedAt;
       })]);
       if (isAutocompleteDebugEnabled()) {
         // eslint-disable-next-line no-console
@@ -650,7 +684,7 @@ export const createLocalSlowLaneClient = (config = {}) => {
       // Guard against base64-encoded responses (encoding_format: 'base64' would
       // yield a string, and new Float32Array(string) silently produces an empty
       // array, corrupting downstream cosine-similarity scoring).
-      const embedding = (_embeddingResponse$da = embeddingResponse.data) === null || _embeddingResponse$da === void 0 ? void 0 : (_embeddingResponse$da2 = _embeddingResponse$da[0]) === null || _embeddingResponse$da2 === void 0 ? void 0 : _embeddingResponse$da2.embedding;
+      const embedding = (_data = embeddingResponse.data) === null || _data === void 0 ? void 0 : (_data$ = _data[0]) === null || _data$ === void 0 ? void 0 : _data$.embedding;
       storedContextVector = Array.isArray(embedding) && embedding.length > 0 ? new Float32Array(embedding) : null;
       if (isAutocompleteDebugEnabled()) {
         // eslint-disable-next-line no-console
@@ -682,8 +716,8 @@ export const createLocalSlowLaneClient = (config = {}) => {
         hasLmLogits: storedLmLogits !== null
       });
     } catch (err) {
-      // Discard errors for stale requests
-      if (requestId < latestRequestId) {
+      // Discard errors for stale requests or after teardown
+      if (requestId < latestRequestId || destroyed) {
         return;
       }
       storedContextVector = null;
@@ -703,10 +737,46 @@ export const createLocalSlowLaneClient = (config = {}) => {
 
   // ── Context update (debounced) ─────────────────────────────────────────
 
+  const 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(() => runInference(text, requestId)).catch(() => {}).finally(() => {
+      inferenceInFlight = false;
+      activeInferenceText = null;
+      activeInferenceRequestId = -1;
+      const next = pendingInference;
+      pendingInference = null;
+      if (next && !destroyed) {
+        startInference(next.text, next.requestId);
+      }
+    });
+  };
   const 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;
+    }
     const requestId = ++requestCounter;
     latestRequestId = requestId;
     if (isAutocompleteDebugEnabled()) {
@@ -720,12 +790,27 @@ export const createLocalSlowLaneClient = (config = {}) => {
       // eslint-disable-next-line no-console
       console.groupEnd();
     }
-    void ensureEngineInitialized().then(() => runInference(text, requestId)).catch(() => {});
+    if (inferenceInFlight) {
+      pendingInference = {
+        text,
+        requestId
+      };
+      return;
+    }
+    startInference(text, requestId);
   };
   const updateContextDebounced = text => {
     if (debounceTimer) {
       clearTimeout(debounceTimer);
     }
+    if (inferenceInFlight) {
+      pendingInference = null;
+      if (text === activeInferenceText) {
+        latestRequestId = activeInferenceRequestId;
+        lastRequestedText = text;
+        return;
+      }
+    }
     lastRequestedText = text;
     debounceTimer = setTimeout(() => {
       debounceTimer = null;
@@ -758,6 +843,10 @@ export const createLocalSlowLaneClient = (config = {}) => {
         unloadEngine(engineToUnload);
       }
       engineInitPromise = null;
+      inferenceInFlight = false;
+      activeInferenceText = null;
+      activeInferenceRequestId = -1;
+      pendingInference = null;
       storedContextVector = null;
       storedLmLogits = null;
     }