markdown-actions 1.1.1 → 1.2.0

package/src/core/detection.js

@@ -40,8 +40,8 @@ export function getActiveFormats(textarea) {
   }
   
   // Check line-based formats
-  if (currentLine.startsWith('- ')) {
-    if (currentLine.startsWith('- [ ] ') || currentLine.startsWith('- [x] ')) {
+  if (/^[-*+] /.test(currentLine)) {
+    if (/^[-*+] \[[ xX]\] /.test(currentLine)) {
       formats.push('task-list')
     } else {
       formats.push('bullet-list')
@@ -66,25 +66,21 @@ export function getActiveFormats(textarea) {
   const surrounding = value.slice(lookBehind, lookAhead)
   
   // Check for bold
-  if (surrounding.includes('**')) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart)
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100))
-    const lastOpenBold = beforeCursor.lastIndexOf('**')
-    const nextCloseBold = afterCursor.indexOf('**')
-    if (lastOpenBold !== -1 && nextCloseBold !== -1) {
-      formats.push('bold')
-    }
+  const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart)
+  const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100))
+  if (['**', '__'].some(marker => surrounding.includes(marker) &&
+      beforeCursor.lastIndexOf(marker) !== -1 && afterCursor.indexOf(marker) !== -1)) {
+    formats.push('bold')
   }
   
-  // Check for italic
-  if (surrounding.includes('_')) {
-    const beforeCursor = value.slice(Math.max(0, selectionStart - 100), selectionStart)
-    const afterCursor = value.slice(selectionEnd, Math.min(value.length, selectionEnd + 100))
-    const lastOpenItalic = beforeCursor.lastIndexOf('_')
-    const nextCloseItalic = afterCursor.indexOf('_')
-    if (lastOpenItalic !== -1 && nextCloseItalic !== -1) {
-      formats.push('italic')
-    }
+  // Check for italic: a single _ or * on each side, not part of __ or **
+  const singleMarker = ch => {
+    const c = ch === '*' ? '\\*' : ch
+    return new RegExp(`(^|[^${c}])${c}[^${c}]*$`).test(beforeCursor) &&
+      new RegExp(`^[^${c}]*${c}(?!${c})`).test(afterCursor)
+  }
+  if ((surrounding.includes('_') && singleMarker('_')) || (surrounding.includes('*') && singleMarker('*'))) {
+    formats.push('italic')
   }
   
   // Check for code

package/src/core/insertion.js

@@ -50,8 +50,10 @@ export function insertText(textarea, { text, selectionStart, selectionEnd }) {
     textarea.contentEditable = 'true'
     try {
       canInsertText = document.execCommand('insertText', false, text)
+      if (debugMode) console.log('execCommand returned:', canInsertText, 'for text with', text.split('\n').length, 'lines');
     } catch (error) {
       canInsertText = false
+      if (debugMode) console.log('execCommand threw error:', error);
     }
     textarea.contentEditable = 'false'
   }

package/src/core/markers.js

@@ -0,0 +1,34 @@
+/**
+ * Markdown spellings that mean the same thing
+ */
+
+export const MARKERS = {
+  bold: ['**', '__'],
+  italic: ['_', '*'],
+  bullet: ['-', '*', '+']
+}
+
+/**
+ * Return the marker if it is a standard spelling for this format, otherwise the default
+ */
+export function resolveMarker(kind, marker) {
+  return MARKERS[kind].indexOf(marker) !== -1 ? marker : MARKERS[kind][0]
+}
+
+const DETECT = {
+  bullet: /^[ \t]*([-*+])[ \t]+\S/m,
+  bold: /(\*\*|__)(?=[^\s*_])[^\n]*?[^\s*_]\1/,
+  italic: /(?:^|[^*_\w])([*_])(?=[^\s*_])[^\n*_]*?[^\s*_]\1(?![*_\w])/
+}
+
+/**
+ * Find the spelling a document already uses for each format, or null when it uses none
+ */
+export function detectMarkers(text) {
+  const found = {}
+  Object.keys(DETECT).forEach(kind => {
+    const match = DETECT[kind].exec(text || '')
+    found[kind] = match ? match[1] : null
+  })
+  return found
+}

package/src/index.js

@@ -10,18 +10,21 @@ import { blockStyle, multilineStyle } from './operations/block.js'
 import { applyListStyle } from './operations/list.js'
 import { getActiveFormats as getActive, hasFormat as has, expandSelection as expand } from './core/detection.js'
 import { debugLog, debugSelection, debugResult, setDebugMode, getDebugMode } from './debug.js'
+import { inlineStyle } from './operations/inline.js'
+import { resolveMarker, detectMarkers } from './core/markers.js'
 
 /**
  * Toggle bold formatting
+ * @param {Object} [options]
+ * @param {string} [options.marker] - '**' (default) or '__'
  */
-export function toggleBold(textarea) {
+export function toggleBold(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly) return
   
   debugLog('toggleBold', 'Starting');
   debugSelection(textarea, 'Before');
   
-  const style = mergeWithDefaults(FORMATS.bold)
-  const result = blockStyle(textarea, style)
+  const result = inlineStyle(textarea, 'bold', resolveMarker('bold', options.marker))
   
   debugResult(result);
   
@@ -32,11 +35,12 @@ export function toggleBold(textarea) {
 
 /**
  * Toggle italic formatting
+ * @param {Object} [options]
+ * @param {string} [options.marker] - '_' (default) or '*'
  */
-export function toggleItalic(textarea) {
+export function toggleItalic(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly) return
-  const style = mergeWithDefaults(FORMATS.italic)
-  const result = blockStyle(textarea, style)
+  const result = inlineStyle(textarea, 'italic', resolveMarker('italic', options.marker))
   insertText(textarea, result)
 }
 
@@ -90,10 +94,13 @@ export function insertLink(textarea, options = {}) {
 
 /**
  * Toggle bullet list formatting
+ * @param {Object} [options]
+ * @param {string} [options.marker] - '-' (default), '*' or '+'
  */
-export function toggleBulletList(textarea) {
+export function toggleBulletList(textarea, options = {}) {
   if (!textarea || textarea.disabled || textarea.readOnly) return
   const style = mergeWithDefaults(FORMATS.bulletList)
+  style.bulletMarker = resolveMarker('bullet', options.marker)
   applyListStyle(textarea, style)
 }
 
@@ -346,6 +353,11 @@ export function applyCustomFormat(textarea, format) {
  */
 export { preserveSelection }
 
+/**
+ * Standard spellings per format, and the ones a document already uses
+ */
+export { detectMarkers }
+
 /**
  * Configure undo method
  */
@@ -376,6 +388,7 @@ export default {
   hasFormat,
   expandSelection,
   applyCustomFormat,
+  detectMarkers,
   preserveSelection,
   setUndoMethod,
   setDebugMode,

package/src/operations/inline.js

@@ -0,0 +1,101 @@
+/**
+ * Bold and italic toggles that understand both spellings (** and __, * and _)
+ */
+
+import { wordSelectionStart, wordSelectionEnd } from '../core/selection.js'
+
+const isEmphasis = ch => ch === '*' || ch === '_'
+const OPENING_PUNCTUATION = /[(\[{"'“‘]/
+const CLOSING_PUNCTUATION = /[.,;:!?)\]}"'”’]/
+
+// A run of n emphasis characters carries italic when n is odd, and bold when n is at least 2
+function carries(kind, n) {
+  return kind === 'bold' ? n >= 2 : n % 2 === 1
+}
+
+function runLength(text, ch, fromEnd) {
+  let n = 0
+  while (n < text.length && text[fromEnd ? text.length - 1 - n : n] === ch) n++
+  return n
+}
+
+/**
+ * Find the markers that already wrap value[start, end] as this format
+ */
+export function findWrap(value, start, end, kind) {
+  const size = kind === 'bold' ? 2 : 1
+  let open = start
+  while (open > 0 && isEmphasis(value[open - 1])) open--
+  let close = end
+  while (close < value.length && isEmphasis(value[close])) close++
+  const before = value.slice(open, start)
+  const after = value.slice(end, close)
+
+  for (const ch of ['*', '_']) {
+    if (carries(kind, runLength(before, ch, true)) && carries(kind, runLength(after, ch, false))) {
+      return { open: start - size, close: end, size }
+    }
+    const outerBefore = runLength(before, ch, false)
+    if (outerBefore < before.length && carries(kind, outerBefore) && carries(kind, runLength(after, ch, true))) {
+      return { open, close: close - size, size }
+    }
+  }
+  return null
+}
+
+/**
+ * The text an inline toggle acts on: the selection, or the word at the caret,
+ * without surrounding punctuation or emphasis markers
+ */
+function targetRange(value, selectionStart, selectionEnd) {
+  let start = selectionStart
+  let end = selectionEnd
+  if (start === end) {
+    start = wordSelectionStart(value, start)
+    end = wordSelectionEnd(value, end, false)
+    while (start < end && OPENING_PUNCTUATION.test(value[start])) start++
+    while (end > start && CLOSING_PUNCTUATION.test(value[end - 1])) end--
+  }
+  while (start < end && /\s/.test(value[start])) start++
+  while (end > start && /\s/.test(value[end - 1])) end--
+  while (start < end && isEmphasis(value[start])) start++
+  while (end > start && isEmphasis(value[end - 1])) end--
+  return { start, end }
+}
+
+const clamp = (n, low, high) => Math.min(Math.max(n, low), high)
+
+/**
+ * Toggle bold or italic on the selection or the word at the caret.
+ * Removes either spelling, and adds the given marker.
+ */
+export function inlineStyle(textarea, kind, marker) {
+  const value = textarea.value
+  const caretStart = textarea.selectionStart
+  const caretEnd = textarea.selectionEnd
+  const hadSelection = caretStart !== caretEnd
+  const { start, end } = targetRange(value, caretStart, caretEnd)
+
+  const wrap = start < end ? findWrap(value, start, end, kind) : null
+  if (wrap) {
+    textarea.selectionStart = wrap.open
+    textarea.selectionEnd = wrap.close + wrap.size
+    const newStart = start - wrap.size
+    const newEnd = end - wrap.size
+    const caret = clamp(caretStart - wrap.size, newStart, newEnd)
+    return {
+      text: value.slice(wrap.open + wrap.size, wrap.close),
+      selectionStart: hadSelection ? newStart : caret,
+      selectionEnd: hadSelection ? newEnd : caret
+    }
+  }
+
+  textarea.selectionStart = start
+  textarea.selectionEnd = end
+  const caret = clamp(caretStart, start, end) + marker.length
+  return {
+    text: marker + value.slice(start, end) + marker,
+    selectionStart: hadSelection ? start + marker.length : caret,
+    selectionEnd: hadSelection ? end + marker.length : caret
+  }
+}

package/src/operations/list.js

@@ -28,11 +28,11 @@ function undoOrderedListStyle(text) {
  */
 function undoUnorderedListStyle(text) {
   const lines = text.split('\n')
-  const unorderedListPrefix = '- '
-  const shouldUndoUnorderedList = lines.every(line => line.startsWith(unorderedListPrefix))
+  const unorderedListRegex = /^[-*+] /
+  const shouldUndoUnorderedList = lines.every(line => unorderedListRegex.test(line))
   let result = lines
   if (shouldUndoUnorderedList) {
-    result = lines.map(line => line.slice(unorderedListPrefix.length))
+    result = lines.map(line => line.replace(unorderedListRegex, ''))
   }
 
   return {
@@ -44,9 +44,9 @@ function undoUnorderedListStyle(text) {
 /**
  * Make prefix for list item
  */
-function makePrefix(index, unorderedList) {
+function makePrefix(index, unorderedList, bulletMarker = '-') {
   if (unorderedList) {
-    return '- '
+    return `${bulletMarker} `
   } else {
     return `${index + 1}. `
   }
@@ -90,7 +90,7 @@ export function listStyle(textarea, style) {
   const [undoResult, undoResultOppositeList, pristineText] = clearExistingListStyle(style, selectedText)
 
   const prefixedLines = pristineText.split('\n').map((value, index) => {
-    return `${makePrefix(index, style.unorderedList)}${value}`
+    return `${makePrefix(index, style.unorderedList, style.bulletMarker)}${value}`
   })
 
   const totalPrefixLength = prefixedLines.reduce((previousValue, _currentValue, currentIndex) => {
@@ -149,7 +149,7 @@ export function applyListStyle(textarea, style) {
         // Get the current line to check if we're removing
         const currentLine = textarea.value.slice(lineStart, textarea.selectionEnd)
         const orderedListRegex = /^\d+\.\s+/
-        const unorderedListRegex = /^- /
+        const unorderedListRegex = /^[-*+] /
         
         // Check if we're removing a list
         const hasOrderedList = orderedListRegex.test(currentLine)