Awesome

turbo-javascript

A collection of commands and ES6-ready snippets for optimizing Javascript and Typescript development productivity.

Commands

Use the following keymaps to speed up your development. You can quickly terminate lines with semicolons or manipulate blocks of code with ease.

End Line `CTRL-;`

Terminates the current line with a semicolon.

End Line with a comma `CTRL-,`

Terminates the current line with a comma (great for object literals).

End New Line `CTRL-ENTER`

Terminates the current line with a colon or semicolon, followed with a new line. A comma is inserted when the cursor is inside an object literal, otherwise a semicolon is inserted.

Easy Blocks `CTRL-B`

Creates a statement block { ... } with the selected text placed inside and properly indented. If the selection is already wrapped with a block, the block is removed and its content is unindented.

Snippets

Snippets are optimized to be short and easy to remember. Some snippets are "chainable" and render differently when preceded by a ".".

For example, .fe renders a chain-friendly version of the "forEach" snippet, while fe renders a full code block.

Declarations

`v⇥` var statement

var ${1:name}

`v=⇥` var assignment

var ${1:name} = ${2:value}

`l⇥` let statement

let ${1:name}

`l=⇥` let assignment

let ${1:name} = ${2:value}

`co⇥` const statement

const ${1:name}

`co=⇥` const assignment

const ${1:name} = ${2:value}

Flow Control

`if⇥` if statement

if (${1:condition}) {
  ${0}
}

`el⇥` else statement

else {
  ${0}
}

`ife⇥` else statement

if (${1:condition}) {
  ${0}
} else {

}

`ei⇥` else if statement

else if (${1:condition}) {
  ${0}
}

`fl⇥` for loop

for (let ${1:i} = 0, ${2:len} = ${3:iterable}.length; ${1:i} < ${2:len}; ${1:i}++) {
  ${0}
}

`fi⇥` for in loop

for (let ${1:key} in ${2:source}) {
  if (${2:source}.hasOwnProperty(${1:key})) {
    ${0}
  }
}

`fo⇥` for of loop (ES6)

for (let ${1:key} of ${2:source}) {
  ${0}
}

`wl⇥` while loop

while (${1:condition}) {
  ${0}
}

`tc⇥` try/catch

try {
 ${0}
} catch (${1:err}) {

}

`tf⇥` try/finally

try {
 ${0}
} finally {

}

`tcf⇥` try/catch/finally

try {
  ${0}
} catch (${1:err}) {

} finally {

}

`sw⇥` switch case

switch (${1:expr}) {
  case ${2:value}:
    return $0;
  default:
    return;
}

Functions

`f⇥` anonymous function

function (${1:arguments}) {${0}}

`fn⇥` named function

function ${1:name}(${2:arguments}) {
  ${0}
}

`iife⇥` immediately-invoked function expression (IIFE)

(function (${1:arguments}) {
  ${0}
})(${2});

`fa⇥` function apply

${1:fn}.apply(${2:this}, ${3:arguments})

`fc⇥` function call

${1:fn}.call(${2:this}, ${3:arguments})

`fb⇥` function bind

${1:fn}.bind(${2:this}, ${3:arguments})

`af⇥` arrow function (ES6)

(${1:arguments}) => ${2:statement}

`afb⇥` arrow function with body (ES6)

(${1:arguments}) => {
\t${0}
}

`gf⇥` generator function (ES6)

function* (${1:arguments}) {
  ${0}
}

`gfn⇥` named generator function (ES6)

function* ${1:name}(${1:arguments}) {
  ${0}
}

Iterables

`seq⇥` sequence of 0..n

[...Array(${1:length}).keys()]${0}

`fe⇥` forEach loop (chainable)

${1:iterable}.forEach((${2:item}) => {
  ${0}
});

`map⇥` map function (chainable)

${1:iterable}.map((${2:item}) => {
  ${0}
});

`reduce⇥` reduce function (chainable)

${1:iterable}.reduce((${2:previous}, ${3:current}) => {
  ${0}
}${4:, initial});

`filter⇥` filter function (chainable)

${1:iterable}.filter((${2:item}) => {
  ${0}
});

`find⇥` ES6 find function (chainable)

${1:iterable}.find((${2:item}) => {
  ${0}
});

Objects and classes

`c⇥` class (ES6)

class ${1:name} {
  constructor(${2:arguments}) {
    ${0}
  }
}

`cex⇥` child class (ES6)

class ${1:name} extends ${2:base} {
  constructor(${2:arguments}) {
    super(${2:arguments});
    ${0}
  }
}

`ctor` class constructor (ES6)

constructor(${1:arguments}) {
  super(${1:arguments});${0}
}

`:⇥` key/value pair

Javascript:

${1:key}: ${2:'value'}

JSON:

"${1:key}": ${2:"value"}

`m⇥` method (ES6 syntax)

${1:method}(${2:arguments}) {
  ${0}
}

`get⇥` getter (ES6 syntax)

get ${1:property}() {
  ${0}
}

`set⇥` setter (ES6 syntax)

set ${1:property}(${2:value}) {
  ${0}
}

`gs⇥` getter and setter (ES6 syntax)

get ${1:property}() {
  ${0}
}
set ${1:property}(${2:value}) {

}

`proto⇥` prototype method (chainable)

${1:Class}.prototype.${2:methodName} = function (${3:arguments}) {
  ${0}
};

`a⇥` Object assign

Object.assign(${1:dest}, ${2:source})

`ac⇥` Object assign copy (shallow clone)

Object.assign({}, ${1:original}, ${2:source})

Returning values

`r⇥` return

return ${0};

`rth⇥` return this

return this;

`rn⇥` return null

return null;

`rt⇥` return true

return true;

`rf⇥` return false

return false;

`r0⇥` return 0

return 0;

`r-1⇥` return -1

return -1;

`rp⇥` return Promise (ES6)

return new Promise((resolve, reject) => {
  ${0}
});

`rc⇥` return complex value (such as JSX components)

return (
  ${0}
);

Types

`S⇥` String

`N⇥` Number

`O⇥` Object

`A⇥` Array

`D⇥` Date

`Rx⇥` RegExp

`tof⇥` typeof comparison

typeof ${1:source} === '${2:undefined}'

`iof⇥` instanceof comparison

${1:source} instanceof ${2:Object}

Promises

`p⇥` new Promise (ES6)

new Promise((resolve, reject) => {
  ${0}
})

`then⇥` Promise.then (chainable)

${1:promise}.then(${2:value} => {
  ${0}
});

`catch⇥` Promise.catch (chainable)

${1:promise}.catch(${2:err} => {
  ${0}
});

ES6 modules

`ex⇥` module export

export ${1:member};

`exd⇥` module default export

export default ${1:member};

`im⇥` module import

import ${1:*} from '${2:module}';

`ima⇥` module import as

import ${1:*} as ${2:name} from '${3:module}';

BDD testing (Mocha, Jasmine, etc.)

`desc⇥` describe

describe('${1:description}', function () {
  ${0}
});

`cont⇥` context

context('${1:description}', function () {
  ${0}
});

`it⇥` and `its⇥` synchronous "it"

it('${1:description}', function () {
  ${0}
});

`ita⇥` asynchronous "it"

it('${1:description}', function (done) {
  ${0}
});

`bf⇥` before test suite

before(function () {
  ${0}
});

`bfe⇥` before each test

beforeEach(function () {
  ${0}
});

`aft⇥` after test suite

after(function () {
  ${0}
});

`afe⇥` after each test

afterEach(function () {
  ${0}
});

Console

`cl⇥` console.log

console.log(${0});

`ce⇥` console.error

console.error(${0});

`cw⇥` console.warn

console.warn(${0});

Timers

`st⇥` setTimeout

setTimeout(() => {
  ${0}
}, ${1:delay});

`si⇥` setInterval

setInterval(() => {
  ${0}
}, ${1:delay});

`sim⇥` setImmediate

setImmediate(() => {
  ${0}
});

DOM specifics

`ae⇥` addEventListener

${1:document}.addEventListener('${2:event}', ${3:ev} => {
  ${0}
});

`gi⇥` getElementById

${1:document}.getElementById('${2:id}')

`gc⇥` getElementsByClassName

Array.from(${1:document}.getElementsByClassName('${2:class}'))

Array.from polyfill required for ES5

`gt⇥` getElementsByTagName

Array.from(${1:document}.getElementsByTagName('${2:tag}'))

Array.from polyfill required for ES5

`qs⇥` querySelector

${1:document}.querySelector('${2:selector}')

`qsa⇥` querySelectorAll

Array.from(${1:document}.querySelectorAll('${2:selector}'))

Array.from polyfill required for ES5

Node.js specifics

`cb⇥` Node.js style callback

function (err${1:, value}) {${0}}

`re⇥` require a module

require('${1:module}');

`em⇥` export member

exports.${1:name} = ${2:value};

`me⇥` module.exports

module.exports = ${1:name};

`on⇥` attach an event handler (chainable)

${1:emitter}.on('${2:event}', (${3:arguments}) => {
  ${0}
});

`xm⇥` Express middleware

function (req, res${1:, next}) {
  ${0}
}

`xerr⇥` Express error handler

function (err, req, res, next) {
  ${0}
}

Miscellaneous

`us⇥` use strict

'use strict';

License

The MIT License (MIT)

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Awesome

turbo-javascript

Commands

End Line CTRL-;

End Line with a comma CTRL-,

End New Line CTRL-ENTER

Easy Blocks CTRL-B

Snippets

Declarations

v⇥ var statement

v=⇥ var assignment

l⇥ let statement

l=⇥ let assignment

co⇥ const statement

co=⇥ const assignment

Flow Control

if⇥ if statement

el⇥ else statement

ife⇥ else statement

ei⇥ else if statement

fl⇥ for loop

fi⇥ for in loop

fo⇥ for of loop (ES6)

wl⇥ while loop

tc⇥ try/catch

tf⇥ try/finally

tcf⇥ try/catch/finally

sw⇥ switch case

Functions

f⇥ anonymous function

fn⇥ named function

iife⇥ immediately-invoked function expression (IIFE)

fa⇥ function apply

fc⇥ function call

fb⇥ function bind

af⇥ arrow function (ES6)

afb⇥ arrow function with body (ES6)

gf⇥ generator function (ES6)

gfn⇥ named generator function (ES6)

Iterables

seq⇥ sequence of 0..n

fe⇥ forEach loop (chainable)

map⇥ map function (chainable)

reduce⇥ reduce function (chainable)

filter⇥ filter function (chainable)

find⇥ ES6 find function (chainable)

Objects and classes

c⇥ class (ES6)

cex⇥ child class (ES6)

ctor class constructor (ES6)

:⇥ key/value pair

m⇥ method (ES6 syntax)

get⇥ getter (ES6 syntax)

set⇥ setter (ES6 syntax)

gs⇥ getter and setter (ES6 syntax)

proto⇥ prototype method (chainable)

a⇥ Object assign

ac⇥ Object assign copy (shallow clone)

Returning values

r⇥ return

rth⇥ return this

rn⇥ return null

rt⇥ return true

rf⇥ return false

r0⇥ return 0

r-1⇥ return -1

rp⇥ return Promise (ES6)

rc⇥ return complex value (such as JSX components)

Types

S⇥ String

N⇥ Number

O⇥ Object

A⇥ Array

D⇥ Date

Rx⇥ RegExp

tof⇥ typeof comparison

iof⇥ instanceof comparison

Promises

p⇥ new Promise (ES6)

then⇥ Promise.then (chainable)

End Line `CTRL-;`

End Line with a comma `CTRL-,`

End New Line `CTRL-ENTER`

Easy Blocks `CTRL-B`

`v⇥` var statement

`v=⇥` var assignment

`l⇥` let statement

`l=⇥` let assignment

`co⇥` const statement

`co=⇥` const assignment

`if⇥` if statement

`el⇥` else statement

`ife⇥` else statement

`ei⇥` else if statement

`fl⇥` for loop

`fi⇥` for in loop

`fo⇥` for of loop (ES6)

`wl⇥` while loop

`tc⇥` try/catch

`tf⇥` try/finally

`tcf⇥` try/catch/finally

`sw⇥` switch case

`f⇥` anonymous function

`fn⇥` named function

`iife⇥` immediately-invoked function expression (IIFE)

`fa⇥` function apply

`fc⇥` function call

`fb⇥` function bind

`af⇥` arrow function (ES6)

`afb⇥` arrow function with body (ES6)

`gf⇥` generator function (ES6)

`gfn⇥` named generator function (ES6)

`seq⇥` sequence of 0..n

`fe⇥` forEach loop (chainable)

`map⇥` map function (chainable)

`reduce⇥` reduce function (chainable)

`filter⇥` filter function (chainable)

`find⇥` ES6 find function (chainable)

`c⇥` class (ES6)

`cex⇥` child class (ES6)

`ctor` class constructor (ES6)

`:⇥` key/value pair

`m⇥` method (ES6 syntax)

`get⇥` getter (ES6 syntax)

`set⇥` setter (ES6 syntax)

`gs⇥` getter and setter (ES6 syntax)

`proto⇥` prototype method (chainable)

`a⇥` Object assign

`ac⇥` Object assign copy (shallow clone)

`r⇥` return

`rth⇥` return this

`rn⇥` return null

`rt⇥` return true

`rf⇥` return false

`r0⇥` return 0

`r-1⇥` return -1

`rp⇥` return Promise (ES6)

`rc⇥` return complex value (such as JSX components)

`S⇥` String

`N⇥` Number

`O⇥` Object

`A⇥` Array

`D⇥` Date

`Rx⇥` RegExp

`tof⇥` typeof comparison

`iof⇥` instanceof comparison

`p⇥` new Promise (ES6)

`then⇥` Promise.then (chainable)

`catch⇥` Promise.catch (chainable)

`ex⇥` module export

`exd⇥` module default export

`im⇥` module import

`ima⇥` module import as

`desc⇥` describe

`cont⇥` context

`it⇥` and `its⇥` synchronous "it"

`ita⇥` asynchronous "it"

`bf⇥` before test suite

`bfe⇥` before each test

`aft⇥` after test suite