Changing ts files to js in parser to keep it consistent

Author: munozemilio

packages/luis/src/commands/luis/generate/cs.ts

@@ -2,8 +2,7 @@ import {CLIError, Command, flags} from '@microsoft/bf-cli-command'
 import {camelCase, upperFirst} from 'lodash'
 import * as path from 'path'
 
-import {LuisToCsConverter} from '../../../parser/converters/luis-to-cs-converter'
-
+const LuisToCsConverter = require('./../../../parser/converters/luistocsconverter')
 const file = require('./../../../utils/filehelper')
 const fs = require('fs-extra')
 

packages/luis/src/commands/luis/generate/ts.ts

@@ -2,8 +2,7 @@ import {CLIError, Command, flags} from '@microsoft/bf-cli-command'
 import {camelCase, kebabCase, upperFirst} from 'lodash'
 import * as path from 'path'
 
-import {LuisToTsConverter} from '../../../parser/converters/luis-to-ts-converter'
-
+const LuisToTsConverter = require('./../../../parser/converters/luistotsconverter')
 const file = require('./../../../utils/filehelper')
 const fs = require('fs-extra')
 

packages/luis/src/parser/converters/helpers/writer.js

@@ -0,0 +1,96 @@
+const fs = require("fs");
+class Writer {
+    constructor() {
+        this.indentSize = 4;
+        this.indentLevel = 0;
+        this.outputStream = undefined;
+    }
+    async setOutputStream(outputPath) {
+        const ConsoleStream = require('console-stream');
+        const stream = outputPath ? fs.createWriteStream(outputPath) : ConsoleStream();
+        const streamPromise = new Promise((resolve) => {
+            if (stream instanceof fs.WriteStream) {
+                stream.once('ready', (_fd) => {
+                    this.outputStream = stream;
+                    resolve();
+                });
+            }
+            else {
+                this.outputStream = stream;
+                resolve();
+            }
+        });
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(resolve, 2000);
+            this.outputStream = stream;
+        });
+        return Promise.race([streamPromise, timeoutPromise]).then(() => {
+        });
+    }
+    increaseIndentation() {
+        this.indentLevel += this.indentSize;
+    }
+    decreaseIndentation() {
+        this.indentLevel -= this.indentSize;
+    }
+    write(str) {
+        this.outputStream.write(str);
+    }
+    writeLine(str = '') {
+        if (typeof str === 'string') {
+            this.write(str + '\n');
+        }
+        else {
+            str.forEach(line => {
+                this.write(line + '\n');
+            });
+        }
+    }
+    writeIndented(str) {
+        let writeFunction = (text) => {
+            for (let index = 0; index < this.indentLevel; index++) {
+                this.write(' ');
+            }
+            this.write(text);
+        };
+        writeFunction.bind(this);
+        if (typeof str === 'string') {
+            writeFunction(str);
+        }
+        else {
+            str.forEach(line => {
+                writeFunction(line);
+            });
+        }
+    }
+    writeLineIndented(lines) {
+        if (typeof lines === 'string') {
+            this.writeIndented(lines + '\n');
+        }
+        else {
+            lines.forEach(line => {
+                this.writeIndented(line + '\n');
+            });
+        }
+    }
+    async closeOutputStream() {
+        this.outputStream.end();
+        const streamPromise = new Promise((resolve) => {
+            if (this.outputStream instanceof fs.WriteStream) {
+                this.outputStream.on('finish', (_fd) => {
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+        const timeoutPromise = new Promise((resolve) => {
+            setTimeout(resolve, 1000);
+        });
+        return Promise.race([streamPromise, timeoutPromise]).then(() => {
+            this.outputStream = undefined;
+        });
+    }
+}
+module.exports = Writer;