chore(typescript): ship to TypeScript

src/util/assert.ts

@@ -1,6 +1,6 @@
-import { AssertionError } from './error.js'
+import { AssertionError } from './error'
 
-export default function (predicate, message) {
+export default function (predicate: any, message: string) {
   if (!predicate) {
     message = message || `expect ${predicate} to be true`
     throw new AssertionError(message)

src/util/error.js

@@ -1,100 +0,0 @@
-import * as _ from './underscore.js'
-
-function initError () {
-  this.name = this.constructor.name
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor)
-  }
-}
-
-function initLiquidError (err, token) {
-  initError.call(this)
-
-  this.input = token.input
-  this.line = token.line
-  this.file = token.file
-
-  const context = mkContext(token.input, token.line)
-  this.message = mkMessage(err.message, token)
-  this.stack = context +
-    '\n' + (this.stack || this.message) +
-      (err.stack ? '\nFrom ' + err.stack : '')
-}
-
-export function TokenizationError (message, token) {
-  initLiquidError.call(this, { message: message }, token)
-}
-TokenizationError.prototype = _.create(Error.prototype)
-TokenizationError.prototype.constructor = TokenizationError
-
-export function ParseError (e, token) {
-  _.assign(this, e)
-  this.originalError = e
-
-  initLiquidError.call(this, e, token)
-}
-ParseError.prototype = _.create(Error.prototype)
-ParseError.prototype.constructor = ParseError
-
-export function RenderError (e, tpl) {
-  // return the original render error
-  if (e instanceof RenderError) {
-    return e
-  }
-  _.assign(this, e)
-  this.originalError = e
-
-  initLiquidError.call(this, e, tpl.token)
-}
-RenderError.prototype = _.create(Error.prototype)
-RenderError.prototype.constructor = RenderError
-
-export function RenderBreakError (message) {
-  initError.call(this)
-  this.message = message + ''
-}
-RenderBreakError.prototype = _.create(Error.prototype)
-RenderBreakError.prototype.constructor = RenderBreakError
-
-export function AssertionError (message) {
-  initError.call(this)
-  this.message = message + ''
-}
-AssertionError.prototype = _.create(Error.prototype)
-AssertionError.prototype.constructor = AssertionError
-
-function mkContext (input, line) {
-  const lines = input.split('\n')
-  const begin = Math.max(line - 2, 1)
-  const end = Math.min(line + 3, lines.length)
-
-  const context = _
-    .range(begin, end + 1)
-    .map(l => [
-      (l === line) ? '>> ' : '   ',
-      align(l, end),
-      '| ',
-      lines[l - 1]
-    ].join(''))
-    .join('\n')
-
-  return context
-}
-
-function align (n, max) {
-  const length = (max + '').length
-  const str = n + ''
-  const blank = Array(length - str.length).join(' ')
-  return blank + str
-}
-
-function mkMessage (msg, token) {
-  msg = msg || ''
-  if (token.file) {
-    msg += ', file:' + token.file
-  }
-  if (token.line) {
-    msg += ', line:' + token.line
-  }
-  return msg
-}

src/util/error.ts

@@ -0,0 +1,120 @@
+import * as _ from './underscore'
+
+function captureStack () {
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor)
+  }
+}
+
+abstract class LiquidError {
+  input: string
+  line: string
+  file: string
+  message: string
+  name: string
+  stack: string
+  token: any
+  originalError: any
+  constructor(err, token) {
+    this.input = token.input
+    this.line = token.line
+    this.file = token.file
+    this.originalError = err
+    this.token = token
+  }
+  captureStackTrace(obj) {
+    this.name = obj.constructor.name
+
+    captureStack.call(obj)
+    const err = this.originalError
+    const context = mkContext(this.input, this.line)
+    this.message = mkMessage(err.message, this.token)
+    this.stack = context +
+      '\n' + (this.stack || this.message) +
+        (err.stack ? '\nFrom ' + err.stack : '')
+  }
+}
+
+export class TokenizationError extends LiquidError {
+  constructor(message, token) {
+    super({message}, token)
+    super.captureStackTrace(this)
+  }
+}
+TokenizationError.prototype = _.create(Error.prototype)
+TokenizationError.prototype.constructor = TokenizationError
+
+export class ParseError extends LiquidError {
+  constructor(err, token) {
+    super(err, token)
+    _.assign(this, err)
+    super.captureStackTrace(this)
+  }
+}
+ParseError.prototype = _.create(Error.prototype)
+ParseError.prototype.constructor = ParseError
+
+export class RenderError extends LiquidError {
+  constructor(err, tpl) {
+    super(err, tpl.token)
+    _.assign(this, err)
+    super.captureStackTrace(this)
+  }
+}
+RenderError.prototype = _.create(Error.prototype)
+RenderError.prototype.constructor = RenderError
+
+export class RenderBreakError {
+  message: string
+  constructor (message) {
+    captureStack.call(this)
+    this.message = message + ''
+  }
+}
+RenderBreakError.prototype = _.create(Error.prototype)
+RenderBreakError.prototype.constructor = RenderBreakError
+
+export class AssertionError {
+  message: string
+  constructor (message) {
+    captureStack.call(this)
+    this.message = message + ''
+  }
+}
+AssertionError.prototype = _.create(Error.prototype)
+AssertionError.prototype.constructor = AssertionError
+
+function mkContext (input, targetLine) {
+  const lines = input.split('\n')
+  const begin = Math.max(targetLine - 2, 1)
+  const end = Math.min(targetLine + 3, lines.length)
+
+  const context = _
+    .range(begin, end + 1)
+    .map(lineNumber => {
+      const indicator = (lineNumber === targetLine) ? '>> ' : '   '
+      const num = padStart(String(end).length, lineNumber)
+      const text = lines[lineNumber - 1]
+      return `${indicator}${num}| ${text}`
+    })
+    .join('\n')
+
+  return context
+}
+
+function mkMessage (msg, token) {
+  msg = msg || ''
+  if (token.file) {
+    msg += ', file:' + token.file
+  }
+  if (token.line) {
+    msg += ', line:' + token.line
+  }
+  return msg
+}
+
+function padStart (length, str) {
+  str = String(str)
+  const blank = Array(length - str.length).join(' ')
+  return blank + str
+}

src/util/underscore.ts

@@ -15,9 +15,9 @@ export function isFunction (value) {
 }
 
 export function promisify (fn) {
-  return function () {
+  return function (...args) {
     return new Promise((resolve, reject) => {
-      fn(...arguments, (err, result) => {
+      fn(...args, (err, result) => {
         err ? reject(err) : resolve(result)
       })
     })
@@ -96,11 +96,14 @@ export function forOwn (object, iteratee) {
  * @param {...Object} sources The source objects.
  * @return {Object} Returns object.
  */
-export function assign (object) {
-  object = isObject(object) ? object : {}
-  const srcs = Array.prototype.slice.call(arguments, 1)
-  srcs.forEach((src) => Object.assign(object, src))
-  return object
+export function assign (obj, ...srcs) {
+  obj = isObject(obj) ? obj : {}
+  srcs.forEach(src => binaryAssign(obj, src))
+  return obj
+}
+
+function binaryAssign(target, src) {
+  for(let key in src) if (src.hasOwnProperty(key)) target[key] = src[key]
 }
 
 export function last (arr) {
@@ -139,7 +142,7 @@ export function isObject (value) {
  * Note that ranges that stop before they start are considered to be zero-length instead of
  * negative — if you'd like a negative range, use a negative step.
  */
-export function range (start, stop, step) {
+export function range (start: number, stop: number, step?: number) {
   if (arguments.length === 1) {
     stop = start
     start = 0