chore(TypeScript): fix linting and generate .d.ts

src/util/error.ts

@@ -16,14 +16,14 @@ abstract class LiquidError {
   private input: string
   private token: Token
   private originalError: Error
-  constructor(err, token) {
+  constructor (err, token) {
     this.input = token.input
     this.line = token.line
     this.file = token.file
     this.originalError = err
     this.token = token
   }
-  captureStackTrace(obj) {
+  captureStackTrace (obj) {
     this.name = obj.constructor.name
 
     captureStack.call(obj)
@@ -37,32 +37,32 @@ abstract class LiquidError {
 }
 
 export class TokenizationError extends LiquidError {
-  constructor(message, token) {
-    super({message}, token)
+  constructor (message, token) {
+    super({ message }, token)
     super.captureStackTrace(this)
   }
 }
-TokenizationError.prototype = _.create(Error.prototype)
+TokenizationError.prototype = _.create(Error.prototype) as any
 TokenizationError.prototype.constructor = TokenizationError
 
 export class ParseError extends LiquidError {
-  constructor(err, token) {
+  constructor (err, token) {
     super(err, token)
     _.assign(this, err)
     super.captureStackTrace(this)
   }
 }
-ParseError.prototype = _.create(Error.prototype)
+ParseError.prototype = _.create(Error.prototype) as any
 ParseError.prototype.constructor = ParseError
 
 export class RenderError extends LiquidError {
-  constructor(err, tpl) {
+  constructor (err, tpl) {
     super(err, tpl.token)
     _.assign(this, err)
     super.captureStackTrace(this)
   }
 }
-RenderError.prototype = _.create(Error.prototype)
+RenderError.prototype = _.create(Error.prototype) as any
 RenderError.prototype.constructor = RenderError
 
 export class RenderBreakError {
@@ -73,7 +73,7 @@ export class RenderBreakError {
     this.message = message + ''
   }
 }
-RenderBreakError.prototype = _.create(Error.prototype)
+RenderBreakError.prototype = _.create(Error.prototype) as any
 RenderBreakError.prototype.constructor = RenderBreakError
 
 export class AssertionError {
@@ -83,7 +83,7 @@ export class AssertionError {
     this.message = message + ''
   }
 }
-AssertionError.prototype = _.create(Error.prototype)
+AssertionError.prototype = _.create(Error.prototype) as any
 AssertionError.prototype.constructor = AssertionError
 
 function mkContext (input, targetLine) {

src/util/promise.ts

@@ -7,7 +7,7 @@
 export function anySeries (iterable, iteratee) {
   let ret: Promise<any> = Promise.reject(new Error('init'))
   iterable.forEach(function (item, idx) {
-    ret = ret.catch(e => iteratee(item, idx, iterable))
+    ret = ret.catch(() => iteratee(item, idx, iterable))
   })
   return ret
 }

src/util/strftime.ts

@@ -159,7 +159,7 @@ const formatCodes = {
   }
 };
 (formatCodes as any).h = formatCodes.b;
-(formatCodes as any).N = formatCodes.L;
+(formatCodes as any).N = formatCodes.L
 
 export default function (d, format) {
   let output = ''

src/util/underscore.ts

@@ -6,11 +6,11 @@ const arrToStr = Array.prototype.toString
  * @param {any} value The value to check.
  * @return {Boolean} Returns true if value is a string, else false.
  */
-export function isString (value) {
+export function isString (value: any) {
   return toStr.call(value) === '[object String]'
 }
 
-export function isFunction (value) {
+export function isFunction (value: any) {
   return typeof value === 'function'
 }
 
@@ -24,7 +24,7 @@ export function promisify (fn) {
   }
 }
 
-export function stringify (value) {
+export function stringify (value: any): string {
   if (isNil(value)) return ''
   if (isFunction(value.to_liquid)) return stringify(value.to_liquid())
   if (isFunction(value.toLiquid)) return stringify(value.toLiquid())
@@ -34,7 +34,7 @@ export function stringify (value) {
   return toStr.call(value)
 }
 
-function defaultToString (value) {
+function defaultToString (value: any): string {
   const cache = []
   return JSON.stringify(value, (key, value) => {
     if (isObject(value)) {
@@ -47,20 +47,20 @@ function defaultToString (value) {
   })
 }
 
-export function create (proto) {
+export function create<T1 extends object, T2 extends T1 = T1> (proto: T1): T2 {
   return Object.create(proto)
 }
 
-export function isNil (value) {
+export function isNil (value: any): boolean {
   return value === null || value === undefined
 }
 
-export function isArray (value) {
+export function isArray (value: any): boolean {
   // be compatible with IE 8
   return toStr.call(value) === '[object Array]'
 }
 
-export function isError (value) {
+export function isError (value: any): boolean {
   const signature = toStr.call(value)
   // [object XXXError]
   return signature.substr(-6, 5) === 'Error' ||
@@ -75,7 +75,7 @@ export function isError (value) {
  * @param {Function} iteratee The function invoked per iteration.
  * @return {Object} Returns object.
  */
-export function forOwn (object, iteratee) {
+export function forOwn (object, iteratee: ((val: any, key: string, obj: object) => boolean | void)) {
   object = object || {}
   for (const k in object) {
     if (object.hasOwnProperty(k)) {
@@ -96,21 +96,22 @@ export function forOwn (object, iteratee) {
  * @param {...Object} sources The source objects.
  * @return {Object} Returns object.
  */
-export function assign (obj, ...srcs) {
+export function assign (obj: object, ...srcs: object[]): object {
   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]
+function binaryAssign (target: object, src: object): object {
+  for (const key in src) if (src.hasOwnProperty(key)) target[key] = src[key]
+  return target
 }
 
-export function last (arr) {
+export function last (arr: any[]): any {
   return arr[arr.length - 1]
 }
 
-export function uniq (arr) {
+export function uniq (arr: any[]): any[] {
   const u = {}
   const a = []
   for (let i = 0, l = arr.length; i < l; ++i) {
@@ -129,7 +130,7 @@ export function uniq (arr) {
  * @param {any} value The value to check.
  * @return {Boolean} Returns true if value is an object, else false.
  */
-export function isObject (value) {
+export function isObject (value: any): boolean {
   const type = typeof value
   return value !== null && (type === 'object' || type === 'function')
 }
@@ -156,9 +157,9 @@ export function range (start: number, stop?: number, step?: number) {
   return arr
 }
 
-export function padStart(str: any, length: number, ch: string = ' ') {
+export function padStart (str: any, length: number, ch: string = ' ') {
   str = String(str)
   let n = length - str.length
-  while(n-- > 0) str = ch + str 
+  while (n-- > 0) str = ch + str
   return str
 }