cosey 0.9.5 → 0.10.1

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;

package/components/editor/plugins/heading.js

@@ -0,0 +1,70 @@
+import { Editor, Path } from 'slate-vue3/core';
+import { isNormalBlock, isHeading } from '../utils.js';
+
+function getActiveHeadingType(editor) {
+  if (!editor.selection) return "paragraph";
+  const nodes = editor.nodes({
+    at: editor.edges(editor.selection)[0],
+    match: isHeading
+  });
+  const { done, value } = nodes.next();
+  return done ? "paragraph" : value[0].type;
+}
+function formatHeading(editor, value) {
+  if (!editor.selection) return;
+  const activeType = getActiveHeadingType(editor);
+  if (activeType === value) {
+    editor.setNodes(
+      {
+        type: "paragraph"
+      },
+      { match: isNormalBlock }
+    );
+  } else {
+    editor.setNodes(
+      {
+        type: value
+      },
+      { match: isNormalBlock }
+    );
+  }
+}
+function insertBreak(editor) {
+  const [match] = editor.nodes({
+    match: isHeading
+  });
+  if (match) {
+    const [, path] = match;
+    const isAtEnd = Editor.isEnd(editor, editor.selection.focus, path);
+    if (isAtEnd) {
+      editor.insertNodes(
+        {
+          type: "paragraph",
+          children: [{ text: "" }]
+        },
+        {
+          at: Path.next(path)
+        }
+      );
+      editor.select(Path.next(path));
+      return true;
+    }
+  }
+}
+function withHeading(editor) {
+  const { insertBreak: srcInsertBreak } = editor;
+  editor.formatHeading = (value) => {
+    formatHeading(editor, value);
+  };
+  editor.insertBreak = () => {
+    if (!insertBreak(editor)) {
+      srcInsertBreak();
+    }
+  };
+  editor.getActiveHeadingType = () => {
+    return getActiveHeadingType(editor);
+  };
+  return editor;
+}
+
+export { withHeading };

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

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

package/components/editor/plugins/html.js

@@ -0,0 +1,30 @@
+function isTransferCode(data) {
+  for (const type of data.types) {
+    if (type === "text/rtf" || type.includes("code") || type.includes("editor")) {
+      return true;
+    }
+  }
+}
+function insertData(editor, data) {
+  if (editor.insertFragmentData(data)) {
+    return true;
+  }
+  if (isTransferCode(data)) return;
+  const html = data.getData("text/html");
+  if (html) {
+    const fragment = editor.deserialize(html);
+    editor.insertFragment(fragment);
+    return true;
+  }
+}
+function withHtml(editor) {
+  const { insertData: srcInsertData } = editor;
+  editor.insertData = (data) => {
+    if (!insertData(editor, data)) {
+      srcInsertData(data);
+    }
+  };
+  return editor;
+}
+
+export { withHtml };

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

@@ -0,0 +1,8 @@
+import { Editor } from 'slate-vue3/core';
+import type { CustomEditor } from '../types';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        insertImage: (url: string, file?: File, width?: number | string, height?: number | string) => void;
+    }
+}
+export declare function withImage(editor: Editor): CustomEditor;

package/components/editor/plugins/image.js

@@ -0,0 +1,63 @@
+import { useInheritRef } from 'slate-vue3';
+import { h } from 'vue';
+import stdin_default from '../contents/content-image.js';
+import { isImageUrl } from '../../../utils/file.js';
+
+const insertImage = (editor, url, file, width, height) => {
+  const image = { type: "image", url, width, height, file, children: [{ text: "" }] };
+  editor.insertNodes(image);
+  editor.move();
+};
+function insertData(editor, data) {
+  const text = data.getData("text/plain");
+  const { files } = data;
+  if (files.length > 0) {
+    Array.from(files).forEach((file) => {
+      const [mime] = file.type.split("/");
+      if (mime === "image") {
+        insertImage(editor, "", file);
+      }
+    });
+    return true;
+  } else if (isImageUrl(text)) {
+    insertImage(editor, text);
+    return true;
+  }
+}
+function withImage(editor) {
+  const { isInline, isVoid, renderElement, insertData: srcInsertData } = editor;
+  editor.isInline = (element) => {
+    return element.type === "image" ? true : isInline(element);
+  };
+  editor.isVoid = (element) => {
+    return element.type === "image" ? true : isVoid(element);
+  };
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    if (element.type === "image") {
+      return h(
+        stdin_default,
+        {
+          ...useInheritRef(attributes),
+          url: element.url,
+          width: element.width,
+          height: element.height,
+          file: element.file
+        },
+        () => children
+      );
+    }
+    return renderElement(props);
+  };
+  editor.insertData = (data) => {
+    if (!insertData(editor, data)) {
+      srcInsertData(data);
+    }
+  };
+  editor.insertImage = (url, file, width, height) => {
+    insertImage(editor, url, file, width, height);
+  };
+  return editor;
+}
+
+export { withImage };

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

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

package/components/editor/plugins/indent.js

@@ -0,0 +1,47 @@
+import { Element } from 'slate-vue3/core';
+
+const indentableElements = [
+  "paragraph",
+  "heading-one",
+  "heading-two",
+  "heading-three",
+  "heading-four",
+  "heading-five",
+  "heading-six",
+  "block-quote"
+];
+function formatIndent(editor, value) {
+  if (!editor.selection) return;
+  const nodeEntries = [
+    ...editor.nodes({
+      match(node) {
+        return Element.isElement(node) && indentableElements.includes(node.type);
+      }
+    })
+  ];
+  for (const entry of nodeEntries) {
+    const element = entry[0];
+    const path = entry[1];
+    let indent = "indent" in element ? element.indent || 0 : 0;
+    indent += value;
+    if (indent < 0) {
+      indent = 0;
+    }
+    editor.setNodes(
+      {
+        indent
+      },
+      {
+        at: path
+      }
+    );
+  }
+}
+function withIndent(editor) {
+  editor.formatIndent = (value) => {
+    formatIndent(editor, value);
+  };
+  return editor;
+}
+
+export { withIndent };

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

@@ -0,0 +1,2 @@
+import { Editor } from 'slate-vue3/core';
+export declare function withDefaultPlugins(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/index.js

@@ -0,0 +1,50 @@
+import { withKeyboard } from './keyboard.js';
+import { withList } from './list/index.js';
+import { withHeading } from './heading.js';
+import { withFont } from './font.js';
+import { withColor } from './color.js';
+import { withBackground } from './background.js';
+import { withSize } from './size.js';
+import { withIndent } from './indent.js';
+import { withMark } from './mark.js';
+import { withBlockQuote } from './block-quote.js';
+import { withAlign } from './align.js';
+import { withClear } from './clear.js';
+import { withSerialize } from './serialize.js';
+import { withRender } from './render.js';
+import { withLink } from './link.js';
+import { withCodeBlock } from './code-block.js';
+import { withImage } from './image.js';
+import { withVideo } from './video.js';
+import { withHtml } from './html.js';
+import { withTable } from './table.js';
+import { withFormula } from './formula.js';
+
+const plugins = [
+  withKeyboard,
+  withRender,
+  withIndent,
+  withHtml,
+  withList,
+  withHeading,
+  withFont,
+  withColor,
+  withBackground,
+  withSize,
+  withMark,
+  withBlockQuote,
+  withAlign,
+  withClear,
+  withSerialize,
+  withLink,
+  withCodeBlock,
+  withImage,
+  withVideo,
+  withTable,
+  withFormula
+];
+function withDefaultPlugins(editor) {
+  return plugins.reduce((editor2, plugin) => plugin(editor2), editor);
+}
+
+export { withDefaultPlugins };

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

@@ -0,0 +1,41 @@
+import { Editor } from 'slate-vue3/core';
+/**
+ * Hotkeys.
+ */
+export declare const Hotkeys: {
+    isBold: (event: KeyboardEvent) => boolean;
+    isCompose: (event: KeyboardEvent) => boolean;
+    isMoveBackward: (event: KeyboardEvent) => boolean;
+    isMoveForward: (event: KeyboardEvent) => boolean;
+    isMoveUp: (event: KeyboardEvent) => boolean;
+    isMoveDown: (event: KeyboardEvent) => boolean;
+    isDeleteBackward: (event: KeyboardEvent) => boolean;
+    isDeleteForward: (event: KeyboardEvent) => boolean;
+    isDeleteLineBackward: (event: KeyboardEvent) => boolean;
+    isDeleteLineForward: (event: KeyboardEvent) => boolean;
+    isDeleteWordBackward: (event: KeyboardEvent) => boolean;
+    isDeleteWordForward: (event: KeyboardEvent) => boolean;
+    isExtendBackward: (event: KeyboardEvent) => boolean;
+    isExtendForward: (event: KeyboardEvent) => boolean;
+    isExtendLineBackward: (event: KeyboardEvent) => boolean;
+    isExtendLineForward: (event: KeyboardEvent) => boolean;
+    isItalic: (event: KeyboardEvent) => boolean;
+    isMoveLineBackward: (event: KeyboardEvent) => boolean;
+    isMoveLineForward: (event: KeyboardEvent) => boolean;
+    isMoveWordBackward: (event: KeyboardEvent) => boolean;
+    isMoveWordForward: (event: KeyboardEvent) => boolean;
+    isRedo: (event: KeyboardEvent) => boolean;
+    isSoftBreak: (event: KeyboardEvent) => boolean;
+    isSplitBlock: (event: KeyboardEvent) => boolean;
+    isTransposeCharacter: (event: KeyboardEvent) => boolean;
+    isUndo: (event: KeyboardEvent) => boolean;
+    isUnderline: (event: KeyboardEvent) => boolean;
+    isIndent: (event: KeyboardEvent) => boolean;
+    isOutdent: (event: KeyboardEvent) => boolean;
+};
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        onKeydown: (event: KeyboardEvent) => void;
+    }
+}
+export declare function withKeyboard(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/keyboard.js

@@ -0,0 +1,120 @@
+import { isHotkey } from 'is-hotkey';
+import { IS_APPLE } from '../../../utils/browser.js';
+
+const HOTKEYS = {
+  bold: "mod+b",
+  compose: ["down", "left", "right", "up", "backspace", "enter"],
+  moveBackward: "left",
+  moveForward: "right",
+  moveUp: "up",
+  moveDown: "down",
+  moveWordBackward: "ctrl+left",
+  moveWordForward: "ctrl+right",
+  deleteBackward: "shift?+backspace",
+  deleteForward: "shift?+delete",
+  extendBackward: "shift+left",
+  extendForward: "shift+right",
+  italic: "mod+i",
+  insertSoftBreak: "shift+enter",
+  splitBlock: "enter",
+  undo: "mod+z",
+  underline: "mod+u",
+  indent: "tab",
+  outdent: "shift+tab"
+};
+const APPLE_HOTKEYS = {
+  moveLineBackward: "opt+up",
+  moveLineForward: "opt+down",
+  moveWordBackward: "opt+left",
+  moveWordForward: "opt+right",
+  deleteBackward: ["ctrl+backspace", "ctrl+h"],
+  deleteForward: ["ctrl+delete", "ctrl+d"],
+  deleteLineBackward: "cmd+shift?+backspace",
+  deleteLineForward: ["cmd+shift?+delete", "ctrl+k"],
+  deleteWordBackward: "opt+shift?+backspace",
+  deleteWordForward: "opt+shift?+delete",
+  extendLineBackward: "opt+shift+up",
+  extendLineForward: "opt+shift+down",
+  redo: "cmd+shift+z",
+  transposeCharacter: "ctrl+t"
+};
+const WINDOWS_HOTKEYS = {
+  deleteWordBackward: "ctrl+shift?+backspace",
+  deleteWordForward: "ctrl+shift?+delete",
+  redo: ["ctrl+y", "ctrl+shift+z"]
+};
+const create = (key) => {
+  const generic = HOTKEYS[key];
+  const apple = APPLE_HOTKEYS[key];
+  const windows = WINDOWS_HOTKEYS[key];
+  const isGeneric = generic && isHotkey(generic);
+  const isApple = apple && isHotkey(apple);
+  const isWindows = windows && isHotkey(windows);
+  return (event) => {
+    if (isGeneric && isGeneric(event)) return true;
+    if (IS_APPLE && isApple && isApple(event)) return true;
+    if (!IS_APPLE && isWindows && isWindows(event)) return true;
+    return false;
+  };
+};
+const Hotkeys = {
+  isBold: create("bold"),
+  isCompose: create("compose"),
+  isMoveBackward: create("moveBackward"),
+  isMoveForward: create("moveForward"),
+  isMoveUp: create("moveUp"),
+  isMoveDown: create("moveDown"),
+  isDeleteBackward: create("deleteBackward"),
+  isDeleteForward: create("deleteForward"),
+  isDeleteLineBackward: create("deleteLineBackward"),
+  isDeleteLineForward: create("deleteLineForward"),
+  isDeleteWordBackward: create("deleteWordBackward"),
+  isDeleteWordForward: create("deleteWordForward"),
+  isExtendBackward: create("extendBackward"),
+  isExtendForward: create("extendForward"),
+  isExtendLineBackward: create("extendLineBackward"),
+  isExtendLineForward: create("extendLineForward"),
+  isItalic: create("italic"),
+  isMoveLineBackward: create("moveLineBackward"),
+  isMoveLineForward: create("moveLineForward"),
+  isMoveWordBackward: create("moveWordBackward"),
+  isMoveWordForward: create("moveWordForward"),
+  isRedo: create("redo"),
+  isSoftBreak: create("insertSoftBreak"),
+  isSplitBlock: create("splitBlock"),
+  isTransposeCharacter: create("transposeCharacter"),
+  isUndo: create("undo"),
+  isUnderline: create("underline"),
+  isIndent: create("indent"),
+  isOutdent: create("outdent")
+};
+function onKeydown(editor, event) {
+  if (Hotkeys.isBold(event)) {
+    event.preventDefault();
+    return editor.formatMark("bold");
+  }
+  if (Hotkeys.isItalic(event)) {
+    event.preventDefault();
+    return editor.formatMark("italic");
+  }
+  if (Hotkeys.isUnderline(event)) {
+    event.preventDefault();
+    return editor.formatMark("underline");
+  }
+  if (Hotkeys.isIndent(event)) {
+    event.preventDefault();
+    return editor.formatIndent(1);
+  }
+  if (Hotkeys.isOutdent(event)) {
+    event.preventDefault();
+    return editor.formatIndent(-1);
+  }
+}
+function withKeyboard(editor) {
+  editor.onKeydown = (event) => {
+    onKeydown(editor, event);
+  };
+  return editor;
+}
+
+export { Hotkeys, withKeyboard };

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

@@ -0,0 +1,8 @@
+import { Editor, Location } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatLink: (url: string, target: string, text: string) => void;
+        unwrapLink: (at?: Location) => void;
+    }
+}
+export declare function withLink(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/link.js

@@ -0,0 +1,56 @@
+import { Element } from 'slate-vue3/core';
+import { useInheritRef } from 'slate-vue3';
+import { h } from 'vue';
+import stdin_default from '../contents/content-link.js';
+
+function unwrapLink(editor, at) {
+  editor.unwrapNodes({
+    match: (n) => Element.isElement(n) && n.type === "link",
+    at
+  });
+}
+function wrapLink(editor, url, target, text) {
+  const link = {
+    type: "link",
+    url,
+    target,
+    children: [{ text }]
+  };
+  editor.delete();
+  editor.insertNodes(link);
+}
+function formatLink(editor, url, target, text) {
+  unwrapLink(editor);
+  wrapLink(editor, url, target, text);
+}
+function withLink(editor) {
+  const { isInline, renderElement } = editor;
+  editor.isInline = (element) => {
+    return element.type === "link" ? true : isInline(element);
+  };
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    if (element.type === "link") {
+      return h(
+        stdin_default,
+        {
+          ...useInheritRef(attributes),
+          url: element.url,
+          target: element.target,
+          element
+        },
+        () => children
+      );
+    }
+    return renderElement(props);
+  };
+  editor.formatLink = (url, target, text) => {
+    formatLink(editor, url, target, text);
+  };
+  editor.unwrapLink = (at) => {
+    unwrapLink(editor, at);
+  };
+  return editor;
+}
+
+export { withLink };

package/components/editor/plugins/list/deserialize.d.ts

@@ -0,0 +1,3 @@
+import { Descendant } from 'slate-vue3/core';
+import { BulletedListElement, NumberedListElement } from '../../types';
+export declare function deserializeList(node: HTMLUListElement | HTMLOListElement, deserialize: (node: Node, markAttributes?: {}) => Descendant | null | Descendant[]): BulletedListElement | NumberedListElement;

package/components/editor/plugins/list/deserialize.js

@@ -0,0 +1,106 @@
+import { tagToElementTypeMap } from '../../types.js';
+import { LIST_MAX_LEVEL } from './utils.js';
+import { toArray } from '../../../../utils/array.js';
+
+function deserializeListItemLike(node, deserialize) {
+  const textChildren = [];
+  const listChildren = [];
+  let listType = "";
+  for (const childNode of node.childNodes) {
+    if (childNode instanceof HTMLUListElement || childNode instanceof HTMLOListElement) {
+      if (!listType) {
+        listType = tagToElementTypeMap[childNode.tagName];
+      }
+      listChildren.push(...deserializeListLike(childNode, deserialize).children);
+    } else {
+      const result = deserialize(childNode);
+      if (Array.isArray(result)) {
+        textChildren.push(...result);
+      } else if (result) {
+        textChildren.push(result);
+      }
+    }
+  }
+  if (textChildren.length === 0) {
+    textChildren.push({ text: "" });
+  }
+  const children = [
+    {
+      type: "list-item-text-like",
+      children: textChildren
+    }
+  ];
+  if (listChildren.length > 0) {
+    children[1] = {
+      type: "list-like",
+      subType: listType,
+      children: listChildren
+    };
+  }
+  return {
+    type: "list-item-like",
+    children
+  };
+}
+function deserializeListLike(node, deserialize) {
+  const children = [];
+  for (const childNode of node.childNodes) {
+    if (childNode instanceof HTMLLIElement) {
+      children.push(deserializeListItemLike(childNode, deserialize));
+    } else if (childNode instanceof HTMLUListElement || childNode instanceof HTMLOListElement) {
+      children.push({
+        type: "list-item-like",
+        children: [
+          {
+            type: "list-item-text-like",
+            children: [{ text: "" }]
+          },
+          deserializeListLike(childNode, deserialize)
+        ]
+      });
+    } else {
+      const result = deserialize(childNode);
+      if (result) {
+        children.push({
+          type: "list-item-like",
+          children: [
+            {
+              type: "list-item-text-like",
+              children: toArray(result)
+            }
+          ]
+        });
+      }
+    }
+  }
+  return {
+    type: "list-like",
+    subType: tagToElementTypeMap[node.tagName],
+    children
+  };
+}
+function flatList(list, level = 0) {
+  return list.children.map(({ children: [text, subList] }) => {
+    const item = [
+      {
+        type: "list-item",
+        listType: list.subType,
+        level: Math.min(level, LIST_MAX_LEVEL - 1),
+        children: text.children
+      }
+    ];
+    if (subList) {
+      item.push(...flatList(subList, level + 1));
+    }
+    return item;
+  }).flat(1);
+}
+function deserializeList(node, deserialize) {
+  const listLike = deserializeListLike(node, deserialize);
+  return {
+    type: tagToElementTypeMap[node.tagName],
+    children: flatList(listLike)
+  };
+}
+
+export { deserializeList };

package/components/editor/plugins/list/format.d.ts

@@ -0,0 +1,3 @@
+import { Editor } from 'slate-vue3/core';
+import { type ListType } from '../../types';
+export declare function formatList(editor: Editor, value: ListType): void;