@tokentop/ttop 0.2.2 → 0.4.0

package/src/tui/views/index.ts

@@ -1,2 +1,2 @@
-export { Dashboard } from './Dashboard.tsx';
-export { ProjectsView } from './ProjectsView.tsx';
+export { Dashboard } from "./Dashboard.tsx";
+export { ProjectsView } from "./ProjectsView.tsx";

package/src/types/opentui-test-utils.d.ts

@@ -1,14 +1,14 @@
-declare module '@opentui/react/test-utils' {
-  import type { TestRendererOptions } from '@opentui/core/testing';
-  import type { ReactNode } from 'react';
+declare module "@opentui/react/test-utils" {
+  import type { TestRendererOptions } from "@opentui/core/testing";
+  import type { ReactNode } from "react";
 
   export function testRender(
     node: ReactNode,
-    testRendererOptions: TestRendererOptions
+    testRendererOptions: TestRendererOptions,
   ): Promise<{
-    renderer: import('@opentui/core/testing').TestRenderer;
-    mockInput: import('@opentui/core/testing').MockInput;
-    mockMouse: import('@opentui/core/testing').MockMouse;
+    renderer: import("@opentui/core/testing").TestRenderer;
+    mockInput: import("@opentui/core/testing").MockInput;
+    mockMouse: import("@opentui/core/testing").MockMouse;
     renderOnce: () => Promise<void>;
     captureCharFrame: () => string;
     resize: (width: number, height: number) => void;

package/src/utils/clipboard.ts

@@ -1,5 +1,5 @@
-import { $ } from 'bun';
-import { platform } from 'os';
+import { $ } from "bun";
+import { platform } from "os";
 
 /**
  * Custom clipboard implementation with platform-specific fallbacks.
@@ -23,10 +23,10 @@ import { platform } from 'os';
  */
 function writeOsc52(text: string): void {
   if (!process.stdout.isTTY) return;
-  const base64 = Buffer.from(text).toString('base64');
+  const base64 = Buffer.from(text).toString("base64");
   const osc52 = `\x1b]52;c;${base64}\x07`;
   // tmux and screen require DCS passthrough wrapping
-  const passthrough = process.env['TMUX'] || process.env['STY'];
+  const passthrough = process.env["TMUX"] || process.env["STY"];
   const sequence = passthrough ? `\x1bPtmux;\x1b${osc52}\x1b\\` : osc52;
   process.stdout.write(sequence);
 }
@@ -38,30 +38,30 @@ function getCopyMethod(): (text: string) => Promise<void> {
 
   const os = platform();
 
-  if (os === 'darwin' && Bun.which('osascript')) {
+  if (os === "darwin" && Bun.which("osascript")) {
     copyMethod = async (text: string) => {
-      const escaped = text.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+      const escaped = text.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
       await $`osascript -e 'set the clipboard to "${escaped}"'`.nothrow().quiet();
     };
     return copyMethod;
   }
 
-  if (os === 'linux') {
-    if (process.env['WAYLAND_DISPLAY'] && Bun.which('wl-copy')) {
+  if (os === "linux") {
+    if (process.env["WAYLAND_DISPLAY"] && Bun.which("wl-copy")) {
       copyMethod = async (text: string) => {
-        const proc = Bun.spawn(['wl-copy'], { stdin: 'pipe', stdout: 'ignore', stderr: 'ignore' });
+        const proc = Bun.spawn(["wl-copy"], { stdin: "pipe", stdout: "ignore", stderr: "ignore" });
         proc.stdin.write(text);
         proc.stdin.end();
         await proc.exited.catch(() => {});
       };
       return copyMethod;
     }
-    if (Bun.which('xclip')) {
+    if (Bun.which("xclip")) {
       copyMethod = async (text: string) => {
-        const proc = Bun.spawn(['xclip', '-selection', 'clipboard'], {
-          stdin: 'pipe',
-          stdout: 'ignore',
-          stderr: 'ignore',
+        const proc = Bun.spawn(["xclip", "-selection", "clipboard"], {
+          stdin: "pipe",
+          stdout: "ignore",
+          stderr: "ignore",
         });
         proc.stdin.write(text);
         proc.stdin.end();
@@ -69,12 +69,12 @@ function getCopyMethod(): (text: string) => Promise<void> {
       };
       return copyMethod;
     }
-    if (Bun.which('xsel')) {
+    if (Bun.which("xsel")) {
       copyMethod = async (text: string) => {
-        const proc = Bun.spawn(['xsel', '--clipboard', '--input'], {
-          stdin: 'pipe',
-          stdout: 'ignore',
-          stderr: 'ignore',
+        const proc = Bun.spawn(["xsel", "--clipboard", "--input"], {
+          stdin: "pipe",
+          stdout: "ignore",
+          stderr: "ignore",
         });
         proc.stdin.write(text);
         proc.stdin.end();
@@ -84,21 +84,21 @@ function getCopyMethod(): (text: string) => Promise<void> {
     }
   }
 
-  if (os === 'win32') {
+  if (os === "win32") {
     copyMethod = async (text: string) => {
       const proc = Bun.spawn(
         [
-          'powershell.exe',
-          '-NonInteractive',
-          '-NoProfile',
-          '-Command',
-          '[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())',
+          "powershell.exe",
+          "-NonInteractive",
+          "-NoProfile",
+          "-Command",
+          "[Console]::InputEncoding = [System.Text.Encoding]::UTF8; Set-Clipboard -Value ([Console]::In.ReadToEnd())",
         ],
         {
-          stdin: 'pipe',
-          stdout: 'ignore',
-          stderr: 'ignore',
-        }
+          stdin: "pipe",
+          stdout: "ignore",
+          stderr: "ignore",
+        },
       );
       proc.stdin.write(text);
       proc.stdin.end();

package/src/utils/currency.test.ts

@@ -1,106 +1,106 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test } from "bun:test";
 import {
   formatBudgetDisplay,
   formatCurrency,
   isValidCurrencyInput,
   parseCurrencyInput,
-} from './currency.ts';
+} from "./currency.ts";
 
-describe('parseCurrencyInput', () => {
-  test('returns null for empty or whitespace input', () => {
-    expect(parseCurrencyInput('')).toBeNull();
-    expect(parseCurrencyInput('   ')).toBeNull();
+describe("parseCurrencyInput", () => {
+  test("returns null for empty or whitespace input", () => {
+    expect(parseCurrencyInput("")).toBeNull();
+    expect(parseCurrencyInput("   ")).toBeNull();
   });
 
-  test('parses US format with thousands and decimal separators', () => {
-    expect(parseCurrencyInput('1,234.56')).toBe(1234.56);
+  test("parses US format with thousands and decimal separators", () => {
+    expect(parseCurrencyInput("1,234.56")).toBe(1234.56);
   });
 
-  test('parses European format with period thousands and comma decimal', () => {
-    expect(parseCurrencyInput('1.234,56')).toBe(1234.56);
+  test("parses European format with period thousands and comma decimal", () => {
+    expect(parseCurrencyInput("1.234,56")).toBe(1234.56);
   });
 
-  test('parses plain numbers', () => {
-    expect(parseCurrencyInput('42.50')).toBe(42.5);
+  test("parses plain numbers", () => {
+    expect(parseCurrencyInput("42.50")).toBe(42.5);
   });
 
-  test('strips supported currency symbols before parsing', () => {
-    expect(parseCurrencyInput('$100')).toBe(100);
-    expect(parseCurrencyInput('€100')).toBe(100);
-    expect(parseCurrencyInput('£100')).toBe(100);
+  test("strips supported currency symbols before parsing", () => {
+    expect(parseCurrencyInput("$100")).toBe(100);
+    expect(parseCurrencyInput("€100")).toBe(100);
+    expect(parseCurrencyInput("£100")).toBe(100);
   });
 
-  test('treats comma as decimal separator when not thousands grouping', () => {
-    expect(parseCurrencyInput('10,50')).toBe(10.5);
+  test("treats comma as decimal separator when not thousands grouping", () => {
+    expect(parseCurrencyInput("10,50")).toBe(10.5);
   });
 
-  test('treats comma as thousands separator with 3 digits after comma', () => {
-    expect(parseCurrencyInput('1,234')).toBe(1234);
+  test("treats comma as thousands separator with 3 digits after comma", () => {
+    expect(parseCurrencyInput("1,234")).toBe(1234);
   });
 
-  test('returns null for invalid input', () => {
-    expect(parseCurrencyInput('abc')).toBeNull();
+  test("returns null for invalid input", () => {
+    expect(parseCurrencyInput("abc")).toBeNull();
   });
 
-  test('rounds parsed values to 2 decimal places', () => {
-    const parsed = parseCurrencyInput('10.129');
+  test("rounds parsed values to 2 decimal places", () => {
+    const parsed = parseCurrencyInput("10.129");
     expect(parsed).toBe(Math.round(10.129 * 100) / 100);
   });
 });
 
-describe('formatCurrency', () => {
-  test('returns None for null input', () => {
-    expect(formatCurrency(null)).toBe('None');
+describe("formatCurrency", () => {
+  test("returns None for null input", () => {
+    expect(formatCurrency(null)).toBe("None");
   });
 
-  test('formats compact values >= 1000 as k notation', () => {
-    expect(formatCurrency(1234, { compact: true })).toBe('$1.2k');
+  test("formats compact values >= 1000 as k notation", () => {
+    expect(formatCurrency(1234, { compact: true })).toBe("$1.2k");
   });
 
-  test('formats compact values >= 100 as rounded integer', () => {
-    expect(formatCurrency(234.4, { compact: true })).toBe('$234');
+  test("formats compact values >= 100 as rounded integer", () => {
+    expect(formatCurrency(234.4, { compact: true })).toBe("$234");
   });
 
-  test('formats compact values >= 10 with one decimal place', () => {
-    expect(formatCurrency(42.34, { compact: true })).toBe('$42.3');
+  test("formats compact values >= 10 with one decimal place", () => {
+    expect(formatCurrency(42.34, { compact: true })).toBe("$42.3");
   });
 
-  test('formats compact values < 10 with two decimal places', () => {
-    expect(formatCurrency(9.5, { compact: true })).toBe('$9.50');
+  test("formats compact values < 10 with two decimal places", () => {
+    expect(formatCurrency(9.5, { compact: true })).toBe("$9.50");
   });
 
-  test('formats non-compact values with locale separators and two decimals', () => {
-    expect(formatCurrency(1234.5)).toBe('$1,234.50');
+  test("formats non-compact values with locale separators and two decimals", () => {
+    expect(formatCurrency(1234.5)).toBe("$1,234.50");
   });
 
-  test('omits currency symbol when showSymbol is false', () => {
-    expect(formatCurrency(1234.5, { showSymbol: false })).toBe('1,234.50');
-    expect(formatCurrency(1234, { compact: true, showSymbol: false })).toBe('1.2k');
+  test("omits currency symbol when showSymbol is false", () => {
+    expect(formatCurrency(1234.5, { showSymbol: false })).toBe("1,234.50");
+    expect(formatCurrency(1234, { compact: true, showSymbol: false })).toBe("1.2k");
   });
 });
 
-describe('formatBudgetDisplay', () => {
-  test('returns None for null input', () => {
-    expect(formatBudgetDisplay(null)).toBe('None');
+describe("formatBudgetDisplay", () => {
+  test("returns None for null input", () => {
+    expect(formatBudgetDisplay(null)).toBe("None");
   });
 
-  test('delegates formatting to formatCurrency for numeric values', () => {
+  test("delegates formatting to formatCurrency for numeric values", () => {
     expect(formatBudgetDisplay(1234.5)).toBe(formatCurrency(1234.5));
   });
 });
 
-describe('isValidCurrencyInput', () => {
-  test('returns true for empty input (represents no value)', () => {
-    expect(isValidCurrencyInput('')).toBe(true);
-    expect(isValidCurrencyInput('   ')).toBe(true);
+describe("isValidCurrencyInput", () => {
+  test("returns true for empty input (represents no value)", () => {
+    expect(isValidCurrencyInput("")).toBe(true);
+    expect(isValidCurrencyInput("   ")).toBe(true);
   });
 
-  test('returns true for valid numeric input', () => {
-    expect(isValidCurrencyInput('42.50')).toBe(true);
-    expect(isValidCurrencyInput('1.234,56')).toBe(true);
+  test("returns true for valid numeric input", () => {
+    expect(isValidCurrencyInput("42.50")).toBe(true);
+    expect(isValidCurrencyInput("1.234,56")).toBe(true);
   });
 
-  test('returns false for invalid input', () => {
-    expect(isValidCurrencyInput('abc')).toBe(false);
+  test("returns false for invalid input", () => {
+    expect(isValidCurrencyInput("abc")).toBe(false);
   });
 });

package/src/utils/currency.ts

@@ -3,77 +3,80 @@
  * Handles US format (1,234.56) and European format (1.234,56).
  */
 export function parseCurrencyInput(input: string): number | null {
-  if (!input || input.trim() === '') {
+  if (!input || input.trim() === "") {
     return null;
   }
-  
-  let normalized = input.trim().replace(/[$€£]/g, '').replace(/\s/g, '');
-  
-  const hasComma = normalized.includes(',');
-  const hasPeriod = normalized.includes('.');
-  
+
+  let normalized = input.trim().replace(/[$€£]/g, "").replace(/\s/g, "");
+
+  const hasComma = normalized.includes(",");
+  const hasPeriod = normalized.includes(".");
+
   if (hasComma && hasPeriod) {
-    const lastComma = normalized.lastIndexOf(',');
-    const lastPeriod = normalized.lastIndexOf('.');
-    
+    const lastComma = normalized.lastIndexOf(",");
+    const lastPeriod = normalized.lastIndexOf(".");
+
     if (lastComma > lastPeriod) {
       // European: 1.234,56 → remove periods, comma becomes decimal
-      normalized = normalized.replace(/\./g, '').replace(',', '.');
+      normalized = normalized.replace(/\./g, "").replace(",", ".");
     } else {
       // US: 1,234.56 → remove commas
-      normalized = normalized.replace(/,/g, '');
+      normalized = normalized.replace(/,/g, "");
     }
   } else if (hasComma) {
-    const parts = normalized.split(',');
+    const parts = normalized.split(",");
     // 3 digits after comma = thousands separator (1,234), otherwise decimal (10,50)
     if (parts.length === 2 && parts[1]!.length === 3 && parts[0]!.length > 0) {
-      normalized = normalized.replace(',', '');
+      normalized = normalized.replace(",", "");
     } else {
-      normalized = normalized.replace(',', '.');
+      normalized = normalized.replace(",", ".");
     }
   }
-  
+
   const parsed = parseFloat(normalized);
-  
+
   if (isNaN(parsed) || !isFinite(parsed)) {
     return null;
   }
-  
+
   return Math.round(parsed * 100) / 100;
 }
 
-export function formatCurrency(value: number | null, options?: { 
-  compact?: boolean;
-  showSymbol?: boolean;
-}): string {
+export function formatCurrency(
+  value: number | null,
+  options?: {
+    compact?: boolean;
+    showSymbol?: boolean;
+  },
+): string {
   if (value === null) {
-    return 'None';
+    return "None";
   }
-  
+
   const { compact = false, showSymbol = true } = options ?? {};
-  const symbol = showSymbol ? '$' : '';
-  
+  const symbol = showSymbol ? "$" : "";
+
   if (compact) {
     if (value >= 1000) return `${symbol}${(value / 1000).toFixed(1)}k`;
     if (value >= 100) return `${symbol}${Math.round(value)}`;
     if (value >= 10) return `${symbol}${value.toFixed(1)}`;
     return `${symbol}${value.toFixed(2)}`;
   }
-  
-  return `${symbol}${value.toLocaleString('en-US', { 
-    minimumFractionDigits: 2, 
-    maximumFractionDigits: 2 
+
+  return `${symbol}${value.toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
   })}`;
 }
 
 export function formatBudgetDisplay(value: number | null): string {
   if (value === null) {
-    return 'None';
+    return "None";
   }
   return formatCurrency(value);
 }
 
 export function isValidCurrencyInput(input: string): boolean {
-  if (input.trim() === '') return true;
+  if (input.trim() === "") return true;
   return parseCurrencyInput(input) !== null;
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = '0.2.2'; // x-release-please-version
+export const VERSION = "0.4.0"; // x-release-please-version