Removed all traces of sockets, real-time collab and other stuff.

2022-03-31 14:28:07 +02:00
parent 4525d60964
commit 859657f8b8
41 changed files with 796 additions and 1691 deletions
@@ -1,8 +1,8 @@
 import {
+  ChangeSpec,
+  EditorSelection,
  StateCommand,
  Text,
-  EditorSelection,
-  ChangeSpec,
 } from "@codemirror/state";
 import { syntaxTree } from "@codemirror/language";
 import { SyntaxNode, Tree } from "@lezer/common";
@@ -1,56 +1,87 @@
-import {Prec} from "@codemirror/state"
-import {KeyBinding, keymap} from "@codemirror/view"
-import {Language, LanguageSupport, LanguageDescription} from "@codemirror/language"
-import {MarkdownExtension, MarkdownParser, parseCode} from "@lezer/markdown"
-import {html} from "@codemirror/lang-html"
-import {commonmarkLanguage, markdownLanguage, mkLang, getCodeParser} from "./markdown"
-import {insertNewlineContinueMarkup, deleteMarkupBackward} from "./commands"
-export {commonmarkLanguage, markdownLanguage, insertNewlineContinueMarkup, deleteMarkupBackward}
+import { Prec } from "@codemirror/state";
+import { KeyBinding, keymap } from "@codemirror/view";
+import {
+  Language,
+  LanguageDescription,
+  LanguageSupport,
+} from "@codemirror/language";
+import { MarkdownExtension, MarkdownParser, parseCode } from "@lezer/markdown";
+import { html } from "@codemirror/lang-html";
+import {
+  commonmarkLanguage,
+  getCodeParser,
+  markdownLanguage,
+  mkLang,
+} from "./markdown";
+import { deleteMarkupBackward, insertNewlineContinueMarkup } from "./commands";
+
+export {
+  commonmarkLanguage,
+  markdownLanguage,
+  insertNewlineContinueMarkup,
+  deleteMarkupBackward,
+};

 /// A small keymap with Markdown-specific bindings. Binds Enter to
 /// [`insertNewlineContinueMarkup`](#lang-markdown.insertNewlineContinueMarkup)
 /// and Backspace to
 /// [`deleteMarkupBackward`](#lang-markdown.deleteMarkupBackward).
 export const markdownKeymap: readonly KeyBinding[] = [
-  {key: "Enter", run: insertNewlineContinueMarkup},
-  {key: "Backspace", run: deleteMarkupBackward}
-]
+  { key: "Enter", run: insertNewlineContinueMarkup },
+  { key: "Backspace", run: deleteMarkupBackward },
+];

-const htmlNoMatch = html({matchClosingTags: false})
+const htmlNoMatch = html({ matchClosingTags: false });

 /// Markdown language support.
-export function markdown(config: {
-  /// When given, this language will be used by default to parse code
-  /// blocks.
-  defaultCodeLanguage?: Language | LanguageSupport,
-  /// A collection of language descriptions to search through for a
-  /// matching language (with
-  /// [`LanguageDescription.matchLanguageName`](#language.LanguageDescription^matchLanguageName))
-  /// when a fenced code block has an info string.
-  codeLanguages?: readonly LanguageDescription[],
-  /// Set this to false to disable installation of the Markdown
-  /// [keymap](#lang-markdown.markdownKeymap).
-  addKeymap?: boolean,
-  /// Markdown parser
-  /// [extensions](https://github.com/lezer-parser/markdown#user-content-markdownextension)
-  /// to add to the parser.
-  extensions?: MarkdownExtension,
-  /// The base language to use. Defaults to
-  /// [`commonmarkLanguage`](#lang-markdown.commonmarkLanguage).
-  base?: Language
-} = {}) {
-  let {codeLanguages, defaultCodeLanguage, addKeymap = true, base: {parser} = commonmarkLanguage} = config
-  if (!(parser instanceof MarkdownParser)) throw new RangeError("Base parser provided to `markdown` should be a Markdown parser")
-  let extensions = config.extensions ? [config.extensions] : []
-  let support = [htmlNoMatch.support], defaultCode
+export function markdown(
+    config: {
+      /// When given, this language will be used by default to parse code
+      /// blocks.
+      defaultCodeLanguage?: Language | LanguageSupport;
+      /// A collection of language descriptions to search through for a
+      /// matching language (with
+      /// [`LanguageDescription.matchLanguageName`](#language.LanguageDescription^matchLanguageName))
+      /// when a fenced code block has an info string.
+      codeLanguages?: readonly LanguageDescription[];
+      /// Set this to false to disable installation of the Markdown
+      /// [keymap](#lang-markdown.markdownKeymap).
+      addKeymap?: boolean;
+      /// Markdown parser
+      /// [extensions](https://github.com/lezer-parser/markdown#user-content-markdownextension)
+      /// to add to the parser.
+      extensions?: MarkdownExtension;
+      /// The base language to use. Defaults to
+      /// [`commonmarkLanguage`](#lang-markdown.commonmarkLanguage).
+      base?: Language;
+    } = {}
+) {
+  let {
+    codeLanguages,
+    defaultCodeLanguage,
+    addKeymap = true,
+    base: {parser} = commonmarkLanguage,
+  } = config;
+  if (!(parser instanceof MarkdownParser))
+    throw new RangeError(
+        "Base parser provided to `markdown` should be a Markdown parser"
+    );
+  let extensions = config.extensions ? [config.extensions] : [];
+  let support = [htmlNoMatch.support],
+      defaultCode;
  if (defaultCodeLanguage instanceof LanguageSupport) {
-    support.push(defaultCodeLanguage.support)
-    defaultCode = defaultCodeLanguage.language
+    support.push(defaultCodeLanguage.support);
+    defaultCode = defaultCodeLanguage.language;
  } else if (defaultCodeLanguage) {
-    defaultCode = defaultCodeLanguage
+    defaultCode = defaultCodeLanguage;
  }
-  let codeParser = codeLanguages || defaultCode ? getCodeParser(codeLanguages || [], defaultCode) : undefined
-  extensions.push(parseCode({codeParser, htmlParser: htmlNoMatch.language.parser}))
-  if (addKeymap) support.push(Prec.high(keymap.of(markdownKeymap)))
-  return new LanguageSupport(mkLang(parser.configure(extensions)), support)
+  let codeParser =
+      codeLanguages || defaultCode
+          ? getCodeParser(codeLanguages || [], defaultCode)
+          : undefined;
+  extensions.push(
+      parseCode({codeParser, htmlParser: htmlNoMatch.language.parser})
+  );
+  if (addKeymap) support.push(Prec.high(keymap.of(markdownKeymap)));
+  return new LanguageSupport(mkLang(parser.configure(extensions)), support);
 }
@@ -1,84 +1,114 @@
 import {
-    Language, defineLanguageFacet, languageDataProp, foldNodeProp, indentNodeProp,
-    LanguageDescription, ParseContext
-} from "@codemirror/language"
-import {styleTags, tags as t} from "@codemirror/highlight"
-import {parser as baseParser, MarkdownParser, GFM, Subscript, Superscript, Emoji, MarkdownConfig} from "@lezer/markdown"
+  defineLanguageFacet,
+  foldNodeProp,
+  indentNodeProp,
+  Language,
+  languageDataProp,
+  LanguageDescription,
+  ParseContext,
+} from "@codemirror/language";
+import { styleTags, tags as t } from "@codemirror/highlight";
+import {
+  Emoji,
+  GFM,
+  MarkdownParser,
+  parser as baseParser,
+  Subscript,
+  Superscript,
+} from "@lezer/markdown";

-const data = defineLanguageFacet({block: {open: "<!--", close: "-->"}})
+const data = defineLanguageFacet({ block: { open: "<!--", close: "-->" } });

 export const commonmark = baseParser.configure({
-    props: [
-        styleTags({
-            "Blockquote/...": t.quote,
-            HorizontalRule: t.contentSeparator,
-            "ATXHeading1/... SetextHeading1/...": t.heading1,
-            "ATXHeading2/... SetextHeading2/...": t.heading2,
-            "ATXHeading3/...": t.heading3,
-            "ATXHeading4/...": t.heading4,
-            "ATXHeading5/...": t.heading5,
-            "ATXHeading6/...": t.heading6,
-            "Comment CommentBlock": t.comment,
-            Escape: t.escape,
-            Entity: t.character,
-            "Emphasis/...": t.emphasis,
-            "StrongEmphasis/...": t.strong,
-            "Link/... Image/...": t.link,
-            "OrderedList/... BulletList/...": t.list,
+  props: [
+    styleTags({
+      "Blockquote/...": t.quote,
+      HorizontalRule: t.contentSeparator,
+      "ATXHeading1/... SetextHeading1/...": t.heading1,
+      "ATXHeading2/... SetextHeading2/...": t.heading2,
+      "ATXHeading3/...": t.heading3,
+      "ATXHeading4/...": t.heading4,
+      "ATXHeading5/...": t.heading5,
+      "ATXHeading6/...": t.heading6,
+      "Comment CommentBlock": t.comment,
+      Escape: t.escape,
+      Entity: t.character,
+      "Emphasis/...": t.emphasis,
+      "StrongEmphasis/...": t.strong,
+      "Link/... Image/...": t.link,
+      "OrderedList/... BulletList/...": t.list,

-            // "CodeBlock/... FencedCode/...": t.blockComment,
-            "InlineCode CodeText": t.monospace,
-            URL: t.url,
-            "HeaderMark HardBreak QuoteMark ListMark LinkMark EmphasisMark CodeMark": t.processingInstruction,
-            "CodeInfo LinkLabel": t.labelName,
-            LinkTitle: t.string,
-            Paragraph: t.content
-        }),
-        foldNodeProp.add(type => {
-            if (!type.is("Block") || type.is("Document")) return undefined
-            return (tree, state) => ({from: state.doc.lineAt(tree.from).to, to: tree.to})
-        }),
-        indentNodeProp.add({
-            Document: () => null
-        }),
-        languageDataProp.add({
-            Document: data
-        })
-    ]
-})
+      // "CodeBlock/... FencedCode/...": t.blockComment,
+      "InlineCode CodeText": t.monospace,
+      URL: t.url,
+      "HeaderMark HardBreak QuoteMark ListMark LinkMark EmphasisMark CodeMark":
+        t.processingInstruction,
+      "CodeInfo LinkLabel": t.labelName,
+      LinkTitle: t.string,
+      Paragraph: t.content,
+    }),
+    foldNodeProp.add((type) => {
+      if (!type.is("Block") || type.is("Document")) return undefined;
+      return (tree, state) => ({
+        from: state.doc.lineAt(tree.from).to,
+        to: tree.to,
+      });
+    }),
+    indentNodeProp.add({
+      Document: () => null,
+    }),
+    languageDataProp.add({
+      Document: data,
+    }),
+  ],
+});

 export function mkLang(parser: MarkdownParser) {
-    return new Language(data, parser, parser.nodeSet.types.find(t => t.name == "Document")!)
+  return new Language(
+    data,
+    parser,
+    parser.nodeSet.types.find((t) => t.name == "Document")!
+  );
 }

 /// Language support for strict CommonMark.
-export const commonmarkLanguage = mkLang(commonmark)
+export const commonmarkLanguage = mkLang(commonmark);

-const extended = commonmark.configure([GFM, Subscript, Superscript, Emoji, {
+const extended = commonmark.configure([
+  GFM,
+  Subscript,
+  Superscript,
+  Emoji,
+  {
    props: [
-        styleTags({
-            "TableDelimiter SubscriptMark SuperscriptMark StrikethroughMark": t.processingInstruction,
-            "TableHeader/...": t.heading,
-            "Strikethrough/...": t.strikethrough,
-            TaskMarker: t.atom,
-            Task: t.list,
-            Emoji: t.character,
-            "Subscript Superscript": t.special(t.content),
-            TableCell: t.content
-        })
-    ]
-}])
+      styleTags({
+        "TableDelimiter SubscriptMark SuperscriptMark StrikethroughMark":
+          t.processingInstruction,
+        "TableHeader/...": t.heading,
+        "Strikethrough/...": t.strikethrough,
+        TaskMarker: t.atom,
+        Task: t.list,
+        Emoji: t.character,
+        "Subscript Superscript": t.special(t.content),
+        TableCell: t.content,
+      }),
+    ],
+  },
+]);

 /// Language support for [GFM](https://github.github.com/gfm/) plus
 /// subscript, superscript, and emoji syntax.
-export const markdownLanguage = mkLang(extended)
+export const markdownLanguage = mkLang(extended);

-export function getCodeParser(languages: readonly LanguageDescription[],
-                              defaultLanguage?: Language) {
-    return (info: string) => {
-        let found = info && LanguageDescription.matchLanguageName(languages, info, true)
-        if (!found) return defaultLanguage ? defaultLanguage.parser : null
-        if (found.support) return found.support.language.parser
-        return ParseContext.getSkippingParser(found.load())
-    }
+export function getCodeParser(
+  languages: readonly LanguageDescription[],
+  defaultLanguage?: Language
+) {
+  return (info: string) => {
+    let found =
+      info && LanguageDescription.matchLanguageName(languages, info, true);
+    if (!found) return defaultLanguage ? defaultLanguage.parser : null;
+    if (found.support) return found.support.language.parser;
+    return ParseContext.getSkippingParser(found.load());
+  };
 }