@atlaskit/editor-plugin-code-block 12.1.10 → 13.0.0

package/dist/cjs/utils/auto-detect-state.js

@@ -0,0 +1,185 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateAutoDetectState = exports.shouldTriggerLargeChangeDetection = exports.removeAutoDetection = exports.queueAutoDetection = exports.hasEnoughTextForAutoDetection = exports.getLocalId = exports.getFirstLine = exports.createAutoDetectEntry = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _codeBlock = require("@atlaskit/editor-common/code-block");
+var _utils = require("../pm-plugins/utils");
+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 MIN_AUTO_DETECT_TEXT_LENGTH = 20;
+var shouldTriggerLargeChangeDetection = exports.shouldTriggerLargeChangeDetection = function shouldTriggerLargeChangeDetection(lastObservedText, text) {
+  if (!lastObservedText) {
+    return text.length > 0;
+  }
+  return Math.abs(text.length - lastObservedText.length) > lastObservedText.length / 2;
+};
+var getFirstLine = exports.getFirstLine = function getFirstLine(text) {
+  var _text$split$;
+  return (_text$split$ = text.split('\n')[0]) !== null && _text$split$ !== void 0 ? _text$split$ : '';
+};
+var hasEnoughTextForAutoDetection = exports.hasEnoughTextForAutoDetection = function hasEnoughTextForAutoDetection(text) {
+  return text.trim().length >= MIN_AUTO_DETECT_TEXT_LENGTH;
+};
+var getLocalId = exports.getLocalId = function getLocalId(node) {
+  return typeof node.attrs.localId === 'string' ? node.attrs.localId : null;
+};
+var createAutoDetectEntry = exports.createAutoDetectEntry = function createAutoDetectEntry(node, pos, isPending, previous) {
+  return {
+    lastObservedText: node.textContent,
+    lastObservedFirstLine: getFirstLine(node.textContent),
+    isPending: isPending,
+    detectionResult: previous === null || previous === void 0 ? void 0 : previous.detectionResult,
+    autoDetectedLanguage: previous === null || previous === void 0 ? void 0 : previous.autoDetectedLanguage,
+    pos: pos
+  };
+};
+var queueAutoDetection = exports.queueAutoDetection = function queueAutoDetection(languageDetectionMap, node, pos, isPending) {
+  var localId = getLocalId(node);
+  if (!localId) {
+    return languageDetectionMap;
+  }
+  return _objectSpread(_objectSpread({}, languageDetectionMap), {}, (0, _defineProperty2.default)({}, localId, createAutoDetectEntry(node, pos, isPending, languageDetectionMap[localId])));
+};
+var removeAutoDetection = exports.removeAutoDetection = function removeAutoDetection(languageDetectionMap, localId) {
+  if (!languageDetectionMap[localId]) {
+    return languageDetectionMap;
+  }
+  var nextLanguageDetectionMap = _objectSpread({}, languageDetectionMap);
+  delete nextLanguageDetectionMap[localId];
+  return nextLanguageDetectionMap;
+};
+var getCodeBlockLocalIdsRemovedFromChangedRanges = function getCodeBlockLocalIdsRemovedFromChangedRanges(tr, codeBlockType) {
+  var localIds = new Set();
+  tr.steps.forEach(function (step, stepIndex) {
+    var docAtStep = tr.docs[stepIndex];
+    step.getMap().forEach(function (oldStart, oldEnd) {
+      if (oldStart === oldEnd) {
+        return;
+      }
+      var clampedOldEnd = Math.min(oldEnd, docAtStep.content.size);
+      docAtStep.nodesBetween(oldStart, clampedOldEnd, function (node, pos) {
+        if (node.type !== codeBlockType) {
+          return true;
+        }
+        var isWholeCodeBlockRemoved = pos >= oldStart && pos + node.nodeSize <= clampedOldEnd;
+        if (!isWholeCodeBlockRemoved) {
+          return false;
+        }
+        var localId = getLocalId(node);
+        if (localId) {
+          localIds.add(localId);
+        }
+        return false;
+      });
+    });
+  });
+  return localIds;
+};
+var getCodeBlockTransactionChanges = function getCodeBlockTransactionChanges(tr, codeBlockType) {
+  var insertedNodesWithPos = (0, _codeBlock.getInsertedCodeBlocksInTransaction)(tr, codeBlockType);
+  var removedFromChangedRangesLocalIds = getCodeBlockLocalIdsRemovedFromChangedRanges(tr, codeBlockType);
+  var insertedLocalIds = new Set();
+  var insertedCodeBlocks = [];
+  insertedNodesWithPos.forEach(function (_ref) {
+    var node = _ref.node,
+      pos = _ref.pos;
+    var localId = getLocalId(node);
+    if (!localId) {
+      return;
+    }
+    insertedLocalIds.add(localId);
+    if (!removedFromChangedRangesLocalIds.has(localId)) {
+      insertedCodeBlocks.push({
+        localId: localId,
+        node: node,
+        pos: pos
+      });
+    }
+  });
+  var deletedLocalIds = new Set();
+  removedFromChangedRangesLocalIds.forEach(function (localId) {
+    if (!insertedLocalIds.has(localId)) {
+      deletedLocalIds.add(localId);
+    }
+  });
+  return {
+    deletedLocalIds: deletedLocalIds,
+    insertedCodeBlocks: insertedCodeBlocks
+  };
+};
+var updateAutoDetectState = exports.updateAutoDetectState = function updateAutoDetectState(tr, pluginState) {
+  var codeBlock = tr.doc.type.schema.nodes.codeBlock;
+  var isPaste = tr.getMeta('paste') === true || tr.getMeta('uiEvent') === 'paste';
+  var isExternalContentChange = tr.getMeta('replaceDocument') === true || tr.getMeta('isRemote') === true;
+  var hasTrackedEntries = Object.keys(pluginState.languageDetectionMap).length > 0;
+
+  // Page loads and remote edits should not start auto-detection for code blocks.
+  if (!hasTrackedEntries && isExternalContentChange) {
+    return pluginState.languageDetectionMap;
+  }
+
+  // Existing entries still need mapping/deletion cleanup, but external edits should not refresh text.
+  var changedCodeBlockNodes = isExternalContentChange ? [] : (0, _utils.getAllChangedCodeBlocksInTransaction)(tr);
+  if (!hasTrackedEntries && !changedCodeBlockNodes.length) {
+    return pluginState.languageDetectionMap;
+  }
+  var _getCodeBlockTransact = getCodeBlockTransactionChanges(tr, codeBlock),
+    deletedLocalIds = _getCodeBlockTransact.deletedLocalIds,
+    insertedCodeBlocks = _getCodeBlockTransact.insertedCodeBlocks;
+  var languageDetectionMap = hasTrackedEntries ? Object.fromEntries(Object.entries(pluginState.languageDetectionMap).map(function (_ref2) {
+    var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+      localId = _ref3[0],
+      entry = _ref3[1];
+    return [localId, _objectSpread(_objectSpread({}, entry), {}, {
+      pos: tr.mapping.map(entry.pos)
+    })];
+  })) : pluginState.languageDetectionMap;
+  if (!isExternalContentChange) {
+    insertedCodeBlocks.forEach(function (_ref4) {
+      var localId = _ref4.localId,
+        node = _ref4.node,
+        pos = _ref4.pos;
+      if (node.attrs.language) {
+        languageDetectionMap = removeAutoDetection(languageDetectionMap, localId);
+        return;
+      }
+      languageDetectionMap = queueAutoDetection(languageDetectionMap, node, pos, hasEnoughTextForAutoDetection(node.textContent));
+    });
+    changedCodeBlockNodes.forEach(function (_ref5) {
+      var node = _ref5.node,
+        pos = _ref5.pos;
+      var localId = getLocalId(node);
+      if (!localId || !languageDetectionMap[localId]) {
+        return;
+      }
+      var currentLanguage = node.attrs.language;
+      var previousEntry = languageDetectionMap[localId];
+      if (currentLanguage && currentLanguage !== previousEntry.autoDetectedLanguage) {
+        languageDetectionMap = removeAutoDetection(languageDetectionMap, localId);
+        return;
+      }
+      var text = node.textContent;
+      var firstLine = getFirstLine(text);
+      var shouldTriggerDetection = previousEntry.isPending || isPaste || firstLine !== previousEntry.lastObservedFirstLine || shouldTriggerLargeChangeDetection(previousEntry.lastObservedText, text);
+      var isPending = hasEnoughTextForAutoDetection(text) && shouldTriggerDetection;
+
+      // Only pending detection refreshes the text snapshot; otherwise gradual typing
+      // should continue comparing against the last attempted detection.
+      languageDetectionMap = isPending ? queueAutoDetection(languageDetectionMap, node, pos, true) : _objectSpread(_objectSpread({}, languageDetectionMap), {}, (0, _defineProperty2.default)({}, localId, _objectSpread(_objectSpread({}, previousEntry), {}, {
+        isPending: false,
+        pos: pos
+      })));
+    });
+  }
+  deletedLocalIds.forEach(function (localId) {
+    if (languageDetectionMap[localId]) {
+      languageDetectionMap = removeAutoDetection(languageDetectionMap, localId);
+    }
+  });
+  return languageDetectionMap;
+};

package/dist/cjs/utils/auto-detect-view.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.syncPendingDetectionTimers = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _analytics = require("@atlaskit/editor-common/analytics");
+var _actions = require("../pm-plugins/actions");
+var _autoDetectState = require("../pm-plugins/auto-detect-state");
+var _autoDetectState2 = require("./auto-detect-state");
+var _languageDetect = require("./language-detect");
+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 AUTO_DETECT_DEBOUNCE_MS = 500;
+
+// Stored positions are mapped through transactions; verify the localId before using them.
+var getCodeBlockFromEntry = function getCodeBlockFromEntry(view, localId, entry) {
+  var node = view.state.doc.nodeAt(entry.pos);
+  var codeBlockType = view.state.schema.nodes.codeBlock;
+  if ((node === null || node === void 0 ? void 0 : node.type) === codeBlockType && node.attrs.localId === localId) {
+    return {
+      node: node,
+      pos: entry.pos
+    };
+  }
+  return null;
+};
+
+// Runs after debounce, so it must re-read current editor state before applying language changes.
+var runPendingDetection = function runPendingDetection(view, localId, api) {
+  var _api$core;
+  var pluginState = _autoDetectState.autoDetectPluginKey.getState(view.state);
+  var entry = pluginState === null || pluginState === void 0 ? void 0 : pluginState.languageDetectionMap[localId];
+  if (!(entry !== null && entry !== void 0 && entry.isPending)) {
+    return;
+  }
+  var found = getCodeBlockFromEntry(view, localId, entry);
+  if (!found) {
+    return;
+  }
+  var detectedLanguage = (0, _languageDetect.detectLanguage)(found.node.textContent);
+  var detectionResult = detectedLanguage ? 'detected' : 'noneDetected';
+  // Keep a previous auto-detected language when the latest snippet is too weak to classify.
+  var shouldPreserveAutoDetectedLanguage = !detectedLanguage && Boolean(entry.autoDetectedLanguage) && found.node.attrs.language === entry.autoDetectedLanguage;
+  var nextEntry = _objectSpread(_objectSpread({}, (0, _autoDetectState2.createAutoDetectEntry)(found.node, found.pos, false, entry)), {}, {
+    detectionResult: detectionResult,
+    autoDetectedLanguage: detectedLanguage !== null && detectedLanguage !== void 0 ? detectedLanguage : entry.autoDetectedLanguage
+  });
+
+  // If there is no confident detection, record the result without clearing user-visible language.
+  var shouldOnlyUpdateDetectionState = !detectedLanguage && (!found.node.attrs.language || shouldPreserveAutoDetectedLanguage);
+  api === null || api === void 0 || (_api$core = api.core) === null || _api$core === void 0 || _api$core.actions.execute(function (_ref) {
+    var _api$analytics;
+    var tr = _ref.tr;
+    if (!shouldOnlyUpdateDetectionState) {
+      tr.setNodeMarkup(found.pos, undefined, _objectSpread(_objectSpread({}, found.node.attrs), {}, {
+        language: detectedLanguage
+      }), found.node.marks);
+    }
+    tr.setMeta(_autoDetectState.autoDetectPluginKey, {
+      type: _actions.ACTIONS.SET_AUTO_DETECT_ENTRY,
+      data: {
+        localId: localId,
+        entry: nextEntry
+      }
+    });
+    api === null || api === void 0 || (_api$analytics = api.analytics) === null || _api$analytics === void 0 || _api$analytics.actions.attachAnalyticsEvent({
+      action: _analytics.ACTION.LANGUAGE_AUTO_DETECTED,
+      actionSubject: _analytics.ACTION_SUBJECT.CODE_BLOCK,
+      attributes: {
+        language: detectedLanguage !== null && detectedLanguage !== void 0 ? detectedLanguage : 'none',
+        detectionResult: detectionResult
+      },
+      eventType: _analytics.EVENT_TYPE.TRACK
+    })(tr);
+    return tr;
+  });
+};
+var clearTimer = function clearTimer(timers, localId) {
+  var scheduledDetection = timers.get(localId);
+  if (scheduledDetection) {
+    clearTimeout(scheduledDetection.timer);
+    timers.delete(localId);
+  }
+};
+
+// Keeps one debounce timer per pending code block and drops timers for stale entries.
+var syncPendingDetectionTimers = exports.syncPendingDetectionTimers = function syncPendingDetectionTimers(view, timers, api) {
+  var _pluginState$language;
+  var pluginState = _autoDetectState.autoDetectPluginKey.getState(view.state);
+  var pendingEntries = Object.entries((_pluginState$language = pluginState === null || pluginState === void 0 ? void 0 : pluginState.languageDetectionMap) !== null && _pluginState$language !== void 0 ? _pluginState$language : {}).filter(function (_ref2) {
+    var _ref3 = (0, _slicedToArray2.default)(_ref2, 2),
+      entry = _ref3[1];
+    return entry.isPending;
+  });
+  var pendingLocalIds = new Set(pendingEntries.map(function (_ref4) {
+    var _ref5 = (0, _slicedToArray2.default)(_ref4, 1),
+      localId = _ref5[0];
+    return localId;
+  }));
+  pendingEntries.forEach(function (_ref6) {
+    var _ref7 = (0, _slicedToArray2.default)(_ref6, 2),
+      localId = _ref7[0],
+      entry = _ref7[1];
+    var scheduledDetection = timers.get(localId);
+    if ((scheduledDetection === null || scheduledDetection === void 0 ? void 0 : scheduledDetection.lastObservedText) === entry.lastObservedText) {
+      return;
+    }
+    clearTimer(timers, localId);
+    var timer = setTimeout(function () {
+      timers.delete(localId);
+      runPendingDetection(view, localId, api);
+    }, AUTO_DETECT_DEBOUNCE_MS);
+    timers.set(localId, {
+      lastObservedText: entry.lastObservedText,
+      timer: timer
+    });
+  });
+  timers.forEach(function (_, localId) {
+    if (!pendingLocalIds.has(localId)) {
+      clearTimer(timers, localId);
+    }
+  });
+};

package/dist/cjs/utils/language-detect.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.detectLanguage = void 0;
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+/* eslint-disable require-unicode-regexp */
+
+// Conservative weighted-regex heuristic for common high-confidence snippets, not a full classifier.
+// Ambiguous snippets intentionally return null so users can select the language manually.
+var MAX_DETECTION_CHARS = 10000;
+var MIN_DETECTION_SCORE = 3; // Require at least one medium-confidence signal before auto-selecting.
+var MIN_SCORE_GAP = 2; // Avoid auto-selecting when top two languages are too close to distinguish.
+
+var hasPattern = function hasPattern(code, pattern) {
+  // Reset stateful regexes so repeated tests always start at the beginning.
+  pattern.lastIndex = 0;
+  return pattern.test(code);
+};
+var scorePatterns = function scorePatterns(code, patterns) {
+  return patterns.reduce(function (score, _ref) {
+    var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+      pattern = _ref2[0],
+      value = _ref2[1];
+    return score + (hasPattern(code, pattern) ? value : 0);
+  }, 0);
+};
+var looksLikeHtmlTagPair = function looksLikeHtmlTagPair(code) {
+  var openTags = new Set();
+  var tagPattern = /<\/?([a-z][a-z0-9-]*)\b[^<>]{0,500}>/gi;
+  var match;
+  while ((match = tagPattern.exec(code)) !== null) {
+    var _match = match,
+      _match2 = (0, _slicedToArray2.default)(_match, 2),
+      tag = _match2[0],
+      tagName = _match2[1];
+    if (tag.endsWith('/>')) {
+      continue;
+    }
+    if (tag.startsWith('</')) {
+      if (openTags.has(tagName.toLowerCase())) {
+        return true;
+      }
+    } else {
+      openTags.add(tagName.toLowerCase());
+    }
+  }
+  return false;
+};
+var looksLikeJson = function looksLikeJson(code) {
+  var trimmed = code.trim();
+  if (!/^[{[]/.test(trimmed) || !/[}\]]$/.test(trimmed)) {
+    return false;
+  }
+  try {
+    var parsed = JSON.parse(trimmed);
+    return parsed !== null && (0, _typeof2.default)(parsed) === 'object';
+  } catch (_unused) {
+    return false;
+  }
+};
+var getLanguageScores = function getLanguageScores(code) {
+  return [{
+    language: 'json',
+    score: looksLikeJson(code) ? 8 : 0
+  }, {
+    language: 'html',
+    score: scorePatterns(code, [[/<!doctype\s+html/i, 5], [/<\/?(?:html|head|body|div|span|script|style|section|template)\b/i, 2]]) + (looksLikeHtmlTagPair(code) ? 3 : 0)
+  }, {
+    language: 'css',
+    score: scorePatterns(code, [[/@[\w-]+\s+[^{]+\{/, 3], [/[.#]?[-_a-zA-Z][-_a-zA-Z0-9\s,.:#>+~*\[\]='"]+\{[^}]*\b(?:color|display|margin|padding|font|background|border|width|height|grid|flex)\s*:/, 5], [/\b(?:color|display|margin|padding|font-size|background|border|width|height)\s*:\s*[^;{}]+;/, 3]])
+  }, {
+    language: 'sql',
+    score: scorePatterns(code, [[/\bSELECT\b[\s\S]+\bFROM\b/i, 5], [/\b(?:INSERT\s+INTO|UPDATE\b[\s\S]+\bSET\b|DELETE\s+FROM|CREATE\s+TABLE|ALTER\s+TABLE)\b/i, 5], [/\b(?:JOIN|WHERE|GROUP\s+BY|ORDER\s+BY|LIMIT)\b/i, 2]])
+  }, {
+    language: 'typescript',
+    score: scorePatterns(code, [[/\b(?:interface|type)\s+[A-Z_$][\w$]*(?:\s*[=<{])/, 5], [/\bimport\s+type\b|\bexport\s+type\b/, 4], [/\b(?:const|let|var)\s+[\w$]+\s*:\s*[A-Za-z_$][\w$<>|\[\],\s]*/, 4], [/\)\s*:\s*(?:Promise<)?[A-Za-z_$][\w$<>|\[\],\s]*(?:>|\s)?\s*=>?\s*[{;]/, 3], [/\b(?:as\s+const|implements\s+[A-Z_$]|enum\s+[A-Z_$])/, 3]])
+  }, {
+    language: 'javascript',
+    score: scorePatterns(code, [[/\b(?:const|let|var)\s+[\w$]+\s*=/, 3], [/\bfunction\s*[\w$]*\s*\([^)]*\)\s*\{/, 3], [/=>\s*(?:\{|[\w$'"`(])/, 3], [/\b(?:import|export)\s+(?:[\w${}*,\s]+\s+from\s+)?['"][^'"]+['"]/, 3], [/\b(?:console\.log|document\.|window\.|require\()|\bmodule\.exports\b/, 3]])
+  }, {
+    language: 'python',
+    score: scorePatterns(code, [[/^\s*def\s+[a-zA-Z_]\w*\([^)]*\)\s*:/m, 5], [/^\s*class\s+[A-Z_]\w*(?:\([^)]*\))?\s*:/m, 4], [/^\s*(?:from\s+[\w.]+\s+import\s+\w+|import\s+[\w.]+)/m, 3], [/^\s*(?:if|elif|else|for|while|try|except)\b[^\n]*:\s*$/m, 2], [/\bprint\([^)]*\)/, 2]])
+  }, {
+    language: 'java',
+    score: scorePatterns(code, [[/\bpublic\s+(?:final\s+)?class\s+[A-Z]\w*/, 5], [/\bpublic\s+static\s+void\s+main\s*\(\s*String\[\]/, 5], [/\bSystem\.out\.println\s*\(/, 4], [/\b(?:private|protected|public)\s+(?:static\s+)?(?:final\s+)?[A-Z]\w*(?:<[^>]+>)?\s+\w+\s*[;(=]/, 3]])
+  }, {
+    language: 'go',
+    score: scorePatterns(code, [[/^\s*package\s+\w+/m, 5], [/\bfunc\s+(?:\([^)]*\)\s*)?[A-Za-z_]\w*\s*\([^)]*\)\s*(?:[A-Za-z_*\[\]]+\s*)?\{/, 5], [/\bfmt\.(?:Println|Printf)\s*\(/, 3], [/\bimport\s+\(\s*[\s\S]*?\)/, 2]])
+  }, {
+    language: 'ruby',
+    score: scorePatterns(code, [[/^\s*def\s+[a-z_]\w*[!?=]?/m, 4], [/^\s*class\s+[A-Z]\w*(?:\s*<\s*[A-Z]\w*)?/m, 3], [/^\s*end\s*$/m, 3], [/\b(?:puts|require|attr_reader|attr_accessor)\b/, 3], [/\bdo\s*\|[^|]+\|/, 2]])
+  }, {
+    language: 'rust',
+    score: scorePatterns(code, [[/\bfn\s+[a-z_]\w*\s*\([^)]*\)\s*(?:->\s*[A-Za-z_:<>]+\s*)?\{/, 5], [/\blet\s+mut\s+\w+/, 3], [/\bprintln!\s*\(/, 4], [/\buse\s+(?:std|crate|super)::/, 3], [/\b(?:impl|pub\s+struct|enum)\s+[A-Z]\w*/, 3]])
+  }, {
+    language: 'shell',
+    score: scorePatterns(code, [[/^#!\/usr\/bin\/(?:env\s+)?(?:ba|z|k)?sh\b/m, 6], [/^\s*(?:if|for|while)\b[\s\S]+\b(?:then|do)\b/m, 4], [/^\s*(?:fi|done)\s*$/m, 3], [/\b(?:echo|export|cd|grep|sed|awk|curl)\b[\s\S]*(?:\$\w+|&&|\|)/, 3], [/\$\{?[A-Z_][A-Z0-9_]*\}?/, 2]])
+  }];
+};
+var detectLanguage = exports.detectLanguage = function detectLanguage(code) {
+  var trimmedCode = code.trim();
+  if (trimmedCode.length < 8) {
+    return null;
+  }
+  var codeForDetection = trimmedCode.slice(0, MAX_DETECTION_CHARS);
+  var _getLanguageScores$fi = getLanguageScores(codeForDetection).filter(function (_ref3) {
+      var score = _ref3.score;
+      return score > 0;
+    }).sort(function (a, b) {
+      return b.score - a.score;
+    }),
+    _getLanguageScores$fi2 = (0, _slicedToArray2.default)(_getLanguageScores$fi, 2),
+    best = _getLanguageScores$fi2[0],
+    secondBest = _getLanguageScores$fi2[1];
+  if (!best || best.score < MIN_DETECTION_SCORE) {
+    return null;
+  }
+  if (secondBest && best.score - secondBest.score < MIN_SCORE_GAP) {
+    return null;
+  }
+  return best.language;
+};

package/dist/es2019/codeBlockPlugin.js

@@ -8,6 +8,7 @@ import { fg } from '@atlaskit/platform-feature-flags';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { editorExperiment } from '@atlaskit/tmp-editor-statsig/experiments';
 import { createInsertCodeBlockTransaction, insertCodeBlockWithAnalytics } from './editor-commands';
+import { createAutoDetectPlugin } from './pm-plugins/auto-detect';
 import { codeBlockAutoFullStopTransformPlugin } from './pm-plugins/codeBlockAutoFullStopTransformPlugin';
 import { codeBlockCopySelectionPlugin, copySelectionPluginKey } from './pm-plugins/codeBlockCopySelectionPlugin';
 import ideUX from './pm-plugins/ide-ux';
@@ -73,7 +74,10 @@ const codeBlockPlugin = ({
           var _api$analytics;
           return createCodeBlockInputRule(schema, api === null || api === void 0 ? void 0 : (_api$analytics = api.analytics) === null || _api$analytics === void 0 ? void 0 : _api$analytics.actions);
         }
-      }, {
+      }, ...(expValEquals('platform_editor_code_block_auto_detection', 'isEnabled', true) ? [{
+        name: 'codeBlockAutoDetect',
+        plugin: () => createAutoDetectPlugin(api)
+      }] : []), {
         name: 'codeBlockIDEKeyBindings',
         plugin: () => ideUX(api)
       }, {

package/dist/es2019/editor-commands/index.js

@@ -9,9 +9,11 @@ import { NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { findParentNodeOfType, findSelectedNodeOfType, isNodeSelection, removeParentNodeOfType, removeSelectedNode, safeInsert } from '@atlaskit/editor-prosemirror/utils';
 import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
 import { ACTIONS } from '../pm-plugins/actions';
+import { autoDetectPluginKey } from '../pm-plugins/auto-detect-state';
 import { copySelectionPluginKey } from '../pm-plugins/codeBlockCopySelectionPlugin';
 import { pluginKey } from '../pm-plugins/plugin-key';
 import { transformToCodeBlockAction } from '../pm-plugins/transform-to-code-block';
+import { createAutoDetectEntry, getLocalId, hasEnoughTextForAutoDetection } from '../utils/auto-detect-state';
 export const removeCodeBlockWithAnalytics = editorAnalyticsAPI => {
   return withAnalytics(editorAnalyticsAPI, {
     action: ACTION.DELETED,
@@ -41,7 +43,7 @@ export const removeCodeBlock = (state, dispatch) => {
   return true;
 };
 export const changeLanguage = editorAnalyticsAPI => (language, selectionSource) => (state, dispatch) => {
-  var _pluginKey$getState;
+  var _pluginKey$getState, _autoDetectPluginKey$;
   const {
     codeBlock
   } = state.schema.nodes;
@@ -50,10 +52,20 @@ export const changeLanguage = editorAnalyticsAPI => (language, selectionSource)
     return false;
   }
   const node = state.doc.nodeAt(pos);
+  const localId = node === null || node === void 0 ? void 0 : node.attrs.localId;
+  const previousAutoDetectEntry = expValEquals('platform_editor_code_block_auto_detection', 'isEnabled', true) ? (_autoDetectPluginKey$ = autoDetectPluginKey.getState(state)) === null || _autoDetectPluginKey$ === void 0 ? void 0 : _autoDetectPluginKey$.languageDetectionMap[localId] : undefined;
   const tr = state.tr.setNodeMarkup(pos, codeBlock, {
     ...(node === null || node === void 0 ? void 0 : node.attrs),
     language
   }).setMeta('scrollIntoView', false);
+  if (expValEquals('platform_editor_code_block_auto_detection', 'isEnabled', true)) {
+    tr.setMeta(autoDetectPluginKey, {
+      type: ACTIONS.REMOVE_AUTO_DETECT_ENTRY,
+      data: {
+        localId
+      }
+    });
+  }
   const selection = isNodeSelection(state.selection) ? NodeSelection.create(tr.doc, pos) : tr.selection;
   const result = tr.setSelection(selection);
   if (dispatch) {
@@ -64,7 +76,9 @@ export const changeLanguage = editorAnalyticsAPI => (language, selectionSource)
         language: language !== null && language !== void 0 ? language : 'none',
         ...(selectionSource ? {
           selectionSource
-        } : {})
+        } : {}),
+        autoDetectionResult: previousAutoDetectEntry === null || previousAutoDetectEntry === void 0 ? void 0 : previousAutoDetectEntry.detectionResult,
+        autoDetectedLanguage: previousAutoDetectEntry === null || previousAutoDetectEntry === void 0 ? void 0 : previousAutoDetectEntry.autoDetectedLanguage
       },
       eventType: EVENT_TYPE.TRACK
     })(result);
@@ -72,6 +86,42 @@ export const changeLanguage = editorAnalyticsAPI => (language, selectionSource)
   }
   return true;
 };
+
+/** Queue auto-detection for selected code block. */
+export const detectLanguage = () => (state, dispatch) => {
+  var _pluginKey$getState2;
+  const pos = (_pluginKey$getState2 = pluginKey.getState(state)) === null || _pluginKey$getState2 === void 0 ? void 0 : _pluginKey$getState2.pos;
+  if (typeof pos !== 'number') {
+    return false;
+  }
+  const node = state.doc.nodeAt(pos);
+  if (!node) {
+    return false;
+  }
+  const localId = getLocalId(node);
+  if (!localId) {
+    return false;
+  }
+  const autoDetectState = autoDetectPluginKey.getState(state);
+  const previousEntry = autoDetectState === null || autoDetectState === void 0 ? void 0 : autoDetectState.languageDetectionMap[localId];
+  const entry = createAutoDetectEntry(node, pos, hasEnoughTextForAutoDetection(node.textContent), previousEntry);
+  const tr = state.tr.setNodeMarkup(pos, state.schema.nodes.codeBlock, {
+    ...node.attrs,
+    language: null
+  }).setMeta(autoDetectPluginKey, {
+    type: ACTIONS.SET_AUTO_DETECT_ENTRY,
+    data: {
+      localId,
+      entry
+    }
+  }).setMeta('scrollIntoView', false);
+  const selection = isNodeSelection(state.selection) ? NodeSelection.create(tr.doc, pos) : tr.selection;
+  const result = tr.setSelection(selection);
+  if (dispatch) {
+    dispatch(result);
+  }
+  return true;
+};
 export const copyContentToClipboardWithAnalytics = editorAnalyticsAPI => (state, dispatch) => {
   const {
     schema: {

package/dist/es2019/pm-plugins/actions.js

@@ -1,5 +1,7 @@
 export const ACTIONS = {
   SET_COPIED_TO_CLIPBOARD: 'SET_COPIED_TO_CLIPBOARD',
   SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS: 'SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS',
-  SET_IS_WRAPPED: 'SET_IS_WRAPPED'
+  SET_IS_WRAPPED: 'SET_IS_WRAPPED',
+  SET_AUTO_DETECT_ENTRY: 'SET_AUTO_DETECT_ENTRY',
+  REMOVE_AUTO_DETECT_ENTRY: 'REMOVE_AUTO_DETECT_ENTRY'
 };

package/dist/es2019/pm-plugins/auto-detect-state.js

@@ -0,0 +1,3 @@
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export const autoDetectPluginKey = new PluginKey('codeBlockAutoDetectPlugin');
+export const getAutoDetectPluginState = state => autoDetectPluginKey.getState(state);

package/dist/es2019/pm-plugins/auto-detect.js

@@ -0,0 +1,47 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { removeAutoDetection, updateAutoDetectState } from '../utils/auto-detect-state';
+import { syncPendingDetectionTimers } from '../utils/auto-detect-view';
+import { ACTIONS } from './actions';
+import { autoDetectPluginKey } from './auto-detect-state';
+export const createAutoDetectPlugin = api => new SafePlugin({
+  key: autoDetectPluginKey,
+  state: {
+    init() {
+      return {
+        languageDetectionMap: {}
+      };
+    },
+    apply(tr, pluginState) {
+      const meta = tr.getMeta(autoDetectPluginKey);
+      let languageDetectionMap = tr.docChanged ? updateAutoDetectState(tr, pluginState) : pluginState.languageDetectionMap;
+      if ((meta === null || meta === void 0 ? void 0 : meta.type) === ACTIONS.SET_AUTO_DETECT_ENTRY) {
+        languageDetectionMap = {
+          ...languageDetectionMap,
+          [meta.data.localId]: meta.data.entry
+        };
+      } else if ((meta === null || meta === void 0 ? void 0 : meta.type) === ACTIONS.REMOVE_AUTO_DETECT_ENTRY) {
+        languageDetectionMap = removeAutoDetection(languageDetectionMap, meta.data.localId);
+      }
+      if (languageDetectionMap === pluginState.languageDetectionMap) {
+        return pluginState;
+      }
+      return {
+        languageDetectionMap
+      };
+    }
+  },
+  view(view) {
+    const timers = new Map();
+    return {
+      update() {
+        syncPendingDetectionTimers(view, timers, api);
+      },
+      destroy() {
+        timers.forEach(({
+          timer
+        }) => clearTimeout(timer));
+        timers.clear();
+      }
+    };
+  }
+});

package/dist/es2019/pm-plugins/main.js

@@ -97,11 +97,11 @@ export const createPlugin = ({
         }
         if (tr.docChanged) {
           const node = findCodeBlock(newState, tr.selection);
+          const codeBlockNodes = getAllChangedCodeBlocksInTransaction(tr);
 
           // Updates mapping position of all existing decorations to new positions
           // specifically used for updating word wrap node decorators (does not cover drag & drop, validateWordWrappedDecorators does).
           let updatedDecorationSet = pluginState.decorations.map(tr.mapping, tr.doc);
-          const codeBlockNodes = getAllChangedCodeBlocksInTransaction(tr);
           if (codeBlockNodes) {
             updateCodeBlockWrappedStateNodeKeys(codeBlockNodes, _oldState);
             // Disabled when using advanced code block for performance reasons