Merge pull request #740 from atom-minimap/use-template-strings

Author: aminya

lib/main.js

@@ -312,7 +312,7 @@ export function standAloneMinimapForEditor (textEditor) {
   if (!textEditor) { return }
 
   return new Minimap({
-    textEditor: textEditor,
+    textEditor,
     standAlone: true
   })
 }

lib/minimap-element.js

@@ -634,13 +634,13 @@ class MinimapElement {
           })
 
           const { top, left, right } = this.getFrontCanvas().getBoundingClientRect()
-          this.quickSettingsElement.style.top = top + 'px'
+          this.quickSettingsElement.style.top = `${top}px`
           this.quickSettingsElement.attach()
 
           if (this.displayMinimapOnLeft) {
-            this.quickSettingsElement.style.left = (right) + 'px'
+            this.quickSettingsElement.style.left = `${right}px`
           } else {
-            this.quickSettingsElement.style.left = (left - this.quickSettingsElement.clientWidth) + 'px'
+            this.quickSettingsElement.style.left = `${left - this.quickSettingsElement.clientWidth}px`
           }
         }
       }
@@ -830,43 +830,43 @@ class MinimapElement {
     const visibleWidth = width + visibleAreaLeft
 
     if (this.adjustToSoftWrap && this.flexBasis) {
-      this.style.flexBasis = this.flexBasis + 'px'
-      this.style.width = this.flexBasis + 'px'
+      this.style.flexBasis = `${this.flexBasis}px`
+      this.style.width = `${this.flexBasis}px`
     } else {
       this.style.flexBasis = null
       this.style.width = null
     }
 
     if (SPEC_MODE) {
       applyStyles(this.visibleArea, {
-        width: Math.round(visibleWidth) + 'px',
-        height: Math.round(minimap.getTextEditorScaledHeight()) + 'px',
-        top: Math.round(visibleAreaTop) + 'px',
-        'border-left-width': Math.round(visibleAreaLeft) + 'px'
+        width: `${Math.round(visibleWidth)}px`,
+        height: `${Math.round(minimap.getTextEditorScaledHeight())}px`,
+        top: `${Math.round(visibleAreaTop)}px`,
+        'border-left-width': `${Math.round(visibleAreaLeft)}px`
       })
     } else {
       applyStyles(this.visibleArea, {
-        width: Math.round(visibleWidth) + 'px',
-        height: Math.round(minimap.getTextEditorScaledHeight()) + 'px',
+        width: `${Math.round(visibleWidth)}px`,
+        height: `${Math.round(minimap.getTextEditorScaledHeight())}px`,
         transform: makeTranslate(0, visibleAreaTop, this.useHardwareAcceleration),
-        'border-left-width': Math.round(visibleAreaLeft) + 'px'
+        'border-left-width': `${Math.round(visibleAreaLeft)}px`
       })
     }
 
-    applyStyles(this.controls, { width: Math.round(width) + 'px' })
+    applyStyles(this.controls, { width: `${Math.round(width)}px` })
 
     const canvasTop = minimap.getFirstVisibleScreenRow() * minimap.getLineHeight() - minimap.getScrollTop()
 
     if (this.smoothScrolling) {
       if (SPEC_MODE) {
-        applyStyles(this.backLayer.canvas, { top: canvasTop + 'px' })
-        applyStyles(this.tokensLayer.canvas, { top: canvasTop + 'px' })
-        applyStyles(this.frontLayer.canvas, { top: canvasTop + 'px' })
+        applyStyles(this.backLayer.canvas, { top: `${canvasTop}px` })
+        applyStyles(this.tokensLayer.canvas, { top: `${canvasTop}px` })
+        applyStyles(this.frontLayer.canvas, { top: `${canvasTop}px` })
       } else {
         let canvasTransform = makeTranslate(0, canvasTop, this.useHardwareAcceleration)
         if (devicePixelRatio !== 1) {
           const scale = 1 / devicePixelRatio
-          canvasTransform += ' ' + makeScale(scale, scale, this.useHardwareAcceleration)
+          canvasTransform += ` ${makeScale(scale, scale, this.useHardwareAcceleration)}`
         }
         applyStyles(this.backLayer.canvas, { transform: canvasTransform })
         applyStyles(this.tokensLayer.canvas, { transform: canvasTransform })
@@ -891,12 +891,12 @@ class MinimapElement {
 
       if (SPEC_MODE) {
         applyStyles(this.scrollIndicator, {
-          height: indicatorHeight + 'px',
-          top: indicatorScroll + 'px'
+          height: `${indicatorHeight}px`,
+          top: `${indicatorScroll}px`
         })
       } else {
         applyStyles(this.scrollIndicator, {
-          height: indicatorHeight + 'px',
+          height: `${indicatorHeight}px`,
           transform: makeTranslate(0, indicatorScroll, this.useHardwareAcceleration)
         })
       }
@@ -1109,13 +1109,13 @@ class MinimapElement {
           this.minimap.setTextEditorScrollTop(now, true)
           this.minimap.setScrollTop(minimapFrom + (minimapTo - minimapFrom) * t)
         }
-        animate({ from: from, to: to, duration: duration, step: step })
+        animate({ from, to, duration, step })
       } else {
         step = (now) => {
           if (this.minimap === null) return // TODO why this happens in the tests?
           this.minimap.setTextEditorScrollTop(now)
         }
-        animate({ from: from, to: to, duration: duration, step: step })
+        animate({ from, to, duration, step })
       }
     } else {
       this.minimap.setTextEditorScrollTop(textEditorScrollTop)

lib/mixins/canvas-drawer.js

@@ -336,11 +336,11 @@ export default class CanvasDrawer extends Mixin {
     const { width: canvasWidth, height: canvasHeight } = this.tokensLayer.getSize()
     const renderData = {
       context: this.backLayer.context,
-      canvasWidth: canvasWidth,
-      canvasHeight: canvasHeight,
-      lineHeight: lineHeight,
-      charWidth: charWidth,
-      charHeight: charHeight,
+      canvasWidth,
+      canvasHeight,
+      lineHeight,
+      charWidth,
+      charHeight,
       orders: Main.getPluginsOrder()
     }
 
@@ -382,11 +382,11 @@ export default class CanvasDrawer extends Mixin {
     const { width: canvasWidth, height: canvasHeight } = this.tokensLayer.getSize()
     const renderData = {
       context: this.frontLayer.context,
-      canvasWidth: canvasWidth,
-      canvasHeight: canvasHeight,
-      lineHeight: lineHeight,
-      charWidth: charWidth,
-      charHeight: charHeight,
+      canvasWidth,
+      canvasHeight,
+      lineHeight,
+      charWidth,
+      charHeight,
       orders: Main.getPluginsOrder()
     }
 

lib/mixins/decoration-management.js

@@ -233,7 +233,6 @@ export default class DecorationManagement {
 
     const decorations = this.decorationsById.values()
     for (const decoration of decorations) {
-
       const range = decoration.marker.getScreenRange()
       const type = decoration.getProperties().type
 
@@ -340,57 +339,57 @@ export default class DecorationManagement {
 
     if (!this.decorationMarkerDestroyedSubscriptions.has(id)) {
       this.decorationMarkerDestroyedSubscriptions.set(id,
-      marker.onDidDestroy(() => {
-        this.removeAllDecorationsForMarker(marker)
-      }))
+        marker.onDidDestroy(() => {
+          this.removeAllDecorationsForMarker(marker)
+        }))
     }
 
     if (!this.decorationMarkerChangedSubscriptions.has(id)) {
       this.decorationMarkerChangedSubscriptions.set(id,
-      marker.onDidChange((event) => {
-        const decorations = this.decorationsByMarkerId.get(id)
-        const screenRange = marker.getScreenRange()
-
-        this.invalidateDecorationForScreenRowsCache()
-
-        if (decorations !== undefined) {
-          for (let i = 0, len = decorations.length; i < len; i++) {
-            const decoration = decorations[i]
-            this.emitter.emit('did-change-decoration', {
-              marker: marker,
-              decoration: decoration,
-              event: event
-            })
-            this.emitDecorationChanges(decoration.type, decoration)
-
-            decoration.screenRange = screenRange
+        marker.onDidChange((event) => {
+          const decorations = this.decorationsByMarkerId.get(id)
+          const screenRange = marker.getScreenRange()
+
+          this.invalidateDecorationForScreenRowsCache()
+
+          if (decorations !== undefined) {
+            for (let i = 0, len = decorations.length; i < len; i++) {
+              const decoration = decorations[i]
+              this.emitter.emit('did-change-decoration', {
+                marker,
+                decoration,
+                event
+              })
+              this.emitDecorationChanges(decoration.type, decoration)
+
+              decoration.screenRange = screenRange
+            }
           }
-        }
-        let oldStart = event.oldTailScreenPosition
-        let oldEnd = event.oldHeadScreenPosition
-        let newStart = event.newTailScreenPosition
-        let newEnd = event.newHeadScreenPosition
-
-        if (oldStart.row > oldEnd.row) {
-          [oldStart, oldEnd] = [oldEnd, oldStart]
-        }
-        if (newStart.row > newEnd.row) {
-          [newStart, newEnd] = [newEnd, newStart]
-        }
-
-        const rangesDiffs = this.computeRangesDiffs(
-          oldStart, oldEnd,
-          newStart, newEnd
-        )
-
-        for (let i = 0, len = rangesDiffs.length; i < len; i++) {
-          const [start, end] = rangesDiffs[i]
-          this.emitRangeChanges(type, {
-            start: start,
-            end: end
-          }, 0)
-        }
-      }))
+          let oldStart = event.oldTailScreenPosition
+          let oldEnd = event.oldHeadScreenPosition
+          let newStart = event.newTailScreenPosition
+          let newEnd = event.newHeadScreenPosition
+
+          if (oldStart.row > oldEnd.row) {
+            [oldStart, oldEnd] = [oldEnd, oldStart]
+          }
+          if (newStart.row > newEnd.row) {
+            [newStart, newEnd] = [newEnd, newStart]
+          }
+
+          const rangesDiffs = this.computeRangesDiffs(
+            oldStart, oldEnd,
+            newStart, newEnd
+          )
+
+          for (let i = 0, len = rangesDiffs.length; i < len; i++) {
+            const [start, end] = rangesDiffs[i]
+            this.emitRangeChanges(type, {
+              start,
+              end
+            }, 0)
+          }
+        }))
     }
 
     const decoration = new Decoration(marker, this, decorationParams)
@@ -404,20 +403,20 @@ export default class DecorationManagement {
 
     if (!this.decorationUpdatedSubscriptions.has(decoration.id)) {
       this.decorationUpdatedSubscriptions.set(decoration.id,
-      decoration.onDidChangeProperties((event) => {
-        this.emitDecorationChanges(type, decoration)
-      }))
+        decoration.onDidChangeProperties((event) => {
+          this.emitDecorationChanges(type, decoration)
+        }))
     }
 
     this.decorationDestroyedSubscriptions.set(decoration.id,
-    decoration.onDidDestroy(() => {
-      this.removeDecoration(decoration)
-    }))
+      decoration.onDidDestroy(() => {
+        this.removeDecoration(decoration)
+      }))
 
     this.emitDecorationChanges(type, decoration)
     this.emitter.emit('did-add-decoration', {
-      marker: marker,
-      decoration: decoration
+      marker,
+      decoration
     })
 
     return decoration
@@ -504,8 +503,8 @@ export default class DecorationManagement {
     const changeEvent = {
       start: startScreenRow,
       end: endScreenRow,
-      screenDelta: screenDelta,
-      type: type
+      screenDelta,
+      type
     }
 
     this.emitter.emit('did-change-decoration-range', changeEvent)
@@ -545,8 +544,8 @@ export default class DecorationManagement {
       decorations.splice(index, 1)
 
       this.emitter.emit('did-remove-decoration', {
-        marker: marker,
-        decoration: decoration
+        marker,
+        decoration
       })
 
       if (decorations.length === 0) {
@@ -575,8 +574,8 @@ export default class DecorationManagement {
         this.emitDecorationChanges(decoration.getProperties().type, decoration)
       }
       this.emitter.emit('did-remove-decoration', {
-        marker: marker,
-        decoration: decoration
+        marker,
+        decoration
       })
     }
 

lib/plugin-management.js

@@ -59,7 +59,7 @@ export function registerPlugin (name, plugin) {
   plugins[name] = plugin
   pluginsSubscriptions[name] = new CompositeDisposable()
 
-  const event = { name: name, plugin: plugin }
+  const event = { name, plugin }
   emitter.emit('did-add-plugin', event)
 
   if (atom.config.get('minimap.displayPluginsControls')) {
@@ -85,7 +85,7 @@ export function unregisterPlugin (name) {
 
   delete plugins[name]
 
-  const event = { name: name, plugin: plugin }
+  const event = { name, plugin }
   emitter.emit('did-remove-plugin', event)
 }
 
@@ -120,7 +120,7 @@ export function togglePluginActivation (name, boolean) {
 export function deactivateAllPlugins () {
   for (const [name, plugin] of eachPlugin()) {
     plugin.deactivatePlugin()
-    emitter.emit('did-deactivate-plugin', { name: name, plugin: plugin })
+    emitter.emit('did-deactivate-plugin', { name, plugin })
   }
 }
 
@@ -165,14 +165,14 @@ function updatesPluginActivationState (name) {
 }
 
 export function activatePlugin (name, plugin) {
-  const event = { name: name, plugin: plugin }
+  const event = { name, plugin }
 
   plugin.activatePlugin()
   emitter.emit('did-activate-plugin', event)
 }
 
 export function deactivatePlugin (name, plugin) {
-  const event = { name: name, plugin: plugin }
+  const event = { name, plugin }
 
   plugin.deactivatePlugin()
   emitter.emit('did-deactivate-plugin', event)
@@ -226,7 +226,7 @@ function registerPluginControls (name, plugin) {
 
   pluginsSubscriptions[name].add(atom.config.observe(orderSettingsKey, (order) => {
     updatePluginsOrderMap(name)
-    const event = { name: name, plugin: plugin, order: order }
+    const event = { name, plugin, order }
     emitter.emit('did-change-plugin-order', event)
   }))