@atlaskit/editor-plugin-autocomplete 2.3.0 → 2.5.0

package/dist/cjs/pm-plugins/text-predictor.js

@@ -11,6 +11,7 @@ var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/sli
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _ufo = require("../analytics/ufo");
 var _l3_vocabulary = _interopRequireDefault(require("./data/l3_vocabulary.json"));
 var _vocabulary_10k = _interopRequireDefault(require("./data/vocabulary_10k.json"));
 var _word_index_10k = _interopRequireDefault(require("./data/word_index_10k.json"));
@@ -709,38 +710,46 @@ var loadVectorsAsync = exports.loadVectorsAsync = /*#__PURE__*/function () {
           return _context.abrupt("return");
         case 5:
           vectorsLoadStarted = true;
-          _context.prev = 6;
-          _context.next = 9;
+          (0, _ufo.startExp)(_ufo.EXPERIENCE_NAME.LOAD_VECTORS, 'singleton');
+          _context.prev = 7;
+          _context.next = 10;
           return options.getBinaryUrl();
-        case 9:
+        case 10:
           url = _context.sent;
-          _context.next = 17;
+          _context.next = 19;
           break;
-        case 12:
-          _context.prev = 12;
-          _context.t0 = _context["catch"](6);
+        case 13:
+          _context.prev = 13;
+          _context.t0 = _context["catch"](7);
           vectorsLoadStarted = false;
+          (0, _ufo.failExp)(_ufo.EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            errorType: 'resolve_url'
+          });
           // eslint-disable-next-line no-console
           console.warn('[text-predictor] Failed to resolve vectors URL:', _context.t0);
           return _context.abrupt("return");
-        case 17:
-          _context.prev = 17;
-          _context.next = 20;
+        case 19:
+          _context.prev = 19;
+          _context.next = 22;
           return fetch(url);
-        case 20:
+        case 22:
           res = _context.sent;
           if (res.ok) {
-            _context.next = 25;
+            _context.next = 28;
             break;
           }
           vectorsLoadStarted = false;
+          (0, _ufo.failExp)(_ufo.EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            status: res.status,
+            errorType: 'http_error'
+          });
           // eslint-disable-next-line no-console
           console.warn("[text-predictor] Failed to load vectors: ".concat(res.status));
           return _context.abrupt("return");
-        case 25:
-          _context.next = 27;
+        case 28:
+          _context.next = 30;
           return res.arrayBuffer();
-        case 27:
+        case 30:
           buffer = _context.sent;
           float32 = new Float32Array(buffer);
           wordIndex = _word_index_10k.default;
@@ -751,6 +760,11 @@ var loadVectorsAsync = exports.loadVectorsAsync = /*#__PURE__*/function () {
             wordIndex: wordIndex,
             dim: dim
           };
+          (0, _ufo.succeedExp)(_ufo.EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            wordCount: nWords,
+            dim: dim,
+            sizeBytes: float32.byteLength
+          });
           if ((0, _debugMode.isAutocompleteDebugEnabled)()) {
             // eslint-disable-next-line no-console
             console.log('[text-predictor] Vectors loaded:', {
@@ -759,19 +773,22 @@ var loadVectorsAsync = exports.loadVectorsAsync = /*#__PURE__*/function () {
               sizeBytes: float32.byteLength
             });
           }
-          _context.next = 40;
+          _context.next = 45;
           break;
-        case 36:
-          _context.prev = 36;
-          _context.t1 = _context["catch"](17);
+        case 40:
+          _context.prev = 40;
+          _context.t1 = _context["catch"](19);
           vectorsLoadStarted = false;
+          (0, _ufo.failExp)(_ufo.EXPERIENCE_NAME.LOAD_VECTORS, 'singleton', {
+            errorType: 'network'
+          });
           // eslint-disable-next-line no-console
           console.warn('[text-predictor] Failed to load vectors:', _context.t1);
-        case 40:
+        case 45:
         case "end":
           return _context.stop();
       }
-    }, _callee, null, [[6, 12], [17, 36]]);
+    }, _callee, null, [[7, 13], [19, 40]]);
   }));
   return function loadVectorsAsync(_x) {
     return _ref6.apply(this, arguments);
@@ -781,24 +798,39 @@ var initVectors = exports.initVectors = function initVectors(store) {
   vectorStore = store;
 };
 var loadDefaultVocabulary = exports.loadDefaultVocabulary = function loadDefaultVocabulary() {
-  // 1. Load the Atlassian Domain (L2)
-  var data = _vocabulary_10k.default;
-  var terms = Object.entries(data.words).map(function (_ref7) {
-    var _ref8 = (0, _slicedToArray2.default)(_ref7, 2),
-      word = _ref8[0],
-      stats = _ref8[1];
-    return {
-      word: word,
-      freq: stats.freq,
-      docFreq: stats.doc_freq,
-      authorFreq: stats.author_freq
-    };
-  });
-  initVocabulary({
-    terms: terms
-  });
+  if (isInitialized) {
+    return;
+  }
+  (0, _ufo.startExp)(_ufo.EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton');
+  try {
+    // 1. Load the Atlassian Domain (L2)
+    var data = _vocabulary_10k.default;
+    var terms = Object.entries(data.words).map(function (_ref7) {
+      var _ref8 = (0, _slicedToArray2.default)(_ref7, 2),
+        word = _ref8[0],
+        stats = _ref8[1];
+      return {
+        word: word,
+        freq: stats.freq,
+        docFreq: stats.doc_freq,
+        authorFreq: stats.author_freq
+      };
+    });
+    initVocabulary({
+      terms: terms
+    });
 
-  // 2. Load General English (L3)
-  var l3Words = _l3_vocabulary.default;
-  initL3Vocabulary(l3Words);
+    // 2. Load General English (L3)
+    var l3Words = _l3_vocabulary.default;
+    initL3Vocabulary(l3Words);
+    (0, _ufo.succeedExp)(_ufo.EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+      l2WordCount: terms.length,
+      l3WordCount: l3Words.length
+    });
+  } catch (e) {
+    (0, _ufo.failExp)(_ufo.EXPERIENCE_NAME.LOAD_VOCABULARY, 'singleton', {
+      errorType: 'parse_error'
+    });
+    throw e;
+  }
 };

package/dist/es2019/analytics/ufo.js

@@ -0,0 +1,110 @@
+/**
+ * UFO experience tracking helpers for `@atlaskit/editor-plugin-autocomplete`.
+ *
+ * Pattern follows `packages/linking-platform/smart-card/src/state/analytics/ufoExperiences.ts`
+ * (ConcurrentExperience keyed per request/instance) plus a try/catch safety wrap
+ * inspired by `packages/editor/collab-provider/src/analytics/ufo.ts` so a UFO
+ * runtime error can never break the autocomplete feature.
+ *
+ * Experience names must be registered in DataPortal's `task` attribute before
+ * they can power FE Reliability SLOs:
+ * https://hello.atlassian.net/wiki/spaces/AA6/pages/3961393753
+ */
+
+import { ConcurrentExperience, ExperiencePerformanceTypes, ExperienceTypes } from '@atlaskit/ufo';
+
+/**
+ * Experience name strings are surfaced downstream by the UFO pipeline as
+ * `platform.fe.<type>.<platform.component>.<name>` (e.g.
+ * `platform.fe.operation.editor-plugin-autocomplete.slow-lane-fetch`), so
+ * names here should be short, dot-free, and must not repeat the component
+ * name. This matches the convention used by `@atlaskit/emoji`'s
+ * `ufoExperiences` map (e.g. `'emoji-rendered'`).
+ */
+/**
+ * Only experiences with meaningful async work and a real success/failure
+ * outcome belong on UFO (which measures latency and success rate for FE
+ * Reliability SLOs). Per-keystroke suggestion lifecycle counters (viewed /
+ * inserted / dismissed) are tracked via analytics-next instead — they would
+ * otherwise emit zero-duration events on every word boundary.
+ */
+export const EXPERIENCE_NAME = {
+  SLOW_LANE_FETCH: 'slow-lane-fetch',
+  LOAD_VOCABULARY: 'load-vocabulary',
+  LOAD_VECTORS: 'load-vectors'
+};
+const isUfoEnabled = () => {
+  var _process, _process$env;
+  return !((_process = process) !== null && _process !== void 0 && (_process$env = _process.env) !== null && _process$env !== void 0 && _process$env.REACT_SSR);
+};
+const operationConfig = {
+  platform: {
+    component: 'editor-plugin-autocomplete'
+  },
+  type: ExperienceTypes.Operation,
+  performanceType: ExperiencePerformanceTypes.Custom,
+  performanceConfig: {
+    histogram: {
+      [ExperiencePerformanceTypes.Custom]: {
+        duration: '50_100_250_500_1000_2000_4000'
+      }
+    }
+  }
+};
+const experiences = {
+  [EXPERIENCE_NAME.SLOW_LANE_FETCH]: new ConcurrentExperience(EXPERIENCE_NAME.SLOW_LANE_FETCH, operationConfig),
+  [EXPERIENCE_NAME.LOAD_VOCABULARY]: new ConcurrentExperience(EXPERIENCE_NAME.LOAD_VOCABULARY, operationConfig),
+  [EXPERIENCE_NAME.LOAD_VECTORS]: new ConcurrentExperience(EXPERIENCE_NAME.LOAD_VECTORS, operationConfig)
+};
+export const startExp = (name, id, metadata) => {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    const instance = experiences[name].getInstance(id);
+    instance.start();
+    if (metadata) {
+      instance.addMetadata(metadata);
+    }
+  } catch {
+    // UFO errors must never break the plugin
+  }
+};
+export const succeedExp = (name, id, metadata) => {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).success({
+      metadata
+    });
+  } catch {
+    // UFO errors must never break the plugin
+  }
+};
+export const failExp = (name, id, metadata) => {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).failure({
+      metadata
+    });
+  } catch {
+    // UFO errors must never break the plugin
+  }
+};
+export const abortExp = (name, id, reason) => {
+  if (!isUfoEnabled()) {
+    return;
+  }
+  try {
+    experiences[name].getInstance(id).abort(reason ? {
+      metadata: {
+        reason
+      }
+    } : undefined);
+  } catch {
+    // UFO errors must never break the plugin
+  }
+};

package/dist/es2019/entry-points/autocompletePlugin.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { autocompletePlugin } from '../autocompletePlugin';

package/dist/es2019/entry-points/src-pm-plugins-autocomplete-plugin.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { autocompletePluginKey, createAutocompletePlugin } from '../pm-plugins/autocomplete-plugin';

package/dist/es2019/entry-points/src-pm-plugins-slow-lane-client.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { createSlowLaneClient, getStoredContextVector, getStoredLmLogits, isWordBoundary, setDefaultSlowLaneClient } from '../pm-plugins/slow-lane-client';

package/dist/es2019/entry-points/src-pm-plugins-text-predictor.js

@@ -0,0 +1,2 @@
+/* eslint-disable @atlaskit/editor/no-re-export */
+export { getLastPredictionDebug, getPredictorStatus, incrementSessionFreq, ingestDocumentPage, initL3Vocabulary, initVectors, initVocabulary, loadDefaultVocabulary, loadVectorsAsync, predict } from '../pm-plugins/text-predictor';

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

@@ -1,14 +1,16 @@
 import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { logException } from '@atlaskit/editor-common/monitoring';
 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 { 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';
-const SLOW_LANE_ENDPOINT = '/gateway/api/v1/autocomplete/typeahead-encodings';
 export const autocompletePluginKey = new PluginKey('autocomplete');
 const DEBOUNCE_MS = 150;
+const hasDestroy = client => 'destroy' in client && typeof client.destroy === 'function';
 const createInitialState = () => ({
   ghostText: '',
   ghostPosition: -1,
@@ -61,17 +63,23 @@ const setAutocompleteMeta = (tr, meta) => {
  */
 let lastShownGhostText = '';
 const showGhostText = (view, text, position) => {
-  const {
-    state,
-    dispatch
-  } = view;
-  const decorationSet = createGhostTextDecorationSet(state, position, text);
-  const tr = setAutocompleteMeta(state.tr, {
-    ghostText: text,
-    ghostPosition: position,
-    decorationSet
-  });
-  dispatch(tr);
+  try {
+    const {
+      state,
+      dispatch
+    } = view;
+    const decorationSet = createGhostTextDecorationSet(state, position, text);
+    const tr = setAutocompleteMeta(state.tr, {
+      ghostText: text,
+      ghostPosition: position,
+      decorationSet
+    });
+    dispatch(tr);
+  } catch (error) {
+    logException(error, {
+      location: 'editor-plugin-autocomplete/showGhostText'
+    });
+  }
 };
 
 /**
@@ -83,12 +91,19 @@ const clearGhostText = (state, dispatch) => {
     return false;
   }
   if (dispatch) {
-    const tr = setAutocompleteMeta(state.tr, {
-      ghostText: '',
-      ghostPosition: -1,
-      decorationSet: DecorationSet.empty
-    });
-    dispatch(tr);
+    try {
+      const tr = setAutocompleteMeta(state.tr, {
+        ghostText: '',
+        ghostPosition: -1,
+        decorationSet: DecorationSet.empty
+      });
+      dispatch(tr);
+    } catch (error) {
+      logException(error, {
+        location: 'editor-plugin-autocomplete/clearGhostText'
+      });
+      return false;
+    }
   }
   return true;
 };
@@ -102,17 +117,24 @@ const acceptGhostText = (state, dispatch) => {
     return false;
   }
   if (dispatch) {
-    const {
-      ghostText,
-      ghostPosition
-    } = pluginState;
-    let tr = state.tr.insertText(ghostText, ghostPosition);
-    tr = setAutocompleteMeta(tr, {
-      ghostText: '',
-      ghostPosition: -1,
-      decorationSet: DecorationSet.empty
-    });
-    dispatch(tr);
+    try {
+      const {
+        ghostText,
+        ghostPosition
+      } = pluginState;
+      let tr = state.tr.insertText(ghostText, ghostPosition);
+      tr = setAutocompleteMeta(tr, {
+        ghostText: '',
+        ghostPosition: -1,
+        decorationSet: DecorationSet.empty
+      });
+      dispatch(tr);
+    } catch (error) {
+      logException(error, {
+        location: 'editor-plugin-autocomplete/acceptGhostText'
+      });
+      return false;
+    }
   }
   return true;
 };
@@ -171,12 +193,23 @@ export const createAutocompletePlugin = (options, api) => {
   let dismissedContext = null;
   let lastSuggestionTypedLength = 0;
   let lastSuggestionLength = 0;
-  const fireSuggestionInsertedAnalytics = ghostText => {
+  const fireSuggestionDismissedAnalytics = reason => {
     var _api$analytics;
+    api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions.fireAnalyticsEvent({
+      action: ACTION.SUGGESTION_DISMISSED,
+      actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
+      eventType: EVENT_TYPE.TRACK,
+      attributes: {
+        reason
+      }
+    });
+  };
+  const fireSuggestionInsertedAnalytics = ghostText => {
+    var _api$analytics2;
     const typedLength = lastSuggestionTypedLength;
     const suggestionLength = lastSuggestionLength || typedLength + ghostText.length;
     const kssDelta = suggestionLength - typedLength;
-    api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions.fireAnalyticsEvent({
+    api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions.fireAnalyticsEvent({
       action: ACTION.SUGGESTION_INSERTED,
       actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
       eventType: EVENT_TYPE.TRACK,
@@ -187,9 +220,11 @@ export const createAutocompletePlugin = (options, api) => {
       }
     });
   };
-  const slowLaneClient = createSlowLaneClient({
+  const slowLaneClient = options !== null && options !== void 0 && options.useLocalModel ? createLocalSlowLaneClient({
+    debounceMs: 300
+  }) : createSlowLaneClient({
     baseUrl: '',
-    endpoint: SLOW_LANE_ENDPOINT
+    debounceMs: 300
   });
   setDefaultSlowLaneClient(slowLaneClient);
 
@@ -203,47 +238,53 @@ export const createAutocompletePlugin = (options, api) => {
       clearTimeout(debounceTimer);
     }
     debounceTimer = setTimeout(() => {
-      const {
-        state
-      } = view;
-      const {
-        selection
-      } = state;
+      try {
+        const {
+          state
+        } = view;
+        const {
+          selection
+        } = state;
 
-      // Only predict for cursor selections (not range selections)
-      if (!selection.empty) {
-        return;
-      }
-      const textBefore = getTextBeforeCursor(state);
+        // Only predict for cursor selections (not range selections)
+        if (!selection.empty) {
+          return;
+        }
+        const textBefore = getTextBeforeCursor(state);
 
-      // Suppress re-showing the same suggestion the user just dismissed.
-      // Once the text context changes (user types or deletes), this clears automatically.
-      if (textBefore === dismissedContext) {
-        return;
-      }
-      dismissedContext = null;
+        // Suppress re-showing the same suggestion the user just dismissed.
+        // Once the text context changes (user types or deletes), this clears automatically.
+        if (textBefore === dismissedContext) {
+          return;
+        }
+        dismissedContext = null;
 
-      // Don't predict if there's not enough context
-      if (textBefore.trim().length < 3) {
-        return;
-      }
+        // Don't predict if there's not enough context
+        if (textBefore.trim().length < 3) {
+          return;
+        }
 
-      // Tier 1 prediction is synchronous -- no async needed
-      const prediction = predict(textBefore);
-      if (prediction && prediction.length > 0) {
-        const typedLength = getTypedLengthForPrediction(textBefore);
-        lastSuggestionTypedLength = typedLength;
-        lastSuggestionLength = typedLength + prediction.length;
-        showGhostText(view, prediction, selection.from);
-        if (prediction !== lastShownGhostText) {
-          var _api$analytics2;
-          lastShownGhostText = prediction;
-          api === null || api === void 0 ? void 0 : (_api$analytics2 = api.analytics) === null || _api$analytics2 === void 0 ? void 0 : _api$analytics2.actions.fireAnalyticsEvent({
-            action: ACTION.SUGGESTION_VIEWED,
-            actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
-            eventType: EVENT_TYPE.TRACK
-          });
+        // Tier 1 prediction is synchronous -- no async needed
+        const prediction = predict(textBefore);
+        if (prediction && prediction.length > 0) {
+          const typedLength = getTypedLengthForPrediction(textBefore);
+          lastSuggestionTypedLength = typedLength;
+          lastSuggestionLength = typedLength + prediction.length;
+          showGhostText(view, prediction, selection.from);
+          if (prediction !== lastShownGhostText) {
+            var _api$analytics3;
+            lastShownGhostText = prediction;
+            api === null || api === void 0 ? void 0 : (_api$analytics3 = api.analytics) === null || _api$analytics3 === void 0 ? void 0 : _api$analytics3.actions.fireAnalyticsEvent({
+              action: ACTION.SUGGESTION_VIEWED,
+              actionSubject: ACTION_SUBJECT.CONTEXTUAL_TYPEAHEAD,
+              eventType: EVENT_TYPE.TRACK
+            });
+          }
         }
+      } catch (error) {
+        logException(error, {
+          location: 'editor-plugin-autocomplete/schedulePrediction'
+        });
       }
     }, DEBOUNCE_MS);
   };
@@ -344,6 +385,7 @@ export const createAutocompletePlugin = (options, api) => {
           const didClear = clearGhostText(state, dispatch);
           if (didClear) {
             dismissedContext = getTextBeforeCursor(state);
+            fireSuggestionDismissedAnalytics('escape');
           }
           return didClear;
         }
@@ -353,14 +395,25 @@ export const createAutocompletePlugin = (options, api) => {
           const pluginState = autocompletePluginKey.getState(view.state);
           if (pluginState !== null && pluginState !== void 0 && pluginState.ghostText) {
             clearGhostText(view.state, view.dispatch);
+            fireSuggestionDismissedAnalytics('blur');
           }
           return false;
         },
         focus: () => {
-          loadDefaultVocabulary();
+          try {
+            loadDefaultVocabulary();
+          } catch (error) {
+            logException(error, {
+              location: 'editor-plugin-autocomplete/loadDefaultVocabulary'
+            });
+          }
           loadVectorsAsync({
             getBinaryUrl: options === null || options === void 0 ? void 0 : options.getVectorsBinaryUrl
-          }).catch(() => {});
+          }).catch(error => {
+            logException(error, {
+              location: 'editor-plugin-autocomplete/loadVectorsAsync'
+            });
+          });
           if (!hasIngestedPage) {
             hasIngestedPage = true;
             if (options !== null && options !== void 0 && options.getContext) {
@@ -377,7 +430,11 @@ export const createAutocompletePlugin = (options, api) => {
                   ingestDocumentPage(context.parentCommentContent);
                 }
                 (_context$siblingComme4 = context.siblingCommentsContents) === null || _context$siblingComme4 === void 0 ? void 0 : _context$siblingComme4.forEach(ingestDocumentPage);
-              }).catch(() => {});
+              }).catch(error => {
+                logException(error, {
+                  location: 'editor-plugin-autocomplete/getContext'
+                });
+              });
             }
           }
           return false;
@@ -413,6 +470,9 @@ export const createAutocompletePlugin = (options, api) => {
         if (debounceTimer) {
           clearTimeout(debounceTimer);
         }
+        if (hasDestroy(slowLaneClient)) {
+          slowLaneClient.destroy();
+        }
         setDefaultSlowLaneClient(null);
       }
     })