switch to smartq

dist/smartfile.fs.d.ts

@@ -1,6 +1,4 @@
-/// <reference types="q" />
 import 'typings-global';
-import plugins = require('./smartfile.plugins');
 /**
  *
  * @param filePath
@@ -12,7 +10,7 @@ export declare let fileExistsSync: (filePath: any) => boolean;
  * @param filePath
  * @returns {any}
  */
-export declare let fileExists: (filePath: any) => plugins.q.Promise<{}>;
+export declare let fileExists: (filePath: any) => Promise<{}>;
 /**
  * Checks if given path points to an existing directory
  */
@@ -24,7 +22,7 @@ export declare let isFile: (pathArg: any) => boolean;
 /**
  * copies a file from A to B on the local disk
  */
-export declare let copy: (fromArg: string, toArg: string) => plugins.q.Promise<{}>;
+export declare let copy: (fromArg: string, toArg: string) => Promise<{}>;
 /**
  * copies a file SYNCHRONOUSLY from A to B on the local disk
  */
@@ -32,7 +30,7 @@ export declare let copySync: (fromArg: string, toArg: string) => boolean;
 /**
  * ensures that a directory is in place
  */
-export declare let ensureDir: (dirPathArg: string) => plugins.q.Promise<{}>;
+export declare let ensureDir: (dirPathArg: string) => Promise<{}>;
 /**
  * ensures that a directory is in place
  */
@@ -41,7 +39,7 @@ export declare let ensureDirSync: (dirPathArg: string) => void;
  * ensure an empty directory
  * @executes ASYNC
  */
-export declare let ensureEmptyDir: (dirPathArg: string) => plugins.q.Promise<{}>;
+export declare let ensureEmptyDir: (dirPathArg: string) => Promise<{}>;
 /**
  * ensure an empty directory
  * @executes SYNC
@@ -54,7 +52,7 @@ export declare let ensureEmptyDirSync: (dirPathArg: string) => void;
  * @returns Promise<void>
  * @exec ASYNC
  */
-export declare let ensureFile: (filePathArg: any, initFileStringArg: any) => plugins.q.Promise<void>;
+export declare let ensureFile: (filePathArg: any, initFileStringArg: any) => Promise<void>;
 /**
  * ensures that a file is on disk
  * @param filePath the filePath to ensureDir
@@ -66,7 +64,7 @@ export declare let ensureFileSync: (filePathArg: string, initFileStringArg: stri
 /**
  * removes a file or folder from local disk
  */
-export declare let remove: (pathArg: string) => plugins.q.Promise<void>;
+export declare let remove: (pathArg: string) => Promise<void>;
 /**
  * removes a file SYNCHRONOUSLY from local disk
  */
@@ -74,7 +72,7 @@ export declare let removeSync: (pathArg: string) => boolean;
 /**
  * removes an array of filePaths from disk
  */
-export declare let removeMany: (filePathArrayArg: string[]) => plugins.q.Promise<void[]>;
+export declare let removeMany: (filePathArrayArg: string[]) => Promise<void[]>;
 /**
  * like removeFilePathArray but SYNCHRONOUSLY
  */
@@ -109,7 +107,7 @@ export declare let requireReload: (path: string) => any;
  * lists Folders in a directory on local disk
  * @returns Promise
  */
-export declare let listFolders: (pathArg: string, regexFilter?: RegExp) => plugins.q.Promise<{}>;
+export declare let listFolders: (pathArg: string, regexFilter?: RegExp) => Promise<{}>;
 /**
  * lists Folders SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
@@ -119,7 +117,7 @@ export declare let listFoldersSync: (pathArg: string, regexFilter?: RegExp) => s
  * lists Files in a directory on local disk
  * @returns Promise
  */
-export declare let listFiles: (pathArg: string, regexFilter?: RegExp) => plugins.q.Promise<{}>;
+export declare let listFiles: (pathArg: string, regexFilter?: RegExp) => Promise<{}>;
 /**
  * lists Files SYNCHRONOUSLY in a directory on local disk
  * @returns an array with the folder names as strings
@@ -129,7 +127,7 @@ export declare let listFilesSync: (pathArg: string, regexFilter?: RegExp) => str
  * lists all items (folders AND files) in a directory on local disk
  * @returns Promise<string[]>
  */
-export declare let listAllItems: (pathArg: string, regexFilter?: RegExp) => plugins.q.Promise<string[]>;
+export declare let listAllItems: (pathArg: string, regexFilter?: RegExp) => Promise<string[]>;
 /**
  * lists all items (folders AND files) in a directory on local disk
  * @returns an array with the folder names as strings
@@ -141,4 +139,4 @@ export declare let listAllItemsSync: (pathArg: string, regexFilter?: RegExp) =>
  * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
  * @returns Promise<string[]> string array with the absolute paths of all matching files
  */
-export declare let listFileTree: (dirPathArg: string, miniMatchFilter: string) => plugins.q.Promise<string[]>;
+export declare let listFileTree: (dirPathArg: string, miniMatchFilter: string) => Promise<string[]>;

dist/smartfile.memory.d.ts

@@ -1,8 +1,6 @@
 /// <reference types="node" />
-/// <reference types="q" />
 import 'typings-global';
-import plugins = require('./smartfile.plugins');
+export interface IVinylFile {
-export interface vinyl {
     contents: Buffer;
     base: string;
     path: string;
@@ -14,7 +12,7 @@ export interface vinyl {
  * @returns stream.Readable
  * @TODO: make it async;
  */
-export declare let toGulpStream: (fileArg: string | string[] | vinyl | vinyl[], baseArg?: string) => any;
+export declare let toGulpStream: (fileArg: string | string[] | IVinylFile | IVinylFile[], baseArg?: string) => any;
 /**
  * converts file to Object
  * @param fileStringArg
@@ -45,12 +43,12 @@ export declare let toVinylArraySync: (arrayArg: string[], optionsArg?: {
 /**
  * takes a vinylFile object and converts it to String
  */
-export declare let vinylToStringSync: (fileArg: vinyl) => string;
+export declare let vinylToStringSync: (fileArg: IVinylFile) => string;
 /**
  * writes string or vinyl file to disk.
  * @param fileArg
  * @param fileNameArg
  * @param fileBaseArg
  */
-export declare let toFs: (fileContentArg: string | vinyl, filePathArg: any) => plugins.q.Promise<{}>;
+export declare let toFs: (fileContentArg: string | IVinylFile, filePathArg: any) => Promise<{}>;
 export declare let toFsSync: (fileArg: any, filePathArg: string) => void;

dist/smartfile.plugins.d.ts

@@ -4,7 +4,7 @@ export import fs = require('fs');
 export import fsExtra = require('fs-extra');
 export declare let glob: any;
 export import path = require('path');
-export import q = require('q');
+export import q = require('smartq');
 export declare let request: any;
 export declare let requireReload: any;
 export import smartpath = require('smartpath');

dist/smartfile.plugins.js

@@ -5,10 +5,10 @@ exports.fs = require("fs");
 exports.fsExtra = require("fs-extra");
 exports.glob = require('glob');
 exports.path = require("path");
-exports.q = require("q");
+exports.q = require("smartq");
 exports.request = require('request');
 exports.requireReload = require('require-reload');
 exports.smartpath = require("smartpath");
 exports.vinylFile = require('vinyl-file');
 exports.yaml = require('js-yaml');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRmaWxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGZpbGUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLHlDQUE4QztBQUM5QywyQkFBZ0M7QUFDaEMsc0NBQTJDO0FBQ2hDLFFBQUEsSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUNqQywrQkFBb0M7QUFDcEMseUJBQThCO0FBQ25CLFFBQUEsT0FBTyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQTtBQUM1QixRQUFBLGFBQWEsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQTtBQUNwRCx5Q0FBOEM7QUFDbkMsUUFBQSxTQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFBO0FBQ2pDLFFBQUEsSUFBSSxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQSJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRmaWxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGZpbGUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLHlDQUE4QztBQUM5QywyQkFBZ0M7QUFDaEMsc0NBQTJDO0FBQ2hDLFFBQUEsSUFBSSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQTtBQUNqQywrQkFBb0M7QUFDcEMsOEJBQW1DO0FBQ3hCLFFBQUEsT0FBTyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQTtBQUM1QixRQUFBLGFBQWEsR0FBRyxPQUFPLENBQUMsZ0JBQWdCLENBQUMsQ0FBQTtBQUNwRCx5Q0FBOEM7QUFDbkMsUUFBQSxTQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFBO0FBQ2pDLFFBQUEsSUFBSSxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQSJ9

dist/smartfile.remote.d.ts

@@ -1,16 +1,14 @@
-/// <reference types="q" />
 import 'typings-global';
-import plugins = require('./smartfile.plugins');
+export declare let toFs: (from: string, toPath: string) => Promise<{}>;
-export declare let toFs: (from: string, toPath: string) => plugins.q.Promise<{}>;
 /**
  *
  * @param fromArg
  * @returns {any}
  */
-export declare let toObject: (fromArg: string) => plugins.q.Promise<{}>;
+export declare let toObject: (fromArg: string) => Promise<{}>;
 /**
  *
  * @param fromArg
  * @returns {any}
  */
-export declare let toString: (fromArg: string) => plugins.q.Promise<{}>;
+export declare let toString: (fromArg: string) => Promise<{}>;

package.json

@@ -27,25 +27,23 @@
   "homepage": "https://gitlab.com/pushrocks/smartfile",
   "dependencies": {
     "@types/fs-extra": "0.x.x",
-    "@types/q": "0.x.x",
     "@types/vinyl": "^2.0.0",
     "beautylog": "^6.0.0",
-    "fs-extra": "^1.0.0",
+    "fs-extra": "^2.0.0",
     "glob": "^7.1.1",
     "js-yaml": "^3.7.0",
-    "q": "^1.4.1",
     "request": "^2.79.0",
     "require-reload": "0.2.2",
     "smartpath": "^3.2.7",
+    "smartq": "^1.0.4",
     "typings-global": "^1.0.14",
     "vinyl": "^2.0.1",
-    "vinyl-file": "^2.0.0"
+    "vinyl-file": "^3.0.0"
   },
   "devDependencies": {
-    "@types/should": "^8.1.30",
     "gulp-function": "^2.2.3",
-    "npmts-g": "^5.2.10",
+    "npmts-g": "^6.0.0",
-    "should": "^11.1.2",
+    "smartchai": "^1.0.1",
     "typings-test": "^1.0.3"
   }
 }

test/test.ts

@@ -2,54 +2,56 @@ import 'typings-test'
 import * as smartfile from '../dist/index'
 import beautylog = require('beautylog')
 import path = require('path')
-import * as should from 'should'
+
+import { expect } from 'smartchai'
+
 import * as vinyl from 'vinyl'
 
 describe('smartfile', function () {
     describe('.fs', function () {
         describe('.fileExistsSync', function () {
             it('should return an accurate boolean', function () {
-                should(smartfile.fs.fileExistsSync('./test/mytest.json')).be.true()
+                expect(smartfile.fs.fileExistsSync('./test/mytest.json')).to.be.true
-                should(smartfile.fs.fileExistsSync('./test/notthere.json')).be.false()
+                expect(smartfile.fs.fileExistsSync('./test/notthere.json')).be.false
             })
         })
         describe('.fileExists', function () {
             it('should return a working promise', function () {
-                should(smartfile.fs.fileExists('./test/mytest.json')).be.Promise()
+                expect(smartfile.fs.fileExists('./test/mytest.json')).to.be.a('promise')
-                should(smartfile.fs.fileExists('./test/mytest.json')).be.fulfilled()
+                expect(smartfile.fs.fileExists('./test/mytest.json')).to.be.fulfilled
-                should(smartfile.fs.fileExists('./test/notthere.json')).not.be.fulfilled()
+                expect(smartfile.fs.fileExists('./test/notthere.json')).to.not.be.fulfilled
             })
         })
         describe('.listFoldersSync()', function () {
             it('should get the file type from a string', function () {
-                should(smartfile.fs.listFoldersSync('./test/')).containDeep(['testfolder'])
+                expect(smartfile.fs.listFoldersSync('./test/')).to.deep.include('testfolder')
-                should(smartfile.fs.listFoldersSync('./test/')).not.containDeep(['notExistentFolder'])
+                expect(smartfile.fs.listFoldersSync('./test/')).to.not.deep.include('notExistentFolder')
             })
         })
         describe('.listFolders()', function () {
             it('should get the file type from a string', function (done) {
                 smartfile.fs.listFolders('./test/')
                     .then(function (folderArrayArg) {
-                        should(folderArrayArg).containDeep(['testfolder'])
+                        expect(folderArrayArg).to.deep.include('testfolder')
-                        should(folderArrayArg).not.containDeep(['notExistentFolder'])
+                        expect(folderArrayArg).to.not.deep.include('notExistentFolder')
                         done()
                     })
             })
         })
         describe('.listFilesSync()', function () {
             it('should get the file type from a string', function () {
-                should(smartfile.fs.listFilesSync('./test/')).containDeep(['mytest.json'])
+                expect(smartfile.fs.listFilesSync('./test/')).to.deep.include('mytest.json')
-                should(smartfile.fs.listFilesSync('./test/')).not.containDeep(['notExistentFile'])
+                expect(smartfile.fs.listFilesSync('./test/')).to.not.deep.include('notExistentFile')
-                should(smartfile.fs.listFilesSync('./test/', /mytest\.json/)).containDeep(['mytest.json'])
+                expect(smartfile.fs.listFilesSync('./test/', /mytest\.json/)).to.deep.include('mytest.json')
-                should(smartfile.fs.listFilesSync('./test/', /mytests.json/)).not.containDeep(['mytest.json'])
+                expect(smartfile.fs.listFilesSync('./test/', /mytests.json/)).to.not.deep.include('mytest.json')
             })
         })
         describe('.listFiles()', function () {
             it('should get the file type from a string', function (done) {
                 smartfile.fs.listFiles('./test/')
                     .then(function (folderArrayArg) {
-                        should(folderArrayArg).containDeep(['mytest.json'])
+                        expect(folderArrayArg).to.deep.include('mytest.json')
-                        should(folderArrayArg).not.containDeep(['notExistentFile'])
+                        expect(folderArrayArg).to.not.deep.include('notExistentFile')
                         done()
                     })
             })
@@ -58,8 +60,8 @@ describe('smartfile', function () {
             it('should get a file tree', function (done) {
                 smartfile.fs.listFileTree(path.resolve('./test/'), '**/*.txt')
                     .then(function (folderArrayArg) {
-                        should(folderArrayArg).containDeep(['testfolder/testfile1.txt'])
+                        expect(folderArrayArg).to.deep.include('testfolder/testfile1.txt')
-                        should(folderArrayArg).not.containDeep(['mytest.json'])
+                        expect(folderArrayArg).to.not.deep.include('mytest.json')
                         done()
                     })
             })
@@ -85,19 +87,19 @@ describe('smartfile', function () {
             })
             it('smartfile.fs.removeSync -> should remove single files synchronouly',function() {
                 smartfile.fs.removeSync('./test/temp/testfile1.txt')
-                should(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).be.false()
+                expect(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).to.be.false
             })
             it('smartfile.fs.removeMany -> should remove and array of files',function(done) {
                 smartfile.fs.removeMany(['./test/temp/testfile1.txt','./test/temp/testfile2.txt']).then(() => {
-                    should(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).be.false()
+                    expect(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).to.be.false
-                    should(smartfile.fs.fileExistsSync('./test/temp/testfile2.txt')).be.false()
+                    expect(smartfile.fs.fileExistsSync('./test/temp/testfile2.txt')).to.be.false
                     done()
                 })
             })
             it('smartfile.fs.removeManySync -> should remove and array of single files synchronouly',function() {
                 smartfile.fs.removeManySync(['./test/temp/testfile1.txt','./test/temp/testfile2.txt'])
-                should(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).be.false()
+                expect(smartfile.fs.fileExistsSync('./test/temp/testfile1.txt')).to.be.false
-                should(smartfile.fs.fileExistsSync('./test/temp/testfile2.txt')).be.false()
+                expect(smartfile.fs.fileExistsSync('./test/temp/testfile2.txt')).to.be.false
             })
         })
     })
@@ -105,7 +107,7 @@ describe('smartfile', function () {
     describe('.interpreter', function () {
         describe('.filetype()', function () {
             it('should get the file type from a string', function () {
-                should(smartfile.interpreter.filetype('./somefolder/data.json')).equal('json')
+                expect(smartfile.interpreter.filetype('./somefolder/data.json')).equal('json')
             })
         })
     })
@@ -114,8 +116,8 @@ describe('smartfile', function () {
         describe('.toObjectSync()', function () {
             it('should read an ' + '.yaml' + ' file to an object', function () {
                 let testData = smartfile.fs.toObjectSync('./test/mytest.yaml')
-                should(testData).have.property('key1', 'this works')
+                expect(testData).have.property('key1', 'this works')
-                should(testData).have.property('key2', 'this works too')
+                expect(testData).have.property('key2', 'this works too')
 
             })
             it('should state unknown file type for unknown file types', function () {
@@ -123,23 +125,21 @@ describe('smartfile', function () {
             })
             it('should read an ' + '.json' + ' file to an object', function () {
                 let testData = smartfile.fs.toObjectSync('./test/mytest.json')
-                should(testData).have.property('key1', 'this works')
+                expect(testData).have.property('key1', 'this works')
-                should(testData).have.property('key2', 'this works too')
+                expect(testData).have.property('key2', 'this works too')
 
             })
         })
         describe('.toStringSync()', function () {
             it('should read a file to a string', function () {
-                should.equal(
+                expect(smartfile.fs.toStringSync('./test/mytest.txt'))
-                    smartfile.fs.toStringSync('./test/mytest.txt'),
+                    .to.equal('Some TestString &&%$')
-                    'Some TestString &&%$'
-                )
             })
         })
         describe('.toVinylSync', function () {
             it('should read an ' + '.json OR .yaml' + ' file to an ' + 'vinyl file object', function () {
                 let testData = smartfile.fs.toVinylSync('./test/mytest.json')
-                should(vinyl.isVinyl(testData)).be.true()
+                expect(vinyl.isVinyl(testData)).to.be.true
             })
         })
     })
@@ -155,7 +155,7 @@ describe('smartfile', function () {
             it('should produce a vinylFile', function () {
                 let localString = 'myString'
                 let localOptions = { filename: 'vinylfile2', base: '/someDir' }
-                should(smartfile.memory.toVinylFileSync(localString, localOptions) instanceof vinyl).be.true()
+                expect(smartfile.memory.toVinylFileSync(localString, localOptions) instanceof vinyl).to.be.true
             })
         })
         describe('toVinylArraySync()', function () {
@@ -163,10 +163,10 @@ describe('smartfile', function () {
                 let localStringArray = ['string1', 'string2', 'string3']
                 let localOptions = { filename: 'vinylfile2', base: '/someDir' }
                 let testResult = smartfile.memory.toVinylArraySync(localStringArray, localOptions)
-                should(testResult).be.Array()
+                expect(testResult).to.be.a('array')
-                should(testResult.length === 3).be.true()
+                expect(testResult.length === 3).to.be.true
                 for (let myKey in testResult) {
-                    should(testResult[myKey] instanceof vinyl).be.true()
+                    expect(testResult[myKey] instanceof vinyl).to.be.true
                 }
             })
         })
@@ -177,7 +177,7 @@ describe('smartfile', function () {
                     path: '/test.txt',
                     contents: new Buffer('myString')
                 }))
-                should(localString).equal('myString')
+                expect(localString).equal('myString')
             })
         })
         describe('toFs()', function () {
@@ -207,18 +207,21 @@ describe('smartfile', function () {
                 smartfile.remote.toString(
                     'https://raw.githubusercontent.com/pushrocks/smartfile/master/test/mytest.txt'
                 ).then(function (responseString) {
-                    should.equal(responseString, 'Some TestString &&%$')
+                    expect(responseString).to.equal('Some TestString &&%$')
                     done()
                 })
             })
             it('should reject a Promise when the link is false', function (done) {
                 this.timeout(10000)
                 smartfile.remote.toString('https://push.rocks/doesnotexist.txt')
-                    .then(function () {
+                    .then(
+                        function () {
                             throw new Error('this test should not be resolved')
-                    }, function () {
+                        },
+                        function () {
                             done()
-                    })
+                        }
+                    )
             })
         })
     })

ts/smartfile.fs.ts

@@ -30,7 +30,7 @@ export let fileExistsSync = function(filePath): boolean {
  */
 export let fileExists = function(filePath){
     let done = plugins.q.defer()
-    plugins.fs.access(filePath, plugins.fs.R_OK, function (err) {
+    plugins.fs.access(filePath, 4, function (err) {
         err ? done.reject(err) : done.resolve()
     })
     return done.promise
@@ -117,7 +117,7 @@ export let ensureEmptyDirSync = (dirPathArg: string) => {
  * @returns Promise<void>
  * @exec ASYNC
  */
-export let ensureFile = (filePathArg, initFileStringArg): plugins.q.Promise<void> => {
+export let ensureFile = (filePathArg, initFileStringArg): Promise<void> => {
     let done = plugins.q.defer<void>()
     ensureFileSync(filePathArg, initFileStringArg)
     done.resolve()
@@ -142,7 +142,7 @@ export let ensureFileSync = (filePathArg: string, initFileStringArg: string): vo
 /**
  * removes a file or folder from local disk
  */
-export let remove = function(pathArg: string): plugins.q.Promise<void> {
+export let remove = function(pathArg: string): Promise<void> {
     let done = plugins.q.defer<void>()
     plugins.fsExtra.remove(pathArg,function(){
         done.resolve()
@@ -162,11 +162,11 @@ export let removeSync = function(pathArg: string): boolean{
  * removes an array of filePaths from disk
  */
 export let removeMany = function(filePathArrayArg: string[]){
-    let promiseArray: plugins.q.Promise<void>[] = []
+    let promiseArray: Promise<void>[] = []
     for (let filePath of filePathArrayArg) {
         promiseArray.push(remove(filePath))
     }
-    return plugins.q.all(promiseArray)
+    return Promise.all(promiseArray)
 }
 
 /**
@@ -297,7 +297,7 @@ export let listFilesSync = function(pathArg: string, regexFilter?: RegExp): stri
  * lists all items (folders AND files) in a directory on local disk
  * @returns Promise<string[]>
  */
-export let listAllItems = function(pathArg: string, regexFilter?: RegExp): plugins.q.Promise<string[]> {
+export let listAllItems = function(pathArg: string, regexFilter?: RegExp): Promise<string[]> {
     let done = plugins.q.defer<string[]>()
     let allItmesArray = plugins.fsExtra.readdirSync(pathArg)
     if (regexFilter) {
@@ -331,7 +331,7 @@ export let listAllItemsSync = function(pathArg: string, regexFilter?: RegExp): s
  * note: if the miniMatch Filter is an absolute path, the cwdArg will be omitted
  * @returns Promise<string[]> string array with the absolute paths of all matching files
  */
-export let listFileTree = (dirPathArg: string, miniMatchFilter: string): plugins.q.Promise<string[]> => {
+export let listFileTree = (dirPathArg: string, miniMatchFilter: string): Promise<string[]> => {
     let done = plugins.q.defer<string[]>()
 
     // handle absolute miniMatchFilter

ts/smartfile.memory.ts

@@ -4,7 +4,7 @@ import plugins = require('./smartfile.plugins')
 import SmartfileInterpreter = require('./smartfile.interpreter')
 let vinyl = require('vinyl')
 
-export interface vinyl {
+export interface IVinylFile {
     contents: Buffer
     base: string
     path: string,
@@ -19,10 +19,10 @@ let Readable = require('stream').Readable
  * @returns stream.Readable
  * @TODO: make it async;
  */
-export let toGulpStream = function(fileArg: string|string[]|vinyl|vinyl[],baseArg: string = '/'){
+export let toGulpStream = function(fileArg: string|string[]|IVinylFile|IVinylFile[],baseArg: string = '/'){
     let fileArray = []
 
-    if (typeof fileArg === 'string' || fileArg instanceof vinyl) { // make sure we work with an array later on
+    if (typeof fileArg === 'string' || vinyl.isVinyl(fileArg)) { // make sure we work with an array later on
         fileArray.push(fileArg)
     } else if (Array.isArray(fileArg)) {
         fileArray = fileArg
@@ -30,7 +30,7 @@ export let toGulpStream = function(fileArg: string|string[]|vinyl|vinyl[],baseAr
         throw new Error('fileArg has unknown format')
     }
 
-    let vinylFileArray: vinyl[] = [] // we want to have an array of vinylFiles
+    let vinylFileArray: IVinylFile[] = [] // we want to have an array of vinylFiles
 
     for (let fileIndexArg in fileArray) { // convert fileArray in vinylArray
         let file = fileArray[fileIndexArg]
@@ -100,7 +100,7 @@ export let toVinylArraySync = function(
 /**
  * takes a vinylFile object and converts it to String
  */
-export let vinylToStringSync = function(fileArg: vinyl){
+export let vinylToStringSync = function(fileArg: IVinylFile): string {
     return fileArg.contents.toString('utf8')
 }
 
@@ -110,7 +110,7 @@ export let vinylToStringSync = function(fileArg: vinyl){
  * @param fileNameArg
  * @param fileBaseArg
  */
-export let toFs = function(fileContentArg: string|vinyl,filePathArg){
+export let toFs = function(fileContentArg: string|IVinylFile,filePathArg){
     let done = plugins.q.defer()
 
     // function checks to abort if needed
@@ -121,8 +121,9 @@ export let toFs = function(fileContentArg: string|vinyl,filePathArg){
     // prepare actual write action
     let fileString: string
     let filePath: string = filePathArg
-    if (fileContentArg instanceof vinyl) {
+    if (vinyl.isVinyl(fileContentArg)) {
-        fileString = vinylToStringSync(fileContentArg)
+        let fileContentArg2: any = fileContentArg
+        fileString = vinylToStringSync(fileContentArg2)
     } else if (typeof fileContentArg === 'string') {
         fileString = fileContentArg
     }

ts/smartfile.plugins.ts

@@ -4,7 +4,7 @@ export import fs = require('fs')
 export import fsExtra = require('fs-extra')
 export let glob = require('glob')
 export import path = require('path')
-export import q = require('q')
+export import q = require('smartq')
 export let request = require('request')
 export let requireReload = require('require-reload')
 export import smartpath = require('smartpath')