pi-openai-usage 0.1.0

package/src/diagnostics-reporter.ts

@@ -0,0 +1,202 @@
+import type { CodexCredentialResolution } from "./auth";
+import type { LoadedUsageConfig } from "./config";
+import { USAGE_ENDPOINT, type UsageFetchError } from "./usage-client";
+import type { UsageStateStore } from "./usage-state";
+
+export type DiagnosticsRuntime = {
+  hasUI?: boolean;
+  model?: {
+    provider?: string;
+    id?: string;
+  };
+  signal?: {
+    aborted?: boolean;
+  };
+};
+
+export type DiagnosticsReportInput = {
+  loaded: LoadedUsageConfig;
+  credentials: CodexCredentialResolution;
+  usageState: UsageStateStore;
+  runtime?: DiagnosticsRuntime;
+  endpoint?: string;
+};
+
+export type RedactedDiagnosticValue =
+  | string
+  | number
+  | boolean
+  | null
+  | RedactedDiagnosticValue[]
+  | { [key: string]: RedactedDiagnosticValue };
+
+const REDACTED = "<redacted>";
+
+export function formatDiagnosticsReport(input: DiagnosticsReportInput): string {
+  return ["openai-usage diagnostics", ...formatDiagnosticsLines(input)].join("\n");
+}
+
+export function formatDiagnosticsLines(input: DiagnosticsReportInput): string[] {
+  const { loaded, credentials, usageState, runtime } = input;
+  const endpoint = input.endpoint ?? USAGE_ENDPOINT;
+
+  return [
+    "Diagnostics:",
+    `  Config path: ${loaded.configPath}`,
+    `  Project config path: ${loaded.projectConfigPath}`,
+    `  Global config path: ${loaded.globalConfigPath}`,
+    `  Project config exists: ${formatBooleanText(loaded.projectConfigExists)}`,
+    `  Global config exists: ${formatBooleanText(loaded.globalConfigExists)}`,
+    `  Endpoint: ${endpoint}`,
+    "  Runtime:",
+    `    UI available: ${formatBooleanText(runtime?.hasUI === true)}`,
+    `    Model provider: ${formatOptionalText(runtime?.model?.provider)}`,
+    `    Model ID: ${formatOptionalText(runtime?.model?.id)}`,
+    `    Signal aborted: ${formatBooleanText(runtime?.signal?.aborted === true)}`,
+    `  Last fetch: ${formatDateTime(usageState.getLastAttemptAt())}`,
+    `  Last success: ${formatDateTime(usageState.getLastSuccessAt())}`,
+    `  Last error: ${formatLastError(usageState.getLastError())}`,
+    `  Auth source: ${credentials.diagnostics.source}`,
+    `  Checked auth sources: ${credentials.diagnostics.checkedSources.join(", ") || "<none>"}`,
+    `  Has access token: ${formatBooleanText(credentials.diagnostics.hasAccessToken)}`,
+    `  Has account ID: ${formatBooleanText(credentials.diagnostics.hasAccountId)}`,
+    `  Account ID: ${credentials.diagnostics.accountId ?? "<redacted or missing>"}`,
+    ...formatCredentialDetails(credentials),
+    `  Effective enabled: ${formatBooleanText(loaded.effective.enabled)}`,
+    `  Effective refresh interval (ms): ${loaded.effective.refreshIntervalMs}`,
+    `  Config enabled: ${formatBooleanText(loaded.effective.enabled)}`,
+    `  Refresh interval (ms): ${loaded.effective.refreshIntervalMs}`,
+    ...formatJsonBlock("  Raw project config:", loaded.raw.project),
+    ...formatJsonBlock("  Raw global config:", loaded.raw.global),
+  ];
+}
+
+export function redactDiagnosticValue(
+  value: unknown,
+  keyPath: readonly string[] = [],
+): RedactedDiagnosticValue {
+  const key = keyPath.at(-1);
+  if (key !== undefined && isSensitiveKey(key)) {
+    return REDACTED;
+  }
+
+  if (value === null) return null;
+
+  if (typeof value === "string") {
+    return redactDiagnosticString(value);
+  }
+
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactDiagnosticValue(entry, keyPath));
+  }
+
+  if (isRecord(value)) {
+    const redacted: { [key: string]: RedactedDiagnosticValue } = {};
+    for (const [childKey, childValue] of Object.entries(value)) {
+      redacted[childKey] = redactDiagnosticValue(childValue, [...keyPath, childKey]);
+    }
+    return redacted;
+  }
+
+  return value === undefined ? null : String(value);
+}
+
+function formatCredentialDetails(credentials: CodexCredentialResolution): string[] {
+  if (!credentials.ok) {
+    return [`  Credential error: ${redactDiagnosticString(credentials.error.message)}`];
+  }
+
+  const redactedCredentials = credentials.toJSON().credentials;
+  return [
+    `  Credential source: ${redactedCredentials.source}`,
+    `  Credential account ID (redacted): ${redactedCredentials.accountId}`,
+  ];
+}
+
+function formatJsonBlock(label: string, value: Record<string, unknown>): string[] {
+  const redacted = redactDiagnosticValue(value);
+  const serialized = JSON.stringify(redacted, null, 2) ?? "null";
+  return [label, ...serialized.split("\n").map((line) => `  ${line}`)];
+}
+
+function formatDateTime(value: Date | undefined): string {
+  return value === undefined ? "<none>" : value.toISOString();
+}
+
+function formatLastError(error: UsageFetchError | undefined): string {
+  if (error === undefined) return "<none>";
+  const message = redactDiagnosticString(error.message);
+  if (error.status === undefined) {
+    return `${error.kind}: ${message}`;
+  }
+  return `${error.kind} (${error.status}): ${message}`;
+}
+
+function formatBooleanText(value: boolean): string {
+  return value ? "yes" : "no";
+}
+
+function formatOptionalText(value: string | undefined): string {
+  return value === undefined || value.trim().length === 0 ? "<none>" : redactDiagnosticString(value);
+}
+
+function redactDiagnosticString(value: string): string {
+  let redacted = value.replace(
+    /\bBearer\s+([A-Za-z0-9._~+/=-]+)/giu,
+    "Bearer <redacted>",
+  );
+
+  redacted = redacted.replace(
+    /\b(access[_ -]?token|refresh[_ -]?token|bearer[_ -]?token|api[_ -]?key|authorization|token)\b(\s*[:=]\s*)(["']?)([^"'\s,;]+)/giu,
+    (_match, label: string, separator: string, quote: string, _secret: string) =>
+      `${label}${separator}${quote}${REDACTED}${quote}`,
+  );
+
+  redacted = redacted.replace(/\bsk-[A-Za-z0-9_-]{8,}\b/giu, REDACTED);
+  redacted = redacted.replace(/\bgh[pousr]_[A-Za-z0-9_]{8,}\b/giu, REDACTED);
+  redacted = redacted.replace(
+    /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu,
+    REDACTED,
+  );
+  redacted = redacted.replace(
+    /\b[A-Za-z0-9_-]*(?:token|secret|api-key|apikey)[A-Za-z0-9_-]*\b/giu,
+    (match) => (match.length >= 8 ? REDACTED : match),
+  );
+
+  return isLikelyOpaqueToken(redacted) ? REDACTED : redacted;
+}
+
+function isSensitiveKey(key: string): boolean {
+  const normalized = key.toLowerCase().replace(/[^a-z0-9]/gu, "");
+  return (
+    normalized.includes("token") ||
+    normalized.includes("apikey") ||
+    normalized.includes("secret") ||
+    normalized.includes("password") ||
+    normalized.includes("credential") ||
+    normalized === "access" ||
+    normalized === "authorization" ||
+    normalized === "bearer" ||
+    normalized === "key" ||
+    normalized === "accountid"
+  );
+}
+
+function isLikelyOpaqueToken(value: string): boolean {
+  const trimmed = value.trim();
+  if (trimmed.length < 20) return false;
+  if (!/^[A-Za-z0-9._~+/=-]+$/u.test(trimmed)) return false;
+  return /[A-Za-z]/u.test(trimmed) && /\d/u.test(trimmed);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/display-width.ts

@@ -0,0 +1,83 @@
+const COMBINING_MARK_RANGES: ReadonlyArray<readonly [number, number]> = [
+  [0x0300, 0x036f],
+  [0x1ab0, 0x1aff],
+  [0x1dc0, 0x1dff],
+  [0x20d0, 0x20ff],
+  [0xfe20, 0xfe2f],
+];
+
+const WIDE_CHARACTER_RANGES: ReadonlyArray<readonly [number, number]> = [
+  [0x1100, 0x115f],
+  [0x231a, 0x231b],
+  [0x2329, 0x232a],
+  [0x23e9, 0x23ec],
+  [0x23f0, 0x23f0],
+  [0x23f3, 0x23f3],
+  [0x25fd, 0x25fe],
+  [0x2614, 0x2615],
+  [0x2648, 0x2653],
+  [0x267f, 0x267f],
+  [0x2693, 0x2693],
+  [0x26a1, 0x26a1],
+  [0x26aa, 0x26ab],
+  [0x26bd, 0x26be],
+  [0x26c4, 0x26c5],
+  [0x26ce, 0x26ce],
+  [0x26d4, 0x26d4],
+  [0x26ea, 0x26ea],
+  [0x26f2, 0x26f3],
+  [0x26f5, 0x26f5],
+  [0x26fa, 0x26fa],
+  [0x26fd, 0x26fd],
+  [0x2705, 0x2705],
+  [0x270a, 0x270b],
+  [0x2728, 0x2728],
+  [0x274c, 0x274c],
+  [0x274e, 0x274e],
+  [0x2753, 0x2755],
+  [0x2757, 0x2757],
+  [0x2795, 0x2797],
+  [0x27b0, 0x27b0],
+  [0x27bf, 0x27bf],
+  [0x2b1b, 0x2b1c],
+  [0x2b50, 0x2b50],
+  [0x2b55, 0x2b55],
+  [0x2e80, 0xa4cf],
+  [0xac00, 0xd7a3],
+  [0xf900, 0xfaff],
+  [0xfe10, 0xfe19],
+  [0xfe30, 0xfe6f],
+  [0xff00, 0xff60],
+  [0xffe0, 0xffe6],
+  [0x1f300, 0x1f64f],
+  [0x1f680, 0x1f6ff],
+  [0x1f900, 0x1f9ff],
+  [0x20000, 0x3fffd],
+];
+
+export function visibleCellWidth(text: string): number {
+  let width = 0;
+  for (const char of text) {
+    width += codePointCellWidth(char.codePointAt(0) ?? 0);
+  }
+  return width;
+}
+
+export function isSingleCellGlyph(text: string): boolean {
+  return Array.from(text).length === 1 && visibleCellWidth(text) === 1;
+}
+
+function codePointCellWidth(codePoint: number): number {
+  if (codePoint === 0) return 0;
+  if (codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0)) return 0;
+  if (isInRanges(codePoint, COMBINING_MARK_RANGES)) return 0;
+  if (isInRanges(codePoint, WIDE_CHARACTER_RANGES)) return 2;
+  return 1;
+}
+
+function isInRanges(
+  codePoint: number,
+  ranges: ReadonlyArray<readonly [number, number]>,
+): boolean {
+  return ranges.some(([start, end]) => codePoint >= start && codePoint <= end);
+}

package/src/format.ts

@@ -0,0 +1,356 @@
+import type {
+  BarConfig,
+  ColorConfig,
+  UsageConfig,
+  ResetWidgetConfig,
+  WindowWidgetConfig,
+} from "./config";
+import {
+  colorizeProgressBarSegments,
+  colorizeUsageText,
+  resolveUsageColor,
+  type UsageColorTheme,
+} from "./color";
+import { renderProgressBarSegments, type ProgressBarSegment } from "./progress-bar";
+import type { UsageSnapshot } from "./usage-snapshot";
+
+const LOGIN_REQUIRED_STATUS_TEXT = "Usage login required";
+const AUTH_FAILED_STATUS_TEXT = "Usage auth failed";
+const REFRESH_FAILED_STATUS_TEXT = "Usage refresh failed";
+const REFRESH_WARNING_TEXT = "refresh failed";
+const VISIBLE_LINE_BREAK_PATTERN = /[\r\n\u2028\u2029]+/gu;
+
+export type FormatUsageStatusLineOptions = {
+  snapshot: UsageSnapshot | undefined;
+  config: UsageConfig;
+  now?: Date;
+  locale?: string | string[];
+  timeZone?: string;
+  theme?: UsageColorTheme;
+};
+
+type FormattedWidget = {
+  text: string;
+  hasAvailableValue: boolean;
+};
+
+/**
+ * Formats a Usage Snapshot into one status-line string.
+ *
+ * The formatter returns text only; Pi UI APIs are owned by the status controller.
+ * Undefined means the controller should clear the status entry.
+ */
+export function formatUsageStatusLine(
+  options: FormatUsageStatusLineOptions,
+): string | undefined {
+  if (options.snapshot === undefined) return undefined;
+
+  const widgets = formatUsageWidgets(options);
+  if (widgets.length === 0) return undefined;
+  if (!widgets.some((widget) => widget.hasAvailableValue)) return undefined;
+
+  return toSingleVisibleLine(composeStatusLine(options.config, widgets, options.theme));
+}
+
+export function formatUsageLoginRequiredStatusLine(theme?: UsageColorTheme): string {
+  return toSingleVisibleLine(formatNeutralText(LOGIN_REQUIRED_STATUS_TEXT, theme));
+}
+
+export function formatUsageAuthFailedStatusLine(theme?: UsageColorTheme): string {
+  return toSingleVisibleLine(formatNeutralText(AUTH_FAILED_STATUS_TEXT, theme));
+}
+
+export function formatUsageRefreshFailedStatusLine(theme?: UsageColorTheme): string {
+  return toSingleVisibleLine(formatNeutralText(REFRESH_FAILED_STATUS_TEXT, theme));
+}
+
+export function appendUsageRefreshFailureMarker(
+  statusText: string,
+  theme?: UsageColorTheme,
+): string {
+  const markerText = theme?.fg("warning", REFRESH_WARNING_TEXT) ?? REFRESH_WARNING_TEXT;
+  return `${statusText}${formatNeutralText(" (", theme)}${markerText}${formatNeutralText(")", theme)}`;
+}
+
+function formatUsageWidgets(options: FormatUsageStatusLineOptions): FormattedWidget[] {
+  const { config, snapshot } = options;
+  if (snapshot === undefined) return [];
+
+  return [
+    formatWindowWidget(snapshot.fiveHourLeftPercent, config.widgets.fiveHour, options),
+    formatWindowWidget(snapshot.sevenDayLeftPercent, config.widgets.sevenDay, options),
+    formatResetWidget(snapshot.fiveHourResetInSeconds, config.widgets.fiveHourReset, options),
+    formatResetWidget(snapshot.sevenDayResetInSeconds, config.widgets.sevenDayReset, options),
+  ].filter((widget): widget is FormattedWidget => widget !== undefined);
+}
+
+function composeStatusLine(
+  config: UsageConfig,
+  widgets: readonly FormattedWidget[],
+  theme?: UsageColorTheme,
+): string {
+  const body = widgets.map((widget) => widget.text).join(formatNeutralText(config.display.separator, theme));
+  const label = formatStatusLabel(config);
+  return label === undefined ? body : `${formatNeutralText(`${label}: `, theme)}${body}`;
+}
+
+function formatStatusLabel(config: UsageConfig): string | undefined {
+  if (!config.display.showLabel) return undefined;
+
+  const label = config.display.label.trim();
+  return label.length > 0 ? label : undefined;
+}
+
+function formatWindowWidget(
+  percent: number | null,
+  config: WindowWidgetConfig,
+  options: FormatUsageStatusLineOptions,
+): FormattedWidget | undefined {
+  if (!isWidgetVisible(config)) return undefined;
+
+  return {
+    text: formatWindowWidgetText(percent, config, options),
+    hasAvailableValue: isFiniteNumber(percent),
+  };
+}
+
+function formatWindowWidgetText(
+  percent: number | null,
+  config: WindowWidgetConfig,
+  options: FormatUsageStatusLineOptions,
+): string {
+  const barConfig = options.config.bar;
+  const colorContext = {
+    colors: options.config.colors,
+    theme: options.theme,
+    isLimited: options.snapshot?.isLimited,
+  };
+
+  switch (config.mode) {
+    case "percent":
+      return formatColorableWindowWidget({
+        labelPrefix: `${config.label}: `,
+        percentText: formatPercent(percent),
+        percent,
+        context: colorContext,
+      });
+    case "bar": {
+      const barSegments = renderProgressBarSegments(percent, barConfig);
+      return formatColorableWindowWidget({
+        labelPrefix: `${config.label} `,
+        barSegments,
+        percent,
+        context: colorContext,
+      });
+    }
+    case "bar-percent": {
+      const barSegments = renderProgressBarSegments(percent, barConfig);
+      return formatColorableWindowWidget({
+        labelPrefix: `${config.label} `,
+        barSegments,
+        percentText: formatPercent(percent),
+        percent,
+        context: colorContext,
+      });
+    }
+    case "hidden":
+      return config.label;
+  }
+}
+
+type WindowColorContext = {
+  colors: ColorConfig;
+  theme?: UsageColorTheme;
+  isLimited?: boolean;
+};
+
+type ColorableWindowWidgetParts = {
+  labelPrefix: string;
+  barSegments?: readonly ProgressBarSegment[];
+  percentText?: string;
+  percent: number | null;
+  context: WindowColorContext;
+};
+
+function formatColorableWindowWidget(parts: ColorableWindowWidgetParts): string {
+  const barText = formatBarText(parts.barSegments);
+  const valueText = joinWindowValueParts(barText, parts.percentText);
+  const uncoloredText = `${parts.labelPrefix}${valueText}`;
+  const neutralLabelPrefix = formatNeutralText(parts.labelPrefix, parts.context.theme);
+  const neutralBarText = formatNeutralText(barText, parts.context.theme);
+  const usesGradient = usesLayeredBarGradient(parts.context.colors, parts.barSegments);
+
+  switch (parts.context.colors.target) {
+    case "widget":
+      if (!usesGradient) return colorizeWindowText(uncoloredText, parts);
+      return `${colorizeWindowText(parts.labelPrefix, parts)}${formatColorableBar(parts)}${formatColorablePercentWithPrefix(
+        parts,
+        true,
+      )}`;
+    case "value":
+      return `${neutralLabelPrefix}${formatColorableValue(parts)}`;
+    case "bar":
+      return `${neutralLabelPrefix}${formatColorableBar(parts)}${formatColorablePercentWithPrefix(parts, false)}`;
+    case "percent":
+      return `${neutralLabelPrefix}${neutralBarText}${formatColorablePercentWithPrefix(parts, true)}`;
+    case "none":
+      return formatNeutralText(uncoloredText, parts.context.theme);
+  }
+}
+
+function formatColorableValue(parts: ColorableWindowWidgetParts): string {
+  if (parts.barSegments === undefined) return colorizeWindowText(parts.percentText ?? "", parts);
+  return `${formatColorableBar(parts)}${formatColorablePercentWithPrefix(parts, false)}`;
+}
+
+function formatColorableBar(parts: ColorableWindowWidgetParts): string {
+  if (parts.barSegments === undefined) return "";
+
+  if (usesLayeredBarGradient(parts.context.colors, parts.barSegments)) {
+    return colorizeProgressBarSegments({
+      segments: parts.barSegments,
+      percent: parts.percent,
+      colors: parts.context.colors,
+      theme: parts.context.theme,
+      isLimited: parts.context.isLimited,
+      formatNeutralSegment: (text) => formatNeutralText(text, parts.context.theme),
+    });
+  }
+
+  return colorizeWindowText(formatBarText(parts.barSegments), parts);
+}
+
+function formatColorablePercentWithPrefix(
+  parts: ColorableWindowWidgetParts,
+  shouldColor: boolean,
+): string {
+  if (parts.percentText === undefined) return "";
+  const separator = parts.barSegments === undefined ? "" : " ";
+  const percentText = shouldColor
+    ? colorizeWindowText(parts.percentText, parts)
+    : formatNeutralText(parts.percentText, parts.context.theme);
+  return `${formatNeutralText(separator, parts.context.theme)}${percentText}`;
+}
+
+function colorizeWindowText(text: string, parts: ColorableWindowWidgetParts): string {
+  const color = resolveUsageColor({
+    percent: parts.percent,
+    colors: parts.context.colors,
+    theme: parts.context.theme,
+    isLimited: parts.context.isLimited,
+  });
+  if (color === undefined) return formatNeutralText(text, parts.context.theme);
+
+  return colorizeUsageText({
+    text,
+    percent: parts.percent,
+    colors: parts.context.colors,
+    theme: parts.context.theme,
+    isLimited: parts.context.isLimited,
+  });
+}
+
+function formatNeutralText(text: string, theme?: UsageColorTheme): string {
+  if (theme === undefined || text.length === 0) return text;
+  return theme.fg("dim", text);
+}
+
+function formatBarText(segments: readonly ProgressBarSegment[] | undefined): string {
+  if (segments === undefined) return "";
+  return segments.map((segment) => segment.text).join("");
+}
+
+function joinWindowValueParts(barText: string, percentText: string | undefined): string {
+  if (barText.length === 0) return percentText ?? "";
+  if (percentText === undefined) return barText;
+  return `${barText} ${percentText}`;
+}
+
+function usesLayeredBarGradient(
+  colors: ColorConfig,
+  barSegments: readonly ProgressBarSegment[] | undefined,
+): boolean {
+  return (
+    barSegments !== undefined &&
+    colors.barGradient.enabled &&
+    colors.scheme !== "none" &&
+    colors.target !== "none" &&
+    colors.target !== "percent"
+  );
+}
+
+function formatResetWidget(
+  seconds: number | null,
+  config: ResetWidgetConfig,
+  options: FormatUsageStatusLineOptions,
+): FormattedWidget | undefined {
+  if (!isWidgetVisible(config)) return undefined;
+
+  return {
+    text: formatNeutralText(`${config.label} ${formatResetValue(seconds, config.mode, options)}`, options.theme),
+    hasAvailableValue: isFiniteNumber(seconds),
+  };
+}
+
+function isWidgetVisible(config: WindowWidgetConfig | ResetWidgetConfig): boolean {
+  return config.enabled && config.mode !== "hidden";
+}
+
+function formatPercent(percent: number | null): string {
+  if (!isFiniteNumber(percent)) return "--";
+  return `${Math.round(clamp(percent, 0, 100))}%`;
+}
+
+function formatResetValue(
+  seconds: number | null,
+  mode: ResetWidgetConfig["mode"],
+  options: FormatUsageStatusLineOptions,
+): string {
+  if (!isFiniteNumber(seconds)) return "--";
+
+  switch (mode) {
+    case "countdown":
+      return formatResetCountdown(seconds);
+    case "clock":
+      return formatResetClock(seconds, options);
+    case "both":
+      return `${formatResetCountdown(seconds)} - ${formatResetClock(seconds, options)}`;
+    case "hidden":
+      return "--";
+  }
+}
+
+export function formatResetCountdown(seconds: number): string {
+  const totalSeconds = Math.max(0, Math.round(seconds));
+  const days = Math.floor(totalSeconds / 86_400);
+  const hours = Math.floor((totalSeconds % 86_400) / 3_600);
+  const minutes = Math.floor((totalSeconds % 3_600) / 60);
+  const remainingSeconds = totalSeconds % 60;
+
+  if (days > 0) return `${days}d${hours}h`;
+  if (hours > 0) return `${hours}h${minutes}m`;
+  if (minutes > 0) return `${minutes}m`;
+  return `${remainingSeconds}s`;
+}
+
+function formatResetClock(seconds: number, options: FormatUsageStatusLineOptions): string {
+  const now = options.now ?? new Date();
+  const resetAt = new Date(now.getTime() + Math.max(0, seconds) * 1000);
+  return new Intl.DateTimeFormat(options.locale, {
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone: options.timeZone,
+  }).format(resetAt);
+}
+
+function toSingleVisibleLine(text: string): string {
+  return text.replace(VISIBLE_LINE_BREAK_PATTERN, " ").trim();
+}
+
+function isFiniteNumber(value: number | null): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.max(min, Math.min(max, value));
+}