Promise wrapper for node-tmp

tmp.js

const co = require('co');
const _tmp = require('tmp');
_tmp.setGracefulCleanup();

// Promise wrappers around tmp
const tmp = {
	/** @return {Promise<{path, cleanup}>} */
	file: () => co(function* () {
		return yield cb => _tmp.file({ unsafeCleanup: true }, (err, path, fd, cleanup) => cb(err, {
			path,
			cleanup
		}));
	}),

	/** @return {Promise<{path, cleanup}>} */
	dir: () => co(function* () {
		return yield cb => _tmp.dir({ unsafeCleanup: true }, (err, path, cleanup) => cb(err, {
			path,
			cleanup
		}));
	}),
	
	withDir: (callback) => co(function* () {
		const tmpObj = yield tmp.dir();
		
		return yield tmp.withTmpObj(tmpObj, callback)
	}),
	
	withFile: (callback) => co(function* () {
		const tmpObj = yield tmp.file();
		
		return yield tmp.withTmpObj(tmpObj, callback)
	}),
	
	withTmpObj: (tmpObj, callback) => co(function* () {
		try {
			const res = yield Promise.resolve(callback(tmpObj.path));
			return res;
		}
		finally {
			tmpObj.cleanup();
		}
	})
};

module.exports = tmp;

tmp.ts

import * as _tmp from 'tmp';

_tmp.setGracefulCleanup();

const tmp = {
  file: (): Promise<ITmpObj> => {
    return new Promise((onRes, onErr) => {
      _tmp.file(
        { unsafeCleanup: true },
        (err, path, fs, cleanup) => err ? onErr(err) : onRes({ path, cleanup })
      )
    })
  },

  dir: (): Promise<ITmpObj> => {
    return new Promise((onRes, onErr) => {
      _tmp.dir(
        { unsafeCleanup: true },
        (err, path, cleanup) => err ? onErr(err) : onRes({ path, cleanup })
      )
    })
  }
};

export default tmp;
export const file = tmp.file;
export const dir = tmp.dir;

interface ITmpObjConsumer<TRes> {
  (tmpFilePath: string): Promise<TRes> | TRes;
}

export async function withDir<TRes>(fn: ITmpObjConsumer<TRes>):Promise<TRes> {
  const tmpObj = await tmp.dir();

  return await withTmpObj(tmpObj, fn);
}

export async function withFile<TRes>(fn: ITmpObjConsumer<TRes>):Promise<TRes> {
  const tmpObj = await tmp.file();

  return await withTmpObj(tmpObj, fn);
}

async function withTmpObj<TRes>(tmpObj: ITmpObj, fn: ITmpObjConsumer<TRes>):Promise<TRes> {
  try {
    const res = await Promise.resolve(fn(tmpObj.path));
    return res;
  }
  finally {
    tmpObj.cleanup();
  }
}

export interface ITmpObj {
  path: string;
  cleanup: () => void;
}