cosey 0.9.5 → 0.10.1

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

@@ -0,0 +1,155 @@
+import { Element, Path } from 'slate-vue3/core';
+import { getListTypeAtStartPoint, isList, isListItem } from './utils.js';
+import { isBlockElement } from '../../utils.js';
+
+const replaceableElements = [
+  "block",
+  "paragraph",
+  "block-quote",
+  "heading-one",
+  "heading-two",
+  "heading-three",
+  "heading-four",
+  "heading-five",
+  "heading-six"
+];
+function isSameParent(path, another) {
+  return Path.equals(Path.parent(path), Path.parent(another));
+}
+function findConsecutiveListItems(editor) {
+  const groups = [];
+  let currentGroup = [];
+  const nodes = Array.from(
+    editor.nodes({
+      match: (n) => isBlockElement(editor, n)
+    })
+  );
+  nodes.forEach(([node, path]) => {
+    if (isListItem(node) && !isList(editor.parent(path)[0])) {
+      if (currentGroup.length === 0 || isSameParent(currentGroup[0].path, path)) {
+        currentGroup.push({ node, path });
+      } else {
+        groups.push([...currentGroup]);
+        currentGroup = [{ node, path }];
+      }
+    } else {
+      if (currentGroup.length > 0) {
+        groups.push([...currentGroup]);
+        currentGroup = [];
+      }
+    }
+  });
+  if (currentGroup.length > 0) {
+    groups.push(currentGroup);
+  }
+  return groups;
+}
+function wrapListItems(editor, type) {
+  const [match] = editor.nodes({
+    match: (n, path) => isListItem(n) && !isList(editor.parent(path)[0])
+  });
+  if (!match) return;
+  const liGroups = findConsecutiveListItems(editor);
+  for (let i = liGroups.length - 1; i >= 0; i--) {
+    const group = liGroups[i];
+    if (group.length > 0) {
+      editor.wrapNodes(
+        {
+          type,
+          children: []
+        },
+        {
+          at: {
+            anchor: editor.start(group[0].path),
+            focus: editor.end(group[group.length - 1].path)
+          },
+          match: isListItem,
+          mode: "lowest",
+          voids: false
+        }
+      );
+    }
+  }
+}
+function getSameLevelSiblings(editor, [node, path]) {
+  const [parentNode, parentPath] = editor.parent(path);
+  const siblings = [[node, path]];
+  const currentIndex = path[path.length - 1];
+  for (let i = currentIndex - 1; i >= 0; i--) {
+    const childNode = parentNode.children[i];
+    if (childNode) {
+      if (childNode.level < node.level) {
+        break;
+      }
+      if (childNode.level === node.level) {
+        siblings.unshift([childNode, [...parentPath, i]]);
+      }
+    }
+  }
+  for (let i = currentIndex + 1; i < parentNode.children.length; i++) {
+    const childNode = parentNode.children[i];
+    if (childNode) {
+      if (childNode.level < node.level) {
+        break;
+      }
+      if (childNode.level === node.level) {
+        siblings.push([childNode, [...parentPath, i]]);
+      }
+    }
+  }
+  return siblings;
+}
+function formatList(editor, value) {
+  if (!editor.selection) return;
+  const listType = getListTypeAtStartPoint(editor);
+  if (listType === value) {
+    editor.unwrapNodes({
+      match: isList,
+      split: true
+    });
+    editor.setNodes(
+      {
+        type: "paragraph"
+      },
+      {
+        match: isListItem
+      }
+    );
+  } else {
+    const nodeEntries = Array.from(
+      editor.nodes({
+        match: isListItem
+      })
+    );
+    editor.withoutNormalizing(() => {
+      for (const nodeEntry of nodeEntries) {
+        const siblings = getSameLevelSiblings(editor, nodeEntry);
+        siblings.forEach(([siblingNode, siblingPath]) => {
+          if (siblingNode.listType !== value) {
+            editor.setNodes(
+              {
+                listType: value
+              },
+              {
+                at: siblingPath
+              }
+            );
+          }
+        });
+      }
+      editor.setNodes(
+        {
+          type: "list-item",
+          level: 0,
+          listType: value
+        },
+        {
+          match: (n) => Element.isElement(n) && replaceableElements.includes(n.type)
+        }
+      );
+      wrapListItems(editor, value);
+    });
+  }
+}
+
+export { formatList };

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

@@ -0,0 +1,2 @@
+import { Editor } from 'slate-vue3/core';
+export declare function formatIndent(editor: Editor, value: number): void;

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

@@ -0,0 +1,38 @@
+import { isListItem, LIST_MAX_LEVEL, isList } from './utils.js';
+
+function formatIndent(editor, value) {
+  const listItemNodes = Array.from(
+    editor.nodes({
+      match: isListItem
+    })
+  ).map(([node, path]) => [node, editor.pathRef(path)]);
+  for (const [node, path] of listItemNodes) {
+    const nextLevel = Math.min((node.level || 0) + value, LIST_MAX_LEVEL - 1);
+    if (nextLevel < 0) {
+      editor.unwrapNodes({
+        match: isList,
+        split: true,
+        at: path.current
+      });
+      editor.setNodes(
+        {
+          type: "paragraph"
+        },
+        {
+          at: path.unref()
+        }
+      );
+    } else if (node.level !== nextLevel) {
+      editor.setNodes(
+        {
+          level: nextLevel
+        },
+        {
+          at: path.unref()
+        }
+      );
+    }
+  }
+}
+
+export { formatIndent };

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

@@ -0,0 +1,10 @@
+import { Editor } from 'slate-vue3/core';
+import { ListItemElement, ListType } from '../../types';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        formatList: (value: ListType) => void;
+        isListItem: (element: unknown) => element is ListItemElement;
+        getListTypeAtStartPoint: () => ListType | undefined;
+    }
+}
+export declare function withList(editor: Editor): import("../../types").CustomEditor;

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

@@ -0,0 +1,61 @@
+import stdin_default from '../../contents/content-list-item.js';
+import { h } from 'vue';
+import { useInheritRef } from 'slate-vue3';
+import { normalizeNode } from './normalize.js';
+import { isListItem, getListTypeAtStartPoint } from './utils.js';
+import { formatList } from './format.js';
+import { formatIndent } from './indent.js';
+import { insertBreak } from './insert-break.js';
+
+function withList(editor) {
+  const {
+    insertBreak: srcInsertBreak,
+    renderElement,
+    formatIndent: srcFormatIndent,
+    normalizeNode: srcNormalizeNode
+  } = editor;
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    switch (element.type) {
+      case "bulleted-list":
+        return h("ul", attributes, children);
+      case "numbered-list":
+        return h("ol", attributes, children);
+      case "list-item":
+        return h(
+          stdin_default,
+          {
+            ...useInheritRef(attributes),
+            level: element.level,
+            listType: element.listType
+          },
+          () => children
+        );
+    }
+    return renderElement(props);
+  };
+  editor.formatIndent = (value) => {
+    formatIndent(editor, value);
+    srcFormatIndent(value);
+  };
+  editor.insertBreak = () => {
+    if (!insertBreak(editor)) {
+      srcInsertBreak();
+    }
+  };
+  editor.formatList = (value) => {
+    formatList(editor, value);
+  };
+  editor.isListItem = isListItem;
+  editor.normalizeNode = (entry, options) => {
+    if (!normalizeNode(editor, entry)) {
+      srcNormalizeNode(entry, options);
+    }
+  };
+  editor.getListTypeAtStartPoint = () => {
+    return getListTypeAtStartPoint(editor);
+  };
+  return editor;
+}
+
+export { withList };

package/components/editor/plugins/list/insert-break.d.ts

@@ -0,0 +1,2 @@
+import { Editor } from 'slate-vue3/core';
+export declare function insertBreak(editor: Editor): true | undefined;

package/components/editor/plugins/list/insert-break.js

@@ -0,0 +1,19 @@
+import { Editor } from 'slate-vue3/core';
+import { isListItem } from './utils.js';
+import { formatIndent } from './indent.js';
+
+function insertBreak(editor) {
+  const [match] = editor.nodes({
+    match: isListItem,
+    mode: "lowest"
+  });
+  if (match) {
+    const [node] = match;
+    if (Editor.isEmpty(editor, node)) {
+      formatIndent(editor, -1);
+      return true;
+    }
+  }
+}
+
+export { insertBreak };

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

@@ -0,0 +1,3 @@
+import { Editor, Node } from 'slate-vue3/core';
+import { type NodeEntry } from 'slate-vue3/core';
+export declare function normalizeNode(editor: Editor, entry: NodeEntry<Node>): true | undefined;

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

@@ -0,0 +1,168 @@
+import { Text, Node, Element } from 'slate-vue3/core';
+import { getPreviousSibling, getNextSibling } from '../../utils.js';
+import { isList, isListItem } from './utils.js';
+
+function mergeListWithPreviousSiblingList(editor, [node, path]) {
+  if (!isList(node)) return;
+  const previousSibling = editor.previous({
+    at: path
+  });
+  if (!previousSibling) return;
+  const [previousSiblingNode] = previousSibling;
+  if (!isList(previousSiblingNode)) return;
+  if (previousSiblingNode.type !== node.type) return;
+  editor.mergeNodes({
+    at: path
+  });
+  return true;
+}
+function getPreviousSameLevelSibling(editor, [node, path]) {
+  return getPreviousSibling(editor, path, {
+    quit(n) {
+      return isListItem(n) && n.level < node.level;
+    },
+    match(n) {
+      return isListItem(n) && n.level === node.level;
+    }
+  });
+}
+function getNextSameLevelSibling(editor, [node, path]) {
+  return getNextSibling(editor, path, {
+    quit(n) {
+      return isListItem(n) && n.level < node.level;
+    },
+    match(n) {
+      return isListItem(n) && n.level === node.level;
+    }
+  });
+}
+function keepSameWithSibling(editor, entry, sibling) {
+  const [node, path] = entry;
+  const [siblingNode] = sibling;
+  if (siblingNode.listType !== node.listType) {
+    editor.setNodes(
+      {
+        listType: siblingNode.listType
+      },
+      {
+        at: path
+      }
+    );
+    return true;
+  }
+}
+function normalizeSiblingLists(editor, entry) {
+  const normalized = mergeListWithPreviousSiblingList(editor, entry);
+  if (normalized) return true;
+  const [, path] = entry;
+  const nextSibling = editor.next({
+    at: path
+  });
+  if (nextSibling) {
+    return mergeListWithPreviousSiblingList(editor, nextSibling);
+  }
+}
+function normalizeSameTypeWithSibling(editor, entry) {
+  const [node] = entry;
+  if (!isListItem(node)) return;
+  const prevSibling = getPreviousSameLevelSibling(editor, entry);
+  if (prevSibling) {
+    const normalized = keepSameWithSibling(
+      editor,
+      entry,
+      prevSibling
+    );
+    if (normalized) return true;
+    const nextSibling = getNextSameLevelSibling(editor, entry);
+    if (nextSibling) {
+      return keepSameWithSibling(editor, nextSibling, entry);
+    }
+  } else {
+    const nextSibling = getNextSameLevelSibling(editor, entry);
+    if (nextSibling) {
+      return keepSameWithSibling(editor, entry, nextSibling);
+    }
+  }
+}
+function normalizeLisItemChildren(editor, [node, path]) {
+  if (!isListItem(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (Element.isElement(childNode) && !editor.isInline(childNode)) {
+      editor.unwrapNodes({
+        at: childPath
+      });
+      return true;
+    }
+  }
+}
+function normalizeLisItem(editor, entry) {
+  const [node, path] = entry;
+  if (!isListItem(node)) return;
+  if (!isList(Node.parent(editor, path))) {
+    editor.setNodes(
+      {
+        type: "paragraph"
+      },
+      {
+        at: path
+      }
+    );
+    return true;
+  }
+}
+function normalizeList(editor, [node, path]) {
+  if (!isList(node)) return;
+  for (let i = 0; i < node.children.length; i++) {
+    const childNode = node.children[i];
+    if (!isListItem(childNode)) {
+      if (Text.isText(childNode)) {
+        editor.wrapNodes(
+          {
+            type: "list-item",
+            level: 0,
+            listType: node.type,
+            children: []
+          },
+          {
+            at: [...path, i]
+          }
+        );
+        return true;
+      }
+      editor.setNodes(
+        {
+          type: "list-item",
+          level: 0,
+          listType: node.type
+        },
+        {
+          at: [...path, i]
+        }
+      );
+      return true;
+    }
+  }
+  const topLevelChildNodes = node.children.filter(
+    (item) => isListItem(item) && item.level === 0
+  );
+  if (topLevelChildNodes.length > 0) {
+    const listType = topLevelChildNodes[0].listType;
+    if (listType !== node.type) {
+      editor.setNodes(
+        {
+          type: listType
+        },
+        {
+          at: path
+        }
+      );
+      return true;
+    }
+  }
+}
+function normalizeNode(editor, entry) {
+  return normalizeList(editor, entry) || normalizeSiblingLists(editor, entry) || normalizeLisItem(editor, entry) || normalizeSameTypeWithSibling(editor, entry) || normalizeLisItemChildren(editor, entry);
+}
+
+export { normalizeNode };

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

@@ -0,0 +1,3 @@
+import { Node } from 'slate-vue3/core';
+import { BulletedListElement, NumberedListElement } from '../../types';
+export declare function serializeList(node: BulletedListElement | NumberedListElement, serialize: (node: Node) => string): string;

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

@@ -0,0 +1,63 @@
+function findSameLevelListType(items, index, level) {
+  for (let i = index; i < items.length; i++) {
+    const item = items[i];
+    if (item.level === level) {
+      return `nested-${items[i].listType}`;
+    }
+    if (item.level < level) {
+      return "nested-bulleted-list";
+    }
+  }
+  return "nested-bulleted-list";
+}
+function serializeList(node, serialize) {
+  const rootListItem = {
+    type: "nested-list-item",
+    children: [],
+    parent: null
+  };
+  let currentList = null;
+  let prevLevel = -1;
+  let prevListItem = rootListItem;
+  node.children.forEach((childNode, index) => {
+    const level = childNode.level;
+    let diffLevel = level - prevLevel;
+    if (diffLevel > 0) {
+      while (--diffLevel) {
+        currentList = {
+          type: findSameLevelListType(node.children, index, level - diffLevel),
+          children: [],
+          parent: prevListItem
+        };
+        prevListItem.children.push(currentList);
+        prevListItem = {
+          type: "nested-list-item",
+          children: [{ text: "" }],
+          parent: currentList
+        };
+        currentList.children.push(prevListItem);
+      }
+      currentList = {
+        type: `nested-${childNode.listType}`,
+        children: [],
+        parent: prevListItem
+      };
+      prevListItem.children.push(currentList);
+    } else if (diffLevel < 0) {
+      while (diffLevel++) {
+        currentList = currentList.parent.parent;
+      }
+    }
+    const listItemNode = {
+      type: "nested-list-item",
+      children: [...childNode.children],
+      parent: currentList
+    };
+    currentList.children.push(listItemNode);
+    prevListItem = listItemNode;
+    prevLevel = level;
+  });
+  return serialize(rootListItem.children[0]);
+}
+
+export { serializeList };

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

@@ -0,0 +1,6 @@
+import { Editor } from 'slate-vue3/core';
+import { BulletedListElement, ListItemElement, ListType, NumberedListElement } from '../../types';
+export declare const LIST_MAX_LEVEL = 6;
+export declare function isListItem(element: unknown): element is ListItemElement;
+export declare function isList(element: unknown): element is BulletedListElement | NumberedListElement;
+export declare function getListTypeAtStartPoint(editor: Editor): ListType | undefined;

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

@@ -0,0 +1,24 @@
+import { Element } from 'slate-vue3/core';
+
+const LIST_MAX_LEVEL = 6;
+function isListItem(element) {
+  return Element.isElementType(element, "list-item");
+}
+function isList(element) {
+  return Element.isElement(element) && (element.type === "numbered-list" || element.type === "bulleted-list");
+}
+function getListTypeAtStartPoint(editor) {
+  if (!editor.selection) return;
+  const [start] = editor.edges(editor.selection);
+  const [entry] = Array.from(
+    editor.nodes({
+      at: start,
+      match: isListItem
+    })
+  );
+  if (entry) {
+    return entry[0].listType;
+  }
+}
+
+export { LIST_MAX_LEVEL, getListTypeAtStartPoint, isList, isListItem };

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

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

package/components/editor/plugins/mark.js

@@ -0,0 +1,27 @@
+import { Range, Editor } from 'slate-vue3/core';
+
+function formatMark(editor, mark) {
+  if (!editor.selection) return;
+  if (Range.isCollapsed(editor.selection)) {
+    return;
+  }
+  const marks = Editor.marks(editor);
+  if ("superscript" in marks && mark === "subscript") {
+    Editor.removeMark(editor, "superscript");
+  } else if ("subscript" in marks && mark === "superscript") {
+    Editor.removeMark(editor, "subscript");
+  }
+  if (marks[mark]) {
+    Editor.removeMark(editor, mark);
+  } else {
+    Editor.addMark(editor, mark, true);
+  }
+}
+function withMark(editor) {
+  editor.formatMark = (mark) => {
+    formatMark(editor, mark);
+  };
+  return editor;
+}
+
+export { withMark };

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

@@ -0,0 +1,11 @@
+import { VNode } from 'vue';
+import { type RenderElementProps, type RenderLeafProps } from 'slate-vue3';
+import { Editor } from 'slate-vue3/core';
+export declare const INDENT_DELTA = 40;
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        renderElement: (props: RenderElementProps) => VNode;
+        renderLeaf: (props: RenderLeafProps) => VNode;
+    }
+}
+export declare function withRender(editor: Editor): import("../types").CustomEditor;

package/components/editor/plugins/render.js

@@ -0,0 +1,54 @@
+import { h } from 'vue';
+import { mapElementTypeTagName } from '../types.js';
+
+const INDENT_DELTA = 40;
+const renderElement = ({ attributes: attrs, children, element }) => {
+  const attributes = {
+    ...attrs,
+    style: {
+      textAlign: "align" in element ? element.align : void 0,
+      paddingLeft: "indent" in element && element.indent ? element.indent * INDENT_DELTA + "px" : ""
+    }
+  };
+  const tagName = mapElementTypeTagName[element.type] || mapElementTypeTagName.paragraph;
+  return h(tagName, attributes, children);
+};
+const renderLeaf = ({ leaf, attributes, children }) => {
+  const {
+    text,
+    bold,
+    italic,
+    underline,
+    strikethrough,
+    code,
+    superscript,
+    subscript,
+    font,
+    size,
+    color,
+    background,
+    ...rest
+  } = leaf;
+  const style = {
+    fontWeight: bold ? "bold" : void 0,
+    fontStyle: italic ? "italic" : void 0,
+    borderBottom: underline ? "1px solid black" : void 0,
+    textDecoration: strikethrough ? "line-through" : void 0,
+    fontFamily: font ? font : void 0,
+    fontSize: size ? size : void 0,
+    color: color ? color : void 0,
+    background: background ? background : void 0
+  };
+  return h(
+    code ? "code" : superscript ? "sup" : subscript ? "sub" : "span",
+    { ...attributes, style, class: Object.keys(rest).join(" ") },
+    children
+  );
+};
+function withRender(editor) {
+  editor.renderLeaf = renderLeaf;
+  editor.renderElement = renderElement;
+  return editor;
+}
+
+export { INDENT_DELTA, withRender };

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

@@ -0,0 +1,10 @@
+import { Descendant, Editor } from 'slate-vue3/core';
+declare module 'slate-vue3/core' {
+    interface BaseEditor {
+        serialize: () => string;
+        deserialize: (html: string) => Descendant[];
+        setContent: (html: string) => void;
+        getContent: () => string;
+    }
+}
+export declare function withSerialize(editor: Editor): import("../types").CustomEditor;