cosey 0.9.4 → 0.10.0

package/components/editor/index.js

@@ -1,26 +1,8 @@
-import { defineComponent, defineAsyncComponent, h } from 'vue';
 import { withInstall } from '../utils.js';
-export { editorEmits, editorProps } from './editor.api.js';
-import { useMounted } from '../../hooks/useMounted.js';
-import { isClient } from '../../utils/env.js';
+import stdin_default$1 from './editor.js';
+export { editorEmits, editorProps, editorSlots } from './editor.api.js';
 
-const Editor = defineComponent({
-  name: "Editor",
-  setup(props, { slots }) {
-    const AsyncComponent = defineAsyncComponent(() => import('./editor.js'));
-    const isMounted = useMounted();
-    return () => {
-      if (!isClient()) {
-        return isMounted.value && h(AsyncComponent, props, slots);
-      }
-      return h(AsyncComponent, props, slots);
-    };
-  }
-});
-if (isClient()) {
-  import('./editor.js');
-}
-const _Editor = withInstall(Editor);
+const _Editor = withInstall(stdin_default$1);
 var stdin_default = _Editor;
 
 export { _Editor as Editor, stdin_default as default };

package/components/editor/plugins/align.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatAlign: (value: string) => void;
+    }
+}
+export type FormatAlign = 'left' | 'center' | 'right' | 'justify';
+export declare function withAlign(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/align.js

@@ -0,0 +1,13 @@
+import { toggleBlockAttr } from '../utils.js';
+
+function formatAlign(editor, value) {
+  toggleBlockAttr(editor, "align", value);
+}
+function withAlign(editor) {
+  editor.formatAlign = (value) => {
+    formatAlign(editor, value);
+  };
+  return editor;
+}
+
+export { withAlign };

package/components/editor/plugins/background.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatBackground: (color?: string) => void;
+    }
+}
+export declare function withBackground(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/background.js

@@ -0,0 +1,19 @@
+import { Range, Editor } from 'slate-vue3/core';
+
+function formatBackground(editor, color) {
+  if (!editor.selection) return;
+  if (Range.isCollapsed(editor.selection)) return;
+  if (color) {
+    Editor.addMark(editor, "background", color);
+  } else {
+    Editor.removeMark(editor, "background");
+  }
+}
+function withBackground(editor) {
+  editor.formatBackground = (color) => {
+    formatBackground(editor, color);
+  };
+  return editor;
+}
+
+export { withBackground };

package/components/editor/plugins/block-quote.d.ts

@@ -0,0 +1,8 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatBlockQuote: () => void;
+        isBlockQuoteActive: () => boolean;
+    }
+}
+export declare function withBlockQuote(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/block-quote.js

@@ -0,0 +1,34 @@
+import { Element } from 'slate-vue3/core';
+import { isNormalBlock } from '../utils.js';
+
+function isBlockQuoteActive(editor) {
+  if (!editor.selection) return false;
+  const nodes = editor.nodes({
+    at: editor.edges(editor.selection)[0],
+    match: (n) => Element.isElement(n) && n.type === "block-quote"
+  });
+  return !nodes.next().done;
+}
+function formatBlockQuote(editor) {
+  if (!editor.selection) return;
+  const isActive = editor.isBlockQuoteActive();
+  editor.setNodes(
+    {
+      type: isActive ? "paragraph" : "block-quote"
+    },
+    {
+      match: isNormalBlock
+    }
+  );
+}
+function withBlockQuote(editor) {
+  editor.formatBlockQuote = () => {
+    formatBlockQuote(editor);
+  };
+  editor.isBlockQuoteActive = () => {
+    return isBlockQuoteActive(editor);
+  };
+  return editor;
+}
+
+export { withBlockQuote };

package/components/editor/plugins/clear.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        clearForamts: () => void;
+    }
+}
+export declare function withClear(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/clear.js

@@ -0,0 +1,53 @@
+import { Range, Text, Editor, Element, Point } from 'slate-vue3/core';
+
+const clearableElementProps = ["align", "indent"];
+function clearForamts(editor) {
+  if (!editor.selection) return;
+  if (Range.isCollapsed(editor.selection)) return;
+  const textNodes = Array.from(
+    editor.nodes({
+      at: editor.selection,
+      match: (n) => Text.isText(n)
+    })
+  );
+  Editor.withoutNormalizing(editor, () => {
+    textNodes.forEach(([node, path]) => {
+      const newProps = {};
+      Object.keys(node).forEach((key) => {
+        if (key !== "text") newProps[key] = void 0;
+      });
+      if (Object.keys(newProps).length > 0) {
+        editor.setNodes(newProps, { at: path });
+      }
+    });
+  });
+  const elementNodes = Array.from(
+    editor.nodes({
+      at: editor.selection,
+      match: (n) => Element.isElement(n)
+    })
+  );
+  elementNodes.forEach(([node, path]) => {
+    const [selectionStart, selectionEnd] = Range.edges(editor.selection);
+    const [elementStart, elementEnd] = Range.edges(Editor.range(editor, path));
+    if (Point.compare(selectionStart, elementStart) <= 0 && Point.compare(selectionEnd, elementEnd) >= 0) {
+      const newProps = {};
+      Object.keys(node).forEach((key) => {
+        if (clearableElementProps.includes(key)) {
+          newProps[key] = void 0;
+        }
+      });
+      if (Object.keys(newProps).length > 0) {
+        editor.setNodes(newProps, { at: path });
+      }
+    }
+  });
+}
+function withClear(editor) {
+  editor.clearForamts = () => {
+    clearForamts(editor);
+  };
+  return editor;
+}
+
+export { withClear };

package/components/editor/plugins/code-block.d.ts

@@ -0,0 +1,13 @@
+import { Editor, Node, Range } from 'slate-vue3/core';
+export declare const languageOptions: {
+    value: string;
+    label: string;
+}[];
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        decorate: (nodeList: Node[]) => Range[];
+        formatCodeBlock: () => void;
+        isCodeBlockActive: () => boolean;
+    }
+}
+export declare function withCodeBlock(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/code-block.js

@@ -0,0 +1,348 @@
+import Prism from 'prismjs';
+import { h } from 'vue';
+import { useInheritRef, toRawWeakMap } from 'slate-vue3';
+import { Range, Editor, Node, Text, Element, Path } from 'slate-vue3/core';
+import stdin_default from '../contents/content-code-block.js';
+import { Hotkeys } from './keyboard.js';
+import { isNormalBlock, isPointAtEndOfElement, getSortedRange, getRangePosition, RangePosition } from '../utils.js';
+
+const languageOptions = [
+  { value: "text", label: "PlainText" },
+  { value: "css", label: "CSS" },
+  { value: "less", label: "Less" },
+  { value: "scss", label: "Scss" },
+  { value: "html", label: "HTML" },
+  { value: "javascript", label: "JavaScript" },
+  { value: "jsx", label: "JSX" },
+  { value: "typescript", label: "TypeScript" },
+  { value: "tsx", label: "TSX" },
+  { value: "json", label: "JSON" },
+  { value: "markdown", label: "Markdown" },
+  { value: "php", label: "PHP" },
+  { value: "java", label: "Java" },
+  { value: "python", label: "Python" },
+  { value: "sql", label: "SQL" }
+];
+const newlineRe = /\r\n|\r|\n/;
+const normalizeEmptyLines = (line) => {
+  if (line.length === 0) {
+    line.push({
+      types: ["plain"],
+      content: "\n",
+      empty: true
+    });
+  } else if (line.length === 1 && line[0].content === "") {
+    line[0].content = "\n";
+    line[0].empty = true;
+  }
+};
+const appendTypes = (types, add) => {
+  const typesSize = types.length;
+  if (typesSize > 0 && types[typesSize - 1] === add) {
+    return types;
+  }
+  return types.concat(add);
+};
+const normalizeTokens = (tokens) => {
+  const typeArrStack = [[]];
+  const tokenArrStack = [tokens];
+  const tokenArrIndexStack = [0];
+  const tokenArrSizeStack = [tokens.length];
+  let i = 0;
+  let stackIndex = 0;
+  let currentLine = [];
+  const acc = [currentLine];
+  while (stackIndex > -1) {
+    while ((i = tokenArrIndexStack[stackIndex]++) < tokenArrSizeStack[stackIndex]) {
+      let content;
+      let types = typeArrStack[stackIndex];
+      const tokenArr = tokenArrStack[stackIndex];
+      const token = tokenArr[i];
+      if (typeof token === "string") {
+        types = stackIndex > 0 ? types : ["plain"];
+        content = token;
+      } else {
+        types = appendTypes(types, token.type);
+        if (token.alias) {
+          types = appendTypes(types, token.alias);
+        }
+        content = token.content;
+      }
+      if (typeof content !== "string") {
+        stackIndex++;
+        typeArrStack.push(types);
+        tokenArrStack.push(content);
+        tokenArrIndexStack.push(0);
+        tokenArrSizeStack.push(content.length);
+        continue;
+      }
+      const splitByNewlines = content.split(newlineRe);
+      const newlineCount = splitByNewlines.length;
+      currentLine.push({ types, content: splitByNewlines[0] });
+      for (let i2 = 1; i2 < newlineCount; i2++) {
+        normalizeEmptyLines(currentLine);
+        acc.push(currentLine = []);
+        currentLine.push({ types, content: splitByNewlines[i2] });
+      }
+    }
+    stackIndex--;
+    typeArrStack.pop();
+    tokenArrStack.pop();
+    tokenArrIndexStack.pop();
+    tokenArrSizeStack.pop();
+  }
+  normalizeEmptyLines(currentLine);
+  return acc;
+};
+function node2Decorations(editor) {
+  const decorationsMap = new toRawWeakMap();
+  const blockEntries = editor.nodes({
+    at: [],
+    mode: "highest",
+    match: isCodeBlock
+  });
+  Array.from(blockEntries).forEach(([block, blockPath]) => {
+    const text = block.children.map((line) => Node.string(line)).join("\n");
+    const tokens = Prism.tokenize(text, Prism.languages[block.language]);
+    normalizeTokens(tokens).forEach((tokens2, index) => {
+      const element = block.children[index];
+      if (!decorationsMap.has(element)) {
+        decorationsMap.set(element, []);
+      }
+      let start = 0;
+      tokens2.forEach((token) => {
+        const length = token.content.length;
+        if (!length) {
+          return;
+        }
+        const end = start + length;
+        const path = [...blockPath, index, 0];
+        const range = {
+          anchor: { path, offset: start },
+          focus: { path, offset: end },
+          token: true,
+          ...Object.fromEntries(token.types.map((type) => [type, true]))
+        };
+        decorationsMap.get(element).push(range);
+        start = end;
+      });
+    });
+  });
+  return decorationsMap;
+}
+function formatCodeBlock(editor) {
+  if (!editor.selection) return;
+  const isActive = editor.isCodeBlockActive();
+  if (isActive) {
+    editor.unwrapNodes({
+      match: isCodeBlock,
+      split: true
+    });
+    editor.setNodes(
+      {
+        type: "paragraph"
+      },
+      { match: isCodeLine }
+    );
+  } else {
+    editor.wrapNodes(
+      { type: "code-block", language: "plain", children: [] },
+      { match: isNormalBlock }
+    );
+    editor.setNodes({ type: "code-line" }, { match: isNormalBlock });
+  }
+}
+function decorate(editor, nodeList) {
+  const node = nodeList[0];
+  if (isCodeLine(node)) {
+    return node2Decorations(editor).get(node) || [];
+  }
+  return [];
+}
+function formatIndent(editor, value) {
+  const codeLineNodes = Array.from(
+    editor.nodes({
+      match: isCodeLine
+    })
+  );
+  function shouldInsert() {
+    const range = getSortedRange(editor.selection);
+    if (codeLineNodes.length === 1) {
+      const pos = getRangePosition(editor.range(codeLineNodes[0][1]), range);
+      return pos === RangePosition.CONTAIN || pos === RangePosition.AFTER_BEGIN || pos === RangePosition.BEFORE_END;
+    }
+    return false;
+  }
+  if (codeLineNodes.length > 0) {
+    const selection = editor.selection;
+    if (Range.isCollapsed(selection) || shouldInsert()) {
+      if (value === 1) {
+        Editor.insertText(editor, "  ");
+      }
+    } else {
+      codeLineNodes.forEach(([, path]) => {
+        const firstNode = Node.first(editor, path);
+        if (Text.isText(firstNode[0])) {
+          const text = firstNode[0].text;
+          if (value === 1) {
+            editor.insertText("  ", {
+              at: editor.start(firstNode[1])
+            });
+          } else {
+            const blankNum = Math.min(text.match(/^ +/)?.[0].length || 0, 2);
+            if (blankNum > 0) {
+              editor.delete({
+                at: {
+                  anchor: {
+                    path: firstNode[1],
+                    offset: 0
+                  },
+                  focus: {
+                    path: firstNode[1],
+                    offset: blankNum
+                  }
+                }
+              });
+            }
+          }
+        }
+      });
+    }
+  }
+}
+function onKeydown(editor, event) {
+  if (Hotkeys.isSoftBreak(event)) {
+    if (isPointAtEndOfElement(editor, "code-block", ([, path]) => {
+      editor.insertNodes(
+        {
+          type: "paragraph",
+          children: [{ text: "" }]
+        },
+        {
+          at: Path.next(path)
+        }
+      );
+      editor.move();
+    })) {
+      event.preventDefault();
+      return true;
+    }
+  }
+}
+function isCodeBlock(element) {
+  return Element.isElementType(element, "code-block");
+}
+function isCodeLine(element) {
+  return Element.isElementType(element, "code-line");
+}
+function normalizeCodeBlock(editor, entry) {
+  const [node, path] = entry;
+  if (!isCodeBlock(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!isCodeLine(childNode)) {
+      const text = editor.string(childPath);
+      editor.removeNodes({
+        at: childPath
+      });
+      editor.insertNodes(
+        {
+          type: "code-line",
+          children: [{ text }]
+        },
+        {
+          at: childPath
+        }
+      );
+      return true;
+    }
+  }
+}
+function normalizeCodeLine(editor, entry) {
+  const [node, path] = entry;
+  if (!isCodeLine(node)) return;
+  if (!isCodeBlock(Node.parent(editor, path))) {
+    editor.setNodes(
+      {
+        type: "paragraph"
+      },
+      {
+        at: path
+      }
+    );
+    return true;
+  }
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!Text.isText(childNode)) {
+      const text = editor.string(childPath);
+      editor.removeNodes({
+        at: childPath
+      });
+      editor.insertNodes(
+        {
+          text
+        },
+        {
+          at: childPath
+        }
+      );
+      return true;
+    }
+  }
+}
+function normalizeNode(editor, entry) {
+  return normalizeCodeBlock(editor, entry) || normalizeCodeLine(editor, entry);
+}
+function isCodeBlockActive(editor) {
+  if (!editor.selection) return false;
+  const nodes = editor.nodes({
+    at: editor.edges(editor.selection)[0],
+    match: isCodeBlock
+  });
+  return !nodes.next().done;
+}
+function withCodeBlock(editor) {
+  const {
+    renderElement,
+    formatIndent: srcFormatIndent,
+    onKeydown: srcOnKeydown,
+    normalizeNode: srcNormalizeNode
+  } = editor;
+  editor.decorate = (nodeList) => {
+    return decorate(editor, nodeList);
+  };
+  editor.formatCodeBlock = () => {
+    formatCodeBlock(editor);
+  };
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    if (element.type === "code-block") {
+      return h(stdin_default, useInheritRef(attributes), () => children);
+    }
+    if (element.type === "code-line") {
+      return h("div", { ...attributes, style: { position: "relative" } }, children);
+    }
+    return renderElement(props);
+  };
+  editor.formatIndent = (value) => {
+    formatIndent(editor, value);
+    return srcFormatIndent(value);
+  };
+  editor.onKeydown = (event) => {
+    if (!onKeydown(editor, event)) {
+      srcOnKeydown(event);
+    }
+  };
+  editor.normalizeNode = (entry, options) => {
+    if (!normalizeNode(editor, entry)) {
+      srcNormalizeNode(entry, options);
+    }
+  };
+  editor.isCodeBlockActive = () => {
+    return isCodeBlockActive(editor);
+  };
+  return editor;
+}
+
+export { languageOptions, withCodeBlock };

package/components/editor/plugins/color.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatColor: (color?: string) => void;
+    }
+}
+export declare function withColor(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/color.js

@@ -0,0 +1,21 @@
+import { Range, Editor } from 'slate-vue3/core';
+
+function formatColor(editor, color) {
+  if (!editor.selection) return;
+  if (Range.isCollapsed(editor.selection)) {
+    return;
+  }
+  if (color) {
+    Editor.addMark(editor, "color", color);
+  } else {
+    Editor.removeMark(editor, "color");
+  }
+}
+function withColor(editor) {
+  editor.formatColor = (color) => {
+    formatColor(editor, color);
+  };
+  return editor;
+}
+
+export { withColor };

package/components/editor/plugins/font.d.ts

@@ -0,0 +1,7 @@
+import { Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatFont: (value: string) => void;
+    }
+}
+export declare function withFont(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/font.js

@@ -0,0 +1,17 @@
+import { Range, Editor } from 'slate-vue3/core';
+
+function formatFont(editor, value) {
+  if (!editor.selection) return;
+  if (Range.isCollapsed(editor.selection)) {
+    return;
+  }
+  Editor.addMark(editor, "font", value);
+}
+function withFont(editor) {
+  editor.formatFont = (value) => {
+    formatFont(editor, value);
+  };
+  return editor;
+}
+
+export { withFont };

package/components/editor/plugins/formula.d.ts

@@ -0,0 +1,11 @@
+import { Editor } from 'slate-vue3/core';
+export declare const formulas: {
+    name: string;
+    formula: string;
+}[];
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        insertFormula: (value: string) => void;
+    }
+}
+export declare function withFormula(editor: Editor): import("../types").CustomEditor;

package/components/editor/{components/toolbar/formats → plugins}/formula.js

@@ -1,3 +1,8 @@
+import { h } from 'vue';
+import { useInheritRef } from 'slate-vue3';
+import stdin_default from '../contents/content-formula.js';
+import { isPointingAt, getPointingOptions } from '../utils.js';
+
 const formulas = [
   {
     name: "\u5085\u91CC\u53F6\u7EA7\u6570",
@@ -84,5 +89,49 @@ const formulas = [
     formula: "\\frac{{\\partial f}}{{\\partial l}} = \\frac{{\\partial f}}{{\\partial x}}\\cos \\phi  + \\frac{{\\partial f}}{{\\partial y}}\\sin \\phi"
   }
 ];
+function insertFormula(editor, value) {
+  if (!editor.selection) return;
+  if (isPointingAt(editor, "formula")) {
+    editor.setNodes(
+      {
+        formula: value
+      },
+      getPointingOptions(editor, "formula")
+    );
+  } else {
+    editor.insertNodes({
+      type: "formula",
+      formula: value,
+      children: [{ text: "" }]
+    });
+  }
+}
+function withFormula(editor) {
+  const { isInline, isVoid, renderElement } = editor;
+  editor.isInline = (element) => {
+    return element.type === "formula" ? true : isInline(element);
+  };
+  editor.isVoid = (element) => {
+    return element.type === "formula" ? true : isVoid(element);
+  };
+  editor.insertFormula = (value) => {
+    insertFormula(editor, value);
+  };
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    if (element.type === "formula") {
+      return h(
+        stdin_default,
+        {
+          ...useInheritRef(attributes),
+          formula: element.formula
+        },
+        () => children
+      );
+    }
+    return renderElement(props);
+  };
+  return editor;
+}
 
-export { formulas };
+export { formulas, withFormula };

package/components/editor/plugins/heading.d.ts

@@ -0,0 +1,9 @@
+import { Editor } from 'slate-vue3/core';
+import { type HeadingParagraphType } from '../types';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatHeading: (value: HeadingParagraphType) => void;
+        getActiveHeadingType: () => HeadingParagraphType;
+    }
+}
+export declare function withHeading(editor: Editor): import("../types").CustomEditor;