canvaslms-cli 1.6.2 → 1.6.4

package/dist/lib/display.js

@@ -1,53 +1,60 @@
-import chalk from 'chalk';
-import { makeCanvasRequest } from './api-client.js';
-import { createReadlineInterface, askQuestion } from './interactive.js';
-export function pad(str, len, align = 'left') {
+import chalk from "chalk";
+import { makeCanvasRequest } from "./api-client.js";
+import { createReadlineInterface, askQuestion } from "./interactive.js";
+export function pad(str, len, align = "left") {
     const strLen = stripAnsi(str).length;
     const padding = Math.max(0, len - strLen);
-    if (align === 'right') {
-        return ' '.repeat(padding) + str;
+    if (align === "right") {
+        return " ".repeat(padding) + str;
     }
-    else if (align === 'center') {
+    else if (align === "center") {
         const leftPad = Math.floor(padding / 2);
         const rightPad = padding - leftPad;
-        return ' '.repeat(leftPad) + str + ' '.repeat(rightPad);
+        return " ".repeat(leftPad) + str + " ".repeat(rightPad);
     }
-    return str + ' '.repeat(padding);
+    return str + " ".repeat(padding);
 }
 function stripAnsi(str) {
-    return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
+    return str.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
 }
 export function truncate(str, maxLen) {
-    if (str.length <= maxLen)
+    const visible = stripAnsi(str);
+    if (visible.length <= maxLen)
         return str;
-    return str.substring(0, maxLen - 3) + '...';
+    if (maxLen <= 3)
+        return visible.substring(0, maxLen);
+    const truncatedVisible = visible.substring(0, Math.max(0, maxLen - 3)) + "...";
+    return truncatedVisible;
 }
 function calculateColumnWidths(columns, data, terminalWidth, showRowNumbers) {
-    const borderOverhead = 2 + (columns.length * 3) + 1;
-    const rowNumWidth = showRowNumbers ? Math.max(3, String(data.length).length + 1) : 0;
-    const rowNumOverhead = showRowNumbers ? 3 : 0;
-    const effectiveTermWidth = Math.max(60, Math.min(terminalWidth, 200));
-    const availableWidth = effectiveTermWidth - borderOverhead - rowNumOverhead - rowNumWidth;
-    const widths = [];
+    const numCols = columns.length;
+    const borderOverhead = 2 * numCols + 1;
+    const rowNumWidth = showRowNumbers
+        ? Math.max(3, String(data.length).length + 1)
+        : 0;
+    const rowNumOverhead = showRowNumbers ? 2 + rowNumWidth : 0;
+    const effectiveTermWidth = Math.min(terminalWidth, 240);
+    const availableWidth = Math.max(numCols * 4, effectiveTermWidth - borderOverhead - rowNumOverhead);
+    let widths = [];
     const contentWidths = [];
     let fixedWidthTotal = 0;
     let totalFlex = 0;
     columns.forEach((col, i) => {
-        const headerLen = col.header.length;
-        const maxContentLen = Math.max(headerLen, ...data.map(row => String(row[col.key] || '').length));
+        const headerLen = stripAnsi(col.header).length;
+        const maxContentLen = Math.max(headerLen, ...data.map((row) => stripAnsi(String(row[col.key] ?? "")).length));
         contentWidths[i] = maxContentLen;
         if (col.width) {
             widths[i] = col.width;
             fixedWidthTotal += col.width;
         }
         else if (col.flex) {
-            const minW = col.minWidth || Math.min(headerLen, 8);
+            const minW = col.minWidth || 4;
             widths[i] = minW;
             fixedWidthTotal += minW;
             totalFlex += col.flex;
         }
         else {
-            const minW = col.minWidth || Math.min(headerLen, 8);
+            const minW = col.minWidth || 4;
             const maxW = col.maxWidth || maxContentLen;
             widths[i] = Math.min(maxW, Math.max(minW, maxContentLen));
             fixedWidthTotal += widths[i];
@@ -58,18 +65,25 @@ function calculateColumnWidths(columns, data, terminalWidth, showRowNumbers) {
         columns.forEach((col, i) => {
             if (col.flex) {
                 const extraWidth = Math.floor((remainingWidth * col.flex) / totalFlex);
-                const maxW = col.maxWidth || contentWidths[i] || 50;
+                const maxW = col.maxWidth || 999;
                 widths[i] = Math.min((widths[i] ?? 0) + extraWidth, maxW);
             }
         });
     }
     let totalWidth = widths.reduce((sum, w) => sum + (w ?? 0), 0);
-    if (totalWidth > availableWidth) {
-        const scale = availableWidth / totalWidth;
-        columns.forEach((col, i) => {
-            const minW = col.minWidth || 8;
-            widths[i] = Math.max(minW, Math.floor((widths[i] ?? 0) * scale));
-        });
+    while (totalWidth > availableWidth && totalWidth > numCols * 4) {
+        let maxIdx = 0;
+        let maxW = widths[0] ?? 0;
+        for (let i = 1; i < widths.length; i++) {
+            if ((widths[i] ?? 0) > maxW) {
+                maxW = widths[i] ?? 0;
+                maxIdx = i;
+            }
+        }
+        if (maxW <= 4)
+            break;
+        widths[maxIdx] = Math.max(4, maxW - 1);
+        totalWidth--;
     }
     return widths;
 }
@@ -78,13 +92,17 @@ export class Table {
     data;
     options;
     rowNumWidth = 0;
+    lastLineCount = 0;
+    lastTableWidth = 0;
+    resizeHandler = null;
+    isWatching = false;
     constructor(columns, options = {}) {
         this.columns = columns;
         this.data = [];
         this.options = {
             showRowNumbers: true,
-            rowNumberHeader: '#',
-            ...options
+            rowNumberHeader: "#",
+            ...options,
         };
     }
     addRow(row) {
@@ -100,8 +118,38 @@ export class Table {
     }
     renderWithResize() {
         this.renderTable();
+        this.startWatching();
+    }
+    startWatching() {
+        if (this.isWatching || !process.stdout.isTTY)
+            return;
+        this.resizeHandler = () => {
+            this.clearTable();
+            this.renderTable();
+        };
+        process.stdout.on("resize", this.resizeHandler);
+        this.isWatching = true;
     }
     stopWatching() {
+        if (!this.isWatching || !this.resizeHandler)
+            return;
+        process.stdout.removeListener("resize", this.resizeHandler);
+        this.resizeHandler = null;
+        this.isWatching = false;
+    }
+    clearTable() {
+        if (this.lastLineCount <= 0)
+            return;
+        const maxPossibleWraps = Math.ceil(this.lastTableWidth / 20);
+        const worstCaseLines = this.lastLineCount * Math.max(maxPossibleWraps, 3);
+        const linesToClear = Math.max(worstCaseLines, 60);
+        process.stdout.write("\x1b[2K");
+        for (let i = 0; i < linesToClear; i++) {
+            process.stdout.write("\x1b[1A");
+            process.stdout.write("\x1b[2K");
+        }
+        process.stdout.write("\x1b[G");
+        process.stdout.write("\x1b[0J");
     }
     renderTable() {
         const terminalWidth = process.stdout.columns || 100;
@@ -109,50 +157,78 @@ export class Table {
         if (this.options.showRowNumbers) {
             this.rowNumWidth = Math.max(3, String(this.data.length).length + 1);
         }
+        const numCols = this.columns.length;
+        const borderWidth = 2 * numCols + 1;
+        const rowNumExtra = this.options.showRowNumbers ? 2 + this.rowNumWidth : 0;
+        const tableWidth = widths.reduce((a, b) => a + b, 0) + borderWidth + rowNumExtra;
+        this.lastTableWidth = tableWidth;
+        const linesPerRow = Math.max(1, Math.ceil(tableWidth / terminalWidth));
+        let lineCount = 0;
         if (this.options.title) {
             console.log(chalk.cyan.bold(`\n${this.options.title}`));
+            lineCount += 2;
         }
         this.renderTopBorder(widths);
+        lineCount += linesPerRow;
         this.renderHeader(widths);
+        lineCount += linesPerRow;
         this.renderHeaderSeparator(widths);
-        this.data.forEach((row, index) => this.renderRow(row, index, widths));
+        lineCount += linesPerRow;
+        this.data.forEach((row, index) => {
+            this.renderRow(row, index, widths);
+            lineCount += linesPerRow;
+        });
         this.renderBottomBorder(widths);
+        lineCount += linesPerRow;
+        this.lastLineCount = lineCount;
     }
     renderTopBorder(widths) {
-        let border = chalk.gray('╭─');
+        let border = chalk.gray("╭─");
         if (this.options.showRowNumbers) {
-            border += chalk.gray('─'.repeat(this.rowNumWidth)) + chalk.gray('┬─');
+            border += chalk.gray("─".repeat(this.rowNumWidth)) + chalk.gray("┬─");
         }
-        border += widths.map(w => chalk.gray('─'.repeat(w))).join(chalk.gray('┬─'));
-        border += chalk.gray('╮');
+        border += widths
+            .map((w) => chalk.gray("─".repeat(w)))
+            .join(chalk.gray("┬─"));
+        border += chalk.gray("╮");
         console.log(border);
     }
     renderHeader(widths) {
-        let header = chalk.gray('│ ');
+        let header = chalk.gray("│ ");
         if (this.options.showRowNumbers) {
-            header += chalk.cyan.bold(pad(this.options.rowNumberHeader, this.rowNumWidth)) + chalk.gray('│ ');
+            header +=
+                chalk.cyan.bold(pad(truncate(this.options.rowNumberHeader, this.rowNumWidth), this.rowNumWidth)) + chalk.gray("│ ");
         }
-        header += this.columns.map((col, i) => chalk.cyan.bold(pad(col.header, widths[i] || 10, col.align))).join(chalk.gray('│ '));
-        header += chalk.gray('│');
+        header += this.columns
+            .map((col, i) => {
+            const colWidth = widths[i] || 10;
+            return chalk.cyan.bold(pad(truncate(col.header, colWidth), colWidth, col.align));
+        })
+            .join(chalk.gray("│ "));
+        header += chalk.gray("│");
         console.log(header);
     }
     renderHeaderSeparator(widths) {
-        let separator = chalk.gray('├─');
+        let separator = chalk.gray("├─");
         if (this.options.showRowNumbers) {
-            separator += chalk.gray('─'.repeat(this.rowNumWidth)) + chalk.gray('┼─');
+            separator += chalk.gray("─".repeat(this.rowNumWidth)) + chalk.gray("┼─");
         }
-        separator += widths.map(w => chalk.gray('─'.repeat(w))).join(chalk.gray('┼─'));
-        separator += chalk.gray('┤');
+        separator += widths
+            .map((w) => chalk.gray("─".repeat(w)))
+            .join(chalk.gray("┼─"));
+        separator += chalk.gray("┤");
         console.log(separator);
     }
     renderRow(row, index, widths) {
-        let rowStr = chalk.gray('│ ');
+        let rowStr = chalk.gray("│ ");
         if (this.options.showRowNumbers) {
-            rowStr += chalk.white(pad(`${index + 1}.`, this.rowNumWidth)) + chalk.gray('│ ');
+            rowStr +=
+                chalk.white(pad(`${index + 1}.`, this.rowNumWidth)) + chalk.gray("│ ");
         }
-        rowStr += this.columns.map((col, i) => {
+        rowStr += this.columns
+            .map((col, i) => {
             const colWidth = widths[i] || 10;
-            let value = String(row[col.key] ?? '');
+            let value = String(row[col.key] ?? "");
             value = truncate(value, colWidth);
             value = pad(value, colWidth, col.align);
             if (col.color) {
@@ -162,70 +238,72 @@ export class Table {
                 value = chalk.white(value);
             }
             return value;
-        }).join(chalk.gray('│ '));
-        rowStr += chalk.gray('│');
+        })
+            .join(chalk.gray("│ "));
+        rowStr += chalk.gray("│");
         console.log(rowStr);
     }
     renderBottomBorder(widths) {
-        let border = chalk.gray('╰─');
+        let border = chalk.gray("╰─");
         if (this.options.showRowNumbers) {
-            border += chalk.gray('─'.repeat(this.rowNumWidth)) + chalk.gray('┴─');
+            border += chalk.gray("─".repeat(this.rowNumWidth)) + chalk.gray("┴─");
         }
-        border += widths.map(w => chalk.gray('─'.repeat(w))).join(chalk.gray('┴─'));
-        border += chalk.gray('╯');
+        border += widths
+            .map((w) => chalk.gray("─".repeat(w)))
+            .join(chalk.gray("┴─"));
+        border += chalk.gray("╯");
         console.log(border);
     }
 }
 export function displayCourses(courses, options = {}) {
     const columns = [
-        { key: 'name', header: 'Course Name', flex: 1, minWidth: 15 }
+        { key: "name", header: "Course Name", flex: 1, minWidth: 15 },
     ];
     if (options.showId) {
-        columns.push({ key: 'id', header: 'ID', minWidth: 5, maxWidth: 10 });
+        columns.push({ key: "id", header: "ID", minWidth: 5, maxWidth: 10 });
     }
     const table = new Table(columns);
-    courses.forEach(course => {
+    courses.forEach((course) => {
         table.addRow({ name: course.name, id: course.id });
     });
     table.render();
 }
 export async function pickCourse(options = {}) {
     const rl = createReadlineInterface();
-    console.log(chalk.cyan.bold(options.title || '\nLoading your courses, please wait...'));
-    const queryParams = [
-        'enrollment_state=active',
-        'include[]=favorites'
-    ];
-    const courses = await makeCanvasRequest('get', 'courses', queryParams);
+    console.log(chalk.cyan.bold(options.title || "\nLoading your courses, please wait..."));
+    const queryParams = ["enrollment_state=active", "include[]=favorites"];
+    const courses = await makeCanvasRequest("get", "courses", queryParams);
     if (!courses || courses.length === 0) {
-        console.log(chalk.red('Error: No courses found.'));
+        console.log(chalk.red("Error: No courses found."));
         rl.close();
         return null;
     }
     let displayCourses = courses;
     if (!options.showAll) {
-        const starred = courses.filter(c => c.is_favorite);
+        const starred = courses.filter((c) => c.is_favorite);
         if (starred.length > 0) {
             displayCourses = starred;
         }
     }
     console.log(chalk.green(`✓ Found ${displayCourses.length} course(s).`));
     const table = new Table([
-        { key: 'name', header: 'Course Name', flex: 1, minWidth: 15 }
+        { key: "name", header: "Course Name", flex: 1, minWidth: 15 },
     ]);
-    displayCourses.forEach(course => table.addRow({ name: course.name }));
+    displayCourses.forEach((course) => table.addRow({ name: course.name }));
     table.renderWithResize();
-    const prompt = options.prompt || chalk.bold.cyan('\nEnter course number: ');
+    const prompt = options.prompt || chalk.bold.cyan("\nEnter course number: ");
     const courseChoice = await askQuestion(rl, prompt);
     table.stopWatching();
-    if (!courseChoice.trim() || courseChoice === '..' || courseChoice.toLowerCase() === 'back') {
-        console.log(chalk.red('No course selected. Exiting...'));
+    if (!courseChoice.trim() ||
+        courseChoice === ".." ||
+        courseChoice.toLowerCase() === "back") {
+        console.log(chalk.red("No course selected. Exiting..."));
         rl.close();
         return null;
     }
     const courseIndex = parseInt(courseChoice) - 1;
     if (courseIndex < 0 || courseIndex >= displayCourses.length) {
-        console.log(chalk.red('Invalid course selection.'));
+        console.log(chalk.red("Invalid course selection."));
         rl.close();
         return null;
     }
@@ -234,8 +312,12 @@ export async function pickCourse(options = {}) {
     return { course: selectedCourse, rl };
 }
 export function formatGrade(submission, pointsPossible) {
-    if (submission && submission.score !== null && submission.score !== undefined) {
-        const score = submission.score % 1 === 0 ? Math.round(submission.score) : submission.score;
+    if (submission &&
+        submission.score !== null &&
+        submission.score !== undefined) {
+        const score = submission.score % 1 === 0
+            ? Math.round(submission.score)
+            : submission.score;
         const text = `${score}/${pointsPossible}`;
         const percentage = pointsPossible > 0 ? (score / pointsPossible) * 100 : 0;
         let color = chalk.white;
@@ -248,133 +330,141 @@ export function formatGrade(submission, pointsPossible) {
         return { text, color };
     }
     else if (submission && submission.excused) {
-        return { text: 'Excused', color: chalk.blue };
+        return { text: "Excused", color: chalk.blue };
     }
     else if (submission && submission.missing) {
-        return { text: 'Missing', color: chalk.red };
+        return { text: "Missing", color: chalk.red };
     }
     else if (pointsPossible) {
         return { text: `–/${pointsPossible}`, color: chalk.gray };
     }
-    return { text: 'N/A', color: chalk.gray };
+    return { text: "N/A", color: chalk.gray };
 }
 export function formatDueDate(dueAt) {
     if (!dueAt)
-        return 'No due date';
+        return "No due date";
     return new Date(dueAt).toLocaleString();
 }
 export function displayAssignments(assignments, options = {}) {
     const columns = [
-        { key: 'name', header: 'Assignment Name', flex: 1, minWidth: 15 }
+        { key: "name", header: "Assignment Name", flex: 1, minWidth: 15 },
     ];
     if (options.showId) {
-        columns.push({ key: 'id', header: 'ID', minWidth: 7, maxWidth: 10 });
+        columns.push({ key: "id", header: "ID", width: 7 });
     }
     if (options.showGrade) {
         columns.push({
-            key: 'grade',
-            header: 'Grade',
-            minWidth: 8,
-            maxWidth: 12,
+            key: "grade",
+            header: "Grade",
+            width: 10,
             color: (value, row) => {
                 const gradeInfo = formatGrade(row._submission, row._pointsPossible);
                 return gradeInfo.color(value);
-            }
+            },
         });
     }
     if (options.showDueDate) {
-        columns.push({ key: 'dueDate', header: 'Due Date', minWidth: 14, maxWidth: 22 });
+        columns.push({ key: "dueDate", header: "Due", width: 10 });
     }
     if (options.showStatus) {
         columns.push({
-            key: 'status',
-            header: 'Status',
-            minWidth: 10,
-            maxWidth: 14,
+            key: "status",
+            header: "Status",
+            width: 10,
             color: (value, row) => {
                 return row._isSubmitted ? chalk.green(value) : chalk.yellow(value);
-            }
+            },
         });
     }
     const table = new Table(columns);
-    assignments.forEach(assignment => {
+    assignments.forEach((assignment) => {
         const submission = assignment.submission;
         const gradeInfo = formatGrade(submission, assignment.points_possible || 0);
         const isSubmitted = !!(submission && submission.submitted_at);
+        let dueDate = "No due";
+        if (assignment.due_at) {
+            const d = new Date(assignment.due_at);
+            dueDate = `${(d.getMonth() + 1).toString().padStart(2, "0")}/${d.getDate().toString().padStart(2, "0")}/${d.getFullYear()}`;
+        }
         table.addRow({
             name: assignment.name,
             id: assignment.id,
             grade: gradeInfo.text,
-            dueDate: formatDueDate(assignment.due_at),
-            status: isSubmitted ? '✓ Submitted' : 'Not submitted',
+            dueDate: dueDate,
+            status: isSubmitted ? "✓ Submitted" : "Not submit",
             _submission: submission,
             _pointsPossible: assignment.points_possible || 0,
-            _isSubmitted: isSubmitted
+            _isSubmitted: isSubmitted,
         });
     });
-    table.render();
+    table.renderWithResize();
+    return table;
 }
 function getAssignmentType(assignment) {
-    if (!assignment.submission_types || assignment.submission_types.length === 0) {
-        return 'Unknown';
+    if (!assignment.submission_types ||
+        assignment.submission_types.length === 0) {
+        return "Unknown";
     }
     const types = assignment.submission_types;
-    if (types.includes('online_quiz')) {
-        return 'Quiz';
+    if (types.includes("online_quiz")) {
+        return "Quiz";
     }
-    else if (types.includes('online_upload')) {
-        if (assignment.allowed_extensions && assignment.allowed_extensions.length > 0) {
+    else if (types.includes("online_upload")) {
+        if (assignment.allowed_extensions &&
+            assignment.allowed_extensions.length > 0) {
             const exts = assignment.allowed_extensions.slice(0, 3);
-            const extList = exts.join(', ');
-            const suffix = assignment.allowed_extensions.length > 3 ? '...' : '';
+            const extList = exts.join(", ");
+            const suffix = assignment.allowed_extensions.length > 3 ? "..." : "";
             return `${extList}${suffix}`;
         }
-        return 'Any file';
+        return "Any file";
     }
-    else if (types.includes('online_text_entry')) {
-        return 'Text Entry';
+    else if (types.includes("online_text_entry")) {
+        return "Text Entry";
     }
-    else if (types.includes('online_url')) {
-        return 'URL';
+    else if (types.includes("online_url")) {
+        return "URL";
     }
-    else if (types.includes('external_tool')) {
-        return 'External Tool';
+    else if (types.includes("external_tool")) {
+        return "External Tool";
     }
-    else if (types.includes('media_recording')) {
-        return 'Media';
+    else if (types.includes("media_recording")) {
+        return "Media";
     }
     else if (types[0]) {
-        return types[0].replace(/_/g, ' ');
+        return types[0].replace(/_/g, " ");
     }
-    return 'Unknown';
+    return "Unknown";
 }
 export function displaySubmitAssignments(assignments) {
     const columns = [
-        { key: 'name', header: 'Assignment Name', flex: 1, minWidth: 20 },
-        { key: 'type', header: 'Type', minWidth: 8, maxWidth: 18 },
-        { key: 'dueDate', header: 'Due Date', minWidth: 16, maxWidth: 22 },
+        { key: "name", header: "Assignment Name", flex: 1, minWidth: 15 },
+        { key: "type", header: "Type", width: 8 },
+        { key: "dueDate", header: "Due", width: 10 },
         {
-            key: 'status',
-            header: 'Status',
-            minWidth: 10,
-            maxWidth: 14,
+            key: "status",
+            header: "Status",
+            width: 10,
             color: (value, row) => {
                 return row._isSubmitted ? chalk.green(value) : chalk.yellow(value);
-            }
-        }
+            },
+        },
     ];
     const table = new Table(columns);
-    assignments.forEach(assignment => {
+    assignments.forEach((assignment) => {
         const submission = assignment.submission;
         const isSubmitted = !!(submission && submission.submitted_at);
+        let dueDate = "No due date";
+        if (assignment.due_at) {
+            const d = new Date(assignment.due_at);
+            dueDate = `${(d.getMonth() + 1).toString().padStart(2, "0")}/${d.getDate().toString().padStart(2, "0")}/${d.getFullYear()}`;
+        }
         table.addRow({
             name: assignment.name,
             type: getAssignmentType(assignment),
-            dueDate: assignment.due_at
-                ? new Date(assignment.due_at).toLocaleString()
-                : 'No due date',
-            status: isSubmitted ? '✓ Submitted' : 'Not submitted',
-            _isSubmitted: isSubmitted
+            dueDate: dueDate,
+            status: isSubmitted ? "✓ Submitted" : "Not submit",
+            _isSubmitted: isSubmitted,
         });
     });
     table.renderWithResize();
@@ -382,30 +472,30 @@ export function displaySubmitAssignments(assignments) {
 }
 export function displayAnnouncements(announcements) {
     const columns = [
-        { key: 'title', header: 'Title', flex: 1, minWidth: 15 },
-        { key: 'posted', header: 'Posted', width: 10 }
+        { key: "title", header: "Title", flex: 1, minWidth: 15 },
+        { key: "posted", header: "Posted", width: 10 },
     ];
     const table = new Table(columns);
-    announcements.forEach(announcement => {
+    announcements.forEach((announcement) => {
         const date = announcement.posted_at
             ? new Date(announcement.posted_at).toLocaleDateString()
-            : 'N/A';
+            : "N/A";
         table.addRow({
-            title: announcement.title || 'Untitled',
-            posted: date
+            title: announcement.title || "Untitled",
+            posted: date,
         });
     });
     table.renderWithResize();
     return table;
 }
-export function printSeparator(char = '─', length) {
-    const width = length || (process.stdout.columns || 60);
+export function printSeparator(char = "─", length) {
+    const width = length || process.stdout.columns || 60;
     console.log(chalk.cyan.bold(char.repeat(width)));
 }
 export function printHeader(title) {
-    console.log(chalk.cyan.bold('\n' + '─'.repeat(60)));
+    console.log(chalk.cyan.bold("\n" + "─".repeat(60)));
     console.log(chalk.cyan.bold(title));
-    console.log(chalk.cyan.bold('─'.repeat(60)));
+    console.log(chalk.cyan.bold("─".repeat(60)));
 }
 export function printSuccess(message) {
     console.log(chalk.green(`✓ ${message}`));
@@ -420,40 +510,40 @@ export function printWarning(message) {
     console.log(chalk.yellow(message));
 }
 function cleanHtmlContent(html) {
-    return html
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
+    return (html
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
         .replace(/&quot;/g, '"')
         .replace(/&#39;/g, "'")
         .replace(/&apos;/g, "'")
-        .replace(/<br\s*\/?>/gi, '\n')
-        .replace(/<\/(p|div|li|h[1-6])>/gi, '\n')
-        .replace(/<li[^>]*>/gi, '• ')
-        .replace(/<[^>]+>/g, '')
-        .replace(/\n{3,}/g, '\n\n')
-        .replace(/[ \t]+/g, ' ')
-        .split('\n')
-        .map(line => line.trim())
-        .join('\n')
-        .trim();
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|h[1-6])>/gi, "\n")
+        .replace(/<li[^>]*>/gi, "• ")
+        .replace(/<[^>]+>/g, "")
+        .replace(/\n{3,}/g, "\n\n")
+        .replace(/[ \t]+/g, " ")
+        .split("\n")
+        .map((line) => line.trim())
+        .join("\n")
+        .trim());
 }
 function wordWrap(text, maxWidth) {
     const lines = [];
-    const paragraphs = text.split('\n');
+    const paragraphs = text.split("\n");
     for (const paragraph of paragraphs) {
-        if (paragraph.trim() === '') {
-            lines.push('');
+        if (paragraph.trim() === "") {
+            lines.push("");
             continue;
         }
-        const words = paragraph.split(' ').filter(w => w.length > 0);
-        let currentLine = '';
+        const words = paragraph.split(" ").filter((w) => w.length > 0);
+        let currentLine = "";
         for (const word of words) {
             if (word.length > maxWidth) {
                 if (currentLine) {
                     lines.push(currentLine);
-                    currentLine = '';
+                    currentLine = "";
                 }
                 for (let i = 0; i < word.length; i += maxWidth) {
                     lines.push(word.substring(i, i + maxWidth));
@@ -481,27 +571,29 @@ export function displayAnnouncementDetail(announcement) {
     const terminalWidth = process.stdout.columns || 80;
     const boxWidth = Math.max(50, terminalWidth - 4);
     const contentWidth = boxWidth - 4;
-    const title = announcement.title || 'Untitled';
-    const date = announcement.postedAt ? new Date(announcement.postedAt).toLocaleString() : 'N/A';
-    const author = announcement.author || 'Unknown';
-    const cleanedMessage = cleanHtmlContent(announcement.message || 'No content');
+    const title = announcement.title || "Untitled";
+    const date = announcement.postedAt
+        ? new Date(announcement.postedAt).toLocaleString()
+        : "N/A";
+    const author = announcement.author || "Unknown";
+    const cleanedMessage = cleanHtmlContent(announcement.message || "No content");
     const titleLines = wordWrap(title, contentWidth);
     const messageLines = wordWrap(cleanedMessage, contentWidth);
     const printLine = (content, style = chalk.white) => {
         const paddedContent = content.padEnd(contentWidth);
-        console.log(chalk.gray('│ ') + style(paddedContent) + chalk.gray(' │'));
+        console.log(chalk.gray("│ ") + style(paddedContent) + chalk.gray(" │"));
     };
-    console.log('\n' + chalk.gray('╭' + '─'.repeat(boxWidth - 2) + '╮'));
+    console.log("\n" + chalk.gray("╭" + "─".repeat(boxWidth - 2) + "╮"));
     for (const line of titleLines) {
         printLine(line, chalk.bold.white);
     }
-    console.log(chalk.gray('├' + '─'.repeat(boxWidth - 2) + '┤'));
+    console.log(chalk.gray("├" + "─".repeat(boxWidth - 2) + "┤"));
     printLine(`Posted: ${date}`, chalk.gray);
     printLine(`Author: ${author}`, chalk.gray);
-    console.log(chalk.gray('├' + '─'.repeat(boxWidth - 2) + '┤'));
+    console.log(chalk.gray("├" + "─".repeat(boxWidth - 2) + "┤"));
     for (const line of messageLines) {
         printLine(line, chalk.white);
     }
-    console.log(chalk.gray('╰' + '─'.repeat(boxWidth - 2) + '╯') + '\n');
+    console.log(chalk.gray("╰" + "─".repeat(boxWidth - 2) + "╯") + "\n");
 }
 //# sourceMappingURL=display.js.map