overtype 2.3.6 → 2.3.8

package/dist/overtype.cjs

@@ -1,5 +1,5 @@
 /**
- * OverType v2.3.6
+ * OverType v2.3.8
  * A lightweight markdown editor library with perfect WYSIWYG alignment
  * @license MIT
  * @author David Miranda
@@ -34,6 +34,7 @@ __export(overtype_exports, {
   OverType: () => OverType,
   default: () => overtype_default,
   defaultToolbarButtons: () => defaultToolbarButtons,
+  markdownActions: () => markdown_actions_esm_exports,
   toolbarButtons: () => toolbarButtons
 });
 module.exports = __toCommonJS(overtype_exports);
@@ -148,13 +149,13 @@ var MarkdownParser = class {
    * @returns {string} Parsed task list item
    */
   static parseTaskList(html, isPreviewMode = false) {
-    return html.replace(/^((?: )*)-\s+\[([ xX])\]\s+(.+)$/, (match, indent, checked, content) => {
+    return html.replace(/^((?: )*)-(\s+)\[([ xX])\](\s*)(.*)$/, (match, indent, spacingBeforeBox, checked, spacingAfterBox, content) => {
       content = this.parseInlineElements(content);
       if (isPreviewMode) {
         const isChecked = checked.toLowerCase() === "x";
         return `${indent}<li class="task-list"><input type="checkbox" ${isChecked ? "checked" : ""}> ${content}</li>`;
       } else {
-        return `${indent}<li class="task-list"><span class="syntax-marker">- [${checked}] </span>${content}</li>`;
+        return `${indent}<li class="task-list"><span class="syntax-marker">-${spacingBeforeBox}[${checked}]${spacingAfterBox}</span>${content}</li>`;
       }
     });
   }
@@ -1913,6 +1914,30 @@ function generateStyles(options = {}) {
 }
 
 // node_modules/markdown-actions/dist/markdown-actions.esm.js
+var markdown_actions_esm_exports = {};
+__export(markdown_actions_esm_exports, {
+  applyCustomFormat: () => applyCustomFormat,
+  default: () => src_default,
+  expandSelection: () => expandSelection2,
+  getActiveFormats: () => getActiveFormats2,
+  getDebugMode: () => getDebugMode,
+  hasFormat: () => hasFormat2,
+  insertHeader: () => insertHeader,
+  insertLink: () => insertLink,
+  preserveSelection: () => preserveSelection,
+  setDebugMode: () => setDebugMode,
+  setUndoMethod: () => setUndoMethod,
+  toggleBold: () => toggleBold,
+  toggleBulletList: () => toggleBulletList,
+  toggleCode: () => toggleCode,
+  toggleH1: () => toggleH1,
+  toggleH2: () => toggleH2,
+  toggleH3: () => toggleH3,
+  toggleItalic: () => toggleItalic,
+  toggleNumberedList: () => toggleNumberedList,
+  toggleQuote: () => toggleQuote,
+  toggleTaskList: () => toggleTaskList
+});
 var __defProp2 = Object.defineProperty;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp2 = Object.prototype.hasOwnProperty;
@@ -1999,6 +2024,9 @@ function mergeWithDefaults(format) {
   return __spreadValues(__spreadValues({}, getDefaultStyle()), format);
 }
 var debugMode = false;
+function setDebugMode(enabled) {
+  debugMode = enabled;
+}
 function getDebugMode() {
   return debugMode;
 }
@@ -2119,6 +2147,19 @@ function insertText(textarea, { text, selectionStart, selectionEnd }) {
     console.groupEnd();
   }
 }
+function setUndoMethod(method) {
+  switch (method) {
+    case "native":
+      canInsertText = true;
+      break;
+    case "manual":
+      canInsertText = false;
+      break;
+    case "auto":
+      canInsertText = null;
+      break;
+  }
+}
 function isMultipleLines(string) {
   return string.trim().split("\n").length > 1;
 }
@@ -2188,6 +2229,15 @@ function newlinesToSurroundSelectedText(textarea) {
   }
   return { newlinesToAppend, newlinesToPrepend };
 }
+function preserveSelection(textarea, callback) {
+  const start = textarea.selectionStart;
+  const end = textarea.selectionEnd;
+  const scrollTop = textarea.scrollTop;
+  callback();
+  textarea.selectionStart = start;
+  textarea.selectionEnd = end;
+  textarea.scrollTop = scrollTop;
+}
 function applyLineOperation(textarea, operation, options = {}) {
   const originalStart = textarea.selectionStart;
   const originalEnd = textarea.selectionEnd;
@@ -2561,6 +2611,43 @@ function getActiveFormats(textarea) {
   }
   return formats;
 }
+function hasFormat(textarea, format) {
+  const activeFormats = getActiveFormats(textarea);
+  return activeFormats.includes(format);
+}
+function expandSelection(textarea, options = {}) {
+  if (!textarea)
+    return;
+  const { toWord, toLine, toFormat } = options;
+  const { selectionStart, selectionEnd, value } = textarea;
+  if (toLine) {
+    const lines = value.split("\n");
+    let lineStart = 0;
+    let lineEnd = 0;
+    let currentPos = 0;
+    for (const line of lines) {
+      if (selectionStart >= currentPos && selectionStart <= currentPos + line.length) {
+        lineStart = currentPos;
+        lineEnd = currentPos + line.length;
+        break;
+      }
+      currentPos += line.length + 1;
+    }
+    textarea.selectionStart = lineStart;
+    textarea.selectionEnd = lineEnd;
+  } else if (toWord && selectionStart === selectionEnd) {
+    let start = selectionStart;
+    let end = selectionEnd;
+    while (start > 0 && !/\s/.test(value[start - 1])) {
+      start--;
+    }
+    while (end < value.length && !/\s/.test(value[end])) {
+      end++;
+    }
+    textarea.selectionStart = start;
+    textarea.selectionEnd = end;
+  }
+}
 function toggleBold(textarea) {
   if (!textarea || textarea.disabled || textarea.readOnly)
     return;
@@ -2754,6 +2841,51 @@ function toggleH3(textarea) {
 function getActiveFormats2(textarea) {
   return getActiveFormats(textarea);
 }
+function hasFormat2(textarea, format) {
+  return hasFormat(textarea, format);
+}
+function expandSelection2(textarea, options = {}) {
+  expandSelection(textarea, options);
+}
+function applyCustomFormat(textarea, format) {
+  if (!textarea || textarea.disabled || textarea.readOnly)
+    return;
+  const style = mergeWithDefaults(format);
+  let result;
+  if (style.multiline) {
+    const selectedText = textarea.value.slice(textarea.selectionStart, textarea.selectionEnd);
+    if (isMultipleLines(selectedText)) {
+      result = multilineStyle(textarea, style);
+    } else {
+      result = blockStyle(textarea, style);
+    }
+  } else {
+    result = blockStyle(textarea, style);
+  }
+  insertText(textarea, result);
+}
+var src_default = {
+  toggleBold,
+  toggleItalic,
+  toggleCode,
+  insertLink,
+  toggleBulletList,
+  toggleNumberedList,
+  toggleQuote,
+  toggleTaskList,
+  insertHeader,
+  toggleH1,
+  toggleH2,
+  toggleH3,
+  getActiveFormats: getActiveFormats2,
+  hasFormat: hasFormat2,
+  expandSelection: expandSelection2,
+  applyCustomFormat,
+  preserveSelection,
+  setUndoMethod,
+  setDebugMode,
+  getDebugMode
+};
 
 // src/toolbar.js
 var Toolbar = class {
@@ -4679,21 +4811,9 @@ var _OverType = class _OverType {
    * @returns {Array} Array of OverType instances
    */
   constructor(target, options = {}) {
-    let elements;
-    if (typeof target === "string") {
-      elements = document.querySelectorAll(target);
-      if (elements.length === 0) {
-        throw new Error(`No elements found for selector: ${target}`);
-      }
-      elements = Array.from(elements);
-    } else if (target instanceof Element) {
-      elements = [target];
-    } else if (target instanceof NodeList) {
-      elements = Array.from(target);
-    } else if (Array.isArray(target)) {
-      elements = target;
-    } else {
-      throw new Error("Invalid target: must be selector string, Element, NodeList, or Array");
+    const elements = _OverType._resolveTargets(target);
+    if (typeof target === "string" && elements.length === 0) {
+      throw new Error(`No elements found for selector: ${target}`);
     }
     const instances = elements.map((element) => {
       if (element.overTypeInstance) {
@@ -4741,7 +4861,7 @@ var _OverType = class _OverType {
     });
     this.initialized = true;
     if (this.options.onChange) {
-      this.options.onChange(this.getValue(), this);
+      this._notifyChange();
     }
   }
   /**
@@ -4779,6 +4899,8 @@ var _OverType = class _OverType {
       onChange: null,
       onKeydown: null,
       onRender: null,
+      onFocus: null,
+      onBlur: null,
       // Features
       showActiveLineRaw: false,
       showStats: false,
@@ -5181,13 +5303,19 @@ var _OverType = class _OverType {
     if (this.options.showStats && this.statsBar) {
       this._updateStats();
     }
-    if (this.options.onChange && this.initialized) {
-      this.options.onChange(text, this);
-    }
     if (this.options.onRender) {
       this.options.onRender(this.preview, isPreviewMode ? "preview" : "normal", this);
     }
   }
+  /**
+   * Notify listeners that the editor value changed
+   * @private
+   */
+  _notifyChange() {
+    if (!this.options.onChange || !this.initialized)
+      return;
+    this.options.onChange(this.textarea.value, this);
+  }
   /**
    * Apply background styling to code blocks
    * @private
@@ -5221,6 +5349,25 @@ var _OverType = class _OverType {
    */
   handleInput(event) {
     this.updatePreview();
+    this._notifyChange();
+  }
+  /**
+   * Handle focus events
+   * @private
+   */
+  handleFocus(event) {
+    if (this.options.onFocus) {
+      this.options.onFocus(event, this);
+    }
+  }
+  /**
+   * Handle blur events
+   * @private
+   */
+  handleBlur(event) {
+    if (this.options.onBlur) {
+      this.options.onBlur(event, this);
+    }
   }
   /**
    * Handle keydown events
@@ -5401,11 +5548,15 @@ var _OverType = class _OverType {
    * @param {string} value - Markdown content to set
    */
   setValue(value) {
+    const didChange = this.textarea.value !== value;
     this.textarea.value = value;
     this.updatePreview();
     if (this.options.autoResize) {
       this._updateAutoHeight();
     }
+    if (didChange) {
+      this._notifyChange();
+    }
   }
   /**
    * Execute an action by ID
@@ -5762,9 +5913,9 @@ var _OverType = class _OverType {
    * // HTML: <div class="editor" data-ot-toolbar="true" data-ot-theme="cave"></div>
    * OverType.initFromData('.editor', { fontSize: '14px' });
    */
-  static initFromData(selector, defaults = {}) {
-    const elements = document.querySelectorAll(selector);
-    return Array.from(elements).map((el) => {
+  static initFromData(target, defaults = {}) {
+    const elements = _OverType._resolveTargets(target);
+    return elements.map((el) => {
       const options = { ...defaults };
       for (const attr of el.attributes) {
         if (attr.name.startsWith("data-ot-")) {
@@ -5776,6 +5927,33 @@ var _OverType = class _OverType {
       return new _OverType(el, options)[0];
     });
   }
+  /**
+   * Normalize various target shapes to an array of Elements
+   * @private
+   * @param {string|Element|NodeList|Element[]} target
+   * @returns {Element[]}
+   */
+  static _resolveTargets(target) {
+    if (target == null) {
+      throw new Error("Invalid target: must be selector string, Element, NodeList, or Array");
+    }
+    if (typeof target === "string") {
+      return Array.from(document.querySelectorAll(target));
+    }
+    if (target instanceof Element) {
+      return [target];
+    }
+    if (target instanceof NodeList) {
+      return Array.from(target);
+    }
+    if (Array.isArray(target)) {
+      return target;
+    }
+    if (typeof target.length === "number") {
+      return Array.from(target);
+    }
+    throw new Error("Invalid target: must be selector string, Element, NodeList, or Array");
+  }
   /**
    * Parse a data attribute value to the appropriate type
    * @private
@@ -5792,11 +5970,22 @@ var _OverType = class _OverType {
     return value;
   }
   /**
-   * Get instance from element
-   * @param {Element} element - DOM element
-   * @returns {OverType|null} OverType instance or null
+   * Get instance from a target. Accepts the same shapes as the constructor;
+   * for multi-element targets, returns the instance for the first matching
+   * element, or null if none.
+   * @param {string|Element|NodeList|Element[]} target
+   * @returns {OverType|null}
    */
-  static getInstance(element) {
+  static getInstance(target) {
+    let element;
+    if (target instanceof Element) {
+      element = target;
+    } else {
+      const elements = _OverType._resolveTargets(target);
+      element = elements[0];
+    }
+    if (!element)
+      return null;
     return element.overTypeInstance || _OverType.instances.get(element) || null;
   }
   /**
@@ -5974,6 +6163,22 @@ var _OverType = class _OverType {
           instance.handleKeydown(e);
       }
     });
+    document.addEventListener("focus", (e) => {
+      if (e.target && e.target.classList && e.target.classList.contains("overtype-input")) {
+        const wrapper = e.target.closest(".overtype-wrapper");
+        const instance = wrapper == null ? void 0 : wrapper._instance;
+        if (instance)
+          instance.handleFocus(e);
+      }
+    }, true);
+    document.addEventListener("blur", (e) => {
+      if (e.target && e.target.classList && e.target.classList.contains("overtype-input")) {
+        const wrapper = e.target.closest(".overtype-wrapper");
+        const instance = wrapper == null ? void 0 : wrapper._instance;
+        if (instance)
+          instance.handleBlur(e);
+      }
+    }, true);
     document.addEventListener("scroll", (e) => {
       if (e.target && e.target.classList && e.target.classList.contains("overtype-input")) {
         const wrapper = e.target.closest(".overtype-wrapper");
@@ -6022,6 +6227,7 @@ var overtype_default = OverType;
 0 && (module.exports = {
   OverType,
   defaultToolbarButtons,
+  markdownActions,
   toolbarButtons
 });
 /**