@atlaskit/editor-plugin-code-block-advanced 1.0.0

package/dist/esm/nodeviews/extensions/keymap/index.js

@@ -0,0 +1,122 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import { defaultKeymap, indentWithTab } from '@codemirror/commands';
+import { keymap as cmKeymap } from '@codemirror/view';
+import { exitCode } from '@atlaskit/editor-prosemirror/commands';
+import { undo, redo } from '@atlaskit/editor-prosemirror/history';
+import { backspaceKeymap } from './backspace';
+import { maybeEscapeKeymap } from './maybeEscape';
+export var keymapExtension = function keymapExtension(_ref) {
+  var view = _ref.view,
+    getNode = _ref.getNode,
+    getPos = _ref.getPos,
+    selectCodeBlockNode = _ref.selectCodeBlockNode,
+    onMaybeNodeSelection = _ref.onMaybeNodeSelection;
+  return cmKeymap.of(codeBlockKeymap({
+    view: view,
+    getNode: getNode,
+    getPos: getPos,
+    selectCodeBlockNode: selectCodeBlockNode,
+    onMaybeNodeSelection: onMaybeNodeSelection
+  }));
+};
+var codeBlockKeymap = function codeBlockKeymap(_ref2) {
+  var view = _ref2.view,
+    getNode = _ref2.getNode,
+    getPos = _ref2.getPos,
+    selectCodeBlockNode = _ref2.selectCodeBlockNode,
+    onMaybeNodeSelection = _ref2.onMaybeNodeSelection;
+  return [{
+    key: 'ArrowUp',
+    run: function run(cm) {
+      return maybeEscapeKeymap({
+        unit: 'line',
+        dir: -1,
+        cm: cm,
+        view: view,
+        getNode: getNode,
+        getPos: getPos,
+        selectCodeBlockNode: selectCodeBlockNode,
+        onMaybeNodeSelection: onMaybeNodeSelection
+      });
+    }
+  }, {
+    key: 'ArrowLeft',
+    run: function run(cm) {
+      return maybeEscapeKeymap({
+        unit: 'char',
+        dir: -1,
+        cm: cm,
+        view: view,
+        getNode: getNode,
+        getPos: getPos,
+        selectCodeBlockNode: selectCodeBlockNode,
+        onMaybeNodeSelection: onMaybeNodeSelection
+      });
+    }
+  }, {
+    key: 'ArrowDown',
+    run: function run(cm) {
+      return maybeEscapeKeymap({
+        unit: 'line',
+        dir: 1,
+        cm: cm,
+        view: view,
+        getNode: getNode,
+        getPos: getPos,
+        selectCodeBlockNode: selectCodeBlockNode,
+        onMaybeNodeSelection: onMaybeNodeSelection
+      });
+    }
+  }, {
+    key: 'ArrowRight',
+    run: function run(cm) {
+      return maybeEscapeKeymap({
+        unit: 'char',
+        dir: 1,
+        cm: cm,
+        view: view,
+        getNode: getNode,
+        getPos: getPos,
+        selectCodeBlockNode: selectCodeBlockNode,
+        onMaybeNodeSelection: onMaybeNodeSelection
+      });
+    }
+  }, {
+    key: 'Ctrl-Enter',
+    run: function run() {
+      if (!exitCode(view.state, view.dispatch)) {
+        return false;
+      }
+      view.focus();
+      return true;
+    }
+  }, {
+    key: 'Ctrl-z',
+    mac: 'Cmd-z',
+    run: function run() {
+      return undo(view.state, view.dispatch);
+    }
+  }, {
+    key: 'Shift-Ctrl-z',
+    mac: 'Shift-Cmd-z',
+    run: function run() {
+      return redo(view.state, view.dispatch);
+    }
+  }, {
+    key: 'Ctrl-y',
+    mac: 'Cmd-y',
+    run: function run() {
+      return redo(view.state, view.dispatch);
+    }
+  }, {
+    key: 'Backspace',
+    run: function run(cm) {
+      return backspaceKeymap({
+        cm: cm,
+        view: view,
+        getNode: getNode,
+        getPos: getPos
+      });
+    }
+  }].concat(_toConsumableArray(defaultKeymap.concat(indentWithTab)));
+};

package/dist/esm/nodeviews/extensions/keymap/maybeEscape.js

@@ -0,0 +1,56 @@
+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 { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import { Selection } from '@atlaskit/editor-prosemirror/state';
+export var maybeEscapeKeymap = function maybeEscapeKeymap(_ref) {
+  var _getPos;
+  var unit = _ref.unit,
+    dir = _ref.dir,
+    view = _ref.view,
+    cm = _ref.cm,
+    getPos = _ref.getPos,
+    getNode = _ref.getNode,
+    onMaybeNodeSelection = _ref.onMaybeNodeSelection,
+    selectCodeBlockNode = _ref.selectCodeBlockNode;
+  if (unit === 'char') {
+    onMaybeNodeSelection();
+  }
+  var node = getNode();
+  var state = cm.state;
+  var main = state.selection.main;
+  if (!main.empty) {
+    return false;
+  }
+  if (unit === 'line') {
+    main = _objectSpread(_objectSpread({}, state.doc.lineAt(main.head)), {}, {
+      head: 0,
+      empty: false
+    });
+  }
+  if (dir < 0 ? main.from > 0 : main.to < state.doc.length) {
+    return false;
+  }
+  var targetPos = ((_getPos = getPos === null || getPos === void 0 ? void 0 : getPos()) !== null && _getPos !== void 0 ? _getPos : 0) + (dir < 0 ? 0 : node.nodeSize);
+  if (unit === 'char') {
+    view.focus();
+    selectCodeBlockNode(dir === -1 ? RelativeSelectionPos.Start : RelativeSelectionPos.End);
+    return true;
+  } else {
+    createParagraphIfEndOfDoc(view, targetPos);
+    var tr = view.state.tr;
+    var selection = Selection.near(tr.doc.resolve(targetPos), dir);
+    tr.setSelection(selection).scrollIntoView();
+    view.dispatch(tr);
+    view.focus();
+    return true;
+  }
+};
+var createParagraphIfEndOfDoc = function createParagraphIfEndOfDoc(view, targetPos) {
+  if (targetPos === view.state.doc.content.size) {
+    var paragraph = view.state.schema.nodes.paragraph.createChecked({});
+    var tr = view.state.tr.insert(targetPos, paragraph);
+    // Note: we purposefully do a multi-dispatch here, otherwise we get stuck in codemirror
+    view.dispatch(tr);
+  }
+};

package/dist/esm/nodeviews/languages/languageMap.js

@@ -0,0 +1,86 @@
+import { LanguageDescription } from '@codemirror/language';
+import { languages } from '@codemirror/language-data';
+// getLanguageIdentifier defines `language.alias[0]`
+export var mapLanguageToCodeMirror = function mapLanguageToCodeMirror(language) {
+  if (!language || language === 'none') {
+    return undefined;
+  }
+  switch (language) {
+    case 'coldfusion':
+      return languages.find(function (l) {
+        return l.name.toLowerCase() === 'xml';
+      });
+    case 'matlab':
+      return languages.find(function (l) {
+        return l.name.toLowerCase() === 'octave';
+      });
+    case 'javafx':
+      return languages.find(function (l) {
+        return l.name.toLowerCase() === 'java';
+      });
+    case 'vbnet':
+      return languages.find(function (l) {
+        return l.name === 'VB.NET';
+      });
+    case 'pas':
+      return languages.find(function (l) {
+        return l.name.toLowerCase() === 'pascal';
+      });
+    case 'cuda':
+      return languages.find(function (l) {
+        return l.name.toLowerCase() === 'c++';
+      });
+    case 'racket':
+      return languages.find(function (l) {
+        return l.name === 'Common Lisp';
+      });
+    case 'abap':
+      return languages.find(function (l) {
+        return l.name === 'SQL';
+      });
+    case 'standardmL':
+      return languages.find(function (l) {
+        return l.name === 'SML';
+      });
+    case 'objective-j':
+      return languages.find(function (l) {
+        return l.name === 'Objective-C';
+      });
+    case 'docker':
+      return languages.find(function (l) {
+        return l.name === 'Dockerfile';
+      });
+    case 'arduino':
+      return languages.find(function (l) {
+        return l.name === 'C++';
+      });
+    case 'visualbasic':
+      return languages.find(function (l) {
+        return l.name === 'VB.NET';
+      });
+    case 'elixir':
+      return LanguageDescription.of({
+        name: 'Elixir',
+        load: function load() {
+          return import( /* webpackChunkName: "@atlaskit-internal_@atlaskit/editor-plugin-code-block-advanced-lang-elixir" */
+          'codemirror-lang-elixir').then(function (m) {
+            return m.elixir();
+          });
+        }
+      });
+    case 'graphql':
+      return LanguageDescription.of({
+        name: 'GraphQL',
+        load: function load() {
+          return import( /* webpackChunkName: "@atlaskit-internal_@atlaskit/editor-plugin-code-block-advanced-lang-graphql" */
+          'cm6-graphql').then(function (m) {
+            return m.graphqlLanguageSupport();
+          });
+        }
+      });
+    default:
+      return languages.find(function (l) {
+        return l.alias.includes(language) || l.name.toLowerCase() === (language === null || language === void 0 ? void 0 : language.toLowerCase());
+      });
+  }
+};

package/dist/esm/nodeviews/languages/loader.js

@@ -0,0 +1,44 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { mapLanguageToCodeMirror } from './languageMap';
+
+/**
+ * Manages loading the languages (for syntax highlighting, etc.)
+ * from CodeMirror and updating the language in the CodeMirror view
+ */
+export var LanguageLoader = /*#__PURE__*/function () {
+  function LanguageLoader(updateLanguageCompartment) {
+    _classCallCheck(this, LanguageLoader);
+    _defineProperty(this, "languageName", '');
+    this.updateLanguageCompartment = updateLanguageCompartment;
+  }
+  return _createClass(LanguageLoader, [{
+    key: "updateLanguage",
+    value: function updateLanguage(languageName) {
+      var _this = this;
+      if (languageName === this.languageName) {
+        return;
+      }
+      var language = mapLanguageToCodeMirror(languageName);
+      var configureEmpty = function configureEmpty() {
+        _this.updateLanguageCompartment([]);
+        _this.languageName = '';
+      };
+      if (!language) {
+        configureEmpty();
+        return;
+      }
+      language.load().then(function (lang) {
+        if (lang) {
+          _this.updateLanguageCompartment(lang);
+          _this.languageName = languageName;
+        } else {
+          configureEmpty();
+        }
+      }).catch(function () {
+        configureEmpty();
+      });
+    }
+  }]);
+}();

package/dist/esm/nodeviews/lazyCodeBlockAdvanced.js

@@ -0,0 +1,17 @@
+import { withLazyLoading } from '@atlaskit/editor-common/lazy-node-view';
+export var lazyCodeBlockView = function lazyCodeBlockView(props) {
+  return withLazyLoading({
+    nodeName: 'codeBlock',
+    getNodeViewOptions: function getNodeViewOptions() {},
+    loader: function loader() {
+      var result = import( /* webpackChunkName: "@atlaskit-internal_editor-plugin-code-block-advanced-nodeview" */
+      './codeBlockAdvanced').then(function (_ref) {
+        var getCodeBlockAdvancedNodeView = _ref.getCodeBlockAdvancedNodeView;
+        return function (node, view, getPos) {
+          return getCodeBlockAdvancedNodeView(props)(node, view, getPos);
+        };
+      });
+      return result;
+    }
+  });
+};

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

@@ -0,0 +1,11 @@
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import { lazyCodeBlockView } from '../nodeviews/lazyCodeBlockAdvanced';
+export var createPlugin = function createPlugin(props) {
+  return new SafePlugin({
+    props: {
+      nodeViews: {
+        codeBlock: lazyCodeBlockView(props)
+      }
+    }
+  });
+};

package/dist/esm/ui/syntaxHighlightingTheme.js

@@ -0,0 +1,70 @@
+import { HighlightStyle } from '@codemirror/language';
+import { tags } from '@lezer/highlight';
+// Based on `platform/packages/design-system/code/src/internal/theme/styles.tsx`
+export var highlightStyle = HighlightStyle.define([{
+  tag: tags.meta,
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: tags.link,
+  textDecoration: 'underline'
+}, {
+  tag: tags.heading,
+  textDecoration: 'underline',
+  // Custom syntax styling to match existing styling
+  // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+  fontWeight: "var(--ds-font-weight-bold, 700)"
+}, {
+  tag: tags.emphasis,
+  fontStyle: 'italic'
+}, {
+  tag: tags.strong,
+  // Custom syntax styling to match existing styling
+  // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+  fontWeight: "var(--ds-font-weight-bold, 700)"
+}, {
+  tag: tags.strikethrough,
+  textDecoration: 'line-through'
+}, {
+  tag: tags.keyword,
+  color: "var(--ds-text-accent-blue, #0055CC)",
+  // Custom syntax styling to match existing styling
+  // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+  fontWeight: "var(--ds-font-weight-bold, 700)"
+}, {
+  tag: [tags.atom, tags.bool, tags.url, tags.contentSeparator, tags.labelName],
+  color: "var(--ds-text-accent-blue, #0055CC)"
+}, {
+  tag: [tags.literal, tags.inserted],
+  color: "var(--ds-text-accent-blue, #0055CC)"
+}, {
+  tag: [tags.string, tags.deleted],
+  color: "var(--ds-text-accent-green, #216E4E)"
+}, {
+  tag: [tags.regexp, tags.escape, tags.special(tags.string)],
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: tags.definition(tags.variableName),
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: tags.local(tags.variableName),
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: [tags.typeName, tags.namespace],
+  color: "var(--ds-text-accent-blue, #0055CC)"
+}, {
+  tag: tags.className,
+  color: "var(--ds-text-accent-purple, #5E4DB2)"
+}, {
+  tag: [tags.special(tags.variableName), tags.macroName],
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: tags.definition(tags.propertyName),
+  color: "var(--ds-text, #172B4D)"
+}, {
+  tag: tags.comment,
+  color: "var(--ds-text-subtlest, #626F86)",
+  fontStyle: 'italic'
+}, {
+  tag: tags.invalid,
+  color: "var(--ds-text, #172B4D)"
+}]);

package/dist/esm/ui/theme.js

@@ -0,0 +1,49 @@
+import { EditorView as CodeMirror } from '@codemirror/view';
+export var cmTheme = CodeMirror.theme({
+  '&': {
+    backgroundColor: "var(--ds-background-neutral, #091E420F)",
+    padding: '0',
+    marginTop: "var(--ds-space-100, 8px)",
+    marginBottom: "var(--ds-space-100, 8px)",
+    borderRadius: "var(--ds-border-radius, 4px)",
+    fontSize: '0.875rem',
+    // Custom syntax styling to match existing styling
+    // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+    lineHeight: '1.5rem'
+  },
+  '&.cm-focused': {
+    outline: 'none'
+  },
+  '.cm-line': {
+    padding: '0'
+  },
+  '&.cm-editor.code-block.danger': {
+    backgroundColor: "var(--ds-background-danger, #FFECEB)"
+  },
+  '.cm-content': {
+    cursor: 'text',
+    caretColor: "var(--ds-text, #172B4D)",
+    margin: "var(--ds-space-100, 8px)",
+    padding: "var(--ds-space-0, 0px)"
+  },
+  '.cm-scroller': {
+    backgroundColor: "var(--ds-background-neutral, #091E420F)",
+    // Custom syntax styling to match existing styling
+    // eslint-disable-next-line @atlaskit/design-system/use-tokens-typography
+    lineHeight: 'unset',
+    fontFamily: "var(--ds-font-family-code, ui-monospace, Menlo, \"Segoe UI Mono\", \"Ubuntu Mono\", monospace)"
+  },
+  '&.cm-focused .cm-cursor': {
+    borderLeftColor: "var(--ds-text, #172B4D)"
+  },
+  '.cm-gutters': {
+    backgroundColor: "var(--ds-background-neutral, #091E420F)",
+    border: 'none',
+    padding: "var(--ds-space-100, 8px)"
+  },
+  '.cm-lineNumbers .cm-gutterElement': {
+    paddingLeft: "var(--ds-space-0, 0px)",
+    paddingRight: "var(--ds-space-0, 0px)",
+    minWidth: 'unset'
+  }
+});

package/dist/types/codeBlockAdvancedPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { CodeBlockAdvancedPlugin } from './codeBlockAdvancedPluginType';
+export declare const codeBlockAdvancedPlugin: CodeBlockAdvancedPlugin;

package/dist/types/codeBlockAdvancedPluginType.d.ts

@@ -0,0 +1,11 @@
+import type { Extension } from '@codemirror/state';
+import type { NextEditorPlugin, OptionalPlugin } from '@atlaskit/editor-common/types';
+import type { CodeBlockPlugin } from '@atlaskit/editor-plugin-code-block';
+import type { EditorDisabledPlugin } from '@atlaskit/editor-plugin-editor-disabled';
+import type { SelectionPlugin } from '@atlaskit/editor-plugin-selection';
+export type CodeBlockAdvancedPlugin = NextEditorPlugin<'codeBlockAdvanced', {
+    dependencies: [CodeBlockPlugin, SelectionPlugin, OptionalPlugin<EditorDisabledPlugin>];
+    pluginConfiguration: {
+        extensions?: Extension[];
+    } | undefined;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export { codeBlockAdvancedPlugin } from './codeBlockAdvancedPlugin';
+export type { CodeBlockAdvancedPlugin } from './codeBlockAdvancedPluginType';

package/dist/types/nodeviews/codeBlockAdvanced.d.ts

@@ -0,0 +1,38 @@
+import { Extension } from '@codemirror/state';
+import { ViewUpdate } from '@codemirror/view';
+import type { getPosHandler, getPosHandlerNode, ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import type { EditorView, NodeView } from '@atlaskit/editor-prosemirror/view';
+import type { CodeBlockAdvancedPlugin } from '../codeBlockAdvancedPluginType';
+interface ConfigProps {
+    api: ExtractInjectionAPI<CodeBlockAdvancedPlugin> | undefined;
+    extensions: Extension[];
+}
+declare class CodeBlockAdvancedNodeView implements NodeView {
+    dom: Node;
+    private updating;
+    private view;
+    private lineWrappingCompartment;
+    private languageCompartment;
+    private readOnlyCompartment;
+    private node;
+    private getPos;
+    private cm;
+    private selectionAPI;
+    private maybeTryingToReachNodeSelection;
+    private cleanupDisabledState;
+    private languageLoader;
+    constructor(node: PMNode, view: EditorView, getPos: getPosHandlerNode, config: ConfigProps);
+    destroy(): void;
+    forwardUpdate(update: ViewUpdate): void;
+    setSelection(anchor: number, head: number): void;
+    private updateReadonlyState;
+    private updateLanguage;
+    private selectCodeBlockNode;
+    private wordWrappingEnabled;
+    private updateWordWrap;
+    update(node: PMNode): boolean;
+    stopEvent(e: Event): boolean;
+}
+export declare const getCodeBlockAdvancedNodeView: (props: ConfigProps) => (node: PMNode, view: EditorView, getPos: getPosHandler) => CodeBlockAdvancedNodeView;
+export {};

package/dist/types/nodeviews/codeBlockNodeWithToDOMFixed.d.ts

@@ -0,0 +1,2 @@
+import type { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+export declare const codeBlockNodeWithFixedToDOM: () => NodeSpec;

package/dist/types/nodeviews/codemirrorSync/syncCMWithPM.d.ts

@@ -0,0 +1,17 @@
+import { ViewUpdate } from '@codemirror/view';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+interface Props {
+    view: EditorView;
+    update: ViewUpdate;
+    offset: number;
+}
+/**
+ *
+ * Synchronises the CodeMirror update changes with the Prosemirror editor
+ *
+ * @param props.view EditorView - Prosemirror EditorView
+ * @param props.update ViewUpdate - CodeMirror ViewUpdate
+ * @param props.offset number - position where the code block starts in prosemirror
+ */
+export declare const syncCMWithPM: ({ view, update, offset }: Props) => void;
+export {};

package/dist/types/nodeviews/codemirrorSync/updateCMSelection.d.ts

@@ -0,0 +1,11 @@
+import { TransactionSpec as CMTransactionSpec } from '@codemirror/state';
+/**
+ *
+ * Compares the updated text with the current to determine the transaction to fire
+ * in the CodeMirror editor.
+ *
+ * @param curText string - the current CodeMirror text
+ * @param newText string - the new CodeMirror text
+ * @param updateCallback Callback to process the CodeMirror transaction
+ */
+export declare const updateCMSelection: (curText: string, newText: string, updateCallback: (value: CMTransactionSpec) => void) => void;

package/dist/types/nodeviews/extensions/bidiCharWarning.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Code based on warning from @atlaskit/code
+ */
+import { ViewPlugin, ViewUpdate, DecorationSet } from '@codemirror/view';
+export declare const bidiCharWarningExtension: ViewPlugin<{
+    placeholders: DecorationSet;
+    update(update: ViewUpdate): void;
+}>;

package/dist/types/nodeviews/extensions/keymap/backspace.d.ts

@@ -0,0 +1,12 @@
+import { EditorView as CodeMirror } from '@codemirror/view';
+import type { getPosHandlerNode } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+interface BackspaceProps {
+    view: EditorView;
+    cm: CodeMirror;
+    getPos: getPosHandlerNode;
+    getNode: () => PMNode;
+}
+export declare const backspaceKeymap: ({ cm, view, getPos, getNode }: BackspaceProps) => boolean;
+export {};

package/dist/types/nodeviews/extensions/keymap/index.d.ts

@@ -0,0 +1,14 @@
+import { Extension } from '@codemirror/state';
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import type { getPosHandlerNode } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+interface KeymapProps {
+    view: EditorView;
+    getNode: () => PMNode;
+    getPos: getPosHandlerNode;
+    selectCodeBlockNode: (relativeSelectionPos: RelativeSelectionPos | undefined) => void;
+    onMaybeNodeSelection: () => void;
+}
+export declare const keymapExtension: ({ view, getNode, getPos, selectCodeBlockNode, onMaybeNodeSelection, }: KeymapProps) => Extension;
+export {};

package/dist/types/nodeviews/extensions/keymap/maybeEscape.d.ts

@@ -0,0 +1,17 @@
+import { EditorView as CodeMirror } from '@codemirror/view';
+import { RelativeSelectionPos } from '@atlaskit/editor-common/selection';
+import type { getPosHandlerNode } from '@atlaskit/editor-common/types';
+import type { Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { EditorView } from '@atlaskit/editor-prosemirror/view';
+interface MaybeEscapeProps {
+    unit: 'line' | 'char';
+    dir: -1 | 1;
+    view: EditorView;
+    cm: CodeMirror;
+    getPos: getPosHandlerNode;
+    getNode: () => PMNode;
+    onMaybeNodeSelection: () => void;
+    selectCodeBlockNode: (relativeSelectionPos: RelativeSelectionPos | undefined) => void;
+}
+export declare const maybeEscapeKeymap: ({ unit, dir, view, cm, getPos, getNode, onMaybeNodeSelection, selectCodeBlockNode, }: MaybeEscapeProps) => boolean;
+export {};

package/dist/types/nodeviews/languages/languageMap.d.ts

@@ -0,0 +1,5 @@
+import { LanguageDescription } from '@codemirror/language';
+import type { LanguageAlias } from '@atlaskit/code';
+type LanguageAliasValue = LanguageAlias[0];
+export declare const mapLanguageToCodeMirror: (language: LanguageAliasValue) => LanguageDescription | undefined;
+export {};

package/dist/types/nodeviews/languages/loader.d.ts

@@ -0,0 +1,11 @@
+import { LanguageSupport } from '@codemirror/language';
+/**
+ * Manages loading the languages (for syntax highlighting, etc.)
+ * from CodeMirror and updating the language in the CodeMirror view
+ */
+export declare class LanguageLoader {
+    private updateLanguageCompartment;
+    private languageName;
+    constructor(updateLanguageCompartment: (value: LanguageSupport | []) => void);
+    updateLanguage(languageName: string): void;
+}

package/dist/types/nodeviews/lazyCodeBlockAdvanced.d.ts

@@ -0,0 +1,9 @@
+import { Extension } from '@codemirror/state';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { CodeBlockAdvancedPlugin } from '../codeBlockAdvancedPluginType';
+interface Props {
+    api: ExtractInjectionAPI<CodeBlockAdvancedPlugin> | undefined;
+    extensions: Extension[];
+}
+export declare const lazyCodeBlockView: (props: Props) => import("@atlaskit/editor-common/lazy-node-view").NodeViewConstructor;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Extension } from '@codemirror/state';
+import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
+import type { ExtractInjectionAPI } from '@atlaskit/editor-common/types';
+import type { CodeBlockAdvancedPlugin } from '../codeBlockAdvancedPluginType';
+interface Props {
+    api: ExtractInjectionAPI<CodeBlockAdvancedPlugin> | undefined;
+    extensions: Extension[];
+}
+export declare const createPlugin: (props: Props) => SafePlugin<any>;
+export {};

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

@@ -0,0 +1,2 @@
+import { HighlightStyle } from '@codemirror/language';
+export declare const highlightStyle: HighlightStyle;

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

@@ -0,0 +1 @@
+export declare const cmTheme: import("@codemirror/state").Extension;

package/dist/types-ts4.5/codeBlockAdvancedPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { CodeBlockAdvancedPlugin } from './codeBlockAdvancedPluginType';
+export declare const codeBlockAdvancedPlugin: CodeBlockAdvancedPlugin;