@openziti/ziti-console-lib 0.3.0

package/assets/scripts/components/codemirror/modes/addons/closetags.js

@@ -0,0 +1,200 @@
+/*
+    Copyright NetFoundry Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/LICENSE
+
+/**
+ * Tag-closer extension for CodeMirror.
+ *
+ * This extension adds an "autoCloseTags" option that can be set to
+ * either true to get the default behavior, or an object to further
+ * configure its behavior.
+ *
+ * These are supported options:
+ *
+ * `whenClosing` (default true)
+ *   Whether to autoclose when the '/' of a closing tag is typed.
+ * `whenOpening` (default true)
+ *   Whether to autoclose the tag when the final '>' of an opening
+ *   tag is typed.
+ * `dontCloseTags` (default is empty tags for HTML, none for XML)
+ *   An array of tag names that should not be autoclosed.
+ * `indentTags` (default is block tags for HTML, none for XML)
+ *   An array of tag names that should, when opened, cause a
+ *   blank line to be added inside the tag, and the blank line and
+ *   closing line to be indented.
+ * `emptyTags` (default is none)
+ *   An array of XML tag names that should be autoclosed with '/>'.
+ *
+ * See demos/closetag.html for a usage example.
+ */
+
+(function(mod) {
+    if (typeof exports == "object" && typeof module == "object") // CommonJS
+      mod(require("../../lib/codemirror"), require("../fold/xml-fold"));
+    else if (typeof define == "function" && define.amd) // AMD
+      define(["../../lib/codemirror", "../fold/xml-fold"], mod);
+    else // Plain browser env
+      mod(CodeMirror);
+  })(function(CodeMirror) {
+    CodeMirror.defineOption("autoCloseTags", false, function(cm, val, old) {
+      if (old != CodeMirror.Init && old)
+        cm.removeKeyMap("autoCloseTags");
+      if (!val) return;
+      var map = {name: "autoCloseTags"};
+      if (typeof val != "object" || val.whenClosing)
+        map["'/'"] = function(cm) { return autoCloseSlash(cm); };
+      if (typeof val != "object" || val.whenOpening)
+        map["'>'"] = function(cm) { return autoCloseGT(cm); };
+      cm.addKeyMap(map);
+    });
+  
+    var htmlDontClose = ["area", "base", "br", "col", "command", "embed", "hr", "img", "input", "keygen", "link", "meta", "param",
+                         "source", "track", "wbr"];
+    var htmlIndent = ["applet", "blockquote", "body", "button", "div", "dl", "fieldset", "form", "frameset", "h1", "h2", "h3", "h4",
+                      "h5", "h6", "head", "html", "iframe", "layer", "legend", "object", "ol", "p", "select", "table", "ul"];
+  
+    function autoCloseGT(cm) {
+      if (cm.getOption("disableInput")) return CodeMirror.Pass;
+      var ranges = cm.listSelections(), replacements = [];
+      var opt = cm.getOption("autoCloseTags");
+      for (var i = 0; i < ranges.length; i++) {
+        if (!ranges[i].empty()) return CodeMirror.Pass;
+        var pos = ranges[i].head, tok = cm.getTokenAt(pos);
+        var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
+        var tagInfo = inner.mode.xmlCurrentTag && inner.mode.xmlCurrentTag(state)
+        var tagName = tagInfo && tagInfo.name
+        if (!tagName) return CodeMirror.Pass
+  
+        var html = inner.mode.configuration == "html";
+        var dontCloseTags = (typeof opt == "object" && opt.dontCloseTags) || (html && htmlDontClose);
+        var indentTags = (typeof opt == "object" && opt.indentTags) || (html && htmlIndent);
+  
+        if (tok.end > pos.ch) tagName = tagName.slice(0, tagName.length - tok.end + pos.ch);
+        var lowerTagName = tagName.toLowerCase();
+        // Don't process the '>' at the end of an end-tag or self-closing tag
+        if (!tagName ||
+            tok.type == "string" && (tok.end != pos.ch || !/[\"\']/.test(tok.string.charAt(tok.string.length - 1)) || tok.string.length == 1) ||
+            tok.type == "tag" && tagInfo.close ||
+            tok.string.indexOf("/") == (pos.ch - tok.start - 1) || // match something like <someTagName />
+            dontCloseTags && indexOf(dontCloseTags, lowerTagName) > -1 ||
+            closingTagExists(cm, inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state) || [], tagName, pos, true))
+          return CodeMirror.Pass;
+  
+        var emptyTags = typeof opt == "object" && opt.emptyTags;
+        if (emptyTags && indexOf(emptyTags, tagName) > -1) {
+          replacements[i] = { text: "/>", newPos: CodeMirror.Pos(pos.line, pos.ch + 2) };
+          continue;
+        }
+  
+        var indent = indentTags && indexOf(indentTags, lowerTagName) > -1;
+        replacements[i] = {indent: indent,
+                           text: ">" + (indent ? "\n\n" : "") + "</" + tagName + ">",
+                           newPos: indent ? CodeMirror.Pos(pos.line + 1, 0) : CodeMirror.Pos(pos.line, pos.ch + 1)};
+      }
+  
+      var dontIndentOnAutoClose = (typeof opt == "object" && opt.dontIndentOnAutoClose);
+      for (var i = ranges.length - 1; i >= 0; i--) {
+        var info = replacements[i];
+        cm.replaceRange(info.text, ranges[i].head, ranges[i].anchor, "+insert");
+        var sel = cm.listSelections().slice(0);
+        sel[i] = {head: info.newPos, anchor: info.newPos};
+        cm.setSelections(sel);
+        if (!dontIndentOnAutoClose && info.indent) {
+          cm.indentLine(info.newPos.line, null, true);
+          cm.indentLine(info.newPos.line + 1, null, true);
+        }
+      }
+    }
+  
+    function autoCloseCurrent(cm, typingSlash) {
+      var ranges = cm.listSelections(), replacements = [];
+      var head = typingSlash ? "/" : "</";
+      var opt = cm.getOption("autoCloseTags");
+      var dontIndentOnAutoClose = (typeof opt == "object" && opt.dontIndentOnSlash);
+      for (var i = 0; i < ranges.length; i++) {
+        if (!ranges[i].empty()) return CodeMirror.Pass;
+        var pos = ranges[i].head, tok = cm.getTokenAt(pos);
+        var inner = CodeMirror.innerMode(cm.getMode(), tok.state), state = inner.state;
+        if (typingSlash && (tok.type == "string" || tok.string.charAt(0) != "<" ||
+                            tok.start != pos.ch - 1))
+          return CodeMirror.Pass;
+        // Kludge to get around the fact that we are not in XML mode
+        // when completing in JS/CSS snippet in htmlmixed mode. Does not
+        // work for other XML embedded languages (there is no general
+        // way to go from a mixed mode to its current XML state).
+        var replacement, mixed = inner.mode.name != "xml" && cm.getMode().name == "htmlmixed"
+        if (mixed && inner.mode.name == "javascript") {
+          replacement = head + "script";
+        } else if (mixed && inner.mode.name == "css") {
+          replacement = head + "style";
+        } else {
+          var context = inner.mode.xmlCurrentContext && inner.mode.xmlCurrentContext(state)
+          if (!context || (context.length && closingTagExists(cm, context, context[context.length - 1], pos)))
+            return CodeMirror.Pass;
+          replacement = head + context[context.length - 1]
+        }
+        if (cm.getLine(pos.line).charAt(tok.end) != ">") replacement += ">";
+        replacements[i] = replacement;
+      }
+      cm.replaceSelections(replacements);
+      ranges = cm.listSelections();
+      if (!dontIndentOnAutoClose) {
+          for (var i = 0; i < ranges.length; i++)
+              if (i == ranges.length - 1 || ranges[i].head.line < ranges[i + 1].head.line)
+                  cm.indentLine(ranges[i].head.line);
+      }
+    }
+  
+    function autoCloseSlash(cm) {
+      if (cm.getOption("disableInput")) return CodeMirror.Pass;
+      return autoCloseCurrent(cm, true);
+    }
+  
+    CodeMirror.commands.closeTag = function(cm) { return autoCloseCurrent(cm); };
+  
+    function indexOf(collection, elt) {
+      if (collection.indexOf) return collection.indexOf(elt);
+      for (var i = 0, e = collection.length; i < e; ++i)
+        if (collection[i] == elt) return i;
+      return -1;
+    }
+  
+    // If xml-fold is loaded, we use its functionality to try and verify
+    // whether a given tag is actually unclosed.
+    function closingTagExists(cm, context, tagName, pos, newTag) {
+      if (!CodeMirror.scanForClosingTag) return false;
+      var end = Math.min(cm.lastLine() + 1, pos.line + 500);
+      var nextClose = CodeMirror.scanForClosingTag(cm, pos, null, end);
+      if (!nextClose || nextClose.tag != tagName) return false;
+      // If the immediate wrapping context contains onCx instances of
+      // the same tag, a closing tag only exists if there are at least
+      // that many closing tags of that type following.
+      var onCx = newTag ? 1 : 0
+      for (var i = context.length - 1; i >= 0; i--) {
+        if (context[i] == tagName) ++onCx
+        else break
+      }
+      pos = nextClose.to;
+      for (var i = 1; i < onCx; i++) {
+        var next = CodeMirror.scanForClosingTag(cm, pos, null, end);
+        if (!next || next.tag != tagName) return false;
+        pos = next.to;
+      }
+      return true;
+    }
+  });

package/assets/scripts/components/codemirror/modes/addons/colorize.js

@@ -0,0 +1,40 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("./runmode"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "./runmode"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var isBlock = /^(p|li|div|h\\d|pre|blockquote|td)$/;
+
+  function textContent(node, out) {
+    if (node.nodeType == 3) return out.push(node.nodeValue);
+    for (var ch = node.firstChild; ch; ch = ch.nextSibling) {
+      textContent(ch, out);
+      if (isBlock.test(node.nodeType)) out.push("\n");
+    }
+  }
+
+  CodeMirror.colorize = function(collection, defaultMode) {
+    if (!collection) collection = document.body.getElementsByTagName("pre");
+
+    for (var i = 0; i < collection.length; ++i) {
+      var node = collection[i];
+      var mode = node.getAttribute("data-lang") || defaultMode;
+      if (!mode) continue;
+
+      var text = [];
+      textContent(node, text);
+      node.innerHTML = "";
+      CodeMirror.runMode(text.join(""), mode, node);
+
+      node.className += " cm-s-default";
+    }
+  };
+});

package/assets/scripts/components/codemirror/modes/addons/css-hint.js

@@ -0,0 +1,66 @@
+// CodeMirror, copyright (c) by Marijn Haverbeke and others
+// Distributed under an MIT license: https://codemirror.net/LICENSE
+
+(function(mod) {
+  if (typeof exports == "object" && typeof module == "object") // CommonJS
+    mod(require("../../lib/codemirror"), require("../../mode/css/css"));
+  else if (typeof define == "function" && define.amd) // AMD
+    define(["../../lib/codemirror", "../../mode/css/css"], mod);
+  else // Plain browser env
+    mod(CodeMirror);
+})(function(CodeMirror) {
+  "use strict";
+
+  var pseudoClasses = {"active":1, "after":1, "before":1, "checked":1, "default":1,
+    "disabled":1, "empty":1, "enabled":1, "first-child":1, "first-letter":1,
+    "first-line":1, "first-of-type":1, "focus":1, "hover":1, "in-range":1,
+    "indeterminate":1, "invalid":1, "lang":1, "last-child":1, "last-of-type":1,
+    "link":1, "not":1, "nth-child":1, "nth-last-child":1, "nth-last-of-type":1,
+    "nth-of-type":1, "only-of-type":1, "only-child":1, "optional":1, "out-of-range":1,
+    "placeholder":1, "read-only":1, "read-write":1, "required":1, "root":1,
+    "selection":1, "target":1, "valid":1, "visited":1
+  };
+
+  CodeMirror.registerHelper("hint", "css", function(cm) {
+    var cur = cm.getCursor(), token = cm.getTokenAt(cur);
+    var inner = CodeMirror.innerMode(cm.getMode(), token.state);
+    if (inner.mode.name != "css") return;
+
+    if (token.type == "keyword" && "!important".indexOf(token.string) == 0)
+      return {list: ["!important"], from: CodeMirror.Pos(cur.line, token.start),
+              to: CodeMirror.Pos(cur.line, token.end)};
+
+    var start = token.start, end = cur.ch, word = token.string.slice(0, end - start);
+    if (/[^\w$_-]/.test(word)) {
+      word = ""; start = end = cur.ch;
+    }
+
+    var spec = CodeMirror.resolveMode("text/css");
+
+    var result = [];
+    function add(keywords) {
+      for (var name in keywords)
+        if (!word || name.lastIndexOf(word, 0) == 0)
+          result.push(name);
+    }
+
+    var st = inner.state.state;
+    if (st == "pseudo" || token.type == "variable-3") {
+      add(pseudoClasses);
+    } else if (st == "block" || st == "maybeprop") {
+      add(spec.propertyKeywords);
+    } else if (st == "prop" || st == "parens" || st == "at" || st == "params") {
+      add(spec.valueKeywords);
+      add(spec.colorKeywords);
+    } else if (st == "media" || st == "media_parens") {
+      add(spec.mediaTypes);
+      add(spec.mediaFeatures);
+    }
+
+    if (result.length) return {
+      list: result,
+      from: CodeMirror.Pos(cur.line, start),
+      to: CodeMirror.Pos(cur.line, end)
+    };
+  });
+});

package/assets/scripts/components/codemirror/modes/addons/formatting.js

@@ -0,0 +1,124 @@
+/*
+    Copyright NetFoundry Inc.
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+    https://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+*/
+
+(function() {
+
+  CodeMirror.extendMode("css", {
+    commentStart: "/*",
+    commentEnd: "*/",
+    newlineAfterToken: function(type, content) {
+      return /^[;{}]$/.test(content);
+    }
+  });
+
+  CodeMirror.extendMode("javascript", {
+    commentStart: "/*",
+    commentEnd: "*/",
+    // FIXME semicolons inside of for
+    newlineAfterToken: function(type, content, textAfter, state) {
+      if (this.jsonMode) {
+        return /^[\[,{]$/.test(content) || /^}/.test(textAfter);
+      } else {
+        if (content == ";" && state.lexical && state.lexical.type == ")") return false;
+        return /^[;{}]$/.test(content) && !/^;/.test(textAfter);
+      }
+    }
+  });
+
+  CodeMirror.extendMode("xml", {
+    commentStart: "<!--",
+    commentEnd: "-->",
+    newlineAfterToken: function(type, content, textAfter) {
+      return type == "tag" && />$/.test(content) || /^</.test(textAfter);
+    }
+  });
+
+  // Comment/uncomment the specified range
+  CodeMirror.defineExtension("commentRange", function (isComment, from, to) {
+    var cm = this, curMode = CodeMirror.innerMode(cm.getMode(), cm.getTokenAt(from).state).mode;
+    cm.operation(function() {
+      if (isComment) { // Comment range
+        cm.replaceRange(curMode.commentEnd, to);
+        cm.replaceRange(curMode.commentStart, from);
+        if (from.line == to.line && from.ch == to.ch) // An empty comment inserted - put cursor inside
+          cm.setCursor(from.line, from.ch + curMode.commentStart.length);
+      } else { // Uncomment range
+        var selText = cm.getRange(from, to);
+        var startIndex = selText.indexOf(curMode.commentStart);
+        var endIndex = selText.lastIndexOf(curMode.commentEnd);
+        if (startIndex > -1 && endIndex > -1 && endIndex > startIndex) {
+          // Take string till comment start
+          selText = selText.substr(0, startIndex)
+          // From comment start till comment end
+            + selText.substring(startIndex + curMode.commentStart.length, endIndex)
+          // From comment end till string end
+            + selText.substr(endIndex + curMode.commentEnd.length);
+        }
+        cm.replaceRange(selText, from, to);
+      }
+    });
+  });
+
+  // Applies automatic mode-aware indentation to the specified range
+  CodeMirror.defineExtension("autoIndentRange", function (from, to) {
+    var cmInstance = this;
+    this.operation(function () {
+      for (var i = from.line; i <= to.line; i++) {
+        cmInstance.indentLine(i, "smart");
+      }
+    });
+  });
+
+  // Applies automatic formatting to the specified range
+  CodeMirror.defineExtension("autoFormatRange", function (from, to) {
+    var cm = this;
+    var outer = cm.getMode(), text = cm.getRange(from, to).split("\n");
+    var state = CodeMirror.copyState(outer, cm.getTokenAt(from).state);
+    var tabSize = cm.getOption("tabSize");
+
+    var out = "", lines = 0, atSol = from.ch == 0;
+    function newline() {
+      out += "\n";
+      atSol = true;
+      ++lines;
+    }
+
+    for (var i = 0; i < text.length; ++i) {
+      var stream = new CodeMirror.StringStream(text[i], tabSize);
+      while (!stream.eol()) {
+        var inner = CodeMirror.innerMode(outer, state);
+        var style = outer.token(stream, state), cur = stream.current();
+        stream.start = stream.pos;
+        if (!atSol || /\S/.test(cur)) {
+          out += cur;
+          atSol = false;
+        }
+        if (!atSol && inner.mode.newlineAfterToken &&
+            inner.mode.newlineAfterToken(style, cur, stream.string.slice(stream.pos) || text[i+1] || "", inner.state))
+          newline();
+      }
+      if (!stream.pos && outer.blankLine) outer.blankLine(state);
+      if (!atSol) newline();
+    }
+
+    cm.operation(function () {
+      cm.replaceRange(out, from, to);
+      for (var cur = from.line + 1, end = from.line + lines; cur <= end; ++cur)
+        cm.indentLine(cur, "smart");
+      cm.setSelection(from, cm.getCursor(false));
+    });
+  });
+})();