multiplex.js

// CodeMirror, copyright (c) by Marijn Haverbeke and others
// Distributed under an MIT license: https://codemirror.net/LICENSE

/*
Multiplexing mode -- exactly like the original CodeMirror multiplexingMode,
https://codemirror.net/demo/multiplex.html,
except use the option start:true to make it so the mode switch pattern
must be at the beginning of the line.

Original copyright on https://codemirror.net/addon/mode/multiplex.js:
   CodeMirror, copyright (c) by Marijn Haverbeke and others
   Distributed under an MIT license: http://codemirror.net/LICENSE
*/

import CodeMirror from "./codemirror";

CodeMirror.cocalcMultiplexingMode = function (outer /*, others */) {
  // Others should be {open, close, mode [, delimStyle] [, innerStyle]} objects
  var others = Array.prototype.slice.call(arguments, 1);

  function indexOf(string, pattern, from, returnEnd) {
    if (typeof pattern == "string") {
      var found = string.indexOf(pattern, from);
      return returnEnd && found > -1 ? found + pattern.length : found;
    }
    var m = pattern.exec(from ? string.slice(from) : string);
    return m ? m.index + from + (returnEnd ? m[0].length : 0) : -1;
  }

  return {
    startState: function () {
      return {
        outer: CodeMirror.startState(outer),
        innerActive: null,
        inner: null,
      };
    },

    copyState: function (state) {
      return {
        outer: CodeMirror.copyState(outer, state.outer),
        innerActive: state.innerActive,
        inner:
          state.innerActive &&
          CodeMirror.copyState(state.innerActive.mode, state.inner),
      };
    },

    token: function (stream, state) {
      if (!state.innerActive) {
        var cutOff = Infinity,
          oldContent = stream.string;
        for (var i = 0; i < others.length; ++i) {
          var other = others[i];
          if (
            // This is our modification of usptream.
            other.start &&
            oldContent.slice(0, other.open.length) != other.open
          ) {
            continue;
          }
          var found = indexOf(oldContent, other.open, stream.pos);
          if (found == stream.pos) {
            if (!other.parseDelimiters) stream.match(other.open);
            state.innerActive = other;

            // Get the outer indent, making sure to handle CodeMirror.Pass
            var outerIndent = 0;
            if (outer.indent) {
              var possibleOuterIndent = outer.indent(state.outer, "", "");
              if (possibleOuterIndent !== CodeMirror.Pass)
                outerIndent = possibleOuterIndent;
            }

            state.inner = CodeMirror.startState(other.mode, outerIndent);
            return (
              other.delimStyle &&
              other.delimStyle + " " + other.delimStyle + "-open"
            );
          } else if (found != -1 && found < cutOff) {
            cutOff = found;
          }
        }
        if (cutOff != Infinity) stream.string = oldContent.slice(0, cutOff);
        var outerToken = outer.token(stream, state.outer);
        if (cutOff != Infinity) stream.string = oldContent;
        return outerToken;
      } else {
        var curInner = state.innerActive,
          oldContent = stream.string;
        if (!curInner.close && stream.sol()) {
          state.innerActive = state.inner = null;
          return this.token(stream, state);
        }
        var found = curInner.close
          ? indexOf(
              oldContent,
              curInner.close,
              stream.pos,
              curInner.parseDelimiters
            )
          : -1;
        if (found == stream.pos && !curInner.parseDelimiters) {
          stream.match(curInner.close);
          state.innerActive = state.inner = null;
          return (
            curInner.delimStyle &&
            curInner.delimStyle + " " + curInner.delimStyle + "-close"
          );
        }
        if (found > -1) stream.string = oldContent.slice(0, found);
        var innerToken = curInner.mode.token(stream, state.inner);
        if (found > -1) stream.string = oldContent;

        if (found == stream.pos && curInner.parseDelimiters)
          state.innerActive = state.inner = null;

        if (curInner.innerStyle) {
          if (innerToken) innerToken = innerToken + " " + curInner.innerStyle;
          else innerToken = curInner.innerStyle;
        }

        return innerToken;
      }
    },

    indent: function (state, textAfter, line) {
      var mode = state.innerActive ? state.innerActive.mode : outer;
      if (!mode.indent) return CodeMirror.Pass;
      return mode.indent(
        state.innerActive ? state.inner : state.outer,
        textAfter,
        line
      );
    },

    blankLine: function (state) {
      var mode = state.innerActive ? state.innerActive.mode : outer;
      if (mode.blankLine) {
        mode.blankLine(state.innerActive ? state.inner : state.outer);
      }
      if (!state.innerActive) {
        for (var i = 0; i < others.length; ++i) {
          var other = others[i];
          if (other.open === "\n") {
            state.innerActive = other;
            state.inner = CodeMirror.startState(
              other.mode,
              mode.indent ? mode.indent(state.outer, "", "") : 0
            );
          }
        }
      } else if (state.innerActive.close === "\n") {
        state.innerActive = state.inner = null;
      }
    },

    electricChars: outer.electricChars,

    innerMode: function (state) {
      return state.inner
        ? { state: state.inner, mode: state.innerActive.mode }
        : { state: state.outer, mode: outer };
    },
  };
};