@cgboiler/biz-basic 1.0.67 → 1.0.68

package/es/rich-text-editor/lib/utils.d.ts

@@ -0,0 +1,123 @@
+import type { Node as TiptapNode } from '@tiptap/pm/model';
+import type { Editor } from '@tiptap/core';
+import { type ClassValue } from 'clsx';
+export declare const MAX_FILE_SIZE: number;
+export declare const MAC_SYMBOLS: Record<string, string>;
+export declare function cn(...inputs: ClassValue[]): string;
+/**
+ * Determines if the current platform is macOS
+ * @returns boolean indicating if the current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Formats a shortcut key based on the platform (Mac or non-Mac)
+ * @param key - The key to format (e.g., "ctrl", "alt", "shift")
+ * @param isMac - Boolean indicating if the platform is Mac
+ * @param capitalize - Whether to capitalize the key (default: true)
+ * @returns Formatted shortcut key symbol
+ */
+export declare const formatShortcutKey: (key: string, isMac: boolean, capitalize?: boolean) => string;
+/**
+ * Parses a shortcut key string into an array of formatted key symbols
+ * @param shortcutKeys - The string of shortcut keys (e.g., "ctrl-alt-shift")
+ * @param delimiter - The delimiter used to split the keys (default: "-")
+ * @param capitalize - Whether to capitalize the keys (default: true)
+ * @returns Array of formatted shortcut key symbols
+ */
+export declare const parseShortcutKeys: (props: {
+    shortcutKeys: string | undefined;
+    delimiter?: string;
+    capitalize?: boolean;
+}) => string[];
+/**
+ * Checks if a mark exists in the editor schema
+ * @param markName - The name of the mark to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the mark exists in the schema
+ */
+export declare const isMarkInSchema: (markName: string, editor: Editor | null) => boolean;
+/**
+ * Checks if a node exists in the editor schema
+ * @param nodeName - The name of the node to check
+ * @param editor - The editor instance
+ * @returns boolean indicating if the node exists in the schema
+ */
+export declare const isNodeInSchema: (nodeName: string, editor: Editor | null) => boolean;
+/**
+ * Moves the focus to the next node in the editor
+ * @param editor - The editor instance
+ * @returns boolean indicating if the focus was moved
+ */
+export declare function focusNextNode(editor: Editor): boolean;
+/**
+ * Checks if a value is a valid number (not null, undefined, or NaN)
+ * @param value - The value to check
+ * @returns boolean indicating if the value is a valid number
+ */
+export declare function isValidPosition(pos: number | null | undefined): pos is number;
+/**
+ * Checks if one or more extensions are registered in the Tiptap editor.
+ * @param editor - The Tiptap editor instance
+ * @param extensionNames - A single extension name or an array of names to check
+ * @returns True if at least one of the extensions is available, false otherwise
+ */
+export declare function isExtensionAvailable(editor: Editor | null, extensionNames: string | string[]): boolean;
+/**
+ * Finds a node at the specified position with error handling
+ * @param editor The Tiptap editor instance
+ * @param position The position in the document to find the node
+ * @returns The node at the specified position, or null if not found
+ */
+export declare function findNodeAtPosition(editor: Editor, position: number): TiptapNode | null;
+/**
+ * Finds the position and instance of a node in the document
+ * @param props Object containing editor, node (optional), and nodePos (optional)
+ * @param props.editor The Tiptap editor instance
+ * @param props.node The node to find (optional if nodePos is provided)
+ * @param props.nodePos The position of the node to find (optional if node is provided)
+ * @returns An object with the position and node, or null if not found
+ */
+export declare function findNodePosition(props: {
+    editor: Editor | null;
+    node?: TiptapNode | null;
+    nodePos?: number | null;
+}): {
+    pos: number;
+    node: TiptapNode;
+} | null;
+/**
+ * Checks if the current selection in the editor is a node selection of specified types
+ * @param editor The Tiptap editor instance
+ * @param types An array of node type names to check against
+ * @returns boolean indicating if the selected node matches any of the specified types
+ */
+export declare function isNodeTypeSelected(editor: Editor | null, types?: string[]): boolean;
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+export declare const handleImageUpload: (file: File, onProgress?: (event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+export declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+export declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+export {};

package/es/rich-text-editor/lib/utils.js

@@ -0,0 +1,244 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { NodeSelection, Selection, TextSelection } from "@tiptap/pm/state";
+import { clsx } from "clsx";
+const MAX_FILE_SIZE = 5 * 1024 * 1024;
+const MAC_SYMBOLS = {
+  mod: "\u2318",
+  command: "\u2318",
+  meta: "\u2318",
+  ctrl: "\u2303",
+  control: "\u2303",
+  alt: "\u2325",
+  option: "\u2325",
+  shift: "\u21E7",
+  backspace: "Del",
+  delete: "\u2326",
+  enter: "\u23CE",
+  escape: "\u238B",
+  capslock: "\u21EA"
+};
+function cn(...inputs) {
+  return clsx(inputs);
+}
+function isMac() {
+  return typeof navigator !== "undefined" && navigator.platform.toLowerCase().includes("mac");
+}
+const formatShortcutKey = (key, isMac2, capitalize = true) => {
+  if (isMac2) {
+    const lowerKey = key.toLowerCase();
+    return MAC_SYMBOLS[lowerKey] || (capitalize ? key.toUpperCase() : key);
+  }
+  return capitalize ? key.charAt(0).toUpperCase() + key.slice(1) : key;
+};
+const parseShortcutKeys = (props) => {
+  const { shortcutKeys, delimiter = "+", capitalize = true } = props;
+  if (!shortcutKeys)
+    return [];
+  return shortcutKeys.split(delimiter).map((key) => key.trim()).map((key) => formatShortcutKey(key, isMac(), capitalize));
+};
+const isMarkInSchema = (markName, editor) => {
+  if (!(editor == null ? void 0 : editor.schema))
+    return false;
+  return editor.schema.spec.marks.get(markName) !== void 0;
+};
+const isNodeInSchema = (nodeName, editor) => {
+  if (!(editor == null ? void 0 : editor.schema))
+    return false;
+  return editor.schema.spec.nodes.get(nodeName) !== void 0;
+};
+function focusNextNode(editor) {
+  const { state, view } = editor;
+  const { doc, selection } = state;
+  const nextSel = Selection.findFrom(selection.$to, 1, true);
+  if (nextSel) {
+    view.dispatch(state.tr.setSelection(nextSel).scrollIntoView());
+    return true;
+  }
+  const paragraphType = state.schema.nodes.paragraph;
+  if (!paragraphType) {
+    console.warn("No paragraph node type found in schema.");
+    return false;
+  }
+  const end = doc.content.size;
+  const para = paragraphType.create();
+  let tr = state.tr.insert(end, para);
+  const $inside = tr.doc.resolve(end + 1);
+  tr = tr.setSelection(TextSelection.near($inside)).scrollIntoView();
+  view.dispatch(tr);
+  return true;
+}
+function isValidPosition(pos) {
+  return typeof pos === "number" && pos >= 0;
+}
+function isExtensionAvailable(editor, extensionNames) {
+  if (!editor)
+    return false;
+  const names = Array.isArray(extensionNames) ? extensionNames : [extensionNames];
+  const found = names.some(
+    (name) => editor.extensionManager.extensions.some((ext) => ext.name === name)
+  );
+  if (!found) {
+    console.warn(
+      `None of the extensions [${names.join(
+        ", "
+      )}] were found in the editor schema. Ensure they are included in the editor configuration.`
+    );
+  }
+  return found;
+}
+function findNodeAtPosition(editor, position) {
+  try {
+    const node = editor.state.doc.nodeAt(position);
+    if (!node) {
+      console.warn(`No node found at position ${position}`);
+      return null;
+    }
+    return node;
+  } catch (error) {
+    console.error(`Error getting node at position ${position}:`, error);
+    return null;
+  }
+}
+function findNodePosition(props) {
+  var _a;
+  const { editor, node, nodePos } = props;
+  if (!editor || !((_a = editor.state) == null ? void 0 : _a.doc))
+    return null;
+  const hasValidNode = node !== void 0 && node !== null;
+  const hasValidPos = isValidPosition(nodePos);
+  if (!hasValidNode && !hasValidPos) {
+    return null;
+  }
+  if (hasValidNode) {
+    let foundPos = -1;
+    let foundNode = null;
+    editor.state.doc.descendants((currentNode, pos) => {
+      if (currentNode === node) {
+        foundPos = pos;
+        foundNode = currentNode;
+        return false;
+      }
+      return true;
+    });
+    if (foundPos !== -1 && foundNode !== null) {
+      return { pos: foundPos, node: foundNode };
+    }
+  }
+  if (hasValidPos) {
+    const nodeAtPos = findNodeAtPosition(editor, nodePos);
+    if (nodeAtPos) {
+      return { pos: nodePos, node: nodeAtPos };
+    }
+  }
+  return null;
+}
+function isNodeTypeSelected(editor, types = []) {
+  if (!editor || !editor.state.selection)
+    return false;
+  const { state } = editor;
+  const { selection } = state;
+  if (selection.empty)
+    return false;
+  if (selection instanceof NodeSelection) {
+    const node = selection.node;
+    return node ? types.includes(node.type.name) : false;
+  }
+  return false;
+}
+const handleImageUpload = (file, onProgress, abortSignal) => __async(void 0, null, function* () {
+  if (!file) {
+    throw new Error("No file provided");
+  }
+  if (file.size > MAX_FILE_SIZE) {
+    throw new Error(`File size exceeds maximum allowed (${MAX_FILE_SIZE / (1024 * 1024)}MB)`);
+  }
+  for (let progress = 0; progress <= 100; progress += 10) {
+    if (abortSignal == null ? void 0 : abortSignal.aborted) {
+      throw new Error("Upload cancelled");
+    }
+    yield new Promise((resolve) => setTimeout(resolve, 500));
+    onProgress == null ? void 0 : onProgress({ progress });
+  }
+  return "/images/tiptap-ui-placeholder-image.jpg";
+});
+const ATTR_WHITESPACE = (
+  // eslint-disable-next-line no-control-regex
+  /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g
+);
+function isAllowedUri(uri, protocols) {
+  const allowedProtocols = [
+    "http",
+    "https",
+    "ftp",
+    "ftps",
+    "mailto",
+    "tel",
+    "callto",
+    "sms",
+    "cid",
+    "xmpp"
+  ];
+  if (protocols) {
+    protocols.forEach((protocol) => {
+      const nextProtocol = typeof protocol === "string" ? protocol : protocol.scheme;
+      if (nextProtocol) {
+        allowedProtocols.push(nextProtocol);
+      }
+    });
+  }
+  return !uri || uri.replace(ATTR_WHITESPACE, "").match(
+    new RegExp(
+      // eslint-disable-next-line no-useless-escape
+      `^(?:(?:${allowedProtocols.join("|")}):|[^a-z]|[a-z0-9+.-]+(?:[^a-z+.-:]|$))`,
+      "i"
+    )
+  );
+}
+function sanitizeUrl(inputUrl, baseUrl, protocols) {
+  try {
+    const url = new URL(inputUrl, baseUrl);
+    if (isAllowedUri(url.href, protocols)) {
+      return url.href;
+    }
+  } catch (e) {
+  }
+  return "#";
+}
+export {
+  MAC_SYMBOLS,
+  MAX_FILE_SIZE,
+  cn,
+  findNodeAtPosition,
+  findNodePosition,
+  focusNextNode,
+  formatShortcutKey,
+  handleImageUpload,
+  isAllowedUri,
+  isExtensionAvailable,
+  isMac,
+  isMarkInSchema,
+  isNodeInSchema,
+  isNodeTypeSelected,
+  isValidPosition,
+  parseShortcutKeys,
+  sanitizeUrl
+};

package/es/rich-text-editor/menu-system/components/_atomic.css

@@ -39,6 +39,8 @@
 
 
 
+/* layer: default */
+.cgx-atm .table{display:table;}
 
 
 

package/es/rich-text-editor/menu-system/components/table-dropdown-menu.d.ts

@@ -0,0 +1,25 @@
+import { type PropType } from 'vue';
+import 'element-plus/es/components/dropdown/style/css';
+import 'element-plus/es/components/dropdown-menu/style/css';
+import 'element-plus/es/components/dropdown-item/style/css';
+export declare const TableDropdownMenu: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    editor: {
+        type: PropType<any>;
+        required: true;
+    };
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    className: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/es/rich-text-editor/menu-system/components/table-dropdown-menu.js

@@ -0,0 +1,167 @@
+import { createVNode as _createVNode, mergeProps as _mergeProps, createTextVNode as _createTextVNode, Fragment as _Fragment } from "vue";
+import "./_atomic.css";
+import { defineComponent } from "vue";
+import { Button } from "../primitives/button";
+import { cn } from "../utils/tiptap-utils";
+import { ElDropdown, ElDropdownMenu, ElDropdownItem } from "element-plus";
+import { ChevronDownIcon, TableIcon } from "../icons";
+import "element-plus/es/components/dropdown/style/css";
+import "element-plus/es/components/dropdown-menu/style/css";
+import "element-plus/es/components/dropdown-item/style/css";
+const TableDropdownMenu = defineComponent({
+  name: "TableDropdownMenu",
+  props: {
+    editor: {
+      type: Object,
+      required: true
+    },
+    className: {
+      type: String,
+      default: ""
+    }
+  },
+  setup(props, {
+    attrs
+  }) {
+    const handleCommand = (command) => {
+      const editor = props.editor && "value" in props.editor ? props.editor.value : props.editor;
+      if (!editor)
+        return;
+      switch (command) {
+        case "insertTable":
+          editor.commands.insertTable({
+            rows: 3,
+            cols: 3,
+            withHeaderRow: true
+          });
+          break;
+        case "addColumnBefore":
+          editor.commands.addColumnBefore();
+          break;
+        case "addColumnAfter":
+          editor.commands.addColumnAfter();
+          break;
+        case "deleteColumn":
+          editor.commands.deleteColumn();
+          break;
+        case "addRowBefore":
+          editor.commands.addRowBefore();
+          break;
+        case "addRowAfter":
+          editor.commands.addRowAfter();
+          break;
+        case "deleteRow":
+          editor.commands.deleteRow();
+          break;
+        case "deleteTable":
+          editor.commands.deleteTable();
+          break;
+        case "mergeCells":
+          editor.commands.mergeCells();
+          break;
+        case "splitCell":
+          editor.commands.splitCell();
+          break;
+        case "toggleHeaderRow":
+          editor.commands.toggleHeaderRow();
+          break;
+        case "toggleHeaderColumn":
+          editor.commands.toggleHeaderColumn();
+          break;
+        case "toggleHeaderCell":
+          editor.commands.toggleHeaderCell();
+          break;
+        default:
+          break;
+      }
+    };
+    const isInTable = () => {
+      const editor = props.editor && "value" in props.editor ? props.editor.value : props.editor;
+      return editor == null ? void 0 : editor.isActive("table");
+    };
+    return () => {
+      const trigger = _createVNode(Button, _mergeProps({
+        "type": "button",
+        "data-style": "ghost",
+        "data-active-state": isInTable() ? "on" : "off",
+        "role": "button",
+        "tooltip": "\u8868\u683C\u64CD\u4F5C",
+        "class": cn(props.className, "tiptap-table-dropdown-trigger")
+      }, attrs), {
+        default: () => [_createVNode(TableIcon, {
+          "class": "tiptap-button-icon"
+        }, null), _createVNode(ChevronDownIcon, {
+          "class": "tiptap-button-icon-chevron"
+        }, null)]
+      });
+      return _createVNode(ElDropdown, {
+        "trigger": "click",
+        "onCommand": handleCommand,
+        "popper-class": "tiptap-dropdown-menu"
+      }, {
+        default: () => trigger,
+        dropdown: () => _createVNode(ElDropdownMenu, null, {
+          default: () => [!isInTable() ? _createVNode(ElDropdownItem, {
+            "command": "insertTable"
+          }, {
+            default: () => [_createTextVNode("\u63D2\u5165\u8868\u683C")]
+          }) : _createVNode(_Fragment, null, [_createVNode(ElDropdownItem, {
+            "command": "addColumnBefore"
+          }, {
+            default: () => [_createTextVNode("\u5728\u524D\u65B9\u63D2\u5165\u5217")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "addColumnAfter"
+          }, {
+            default: () => [_createTextVNode("\u5728\u540E\u65B9\u63D2\u5165\u5217")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "deleteColumn"
+          }, {
+            default: () => [_createTextVNode("\u5220\u9664\u5F53\u524D\u5217")]
+          }), _createVNode(ElDropdownItem, {
+            "divided": true,
+            "command": "addRowBefore"
+          }, {
+            default: () => [_createTextVNode("\u5728\u4E0A\u65B9\u63D2\u5165\u884C")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "addRowAfter"
+          }, {
+            default: () => [_createTextVNode("\u5728\u4E0B\u65B9\u63D2\u5165\u884C")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "deleteRow"
+          }, {
+            default: () => [_createTextVNode("\u5220\u9664\u5F53\u524D\u884C")]
+          }), _createVNode(ElDropdownItem, {
+            "divided": true,
+            "command": "mergeCells"
+          }, {
+            default: () => [_createTextVNode("\u5408\u5E76\u5355\u5143\u683C")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "splitCell"
+          }, {
+            default: () => [_createTextVNode("\u62C6\u5206\u5355\u5143\u683C")]
+          }), _createVNode(ElDropdownItem, {
+            "divided": true,
+            "command": "toggleHeaderRow"
+          }, {
+            default: () => [_createTextVNode("\u5207\u6362\u8868\u5934\u884C")]
+          }), _createVNode(ElDropdownItem, {
+            "command": "toggleHeaderColumn"
+          }, {
+            default: () => [_createTextVNode("\u5207\u6362\u8868\u5934\u5217")]
+          }), _createVNode(ElDropdownItem, {
+            "divided": true,
+            "command": "deleteTable",
+            "style": {
+              color: "var(--red)"
+            }
+          }, {
+            default: () => [_createTextVNode("\u5220\u9664\u8868\u683C")]
+          })])]
+        })
+      });
+    };
+  }
+});
+export {
+  TableDropdownMenu
+};

package/es/rich-text-editor/menu-system/icons/index.d.ts

@@ -544,3 +544,16 @@ export declare const DivideIcon: import("vue").DefineComponent<import("vue").Ext
 }>> & Readonly<{}>, {
     className: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TableIcon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    className: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    className: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/es/rich-text-editor/menu-system/icons/index.js

@@ -441,6 +441,31 @@ const DivideIcon = createIcon("DivideIcon", _createVNode("path", {
   "stroke-width": "2",
   "stroke-linecap": "round"
 }, null));
+const TableIcon = createIcon("TableIcon", _createVNode(_Fragment, null, [_createVNode("rect", {
+  "x": "3",
+  "y": "3",
+  "width": "18",
+  "height": "18",
+  "rx": "2",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), _createVNode("path", {
+  "d": "M3 9H21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), _createVNode("path", {
+  "d": "M3 15H21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), _createVNode("path", {
+  "d": "M9 3V21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null), _createVNode("path", {
+  "d": "M15 3V21",
+  "stroke": "currentColor",
+  "stroke-width": "2"
+}, null)]));
 export {
   AlignCenterIcon,
   AlignJustifyIcon,
@@ -481,6 +506,7 @@ export {
   StrikeIcon,
   SubscriptIcon,
   SuperscriptIcon,
+  TableIcon,
   TrashIcon,
   UnderlineIcon,
   Undo2Icon