@oix1987/yjd 1.0.0 → 1.0.2

package/lib/formats/import.js

@@ -1,385 +0,0 @@
-import { InlineFormat } from '../core/format.js';
-import ImportPopup from '../ui/import-popup.js';
-import Editor from '../core/editor.js';
-
-/**
- * Import Format - Handles importing various file types
- * Now supports multiple editor instances with separate popup instances
- */
-class Import extends InlineFormat {
-  static formatName = 'import';
-  static tagName = 'DIV';
-  static className = 'imported-content';
-
-  constructor() {
-    super();
-    
-    // Get current editor instance
-    const currentEditor = Editor.getCurrentInstance();
-    if (!currentEditor) {
-      console.warn('No editor instance found for Import format');
-      return;
-    }
-    
-    this.editorId = currentEditor.instanceId;
-    
-    // Check if this editor already has an import popup instance
-    let importPopup = currentEditor.getPopupInstance('import');
-    
-    if (!importPopup) {
-      // Create new import popup instance for this editor
-      importPopup = new ImportPopup({
-        onImport: (content, fileType) => {
-          Import.insertImportedContent(content, fileType, this.editorId);
-        },
-        editor: currentEditor,
-        editorId: this.editorId
-      });
-      
-      // Store popup instance in editor
-      currentEditor.setPopupInstance('import', importPopup);
-    }
-    
-    this.importPopup = importPopup;
-  }
-
-  /**
-   * Create a new Import format instance for a specific editor
-   * @param {string} editorId - Editor instance ID
-   * @returns {Import} Import format instance
-   */
-  static createForEditor(editorId) {
-    const editor = Editor.getInstanceById(editorId);
-    if (!editor) {
-      console.warn('No editor instance found for ID:', editorId);
-      return null;
-    }
-    
-    // Temporarily set as current instance
-    const originalCurrent = Editor.currentInstance;
-    Editor.currentInstance = editor;
-    
-    // Create format instance
-    const format = new Import();
-    
-    // Restore original current instance
-    Editor.currentInstance = originalCurrent;
-    
-    return format;
-  }
-
-  /**
-   * Insert imported content at current cursor position
-   * @param {string} content - Imported content
-   * @param {string} fileType - Type of imported file
-   * @param {string} editorId - Editor instance ID
-   */
-  static insertImportedContent(content, fileType, editorId = null) {
-    // Get the correct editor instance
-    let editor = null;
-    if (editorId) {
-      editor = Editor.getInstanceById(editorId);
-    } else {
-      editor = Editor.getCurrentInstance();
-    }
-    
-    if (!editor) {
-      console.warn('No editor instance found for content insertion');
-      return;
-    }
-    
-    const selection = window.getSelection();
-    if (!selection || !selection.rangeCount) return;
-
-    try {
-      const range = selection.getRangeAt(0);
-      
-      // Create content element based on file type
-      let contentElement;
-      
-      if (fileType === 'html') {
-        contentElement = Import.processHtmlContent(content);
-      } else if (fileType === 'excel') {
-        contentElement = Import.processExcelContent(content);
-      } else if (fileType === 'pdf' || fileType === 'word') {
-        contentElement = Import.processTextContent(content);
-      } else {
-        contentElement = Import.processTextContent(content);
-      }
-      
-      // Insert content at cursor position
-      range.deleteContents();
-      range.insertNode(contentElement);
-      
-      // Position cursor after the content
-      range.setStartAfter(contentElement);
-      range.collapse(true);
-      selection.removeAllRanges();
-      selection.addRange(range);
-      
-      // Trigger content change event
-      if (editor && typeof editor.onContentChange === 'function') {
-        editor.onContentChange();
-      }
-      
-    } catch (error) {
-      console.error('Error inserting imported content:', error);
-    }
-  }
-
-  /**
-   * Process HTML content
-   * @param {string} htmlContent - HTML content to process
-   * @returns {HTMLElement}
-   */
-  static processHtmlContent(htmlContent) {
-    const container = document.createElement('div');
-    container.className = 'imported-content html-content';
-    
-    // Create a temporary element to parse HTML safely
-    const temp = document.createElement('div');
-    temp.innerHTML = htmlContent;
-    
-    // Clean and transfer content
-    Import.cleanHtmlContent(temp);
-    container.appendChild(temp);
-    
-    return container;
-  }
-
-  /**
-   * Process Excel content (CSV-like data)
-   * @param {Array} data - Excel data as array of arrays
-   * @returns {HTMLElement}
-   */
-  static processExcelContent(data) {
-    const container = document.createElement('div');
-    container.className = 'imported-content excel-content';
-    
-    if (!Array.isArray(data) || data.length === 0) {
-      container.textContent = 'No data to import';
-      return container;
-    }
-    
-    // Create table
-    const table = document.createElement('table');
-    table.className = 'imported-table';
-    
-    // Add header row if available
-    if (data.length > 0) {
-      const thead = document.createElement('thead');
-      const headerRow = document.createElement('tr');
-      
-      data[0].forEach(cellData => {
-        const th = document.createElement('th');
-        th.textContent = cellData || '';
-        headerRow.appendChild(th);
-      });
-      
-      thead.appendChild(headerRow);
-      table.appendChild(thead);
-    }
-    
-    // Add data rows
-    if (data.length > 1) {
-      const tbody = document.createElement('tbody');
-      
-      for (let i = 1; i < data.length; i++) {
-        const row = document.createElement('tr');
-        
-        data[i].forEach(cellData => {
-          const td = document.createElement('td');
-          td.textContent = cellData || '';
-          row.appendChild(td);
-        });
-        
-        tbody.appendChild(row);
-      }
-      
-      table.appendChild(tbody);
-    }
-    
-    container.appendChild(table);
-    return container;
-  }
-
-  /**
-   * Process plain text content (PDF, Word)
-   * @param {string} textContent - Text content to process
-   * @returns {HTMLElement}
-   */
-  static processTextContent(textContent) {
-    const container = document.createElement('div');
-    container.className = 'imported-content text-content';
-    
-    // Split into paragraphs and process
-    const paragraphs = textContent.split(/\n\s*\n/);
-    
-    paragraphs.forEach(paragraph => {
-      if (paragraph.trim()) {
-        const p = document.createElement('p');
-        p.textContent = paragraph.trim();
-        container.appendChild(p);
-      }
-    });
-    
-    return container;
-  }
-
-  /**
-   * Clean HTML content by removing dangerous elements and attributes
-   * @param {HTMLElement} element - Element to clean
-   */
-  static cleanHtmlContent(element) {
-    const allowedTags = ['p', 'div', 'span', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 
-                        'strong', 'b', 'em', 'i', 'u', 'ul', 'ol', 'li', 'br', 
-                        'table', 'thead', 'tbody', 'tr', 'th', 'td'];
-    
-    const allowedAttrs = ['class', 'style'];
-    
-    const walker = document.createTreeWalker(
-      element,
-      NodeFilter.SHOW_ELEMENT,
-      null,
-      false
-    );
-    
-    const elementsToRemove = [];
-    
-    while (walker.nextNode()) {
-      const node = walker.currentNode;
-      
-      // Remove dangerous tags
-      if (!allowedTags.includes(node.tagName.toLowerCase())) {
-        elementsToRemove.push(node);
-        continue;
-      }
-      
-      // Clean attributes
-      const attrs = Array.from(node.attributes);
-      attrs.forEach(attr => {
-        if (!allowedAttrs.includes(attr.name.toLowerCase())) {
-          node.removeAttribute(attr.name);
-        }
-      });
-    }
-    
-    // Remove dangerous elements
-    elementsToRemove.forEach(el => {
-      if (el.parentNode) {
-        el.parentNode.removeChild(el);
-      }
-    });
-  }
-
-  /**
-   * Parse CSV content
-   * @param {string} csvContent - CSV content
-   * @returns {Array} - Array of arrays representing CSV data
-   */
-  static parseCSV(csvContent) {
-    const lines = csvContent.split('\n');
-    const result = [];
-    
-    lines.forEach(line => {
-      if (line.trim()) {
-        // Simple CSV parsing (doesn't handle quoted values with commas)
-        const cells = line.split(',').map(cell => cell.trim().replace(/^["']|["']$/g, ''));
-        result.push(cells);
-      }
-    });
-    
-    return result;
-  }
-
-  /**
-   * Apply import formatting - shows import popup
-   */
-  apply() {
-    this.showImportPopup();
-  }
-
-  /**
-   * Toggle import formatting - shows import popup
-   */
-  toggle() {
-    if (this.importPopup.isVisible) {
-      this.importPopup.hide();
-    } else {
-      this.showImportPopup();
-    }
-  }
-
-  /**
-   * Show import popup
-   */
-  showImportPopup() {
-    // Find import button in the current editor's toolbar
-    const editor = Editor.getInstanceById(this.editorId);
-    if (!editor) return;
-    
-    const toolbar = editor.getModule('toolbar');
-    let importButton = null;
-    
-    if (toolbar) {
-      importButton = toolbar.getButton('import');
-    }
-    
-    // Fallback: find button by class in the current editor's toolbar
-    if (!importButton) {
-      const toolbarContainer = toolbar?.getContainer();
-      if (toolbarContainer) {
-        importButton = toolbarContainer.querySelector('.rich-editor-toolbar-btn.import-btn');
-      }
-    }
-    
-    // Final fallback: find any import button in the current editor's wrapper
-    if (!importButton) {
-      importButton = editor.wrapper.querySelector('.rich-editor-toolbar-btn.import-btn');
-    }
-    
-    if (!importButton) {
-      console.warn('Import button not found for editor:', this.editorId);
-      return;
-    }
-    
-    this.importPopup.show(importButton);
-  }
-
-  /**
-   * Check if import formatting is active
-   */
-  isActive() {
-    return false; // Import doesn't have an "active" state
-  }
-
-  /**
-   * Get supported file types
-   */
-  static getSupportedTypes() {
-    return {
-      html: {
-        extensions: ['.html', '.htm'],
-        mimeTypes: ['text/html'],
-        name: 'HTML Files'
-      },
-      excel: {
-        extensions: ['.csv', '.xlsx', '.xls'],
-        mimeTypes: ['text/csv', 'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
-        name: 'Excel Files'
-      },
-      pdf: {
-        extensions: ['.pdf'],
-        mimeTypes: ['application/pdf'],
-        name: 'PDF Files'
-      },
-      word: {
-        extensions: ['.doc', '.docx'],
-        mimeTypes: ['application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'],
-        name: 'Word Documents'
-      }
-    };
-  }
-}
-
-export default Import; 

package/lib/formats/indent.js

@@ -1,297 +0,0 @@
-import { BlockFormat } from '../core/format.js';
-import { saveBeforeFormat } from '../utils/history-helper.js';
-import Editor from '../core/editor.js';
-
-/**
- * Indent Format - Handles text indentation (increase/decrease)
- */
-class Indent extends BlockFormat {
-  static formatName = 'indent';
-  static tagName = 'DIV';
-  static attribute = 'style';
-
-  constructor() {
-    super();
-  }
-
-  /**
-   * Create element with indentation
-   * @param {string} value - Indent level (e.g., '20px', '40px')
-   * @returns {HTMLElement}
-   */
-  static create(value) {
-    const node = document.createElement('DIV');
-    if (value) {
-      node.style.paddingLeft = value;
-    }
-    return node;
-  }
-
-  /**
-   * Apply indent to current selection
-   * @param {string} direction - 'increase' or 'decrease'
-   */
-  static applyIndentToCurrentSelection(direction) {
-    const selection = window.getSelection();
-    if (!selection || !selection.rangeCount) return;
-
-    // Save state before applying format
-    saveBeforeFormat();
-
-    try {
-      const range = selection.getRangeAt(0);
-      const blockElements = Indent.getSelectedBlockElements(range);
-      
-      if (blockElements.length === 0) {
-        // If no block elements found, create one and apply indent
-        const newBlock = document.createElement('DIV');
-        newBlock.style.paddingLeft = direction === 'increase' ? '20px' : '0px';
-        
-        // Get selected text or use default
-        const selectedText = range.toString() || '';
-        if (selectedText) {
-          newBlock.textContent = selectedText;
-          range.deleteContents();
-          range.insertNode(newBlock);
-        } else {
-          // Insert at cursor position
-          range.insertNode(newBlock);
-          newBlock.innerHTML = '<br>'; // Make it editable
-        }
-        
-        // Position cursor in the new block
-        const newRange = document.createRange();
-        newRange.selectNodeContents(newBlock);
-        newRange.collapse(false);
-        selection.removeAllRanges();
-        selection.addRange(newRange);
-      } else {
-        // Apply indent to existing blocks
-        blockElements.forEach(block => {
-          Indent.applyIndentToBlock(block, direction);
-        });
-      }
-    } catch (error) {
-      console.error('Error applying indent:', error);
-    }
-    
-    // Trigger content change after applying format
-    setTimeout(() => {
-      const currentEditor = Editor.getCurrentInstance();
-      if (currentEditor && typeof currentEditor.onContentChange === 'function') {
-        currentEditor.onContentChange();
-      }
-    }, 0);
-  }
-
-  /**
-   * Apply indent to a specific block element
-   * @param {HTMLElement} block - Block element to indent
-   * @param {string} direction - 'increase' or 'decrease'
-   */
-  static applyIndentToBlock(block, direction) {
-    if (!block || !block.style) return;
-
-    const currentIndent = parseInt(block.style.paddingLeft) || 0;
-    let newIndent;
-
-    if (direction === 'increase') {
-      newIndent = currentIndent + 20; // Increase by 20px
-    } else {
-      newIndent = Math.max(0, currentIndent - 20); // Decrease by 20px, minimum 0
-    }
-
-    if (newIndent === 0) {
-      block.style.paddingLeft = '';
-    } else {
-      block.style.paddingLeft = newIndent + 'px';
-    }
-  }
-
-  /**
-   * Get all selected block elements
-   */
-  static getSelectedBlockElements(range) {
-    const blocks = [];
-    const startContainer = range.startContainer;
-    const endContainer = range.endContainer;
-    
-    // Get start block
-    const startBlock = Indent.getBlockElement(startContainer);
-    if (startBlock) blocks.push(startBlock);
-    
-    // If selection spans multiple blocks, get all blocks in between
-    if (startContainer !== endContainer) {
-      let currentNode = startBlock;
-      while (currentNode && currentNode !== endContainer) {
-        const nextBlock = Indent.getNextBlockElement(currentNode);
-        if (nextBlock && !blocks.includes(nextBlock)) {
-          blocks.push(nextBlock);
-          currentNode = nextBlock;
-        } else {
-          break;
-        }
-      }
-      
-      // Get end block
-      const endBlock = Indent.getBlockElement(endContainer);
-      if (endBlock && !blocks.includes(endBlock)) {
-        blocks.push(endBlock);
-      }
-    }
-    
-    return blocks;
-  }
-
-  /**
-   * Get the block element containing the given node
-   */
-  static getBlockElement(node) {
-    if (!node) return null;
-    
-    let currentNode = node;
-    while (currentNode && currentNode !== document.body) {
-      if (currentNode.nodeType === Node.ELEMENT_NODE) {
-        const tagName = currentNode.tagName;
-        if (['P', 'DIV', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'BLOCKQUOTE', 'LI'].includes(tagName)) {
-          return currentNode;
-        }
-      }
-      currentNode = currentNode.parentNode;
-    }
-    return null;
-  }
-
-  /**
-   * Get next block element in document order
-   */
-  static getNextBlockElement(element) {
-    let currentNode = element.nextSibling;
-    
-    while (currentNode) {
-      if (currentNode.nodeType === Node.ELEMENT_NODE) {
-        const tagName = currentNode.tagName;
-        if (['P', 'DIV', 'H1', 'H2', 'H3', 'H4', 'H5', 'H6', 'BLOCKQUOTE', 'LI'].includes(tagName)) {
-          return currentNode;
-        }
-      }
-      currentNode = currentNode.nextSibling;
-    }
-    
-    return null;
-  }
-
-  /**
-   * Apply indent formatting
-   * @param {string} value - Direction ('increase' or 'decrease')
-   */
-  apply(value = 'increase') {
-    Indent.applyIndentToCurrentSelection(value);
-  }
-
-  /**
-   * Remove indent formatting (reset to 0)
-   */
-  remove() {
-    Indent.applyIndentToCurrentSelection('remove');
-  }
-
-  /**
-   * Check if indent formatting is active
-   * @returns {boolean}
-   */
-  isActive() {
-    const selection = window.getSelection();
-    if (!selection || !selection.rangeCount) return false;
-
-    const range = selection.getRangeAt(0);
-    const blockElement = Indent.getBlockElement(range.commonAncestorContainer);
-    
-    if (!blockElement) return false;
-    
-    const paddingLeft = parseInt(blockElement.style.paddingLeft) || 0;
-    return paddingLeft > 0;
-  }
-
-  /**
-   * Get current indent level
-   * @returns {number}
-   */
-  static getCurrentIndentLevel() {
-    const selection = window.getSelection();
-    if (!selection || !selection.rangeCount) return 0;
-
-    const range = selection.getRangeAt(0);
-    const blockElement = Indent.getBlockElement(range.commonAncestorContainer);
-    
-    if (!blockElement) return 0;
-    
-    return parseInt(blockElement.style.paddingLeft) || 0;
-  }
-
-  /**
-   * Get current indent level (instance method)
-   * @returns {number}
-   */
-  getCurrentIndentLevel() {
-    return Indent.getCurrentIndentLevel();
-  }
-}
-
-/**
- * Indent Increase Format - Handles increasing indentation
- */
-class IndentIncrease extends Indent {
-  static formatName = 'indent-increase';
-
-  /**
-   * Apply increase indent formatting
-   */
-  apply() {
-    Indent.applyIndentToCurrentSelection('increase');
-  }
-
-  /**
-   * Toggle increase indent - always increases
-   */
-  toggle() {
-    this.apply();
-  }
-
-  /**
-   * Never active - this is an action button
-   */
-  isActive() {
-    return false;
-  }
-}
-
-/**
- * Indent Decrease Format - Handles decreasing indentation
- */
-class IndentDecrease extends Indent {
-  static formatName = 'indent-decrease';
-
-  /**
-   * Apply decrease indent formatting
-   */
-  apply() {
-    Indent.applyIndentToCurrentSelection('decrease');
-  }
-
-  /**
-   * Toggle decrease indent - always decreases
-   */
-  toggle() {
-    this.apply();
-  }
-
-  /**
-   * Never active - this is an action button
-   */
-  isActive() {
-    return false;
-  }
-}
-
-export { Indent as default, IndentIncrease, IndentDecrease }; 

package/lib/formats/italic.js

@@ -1,27 +0,0 @@
-import { InlineFormat } from '../core/format.js';
-import { saveBeforeFormat } from '../utils/history-helper.js';
-
-/**
- * Italic Format - Handles italic text formatting
- */
-class Italic extends InlineFormat {
-  static formatName = 'italic';
-  static tagName = 'I';
-  static alternativeTagNames = ['EM'];
-
-  /**
-   * Toggle italic formatting
-   */
-  toggle() {
-    // Save state before applying format
-    saveBeforeFormat();
-
-    if (this.isActive()) {
-      this.remove();
-    } else {
-      this.apply();
-    }
-  }
-}
-
-export default Italic;