@rockcarver/frodo-lib 0.12.0 → 0.12.2-0

package/cjs/ops/ThemeOps.js

@@ -1,27 +1,42 @@
-import fs from 'fs';
-import { deleteTheme, deleteThemeByName, deleteThemes, getTheme, getThemeByName, getThemes, putTheme, putThemeByName, putThemes } from '../api/ThemeApi';
-import { createProgressIndicator, createTable, printMessage, stopProgressIndicator, updateProgressIndicator } from './utils/Console';
-import { getRealmString, getTypedFilename, saveToFile, validateImport } from './utils/ExportImportUtils';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.deleteThemeByNameCmd = deleteThemeByNameCmd;
+exports.deleteThemeCmd = deleteThemeCmd;
+exports.deleteThemesCmd = deleteThemesCmd;
+exports.exportThemeById = exportThemeById;
+exports.exportThemeByName = exportThemeByName;
+exports.exportThemesToFile = exportThemesToFile;
+exports.exportThemesToFiles = exportThemesToFiles;
+exports.importFirstThemeFromFile = importFirstThemeFromFile;
+exports.importThemeById = importThemeById;
+exports.importThemeByName = importThemeByName;
+exports.importThemesFromFile = importThemesFromFile;
+exports.importThemesFromFiles = importThemesFromFiles;
+exports.listThemes = listThemes;
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _ThemeApi = require("../api/ThemeApi");
+
+var _Console = require("./utils/Console");
+
+var _ExportImportUtils = require("./utils/ExportImportUtils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
 /**
  * List all the themes
  * @param {boolean} long Long version, more fields
  */
-
-export async function listThemes(long = false) {
-  const themeList = await getThemes();
-  themeList.sort((a, b) => a.name.localeCompare(b.name));
-
-  if (!long) {
-    themeList.forEach(theme => {
-      printMessage(`${theme.isDefault ? theme.name.brightCyan : theme.name}`, 'data');
-    });
-  } else {
-    const table = createTable(['Name'['brightCyan'], 'Id'['brightCyan'], 'Default'['brightCyan']]);
-    themeList.forEach(theme => {
-      table.push([`${theme.name}`, `${theme._id}`, `${theme.isDefault ? 'Yes'['brightGreen'] : ''}`]);
-    });
-    printMessage(table.toString(), 'data');
-  }
+function listThemes() {
+  return _listThemes.apply(this, arguments);
 }
 /**
  * Export theme by name to file
@@ -29,24 +44,30 @@ export async function listThemes(long = false) {
  * @param {String} file optional export file name
  */
 
-export async function exportThemeByName(name, file) {
-  let fileName = getTypedFilename(name, 'theme');
 
-  if (file) {
-    fileName = file;
-  }
+function _listThemes() {
+  _listThemes = _asyncToGenerator(function* () {
+    var long = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+    var themeList = yield (0, _ThemeApi.getThemes)();
+    themeList.sort((a, b) => a.name.localeCompare(b.name));
 
-  createProgressIndicator(1, `Exporting ${name}`);
-  const themeData = await getThemeByName(name);
+    if (!long) {
+      themeList.forEach(theme => {
+        (0, _Console.printMessage)("".concat(theme.isDefault ? theme.name.brightCyan : theme.name), 'data');
+      });
+    } else {
+      var table = (0, _Console.createTable)(['Name'['brightCyan'], 'Id'['brightCyan'], 'Default'['brightCyan']]);
+      themeList.forEach(theme => {
+        table.push(["".concat(theme.name), "".concat(theme._id), "".concat(theme.isDefault ? 'Yes'['brightGreen'] : '')]);
+      });
+      (0, _Console.printMessage)(table.toString(), 'data');
+    }
+  });
+  return _listThemes.apply(this, arguments);
+}
 
-  if (themeData.length === 0) {
-    stopProgressIndicator(`Theme ${name} not found!`);
-    printMessage(`Theme ${name} not found!`, 'error');
-  } else {
-    updateProgressIndicator(`Writing file ${fileName}`);
-    saveToFile('theme', themeData, '_id', fileName);
-    stopProgressIndicator(`Successfully exported theme ${name}.`);
-  }
+function exportThemeByName(_x, _x2) {
+  return _exportThemeByName.apply(this, arguments);
 }
 /**
  * Export theme by uuid to file
@@ -54,62 +75,93 @@ export async function exportThemeByName(name, file) {
  * @param {String} file optional export file name
  */
 
-export async function exportThemeById(id, file) {
-  let fileName = getTypedFilename(id, 'theme');
 
-  if (file) {
-    fileName = file;
-  }
+function _exportThemeByName() {
+  _exportThemeByName = _asyncToGenerator(function* (name, file) {
+    var fileName = (0, _ExportImportUtils.getTypedFilename)(name, 'theme');
+
+    if (file) {
+      fileName = file;
+    }
 
-  createProgressIndicator(1, `Exporting ${id}`);
-  const themeData = await getTheme(id);
+    (0, _Console.createProgressIndicator)(1, "Exporting ".concat(name));
+    var themeData = yield (0, _ThemeApi.getThemeByName)(name);
 
-  if (themeData.length === 0) {
-    stopProgressIndicator(`Theme ${id} not found!`);
-    printMessage(`Theme ${id} not found!`, 'error');
-  } else {
-    updateProgressIndicator(`Writing file ${fileName}`);
-    saveToFile('theme', themeData, '_id', fileName);
-    stopProgressIndicator(`Successfully exported theme ${id}.`);
-  }
+    if (themeData.length === 0) {
+      (0, _Console.stopProgressIndicator)("Theme ".concat(name, " not found!"));
+      (0, _Console.printMessage)("Theme ".concat(name, " not found!"), 'error');
+    } else {
+      (0, _Console.updateProgressIndicator)("Writing file ".concat(fileName));
+      (0, _ExportImportUtils.saveToFile)('theme', themeData, '_id', fileName);
+      (0, _Console.stopProgressIndicator)("Successfully exported theme ".concat(name, "."));
+    }
+  });
+  return _exportThemeByName.apply(this, arguments);
+}
+
+function exportThemeById(_x3, _x4) {
+  return _exportThemeById.apply(this, arguments);
 }
 /**
  * Export all themes to file
  * @param {String} file optional export file name
  */
 
-export async function exportThemesToFile(file) {
-  let fileName = getTypedFilename(`all${getRealmString()}Themes`, 'theme');
 
-  if (file) {
-    fileName = file;
-  }
+function _exportThemeById() {
+  _exportThemeById = _asyncToGenerator(function* (id, file) {
+    var fileName = (0, _ExportImportUtils.getTypedFilename)(id, 'theme');
 
-  const allThemesData = await getThemes();
-  createProgressIndicator(allThemesData.length, 'Exporting themes');
+    if (file) {
+      fileName = file;
+    }
 
-  for (const themeData of allThemesData) {
-    updateProgressIndicator(`Exporting theme ${themeData.name}`);
-  }
+    (0, _Console.createProgressIndicator)(1, "Exporting ".concat(id));
+    var themeData = yield (0, _ThemeApi.getTheme)(id);
 
-  saveToFile('theme', allThemesData, '_id', fileName);
-  stopProgressIndicator(`${allThemesData.length} themes exported to ${fileName}.`);
+    if (themeData.length === 0) {
+      (0, _Console.stopProgressIndicator)("Theme ".concat(id, " not found!"));
+      (0, _Console.printMessage)("Theme ".concat(id, " not found!"), 'error');
+    } else {
+      (0, _Console.updateProgressIndicator)("Writing file ".concat(fileName));
+      (0, _ExportImportUtils.saveToFile)('theme', themeData, '_id', fileName);
+      (0, _Console.stopProgressIndicator)("Successfully exported theme ".concat(id, "."));
+    }
+  });
+  return _exportThemeById.apply(this, arguments);
+}
+
+function exportThemesToFile(_x5) {
+  return _exportThemesToFile.apply(this, arguments);
 }
 /**
  * Export all themes to separate files
  */
 
-export async function exportThemesToFiles() {
-  const allThemesData = await getThemes();
-  createProgressIndicator(allThemesData.length, 'Exporting themes');
 
-  for (const themeData of allThemesData) {
-    updateProgressIndicator(`Writing theme ${themeData.name}`);
-    const fileName = getTypedFilename(themeData.name, 'theme');
-    saveToFile('theme', themeData, '_id', fileName);
-  }
+function _exportThemesToFile() {
+  _exportThemesToFile = _asyncToGenerator(function* (file) {
+    var fileName = (0, _ExportImportUtils.getTypedFilename)("all".concat((0, _ExportImportUtils.getRealmString)(), "Themes"), 'theme');
+
+    if (file) {
+      fileName = file;
+    }
+
+    var allThemesData = yield (0, _ThemeApi.getThemes)();
+    (0, _Console.createProgressIndicator)(allThemesData.length, 'Exporting themes');
 
-  stopProgressIndicator(`${allThemesData.length} themes exported.`);
+    for (var themeData of allThemesData) {
+      (0, _Console.updateProgressIndicator)("Exporting theme ".concat(themeData.name));
+    }
+
+    (0, _ExportImportUtils.saveToFile)('theme', allThemesData, '_id', fileName);
+    (0, _Console.stopProgressIndicator)("".concat(allThemesData.length, " themes exported to ").concat(fileName, "."));
+  });
+  return _exportThemesToFile.apply(this, arguments);
+}
+
+function exportThemesToFiles() {
+  return _exportThemesToFiles.apply(this, arguments);
 }
 /**
  * Import theme by name from file
@@ -117,40 +169,25 @@ export async function exportThemesToFiles() {
  * @param {String} file import file name
  */
 
-export async function importThemeByName(name, file) {
-  fs.readFile(file, 'utf8', (err, data) => {
-    if (err) throw err;
-    const themeData = JSON.parse(data);
-
-    if (validateImport(themeData.meta)) {
-      createProgressIndicator(1, 'Importing theme...');
-      let found = false;
-
-      for (const id in themeData.theme) {
-        if ({}.hasOwnProperty.call(themeData.theme, id)) {
-          if (themeData.theme[id].name === name) {
-            found = true;
-            updateProgressIndicator(`Importing ${themeData.theme[id].name}`);
-            putThemeByName(name, themeData.theme[id]).then(result => {
-              if (result == null) {
-                stopProgressIndicator(`Error importing theme ${themeData.theme[id].name}`);
-                printMessage(`Error importing theme ${themeData.theme[id].name}`, 'error');
-              } else {
-                stopProgressIndicator(`Successfully imported theme ${name}.`);
-              }
-            });
-            break;
-          }
-        }
-      }
 
-      if (!found) {
-        stopProgressIndicator(`Theme ${name} not found!`);
-      }
-    } else {
-      printMessage('Import validation failed...', 'error');
+function _exportThemesToFiles() {
+  _exportThemesToFiles = _asyncToGenerator(function* () {
+    var allThemesData = yield (0, _ThemeApi.getThemes)();
+    (0, _Console.createProgressIndicator)(allThemesData.length, 'Exporting themes');
+
+    for (var themeData of allThemesData) {
+      (0, _Console.updateProgressIndicator)("Writing theme ".concat(themeData.name));
+      var fileName = (0, _ExportImportUtils.getTypedFilename)(themeData.name, 'theme');
+      (0, _ExportImportUtils.saveToFile)('theme', themeData, '_id', fileName);
     }
+
+    (0, _Console.stopProgressIndicator)("".concat(allThemesData.length, " themes exported."));
   });
+  return _exportThemesToFiles.apply(this, arguments);
+}
+
+function importThemeByName(_x6, _x7) {
+  return _importThemeByName.apply(this, arguments);
 }
 /**
  * Import theme by uuid from file
@@ -158,183 +195,298 @@ export async function importThemeByName(name, file) {
  * @param {String} file import file name
  */
 
-export async function importThemeById(id, file) {
-  fs.readFile(file, 'utf8', (err, data) => {
-    if (err) throw err;
-    const themeData = JSON.parse(data);
-
-    if (validateImport(themeData.meta)) {
-      createProgressIndicator(1, 'Importing theme...');
-      let found = false;
-
-      for (const themeId in themeData.theme) {
-        if ({}.hasOwnProperty.call(themeData.theme, themeId)) {
-          if (themeId === id) {
-            found = true;
-            updateProgressIndicator(`Importing ${themeData.theme[themeId]._id}`);
-            putTheme(themeId, themeData.theme[themeId]).then(result => {
-              if (result == null) {
-                stopProgressIndicator(`Error importing theme ${themeData.theme[themeId]._id}`);
-                printMessage(`Error importing theme ${themeData.theme[themeId]._id}`, 'error');
-              } else {
-                stopProgressIndicator(`Successfully imported theme ${id}.`);
-              }
-            });
-            break;
+
+function _importThemeByName() {
+  _importThemeByName = _asyncToGenerator(function* (name, file) {
+    _fs.default.readFile(file, 'utf8', (err, data) => {
+      if (err) throw err;
+      var themeData = JSON.parse(data);
+
+      if ((0, _ExportImportUtils.validateImport)(themeData.meta)) {
+        (0, _Console.createProgressIndicator)(1, 'Importing theme...');
+        var found = false;
+
+        var _loop = function _loop(id) {
+          if ({}.hasOwnProperty.call(themeData.theme, id)) {
+            if (themeData.theme[id].name === name) {
+              found = true;
+              (0, _Console.updateProgressIndicator)("Importing ".concat(themeData.theme[id].name));
+              (0, _ThemeApi.putThemeByName)(name, themeData.theme[id]).then(result => {
+                if (result == null) {
+                  (0, _Console.stopProgressIndicator)("Error importing theme ".concat(themeData.theme[id].name));
+                  (0, _Console.printMessage)("Error importing theme ".concat(themeData.theme[id].name), 'error');
+                } else {
+                  (0, _Console.stopProgressIndicator)("Successfully imported theme ".concat(name, "."));
+                }
+              });
+              return "break";
+            }
           }
+        };
+
+        for (var id in themeData.theme) {
+          var _ret = _loop(id);
+
+          if (_ret === "break") break;
         }
-      }
 
-      if (!found) {
-        stopProgressIndicator(`Theme ${id} not found!`);
+        if (!found) {
+          (0, _Console.stopProgressIndicator)("Theme ".concat(name, " not found!"));
+        }
+      } else {
+        (0, _Console.printMessage)('Import validation failed...', 'error');
       }
-    } else {
-      printMessage('Import validation failed...', 'error');
-    }
+    });
   });
+  return _importThemeByName.apply(this, arguments);
+}
+
+function importThemeById(_x8, _x9) {
+  return _importThemeById.apply(this, arguments);
 }
 /**
  * Import all themes from single file
  * @param {String} file import file name
  */
 
-export async function importThemesFromFile(file) {
-  fs.readFile(file, 'utf8', (err, data) => {
-    if (err) throw err;
-    const fileData = JSON.parse(data);
 
-    if (validateImport(fileData.meta)) {
-      createProgressIndicator(Object.keys(fileData.theme).length, 'Importing themes...');
+function _importThemeById() {
+  _importThemeById = _asyncToGenerator(function* (id, file) {
+    _fs.default.readFile(file, 'utf8', (err, data) => {
+      if (err) throw err;
+      var themeData = JSON.parse(data);
+
+      if ((0, _ExportImportUtils.validateImport)(themeData.meta)) {
+        (0, _Console.createProgressIndicator)(1, 'Importing theme...');
+        var found = false;
+
+        var _loop2 = function _loop2(themeId) {
+          if ({}.hasOwnProperty.call(themeData.theme, themeId)) {
+            if (themeId === id) {
+              found = true;
+              (0, _Console.updateProgressIndicator)("Importing ".concat(themeData.theme[themeId]._id));
+              (0, _ThemeApi.putTheme)(themeId, themeData.theme[themeId]).then(result => {
+                if (result == null) {
+                  (0, _Console.stopProgressIndicator)("Error importing theme ".concat(themeData.theme[themeId]._id));
+                  (0, _Console.printMessage)("Error importing theme ".concat(themeData.theme[themeId]._id), 'error');
+                } else {
+                  (0, _Console.stopProgressIndicator)("Successfully imported theme ".concat(id, "."));
+                }
+              });
+              return "break";
+            }
+          }
+        };
+
+        for (var themeId in themeData.theme) {
+          var _ret2 = _loop2(themeId);
 
-      for (const id in fileData.theme) {
-        if ({}.hasOwnProperty.call(fileData.theme, id)) {
-          updateProgressIndicator(`Importing ${fileData.theme[id].name}`);
+          if (_ret2 === "break") break;
         }
-      }
 
-      putThemes(fileData.theme).then(result => {
-        if (result == null) {
-          stopProgressIndicator(`Error importing ${Object.keys(fileData.theme).length} themes!`);
-          printMessage(`Error importing ${Object.keys(fileData.theme).length} themes from ${file}`, 'error');
-        } else {
-          stopProgressIndicator(`Successfully imported ${Object.keys(fileData.theme).length} themes.`);
+        if (!found) {
+          (0, _Console.stopProgressIndicator)("Theme ".concat(id, " not found!"));
         }
-      });
-    } else {
-      printMessage('Import validation failed...', 'error');
-    }
+      } else {
+        (0, _Console.printMessage)('Import validation failed...', 'error');
+      }
+    });
   });
+  return _importThemeById.apply(this, arguments);
+}
+
+function importThemesFromFile(_x10) {
+  return _importThemesFromFile.apply(this, arguments);
 }
 /**
  * Import themes from separate files
  */
 
-export async function importThemesFromFiles() {
-  const names = fs.readdirSync('.');
-  const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.theme.json'));
-  createProgressIndicator(jsonFiles.length, 'Importing themes...');
-  let fileData = null;
-  let count = 0;
-  let total = 0;
-  let files = 0;
 
-  for (const file of jsonFiles) {
-    const data = fs.readFileSync(file, 'utf8');
-    fileData = JSON.parse(data);
+function _importThemesFromFile() {
+  _importThemesFromFile = _asyncToGenerator(function* (file) {
+    _fs.default.readFile(file, 'utf8', (err, data) => {
+      if (err) throw err;
+      var fileData = JSON.parse(data);
 
-    if (validateImport(fileData.meta)) {
-      count = Object.keys(fileData.theme).length; // eslint-disable-next-line no-await-in-loop
+      if ((0, _ExportImportUtils.validateImport)(fileData.meta)) {
+        (0, _Console.createProgressIndicator)(Object.keys(fileData.theme).length, 'Importing themes...');
 
-      const result = await putThemes(fileData.theme);
+        for (var id in fileData.theme) {
+          if ({}.hasOwnProperty.call(fileData.theme, id)) {
+            (0, _Console.updateProgressIndicator)("Importing ".concat(fileData.theme[id].name));
+          }
+        }
 
-      if (result == null) {
-        printMessage(`Error importing ${count} themes from ${file}`, 'error');
+        (0, _ThemeApi.putThemes)(fileData.theme).then(result => {
+          if (result == null) {
+            (0, _Console.stopProgressIndicator)("Error importing ".concat(Object.keys(fileData.theme).length, " themes!"));
+            (0, _Console.printMessage)("Error importing ".concat(Object.keys(fileData.theme).length, " themes from ").concat(file), 'error');
+          } else {
+            (0, _Console.stopProgressIndicator)("Successfully imported ".concat(Object.keys(fileData.theme).length, " themes."));
+          }
+        });
       } else {
-        files += 1;
-        total += count;
-        updateProgressIndicator(`Imported ${count} theme(s) from ${file}`);
+        (0, _Console.printMessage)('Import validation failed...', 'error');
       }
-    } else {
-      printMessage(`Validation of ${file} failed!`, 'error');
-    }
-  }
+    });
+  });
+  return _importThemesFromFile.apply(this, arguments);
+}
 
-  stopProgressIndicator(`Finished importing ${total} theme(s) from ${files} file(s).`);
+function importThemesFromFiles() {
+  return _importThemesFromFiles.apply(this, arguments);
 }
 /**
  * Import first theme from file
  * @param {String} file import file name
  */
 
-export async function importFirstThemeFromFile(file) {
-  fs.readFile(file, 'utf8', (err, data) => {
-    if (err) throw err;
-    const themeData = JSON.parse(data);
-
-    if (validateImport(themeData.meta)) {
-      createProgressIndicator(1, 'Importing theme...');
-
-      for (const id in themeData.theme) {
-        if ({}.hasOwnProperty.call(themeData.theme, id)) {
-          updateProgressIndicator(`Importing ${themeData.theme[id].name}`);
-          putTheme(id, themeData.theme[id]).then(result => {
-            if (result == null) {
-              stopProgressIndicator(`Error importing theme ${themeData.theme[id].name}`);
-              printMessage(`Error importing theme ${themeData.theme[id].name}`, 'error');
-            } else {
-              stopProgressIndicator(`Successfully imported theme ${themeData.theme[id].name}`);
-            }
-          });
-          break;
+
+function _importThemesFromFiles() {
+  _importThemesFromFiles = _asyncToGenerator(function* () {
+    var names = _fs.default.readdirSync('.');
+
+    var jsonFiles = names.filter(name => name.toLowerCase().endsWith('.theme.json'));
+    (0, _Console.createProgressIndicator)(jsonFiles.length, 'Importing themes...');
+    var fileData = null;
+    var count = 0;
+    var total = 0;
+    var files = 0;
+
+    for (var file of jsonFiles) {
+      var data = _fs.default.readFileSync(file, 'utf8');
+
+      fileData = JSON.parse(data);
+
+      if ((0, _ExportImportUtils.validateImport)(fileData.meta)) {
+        count = Object.keys(fileData.theme).length; // eslint-disable-next-line no-await-in-loop
+
+        var result = yield (0, _ThemeApi.putThemes)(fileData.theme);
+
+        if (result == null) {
+          (0, _Console.printMessage)("Error importing ".concat(count, " themes from ").concat(file), 'error');
+        } else {
+          files += 1;
+          total += count;
+          (0, _Console.updateProgressIndicator)("Imported ".concat(count, " theme(s) from ").concat(file));
         }
+      } else {
+        (0, _Console.printMessage)("Validation of ".concat(file, " failed!"), 'error');
       }
-    } else {
-      printMessage('Import validation failed...', 'error');
     }
+
+    (0, _Console.stopProgressIndicator)("Finished importing ".concat(total, " theme(s) from ").concat(files, " file(s)."));
   });
+  return _importThemesFromFiles.apply(this, arguments);
+}
+
+function importFirstThemeFromFile(_x11) {
+  return _importFirstThemeFromFile.apply(this, arguments);
 }
 /**
  * Delete theme by id
  * @param {String} id theme id
  */
 
-export async function deleteThemeCmd(id) {
-  createProgressIndicator(undefined, `Deleting ${id}...`, 'indeterminate');
 
-  try {
-    await deleteTheme(id);
-    stopProgressIndicator(`Deleted ${id}.`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.message}`, 'fail');
-  }
+function _importFirstThemeFromFile() {
+  _importFirstThemeFromFile = _asyncToGenerator(function* (file) {
+    _fs.default.readFile(file, 'utf8', (err, data) => {
+      if (err) throw err;
+      var themeData = JSON.parse(data);
+
+      if ((0, _ExportImportUtils.validateImport)(themeData.meta)) {
+        (0, _Console.createProgressIndicator)(1, 'Importing theme...');
+
+        var _loop3 = function _loop3(id) {
+          if ({}.hasOwnProperty.call(themeData.theme, id)) {
+            (0, _Console.updateProgressIndicator)("Importing ".concat(themeData.theme[id].name));
+            (0, _ThemeApi.putTheme)(id, themeData.theme[id]).then(result => {
+              if (result == null) {
+                (0, _Console.stopProgressIndicator)("Error importing theme ".concat(themeData.theme[id].name));
+                (0, _Console.printMessage)("Error importing theme ".concat(themeData.theme[id].name), 'error');
+              } else {
+                (0, _Console.stopProgressIndicator)("Successfully imported theme ".concat(themeData.theme[id].name));
+              }
+            });
+            return "break";
+          }
+        };
+
+        for (var id in themeData.theme) {
+          var _ret3 = _loop3(id);
+
+          if (_ret3 === "break") break;
+        }
+      } else {
+        (0, _Console.printMessage)('Import validation failed...', 'error');
+      }
+    });
+  });
+  return _importFirstThemeFromFile.apply(this, arguments);
+}
+
+function deleteThemeCmd(_x12) {
+  return _deleteThemeCmd.apply(this, arguments);
 }
 /**
  * Delete theme by name
  * @param {String} name theme name
  */
 
-export async function deleteThemeByNameCmd(name) {
-  createProgressIndicator(undefined, `Deleting ${name}...`, 'indeterminate');
 
-  try {
-    await deleteThemeByName(name);
-    stopProgressIndicator(`Deleted ${name}.`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.message}`, 'fail');
-  }
+function _deleteThemeCmd() {
+  _deleteThemeCmd = _asyncToGenerator(function* (id) {
+    (0, _Console.createProgressIndicator)(undefined, "Deleting ".concat(id, "..."), 'indeterminate');
+
+    try {
+      yield (0, _ThemeApi.deleteTheme)(id);
+      (0, _Console.stopProgressIndicator)("Deleted ".concat(id, "."), 'success');
+    } catch (error) {
+      (0, _Console.stopProgressIndicator)("Error: ".concat(error.message), 'fail');
+    }
+  });
+  return _deleteThemeCmd.apply(this, arguments);
+}
+
+function deleteThemeByNameCmd(_x13) {
+  return _deleteThemeByNameCmd.apply(this, arguments);
 }
 /**
  * Delete all themes
  */
 
-export async function deleteThemesCmd() {
-  createProgressIndicator(undefined, `Deleting all realm themes...`, 'indeterminate');
 
-  try {
-    await deleteThemes();
-    stopProgressIndicator(`Deleted all realm themes.`, 'success');
-  } catch (error) {
-    stopProgressIndicator(`Error: ${error.message}`, 'fail');
-  }
+function _deleteThemeByNameCmd() {
+  _deleteThemeByNameCmd = _asyncToGenerator(function* (name) {
+    (0, _Console.createProgressIndicator)(undefined, "Deleting ".concat(name, "..."), 'indeterminate');
+
+    try {
+      yield (0, _ThemeApi.deleteThemeByName)(name);
+      (0, _Console.stopProgressIndicator)("Deleted ".concat(name, "."), 'success');
+    } catch (error) {
+      (0, _Console.stopProgressIndicator)("Error: ".concat(error.message), 'fail');
+    }
+  });
+  return _deleteThemeByNameCmd.apply(this, arguments);
+}
+
+function deleteThemesCmd() {
+  return _deleteThemesCmd.apply(this, arguments);
+}
+
+function _deleteThemesCmd() {
+  _deleteThemesCmd = _asyncToGenerator(function* () {
+    (0, _Console.createProgressIndicator)(undefined, "Deleting all realm themes...", 'indeterminate');
+
+    try {
+      yield (0, _ThemeApi.deleteThemes)();
+      (0, _Console.stopProgressIndicator)("Deleted all realm themes.", 'success');
+    } catch (error) {
+      (0, _Console.stopProgressIndicator)("Error: ".concat(error.message), 'fail');
+    }
+  });
+  return _deleteThemesCmd.apply(this, arguments);
 }
 //# sourceMappingURL=ThemeOps.js.map