overtype 2.3.7 → 2.3.8

package/dist/overtype.d.ts

@@ -140,6 +140,8 @@ export interface Options {
   // Callbacks
   onChange?: (value: string, instance: OverTypeInstance) => void;
   onKeydown?: (event: KeyboardEvent, instance: OverTypeInstance) => void;
+  onFocus?: (event: FocusEvent, instance: OverTypeInstance) => void;
+  onBlur?: (event: FocusEvent, instance: OverTypeInstance) => void;
 }
 
 // Interface for constructor that returns array
@@ -158,7 +160,8 @@ export interface OverTypeConstructor {
   MarkdownParser: any;
   ShortcutsManager: any;
   init(target: string | Element | NodeList | Element[], options?: Options): OverTypeInstance[];
-  getInstance(element: Element): OverTypeInstance | null;
+  initFromData(target: string | Element | NodeList | Element[], defaults?: Options): OverTypeInstance[];
+  getInstance(target: string | Element | NodeList | Element[]): OverTypeInstance | null;
   destroyAll(): void;
   injectStyles(force?: boolean): void;
   setTheme(theme: string | Theme, customColors?: Partial<Theme['colors']>): void;
@@ -225,6 +228,26 @@ export type OverType = OverTypeInstance;
 // Module exports - default export is the constructor
 export default OverType;
 
+/** Re-exported markdown-actions. Useful for custom toolbar implementations */
+export const markdownActions: {
+  toggleBold(textarea: HTMLTextAreaElement): void;
+  toggleItalic(textarea: HTMLTextAreaElement): void;
+  toggleCode(textarea: HTMLTextAreaElement): void;
+  insertLink(textarea: HTMLTextAreaElement, options?: { url?: string; text?: string }): void;
+  toggleBulletList(textarea: HTMLTextAreaElement): void;
+  toggleNumberedList(textarea: HTMLTextAreaElement): void;
+  toggleQuote(textarea: HTMLTextAreaElement): void;
+  toggleTaskList(textarea: HTMLTextAreaElement): void;
+  insertHeader(textarea: HTMLTextAreaElement, level?: number, toggle?: boolean): void;
+  toggleH1(textarea: HTMLTextAreaElement): void;
+  toggleH2(textarea: HTMLTextAreaElement): void;
+  toggleH3(textarea: HTMLTextAreaElement): void;
+  getActiveFormats(textarea: HTMLTextAreaElement): string[];
+  hasFormat(textarea: HTMLTextAreaElement, format: string): boolean;
+  expandSelection(textarea: HTMLTextAreaElement, options?: object): void;
+  applyCustomFormat(textarea: HTMLTextAreaElement, format: object): void;
+};
+
 /**
  * Pre-defined toolbar buttons
  */

package/dist/overtype.esm.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
@@ -7,6 +7,10 @@
  */
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
@@ -1887,6 +1891,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 __hasOwnProp = Object.prototype.hasOwnProperty;
@@ -1973,6 +2001,9 @@ function mergeWithDefaults(format) {
   return __spreadValues(__spreadValues({}, getDefaultStyle()), format);
 }
 var debugMode = false;
+function setDebugMode(enabled) {
+  debugMode = enabled;
+}
 function getDebugMode() {
   return debugMode;
 }
@@ -2093,6 +2124,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;
 }
@@ -2162,6 +2206,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;
@@ -2535,6 +2588,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;
@@ -2728,6 +2818,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 {
@@ -4653,21 +4788,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) {
@@ -4753,6 +4876,8 @@ var _OverType = class _OverType {
       onChange: null,
       onKeydown: null,
       onRender: null,
+      onFocus: null,
+      onBlur: null,
       // Features
       showActiveLineRaw: false,
       showStats: false,
@@ -5203,6 +5328,24 @@ var _OverType = class _OverType {
     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
@@ -5747,9 +5890,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-")) {
@@ -5761,6 +5904,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
@@ -5777,11 +5947,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;
   }
   /**
@@ -5959,6 +6140,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");
@@ -6007,6 +6204,7 @@ export {
   OverType,
   overtype_default as default,
   defaultToolbarButtons,
+  markdown_actions_esm_exports as markdownActions,
   toolbarButtons
 };
 /**