From 79c688f14c08f2b0d4ffce0d88b5e31952fa6a44 Mon Sep 17 00:00:00 2001 From: Eric Engberg Date: Thu, 5 Nov 2026 17:31:45 -0600 Subject: [PATCH] refactor(widgets): consolidate the progress-bar widgets' duplicated code - Shared bar rendering: Block Timer, Block Reset Timer, Weekly Reset Timer, Extra Usage Utilization and the usage-percent widgets each built their bars with the same blocks. formatUsageBar in usage-display.ts now builds every bar mode (block, line and slider, with or without the percentage) in one place and returns null outside them, so each widget only adds its label. The time cursor is still resolved only in bar modes. - One class for the usage-percent widgets: Block, Weekly, Weekly Sonnet, Weekly Opus and Fable Weekly Usage were identical apart from their kind. UsagePercentWidget holds the class once and each widget names its kind. Spend Limit Usage extends it too and keeps only its color; the class takes the time cursor and the API-error state from the kind. - A shared base for the Context % widgets: Context % and Context % (usable) differed only in name, color, description, label prefix, preview sample and how they measure the used share. ContextPercentageWidgetBase holds the rest. No change in behavior. --- src/widgets/BlockResetTimer.ts | 39 ++------ src/widgets/BlockTimer.ts | 55 +++-------- src/widgets/ContextPercentage.ts | 83 ++--------------- src/widgets/ContextPercentageUsable.ts | 90 ++---------------- src/widgets/ExtraUsageUtilization.ts | 31 ++----- src/widgets/FableWeeklyUsage.ts | 55 +---------- src/widgets/SessionUsage.ts | 46 ++-------- src/widgets/SpendLimitUsage.ts | 47 +--------- src/widgets/WeeklyOpusUsage.ts | 55 +---------- src/widgets/WeeklyResetTimer.ts | 39 ++------ src/widgets/WeeklySonnetUsage.ts | 55 +---------- src/widgets/WeeklyUsage.ts | 55 +---------- src/widgets/__tests__/SpendLimitUsage.test.ts | 5 + .../shared/__tests__/usage-bar.test.ts | 33 +++++++ .../shared/context-percentage-widget-base.ts | 91 +++++++++++++++++++ src/widgets/shared/usage-display.ts | 22 +++++ src/widgets/shared/usage-percent-widget.ts | 77 +++++++++++----- 17 files changed, 284 insertions(+), 594 deletions(-) create mode 100644 src/widgets/shared/__tests__/usage-bar.test.ts create mode 100644 src/widgets/shared/context-percentage-widget-base.ts diff --git a/src/widgets/BlockResetTimer.ts b/src/widgets/BlockResetTimer.ts index a89fb5669..f43fc54b1 100644 --- a/src/widgets/BlockResetTimer.ts +++ b/src/widgets/BlockResetTimer.ts @@ -10,10 +10,7 @@ import type { WidgetEditorProps, WidgetItem } from '../types/Widget'; -import { - formatPercent, - resolveNumberFormat -} from '../utils/number-format'; +import { resolveNumberFormat } from '../utils/number-format'; import { formatUsageDuration, formatUsageResetAt, @@ -35,6 +32,7 @@ import { SESSION_UNDER_LIMIT_HIDEABLE_STATE, USAGE_NO_DATA_HIDEABLE_STATE, cycleUsageDisplayMode, + formatUsageBar, getUsageDisplayMode, getUsageDisplayModifierText, getUsageLocale, @@ -47,8 +45,6 @@ import { isUsageInverted, isUsageProgressMode, isUsageSliderMode, - makeSliderBar, - renderUsageProgressBar, toggleUsageCompact, toggleUsageDateMode, toggleUsageHourFormat, @@ -107,7 +103,6 @@ export class BlockResetTimerWidget implements Widget { } render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const displayMode = getUsageDisplayMode(item); const inverted = isUsageInverted(item); const compact = isUsageCompact(item); const dateMode = isUsageDateMode(item); @@ -116,17 +111,9 @@ export class BlockResetTimerWidget implements Widget { if (context.isPreview) { const previewPercent = inverted ? 90.0 : 10.0; - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(previewPercent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(previewPercent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(previewPercent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, previewPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } if (dateMode) { @@ -162,19 +149,9 @@ export class BlockResetTimerWidget implements Widget { return formatRawOrLabeledValue(item, this.getLabelPrefix(item), USAGE_TIMER_LOADING_MESSAGE); } - if (isUsageProgressMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = renderUsageProgressBar(percent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const slider = makeSliderBar(percent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(percent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, inverted ? window.remainingPercent : window.elapsedPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } if (dateMode) { diff --git a/src/widgets/BlockTimer.ts b/src/widgets/BlockTimer.ts index ee99726d7..5709dd6b3 100644 --- a/src/widgets/BlockTimer.ts +++ b/src/widgets/BlockTimer.ts @@ -7,10 +7,7 @@ import type { WidgetEditorDisplay, WidgetItem } from '../types/Widget'; -import { - formatPercent, - resolveNumberFormat -} from '../utils/number-format'; +import { resolveNumberFormat } from '../utils/number-format'; import { formatUsageDuration, resolveUsageWindowWithFallback @@ -20,6 +17,7 @@ import { isHidden } from './shared/hideable'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { cycleUsageDisplayMode, + formatUsageBar, getUsageDisplayMode, getUsageDisplayModifierText, getUsageTimerCustomKeybinds, @@ -27,8 +25,6 @@ import { isUsageInverted, isUsageProgressMode, isUsageSliderMode, - makeSliderBar, - renderUsageProgressBar, toggleUsageCompact, toggleUsageInverted } from './shared/usage-display'; @@ -72,7 +68,6 @@ export class BlockTimerWidget implements Widget { } render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const displayMode = getUsageDisplayMode(item); const inverted = isUsageInverted(item); const compact = isUsageCompact(item); const format = resolveNumberFormat('percent', item, settings); @@ -80,17 +75,9 @@ export class BlockTimerWidget implements Widget { if (context.isPreview) { const previewPercent = inverted ? 26.1 : 73.9; - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(previewPercent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(previewPercent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(previewPercent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, previewPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } return formatRawOrLabeledValue(item, this.getLabelPrefix(item), compact ? '3h45m' : '3hr 45m'); @@ -103,37 +90,17 @@ export class BlockTimerWidget implements Widget { if (isHidden(item, NO_DATA_HIDEABLE_STATE.key)) { return null; } - - const emptyPercent = formatPercent(0, format); - if (isUsageProgressMode(displayMode)) { - const emptyBar = renderUsageProgressBar(0, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${emptyBar} ${emptyPercent}`); - } - - if (isUsageSliderMode(displayMode)) { - const emptySlider = makeSliderBar(0); - const sliderDisplay = displayMode === 'slider' - ? `${emptySlider} ${emptyPercent}` - : emptySlider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, 0, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } return formatRawOrLabeledValue(item, this.getLabelPrefix(item), compact ? '0h' : '0hr 0m'); } - if (isUsageProgressMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = renderUsageProgressBar(percent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const slider = makeSliderBar(percent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(percent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, inverted ? window.remainingPercent : window.elapsedPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } const elapsedTime = formatUsageDuration(window.elapsedMs, compact); diff --git a/src/widgets/ContextPercentage.ts b/src/widgets/ContextPercentage.ts index e21b83702..27b49e1b3 100644 --- a/src/widgets/ContextPercentage.ts +++ b/src/widgets/ContextPercentage.ts @@ -1,86 +1,17 @@ import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; import { calculateContextPercentageMetrics } from '../utils/context-percentage'; -import { - formatPercent, - resolveNumberFormat -} from '../utils/number-format'; -import { - getContextInverseModifierText, - handleContextInverseAction, - isContextInverse -} from './shared/context-inverse'; -import { - cycleContextSliderMode, - getContextSliderKeybinds, - getContextSliderMode, - getContextSliderModifierText, - renderContextSlider -} from './shared/context-slider'; -import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; +import { ContextPercentageWidgetBase } from './shared/context-percentage-widget-base'; + +export class ContextPercentageWidget extends ContextPercentageWidgetBase { + protected readonly labelPrefix = 'Ctx'; + protected readonly previewUsedPercent = 9.3; -export class ContextPercentageWidget implements Widget { getDefaultColor(): string { return 'blue'; } getDescription(): string { return 'Shows percentage of context window used or remaining'; } getDisplayName(): string { return 'Context %'; } - getCategory(): string { return 'Context'; } - getLabelPrefix(item: WidgetItem): string { return isContextInverse(item) ? 'Ctx Left: ' : 'Ctx Used: '; } - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - const modifiers = [ - getContextInverseModifierText(item), - getContextSliderModifierText(item) - ].filter((m): m is string => m !== undefined); - return { - displayText: this.getDisplayName(), - modifierText: modifiers.length > 0 ? `(${modifiers.map(m => m.replace(/^\(|\)$/g, '')).join(', ')})` : undefined - }; - } - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - if (action === 'toggle-slider') { - return cycleContextSliderMode(item); - } - return handleContextInverseAction(action, item); + protected getUsedPercentage(context: RenderContext): number | null { + return calculateContextPercentageMetrics(context)?.usedPercentage ?? null; } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const isInverse = isContextInverse(item); - const sliderMode = getContextSliderMode(item); - const contextPercentageMetrics = calculateContextPercentageMetrics(context); - const format = resolveNumberFormat('percent', item, settings); - - const formatContextPercentage = (displayPercentage: number): string => { - const sliderResult = renderContextSlider(sliderMode, displayPercentage, format); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderResult ?? formatPercent(displayPercentage, format)); - }; - - if (context.isPreview) { - return formatContextPercentage(isInverse ? 90.7 : 9.3); - } - - if (contextPercentageMetrics !== null) { - const displayPercentage = isInverse ? (100 - contextPercentageMetrics.usedPercentage) : contextPercentageMetrics.usedPercentage; - return formatContextPercentage(displayPercentage); - } - - return null; - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return [ - { key: 'u', label: '(u)sed/remaining', action: 'toggle-inverse' }, - ...getContextSliderKeybinds() - ]; - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/ContextPercentageUsable.ts b/src/widgets/ContextPercentageUsable.ts index 8a9c05103..594ab1610 100644 --- a/src/widgets/ContextPercentageUsable.ts +++ b/src/widgets/ContextPercentageUsable.ts @@ -1,11 +1,4 @@ import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; import { getAutoCompactConfig, resolveClaudeConfigCwd @@ -15,90 +8,23 @@ import { getContextConfig, getModelContextIdentifier } from '../utils/model-context'; -import { - formatPercent, - resolveNumberFormat -} from '../utils/number-format'; -import { - getContextInverseModifierText, - handleContextInverseAction, - isContextInverse -} from './shared/context-inverse'; -import { - cycleContextSliderMode, - getContextSliderKeybinds, - getContextSliderMode, - getContextSliderModifierText, - renderContextSlider -} from './shared/context-slider'; -import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; +import { ContextPercentageWidgetBase } from './shared/context-percentage-widget-base'; + +export class ContextPercentageUsableWidget extends ContextPercentageWidgetBase { + protected readonly labelPrefix = 'Ctx(u)'; + protected readonly previewUsedPercent = 11.6; -export class ContextPercentageUsableWidget implements Widget { getDefaultColor(): string { return 'green'; } getDescription(): string { return 'Shows used or remaining context against an estimated compaction budget.\nHonors Claude Code compaction settings and environment overrides; defaults to an 80% estimate.'; } getDisplayName(): string { return 'Context % (usable)'; } - getCategory(): string { return 'Context'; } - getLabelPrefix(item: WidgetItem): string { return isContextInverse(item) ? 'Ctx(u) Left: ' : 'Ctx(u) Used: '; } - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - const modifiers = [ - getContextInverseModifierText(item), - getContextSliderModifierText(item) - ].filter((m): m is string => m !== undefined); - return { - displayText: this.getDisplayName(), - modifierText: modifiers.length > 0 ? `(${modifiers.map(m => m.replace(/^\(|\)$/g, '')).join(', ')})` : undefined - }; - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - if (action === 'toggle-slider') { - return cycleContextSliderMode(item); - } - return handleContextInverseAction(action, item); - } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const isInverse = isContextInverse(item); - const sliderMode = getContextSliderMode(item); - const format = resolveNumberFormat('percent', item, settings); - - const formatContextPercentage = (displayPercentage: number): string => { - const sliderResult = renderContextSlider(sliderMode, displayPercentage, format); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderResult ?? formatPercent(displayPercentage, format)); - }; - - if (context.isPreview) { - return formatContextPercentage(isInverse ? 88.4 : 11.6); - } + protected getUsedPercentage(context: RenderContext): number | null { const modelIdentifier = getModelContextIdentifier(context.data?.model); const contextWindowMetrics = getContextWindowMetrics(context.data); const autoCompact = getAutoCompactConfig(resolveClaudeConfigCwd(context)); const contextConfig = getContextConfig(modelIdentifier, contextWindowMetrics.windowSize, autoCompact); - - if (contextWindowMetrics.contextLengthTokens !== null) { - const usedPercentage = Math.min(100, (contextWindowMetrics.contextLengthTokens / contextConfig.usableTokens) * 100); - const displayPercentage = isInverse ? (100 - usedPercentage) : usedPercentage; - return formatContextPercentage(displayPercentage); - } - - if (context.tokenMetrics) { - const usedPercentage = Math.min(100, (context.tokenMetrics.contextLength / contextConfig.usableTokens) * 100); - const displayPercentage = isInverse ? (100 - usedPercentage) : usedPercentage; - return formatContextPercentage(displayPercentage); - } - return null; + const contextLength = contextWindowMetrics.contextLengthTokens ?? context.tokenMetrics?.contextLength ?? null; + return contextLength === null ? null : Math.min(100, (contextLength / contextConfig.usableTokens) * 100); } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return [ - { key: 'u', label: '(u)sed/remaining', action: 'toggle-inverse' }, - ...getContextSliderKeybinds() - ]; - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/ExtraUsageUtilization.ts b/src/widgets/ExtraUsageUtilization.ts index 4327ccfdc..02b575510 100644 --- a/src/widgets/ExtraUsageUtilization.ts +++ b/src/widgets/ExtraUsageUtilization.ts @@ -22,14 +22,10 @@ import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { USAGE_NO_DATA_HIDEABLE_STATE, cycleUsageDisplayMode, - getUsageDisplayMode, + formatUsageBar, getUsageDisplayModifierText, getUsagePercentCustomKeybinds, isUsageInverted, - isUsageProgressMode, - isUsageSliderMode, - makeSliderBar, - renderUsageProgressBar, toggleUsageInverted } from './shared/usage-display'; @@ -77,7 +73,6 @@ export class ExtraUsageUtilizationWidget implements Widget { } render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const displayMode = getUsageDisplayMode(item); const inverted = isUsageInverted(item); const format = resolveNumberFormat('percent', item, settings); @@ -85,15 +80,9 @@ export class ExtraUsageUtilizationWidget implements Widget { const previewPercent = 2.6; const renderedPercent = inverted ? 100 - previewPercent : previewPercent; - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(renderedPercent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(), `${progressBar} ${formatPercent(renderedPercent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(renderedPercent); - const sliderDisplay = displayMode === 'slider' ? `${slider} ${formatPercent(renderedPercent, format)}` : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(), sliderDisplay); + const bar = formatUsageBar(item, renderedPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(), bar); } return formatRawOrLabeledValue(item, this.getLabelPrefix(), formatPercent(renderedPercent, format)); @@ -119,15 +108,9 @@ export class ExtraUsageUtilizationWidget implements Widget { const percent = Math.max(0, Math.min(100, utilization)); const renderedPercent = inverted ? 100 - percent : percent; - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(renderedPercent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(), `${progressBar} ${formatPercent(renderedPercent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(renderedPercent); - const sliderDisplay = displayMode === 'slider' ? `${slider} ${formatPercent(renderedPercent, format)}` : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(), sliderDisplay); + const bar = formatUsageBar(item, renderedPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(), bar); } return formatRawOrLabeledValue(item, this.getLabelPrefix(), formatPercent(renderedPercent, format)); diff --git a/src/widgets/FableWeeklyUsage.ts b/src/widgets/FableWeeklyUsage.ts index 6bc331635..152c43677 100644 --- a/src/widgets/FableWeeklyUsage.ts +++ b/src/widgets/FableWeeklyUsage.ts @@ -1,54 +1,7 @@ -import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - HideableState, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; +import { UsagePercentWidget } from './shared/usage-percent-widget'; -import { - USAGE_NO_DATA_HIDEABLE_STATE, - getUsagePercentCustomKeybinds -} from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class FableWeeklyUsageWidget implements Widget { - getDefaultColor(): string { return 'brightBlue'; } - getDescription(): string { return getUsagePercentWidgetDescription('fable-weekly'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('fable-weekly'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('fable-weekly'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('fable-weekly', item); - } - - getHideableStates(): HideableState[] { - return [USAGE_NO_DATA_HIDEABLE_STATE]; - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); +export class FableWeeklyUsageWidget extends UsagePercentWidget { + constructor() { + super('fable-weekly'); } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - return renderUsagePercentWidgetValue('fable-weekly', item, context, settings); - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item); - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/SessionUsage.ts b/src/widgets/SessionUsage.ts index 5662a77f1..d0953f116 100644 --- a/src/widgets/SessionUsage.ts +++ b/src/widgets/SessionUsage.ts @@ -1,61 +1,31 @@ import type { RenderContext } from '../types/RenderContext'; import type { Settings } from '../types/Settings'; import type { - CustomKeybind, HideableState, - Widget, - WidgetEditorDisplay, WidgetItem } from '../types/Widget'; import { isHidden } from './shared/hideable'; import { SESSION_AT_LIMIT_HIDEABLE_STATE, - USAGE_NO_DATA_HIDEABLE_STATE, - getUsagePercentCustomKeybinds, isAtSessionLimit } from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class SessionUsageWidget implements Widget { - getDefaultColor(): string { return 'brightBlue'; } - getDescription(): string { return getUsagePercentWidgetDescription('session'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('session'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('session'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('session', item); - } +import { UsagePercentWidget } from './shared/usage-percent-widget'; - getHideableStates(): HideableState[] { - return [USAGE_NO_DATA_HIDEABLE_STATE, SESSION_AT_LIMIT_HIDEABLE_STATE]; +export class SessionUsageWidget extends UsagePercentWidget { + constructor() { + super('session'); } - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); + override getHideableStates(): HideableState[] { + return [...super.getHideableStates(), SESSION_AT_LIMIT_HIDEABLE_STATE]; } - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { + override render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { // The preview keeps its sample if (!context.isPreview && isHidden(item, SESSION_AT_LIMIT_HIDEABLE_STATE.key) && isAtSessionLimit(context)) { return null; } - return renderUsagePercentWidgetValue('session', item, context, settings); + return super.render(item, context, settings); } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item); - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/SpendLimitUsage.ts b/src/widgets/SpendLimitUsage.ts index 3b80e93aa..df4b13987 100644 --- a/src/widgets/SpendLimitUsage.ts +++ b/src/widgets/SpendLimitUsage.ts @@ -1,46 +1,9 @@ -import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; +import { UsagePercentWidget } from './shared/usage-percent-widget'; -import { getUsagePercentCustomKeybinds } from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class SpendLimitUsageWidget implements Widget { - getDefaultColor(): string { return 'brightMagenta'; } - getDescription(): string { return getUsagePercentWidgetDescription('spend-limit'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('spend-limit'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('spend-limit'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('spend-limit', item); - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); - } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - return renderUsagePercentWidgetValue('spend-limit', item, context, settings); - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item, false); +export class SpendLimitUsageWidget extends UsagePercentWidget { + constructor() { + super('spend-limit'); } - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } + override getDefaultColor(): string { return 'brightMagenta'; } } diff --git a/src/widgets/WeeklyOpusUsage.ts b/src/widgets/WeeklyOpusUsage.ts index 5c5fca343..52e68d8bd 100644 --- a/src/widgets/WeeklyOpusUsage.ts +++ b/src/widgets/WeeklyOpusUsage.ts @@ -1,54 +1,7 @@ -import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - HideableState, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; +import { UsagePercentWidget } from './shared/usage-percent-widget'; -import { - USAGE_NO_DATA_HIDEABLE_STATE, - getUsagePercentCustomKeybinds -} from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class WeeklyOpusUsageWidget implements Widget { - getDefaultColor(): string { return 'brightBlue'; } - getDescription(): string { return getUsagePercentWidgetDescription('weekly-opus'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('weekly-opus'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('weekly-opus'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('weekly-opus', item); - } - - getHideableStates(): HideableState[] { - return [USAGE_NO_DATA_HIDEABLE_STATE]; - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); +export class WeeklyOpusUsageWidget extends UsagePercentWidget { + constructor() { + super('weekly-opus'); } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - return renderUsagePercentWidgetValue('weekly-opus', item, context, settings); - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item); - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/WeeklyResetTimer.ts b/src/widgets/WeeklyResetTimer.ts index 78611066a..1bbccb465 100644 --- a/src/widgets/WeeklyResetTimer.ts +++ b/src/widgets/WeeklyResetTimer.ts @@ -10,10 +10,7 @@ import type { WidgetEditorProps, WidgetItem } from '../types/Widget'; -import { - formatPercent, - resolveNumberFormat -} from '../utils/number-format'; +import { resolveNumberFormat } from '../utils/number-format'; import { formatUsageDuration, formatUsageResetAt, @@ -39,6 +36,7 @@ import { import { USAGE_NO_DATA_HIDEABLE_STATE, cycleUsageDisplayMode, + formatUsageBar, getUsageDisplayMode, getUsageLocale, getUsageLocaleModifier, @@ -52,8 +50,6 @@ import { isUsageProgressMode, isUsageSliderMode, isUsageWeekdayEnabled, - makeSliderBar, - renderUsageProgressBar, toggleUsageCompact, toggleUsageDateMode, toggleUsageHourFormat, @@ -185,7 +181,6 @@ export class WeeklyResetTimerWidget implements Widget { } render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - const displayMode = getUsageDisplayMode(item); const inverted = isUsageInverted(item); const compact = isUsageCompact(item); const dateMode = isUsageDateMode(item); @@ -195,17 +190,9 @@ export class WeeklyResetTimerWidget implements Widget { if (context.isPreview) { const previewPercent = inverted ? 90.0 : 10.0; - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(previewPercent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(previewPercent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(previewPercent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, previewPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } if (dateMode) { @@ -242,19 +229,9 @@ export class WeeklyResetTimerWidget implements Widget { return formatRawOrLabeledValue(item, this.getLabelPrefix(item), USAGE_TIMER_LOADING_MESSAGE); } - if (isUsageProgressMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = renderUsageProgressBar(percent, displayMode); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); - } - - if (isUsageSliderMode(displayMode)) { - const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const slider = makeSliderBar(percent); - const sliderDisplay = displayMode === 'slider' - ? `${slider} ${formatPercent(percent, format)}` - : slider; - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderDisplay); + const bar = formatUsageBar(item, inverted ? window.remainingPercent : window.elapsedPercent, format); + if (bar !== null) { + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), bar); } if (dateMode) { diff --git a/src/widgets/WeeklySonnetUsage.ts b/src/widgets/WeeklySonnetUsage.ts index d16406183..5301e8d75 100644 --- a/src/widgets/WeeklySonnetUsage.ts +++ b/src/widgets/WeeklySonnetUsage.ts @@ -1,54 +1,7 @@ -import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - HideableState, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; +import { UsagePercentWidget } from './shared/usage-percent-widget'; -import { - USAGE_NO_DATA_HIDEABLE_STATE, - getUsagePercentCustomKeybinds -} from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class WeeklySonnetUsageWidget implements Widget { - getDefaultColor(): string { return 'brightBlue'; } - getDescription(): string { return getUsagePercentWidgetDescription('weekly-sonnet'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('weekly-sonnet'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('weekly-sonnet'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('weekly-sonnet', item); - } - - getHideableStates(): HideableState[] { - return [USAGE_NO_DATA_HIDEABLE_STATE]; - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); +export class WeeklySonnetUsageWidget extends UsagePercentWidget { + constructor() { + super('weekly-sonnet'); } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - return renderUsagePercentWidgetValue('weekly-sonnet', item, context, settings); - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item); - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/WeeklyUsage.ts b/src/widgets/WeeklyUsage.ts index 7e08d5360..39f25620c 100644 --- a/src/widgets/WeeklyUsage.ts +++ b/src/widgets/WeeklyUsage.ts @@ -1,54 +1,7 @@ -import type { RenderContext } from '../types/RenderContext'; -import type { Settings } from '../types/Settings'; -import type { - CustomKeybind, - HideableState, - Widget, - WidgetEditorDisplay, - WidgetItem -} from '../types/Widget'; +import { UsagePercentWidget } from './shared/usage-percent-widget'; -import { - USAGE_NO_DATA_HIDEABLE_STATE, - getUsagePercentCustomKeybinds -} from './shared/usage-display'; -import { - getUsagePercentWidgetDescription, - getUsagePercentWidgetDisplayName, - getUsagePercentWidgetEditorDisplay, - getUsagePercentWidgetLabel, - handleUsagePercentWidgetEditorAction, - renderUsagePercentWidgetValue -} from './shared/usage-percent-widget'; - -export class WeeklyUsageWidget implements Widget { - getDefaultColor(): string { return 'brightBlue'; } - getDescription(): string { return getUsagePercentWidgetDescription('weekly'); } - getDisplayName(): string { return getUsagePercentWidgetDisplayName('weekly'); } - getCategory(): string { return 'Usage'; } - getLabelPrefix(): string { return getUsagePercentWidgetLabel('weekly'); } - - getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { - return getUsagePercentWidgetEditorDisplay('weekly', item); - } - - getHideableStates(): HideableState[] { - return [USAGE_NO_DATA_HIDEABLE_STATE]; - } - - handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { - return handleUsagePercentWidgetEditorAction(action, item); +export class WeeklyUsageWidget extends UsagePercentWidget { + constructor() { + super('weekly'); } - - render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { - return renderUsagePercentWidgetValue('weekly', item, context, settings); - } - - getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { - return getUsagePercentCustomKeybinds(item); - } - - supportsRawValue(): boolean { return true; } - supportsColors(item: WidgetItem): boolean { return true; } - supportsNumberFormat(): boolean { return true; } } diff --git a/src/widgets/__tests__/SpendLimitUsage.test.ts b/src/widgets/__tests__/SpendLimitUsage.test.ts index 65dcead80..2bfb42c3c 100644 --- a/src/widgets/__tests__/SpendLimitUsage.test.ts +++ b/src/widgets/__tests__/SpendLimitUsage.test.ts @@ -28,6 +28,7 @@ describe('SpendLimitUsageWidget', () => { const widget = new SpendLimitUsageWidget(); expect(widget.getDisplayName()).toBe('Spend Limit Usage'); + expect(widget.getDefaultColor()).toBe('brightMagenta'); expect(widget.getCategory()).toBe('Usage'); expect(widget.getLabelPrefix()).toBe('Spend Limit: '); expect(widget.supportsRawValue()).toBe(true); @@ -79,4 +80,8 @@ describe('SpendLimitUsageWidget', () => { expect(keybinds.map(keybind => keybind.action)).toEqual(['toggle-progress', 'toggle-invert']); }); + + it('offers no state to hide, because it never shows a usage API error', () => { + expect(new SpendLimitUsageWidget().getHideableStates()).toEqual([]); + }); }); diff --git a/src/widgets/shared/__tests__/usage-bar.test.ts b/src/widgets/shared/__tests__/usage-bar.test.ts new file mode 100644 index 000000000..369a8a5b7 --- /dev/null +++ b/src/widgets/shared/__tests__/usage-bar.test.ts @@ -0,0 +1,33 @@ +import { + describe, + expect, + it +} from 'vitest'; + +import type { WidgetItem } from '../../../types/Widget'; +import { formatUsageBar } from '../usage-display'; + +const item = (display?: string): WidgetItem => ({ id: 'u', type: 'session-usage', metadata: display ? { display } : undefined }); + +describe('formatUsageBar', () => { + it('formats each bar mode with its width and the percentage', () => { + expect(formatUsageBar(item('progress'), 50, {})).toBe(`[${'█'.repeat(16)}${'░'.repeat(16)}] 50.0%`); + expect(formatUsageBar(item('progress-short'), 50, {})).toBe(`[${'█'.repeat(8)}${'░'.repeat(8)}] 50.0%`); + expect(formatUsageBar(item('slider'), 50, {})).toBe(`${'▓'.repeat(5)}${'░'.repeat(5)} 50.0%`); + expect(formatUsageBar(item('slider-only'), 50, {})).toBe(`${'▓'.repeat(5)}${'░'.repeat(5)}`); + expect(formatUsageBar(item('line'), 50, {})).toBe(`${'━'.repeat(8)}${'─'.repeat(8)} 50.0%`); + }); + + it('returns null outside the bar modes, without asking for the cursor', () => { + let asked = false; + expect(formatUsageBar(item(), 50, {}, () => { + asked = true; + return { cursorPercent: 10 }; + })).toBeNull(); + expect(asked).toBe(false); + }); + + it('draws the time cursor when given one', () => { + expect(formatUsageBar(item('slider-only'), 50, {}, () => ({ cursorPercent: 90 }))).toBe(`${'▓'.repeat(5)}${'░'.repeat(4)}│`); + }); +}); diff --git a/src/widgets/shared/context-percentage-widget-base.ts b/src/widgets/shared/context-percentage-widget-base.ts new file mode 100644 index 000000000..5abb748b0 --- /dev/null +++ b/src/widgets/shared/context-percentage-widget-base.ts @@ -0,0 +1,91 @@ +import type { RenderContext } from '../../types/RenderContext'; +import type { Settings } from '../../types/Settings'; +import type { + CustomKeybind, + Widget, + WidgetEditorDisplay, + WidgetItem +} from '../../types/Widget'; +import { + formatPercent, + resolveNumberFormat +} from '../../utils/number-format'; + +import { + getContextInverseModifierText, + handleContextInverseAction, + isContextInverse +} from './context-inverse'; +import { + cycleContextSliderMode, + getContextSliderKeybinds, + getContextSliderMode, + getContextSliderModifierText, + renderContextSlider +} from './context-slider'; +import { formatRawOrLabeledValue } from './raw-or-labeled'; + +// Context % and Context % (usable) differ only in their name, color, label, preview +// sample and how they measure the used share of the context window +export abstract class ContextPercentageWidgetBase implements Widget { + abstract getDefaultColor(): string; + abstract getDescription(): string; + abstract getDisplayName(): string; + + // Shown before "Used: " or "Left: ", e.g. "Ctx" + protected abstract readonly labelPrefix: string; + // The used percentage the TUI preview shows + protected abstract readonly previewUsedPercent: number; + // The used percentage, or null without the data to measure it + protected abstract getUsedPercentage(context: RenderContext): number | null; + + getCategory(): string { return 'Context'; } + + // "Ctx Used: " or "Ctx Left: ", by which way the widget counts + getLabelPrefix(item: WidgetItem): string { + return `${this.labelPrefix} ${isContextInverse(item) ? 'Left' : 'Used'}: `; + } + + getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { + const modifiers = [ + getContextInverseModifierText(item), + getContextSliderModifierText(item) + ].filter((m): m is string => m !== undefined); + + return { + displayText: this.getDisplayName(), + modifierText: modifiers.length > 0 ? `(${modifiers.map(m => m.replace(/^\(|\)$/g, '')).join(', ')})` : undefined + }; + } + + handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { + if (action === 'toggle-slider') { + return cycleContextSliderMode(item); + } + return handleContextInverseAction(action, item); + } + + render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { + const isInverse = isContextInverse(item); + const usedPercentage = context.isPreview ? this.previewUsedPercent : this.getUsedPercentage(context); + if (usedPercentage === null) { + return null; + } + + const displayPercentage = isInverse ? 100 - usedPercentage : usedPercentage; + const format = resolveNumberFormat('percent', item, settings); + const sliderResult = renderContextSlider(getContextSliderMode(item), displayPercentage, format); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), sliderResult ?? formatPercent(displayPercentage, format)); + } + + getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { + return [ + { key: 'u', label: '(u)sed/remaining', action: 'toggle-inverse' }, + ...getContextSliderKeybinds() + ]; + } + + supportsRawValue(): boolean { return true; } + supportsColors(item: WidgetItem): boolean { return true; } + supportsNumberFormat(): boolean { return true; } +} diff --git a/src/widgets/shared/usage-display.ts b/src/widgets/shared/usage-display.ts index 1f7c4ebe0..ab7b57c1e 100644 --- a/src/widgets/shared/usage-display.ts +++ b/src/widgets/shared/usage-display.ts @@ -1,3 +1,4 @@ +import type { NumberFormat } from '../../types/NumberFormat'; import type { RenderContext } from '../../types/RenderContext'; import type { CustomKeybind, @@ -8,6 +9,7 @@ import { DEFAULT_RESET_LOCALE, canonicalizeLocale } from '../../utils/locales'; +import { formatPercent } from '../../utils/number-format'; import { makeModifierText } from './editor-display'; import { @@ -77,6 +79,26 @@ export function isUsageSliderMode(mode: UsageDisplayMode): boolean { interface SliderBarOptions { cursorPercent?: number } +// The bar modes' text: "[████░░░░] 50.0%", "━━━━──── 50.0%", "▓▓▓▓░░░░ 50.0%" or +// "▓▓▓▓░░░░". Null in the other modes, without calling getCursor, which can be costly +// to resolve. +export function formatUsageBar( + item: WidgetItem, + percent: number, + format: NumberFormat, + getCursor: () => SliderBarOptions | undefined = () => undefined +): string | null { + const mode = getUsageDisplayMode(item); + if (isUsageProgressMode(mode)) { + return `${renderUsageProgressBar(percent, mode, getCursor())} ${formatPercent(percent, format)}`; + } + if (isUsageSliderMode(mode)) { + const slider = makeSliderBar(percent, undefined, getCursor()); + return mode === 'slider' ? `${slider} ${formatPercent(percent, format)}` : slider; + } + return null; +} + export function makeSliderBar(percent: number, width: number = SLIDER_WIDTH, options?: SliderBarOptions): string { const clamped = Math.max(0, Math.min(100, percent)); const filled = Math.round((clamped / 100) * width); diff --git a/src/widgets/shared/usage-percent-widget.ts b/src/widgets/shared/usage-percent-widget.ts index c05555bfd..501be440f 100644 --- a/src/widgets/shared/usage-percent-widget.ts +++ b/src/widgets/shared/usage-percent-widget.ts @@ -5,6 +5,9 @@ import type { } from '../../types/RenderContext'; import type { Settings } from '../../types/Settings'; import type { + CustomKeybind, + HideableState, + Widget, WidgetEditorDisplay, WidgetItem } from '../../types/Widget'; @@ -27,14 +30,11 @@ import { formatRawOrLabeledValue } from './raw-or-labeled'; import { USAGE_NO_DATA_HIDEABLE_STATE, cycleUsageDisplayMode, - getUsageDisplayMode, + formatUsageBar, getUsageDisplayModifierText, + getUsagePercentCustomKeybinds, isUsageCursorEnabled, isUsageInverted, - isUsageProgressMode, - isUsageSliderMode, - makeSliderBar, - renderUsageProgressBar, toggleUsageCursor, toggleUsageInverted } from './usage-display'; @@ -116,13 +116,18 @@ function resolveUsageWindow(kind: UsagePercentWidgetKind, data: RenderUsageData, if (kind === 'weekly-opus') { return resolveWeeklyOpusUsageWindow(data); } - if (kind === 'spend-limit') { - // The payload does not say how long the limit's period is, so there is no window to place a cursor in. + if (!hasUsageWindow(kind)) { return null; } return resolveFableUsageWindow(data); } +// The spend limit payload does not say how long the limit's period is, so there +// is no window to place a time cursor in. +function hasUsageWindow(kind: UsagePercentWidgetKind): boolean { + return kind !== 'spend-limit'; +} + function renderUsageDisplay( item: WidgetItem, label: string, @@ -130,21 +135,8 @@ function renderUsageDisplay( format: NumberFormat, getCursorOptions: () => UsageCursorOptions | undefined ): string { - const displayMode = getUsageDisplayMode(item); - - if (isUsageProgressMode(displayMode)) { - const progressBar = renderUsageProgressBar(percent, displayMode, getCursorOptions()); - const progressDisplay = `${progressBar} ${formatPercent(percent, format)}`; - return formatRawOrLabeledValue(item, label, progressDisplay); - } - - if (isUsageSliderMode(displayMode)) { - const slider = makeSliderBar(percent, undefined, getCursorOptions()); - const sliderDisplay = displayMode === 'slider' ? `${slider} ${formatPercent(percent, format)}` : slider; - return formatRawOrLabeledValue(item, label, sliderDisplay); - } - - return formatRawOrLabeledValue(item, label, formatPercent(percent, format)); + const bar = formatUsageBar(item, percent, format, getCursorOptions); + return formatRawOrLabeledValue(item, label, bar ?? formatPercent(percent, format)); } export function getUsagePercentWidgetDisplayName(kind: UsagePercentWidgetKind): string { @@ -226,3 +218,44 @@ export function renderUsagePercentWidgetValue( return { cursorPercent: inverted ? window.remainingPercent : window.elapsedPercent }; }); } + +// Session, Weekly, Weekly Sonnet, Weekly Opus and Fable Weekly Usage differ only +// in their kind +export class UsagePercentWidget implements Widget { + private readonly kind: UsagePercentWidgetKind; + + constructor(kind: UsagePercentWidgetKind) { + this.kind = kind; + } + + getDefaultColor(): string { return 'brightBlue'; } + getDescription(): string { return getUsagePercentWidgetDescription(this.kind); } + getDisplayName(): string { return getUsagePercentWidgetDisplayName(this.kind); } + getCategory(): string { return 'Usage'; } + getLabelPrefix(): string { return getUsagePercentWidgetLabel(this.kind); } + + getEditorDisplay(item: WidgetItem): WidgetEditorDisplay { + return getUsagePercentWidgetEditorDisplay(this.kind, item); + } + + // The state hides the usage API's error, which a widget that ignores API errors never shows + getHideableStates(): HideableState[] { + return USAGE_PERCENT_WIDGET_CONFIG[this.kind].ignoreApiError ? [] : [USAGE_NO_DATA_HIDEABLE_STATE]; + } + + handleEditorAction(action: string, item: WidgetItem): WidgetItem | null { + return handleUsagePercentWidgetEditorAction(action, item); + } + + render(item: WidgetItem, context: RenderContext, settings: Settings): string | null { + return renderUsagePercentWidgetValue(this.kind, item, context, settings); + } + + getCustomKeybinds(item?: WidgetItem): CustomKeybind[] { + return getUsagePercentCustomKeybinds(item, hasUsageWindow(this.kind)); + } + + supportsRawValue(): boolean { return true; } + supportsColors(item: WidgetItem): boolean { return true; } + supportsNumberFormat(): boolean { return true; } +}