chore(TypeScript): ship Liquid to class

BREAKING CHANGE: calling `Liquid()` without `new` now becomes invalid

src/index.ts

@@ -12,48 +12,68 @@ import { ParseError, TokenizationError, RenderBreakError, AssertionError } from
 import tags from './tags/index'
 import filters from './filters'
 
-const _engine = {
-  init: function (tag, filter, options) {
+export default class Liquid {
+  private cache: object
+  private options: any
+  private tags: any
+  private filters: any
+  private parser: any
+  private renderer: any
+
+  constructor (options) {
+    options = _.assign({
+      root: ['.'],
+      cache: false,
+      extname: '',
+      dynamicPartials: true,
+      trim_tag_right: false,
+      trim_tag_left: false,
+      trim_value_right: false,
+      trim_value_left: false,
+      greedy: true,
+      strict_filters: false,
+      strict_variables: false
+    }, options)
+    options.root = normalizeStringArray(options.root)
+
     if (options.cache) {
       this.cache = {}
     }
     this.options = options
-    this.tag = tag
-    this.filter = filter
-    this.parser = Parser(tag, filter)
+    this.tags = Tag()
+    this.filters = Filter(options)
+    this.parser = Parser(this.tags, this.filters)
     this.renderer = Render()
 
     tags(this, Liquid)
     filters(this, Liquid)
-
-    return this
-  },
-  parse: function (html, filepath) {
+  }
+  parse(html: string, filepath?: string) {
     const tokens = tokenizer.parse(html, filepath, this.options)
     return this.parser.parse(tokens)
-  },
-  render: function (tpl, ctx, opts) {
+  }
+  render(tpl: string, ctx: any, opts: any) {
     opts = _.assign({}, this.options, opts)
     const scope = new Scope(ctx, opts)
     return this.renderer.renderTemplates(tpl, scope)
-  },
-  parseAndRender: async function (html, ctx, opts) {
+  }
+  async parseAndRender(html, ctx, opts) {
     const tpl = await this.parse(html)
     return this.render(tpl, ctx, opts)
-  },
-  getTemplate: async function (file, root) {
+  }
+  async getTemplate(file, root) {
     const filepath = await template.resolve(file, root, this.options)
     return this.respectCache(filepath, async () => {
       const str = await template.read(filepath)
       return this.parse(str, filepath)
     })
-  },
-  renderFile: async function (file, ctx, opts) {
+  }
+  async renderFile(file, ctx, opts) {
     opts = _.assign({}, opts)
     const templates = await this.getTemplate(file, opts.root)
     return this.render(templates, ctx, opts)
-  },
-  respectCache: async function (key, getter) {
+  }
+  async respectCache (key, getter) {
     const cacheEnabled = this.options.cache
     if (cacheEnabled && this.cache[key]) {
       return this.cache[key]
@@ -63,21 +83,21 @@ const _engine = {
       this.cache[key] = value
     }
     return value
-  },
-  evalValue: function (str, scope) {
+  }
+  evalValue (str, scope) {
     const tpl = this.parser.parseValue(str.trim())
     return this.renderer.evalValue(tpl, scope)
-  },
-  registerFilter: function (name, filter) {
-    return this.filter.register(name, filter)
-  },
-  registerTag: function (name, tag) {
-    return this.tag.register(name, tag)
-  },
-  plugin: function (plugin) {
+  }
+  registerFilter (name, filter) {
+    return this.filters.register(name, filter)
+  }
+  registerTag (name, tag) {
+    return this.tags.register(name, tag)
+  }
+  plugin (plugin) {
     return plugin.call(this, Liquid)
-  },
-  express: function (opts) {
+  }
+  express (opts) {
     opts = opts || {}
     const self = this
     return function (filePath, ctx, cb) {
@@ -87,6 +107,21 @@ const _engine = {
       self.renderFile(filePath, ctx, opts).then(html => cb(null, html), cb)
     }
   }
+  static default = Liquid
+  static isTruthy = isTruthy
+  static isFalsy = isFalsy
+  static evalExp = evalExp
+  static evalValue = evalValue
+  static Types = {
+    ParseError,
+    TokenizationError,
+    RenderBreakError,
+    AssertionError,
+    AssignScope: {},
+    CaptureScope: {},
+    IncrementScope: {},
+    DecrementScope: {}
+  }
 }
 
 function normalizeStringArray (value) {
@@ -94,40 +129,3 @@ function normalizeStringArray (value) {
   if (_.isString(value)) return [value]
   throw new TypeError('illegal root: ' + value)
 }
-
-export default function Liquid (options) {
-  options = _.assign({
-    root: ['.'],
-    cache: false,
-    extname: '',
-    dynamicPartials: true,
-    trim_tag_right: false,
-    trim_tag_left: false,
-    trim_value_right: false,
-    trim_value_left: false,
-    greedy: true,
-    strict_filters: false,
-    strict_variables: false
-  }, options)
-  options.root = normalizeStringArray(options.root)
-
-  const engine = _.create(_engine)
-  engine.init(Tag(), Filter(options), options)
-  return engine
-}
-
-Liquid.default = Liquid
-Liquid.isTruthy = isTruthy
-Liquid.isFalsy = isFalsy
-Liquid.evalExp = evalExp
-Liquid.evalValue = evalValue
-Liquid.Types = {
-  ParseError,
-  TokenizationError,
-  RenderBreakError,
-  AssertionError,
-  AssignScope: {},
-  CaptureScope: {},
-  IncrementScope: {},
-  DecrementScope: {}
-}

src/template.ts

@@ -3,8 +3,8 @@ import * as path from 'path'
 import { anySeries } from './util/promise'
 import * as fs from 'fs'
 
-const statFileAsync = _.promisify(fs.stat)
-const readFileAsync = _.promisify(fs.readFile)
+const statFileAsync = <(filepath: string) => Promise<object>>_.promisify(fs.stat)
+const readFileAsync = <(filepath: string, encoding: string) => Promise<string>>_.promisify(fs.readFile)
 
 export async function resolve (filepath, root, options) {
   if (!path.extname(filepath)) {
@@ -24,6 +24,6 @@ export async function resolve (filepath, root, options) {
   })
 }
 
-export async function read (filepath) {
+export async function read (filepath): Promise<string> {
   return readFileAsync(filepath, 'utf8')
 }