vapid 0.1.0

data/lib/vapid/vendor/trix/src/trix/config/toolbar.coffee

@@ -0,0 +1,41 @@
+{makeFragment} = Trix
+{lang} = Trix.config
+
+Trix.config.toolbar =
+  content: makeFragment """
+    <div class="button_row">
+      <span class="button_group text_tools">
+        <button type="button" class="icon bold" data-trix-attribute="bold" data-trix-key="b" title="#{lang.bold}">#{lang.bold}</button>
+        <button type="button" class="icon italic" data-trix-attribute="italic" data-trix-key="i" title="#{lang.italic}">#{lang.italic}</button>
+        <button type="button" class="icon strike" data-trix-attribute="strike" title="#{lang.strike}">#{lang.strike}</button>
+        <button type="button" class="icon link" data-trix-attribute="href" data-trix-action="link" data-trix-key="k" title="#{lang.link}">#{lang.link}</button>
+      </span>
+
+      <span class="button_group block_tools">
+        <button type="button" class="icon heading-1" data-trix-attribute="heading1" title="#{lang.heading1}">#{lang.heading1}</button>
+        <button type="button" class="icon quote" data-trix-attribute="quote" title="#{lang.quote}">#{lang.quote}</button>
+        <button type="button" class="icon code" data-trix-attribute="code" title="#{lang.code}">#{lang.code}</button>
+        <button type="button" class="icon list bullets" data-trix-attribute="bullet" title="#{lang.bullets}">#{lang.bullets}</button>
+        <button type="button" class="icon list numbers" data-trix-attribute="number" title="#{lang.numbers}">#{lang.numbers}</button>
+        <button type="button" class="icon nesting-level decrease" data-trix-action="decreaseNestingLevel" title="#{lang.outdent}">#{lang.outdent}</button>
+        <button type="button" class="icon nesting-level increase" data-trix-action="increaseNestingLevel" title="#{lang.indent}">#{lang.indent}</button>
+      </span>
+
+      <span class="button_group history_tools">
+        <button type="button" class="icon undo" data-trix-action="undo" data-trix-key="z" title="#{lang.undo}">#{lang.undo}</button>
+        <button type="button" class="icon redo" data-trix-action="redo" data-trix-key="shift+z" title="#{lang.redo}">#{lang.redo}</button>
+      </span>
+    </div>
+
+    <div class="dialogs">
+      <div class="dialog link_dialog" data-trix-attribute="href" data-trix-dialog="href">
+        <div class="link_url_fields">
+          <input type="url" required name="href" placeholder="#{lang.urlPlaceholder}">
+          <div class="button_group">
+            <input type="button" value="#{lang.link}" data-trix-method="setAttribute">
+            <input type="button" value="#{lang.unlink}" data-trix-method="removeAttribute">
+          </div>
+        </div>
+      </div>
+    </div>
+  """

data/lib/vapid/vendor/trix/src/trix/config/undo_interval.coffee

@@ -0,0 +1,7 @@
+# Not all changes to a Trix document result in an undo entry being added to
+# the stack. Trix aggregates successive changes into a single undo entry for
+# typing and for attribute changes to the same selected range. The "undo
+# interval" specifies how often, in milliseconds, these aggregate entries are
+# split (or prevents splitting them at all when set to 0).
+
+Trix.config.undoInterval = 5000

data/lib/vapid/vendor/trix/src/trix/controllers/attachment_editor_controller.coffee

@@ -0,0 +1,104 @@
+#= require trix/controllers/attachment_editor_controller
+
+{handleEvent, makeElement, tagName} = Trix
+{keyNames} = Trix.InputController
+{lang} = Trix.config
+{classNames} = Trix.config.css
+
+class Trix.AttachmentEditorController extends Trix.BasicObject
+  constructor: (@attachmentPiece, @element, @container) ->
+    {@attachment} = @attachmentPiece
+    @element = @element.firstChild if tagName(@element) is "a"
+    @install()
+
+  undoable = (fn) -> ->
+    commands = fn.apply(this, arguments)
+    commands.do()
+    @undos ?= []
+    @undos.push(commands.undo)
+
+  install: ->
+    @makeElementMutable()
+    @makeCaptionEditable() if @attachment.isPreviewable()
+    @addRemoveButton()
+
+  makeElementMutable: undoable ->
+    do: => @element.dataset.trixMutable = true
+    undo: => delete @element.dataset.trixMutable
+
+  makeCaptionEditable: undoable ->
+    figcaption = @element.querySelector("figcaption")
+    handler = null
+    do: => handler = handleEvent("click", onElement: figcaption, withCallback: @didClickCaption, inPhase: "capturing")
+    undo: => handler.destroy()
+
+  addRemoveButton: undoable ->
+    removeButton = makeElement
+      tagName: "button"
+      textContent: lang.remove
+      className: classNames.attachment.removeButton
+      attributes: type: "button", title: lang.remove
+      data: trixMutable: true
+    handleEvent("click", onElement: removeButton, withCallback: @didClickRemoveButton)
+    do: => @element.appendChild(removeButton)
+    undo: => @element.removeChild(removeButton)
+
+  editCaption: undoable ->
+    textarea = makeElement
+      tagName: "textarea"
+      className: classNames.attachment.captionEditor
+      attributes: placeholder: lang.captionPlaceholder
+    textarea.value = @attachmentPiece.getCaption()
+
+    textareaClone = textarea.cloneNode()
+    textareaClone.classList.add("trix-autoresize-clone")
+
+    autoresize = ->
+      textareaClone.value = textarea.value
+      textarea.style.height = textareaClone.scrollHeight + "px"
+
+    handleEvent("input", onElement: textarea, withCallback: autoresize)
+    handleEvent("keydown", onElement: textarea, withCallback: @didKeyDownCaption)
+    handleEvent("change", onElement: textarea, withCallback: @didChangeCaption)
+    handleEvent("blur", onElement: textarea, withCallback: @uninstall)
+
+    figcaption = @element.querySelector("figcaption")
+    editingFigcaption = figcaption.cloneNode()
+
+    do: ->
+      figcaption.style.display = "none"
+      editingFigcaption.appendChild(textarea)
+      editingFigcaption.appendChild(textareaClone)
+      editingFigcaption.classList.add(classNames.attachment.editingCaption)
+      figcaption.parentElement.insertBefore(editingFigcaption, figcaption)
+      autoresize()
+      textarea.focus()
+    undo: ->
+      editingFigcaption.parentNode.removeChild(editingFigcaption)
+      figcaption.style.display = null
+
+  didClickRemoveButton: (event) =>
+    event.preventDefault()
+    event.stopPropagation()
+    @delegate?.attachmentEditorDidRequestRemovalOfAttachment(@attachment)
+
+  didClickCaption: (event) =>
+    event.preventDefault()
+    @editCaption()
+
+  didChangeCaption: (event) =>
+    caption = event.target.value.replace(/\s/g, " ").trim()
+    if caption
+      @delegate?.attachmentEditorDidRequestUpdatingAttributesForAttachment?({caption}, @attachment)
+    else
+      @delegate?.attachmentEditorDidRequestRemovingAttributeForAttachment?("caption", @attachment)
+
+  didKeyDownCaption: (event) =>
+    if keyNames[event.keyCode] is "return"
+      event.preventDefault()
+      @didChangeCaption(event)
+      @delegate?.attachmentEditorDidRequestDeselectingAttachment?(@attachment)
+
+  uninstall: =>
+    undo() while undo = @undos.pop()
+    @delegate?.didUninstallAttachmentEditor(this)

data/lib/vapid/vendor/trix/src/trix/controllers/composition_controller.coffee

@@ -0,0 +1,117 @@
+#= require trix/controllers/attachment_editor_controller
+#= require trix/views/document_view
+
+{handleEvent, innerElementIsActive, defer}  = Trix
+
+{attachmentSelector} = Trix.AttachmentView
+
+class Trix.CompositionController extends Trix.BasicObject
+  constructor: (@element, @composition) ->
+    @documentView = new Trix.DocumentView @composition.document, {@element}
+
+    handleEvent "focus", onElement: @element, withCallback: @didFocus
+    handleEvent "blur", onElement: @element, withCallback: @didBlur
+    handleEvent "click", onElement: @element, matchingSelector: "a[contenteditable=false]", preventDefault: true
+    handleEvent "mousedown", onElement: @element, matchingSelector: attachmentSelector, withCallback: @didClickAttachment
+    handleEvent "click", onElement: @element, matchingSelector: "a#{attachmentSelector}", preventDefault: true
+
+  didFocus: (event) =>
+    perform = =>
+      unless @focused
+        @focused = true
+        @delegate?.compositionControllerDidFocus?()
+
+    @blurPromise?.then(perform) ? perform()
+
+  didBlur: (event) =>
+    @blurPromise = new Promise (resolve) =>
+      defer =>
+        unless innerElementIsActive(@element)
+          @focused = null
+          @delegate?.compositionControllerDidBlur?()
+        @blurPromise = null
+        resolve()
+
+  didClickAttachment: (event, target) =>
+    attachment = @findAttachmentForElement(target)
+    @delegate?.compositionControllerDidSelectAttachment?(attachment)
+
+  render: ->
+    unless @revision is @composition.revision
+      @documentView.setDocument(@composition.document)
+      @documentView.render()
+      @revision = @composition.revision
+
+    unless @documentView.isSynced()
+      @delegate?.compositionControllerWillSyncDocumentView?()
+      @documentView.sync()
+      @reinstallAttachmentEditor()
+      @delegate?.compositionControllerDidSyncDocumentView?()
+
+    @delegate?.compositionControllerDidRender?()
+
+  rerenderViewForObject: (object) ->
+    @invalidateViewForObject(object)
+    @render()
+
+  invalidateViewForObject: (object) ->
+    @documentView.invalidateViewForObject(object)
+
+  isViewCachingEnabled: ->
+    @documentView.isViewCachingEnabled()
+
+  enableViewCaching: ->
+    @documentView.enableViewCaching()
+
+  disableViewCaching: ->
+    @documentView.disableViewCaching()
+
+  refreshViewCache: ->
+    @documentView.garbageCollectCachedViews()
+
+  # Attachment editor management
+
+  installAttachmentEditorForAttachment: (attachment) ->
+    return if @attachmentEditor?.attachment is attachment
+    return unless element = @documentView.findElementForObject(attachment)
+    @uninstallAttachmentEditor()
+    attachmentPiece = @composition.document.getAttachmentPieceForAttachment(attachment)
+    @attachmentEditor = new Trix.AttachmentEditorController attachmentPiece, element, @element
+    @attachmentEditor.delegate = this
+
+  uninstallAttachmentEditor: ->
+    @attachmentEditor?.uninstall()
+
+  reinstallAttachmentEditor: ->
+    if @attachmentEditor
+      attachment = @attachmentEditor.attachment
+      @uninstallAttachmentEditor()
+      @installAttachmentEditorForAttachment(attachment)
+
+  editAttachmentCaption: ->
+    @attachmentEditor?.editCaption()
+
+  # Attachment controller delegate
+
+  didUninstallAttachmentEditor: ->
+    @attachmentEditor = null
+    @render()
+
+  attachmentEditorDidRequestUpdatingAttributesForAttachment: (attributes, attachment) ->
+    @delegate?.compositionControllerWillUpdateAttachment?(attachment)
+    @composition.updateAttributesForAttachment(attributes, attachment)
+
+  attachmentEditorDidRequestRemovingAttributeForAttachment: (attribute, attachment) ->
+    @delegate?.compositionControllerWillUpdateAttachment?(attachment)
+    @composition.removeAttributeForAttachment(attribute, attachment)
+
+  attachmentEditorDidRequestRemovalOfAttachment: (attachment) ->
+    @delegate?.compositionControllerDidRequestRemovalOfAttachment?(attachment)
+
+  attachmentEditorDidRequestDeselectingAttachment: (attachment) ->
+    @delegate?.compositionControllerDidRequestDeselectingAttachment?(attachment)
+
+  # Private
+
+  findAttachmentForElement: (element) ->
+    @composition.document.getAttachmentById(parseInt(element.dataset.trixId, 10))

data/lib/vapid/vendor/trix/src/trix/controllers/controller.coffee

@@ -0,0 +1,3 @@
+#= require trix/views/object_view
+
+class Trix.Controller extends Trix.BasicObject

data/lib/vapid/vendor/trix/src/trix/controllers/editor_controller.coffee

@@ -0,0 +1,369 @@
+#= require trix/controllers/controller
+#= require trix/controllers/input_controller
+#= require trix/controllers/composition_controller
+#= require trix/controllers/toolbar_controller
+#= require trix/models/composition
+#= require trix/models/editor
+#= require trix/models/attachment_manager
+#= require trix/models/selection_manager
+
+{rangeIsCollapsed, rangesAreEqual, objectsAreEqual} = Trix
+
+class Trix.EditorController extends Trix.Controller
+  constructor: ({@editorElement, document, html}) ->
+    @selectionManager = new Trix.SelectionManager @editorElement
+    @selectionManager.delegate = this
+
+    @composition = new Trix.Composition
+    @composition.delegate = this
+
+    @attachmentManager = new Trix.AttachmentManager @composition.getAttachments()
+    @attachmentManager.delegate = this
+
+    @inputController = new Trix.InputController @editorElement
+    @inputController.delegate = this
+    @inputController.responder = @composition
+
+    @compositionController = new Trix.CompositionController @editorElement, @composition
+    @compositionController.delegate = this
+
+    @toolbarController = new Trix.ToolbarController @editorElement.toolbarElement
+    @toolbarController.delegate = this
+
+    @editor = new Trix.Editor @composition, @selectionManager, @editorElement
+    if document?
+      @editor.loadDocument(document)
+    else
+      @editor.loadHTML(html)
+
+  registerSelectionManager: ->
+    Trix.selectionChangeObserver.registerSelectionManager(@selectionManager)
+
+  unregisterSelectionManager: ->
+    Trix.selectionChangeObserver.unregisterSelectionManager(@selectionManager)
+
+  # Composition delegate
+
+  compositionDidChangeDocument: (document) ->
+    @editorElement.notify("document-change")
+    @render() unless @handlingInput
+
+  compositionDidChangeCurrentAttributes: (@currentAttributes) ->
+    @toolbarController.updateAttributes(@currentAttributes)
+    @updateCurrentActions()
+    @editorElement.notify("attributes-change", attributes: @currentAttributes)
+
+  compositionDidPerformInsertionAtRange: (range) ->
+    @pastedRange = range if @pasting
+
+  compositionShouldAcceptFile: (file) ->
+    @editorElement.notify("file-accept", {file})
+
+  compositionDidAddAttachment: (attachment) ->
+    managedAttachment = @attachmentManager.manageAttachment(attachment)
+    @editorElement.notify("attachment-add", attachment: managedAttachment)
+
+  compositionDidEditAttachment: (attachment) ->
+    @compositionController.rerenderViewForObject(attachment)
+    managedAttachment = @attachmentManager.manageAttachment(attachment)
+    @editorElement.notify("attachment-edit", attachment: managedAttachment)
+    @editorElement.notify("change")
+
+  compositionDidChangeAttachmentPreviewURL: (attachment) ->
+    @compositionController.invalidateViewForObject(attachment)
+    @editorElement.notify("change")
+
+  compositionDidRemoveAttachment: (attachment) ->
+    managedAttachment = @attachmentManager.unmanageAttachment(attachment)
+    @editorElement.notify("attachment-remove", attachment: managedAttachment)
+
+  compositionDidStartEditingAttachment: (attachment) ->
+    @attachmentLocationRange = @composition.document.getLocationRangeOfAttachment(attachment)
+    @compositionController.installAttachmentEditorForAttachment(attachment)
+    @selectionManager.setLocationRange(@attachmentLocationRange)
+
+  compositionDidStopEditingAttachment: (attachment) ->
+    @compositionController.uninstallAttachmentEditor()
+    @attachmentLocationRange = null
+
+  compositionDidRequestChangingSelectionToLocationRange: (locationRange) ->
+    return if @loadingSnapshot and not @isFocused()
+    @requestedLocationRange = locationRange
+    @compositionRevisionWhenLocationRangeRequested = @composition.revision
+    @render() unless @handlingInput
+
+  compositionWillLoadSnapshot: ->
+    @loadingSnapshot = true
+
+  compositionDidLoadSnapshot: ->
+    @compositionController.refreshViewCache()
+    @render()
+    @loadingSnapshot = false
+
+  getSelectionManager: ->
+    @selectionManager
+
+  @proxyMethod "getSelectionManager().setLocationRange"
+  @proxyMethod "getSelectionManager().getLocationRange"
+
+  # Attachment manager delegate
+
+  attachmentManagerDidRequestRemovalOfAttachment: (attachment) ->
+    @removeAttachment(attachment)
+
+  # Document controller delegate
+
+  compositionControllerWillSyncDocumentView: ->
+    @inputController.editorWillSyncDocumentView()
+    @selectionManager.lock()
+    @selectionManager.clearSelection()
+
+  compositionControllerDidSyncDocumentView: ->
+    @inputController.editorDidSyncDocumentView()
+    @selectionManager.unlock()
+    @updateCurrentActions()
+    @editorElement.notify("sync")
+
+  compositionControllerDidRender: ->
+    if @requestedLocationRange?
+      if @compositionRevisionWhenLocationRangeRequested is @composition.revision
+        @selectionManager.setLocationRange(@requestedLocationRange)
+      @requestedLocationRange = null
+      @compositionRevisionWhenLocationRangeRequested = null
+
+    unless @renderedCompositionRevision is @composition.revision
+      @composition.updateCurrentAttributes()
+      @editorElement.notify("render")
+
+    @renderedCompositionRevision = @composition.revision
+
+  compositionControllerDidFocus: ->
+    @toolbarController.hideDialog()
+    @editorElement.notify("focus")
+
+  compositionControllerDidBlur: ->
+    @editorElement.notify("blur")
+
+  compositionControllerDidSelectAttachment: (attachment) ->
+    @composition.editAttachment(attachment)
+
+  compositionControllerDidRequestDeselectingAttachment: (attachment) ->
+    locationRange = @attachmentLocationRange ? @composition.document.getLocationRangeOfAttachment(attachment)
+    @selectionManager.setLocationRange(locationRange[1])
+
+  compositionControllerWillUpdateAttachment: (attachment) ->
+    @editor.recordUndoEntry("Edit Attachment", context: attachment.id, consolidatable: true)
+
+  compositionControllerDidRequestRemovalOfAttachment: (attachment) ->
+    @removeAttachment(attachment)
+
+  # Input controller delegate
+
+  inputControllerWillHandleInput: ->
+    @handlingInput = true
+    @requestedRender = false
+
+  inputControllerDidRequestRender: ->
+    @requestedRender = true
+
+  inputControllerDidHandleInput: ->
+    @handlingInput = false
+    if @requestedRender
+      @requestedRender = false
+      @render()
+
+  inputControllerDidAllowUnhandledInput: ->
+    @editorElement.notify("change")
+
+  inputControllerDidRequestReparse: ->
+    @reparse()
+
+  inputControllerWillPerformTyping: ->
+    @recordTypingUndoEntry()
+
+  inputControllerWillCutText: ->
+    @editor.recordUndoEntry("Cut")
+
+  inputControllerWillPasteText: (pasteData) ->
+    @editor.recordUndoEntry("Paste")
+    @pasting = true
+
+  inputControllerDidPaste: (pasteData) ->
+    range = @pastedRange
+    @pastedRange = null
+    @pasting = null
+    @editorElement.notify("paste", {pasteData, range})
+
+  inputControllerWillMoveText: ->
+    @editor.recordUndoEntry("Move")
+
+  inputControllerWillAttachFiles: ->
+    @editor.recordUndoEntry("Drop Files")
+
+  inputControllerDidReceiveKeyboardCommand: (keys) ->
+    @toolbarController.applyKeyboardCommand(keys)
+
+  inputControllerDidStartDrag: ->
+    @locationRangeBeforeDrag = @selectionManager.getLocationRange()
+
+  inputControllerDidReceiveDragOverPoint: (point) ->
+    @selectionManager.setLocationRangeFromPointRange(point)
+
+  inputControllerDidCancelDrag: ->
+    @selectionManager.setLocationRange(@locationRangeBeforeDrag)
+    @locationRangeBeforeDrag = null
+
+  # Selection manager delegate
+
+  locationRangeDidChange: (locationRange) ->
+    @composition.updateCurrentAttributes()
+    @updateCurrentActions()
+    if @attachmentLocationRange and not rangesAreEqual(@attachmentLocationRange, locationRange)
+      @composition.stopEditingAttachment()
+    @editorElement.notify("selection-change")
+
+  # Toolbar controller delegate
+
+  toolbarDidClickButton: ->
+    @setLocationRange(index: 0, offset: 0) unless @getLocationRange()
+
+  toolbarDidInvokeAction: (actionName) ->
+    @invokeAction(actionName)
+
+  toolbarDidToggleAttribute: (attributeName) ->
+    @recordFormattingUndoEntry()
+    @composition.toggleCurrentAttribute(attributeName)
+    @render()
+    @editorElement.focus() unless @selectionFrozen
+
+  toolbarDidUpdateAttribute: (attributeName, value) ->
+    @recordFormattingUndoEntry()
+    @composition.setCurrentAttribute(attributeName, value)
+    @render()
+    @editorElement.focus() unless @selectionFrozen
+
+  toolbarDidRemoveAttribute: (attributeName) ->
+    @recordFormattingUndoEntry()
+    @composition.removeCurrentAttribute(attributeName)
+    @render()
+    @editorElement.focus() unless @selectionFrozen
+
+  toolbarWillShowDialog: (dialogElement) ->
+    @composition.expandSelectionForEditing()
+    @freezeSelection()
+
+  toolbarDidShowDialog: (dialogName) ->
+    @editorElement.notify("toolbar-dialog-show", {dialogName})
+
+  toolbarDidHideDialog: (dialogName) ->
+    @thawSelection()
+    @editorElement.focus()
+    @editorElement.notify("toolbar-dialog-hide", {dialogName})
+
+  # Selection
+
+  freezeSelection: ->
+    unless @selectionFrozen
+      @selectionManager.lock()
+      @composition.freezeSelection()
+      @selectionFrozen = true
+      @render()
+
+  thawSelection: ->
+    if @selectionFrozen
+      @composition.thawSelection()
+      @selectionManager.unlock()
+      @selectionFrozen = false
+      @render()
+
+  # Actions
+
+  actions:
+    undo:
+      test: -> @editor.canUndo()
+      perform: -> @editor.undo()
+    redo:
+      test: -> @editor.canRedo()
+      perform: -> @editor.redo()
+    link:
+      test: -> @editor.canActivateAttribute("href")
+    increaseNestingLevel:
+      test: -> @editor.canIncreaseNestingLevel()
+      perform: -> @editor.increaseNestingLevel() and @render()
+    decreaseNestingLevel:
+      test: -> @editor.canDecreaseNestingLevel()
+      perform: -> @editor.decreaseNestingLevel() and @render()
+    increaseBlockLevel: # deprecated in favor of increaseNestingLevel
+      test: -> @editor.canIncreaseNestingLevel()
+      perform: -> @editor.increaseNestingLevel() and @render()
+    decreaseBlockLevel: # deprecated in favor of decreaseNestingLevel
+      test: -> @editor.canDecreaseNestingLevel()
+      perform: -> @editor.decreaseNestingLevel() and @render()
+
+  canInvokeAction: (actionName) ->
+    if @actionIsExternal(actionName)
+      true
+    else
+      !! @actions[actionName]?.test?.call(this)
+
+  invokeAction: (actionName) ->
+    if @actionIsExternal(actionName)
+      @editorElement.notify("action-invoke", {actionName})
+    else
+      @actions[actionName]?.perform?.call(this)
+
+  actionIsExternal: (actionName) ->
+    /^x-./.test(actionName)
+
+  getCurrentActions: ->
+    result = {}
+    for actionName of @actions
+      result[actionName] = @canInvokeAction(actionName)
+    result
+
+  updateCurrentActions: ->
+    currentActions = @getCurrentActions()
+    unless objectsAreEqual(currentActions, @currentActions)
+      @currentActions = currentActions
+      @toolbarController.updateActions(@currentActions)
+      @editorElement.notify("actions-change", actions: @currentActions)
+
+  # Private
+
+  reparse: ->
+    @composition.replaceHTML(@editorElement.innerHTML)
+
+  render: ->
+    @compositionController.render()
+
+  removeAttachment: (attachment) ->
+    @editor.recordUndoEntry("Delete Attachment")
+    @composition.removeAttachment(attachment)
+    @render()
+
+  recordFormattingUndoEntry: ->
+    locationRange = @selectionManager.getLocationRange()
+    unless rangeIsCollapsed(locationRange)
+      @editor.recordUndoEntry("Formatting", context: @getUndoContext(), consolidatable: true)
+
+  recordTypingUndoEntry: ->
+    @editor.recordUndoEntry("Typing", context: @getUndoContext(@currentAttributes), consolidatable: true)
+
+  getUndoContext: (context...) ->
+    [@getLocationContext(), @getTimeContext(), context...]
+
+  getLocationContext: ->
+    locationRange = @selectionManager.getLocationRange()
+    if rangeIsCollapsed(locationRange)
+      locationRange[0].index
+    else
+      locationRange
+
+  getTimeContext: ->
+    if Trix.config.undoInterval > 0
+      Math.floor(new Date().getTime() / Trix.config.undoInterval)
+    else
+      0
+
+  isFocused: ->
+    @editorElement is @editorElement.ownerDocument?.activeElement