overtype 2.0.6 → 2.1.0

package/dist/overtype.js

@@ -53,6 +53,24 @@ var OverType = (() => {
     static setCodeHighlighter(highlighter) {
       this.codeHighlighter = highlighter;
     }
+    /**
+     * Set custom syntax processor function
+     * @param {Function|null} processor - Function that takes (html) and returns modified HTML
+     */
+    static setCustomSyntax(processor) {
+      this.customSyntax = processor;
+    }
+    /**
+     * Apply custom syntax processor to parsed HTML
+     * @param {string} html - Parsed HTML line
+     * @returns {string} HTML with custom syntax applied
+     */
+    static applyCustomSyntax(html) {
+      if (this.customSyntax) {
+        return this.customSyntax(html);
+      }
+      return html;
+    }
     /**
      * Escape HTML special characters
      * @param {string} text - Raw text to escape
@@ -391,14 +409,14 @@ var OverType = (() => {
         const codeFenceRegex = /^```[^`]*$/;
         if (codeFenceRegex.test(line)) {
           inCodeBlock = !inCodeBlock;
-          return this.parseLine(line, isPreviewMode);
+          return this.applyCustomSyntax(this.parseLine(line, isPreviewMode));
         }
         if (inCodeBlock) {
           const escaped = this.escapeHtml(line);
           const indented = this.preserveIndentation(escaped, line);
           return `<div>${indented || "&nbsp;"}</div>`;
         }
-        return this.parseLine(line, isPreviewMode);
+        return this.applyCustomSyntax(this.parseLine(line, isPreviewMode));
       });
       const html = parsedLines.join("");
       return this.postProcessHTML(html, instanceHighlighter);
@@ -730,6 +748,8 @@ var OverType = (() => {
   __publicField(MarkdownParser, "linkIndex", 0);
   // Global code highlighter function
   __publicField(MarkdownParser, "codeHighlighter", null);
+  // Custom syntax processor function
+  __publicField(MarkdownParser, "customSyntax", null);
   /**
    * List pattern definitions
    */
@@ -4110,6 +4130,8 @@ ${blockSuffix}` : suffix;
         this.statsBar.className = "overtype-stats";
         this.container.appendChild(this.statsBar);
         this._updateStats();
+      } else if (show && this.statsBar) {
+        this._updateStats();
       } else if (!show && this.statsBar) {
         this.statsBar.remove();
         this.statsBar = null;
@@ -4178,6 +4200,44 @@ ${blockSuffix}` : suffix;
     static init(target, options = {}) {
       return new _OverType(target, options);
     }
+    /**
+     * Initialize editors with options from data-ot-* attributes
+     * @param {string} selector - CSS selector for target elements
+     * @param {Object} defaults - Default options (data attrs override these)
+     * @returns {Array<OverType>} Array of OverType instances
+     * @example
+     * // 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) => {
+        const options = { ...defaults };
+        for (const attr of el.attributes) {
+          if (attr.name.startsWith("data-ot-")) {
+            const kebab = attr.name.slice(8);
+            const key = kebab.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+            options[key] = _OverType._parseDataValue(attr.value);
+          }
+        }
+        return new _OverType(el, options);
+      });
+    }
+    /**
+     * Parse a data attribute value to the appropriate type
+     * @private
+     */
+    static _parseDataValue(value) {
+      if (value === "true")
+        return true;
+      if (value === "false")
+        return false;
+      if (value === "null")
+        return null;
+      if (value !== "" && !isNaN(Number(value)))
+        return Number(value);
+      return value;
+    }
     /**
      * Get instance from element
      * @param {Element} element - DOM element
@@ -4278,6 +4338,32 @@ ${blockSuffix}` : suffix;
         }
       });
     }
+    /**
+     * Set custom syntax processor for extending markdown parsing
+     * @param {Function|null} processor - Function that takes (html) and returns modified HTML
+     * @example
+     * OverType.setCustomSyntax((html) => {
+     *   // Highlight footnote references [^1]
+     *   return html.replace(/\[\^(\w+)\]/g, '<span class="footnote-ref">$&</span>');
+     * });
+     */
+    static setCustomSyntax(processor) {
+      MarkdownParser.setCustomSyntax(processor);
+      document.querySelectorAll(".overtype-wrapper").forEach((wrapper) => {
+        const instance = wrapper._instance;
+        if (instance && instance.updatePreview) {
+          instance.updatePreview();
+        }
+      });
+      document.querySelectorAll("overtype-editor").forEach((webComponent) => {
+        if (typeof webComponent.getEditor === "function") {
+          const instance = webComponent.getEditor();
+          if (instance && instance.updatePreview) {
+            instance.updatePreview();
+          }
+        }
+      });
+    }
     /**
      * Initialize global event listeners
      */
@@ -4348,9 +4434,10 @@ ${blockSuffix}` : suffix;
  */
 
 if (typeof window !== "undefined" && typeof window.document !== "undefined") {
-  window.OverType = OverType.default ? OverType.default : OverType;
+  // Extract exports BEFORE reassigning OverType (var OverType is window.OverType)
   window.toolbarButtons = OverType.toolbarButtons;
   window.defaultToolbarButtons = OverType.defaultToolbarButtons;
+  window.OverType = OverType.default ? OverType.default : OverType;
 }
     
 //# sourceMappingURL=overtype.js.map