cosey 0.9.5 → 0.10.1

package/components/editor/plugins/table.js

@@ -0,0 +1,702 @@
+import { h } from 'vue';
+import { Range, Editor, Point, Path, Element, Node } from 'slate-vue3/core';
+import { isBlockElement, isPointAtLastLine, isPointAtFirstLine, isEdgesEqual } from '../utils.js';
+import { Hotkeys } from './keyboard.js';
+import stdin_default from '../contents/content-table.js';
+import { DOMEditor } from 'slate-vue3/dom';
+import { useInheritRef } from 'slate-vue3';
+
+function isTable(node) {
+  return Element.isElementType(node, "table");
+}
+function isTableHead(node) {
+  return Element.isElementType(node, "table-head");
+}
+function isTableBody(node) {
+  return Element.isElementType(node, "table-body");
+}
+function isTableRow(node) {
+  return Element.isElementType(node, "table-row");
+}
+function isTableCell(node) {
+  return Element.isElementType(node, "table-cell");
+}
+function createTableCell() {
+  return {
+    type: "table-cell",
+    children: [{ text: "" }]
+  };
+}
+function createTableRow(cellCount) {
+  return {
+    type: "table-row",
+    children: Array(cellCount).fill(0).map(createTableCell)
+  };
+}
+function insertTable(editor, rowCount, columnCount) {
+  if (!editor.selection) return;
+  const generator = editor.nodes({
+    at: editor.selection,
+    mode: "lowest",
+    match(n, path) {
+      return isBlockElement(editor, n) && isEdgesEqual(editor.edges(path), editor.edges(editor.selection));
+    }
+  });
+  const { done, value } = generator.next();
+  const shouldRemoveNode = !done;
+  const table = {
+    type: "table",
+    children: [
+      {
+        type: "table-body",
+        children: Array(rowCount).fill(0).map(() => createTableRow(columnCount))
+      }
+    ]
+  };
+  const nodes = [table];
+  const after = editor.after(editor.selection);
+  if (!after) {
+    nodes.push({
+      type: "paragraph",
+      children: [{ text: "" }]
+    });
+  }
+  editor.insertNodes(nodes);
+  if (shouldRemoveNode) {
+    editor.removeNodes({
+      at: value[1]
+    });
+  }
+}
+function insertRow(editor, _tablePath, cellPath, isNext) {
+  const rowPath = Path.parent(cellPath);
+  const rowNode = editor.node(rowPath)[0];
+  const columns = rowNode.children.length;
+  editor.insertNodes(createTableRow(columns), {
+    at: isNext ? Path.next(rowPath) : rowPath
+  });
+}
+function insertRowAbove(editor, tablePath, cellPath) {
+  insertRow(editor, tablePath, cellPath);
+}
+function insertRowBelow(editor, tablePath, cellPath) {
+  insertRow(editor, tablePath, cellPath, true);
+}
+function insertColumn(editor, tablePath, cellPath, isNext) {
+  const tableNode = editor.node(tablePath)[0];
+  const bodyIndex = tableNode.children.findIndex(isTableBody);
+  const headIndex = tableNode.children.findIndex(isTableHead);
+  const cellIndex = cellPath[cellPath.length - 1] + (isNext ? 1 : 0);
+  function insertNodes(node) {
+    node.children.forEach((row) => {
+      const rowPath = DOMEditor.findPath(editor, row);
+      editor.insertNodes(createTableCell(), {
+        at: [...rowPath, cellIndex]
+      });
+    });
+  }
+  if (bodyIndex !== -1) {
+    const bodyPath = [...tablePath, bodyIndex];
+    const bodyNode = editor.node(bodyPath)[0];
+    insertNodes(bodyNode);
+  }
+  if (headIndex !== -1) {
+    const headPath = [...tablePath, headIndex];
+    const headNode = editor.node(headPath)[0];
+    insertNodes(headNode);
+  }
+}
+function insertColumnLeft(editor, tablePath, cellPath) {
+  insertColumn(editor, tablePath, cellPath);
+}
+function insertColumnRight(editor, tablePath, cellPath) {
+  insertColumn(editor, tablePath, cellPath, true);
+}
+function deleteRow(editor, tablePath, cellPath) {
+  const rowPath = Path.parent(cellPath);
+  editor.removeNodes({
+    at: rowPath
+  });
+  const tableNode = editor.node(tablePath)[0];
+  const bodyIndex = tableNode.children.findIndex(isTableBody);
+  if (bodyIndex !== -1) {
+    const bodyPath = [...tablePath, bodyIndex];
+    const bodyNode = editor.node(bodyPath)[0];
+    if (!bodyNode.children.find(isTableRow)) {
+      editor.removeNodes({
+        at: bodyPath
+      });
+    }
+  }
+  const headIndex = tableNode.children.findIndex(isTableHead);
+  if (headIndex !== -1) {
+    const headPath = [...tablePath, headIndex];
+    const headNode = editor.node(headPath)[0];
+    if (!headNode.children.find(isTableRow)) {
+      editor.removeNodes({
+        at: headPath
+      });
+    }
+  }
+  if (!tableNode.children.find((node) => isTableHead(node) || isTableBody(node))) {
+    editor.removeNodes({
+      at: tablePath
+    });
+  }
+}
+function deleteColumn(editor, tablePath, cellPath) {
+  const tableNode = editor.node(tablePath)[0];
+  const rowPath = Path.parent(cellPath);
+  const rowNode = editor.node(rowPath)[0];
+  function removeNodes(node) {
+    const cellIndex = cellPath[cellPath.length - 1];
+    node.children.forEach((row) => {
+      const rowPath2 = DOMEditor.findPath(editor, row);
+      editor.removeNodes({
+        at: [...rowPath2, cellIndex]
+      });
+    });
+  }
+  if (rowNode.children.length === 1) {
+    deleteTable(editor, tablePath);
+  } else {
+    const bodyIndex = tableNode.children.findIndex(isTableBody);
+    if (bodyIndex !== -1) {
+      const bodyPath = [...tablePath, bodyIndex];
+      const bodyNode = editor.node(bodyPath)[0];
+      removeNodes(bodyNode);
+    }
+    const headIndex = tableNode.children.findIndex(isTableHead);
+    if (headIndex !== -1) {
+      const headPath = [...tablePath, headIndex];
+      const headNode = editor.node(headPath)[0];
+      removeNodes(headNode);
+    }
+  }
+}
+function deleteTable(editor, tablePath) {
+  editor.removeNodes({
+    at: tablePath
+  });
+}
+function moveToHead(editor, tablePath, cellPath) {
+  const rowPath = Path.parent(cellPath);
+  const rowParentPath = Path.parent(rowPath);
+  const rowParentNode = editor.node(rowParentPath)[0];
+  if (rowParentNode.type === "table-head") return;
+  const tableNode = editor.node(tablePath)[0];
+  editor.withoutNormalizing(() => {
+    const rowPathRef = editor.pathRef(rowPath);
+    let headIndex = tableNode.children.findIndex(isTableHead);
+    if (headIndex === -1) {
+      editor.insertNodes(
+        {
+          type: "table-head",
+          children: []
+        },
+        { at: rowParentPath }
+      );
+    }
+    headIndex = tableNode.children.findIndex(isTableHead);
+    const headPath = [...tablePath, headIndex];
+    const headNode = editor.node(headPath)[0];
+    const lastRowIndex = headNode.children.length;
+    editor.moveNodes({
+      at: rowPathRef.unref(),
+      to: [...headPath, lastRowIndex]
+    });
+  });
+  const bodyIndex = tableNode.children.findIndex(isTableBody);
+  const bodyPath = [...tablePath, bodyIndex];
+  const bodyNode = editor.node(bodyPath)[0];
+  if (!bodyNode.children.find(isTableRow)) {
+    editor.removeNodes({
+      at: bodyPath
+    });
+  }
+}
+function moveToBody(editor, tablePath, cellPath) {
+  const rowPath = Path.parent(cellPath);
+  const rowParentPath = Path.parent(rowPath);
+  const rowParentNode = editor.node(rowParentPath)[0];
+  if (rowParentNode.type === "table-body") return;
+  const tableNode = editor.node(tablePath)[0];
+  editor.withoutNormalizing(() => {
+    const rowPathRef = editor.pathRef(rowPath);
+    let bodyIndex = tableNode.children.findIndex(isTableBody);
+    if (bodyIndex === -1) {
+      editor.insertNodes(
+        {
+          type: "table-body",
+          children: []
+        },
+        { at: Path.next(rowParentPath) }
+      );
+    }
+    bodyIndex = tableNode.children.findIndex(isTableBody);
+    const bodyPath = [...tablePath, bodyIndex];
+    editor.moveNodes({
+      at: rowPathRef.unref(),
+      to: [...bodyPath, 0]
+    });
+  });
+  const headIndex = tableNode.children.findIndex(isTableHead);
+  const headPath = [...tablePath, headIndex];
+  const headNode = editor.node(headPath)[0];
+  if (!headNode.children.find(isTableRow)) {
+    editor.removeNodes({
+      at: headPath
+    });
+  }
+}
+function deleteBackward(editor) {
+  if (editor.selection && Range.isCollapsed(editor.selection)) {
+    const generator = editor.nodes({
+      match: isTableCell
+    });
+    const { value: cell, done } = generator.next();
+    if (!done) {
+      const [, cellPath] = cell;
+      const start = Editor.start(editor, cellPath);
+      if (Point.equals(editor.selection.anchor, start)) {
+        return true;
+      }
+    } else {
+      const generator2 = editor.nodes({
+        at: editor.before(editor.selection.anchor),
+        match: isTable
+      });
+      if (!generator2.next().done) {
+        return true;
+      }
+    }
+  }
+}
+function deleteForward(editor) {
+  if (editor.selection && Range.isCollapsed(editor.selection)) {
+    const generator = editor.nodes({
+      match: isTableCell
+    });
+    const { value: cell, done } = generator.next();
+    if (!done) {
+      const [, cellPath] = cell;
+      const end = editor.end(cellPath);
+      if (Point.equals(editor.selection.anchor, end)) {
+        return true;
+      }
+    } else {
+      const generator2 = editor.nodes({
+        at: editor.after(editor.selection.anchor),
+        match: isTable
+      });
+      if (!generator2.next().done) {
+        const [[node, path]] = editor.nodes({
+          at: editor.selection,
+          mode: "lowest",
+          match: (n) => isBlockElement(editor, n)
+        });
+        if (editor.isEmpty(node)) {
+          editor.removeNodes({
+            at: path
+          });
+        }
+        return true;
+      }
+    }
+  }
+}
+function getSplitedTableRange(editor) {
+  const tableEntries = Array.from(
+    editor.nodes({
+      match: isTable
+    })
+  );
+  const ranges = tableEntries.reduce((ranges2, current) => {
+    const [tableStart, tableEnd] = Range.edges(editor.range(current[1]));
+    const prev = ranges2[ranges2.length - 1];
+    if (prev) {
+      ranges2.push({
+        type: "non-table",
+        range: {
+          anchor: editor.after(prev.range.focus),
+          focus: editor.before(tableStart)
+        }
+      });
+    }
+    ranges2.push({
+      type: "table",
+      full: true,
+      range: {
+        anchor: tableStart,
+        focus: tableEnd
+      }
+    });
+    return ranges2;
+  }, []);
+  const [selectionStart, selectionEnd] = Range.edges(editor.selection);
+  const firstRange = ranges[0].range;
+  if (Point.isBefore(selectionStart, firstRange.anchor)) {
+    ranges.unshift({
+      type: "non-table",
+      range: {
+        anchor: selectionStart,
+        focus: editor.before(firstRange.anchor)
+      }
+    });
+  } else {
+    ranges[0].full = false;
+    firstRange.anchor = selectionStart;
+  }
+  const lastRange = ranges[ranges.length - 1].range;
+  if (Point.isAfter(selectionEnd, lastRange.focus)) {
+    ranges.push({
+      type: "non-table",
+      range: {
+        anchor: editor.after(lastRange.focus),
+        focus: selectionEnd
+      }
+    });
+  } else {
+    ranges[ranges.length - 1].full = false;
+    lastRange.focus = selectionEnd;
+  }
+  return ranges;
+}
+function clearTableCells(editor, range) {
+  const cellEntries = Array.from(
+    editor.nodes({
+      at: range,
+      match: isTableCell
+    })
+  );
+  const [start, end] = editor.edges(editor.selection);
+  for (const [, path] of cellEntries) {
+    const [cellStart, cellEnd] = editor.edges(path);
+    const anchor = Point.isBefore(start, cellStart) ? cellStart : start;
+    const focus = Point.isAfter(end, cellEnd) ? cellEnd : end;
+    if (Point.equals(anchor, focus)) {
+      continue;
+    }
+    editor.delete({
+      at: {
+        anchor,
+        focus
+      }
+    });
+  }
+}
+function deleteFragment(editor) {
+  if (!editor.selection) return;
+  const [anchorCell] = editor.nodes({ at: editor.selection.anchor, match: isTableCell });
+  const [focusCell] = editor.nodes({ at: editor.selection.focus, match: isTableCell });
+  if (!anchorCell && !focusCell) return;
+  if (anchorCell && focusCell && Path.equals(anchorCell[1], focusCell[1])) return;
+  const ranges = getSplitedTableRange(editor);
+  for (let i = ranges.length - 1; i >= 0; i--) {
+    const { type, full, range } = ranges[i];
+    if (Range.isCollapsed(range)) continue;
+    if (type === "non-table") {
+      editor.delete({
+        at: range
+      });
+    } else if (full) {
+      editor.delete({
+        at: {
+          anchor: editor.before(range.anchor),
+          focus: editor.after(range.focus)
+        }
+      });
+    } else {
+      clearTableCells(editor, range);
+    }
+  }
+  return true;
+}
+function wrapTableCellChildren(editor, cellPath) {
+  const children = Array.from(Node.children(editor, cellPath));
+  for (const [childNode, childPath] of children) {
+    if (!Element.isElement(childNode) || editor.isInline(childNode)) {
+      editor.wrapNodes(
+        {
+          type: "paragraph",
+          children: []
+        },
+        {
+          at: childPath
+        }
+      );
+      return true;
+    }
+  }
+}
+function insertBreak(editor) {
+  if (!editor.selection || Range.isCollapsed(editor.selection)) return;
+  const [anchorCell] = editor.nodes({ at: editor.selection.anchor, match: isTableCell });
+  const [focusCell] = editor.nodes({ at: editor.selection.focus, match: isTableCell });
+  if (!anchorCell && !focusCell) return;
+  if (anchorCell && focusCell && Path.equals(anchorCell[1], focusCell[1])) return;
+  return true;
+}
+function onKeydown(editor, event) {
+  if (Hotkeys.isMoveDown(event)) {
+    if (editor.selection) {
+      const [cell] = editor.nodes({
+        match: isTableCell,
+        at: editor.selection.focus
+      });
+      if (!cell) return;
+      const cellPath = cell[1];
+      if (isPointAtLastLine(editor, cellPath, editor.selection.focus)) {
+        event.preventDefault();
+        const cellIndex = cellPath[cellPath.length - 1];
+        const [[, tablePath]] = editor.nodes({
+          at: cellPath,
+          match: isTable
+        });
+        const [, rowPath] = editor.parent(cellPath);
+        const maybeNextRow = editor.next({
+          at: rowPath,
+          match: (n, path) => isTableRow(n) && Path.isAncestor(tablePath, path)
+        });
+        if (maybeNextRow) {
+          const nextRowCellPath = [...maybeNextRow[1], cellIndex];
+          editor.select(editor.start(nextRowCellPath));
+        } else {
+          const after = editor.after(tablePath);
+          if (after) {
+            editor.select(after);
+          } else {
+            editor.insertNodes(
+              {
+                type: "paragraph",
+                children: [{ text: "" }]
+              },
+              {
+                at: Path.next(tablePath)
+              }
+            );
+            editor.select(Path.next(tablePath));
+          }
+        }
+      }
+      return true;
+    }
+  }
+  if (Hotkeys.isMoveUp(event)) {
+    if (editor.selection) {
+      const [cell] = editor.nodes({
+        match: isTableCell,
+        at: editor.selection.focus
+      });
+      if (!cell) return;
+      const cellPath = cell[1];
+      if (isPointAtFirstLine(editor, cellPath, editor.selection.focus)) {
+        event.preventDefault();
+        const cellIndex = cellPath[cellPath.length - 1];
+        const [[, tablePath]] = editor.nodes({
+          at: cellPath,
+          match: isTable
+        });
+        const [, rowPath] = editor.parent(cellPath);
+        const maybeNextRow = editor.previous({
+          at: rowPath,
+          match: (n, path) => isTableRow(n) && Path.isAncestor(tablePath, path)
+        });
+        if (maybeNextRow) {
+          const nextRowCellPath = [...maybeNextRow[1], cellIndex];
+          editor.select(editor.end(nextRowCellPath));
+        } else {
+          const before = editor.before(tablePath);
+          if (before) {
+            editor.select(before);
+          } else {
+            editor.insertNodes(
+              {
+                type: "paragraph",
+                children: [{ text: "" }]
+              },
+              {
+                at: [0]
+              }
+            );
+            editor.select([0]);
+          }
+        }
+      }
+      return true;
+    }
+  }
+}
+function normalizeTable(editor, entry) {
+  const [node, path] = entry;
+  if (!isTable(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!isTableHead(childNode) && !isTableBody(childNode)) {
+      editor.removeNodes({
+        at: childPath
+      });
+      return true;
+    }
+  }
+}
+function normalizeTableHead(editor, entry) {
+  const [node, path] = entry;
+  if (!isTableHead(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!isTableRow(childNode)) {
+      editor.removeNodes({
+        at: childPath
+      });
+      return true;
+    }
+  }
+}
+function normalizeTableBody(editor, entry) {
+  const [node, path] = entry;
+  if (!isTableBody(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!isTableRow(childNode)) {
+      editor.removeNodes({
+        at: childPath
+      });
+      return true;
+    }
+  }
+}
+function normalizeTableRow(editor, entry) {
+  const [node, path] = entry;
+  if (!isTableRow(node)) return;
+  const children = Array.from(Node.children(editor, path));
+  for (const [childNode, childPath] of children) {
+    if (!isTableCell(childNode)) {
+      editor.removeNodes({
+        at: childPath
+      });
+      return true;
+    }
+  }
+}
+function normalizeTableCell(editor, entry) {
+  const [node, path] = entry;
+  if (!isTableCell(node)) return;
+  return wrapTableCellChildren(editor, path);
+}
+function normalizeNode(editor, entry) {
+  return normalizeTable(editor, entry) || normalizeTableHead(editor, entry) || normalizeTableBody(editor, entry) || normalizeTableRow(editor, entry) || normalizeTableCell(editor, entry);
+}
+function insertData(editor) {
+  if (!editor.selection) return;
+  const [anchorCell] = editor.nodes({ at: editor.selection.anchor, match: isTableCell });
+  const [focusCell] = editor.nodes({ at: editor.selection.focus, match: isTableCell });
+  if (!anchorCell && !focusCell) return;
+  if (anchorCell && focusCell && Path.equals(anchorCell[1], focusCell[1])) return;
+  return true;
+}
+function withTable(editor) {
+  const {
+    renderElement,
+    deleteBackward: srcDeleteBackward,
+    deleteForward: srcDeleteForward,
+    deleteFragment: srcDeleteFragment,
+    insertBreak: srcInsertBreak,
+    onKeydown: srcOnKeydown,
+    normalizeNode: srcNormalizeNode,
+    insertData: srcInsertData
+  } = editor;
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    switch (element.type) {
+      case "table": {
+        return h(stdin_default, useInheritRef(attributes), () => children);
+      }
+      case "table-head":
+        return h("thead", attributes, children);
+      case "table-body":
+        return h("tbody", attributes, children);
+      case "table-row":
+        return h("tr", attributes, children);
+      case "table-cell":
+        return h("td", attributes, children);
+    }
+    return renderElement(props);
+  };
+  editor.deleteBackward = (unit) => {
+    if (!deleteBackward(editor)) {
+      srcDeleteBackward(unit);
+    }
+  };
+  editor.deleteForward = (unit) => {
+    if (!deleteForward(editor)) {
+      srcDeleteForward(unit);
+    }
+  };
+  editor.deleteFragment = (options) => {
+    if (!deleteFragment(editor)) {
+      srcDeleteFragment(options);
+    }
+  };
+  editor.insertBreak = () => {
+    if (!insertBreak(editor)) {
+      srcInsertBreak();
+    }
+  };
+  editor.onKeydown = (event) => {
+    if (!onKeydown(editor, event)) {
+      srcOnKeydown(event);
+    }
+  };
+  editor.insertTable = (rowCount, columnCount) => {
+    insertTable(editor, rowCount, columnCount);
+  };
+  editor.insertRow = (tablePath, cellPath, isNext) => {
+    insertRow(editor, tablePath, cellPath, isNext);
+  };
+  editor.insertRowAbove = (tablePath, cellPath) => {
+    insertRowAbove(editor, tablePath, cellPath);
+  };
+  editor.insertRowBelow = (tablePath, cellPath) => {
+    insertRowBelow(editor, tablePath, cellPath);
+  };
+  editor.insertColumn = (tablePath, cellPath, isNext) => {
+    insertColumn(editor, tablePath, cellPath, isNext);
+  };
+  editor.insertColumnLeft = (tablePath, cellPath) => {
+    insertColumnLeft(editor, tablePath, cellPath);
+  };
+  editor.insertColumnRight = (tablePath, cellPath) => {
+    insertColumnRight(editor, tablePath, cellPath);
+  };
+  editor.deleteRow = (tablePath, cellPath) => {
+    deleteRow(editor, tablePath, cellPath);
+  };
+  editor.deleteColumn = (tablePath, cellPath) => {
+    deleteColumn(editor, tablePath, cellPath);
+  };
+  editor.deleteTable = (tablePath) => {
+    deleteTable(editor, tablePath);
+  };
+  editor.moveToHead = (tablePath, cellPath) => {
+    moveToHead(editor, tablePath, cellPath);
+  };
+  editor.moveToBody = (tablePath, cellPath) => {
+    moveToBody(editor, tablePath, cellPath);
+  };
+  editor.isTable = isTable;
+  editor.isTableCell = isTableCell;
+  editor.normalizeNode = (entry, options) => {
+    if (!normalizeNode(editor, entry)) {
+      srcNormalizeNode(entry, options);
+    }
+  };
+  editor.insertData = (data) => {
+    if (!insertData(editor)) {
+      srcInsertData(data);
+    }
+  };
+  return editor;
+}
+
+export { withTable };

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

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