Initial version

Author: barbatus

cache.js

@@ -0,0 +1,141 @@
+'use strict';
+
+const path = require("path");
+const fs = require("fs");
+const assert = require("assert");
+const LRU = require("lru-cache");
+const utils = require("./utils");
+const pkgVersion = require("./package.json").version;
+const random = require("random-js")();
+
+function ensureCacheDir(cacheDir) {
+  cacheDir = path.resolve(
+    cacheDir ||
+    process.env.TYPESCRIPT_CACHE_DIR ||
+    path.join(
+      process.env.HOME || process.env.USERPROFILE || __dirname,
+        ".typescript-cache"
+    )
+  );
+
+  try {
+    utils.mkdirp(cacheDir);
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+
+  return cacheDir;
+}
+
+class Cache {
+
+  constructor(compileFn, cacheDir) {
+    assert.strictEqual(typeof compileFn, "function");
+
+    this.compileFn = compileFn;
+    this.cacheDir = ensureCacheDir(cacheDir);
+
+    const maxSize = process.env.TYPESCRIPT_CACHE_SIZE;
+    this._cache = new LRU({
+      max: maxSize || 1024 * 10 * 10
+    });
+  }
+
+  get(source, options) {
+    let cacheKey = utils.deepHash(pkgVersion, source, options);
+    let compileResult = this._cache.get(cacheKey);
+
+    if (! compileResult) {
+      compileResult = this._readCache(cacheKey);
+    }
+
+    if (! compileResult) {
+      compileResult = this.compileFn(source, options);
+      this._cache.set(cacheKey, compileResult);
+      this._writeCacheAsync(cacheKey, compileResult);
+    }
+
+    return compileResult;
+  }
+
+  _cacheFilename(cacheKey) {
+    // We want cacheKeys to be hex so that they work on any FS
+    // and never end in .cache.
+    if (!/^[a-f0-9]+$/.test(cacheKey)) {
+      throw Error('bad cacheKey: ' + cacheKey);
+    }
+
+    return path.join(this.cacheDir, cacheKey + '.cache');
+  }
+
+  _readFileOrNull(filename) {
+    try {
+      return fs.readFileSync(filename, 'utf8');
+    } catch (e) {
+      if (e && e.code === 'ENOENT')
+        return null;
+      throw e;
+    }
+  }
+
+  _parseJSONOrNull(json) {
+    try {
+      return JSON.parse(json);
+    } catch (e) {
+      if (e instanceof SyntaxError)
+        return null;
+      throw e;
+    }
+  }
+
+  // Returns null if the file does not exist or can't be parsed; otherwise
+  // returns the parsed compileResult in the file.
+  _readAndParseCompileResultOrNull(filename) {
+    var content = this._readFileOrNull(filename);
+    return this._parseJSONOrNull(content);
+  }
+
+  _readCache(cacheKey) {
+    if (! this.cacheDir) {
+      return null;
+    }
+
+    var cacheFilename = this._cacheFilename(cacheKey);
+    var compileResult = this._readAndParseCompileResultOrNull(cacheFilename);
+    if (! compileResult) {
+      return null;
+    }
+    this._cache.set(cacheKey, compileResult);
+
+    return compileResult;
+  }
+
+  // We want to write the file atomically.
+  // But we also don't want to block processing on the file write.
+  _writeFileAsync(filename, contents) {
+    var tempFilename = filename + '.tmp.' + random.uuid4();
+    fs.writeFile(tempFilename, contents, (err) => {
+      // ignore errors, it's just a cache
+      if (err) {
+        return;
+      }
+      fs.rename(tempFilename, filename, (err) => {
+        // ignore this error too.
+      });
+    });
+  }
+
+  _writeCacheAsync(cacheKey, compileResult) {
+    if (! this.cacheDir) return;
+
+    var cacheFilename = this._cacheFilename(cacheKey);
+    var cacheContents = JSON.stringify(compileResult);
+    this._writeFileAsync(cacheFilename, cacheContents);
+  }
+
+}
+
+exports.Cache = Cache;
+

index.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const getDefaultOptions = require("./options").getDefaultOptions;
+const tsCompile = require("./typescript").compile;
+const Cache = require("./cache").Cache;
+
+function setCacheDir(cacheDir) {
+  if (compileCache && compileCache.cacheDir === cacheDir) {
+    return;
+  }
+
+  compileCache = new Cache(function(source, options) {
+    return tsCompile(source, options);
+  }, cacheDir);
+}
+
+exports.setCacheDir = setCacheDir;
+
+let compileCache;
+exports.compile = function compile(source, options) {
+  options = options || {compilerOptions: getDefaultOptions()};
+
+  if (! options.useCache) {
+    return tsCompile(source, options);
+  }
+
+  if (! compileCache) {
+    setCacheDir();
+  }
+
+  return compileCache.get(source, options);
+};

options.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const ts = require("typescript");
+const _ = require("underscore");
+
+function getCompilerOptions(customOptions) {
+  let compilerOptions = ts.getDefaultCompilerOptions();
+
+  _.extend(compilerOptions, customOptions);
+
+  // Support decorators by default.
+  compilerOptions.experimentalDecorators = true;
+
+  // Declaration files are expected to
+  // be generated separately.
+  compilerOptions.declaration = false;
+
+  // Overrides watching,
+  // it is handled by Meteor itself.
+  compilerOptions.watch = false;
+
+  // We use source maps via Meteor file API,
+  // This class's API provides source maps
+  // separately but alongside compilation results.
+  // Hence, skip generating inline source maps.
+  compilerOptions.inlineSourceMap = false;
+  compilerOptions.inlineSources = false;
+
+  // Always emit.
+  compilerOptions.noEmit = false;
+  compilerOptions.noEmitOnError = false;
+
+  // Don't generate any files, hence,
+  // skip setting outDir and outFile.
+  compilerOptions.outDir = null;
+  compilerOptions.outFile = null;
+
+  // This is not need as well.
+  // API doesn't have paramless methods.
+  compilerOptions.rootDir = null;
+  compilerOptions.sourceRoot = null;
+
+  return compilerOptions;
+}
+
+exports.getCompilerOptions = getCompilerOptions;
+
+// Default compiler options.
+function getDefaultOptions() {
+  return {
+    module : ts.ModuleKind.None,
+    target: ts.ScriptTarget.ES5,
+    sourceMap: true,
+    noResolve: false,
+    diagnostics: true,
+    // Custom option to turn on/off cache.
+    useCache: true,
+    // Always emit class metadata,
+    // especially useful for Angular2.
+    emitDecoratorMetadata: true
+  }
+}
+
+exports.getDefaultOptions = getDefaultOptions;

package.json

@@ -0,0 +1,36 @@
+{
+  "name": "meteor-typescript",
+  "author": "@barbatus",
+  "version": "0.1.0",
+  "license": "MIT",
+  "description": "TypeScript wrapper package for use with Meteor",
+  "keywords": [
+    "meteor",
+    "typescript",
+    "es6",
+    "es7",
+    "transpiler",
+    "transpilation",
+    "compilation"
+  ],
+  "main": "index.js",
+  "scripts": {
+    "test": "tests/run.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/barbatus/meteor-typescript.git"
+  },
+  "bugs": {
+    "url": "https://github.com/barbatus/meteor-typescript/issues"
+  },
+  "dependencies": {
+    "typescript": "^1.7.5",
+    "lru-cache": "^2.6.4",
+    "underscore": "^1.8.3",
+    "random-js": "^1.0.3"
+  },
+  "devDependencies": {
+    "mocha": "^2.2.5"
+  }
+}

tests/run.sh

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+
+cd $(dirname $0)
+TEST_DIR=$(pwd)
+
+TYPESCRIPT_CACHE_DIR=${TEST_DIR}/.cache
+export TYPESCRIPT_CACHE_DIR
+
+node tests.js

tests/tests.js

@@ -0,0 +1,7 @@
+var meteorTS = require("../index");
+var assert = require("assert");
+
+// Some dummy test.
+var result = meteorTS.compile("export const foo = 600;");
+assert.equal(result.code.indexOf("exports.foo = 600;"), 0);
+