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

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

@@ -0,0 +1,120 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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) { _defineProperty(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; }
+import { ACTION, ACTION_SUBJECT, EVENT_TYPE } from '@atlaskit/editor-common/analytics';
+import { ACTIONS } from '../pm-plugins/actions';
+import { autoDetectPluginKey } from '../pm-plugins/auto-detect-state';
+import { createAutoDetectEntry } from './auto-detect-state';
+import { detectLanguage } from './language-detect';
+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 = 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 = 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({}, 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(autoDetectPluginKey, {
+      type: 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: ACTION.LANGUAGE_AUTO_DETECTED,
+      actionSubject: ACTION_SUBJECT.CODE_BLOCK,
+      attributes: {
+        language: detectedLanguage !== null && detectedLanguage !== void 0 ? detectedLanguage : 'none',
+        detectionResult: detectionResult
+      },
+      eventType: 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.
+export var syncPendingDetectionTimers = function syncPendingDetectionTimers(view, timers, api) {
+  var _pluginState$language;
+  var pluginState = 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 = _slicedToArray(_ref2, 2),
+      entry = _ref3[1];
+    return entry.isPending;
+  });
+  var pendingLocalIds = new Set(pendingEntries.map(function (_ref4) {
+    var _ref5 = _slicedToArray(_ref4, 1),
+      localId = _ref5[0];
+    return localId;
+  }));
+  pendingEntries.forEach(function (_ref6) {
+    var _ref7 = _slicedToArray(_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/esm/utils/language-detect.js

@@ -0,0 +1,119 @@
+import _typeof from "@babel/runtime/helpers/typeof";
+import _slicedToArray from "@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 = _slicedToArray(_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 = _slicedToArray(_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 && _typeof(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]])
+  }];
+};
+export var 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 = _slicedToArray(_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/types/editor-commands/index.d.ts

@@ -6,6 +6,8 @@ import type { LanguagePickerSelectionSource } from '../ui/language-picker-option
 export declare const removeCodeBlockWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
 export declare const removeCodeBlock: Command;
 export declare const changeLanguage: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (language: string | null, selectionSource?: LanguagePickerSelectionSource) => Command;
+/** Queue auto-detection for selected code block. */
+export declare const detectLanguage: () => Command;
 export declare const copyContentToClipboardWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
 export declare const copyContentToClipboard: Command;
 export declare const resetCopiedState: Command;

package/dist/types/pm-plugins/actions.d.ts

@@ -2,4 +2,6 @@ export declare const ACTIONS: {
     SET_COPIED_TO_CLIPBOARD: string;
     SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS: string;
     SET_IS_WRAPPED: string;
+    SET_AUTO_DETECT_ENTRY: string;
+    REMOVE_AUTO_DETECT_ENTRY: string;
 };

package/dist/types/pm-plugins/auto-detect-state.d.ts

@@ -0,0 +1,16 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export type AutoDetectResult = 'detected' | 'noneDetected';
+export type AutoDetectEntry = {
+    autoDetectedLanguage?: string;
+    detectionResult?: AutoDetectResult;
+    isPending?: boolean;
+    lastObservedFirstLine: string;
+    lastObservedText: string;
+    pos: number;
+};
+export type AutoDetectState = {
+    languageDetectionMap: Record<string, AutoDetectEntry>;
+};
+export declare const autoDetectPluginKey: PluginKey<AutoDetectState>;
+export declare const getAutoDetectPluginState: (state: EditorState) => AutoDetectState | undefined;

package/dist/types/pm-plugins/auto-detect.d.ts

@@ -0,0 +1,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { CodeBlockPlugin } from '../index';
+import { type AutoDetectState } from './auto-detect-state';
+export declare const createAutoDetectPlugin: (api?: ExtractInjectionAPI<CodeBlockPlugin>) => SafePlugin<AutoDetectState>;

package/dist/types/pm-plugins/utils.d.ts

@@ -3,4 +3,4 @@ import type { EditorState, ReadonlyTransaction, Selection } from '@atlaskit/edit
 import type { NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
 export declare function getCursor(selection: Selection): ResolvedPos | undefined;
 export declare function getAllCodeBlockNodesInDoc(state: EditorState): NodeWithPos[];
-export declare function getAllChangedCodeBlocksInTransaction(tr: ReadonlyTransaction): NodeWithPos[] | null;
+export declare function getAllChangedCodeBlocksInTransaction(tr: ReadonlyTransaction): NodeWithPos[];

package/dist/types/ui/CodeBlockLanguagePicker.d.ts

@@ -1,5 +1,11 @@
 import React from 'react';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CodeBlockPlugin } from '../index';
 import type { LanguagePickerProps } from './LanguagePicker';
-type CodeBlockLanguagePickerProps = Omit<LanguagePickerProps, 'recentLanguageValues' | 'onLanguageSelect' | 'onMenuOpen'>;
+type CodeBlockLanguagePickerProps = Omit<LanguagePickerProps, 'recentLanguageValues' | 'onMenuOpen' | 'onSelection'> & {
+    api: ExtractInjectionAPI<CodeBlockPlugin> | undefined;
+    editorView: EditorView;
+};
 export declare const CodeBlockLanguagePicker: ({ api, defaultValue, editorView, filterOption, formatMessage, languagePickerOptions, }: CodeBlockLanguagePickerProps) => React.JSX.Element;
 export {};

package/dist/types/ui/LanguagePicker.d.ts

@@ -4,19 +4,15 @@
  */
 import React from 'react';
 import type { IntlShape } from 'react-intl';
-import type { ExtractInjectionAPI, SelectOption } from '@atlaskit/editor-common/types';
-import type { EditorView } from '@atlaskit/editor-prosemirror/view';
-import type { CodeBlockPlugin } from '../index';
-import type { LanguagePickerOption } from './language-picker-options';
+import type { SelectOption } from '@atlaskit/editor-common/types';
+import { type LanguagePickerOption, type LanguagePickerSelectionSource } from './language-picker-options';
 export type LanguagePickerProps = {
-    api: ExtractInjectionAPI<CodeBlockPlugin> | undefined;
     defaultValue?: LanguagePickerOption;
-    editorView: EditorView;
     filterOption: (option: SelectOption<LanguagePickerOption>, rawInput: string) => boolean;
     formatMessage: IntlShape['formatMessage'];
     languagePickerOptions: LanguagePickerOption[];
-    onLanguageSelect?: (language: string) => void;
     onMenuOpen?: () => void;
+    onSelection: (option: LanguagePickerOption, selectionSource: LanguagePickerSelectionSource) => void;
     recentLanguageValues?: string[];
 };
-export declare const LanguagePicker: ({ api, defaultValue, editorView, filterOption, formatMessage, languagePickerOptions, recentLanguageValues, onLanguageSelect, onMenuOpen, }: LanguagePickerProps) => React.JSX.Element;
+export declare const LanguagePicker: ({ defaultValue, filterOption, formatMessage, languagePickerOptions, recentLanguageValues, onMenuOpen, onSelection, }: LanguagePickerProps) => React.JSX.Element;

package/dist/types/utils/auto-detect-state.d.ts

@@ -0,0 +1,11 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
+import type { AutoDetectEntry, AutoDetectState } from '../pm-plugins/auto-detect-state';
+export declare const shouldTriggerLargeChangeDetection: (lastObservedText: string, text: string) => boolean;
+export declare const getFirstLine: (text: string) => string;
+export declare const hasEnoughTextForAutoDetection: (text: string) => boolean;
+export declare const getLocalId: (node: PMNode) => string | null;
+export declare const createAutoDetectEntry: (node: PMNode, pos: number, isPending: boolean, previous?: AutoDetectEntry) => AutoDetectEntry;
+export declare const queueAutoDetection: (languageDetectionMap: AutoDetectState["languageDetectionMap"], node: PMNode, pos: number, isPending: boolean) => AutoDetectState["languageDetectionMap"];
+export declare const removeAutoDetection: (languageDetectionMap: AutoDetectState["languageDetectionMap"], localId: string) => AutoDetectState["languageDetectionMap"];
+export declare const updateAutoDetectState: (tr: ReadonlyTransaction, pluginState: AutoDetectState) => AutoDetectState["languageDetectionMap"];

package/dist/types/utils/auto-detect-view.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CodeBlockPlugin } from '../index';
+export type AutoDetectTimer = {
+    lastObservedText: string;
+    timer: ReturnType<typeof setTimeout>;
+};
+export declare const syncPendingDetectionTimers: (view: EditorView, timers: Map<string, AutoDetectTimer>, api?: ExtractInjectionAPI<CodeBlockPlugin>) => void;

package/dist/types/utils/language-detect.d.ts

@@ -0,0 +1,3 @@
+type LanguageId = 'css' | 'go' | 'html' | 'java' | 'javascript' | 'json' | 'python' | 'ruby' | 'rust' | 'shell' | 'sql' | 'typescript';
+export declare const detectLanguage: (code: string) => LanguageId | null;
+export {};

package/dist/types-ts4.5/editor-commands/index.d.ts

@@ -6,6 +6,8 @@ import type { LanguagePickerSelectionSource } from '../ui/language-picker-option
 export declare const removeCodeBlockWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
 export declare const removeCodeBlock: Command;
 export declare const changeLanguage: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => (language: string | null, selectionSource?: LanguagePickerSelectionSource) => Command;
+/** Queue auto-detection for selected code block. */
+export declare const detectLanguage: () => Command;
 export declare const copyContentToClipboardWithAnalytics: (editorAnalyticsAPI: EditorAnalyticsAPI | undefined) => Command;
 export declare const copyContentToClipboard: Command;
 export declare const resetCopiedState: Command;

package/dist/types-ts4.5/pm-plugins/actions.d.ts

@@ -2,4 +2,6 @@ export declare const ACTIONS: {
     SET_COPIED_TO_CLIPBOARD: string;
     SET_SHOULD_IGNORE_FOLLOWING_MUTATIONS: string;
     SET_IS_WRAPPED: string;
+    SET_AUTO_DETECT_ENTRY: string;
+    REMOVE_AUTO_DETECT_ENTRY: string;
 };

package/dist/types-ts4.5/pm-plugins/auto-detect-state.d.ts

@@ -0,0 +1,16 @@
+import type { EditorState } from '@atlaskit/editor-prosemirror/state';
+import { PluginKey } from '@atlaskit/editor-prosemirror/state';
+export type AutoDetectResult = 'detected' | 'noneDetected';
+export type AutoDetectEntry = {
+    autoDetectedLanguage?: string;
+    detectionResult?: AutoDetectResult;
+    isPending?: boolean;
+    lastObservedFirstLine: string;
+    lastObservedText: string;
+    pos: number;
+};
+export type AutoDetectState = {
+    languageDetectionMap: Record<string, AutoDetectEntry>;
+};
+export declare const autoDetectPluginKey: PluginKey<AutoDetectState>;
+export declare const getAutoDetectPluginState: (state: EditorState) => AutoDetectState | undefined;

package/dist/types-ts4.5/pm-plugins/auto-detect.d.ts

@@ -0,0 +1,5 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { CodeBlockPlugin } from '../index';
+import { type AutoDetectState } from './auto-detect-state';
+export declare const createAutoDetectPlugin: (api?: ExtractInjectionAPI<CodeBlockPlugin>) => SafePlugin<AutoDetectState>;

package/dist/types-ts4.5/pm-plugins/utils.d.ts

@@ -3,4 +3,4 @@ import type { EditorState, ReadonlyTransaction, Selection } from '@atlaskit/edit
 import type { NodeWithPos } from '@atlaskit/editor-prosemirror/utils';
 export declare function getCursor(selection: Selection): ResolvedPos | undefined;
 export declare function getAllCodeBlockNodesInDoc(state: EditorState): NodeWithPos[];
-export declare function getAllChangedCodeBlocksInTransaction(tr: ReadonlyTransaction): NodeWithPos[] | null;
+export declare function getAllChangedCodeBlocksInTransaction(tr: ReadonlyTransaction): NodeWithPos[];

package/dist/types-ts4.5/ui/CodeBlockLanguagePicker.d.ts

@@ -1,5 +1,11 @@
 import React from 'react';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CodeBlockPlugin } from '../index';
 import type { LanguagePickerProps } from './LanguagePicker';
-type CodeBlockLanguagePickerProps = Omit<LanguagePickerProps, 'recentLanguageValues' | 'onLanguageSelect' | 'onMenuOpen'>;
+type CodeBlockLanguagePickerProps = Omit<LanguagePickerProps, 'recentLanguageValues' | 'onMenuOpen' | 'onSelection'> & {
+    api: ExtractInjectionAPI<CodeBlockPlugin> | undefined;
+    editorView: EditorView;
+};
 export declare const CodeBlockLanguagePicker: ({ api, defaultValue, editorView, filterOption, formatMessage, languagePickerOptions, }: CodeBlockLanguagePickerProps) => React.JSX.Element;
 export {};

package/dist/types-ts4.5/ui/LanguagePicker.d.ts

@@ -4,19 +4,15 @@
  */
 import React from 'react';
 import type { IntlShape } from 'react-intl';
-import type { ExtractInjectionAPI, SelectOption } from '@atlaskit/editor-common/types';
-import type { EditorView } from '@atlaskit/editor-prosemirror/view';
-import type { CodeBlockPlugin } from '../index';
-import type { LanguagePickerOption } from './language-picker-options';
+import type { SelectOption } from '@atlaskit/editor-common/types';
+import { type LanguagePickerOption, type LanguagePickerSelectionSource } from './language-picker-options';
 export type LanguagePickerProps = {
-    api: ExtractInjectionAPI<CodeBlockPlugin> | undefined;
     defaultValue?: LanguagePickerOption;
-    editorView: EditorView;
     filterOption: (option: SelectOption<LanguagePickerOption>, rawInput: string) => boolean;
     formatMessage: IntlShape['formatMessage'];
     languagePickerOptions: LanguagePickerOption[];
-    onLanguageSelect?: (language: string) => void;
     onMenuOpen?: () => void;
+    onSelection: (option: LanguagePickerOption, selectionSource: LanguagePickerSelectionSource) => void;
     recentLanguageValues?: string[];
 };
-export declare const LanguagePicker: ({ api, defaultValue, editorView, filterOption, formatMessage, languagePickerOptions, recentLanguageValues, onLanguageSelect, onMenuOpen, }: LanguagePickerProps) => React.JSX.Element;
+export declare const LanguagePicker: ({ defaultValue, filterOption, formatMessage, languagePickerOptions, recentLanguageValues, onMenuOpen, onSelection, }: LanguagePickerProps) => React.JSX.Element;

package/dist/types-ts4.5/utils/auto-detect-state.d.ts

@@ -0,0 +1,11 @@
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { ReadonlyTransaction } from '@atlaskit/editor-prosemirror/state';
+import type { AutoDetectEntry, AutoDetectState } from '../pm-plugins/auto-detect-state';
+export declare const shouldTriggerLargeChangeDetection: (lastObservedText: string, text: string) => boolean;
+export declare const getFirstLine: (text: string) => string;
+export declare const hasEnoughTextForAutoDetection: (text: string) => boolean;
+export declare const getLocalId: (node: PMNode) => string | null;
+export declare const createAutoDetectEntry: (node: PMNode, pos: number, isPending: boolean, previous?: AutoDetectEntry) => AutoDetectEntry;
+export declare const queueAutoDetection: (languageDetectionMap: AutoDetectState["languageDetectionMap"], node: PMNode, pos: number, isPending: boolean) => AutoDetectState["languageDetectionMap"];
+export declare const removeAutoDetection: (languageDetectionMap: AutoDetectState["languageDetectionMap"], localId: string) => AutoDetectState["languageDetectionMap"];
+export declare const updateAutoDetectState: (tr: ReadonlyTransaction, pluginState: AutoDetectState) => AutoDetectState["languageDetectionMap"];

package/dist/types-ts4.5/utils/auto-detect-view.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { EditorView } from '@atlaskit/editor-prosemirror/view';
+import type { CodeBlockPlugin } from '../index';
+export type AutoDetectTimer = {
+    lastObservedText: string;
+    timer: ReturnType<typeof setTimeout>;
+};
+export declare const syncPendingDetectionTimers: (view: EditorView, timers: Map<string, AutoDetectTimer>, api?: ExtractInjectionAPI<CodeBlockPlugin>) => void;

package/dist/types-ts4.5/utils/language-detect.d.ts

@@ -0,0 +1,3 @@
+type LanguageId = 'css' | 'go' | 'html' | 'java' | 'javascript' | 'json' | 'python' | 'ruby' | 'rust' | 'shell' | 'sql' | 'typescript';
+export declare const detectLanguage: (code: string) => LanguageId | null;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/editor-plugin-code-block",
-	"version": "12.1.10",
+	"version": "12.1.11",
 	"description": "Code block plugin for @atlaskit/editor-core",
 	"author": "Atlassian Pty Ltd",
 	"license": "Apache-2.0",
@@ -49,13 +49,13 @@
 		"@atlaskit/primitives": "^19.0.0",
 		"@atlaskit/prosemirror-input-rules": "^3.7.0",
 		"@atlaskit/select": "^21.12.0",
-		"@atlaskit/tmp-editor-statsig": "^86.0.0",
+		"@atlaskit/tmp-editor-statsig": "^87.0.0",
 		"@atlaskit/tokens": "^13.1.0",
 		"@babel/runtime": "^7.0.0",
 		"@compiled/react": "^0.20.0"
 	},
 	"peerDependencies": {
-		"@atlaskit/editor-common": "^114.54.0",
+		"@atlaskit/editor-common": "^114.55.0",
 		"react": "^18.2.0",
 		"react-intl": "^5.25.1 || ^6.0.0 || ^7.0.0"
 	},