bjira 0.0.16 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bjira",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "description": "A simple jira CLI tool",
   "main": "src/index.js",
   "author": {

package/src/create.js

@@ -33,8 +33,8 @@ class Create extends Command {
             }
           })));
 
-        const meta = await jira.spin('Retrieving issue metadata...',
-          jira.apiRequest(`/issue/createmeta?projectKeys=${project.key}&issuetypeNames=${issueType.name}&expand=projects.issuetypes.fields`));
+        const meta = await Project.metadata(jira, project.key, issueType.name);
+
         const newIssue = {
           fields: {
             project: {
@@ -58,11 +58,12 @@ class Create extends Command {
           .issuetypes.find(i => i.name === issueType.name).fields;
         const requiredFields = Object.keys(issueFields).filter(
           key => issueFields[key].required &&
-          Field.isSupported(issueFields[key].schema.type) &&
-          !["summary", "description", "project"].includes(key)).map(key => issueFields[key]);
+          Field.isSupported(issueFields[key]) &&
+          !["issuetype", "summary", "description", "project"].includes(key)).map(key => issueFields[key]);
 
         for (const field of requiredFields) {
-          newIssue.fields[field.key] = await Ask.askString(`${field.name}:`);
+          const fieldData = await Field.askFieldIfSupported(field);
+          newIssue.fields[fieldData.key] = fieldData.value;
         }
 
         if (issueType.name !== 'Epic' &&
@@ -100,10 +101,12 @@ class Create extends Command {
           await Set.setStatus(jira, issue.key);
         }
 
-        if (jira.fields && jira.fields.length > 0 &&
-          await Ask.askBoolean('Do you want to set custom fields?')) {
-          for (let fieldName of jira.fields) {
-            await Set.setCustomField(jira, fieldName, issue.key);
+        const customFields = jira.fields.filter(
+          field => field.projectName === project.key &&
+          field.issueTypeName === issueType.name);
+        if (customFields.length > 0 && await Ask.askBoolean('Do you want to set custom fields?')) {
+          for (let customField of customFields) {
+            await Set.setCustomField(jira, customField, issue.key);
           }
         }
 

package/src/errorhandler.js

@@ -20,6 +20,11 @@ class ErrorHandler {
         color: "blue",
         text: error
       }]));
+    } else if ("message" in e.error) {
+      table.addRow([{
+        color: "blue",
+        text: e.error.message
+      }]);
     } else {
       table.addRow([{
         color: "blue",

package/src/field.js

@@ -2,9 +2,12 @@
 //
 // SPDX-License-Identifier: MIT
 
+import color from 'chalk';
+
 import Ask from './ask.js';
 import Command from './command.js';
 import Jira from './jira.js';
+import Project from './project.js';
 import Table from './table.js';
 
 class Field extends Command {
@@ -16,59 +19,76 @@ class Field extends Command {
       .action(async () => {
         const jira = new Jira(program);
 
-        const resultFields = await Field.listFields(jira);
-
-        const table = new Table({
-          head: ['Name', 'Supported', 'Type']
-        });
-
-        resultFields.forEach(field => {
-          const supported = Field.isSupported(field.schema?.type);
-          table.addRow([{
-            color: "blue",
-            text: field.name
-          }, supported, supported ? field.schema?.type : ""]);
+        const resultFields = await jira.spin('Retrieving the fields...',
+          jira.apiRequest('/issue/createmeta?expand=projects.issuetypes.fields'));
+
+        resultFields.projects.forEach(project => {
+          console.log(`\nProject: ${color.blue(project.name)} (${color.blue(project.key)})`);
+          project.issuetypes.forEach(issueType => {
+            console.log(`\nIssue type: ${color.yellow(issueType.name)}`);
+
+            const table = new Table({
+              head: ['Name', 'Supported', 'Type']
+            });
+
+            for (const fieldName in issueType.fields) {
+              const field = issueType.fields[fieldName];
+              const supported = Field.isSupported(field);
+              table.addRow([{
+                color: "blue",
+                text: field.name
+              }, supported, supported ? field.schema?.type : ""]);
+            }
+
+            console.log(table.toString());
+          });
         });
-        console.log(table.toString());
       });
 
     cmd.command("add")
       .description("Add a custom field to be shown")
+      .argument('<project>', 'The project name')
+      .argument('<issueType>', 'The issue type')
       .argument('<field>', 'The field name')
-      .action(async fieldName => {
+      .action(async (projectName, issueTypeName, fieldName) => {
         const jira = new Jira(program);
 
-        const resultFields = await Field.listFields(jira);
-
-        const fieldData = resultFields.find(field => field.name === fieldName);
-        if (!fieldData) {
-          console.log("Unknown field.");
+        const meta = await Project.metadata(jira, projectName, issueTypeName);
+        const issueType = meta.projects.find(p => p.key === projectName)
+          .issuetypes.find(i => i.name === issueTypeName);
+        if (!issueType) {
+          console.log(`Issue type ${issueTypeName} does not exist.`);
           return;
         }
 
-        if (!Field.isSupported(fieldData.schema?.type)) {
-          console.log("Unsupported field.");
+        for (const name in issueType.fields) {
+          const field = issueType.fields[name];
+          if (field.name !== fieldName) continue;
+
+          if (!Field.isSupported(field)) {
+            console.log("Unsupported field.");
+            return;
+          }
+
+          jira.addField(projectName, issueTypeName, fieldName);
+          jira.syncConfig();
+
+          console.log('Config file succesfully updated');
           return;
         }
 
-        jira.addField(fieldName);
-        jira.syncConfig();
-
-        console.log('Config file succesfully updated');
+        console.log(`Field ${fieldName} does not exist in Issue type ${issueTypeName} for project ${projectName}`);
       });
 
     cmd.command("remove")
       .description("Remove a custom field")
+      .argument('<project>', 'The project name')
+      .argument('<issueType>', 'The issue type')
       .argument('<field>', 'The field name')
-      .action(async fieldName => {
+      .action(async (projectName, issueTypeName, fieldName) => {
         const jira = new Jira(program);
 
-        if (!jira.fields.includes(fieldName)) {
-          console.log("Unknown field.");
-          return;
-        }
-
-        jira.removeField(fieldName);
+        jira.removeField(projectName, issueTypeName, fieldName);
         jira.syncConfig();
 
         console.log('Config file succesfully updated');
@@ -80,12 +100,17 @@ class Field extends Command {
         const jira = new Jira(program);
 
         const table = new Table({
-          head: ['Name']
+          head: ['Project', 'Issue Type', 'Name']
         });
 
-        jira.fields.forEach(fieldName => table.addRow([{
+        jira.fields.forEach(field => table.addRow([{
           color: "blue",
-          text: fieldName
+          text: field.projectName,
+        }, {
+          color: "yellow",
+          text: field.issueTypeName
+        }, {
+          text: field.fieldName
         }]));
         console.log(table.toString());
       });
@@ -95,24 +120,51 @@ class Field extends Command {
     return await jira.spin('Retrieving the fields...', jira.api.listFields());
   }
 
-  static isSupported(fieldType) {
-    return ["string", "number"].includes(fieldType);
-  }
+  static isSupported(fieldData) {
+    if (["string", "number"].includes(fieldData.schema?.type)) {
+      return true;
+    }
 
-  static async askFieldIfSupported(jira, fieldName) {
-    const resultFields = await Field.listFields(jira);
+    if ("allowedValues" in fieldData) {
+      return true;
+    }
 
-    let fieldData;
-    resultFields.forEach(field => {
-      if (field.name === fieldName) fieldData = field;
-    });
+    return false;
+  }
 
-    if (!fieldData) {
-      console.log(`Unable to find the field "${fieldName}"`);
+  static fieldValue(field, fieldData) {
+    if (!Field.isSupported(fieldData)) {
       return null;
     }
 
-    if (!Field.isSupported(fieldData.schema?.type)) {
+    let type;
+    switch (fieldData.schema.type) {
+      case 'number':
+        return field;
+      case 'string':
+        return field;
+    }
+
+    return field.name;
+  }
+
+  static async fetchAndAskFieldIfSupported(jira, field) {
+    const meta = await Project.metadata(jira, field.projectName, field.issueTypeName);
+    const fields = meta.projects.find(p => p.key === field.projectName)
+      .issuetypes.find(i => i.name === field.issueTypeName).fields;
+
+    for (const name in fields) {
+      const fieldObj = fields[name];
+      if (fieldObj.name === field.fieldName) {
+        return Field.askFieldIfSupported(fieldObj);
+      }
+    }
+
+    return null;
+  }
+
+  static async askFieldIfSupported(fieldData) {
+    if (!Field.isSupported(fieldData)) {
       console.log("Unsupported field");
       return null;
     }
@@ -121,15 +173,24 @@ class Field extends Command {
     switch (fieldData.schema.type) {
       case 'number':
         return {
-          value: await Ask.askNumber(`${fieldName}:`), key: fieldData.key
+          value: await Ask.askNumber(`${fieldData.name}:`), key: fieldData.key
         };
       case 'string':
         return {
-          value: await Ask.askString(`${fieldName}:`), key: fieldData.key
+          value: await Ask.askString(`${fieldData.name}:`), key: fieldData.key
         };
     }
 
-    return null;
+    return {
+      key: fieldData.key,
+      value: await Ask.askList(`${fieldData.name}:`,
+        fieldData.allowedValues.map(value => ({
+          name: value.name,
+          value: {
+            id: value.id
+          }
+        })))
+    };
   }
 };
 

package/src/issue.js

@@ -5,6 +5,8 @@
 import Command from './command.js';
 import Field from './field.js';
 import Jira from './jira.js';
+import Project from './project.js';
+import Query from './query.js';
 import Table from './table.js';
 
 const DEFAULT_QUERY_LIMIT = 20;
@@ -18,6 +20,7 @@ class Issue extends Command {
     const cmd = program.command('show')
       .description('Show an issue')
       .option('-C, --comments', 'Show the comments too')
+      .option('-s, --subissues', 'Show the comments too')
       .argument('<id>', 'The issue ID')
       .action(async id => {
         const jira = new Jira(program);
@@ -64,9 +67,6 @@ class Issue extends Command {
           [
             'Assignee', Issue.showUser(issue.fields['Assignee'])
           ],
-          [
-            'Priority', issue.fields['Priority'].name
-          ],
           [
             'Epic Link', {
               color: "yellow",
@@ -84,7 +84,22 @@ class Issue extends Command {
           ]
         ]);
 
-        jira.fields.forEach(fieldName => table.addRow([fieldName, issue.fields[fieldName] || "unset"]));
+        const customFields = jira.fields.filter(
+          field => field.projectName === issue.fields['Project'].key &&
+          field.issueTypeName === issue.fields['Issue Type'].name);
+        if (customFields.length > 0) {
+          const meta = await Project.metadata(jira, issue.fields['Project'].key, issue.fields['Issue Type'].name);
+          customFields.forEach(field => {
+            const fields = meta.projects.find(p => p.key === field.projectName)
+              .issuetypes.find(i => i.name === field.issueTypeName).fields;
+            for (const name in fields) {
+              const fieldObj = fields[name];
+              if (fieldObj.name === field.fieldName) {
+                table.addRow([field.fieldName, Field.fieldValue(issue.fields[field.fieldName], fieldObj) || "unset"]);
+              }
+            }
+          });
+        }
 
         table.addRows([
           [
@@ -139,6 +154,19 @@ class Issue extends Command {
         }
 
         console.log(table.toString());
+
+        if (cmd.opts().subissues) {
+          console.log("\nSub-issues:");
+          const children = await Query.runQuery(jira, `parent = "${id}"`, 999999);
+          await Query.showIssues(jira, children.issues, children.total, resultFields, false);
+
+          if (issue.fields['Issue Type'].name === 'Epic') {
+            console.log("\nEpic issues:");
+            const children = await jira.spin('Fetching child issues...', jira.api.getIssuesForEpic(id));
+            await Query.showIssues(jira, children.issues, children.total, resultFields, false);
+          }
+        }
+
       });
   }
 

package/src/jira.js

@@ -31,16 +31,27 @@ class Jira {
     this._config.latestProject = latestProject;
   }
 
-  addField(fieldName) {
+  addField(projectName, issueTypeName, fieldName) {
     if (!Array.isArray(this._config.fields)) this._config.fields = [];
 
-    this._config.fields.push(fieldName);
+    if (!this._config.fields.find(field => field.projectName === projectName &&
+        field.issueTypeName === issueTypeName && field.fieldName === fieldName)) {
+      this._config.fields.push({
+        projectName,
+        issueTypeName,
+        fieldName
+      });
+    }
   }
 
-  removeField(fieldName) {
-    if (!Array.isArray(this._config.fields) || this._config.fields.indexOf(fieldName) === -1) return;
+  removeField(projectName, issueTypeName, fieldName) {
+    if (!Array.isArray(this._config.fields)) return;
 
-    this._config.fields.splice(this._config.fields.indexOf(fieldName), 1);
+    const pos = this._config.fields.findIndex(field => field.projectName === projectName &&
+      field.issueTypeName === issueTypeName && field.fieldName === fieldName);
+    if (pos !== -1) {
+      this._config.fields.splice(pos, 1);
+    }
   }
 
   get fields() {

package/src/project.js

@@ -73,6 +73,11 @@ class Project extends Command {
       issueTypes: project.issuetypes,
     };
   }
+
+  static async metadata(jira, project, issueType) {
+    return await jira.spin('Retrieving the fields...',
+      jira.apiRequest(`/issue/createmeta?projectKeys=${project}&issuetypeNames=${issueType}&expand=projects.issuetypes.fields`));
+  }
 };
 
 export default Project;

package/src/query.js

@@ -21,6 +21,7 @@ class Query extends Command {
       .option('-l, --limit <limit>',
         `Set the query limit. Default ${DEFAULT_QUERY_LIMIT}`,
         DEFAULT_QUERY_LIMIT)
+      .option('-g, --grouped', 'Group the issues by parenting')
       .action(async query => {
         const jira = new Jira(program);
         const opts = cmd.opts();
@@ -28,32 +29,120 @@ class Query extends Command {
         const resultFields = await Field.listFields(jira);
         const result = await Query.runQuery(jira, query, opts.limit);
 
-        Query.showIssues(jira, result.issues, result.total, resultFields);
+        await Query.showIssues(jira, result.issues, result.total, resultFields, opts.grouped);
       });
   }
 
-  static showIssues(jira, issues, total, fields) {
+  static async showIssues(jira, issues, total, fields, grouped) {
     console.log(`Showing ${color.bold(issues.length)} issues of ${color.bold(total)}`);
 
+    issues = issues.map(issue => Issue.replaceFields(issue, fields)).map(issue => ({
+      children: [],
+      issue
+    }));
+
+    const addIssueInTree = (issues, issue, parentId) => {
+      for (const existingIssue of issues) {
+        if (existingIssue.issue.key == parentId) {
+          existingIssue.children.push(issue);
+          return true;
+        }
+
+        if (addIssueInTree(existingIssue.children, issue, parentId)) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    const computeIssueInTree = async (issues, newIssues, issue) => {
+      // Top level.
+      if (!issue.issue.fields['Epic Link'] && !issue.issue.fields['Parent']) {
+        newIssues.push(issue);
+        return;
+      }
+
+      const parentId = issue.issue.fields['Epic Link'] || issue.issue.fields['Parent'].key;
+
+      // In the already processed issues
+      if (addIssueInTree(newIssues, issue, parentId)) {
+        return;
+      }
+
+      // In the non-already processed issues
+      if (addIssueInTree(issues, issue, parentId)) {
+        return;
+      }
+
+      const parentIssueResult = await jira.spin('Running query...', jira.api.findIssue(parentId));
+      const parentIssue = Issue.replaceFields(parentIssueResult, fields);
+
+      const parentIssueData = {
+        children: [issue],
+        incompleted: true,
+        issue: parentIssue
+      };
+
+      await computeIssueInTree(issues, newIssues, parentIssueData);
+    };
+
+    if (grouped) {
+      const newIssues = [];
+      for (; issues.length; issues = issues.splice(1)) {
+        await computeIssueInTree(issues, newIssues, issues[0]);
+      }
+      issues = newIssues;
+    }
+
     const table = new Table({
-      head: ['Key', 'Status', 'Type', 'Assignee', 'Summary']
+      head: ['Key', 'Status', 'Type', 'Assignee', 'Summary'],
+      unresizableColumns: [0],
     });
 
-    issues.forEach(issue => table.addRow([{
+    const showIssue = (table, issue, nested) => {
+      let pre = "";
+      if (nested.length) {
+        pre += " ";
+        for (let i = 0; i < nested.length - 1; ++i) {
+          pre += (nested[i]) ? '│   ' : '    ';
+        }
+        pre += (nested[nested.length - 1]) ? "├─ " : "└─ ";
+      }
+
+      table.addRow([{
         color: "blue",
-        text: issue.key
+        style: issue.incompleted ? "italic" : "normal",
+        text: pre + issue.issue.key
       }, {
         color: "green",
-        text: issue.fields.status.name
+        style: issue.incompleted ? "italic" : "normal",
+        text: issue.issue.fields['Status'].name
       }, {
         color: "green",
-        text: issue.fields.issuetype.name
+        style: issue.incompleted ? "italic" : "normal",
+        text: issue.issue.fields['Issue Type'].name
       }, {
         color: "yellow",
-        text: Issue.showUser(issue.fields.assignee)
-      },
-      issue.fields.summary
-    ]))
+        style: issue.incompleted ? "italic" : "normal",
+        text: Issue.showUser(issue.issue.fields['Assignee'])
+      }, {
+        style: issue.incompleted ? "italic" : "normal",
+        text: issue.issue.fields['Summary']
+      }]);
+
+      if (issue.children.length) {
+        const newNested = [];
+        nested.forEach(n => newNested.push(n));
+        newNested.push(false);
+        issue.children.forEach((subissue, pos) => {
+          newNested[nested.length] = (pos < issue.children.length - 1);
+          showIssue(table, subissue, newNested);
+        });
+      }
+    };
+
+    issues.forEach(issue => showIssue(table, issue, []));
 
     console.log(table.toString());
   }

package/src/run.js

@@ -19,6 +19,7 @@ class Run extends Command {
       .option('-l, --limit <limit>',
         `Set the query limit. Default ${DEFAULT_QUERY_LIMIT}`,
         DEFAULT_QUERY_LIMIT)
+      .option('-g, --grouped', 'Group the issues by parenting')
       .action(async name => {
         const jira = new Jira(program);
         const opts = cmd.opts();
@@ -46,7 +47,7 @@ class Run extends Command {
         const resultFields = await Field.listFields(jira);
         const result = await Query.runQuery(jira, query, opts.limit);
 
-        Query.showIssues(jira, result.issues, result.total, resultFields);
+        await Query.showIssues(jira, result.issues, result.total, resultFields, opts.grouped);
       });
   }
 

package/src/set.js

@@ -5,6 +5,7 @@
 import Ask from './ask.js';
 import Command from './command.js';
 import Field from './field.js';
+import Issue from './issue.js';
 import Jira from './jira.js';
 import User from './user.js';
 
@@ -14,7 +15,7 @@ class Set extends Command {
       .description('Update fields in an issue');
     setCmd.command('assignee')
       .description('Assign the issue to somebody')
-      .argument('<id>', 'The issue ID')
+      .argument('<ID>', 'The issue ID')
       .action(async id => {
         const jira = new Jira(program);
         await Set.assignIssue(jira, id);
@@ -22,7 +23,7 @@ class Set extends Command {
 
     setCmd.command('unassign')
       .description('Unassign the issue')
-      .argument('<id>', 'The issue ID')
+      .argument('<ID>', 'The issue ID')
       .action(async id => {
         const jira = new Jira(program);
 
@@ -34,12 +35,12 @@ class Set extends Command {
           }
         }
 
-        await jira.spin('Updating the issue...', jira.api.updateIssue(id, issue));
+        await jira.spin(`Updating issue ${id}...`, jira.api.updateIssue(id, issue));
       });
 
     setCmd.command('status')
       .description('Change the status')
-      .argument('<id>', 'The issue ID')
+      .argument('<ID>', 'The issue ID')
       .action(async id => {
         const jira = new Jira(program);
         await Set.setStatus(jira, id);
@@ -51,7 +52,21 @@ class Set extends Command {
       .argument('<id>', 'The issue ID')
       .action(async (fieldName, id) => {
         const jira = new Jira(program);
-        await Set.setCustomField(jira, fieldName, id);
+
+        const resultFields = await Field.listFields(jira);
+        const result = await jira.spin('Running query...', jira.api.findIssue(id));
+        const issue = Issue.replaceFields(result, resultFields);
+
+        const customField = jira.fields.find(
+          field => field.projectName === issue.fields['Project'].key &&
+          field.issueTypeName === issue.fields['Issue Type'].name &&
+          field.fieldName === fieldName);
+        if (!customField) {
+          console.log("Unknown custom field");
+          return;
+        }
+
+        await Set.setCustomField(jira, customField, id);
       });
   }
 
@@ -72,12 +87,12 @@ class Set extends Command {
       }
     }
 
-    await jira.spin('Updating the issue...', jira.api.updateIssue(id, issue));
+    await jira.spin(`Updating issue ${id}...`, jira.api.updateIssue(id, issue));
   }
 
-  static async setCustomField(jira, fieldName, id) {
-    const field = await Field.askFieldIfSupported(jira, fieldName);
-    if (!field) {
+  static async setCustomField(jira, customField, id) {
+    const field = await Field.fetchAndAskFieldIfSupported(jira, customField);
+    if (field === null) {
       console.log("Unsupported field type");
       return;
     }
@@ -85,7 +100,7 @@ class Set extends Command {
     const data = {};
     data[field.key] = field.value;
 
-    await jira.spin('Updating the issue...', jira.api.updateIssue(id, {
+    await jira.spin(`Updating issue ${id}...`, jira.api.updateIssue(id, {
       fields: {
         ...data
       }
@@ -94,18 +109,33 @@ class Set extends Command {
 
   static async setStatus(jira, id) {
     const transitionList = await jira.spin('Retrieving transitions...', jira.api.listTransitions(id));
-    const transitionId = await Ask.askList('Status:',
-      transitionList.transitions.map(transition => ({
+    const transitionData = await Ask.askList('Status:',
+      transitionList.transitions.filter(transition => transition.isAvailable).map(transition => ({
         name: transition.name,
-        value: transition.id
+        value: transition
       })));
+
     const transition = {
       transition: {
-        id: transitionId
+        id: transitionData.id
       }
     };
 
-    await jira.spin('Updating the issue...', jira.api.transitionIssue(id, transition));
+    for (const field of Object.keys(transitionData.fields)) {
+      const fieldData = transitionData.fields[field];
+
+      if (!fieldData.required) continue;
+
+      if (!Field.isSupported(fieldData)) {
+        console.log(`Field ${field} is required but it's not supported`);
+        return;
+      }
+
+      const fieldValue = await Field.askFieldIfSupported(fieldData);
+      transition.transition[fieldValue.key] = fieldValue.value;
+    }
+
+    await jira.spin(`Updating issue ${id}...`, jira.api.transitionIssue(id, transition));
   }
 };
 

package/src/table.js

@@ -12,6 +12,8 @@ class Table {
     options.head?.forEach(head => {
       this._columns.push(this._createColumn(head, 0));
     });
+
+    this._unresizableColumns = options.unresizableColumns || [];
   }
 
   addRow(row) {
@@ -58,7 +60,7 @@ class Table {
       const rowHeight = Math.max(...this._columns.map(column => this._computeRowHeight(column, row)));
 
       for (let i = 0; i < rowHeight; ++i) {
-        lines.push(this._columns.map(column => this._colorize(column.rows[row], this._toWidth(this._computeLine(column.rows[row], i), column.width))).join(" "));
+        lines.push(this._columns.map(column => this._stylize(column.rows[row], this._toWidth(this._computeLine(column.rows[row], i), column.width))).join(" "));
       }
     }
 
@@ -118,7 +120,7 @@ class Table {
   }
 
   _maybeSplitRow(row, width) {
-    if (row.length < width) return [row];
+    if (row.length <= width) return [row];
 
     const rows = [];
     let currentRow = "";
@@ -142,8 +144,9 @@ class Table {
 
   _resizeWidthOfOne() {
     const max = Math.max(...this._columns.map(column => column.width));
-    for (let column of this._columns) {
-      if (column.width === max) {
+    for (let columnId in this._columns) {
+      const column = this._columns[columnId];
+      if (!this._unresizableColumns.includes(columnId) && column.width === max) {
         --column.width;
         break;
       }
@@ -154,6 +157,14 @@ class Table {
     return str.slice(0, width);
   }
 
+  _stylize(row, text) {
+    if (!("style" in row) || row.style === "normal") {
+      return this._colorize(row, text);
+    }
+
+    return color[row.style].apply(null, [this._colorize(row, text)]);
+  }
+
   _colorize(row, text) {
     if (!("color" in row)) {
       return text;