fixes for rich text menu updates and setting parameters on text doc vs within in RTF. Lots of lint cleanup.

1 files changed, 46 insertions, 33 deletions

diff --git a/src/server/ActionUtilities.ts b/src/server/ActionUtilities.ts
index 6f5b9272a..520ebb42e 100644
--- a/src/server/ActionUtilities.ts
+++ b/src/server/ActionUtilities.ts
@@ -16,29 +16,30 @@ export function pathFromRoot(relative?: string) {
     return path.resolve(projectRoot, relative);
 }
 
-export async function fileDescriptorFromStream(path: string) {
-    const logStream = createWriteStream(path);
-    return new Promise<number>(resolve => logStream.on('open', resolve));
+export async function fileDescriptorFromStream(filePath: string) {
+    const logStream = createWriteStream(filePath);
+    return new Promise<number>(resolve => {
+        logStream.on('open', resolve);
+    });
 }
 
-export const command_line = (command: string, fromDirectory?: string) => {
-    return new Promise<string>((resolve, reject) => {
+export const commandLine = (command: string, fromDirectory?: string) =>
+    new Promise<string>((resolve, reject) => {
         const options: ExecOptions = {};
         if (fromDirectory) {
             options.cwd = fromDirectory ? path.resolve(projectRoot, fromDirectory) : projectRoot;
         }
         exec(command, options, (err, stdout) => (err ? reject(err) : resolve(stdout)));
     });
-};
 
-export const read_text_file = (relativePath: string) => {
+export const readTextFile = (relativePath: string) => {
     const target = path.resolve(__dirname, relativePath);
     return new Promise<string>((resolve, reject) => {
         readFile(target, (err, data) => (err ? reject(err) : resolve(data.toString())));
     });
 };
 
-export const write_text_file = (relativePath: string, contents: any) => {
+export const writeTextFile = (relativePath: string, contents: any) => {
     const target = path.resolve(__dirname, relativePath);
     return new Promise<void>((resolve, reject) => {
         writeFile(target, contents, err => (err ? reject(err) : resolve()));
@@ -55,39 +56,38 @@ export interface LogData<T> {
     color?: Color;
 }
 
+function logHelper(content: string, color: Color | string) {
+    if (typeof color === 'string') {
+        console.log(color, content);
+    } else {
+        console.log(color(content));
+    }
+}
+
 let current = Math.ceil(Math.random() * 20);
 export async function logExecution<T>({ startMessage, endMessage, action, color }: LogData<T>): Promise<T | undefined> {
-    let result: T | undefined = undefined,
-        error: Error | null = null;
+    let result: T | undefined;
+    let error: Error | null = null;
     const resolvedColor = color || `\x1b[${31 + (++current % 6)}m%s\x1b[0m`;
-    log_helper(`${startMessage}...`, resolvedColor);
+    logHelper(`${startMessage}...`, resolvedColor);
     try {
         result = await action();
     } catch (e: any) {
         error = e;
     } finally {
-        log_helper(typeof endMessage === 'string' ? endMessage : endMessage({ result, error }), resolvedColor);
+        logHelper(typeof endMessage === 'string' ? endMessage : endMessage({ result, error }), resolvedColor);
     }
     return result;
 }
-
-function log_helper(content: string, color: Color | string) {
-    if (typeof color === 'string') {
-        console.log(color, content);
-    } else {
-        console.log(color(content));
-    }
-}
-
 export function logPort(listener: string, port: number) {
     console.log(`${listener} listening on port ${yellow(String(port))}`);
 }
 
 export function msToTime(duration: number) {
-    const milliseconds = Math.floor((duration % 1000) / 100),
-        seconds = Math.floor((duration / 1000) % 60),
-        minutes = Math.floor((duration / (1000 * 60)) % 60),
-        hours = Math.floor((duration / (1000 * 60 * 60)) % 24);
+    const milliseconds = Math.floor((duration % 1000) / 100);
+    const seconds = Math.floor((duration / 1000) % 60);
+    const minutes = Math.floor((duration / (1000 * 60)) % 60);
+    const hours = Math.floor((duration / (1000 * 60 * 60)) % 24);
 
     const hoursS = hours < 10 ? '0' + hours : hours;
     const minutesS = minutes < 10 ? '0' + minutes : minutes;
@@ -96,21 +96,32 @@ export function msToTime(duration: number) {
     return hoursS + ':' + minutesS + ':' + secondsS + '.' + milliseconds;
 }
 
-export const createIfNotExists = async (path: string) => {
-    if (await new Promise<boolean>(resolve => exists(path, resolve))) {
+export const createIfNotExists = async (filePath: string) => {
+    if (
+        await new Promise<boolean>(resolve => {
+            exists(filePath, resolve);
+        })
+    ) {
         return true;
     }
-    return new Promise<boolean>(resolve => mkdir(path, error => resolve(error === null)));
+    return new Promise<boolean>(resolve => {
+        mkdir(filePath, error => resolve(error === null));
+    });
 };
 
 export async function Prune(rootDirectory: string): Promise<boolean> {
     // const error =  await new Promise<Error>(resolve => rimraf(rootDirectory).then(resolve));
-    await new Promise<void>(resolve => rimraf(rootDirectory).then(() => resolve()));
+    await new Promise<void>(resolve => {
+        rimraf(rootDirectory).then(() => resolve());
+    });
     // return error === null;
     return true;
 }
 
-export const Destroy = (mediaPath: string) => new Promise<boolean>(resolve => unlink(mediaPath, error => resolve(error === null)));
+export const Destroy = (mediaPath: string) =>
+    new Promise<boolean>(resolve => {
+        unlink(mediaPath, error => resolve(error === null));
+    });
 
 export namespace Email {
     const smtpTransport = nodemailer.createTransport({
@@ -137,9 +148,9 @@ export namespace Email {
         const failures: DispatchFailure[] = [];
         await Promise.all(
             to.map(async recipient => {
-                let error: Error | null;
                 const resolved = attachments ? ('length' in attachments ? attachments : [attachments]) : undefined;
-                if ((error = await Email.dispatch({ to: recipient, subject, content, attachments: resolved })) !== null) {
+                const error = await Email.dispatch({ to: recipient, subject, content, attachments: resolved });
+                if (error !== null) {
                     failures.push({
                         recipient,
                         error,
@@ -158,6 +169,8 @@ export namespace Email {
             text: `Hello ${to.split('@')[0]},\n\n${content}`,
             attachments,
         } as MailOptions;
-        return new Promise<Error | null>(resolve => smtpTransport.sendMail(mailOptions, resolve));
+        return new Promise<Error | null>(resolve => {
+            smtpTransport.sendMail(mailOptions, resolve);
+        });
     }
 }