overtype 2.3.7 → 2.3.8

package/dist/overtype-webcomponent.js

@@ -1,5 +1,5 @@
 /**
- * OverType v2.3.7
+ * OverType v2.3.8
  * A lightweight markdown editor library with perfect WYSIWYG alignment
  * @license MIT
  * @author David Miranda
@@ -1910,6 +1910,30 @@ var OverTypeEditor = (() => {
   }
 
   // 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;
@@ -1996,6 +2020,9 @@ var OverTypeEditor = (() => {
     return __spreadValues(__spreadValues({}, getDefaultStyle()), format);
   }
   var debugMode = false;
+  function setDebugMode(enabled) {
+    debugMode = enabled;
+  }
   function getDebugMode() {
     return debugMode;
   }
@@ -2116,6 +2143,19 @@ var OverTypeEditor = (() => {
       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;
   }
@@ -2185,6 +2225,15 @@ var OverTypeEditor = (() => {
     }
     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;
@@ -2558,6 +2607,43 @@ ${blockSuffix}` : suffix;
     }
     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;
@@ -2751,6 +2837,51 @@ ${blockSuffix}` : suffix;
   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 {
@@ -4676,21 +4807,9 @@ ${blockSuffix}` : suffix;
      * @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) {
@@ -4776,6 +4895,8 @@ ${blockSuffix}` : suffix;
         onChange: null,
         onKeydown: null,
         onRender: null,
+        onFocus: null,
+        onBlur: null,
         // Features
         showActiveLineRaw: false,
         showStats: false,
@@ -5226,6 +5347,24 @@ ${blockSuffix}` : suffix;
       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
      * @private
@@ -5770,9 +5909,9 @@ ${blockSuffix}` : suffix;
      * // 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-")) {
@@ -5784,6 +5923,33 @@ ${blockSuffix}` : suffix;
         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
@@ -5800,11 +5966,22 @@ ${blockSuffix}` : suffix;
       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;
     }
     /**
@@ -5982,6 +6159,22 @@ ${blockSuffix}` : suffix;
             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");