@kopexa/extension-table 17.0.45 → 17.1.0

package/dist/chunk-6FHFDGJO.mjs

@@ -0,0 +1,251 @@
+"use client";
+import {
+  messages
+} from "./chunk-CN73TYHV.mjs";
+import {
+  getRowOrColumnCells,
+  getTable,
+  getTableSelectionType,
+  isCellEmpty
+} from "./chunk-5B5XIL2G.mjs";
+
+// src/hooks/use-table-sort-row-column.ts
+import { isExtensionAvailable, useTiptapEditor } from "@kopexa/editor-utils";
+import { useSafeIntl } from "@kopexa/i18n";
+import { ArrowDownAZIcon, ArrowDownZAIcon } from "@kopexa/icons";
+import { useCallback, useMemo } from "react";
+var REQUIRED_EXTENSIONS = ["tableHandleExtension"];
+var sortMessageKeys = {
+  row: {
+    asc: messages.sort_row_asc,
+    desc: messages.sort_row_desc
+  },
+  column: {
+    asc: messages.sort_column_asc,
+    desc: messages.sort_column_desc
+  }
+};
+var tableSortRowColumnIcons = {
+  asc: ArrowDownAZIcon,
+  desc: ArrowDownZAIcon
+};
+function isCellHeader(cellNode) {
+  var _a;
+  if (!cellNode) return false;
+  return cellNode.type.name === "tableHeader" || cellNode.type.name === "table_header" || ((_a = cellNode.attrs) == null ? void 0 : _a.header) === true;
+}
+function getCellSortText(cellNode) {
+  if (!cellNode) return "";
+  let text = "";
+  cellNode.descendants((node) => {
+    if (node.isText) {
+      text += node.text || "";
+    }
+    return true;
+  });
+  return text.trim().toLowerCase();
+}
+function canSortRowColumn({
+  editor,
+  index,
+  orientation,
+  tablePos
+}) {
+  if (!editor || !editor.isEditable || !isExtensionAvailable(editor, REQUIRED_EXTENSIONS)) {
+    return false;
+  }
+  try {
+    const table = getTable(editor, tablePos);
+    if (!table) return false;
+    const cellData = getRowOrColumnCells(editor, index, orientation, tablePos);
+    if (cellData.orientation === "row") {
+      if (table.map.width < 2) return false;
+    } else {
+      if (table.map.height < 2) return false;
+    }
+    if (cellData.mergedCells.length > 0) {
+      return false;
+    }
+    const hasContent = cellData.cells.some(
+      (cellInfo) => cellInfo.node && !isCellHeader(cellInfo.node) && !isCellEmpty(cellInfo.node)
+    );
+    if (!hasContent) {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function tableSortRowColumn({
+  editor,
+  index,
+  orientation,
+  direction,
+  tablePos
+}) {
+  if (!canSortRowColumn({ editor, index, orientation, tablePos }) || !editor)
+    return false;
+  try {
+    const { state, view } = editor;
+    const tr = state.tr;
+    const cellData = getRowOrColumnCells(editor, index, orientation, tablePos);
+    if (cellData.mergedCells.length > 0) {
+      console.warn(
+        `Cannot sort ${orientation} ${index}: contains merged cells`
+      );
+      return false;
+    }
+    if (cellData.cells.length < 2) {
+      return false;
+    }
+    const allItems = cellData.cells.map(
+      (cellInfo, originalIndex) => {
+        const isHeader = isCellHeader(cellInfo.node);
+        const isEmpty = cellInfo.node ? isCellEmpty(cellInfo.node) : true;
+        return {
+          sortText: getCellSortText(cellInfo.node),
+          originalNode: cellInfo.node,
+          cellInfo,
+          originalIndex,
+          isHeader,
+          isEmpty
+        };
+      }
+    );
+    const dataItems = allItems.filter((item) => !item.isHeader);
+    if (dataItems.length < 2) {
+      console.log("No sortable data cells found (excluding headers)");
+      return false;
+    }
+    dataItems.sort((a, b) => {
+      if (a.isEmpty && !b.isEmpty) return 1;
+      if (!a.isEmpty && b.isEmpty) return -1;
+      if (a.isEmpty && b.isEmpty) return 0;
+      const comparison = a.sortText.localeCompare(b.sortText, void 0, {
+        sensitivity: "base"
+      });
+      return direction === "asc" ? comparison : -comparison;
+    });
+    const newCellNodes = [];
+    let dataIndex = 0;
+    for (let i = 0; i < allItems.length; i++) {
+      const originalItem = allItems[i];
+      const targetCell = cellData.cells[i];
+      if (!targetCell || !originalItem) continue;
+      let nodeToPlace = null;
+      if (originalItem.isHeader) {
+        nodeToPlace = originalItem.originalNode;
+      } else {
+        const sortedDataItem = dataItems[dataIndex];
+        nodeToPlace = (sortedDataItem == null ? void 0 : sortedDataItem.originalNode) || null;
+        dataIndex++;
+      }
+      if (nodeToPlace && targetCell.node) {
+        const cellType = targetCell.node.type;
+        const newCellNode = cellType.create(
+          nodeToPlace.attrs,
+          nodeToPlace.content,
+          nodeToPlace.marks
+        );
+        newCellNodes.push(newCellNode);
+      } else {
+        newCellNodes.push(targetCell.node);
+      }
+    }
+    const cellsToReplace = [...cellData.cells].reverse();
+    const newNodesToPlace = [...newCellNodes].reverse();
+    cellsToReplace.forEach((targetCell, reverseIndex) => {
+      const newNode = newNodesToPlace[reverseIndex];
+      if (newNode && targetCell.node) {
+        const cellEnd = targetCell.pos + targetCell.node.nodeSize;
+        tr.replaceWith(targetCell.pos, cellEnd, newNode);
+      }
+    });
+    if (tr.docChanged) {
+      view.dispatch(tr);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error(`Error sorting table ${orientation}:`, error);
+    return false;
+  }
+}
+function shouldShowButton({
+  editor,
+  index,
+  orientation,
+  hideWhenUnavailable,
+  tablePos
+}) {
+  if (!editor || !editor.isEditable) return false;
+  if (!isExtensionAvailable(editor, REQUIRED_EXTENSIONS)) return false;
+  const table = getTable(editor, tablePos);
+  if (!table) return false;
+  const selectionType = getTableSelectionType(
+    editor,
+    index,
+    orientation,
+    tablePos
+  );
+  if (!selectionType) return false;
+  return hideWhenUnavailable ? canSortRowColumn({ editor, index, orientation, tablePos }) : true;
+}
+function useTableSortRowColumn(config = { direction: "asc" }) {
+  const {
+    editor: providedEditor,
+    index,
+    orientation,
+    tablePos,
+    direction,
+    hideWhenUnavailable = false,
+    onSorted
+  } = config;
+  const { editor } = useTiptapEditor(providedEditor);
+  const intl = useSafeIntl();
+  const selectionType = getTableSelectionType(editor, index, orientation);
+  const isVisible = shouldShowButton({
+    editor,
+    index,
+    orientation,
+    hideWhenUnavailable,
+    tablePos
+  });
+  const canPerformSort = canSortRowColumn({
+    editor,
+    index,
+    orientation,
+    tablePos
+  });
+  const handleSort = useCallback(() => {
+    const success = tableSortRowColumn({
+      editor,
+      index,
+      orientation,
+      direction,
+      tablePos
+    });
+    if (success) onSorted == null ? void 0 : onSorted();
+    return success;
+  }, [editor, index, orientation, direction, tablePos, onSorted]);
+  const label = useMemo(() => {
+    const orient = (selectionType == null ? void 0 : selectionType.orientation) || "row";
+    return intl.formatMessage(sortMessageKeys[orient][direction]);
+  }, [intl, selectionType, direction]);
+  const Icon = useMemo(() => {
+    return tableSortRowColumnIcons[direction] || ArrowDownAZIcon;
+  }, [direction]);
+  return {
+    isVisible,
+    canSortRowColumn: canPerformSort,
+    handleSort,
+    label,
+    Icon
+  };
+}
+
+export {
+  tableSortRowColumnIcons,
+  useTableSortRowColumn
+};

package/dist/chunk-CD62W5C3.mjs

@@ -0,0 +1,165 @@
+"use client";
+import {
+  messages
+} from "./chunk-CN73TYHV.mjs";
+import {
+  getIndexCoordinates,
+  getRowOrColumnCells,
+  getTableSelectionType,
+  selectCellsByCoords
+} from "./chunk-5B5XIL2G.mjs";
+
+// src/hooks/use-table-header-row-column.ts
+import {
+  isExtensionAvailable,
+  isValidPosition,
+  useTiptapEditor
+} from "@kopexa/editor-utils";
+import { useSafeIntl } from "@kopexa/i18n";
+import { TableHeaderColumnIcon, TableHeaderRowIcon } from "@kopexa/icons";
+import { CellSelection, toggleHeader } from "@tiptap/pm/tables";
+import { useCallback } from "react";
+var REQUIRED_EXTENSIONS = ["table"];
+var headerMessageKeys = {
+  row: messages.header_row,
+  column: messages.header_column
+};
+var tableHeaderRowColumnIcons = {
+  row: TableHeaderRowIcon,
+  column: TableHeaderColumnIcon
+};
+function canToggleHeader({
+  editor,
+  index,
+  orientation,
+  tablePos
+}) {
+  if (!editor || !editor.isEditable || !isExtensionAvailable(editor, REQUIRED_EXTENSIONS)) {
+    return false;
+  }
+  const selectionType = getTableSelectionType(
+    editor,
+    index,
+    orientation,
+    tablePos
+  );
+  if (!selectionType) return false;
+  return selectionType.index === 0;
+}
+function toggleTableHeader({
+  editor,
+  index,
+  orientation,
+  tablePos
+}) {
+  if (!editor) return false;
+  if (!canToggleHeader({ editor, index, orientation, tablePos })) return false;
+  try {
+    const selectionType = getTableSelectionType(
+      editor,
+      index,
+      orientation,
+      tablePos
+    );
+    if (!selectionType) return false;
+    const isRow = selectionType.orientation === "row";
+    if (editor.state.selection instanceof CellSelection) {
+      return isRow ? editor.commands.toggleHeaderRow() : editor.commands.toggleHeaderColumn();
+    }
+    if (!isValidPosition(tablePos)) return false;
+    const cellCoords = getIndexCoordinates({
+      editor,
+      index: selectionType.index,
+      orientation: selectionType.orientation,
+      tablePos
+    });
+    if (!cellCoords) return false;
+    const stateWithCellSel = selectCellsByCoords(editor, tablePos, cellCoords, {
+      mode: "state"
+    });
+    if (!stateWithCellSel) return false;
+    const dispatch = (tr) => editor.view.dispatch(tr);
+    return isRow ? toggleHeader("row")(stateWithCellSel, dispatch) : toggleHeader("column")(stateWithCellSel, dispatch);
+  } catch {
+    return false;
+  }
+}
+function shouldShowButton({
+  editor,
+  index,
+  orientation,
+  hideWhenUnavailable,
+  tablePos
+}) {
+  if (!editor || !editor.isEditable) return false;
+  if (!isExtensionAvailable(editor, REQUIRED_EXTENSIONS)) return false;
+  if (hideWhenUnavailable) {
+    return canToggleHeader({ editor, index, orientation, tablePos });
+  }
+  const selectionType = getTableSelectionType(editor, index, orientation);
+  return Boolean(selectionType);
+}
+function useTableHeaderRowColumn(config) {
+  var _a, _b;
+  const {
+    editor: providedEditor,
+    index,
+    orientation,
+    tablePos,
+    hideWhenUnavailable = false,
+    onToggled
+  } = config;
+  const { editor } = useTiptapEditor(providedEditor);
+  const intl = useSafeIntl();
+  const selectionType = getTableSelectionType(editor, index, orientation);
+  const isVisible = shouldShowButton({
+    editor,
+    index,
+    orientation,
+    hideWhenUnavailable,
+    tablePos
+  });
+  const canPerformToggle = canToggleHeader({
+    editor,
+    index,
+    orientation,
+    tablePos
+  });
+  let isActive = false;
+  if ((editor == null ? void 0 : editor.state.selection) instanceof CellSelection) {
+    isActive = (editor == null ? void 0 : editor.isActive("tableHeader")) || false;
+  } else {
+    const rowsOrCols = getRowOrColumnCells(
+      editor,
+      index,
+      selectionType == null ? void 0 : selectionType.orientation,
+      tablePos
+    );
+    if (rowsOrCols) {
+      const secondIndex = rowsOrCols.cells.length > 1 ? 1 : 0;
+      isActive = ((_b = (_a = rowsOrCols.cells[secondIndex]) == null ? void 0 : _a.node) == null ? void 0 : _b.type.name) === "tableHeader" || false;
+    }
+  }
+  const handleToggle = useCallback(() => {
+    const success = toggleTableHeader({ editor, index, orientation, tablePos });
+    if (success) onToggled == null ? void 0 : onToggled();
+    return success;
+  }, [editor, index, orientation, tablePos, onToggled]);
+  const label = intl.formatMessage(
+    headerMessageKeys[(selectionType == null ? void 0 : selectionType.orientation) || "row"]
+  );
+  const Icon = tableHeaderRowColumnIcons[(selectionType == null ? void 0 : selectionType.orientation) || "row"];
+  return {
+    isVisible,
+    canToggleHeader: canPerformToggle,
+    handleToggle,
+    label,
+    Icon,
+    isActive
+  };
+}
+
+export {
+  tableHeaderRowColumnIcons,
+  useTableHeaderRowColumn
+};

package/dist/chunk-CN73TYHV.mjs

@@ -0,0 +1,190 @@
+"use client";
+
+// src/messages.ts
+import { defineMessages } from "@kopexa/i18n";
+var messages = defineMessages({
+  // Row/Column actions (aria labels)
+  row_actions: {
+    id: "editor.table.row_actions",
+    defaultMessage: "Row actions",
+    description: "ARIA label for row actions menu button"
+  },
+  column_actions: {
+    id: "editor.table.column_actions",
+    defaultMessage: "Column actions",
+    description: "ARIA label for column actions menu button"
+  },
+  cell_options: {
+    id: "editor.table.cell_options",
+    defaultMessage: "Table cells option",
+    description: "ARIA label for cell options menu button"
+  },
+  // Alignment
+  alignment: {
+    id: "editor.table.alignment",
+    defaultMessage: "Alignment",
+    description: "Label for alignment submenu"
+  },
+  align_left: {
+    id: "editor.table.align_left",
+    defaultMessage: "Align left",
+    description: "Label for align left action"
+  },
+  align_center: {
+    id: "editor.table.align_center",
+    defaultMessage: "Align center",
+    description: "Label for align center action"
+  },
+  align_right: {
+    id: "editor.table.align_right",
+    defaultMessage: "Align right",
+    description: "Label for align right action"
+  },
+  justify: {
+    id: "editor.table.justify",
+    defaultMessage: "Justify",
+    description: "Label for justify action"
+  },
+  align_top: {
+    id: "editor.table.align_top",
+    defaultMessage: "Align top",
+    description: "Label for vertical align top action"
+  },
+  align_middle: {
+    id: "editor.table.align_middle",
+    defaultMessage: "Align middle",
+    description: "Label for vertical align middle action"
+  },
+  align_bottom: {
+    id: "editor.table.align_bottom",
+    defaultMessage: "Align bottom",
+    description: "Label for vertical align bottom action"
+  },
+  // Add row/column
+  insert_row_above: {
+    id: "editor.table.insert_row_above",
+    defaultMessage: "Insert row above",
+    description: "Label for insert row above action"
+  },
+  insert_row_below: {
+    id: "editor.table.insert_row_below",
+    defaultMessage: "Insert row below",
+    description: "Label for insert row below action"
+  },
+  insert_column_left: {
+    id: "editor.table.insert_column_left",
+    defaultMessage: "Insert column left",
+    description: "Label for insert column left action"
+  },
+  insert_column_right: {
+    id: "editor.table.insert_column_right",
+    defaultMessage: "Insert column right",
+    description: "Label for insert column right action"
+  },
+  // Delete row/column
+  delete_row: {
+    id: "editor.table.delete_row",
+    defaultMessage: "Delete row",
+    description: "Label for delete row action"
+  },
+  delete_column: {
+    id: "editor.table.delete_column",
+    defaultMessage: "Delete column",
+    description: "Label for delete column action"
+  },
+  // Move row/column
+  move_row_up: {
+    id: "editor.table.move_row_up",
+    defaultMessage: "Move row up",
+    description: "Label for move row up action"
+  },
+  move_row_down: {
+    id: "editor.table.move_row_down",
+    defaultMessage: "Move row down",
+    description: "Label for move row down action"
+  },
+  move_column_left: {
+    id: "editor.table.move_column_left",
+    defaultMessage: "Move column left",
+    description: "Label for move column left action"
+  },
+  move_column_right: {
+    id: "editor.table.move_column_right",
+    defaultMessage: "Move column right",
+    description: "Label for move column right action"
+  },
+  // Sort
+  sort_row_asc: {
+    id: "editor.table.sort_row_asc",
+    defaultMessage: "Sort row A-Z",
+    description: "Label for sort row ascending action"
+  },
+  sort_row_desc: {
+    id: "editor.table.sort_row_desc",
+    defaultMessage: "Sort row Z-A",
+    description: "Label for sort row descending action"
+  },
+  sort_column_asc: {
+    id: "editor.table.sort_column_asc",
+    defaultMessage: "Sort column A-Z",
+    description: "Label for sort column ascending action"
+  },
+  sort_column_desc: {
+    id: "editor.table.sort_column_desc",
+    defaultMessage: "Sort column Z-A",
+    description: "Label for sort column descending action"
+  },
+  // Duplicate
+  duplicate_row: {
+    id: "editor.table.duplicate_row",
+    defaultMessage: "Duplicate row",
+    description: "Label for duplicate row action"
+  },
+  duplicate_column: {
+    id: "editor.table.duplicate_column",
+    defaultMessage: "Duplicate column",
+    description: "Label for duplicate column action"
+  },
+  // Header
+  header_row: {
+    id: "editor.table.header_row",
+    defaultMessage: "Header row",
+    description: "Label for toggle header row action"
+  },
+  header_column: {
+    id: "editor.table.header_column",
+    defaultMessage: "Header column",
+    description: "Label for toggle header column action"
+  },
+  // Merge/Split
+  merge_cells: {
+    id: "editor.table.merge_cells",
+    defaultMessage: "Merge cells",
+    description: "Label for merge cells action"
+  },
+  split_cell: {
+    id: "editor.table.split_cell",
+    defaultMessage: "Split cell",
+    description: "Label for split cell action"
+  },
+  // Clear contents
+  clear_row_contents: {
+    id: "editor.table.clear_row_contents",
+    defaultMessage: "Clear row contents",
+    description: "Label for clear row contents action"
+  },
+  clear_column_contents: {
+    id: "editor.table.clear_column_contents",
+    defaultMessage: "Clear column contents",
+    description: "Label for clear column contents action"
+  },
+  clear_contents: {
+    id: "editor.table.clear_contents",
+    defaultMessage: "Clear contents",
+    description: "Label for clear contents action (generic)"
+  }
+});
+
+export {
+  messages
+};