next-issue 2.4.1 → 2.4.3

package/dist/github.mjs

@@ -1,21 +1,23 @@
-import { must, run } from "./exec.mjs";
+import { must, run } from './exec.mjs';
 const CHECK_PENDING_CODE = 8;
 const READ_TRIES = 3;
 const NETWORK_TRIES = 3;
 const NETWORK_FAULT = /unexpected EOF|connection reset|connection refused|i\/o timeout|TLS handshake timeout|HTTP 50[234]/i;
 const KNOWN_LABELS = new Map();
 const NO_CHECKS = /no checks reported/i;
-const FAILED_CONCLUSIONS = new Set(["failure", "timed_out", "startup_failure"]);
+const FAILED_CONCLUSIONS = new Set(['failure', 'timed_out', 'startup_failure']);
 function slug(repo) {
     return `${repo.owner}/${repo.name}`;
 }
 async function repeatable(args, options) {
     for (let attempt = 1;; attempt += 1) {
         try {
-            return await must("gh", args, options);
+            return await must('gh', args, options);
         }
         catch (error) {
-            if (attempt >= NETWORK_TRIES || !(error instanceof Error) || !NETWORK_FAULT.test(error.message)) {
+            if (attempt >= NETWORK_TRIES ||
+                !(error instanceof Error) ||
+                !NETWORK_FAULT.test(error.message)) {
                 throw error;
             }
             await new Promise((resolve) => setTimeout(resolve, attempt * 1000));
@@ -23,95 +25,95 @@ async function repeatable(args, options) {
     }
 }
 async function gh(repo, args) {
-    return repeatable([...args, "--repo", slug(repo)], { cwd: repo.root });
+    return repeatable([...args, '--repo', slug(repo)], { cwd: repo.root });
 }
 async function ghOnce(repo, args, input) {
-    return must("gh", [...args, "--repo", slug(repo)], { cwd: repo.root, input });
+    return must('gh', [...args, '--repo', slug(repo)], { cwd: repo.root, input });
 }
 export async function defaultBranch(repo) {
-    const raw = await repeatable(["repo", "view", slug(repo), "--json", "defaultBranchRef"], {
+    const raw = await repeatable(['repo', 'view', slug(repo), '--json', 'defaultBranchRef'], {
         cwd: repo.root,
     });
     return JSON.parse(raw).defaultBranchRef.name;
 }
-const ISSUE_FIELDS = "number,title,body,createdAt,labels";
+const ISSUE_FIELDS = 'number,title,body,createdAt,labels';
 function toIssue(item) {
     return {
         number: item.number,
         title: item.title,
-        body: item.body ?? "",
+        body: item.body ?? '',
         createdAt: item.createdAt,
         labels: item.labels.map((label) => label.name),
     };
 }
 export async function openIssues(repo, limit, labels) {
-    const filter = labels.length === 0 ? "" : ` label:${labels.map((label) => `"${label}"`).join(",")}`;
+    const filter = labels.length === 0 ? '' : ` label:${labels.map((label) => `"${label}"`).join(',')}`;
     const raw = await gh(repo, [
-        "issue",
-        "list",
-        "--state",
-        "open",
-        "--search",
+        'issue',
+        'list',
+        '--state',
+        'open',
+        '--search',
         `sort:created-asc${filter}`,
-        "--limit",
+        '--limit',
         String(limit),
-        "--json",
+        '--json',
         ISSUE_FIELDS,
     ]);
     const parsed = JSON.parse(raw);
     return parsed.map(toIssue).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
 }
 export async function viewIssue(repo, issue) {
-    const raw = await gh(repo, ["issue", "view", String(issue), "--json", `${ISSUE_FIELDS},state`]);
+    const raw = await gh(repo, ['issue', 'view', String(issue), '--json', `${ISSUE_FIELDS},state`]);
     const parsed = JSON.parse(raw);
-    return { ...toIssue(parsed), open: parsed.state === "OPEN" };
+    return { ...toIssue(parsed), open: parsed.state === 'OPEN' };
 }
 export async function issueComments(repo, issue) {
-    const raw = await gh(repo, ["issue", "view", String(issue), "--json", "comments"]);
+    const raw = await gh(repo, ['issue', 'view', String(issue), '--json', 'comments']);
     const parsed = JSON.parse(raw);
     return parsed.comments.map((comment) => `@${comment.author.login}: ${comment.body}`);
 }
 export async function openBlockers(repo, issue) {
     const raw = await repeatable([
-        "api",
-        "--paginate",
+        'api',
+        '--paginate',
         `repos/${slug(repo)}/issues/${issue}/dependencies/blocked_by`,
-        "--jq",
+        '--jq',
         '.[] | select(.state == "open") | (.repository_url | split("/") | .[-2:] | join("/")) + "#" + (.number | tostring)',
     ], { cwd: repo.root });
     return raw
-        .split("\n")
+        .split('\n')
         .filter((line) => line.length > 0)
         .map((ref) => (ref.startsWith(`${slug(repo)}#`) ? ref.slice(slug(repo).length) : ref));
 }
 async function labelsOf(repo, kind, number) {
-    const raw = await gh(repo, [kind, "view", String(number), "--json", "labels"]);
+    const raw = await gh(repo, [kind, 'view', String(number), '--json', 'labels']);
     const parsed = JSON.parse(raw);
     return parsed.labels.map((label) => label.name);
 }
 export function labelArgs(add, remove, current) {
-    const args = ["--add-label", add];
+    const args = ['--add-label', add];
     for (const name of remove.filter((item) => item !== add && current.includes(item))) {
-        args.push("--remove-label", name);
+        args.push('--remove-label', name);
     }
     return args;
 }
 export async function setLabel(repo, kind, number, add, remove) {
     await ensureLabel(repo, add);
     const current = await labelsOf(repo, kind, number);
-    await gh(repo, [kind, "edit", String(number), ...labelArgs(add, remove, current)]);
+    await gh(repo, [kind, 'edit', String(number), ...labelArgs(add, remove, current)]);
 }
 async function ensureLabel(repo, label) {
     let known = KNOWN_LABELS.get(slug(repo));
     if (known === undefined) {
-        const raw = await gh(repo, ["label", "list", "--limit", "1000", "--json", "name"]);
+        const raw = await gh(repo, ['label', 'list', '--limit', '1000', '--json', 'name']);
         known = new Set(JSON.parse(raw).map((item) => item.name));
         KNOWN_LABELS.set(slug(repo), known);
     }
     if (known.has(label)) {
         return;
     }
-    const result = await run("gh", ["label", "create", label, "--repo", slug(repo)], {
+    const result = await run('gh', ['label', 'create', label, '--repo', slug(repo)], {
         cwd: repo.root,
     });
     if (result.code === 0) {
@@ -119,23 +121,32 @@ async function ensureLabel(repo, label) {
     }
 }
 export async function findPr(repo, branch) {
-    const raw = await gh(repo, ["pr", "list", "--head", branch, "--state", "open", "--json", "number"]);
+    const raw = await gh(repo, [
+        'pr',
+        'list',
+        '--head',
+        branch,
+        '--state',
+        'open',
+        '--json',
+        'number',
+    ]);
     const parsed = JSON.parse(raw);
     return parsed[0]?.number;
 }
 export async function createPr(repo, branch, base, title, body, draft) {
     const created = await ghOnce(repo, [
-        "pr",
-        "create",
-        "--head",
+        'pr',
+        'create',
+        '--head',
         branch,
-        "--base",
+        '--base',
         base,
-        "--title",
+        '--title',
         title,
-        "--body",
+        '--body',
         body,
-        ...(draft ? ["--draft"] : []),
+        ...(draft ? ['--draft'] : []),
     ]);
     const number = prNumber(created) ?? (await findPr(repo, branch));
     if (number === undefined) {
@@ -148,34 +159,44 @@ export function prNumber(output) {
     return match === null ? undefined : Number(match[1]);
 }
 async function prHead(repo, pr) {
-    return gh(repo, ["pr", "view", String(pr), "--json", "headRefOid", "--jq", ".headRefOid"]);
+    return gh(repo, ['pr', 'view', String(pr), '--json', 'headRefOid', '--jq', '.headRefOid']);
 }
 async function readChecks(repo, pr) {
-    const result = await run("gh", ["pr", "checks", String(pr), "--json", "name,bucket,link,description", "--repo", slug(repo)], { cwd: repo.root });
+    const result = await run('gh', ['pr', 'checks', String(pr), '--json', 'name,bucket,link,description', '--repo', slug(repo)], { cwd: repo.root });
     const output = result.stdout.trim();
     if (output.length === 0) {
         if (NO_CHECKS.test(result.stderr)) {
-            return "none";
+            return 'none';
         }
         throw new Error(`gh pr checks ${pr} failed with code ${result.code}: ${result.stderr.trim()}`);
     }
     const checks = JSON.parse(output);
-    return checks.length === 0 ? "none" : checks;
+    return checks.length === 0 ? 'none' : checks;
 }
 async function watchOnce(repo, pr, intervalSeconds, timeoutMs, show) {
-    const watch = await run("gh", ["pr", "checks", String(pr), "--watch", "--fail-fast", "--interval", String(intervalSeconds), "--repo", slug(repo)], { cwd: repo.root, show, timeoutMs });
+    const watch = await run('gh', [
+        'pr',
+        'checks',
+        String(pr),
+        '--watch',
+        '--fail-fast',
+        '--interval',
+        String(intervalSeconds),
+        '--repo',
+        slug(repo),
+    ], { cwd: repo.root, show, timeoutMs });
     if (watch.timedOut) {
-        return "timeout";
+        return 'timeout';
     }
     if (watch.code === 0) {
-        return "pass";
+        return 'pass';
     }
     if (watch.code === CHECK_PENDING_CODE) {
-        return "pending";
+        return 'pending';
     }
     const checks = await readChecks(repo, pr);
-    if (checks !== "none" && checks.some((check) => check.bucket === "fail")) {
-        return "fail";
+    if (checks !== 'none' && checks.some((check) => check.bucket === 'fail')) {
+        return 'fail';
     }
     throw new Error(`gh pr checks ${pr} --watch failed with code ${watch.code} and no check failed: ${watch.stderr.trim()}`);
 }
@@ -190,7 +211,7 @@ export async function pollChecks(probe, options, clock = REAL_CLOCK) {
     let failures = 0;
     for (;;) {
         if (rest() === 0) {
-            return "timeout";
+            return 'timeout';
         }
         const state = await read(probe, options.head, rest(), () => (shown ??= clock.now()));
         if (state instanceof Error) {
@@ -201,10 +222,10 @@ export async function pollChecks(probe, options, clock = REAL_CLOCK) {
         }
         else {
             failures = 0;
-            if (state === "none" && clock.now() - (shown ?? 0) >= options.graceMs) {
-                return "none";
+            if (state === 'none' && clock.now() - (shown ?? 0) >= options.graceMs) {
+                return 'none';
             }
-            if (state !== "none" && state !== "behind" && state !== "pending") {
+            if (state !== 'none' && state !== 'behind' && state !== 'pending') {
                 return state;
             }
         }
@@ -214,11 +235,11 @@ export async function pollChecks(probe, options, clock = REAL_CLOCK) {
 async function read(probe, head, timeoutMs, shown) {
     try {
         if (head !== undefined && (await probe.head()) !== head) {
-            return "behind";
+            return 'behind';
         }
         shown();
-        if ((await probe.list()) === "none") {
-            return "none";
+        if ((await probe.list()) === 'none') {
+            return 'none';
         }
         return await probe.watch(timeoutMs);
     }
@@ -229,17 +250,17 @@ async function read(probe, head, timeoutMs, shown) {
 export function waitForChecks(repo, pr, options) {
     return pollChecks({
         head: () => prHead(repo, pr),
-        list: async () => ((await readChecks(repo, pr)) === "none" ? "none" : "some"),
+        list: async () => ((await readChecks(repo, pr)) === 'none' ? 'none' : 'some'),
         watch: (timeoutMs) => watchOnce(repo, pr, options.intervalSeconds, timeoutMs, options.show),
     }, options);
 }
 export async function failedCheckLogs(repo, pr, maxChars) {
     const checks = await readChecks(repo, pr);
-    if (checks === "none") {
-        return "The checks failed, but gh reports no check for the pull request.";
+    if (checks === 'none') {
+        return 'The checks failed, but gh reports no check for the pull request.';
     }
     const failed = checks
-        .filter((check) => check.bucket === "fail")
+        .filter((check) => check.bucket === 'fail')
         .map((check) => ({
         heading: `## ${check.name}\n${check.description}`,
         runId: /\/actions\/runs\/(\d+)/.exec(check.link)?.[1],
@@ -247,25 +268,32 @@ export async function failedCheckLogs(repo, pr, maxChars) {
     return runLogs(repo, failed, maxChars);
 }
 async function baseRuns(repo, sha) {
-    const raw = await gh(repo, ["run", "list", "--commit", sha, "--json", "databaseId,name,status,conclusion"]);
+    const raw = await gh(repo, [
+        'run',
+        'list',
+        '--commit',
+        sha,
+        '--json',
+        'databaseId,name,status,conclusion',
+    ]);
     return JSON.parse(raw);
 }
 function baseState(runs) {
-    if (runs.some((entry) => entry.status === "completed" && FAILED_CONCLUSIONS.has(entry.conclusion))) {
-        return "fail";
+    if (runs.some((entry) => entry.status === 'completed' && FAILED_CONCLUSIONS.has(entry.conclusion))) {
+        return 'fail';
     }
-    return runs.every((entry) => entry.status === "completed") ? "pass" : "pending";
+    return runs.every((entry) => entry.status === 'completed') ? 'pass' : 'pending';
 }
 export function waitForBaseChecks(repo, sha, options) {
     return pollChecks({
         head: async () => sha,
-        list: async () => ((await baseRuns(repo, sha)).length === 0 ? "none" : "some"),
+        list: async () => ((await baseRuns(repo, sha)).length === 0 ? 'none' : 'some'),
         watch: async () => baseState(await baseRuns(repo, sha)),
     }, options);
 }
 export async function failedBaseLogs(repo, sha, maxChars) {
     const failed = (await baseRuns(repo, sha))
-        .filter((entry) => entry.status === "completed" && FAILED_CONCLUSIONS.has(entry.conclusion))
+        .filter((entry) => entry.status === 'completed' && FAILED_CONCLUSIONS.has(entry.conclusion))
         .map((entry) => ({ heading: `## ${entry.name}`, runId: String(entry.databaseId) }));
     return runLogs(repo, failed, maxChars);
 }
@@ -277,7 +305,7 @@ async function runLogs(repo, failed, maxChars) {
         if (runId === undefined) {
             continue;
         }
-        const logs = await run("gh", ["run", "view", runId, "--log-failed", "--repo", slug(repo)], {
+        const logs = await run('gh', ['run', 'view', runId, '--log-failed', '--repo', slug(repo)], {
             cwd: repo.root,
             tailChars: share,
         });
@@ -286,43 +314,44 @@ async function runLogs(repo, failed, maxChars) {
             continue;
         }
         const reason = [`The log read failed with code ${logs.code}.`, logs.stderr.trim()]
-            .filter((line) => line !== "")
-            .join(" ");
-        parts.push([logs.stdout.trim(), reason].filter((line) => line !== "").join("\n"));
+            .filter((line) => line !== '')
+            .join(' ');
+        parts.push([logs.stdout.trim(), reason].filter((line) => line !== '').join('\n'));
     }
-    return parts.join("\n\n");
+    return parts.join('\n\n');
 }
 export async function markPrReady(repo, pr) {
-    const result = await run("gh", ["pr", "ready", String(pr), "--repo", slug(repo)], {
+    const result = await run('gh', ['pr', 'ready', String(pr), '--repo', slug(repo)], {
         cwd: repo.root,
     });
     return result.code === 0;
 }
 export async function mergePr(repo, pr) {
-    const result = await run("gh", ["pr", "merge", String(pr), "--squash", "--delete-branch", "--repo", slug(repo)], { cwd: repo.root });
+    const result = await run('gh', ['pr', 'merge', String(pr), '--squash', '--delete-branch', '--repo', slug(repo)], { cwd: repo.root });
     return result.code === 0;
 }
 export async function prMerged(repo, pr) {
-    return (await gh(repo, ["pr", "view", String(pr), "--json", "state", "--jq", ".state"])).trim() === "MERGED";
+    return ((await gh(repo, ['pr', 'view', String(pr), '--json', 'state', '--jq', '.state'])).trim() ===
+        'MERGED');
 }
 export async function mergeCommit(repo, pr, options, clock = REAL_CLOCK) {
     const deadline = clock.now() + options.timeoutMs;
     for (;;) {
-        const raw = await gh(repo, ["pr", "view", String(pr), "--json", "state,mergeCommit"]);
+        const raw = await gh(repo, ['pr', 'view', String(pr), '--json', 'state,mergeCommit']);
         const view = JSON.parse(raw);
-        if (view.state === "MERGED" && view.mergeCommit?.oid) {
+        if (view.state === 'MERGED' && view.mergeCommit?.oid) {
             return view.mergeCommit.oid;
         }
         const rest = deadline - clock.now();
-        if (view.state === "CLOSED" || rest <= 0) {
+        if (view.state === 'CLOSED' || rest <= 0) {
             return undefined;
         }
         await clock.sleep(Math.min(options.intervalSeconds * 1000, rest));
     }
 }
 export async function reopenIssue(repo, issue) {
-    await gh(repo, ["issue", "reopen", String(issue)]);
+    await gh(repo, ['issue', 'reopen', String(issue)]);
 }
 export async function commentOnPr(repo, pr, body) {
-    await ghOnce(repo, ["pr", "comment", String(pr), "--body-file", "-"], body);
+    await ghOnce(repo, ['pr', 'comment', String(pr), '--body-file', '-'], body);
 }

package/dist/interrupt.mjs

@@ -1,25 +1,25 @@
-import { stopChildren } from "./exec.mjs";
+import { stopChildren } from './exec.mjs';
 export function listenForInterrupts(say) {
     let presses = 0;
     let wake;
     const press = () => {
         presses += 1;
         if (presses === 1 && wake !== undefined) {
-            say("Stopping now.");
+            say('Stopping now.');
             wake();
         }
         else if (presses === 1) {
-            say("Stopping after this issue. Press Ctrl-C again to stop after this round.");
+            say('Stopping after this issue. Press Ctrl-C again to stop after this round.');
         }
         else if (presses === 2) {
-            say("Stopping after this round. Press Ctrl-C again to stop now.");
+            say('Stopping after this round. Press Ctrl-C again to stop now.');
         }
         else {
-            process.off("SIGINT", press);
-            stopChildren("SIGINT");
+            process.off('SIGINT', press);
+            stopChildren('SIGINT');
         }
     };
-    process.on("SIGINT", press);
+    process.on('SIGINT', press);
     return {
         afterIssue: () => presses >= 1,
         afterRound: () => presses >= 2,

package/dist/loop.mjs

@@ -1,7 +1,6 @@
 export const BACK_OFF_MINUTES = [1, 2, 3, 5, 10];
-export async function runIssues(args, loop) {
+export async function runIssues(args, loop, seen = new Set()) {
     const reports = [];
-    const seen = new Set();
     while (args.max === undefined || handled(reports) < args.max) {
         let issues;
         try {
@@ -20,7 +19,7 @@ export async function runIssues(args, loop) {
         if (loop.stop() || report.halt === true) {
             return { reports, stoppedAt: issue.number };
         }
-        if (args.once && report.outcome !== "skipped") {
+        if (args.once && report.outcome !== 'skipped') {
             break;
         }
     }
@@ -29,10 +28,16 @@ export async function runIssues(args, loop) {
 export async function watchIssues(args, watch) {
     const limit = args.once ? 1 : args.max;
     const reports = [];
+    const failed = new Set();
     let step = 0;
     for (;;) {
-        const pass = await runIssues({ once: false, max: limit === undefined ? undefined : limit - handled(reports) }, watch);
+        const pass = await runIssues({ once: false, max: limit === undefined ? undefined : limit - handled(reports) }, watch, new Set(failed));
         reports.push(...pass.reports);
+        for (const report of pass.reports) {
+            if (report.outcome === 'error') {
+                failed.add(report.issue);
+            }
+        }
         if (handled(pass.reports) > 0) {
             await watch.passEnd(pass.reports);
             step = 0;
@@ -51,8 +56,10 @@ export async function watchIssues(args, watch) {
     }
 }
 export function exitCode(reports) {
-    return reports.some((report) => report.outcome === "needs-human" || report.outcome === "error") ? 1 : 0;
+    return reports.some((report) => report.outcome === 'needs-human' || report.outcome === 'error')
+        ? 1
+        : 0;
 }
 function handled(reports) {
-    return reports.filter((report) => report.outcome !== "skipped").length;
+    return reports.filter((report) => report.outcome !== 'skipped').length;
 }

package/dist/observe.mjs

@@ -1,7 +1,7 @@
-import { createWriteStream } from "node:fs";
-import { mkdir, readdir, rm, stat } from "node:fs/promises";
-import { join } from "node:path";
-import { STATE_DIR } from "./state.mjs";
+import { createWriteStream } from 'node:fs';
+import { mkdir, readdir, rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { STATE_DIR } from './state.mjs';
 const VISIBILITY = { quiet: 0, normal: 1, verbose: 2 };
 export function emptyUsage() {
     return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 };
@@ -63,11 +63,11 @@ export class Recorder {
         this.runId = runId;
     }
     static async create(root, level, listener) {
-        const runId = new Date().toISOString().replace(/[:.]/g, "-");
-        const dir = join(root, STATE_DIR, "runs");
+        const runId = new Date().toISOString().replace(/[:.]/g, '-');
+        const dir = join(root, STATE_DIR, 'runs');
         await mkdir(dir, { recursive: true });
         const file = join(dir, `${runId}.jsonl`);
-        const sink = new Sink(createWriteStream(file, { flags: "a" }), level, file, listener);
+        const sink = new Sink(createWriteStream(file, { flags: 'a' }), level, file, listener);
         return new Recorder(sink, {}, runId);
     }
     get logFile() {
@@ -79,7 +79,7 @@ export class Recorder {
     scope(fields) {
         return new Recorder(this.sink, { ...this.base, ...fields }, this.runId);
     }
-    event(kind, fields = {}, visibility = "normal") {
+    event(kind, fields = {}, visibility = 'normal') {
         this.sink.count(kind);
         const record = {
             ts: new Date().toISOString(),
@@ -95,18 +95,18 @@ export class Recorder {
     }
     usage(role, usage, ms, fields = {}) {
         this.sink.add(role, usage, ms);
-        this.event("usage", { role, ms, ...usage, ...fields }, "normal");
+        this.event('usage', { role, ms, ...usage, ...fields }, 'normal');
     }
     async step(kind, fields, run) {
         const started = Date.now();
-        this.event(`${kind}.start`, fields, "verbose");
+        this.event(`${kind}.start`, fields, 'verbose');
         try {
             const result = await run();
             this.event(`${kind}.end`, { ...fields, ms: Date.now() - started });
             return result;
         }
         catch (error) {
-            this.event(`${kind}.error`, { ...fields, ms: Date.now() - started, error: message(error) }, "quiet");
+            this.event(`${kind}.error`, { ...fields, ms: Date.now() - started, error: message(error) }, 'quiet');
             throw error;
         }
     }
@@ -140,7 +140,7 @@ export async function pruneRuns(root, keepDays) {
     if (keepDays <= 0) {
         return 0;
     }
-    const dir = join(root, STATE_DIR, "runs");
+    const dir = join(root, STATE_DIR, 'runs');
     let names;
     try {
         names = await readdir(dir);
@@ -170,20 +170,20 @@ export function message(error) {
 }
 function render(record) {
     const time = new Date(String(record.ts)).toTimeString().slice(0, 8);
-    const issue = record.issue === undefined ? "" : ` #${record.issue}`;
+    const issue = record.issue === undefined ? '' : ` #${record.issue}`;
     const extras = Object.entries(record)
-        .filter(([key]) => !["ts", "runId", "kind", "issue"].includes(key))
+        .filter(([key]) => !['ts', 'runId', 'kind', 'issue'].includes(key))
         .map(([key, value]) => `${key}=${short(value)}`)
-        .join(" ");
-    return `${time}${issue} ${String(record.kind)}${extras.length > 0 ? ` ${extras}` : ""}\n`;
+        .join(' ');
+    return `${time}${issue} ${String(record.kind)}${extras.length > 0 ? ` ${extras}` : ''}\n`;
 }
 function short(value) {
     if (value === undefined || value === null) {
-        return "-";
+        return '-';
     }
-    if (typeof value === "number") {
+    if (typeof value === 'number') {
         return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(6)));
     }
-    const text = String(value).replace(/\s+/g, " ");
+    const text = String(value).replace(/\s+/g, ' ');
     return text.length > 120 ? `${text.slice(0, 117)}...` : text;
 }