gloomberb 0.11.2 → 0.12.0

package/src/utils/fuzzy-search.ts

@@ -1,45 +1,104 @@
+interface FuzzyMatchResult {
+  match: boolean;
+  score: number;
+}
+
+const NO_MATCH: FuzzyMatchResult = { match: false, score: 0 };
+
+/** Awarded on top of the per-word scores when the words also appear as one phrase. */
+const PHRASE_BONUS = 1000;
 
-/** Simple fuzzy matching: all query chars must appear in order in target */
-function fuzzyMatch(query: string, target: string): { match: boolean; score: number } {
-  const q = query.toLowerCase();
-  const t = target.toLowerCase();
+function isWordStart(text: string, index: number): boolean {
+  return index === 0 || !/[a-z0-9]/i.test(text[index - 1]!);
+}
+
+/**
+ * Subsequence fallback, kept deliberately narrow: the first query character
+ * must be the first character of the text, and every one after it must start
+ * a word or directly follow the previous match, so the query has to read as
+ * an ordered run of word prefixes from the start ("cm" or "corrmat" for
+ * "Correlation Matrix"). Letters scattered across the text, which is how
+ * "nvidia" used to hit "Options Calculator" through its keywords, no longer
+ * count, and callers that hand over a keyword-heavy haystack instead of a
+ * label still get a run that begins in the label.
+ */
+function matchWordPrefixRun(query: string, label: string): FuzzyMatchResult {
+  if (label[0] !== query[0]) return NO_MATCH;
+  let qi = 1;
+  let score = 10;
+  let previous = 0;
+  for (let li = 1; li < label.length && qi < query.length; li++) {
+    if (label[li] !== query[qi]) continue;
+    const atWordStart = isWordStart(label, li);
+    if (!atWordStart && li !== previous + 1) continue;
+    score += atWordStart ? 10 : 1;
+    previous = li;
+    qi++;
+  }
+  return qi === query.length ? { match: true, score } : NO_MATCH;
+}
 
-  if (q.length === 0) return { match: true, score: 0 };
-  if (t === q) return { match: true, score: 2500 - q.length };
+/**
+ * Match one lowercase word. Exact, token, prefix, and substring hits are looked
+ * up in the full haystack; the looser fallback only ever sees the label, since
+ * keywords and descriptions are there to be found by whole words, not letters.
+ */
+function matchTerm(term: string, haystack: string, label: string): FuzzyMatchResult {
+  if (haystack === term) return { match: true, score: 2500 - term.length };
 
-  const tokens = t.split(/\s+/).filter(Boolean);
-  const exactTokenIndex = tokens.findIndex((token) => token === q);
-  if (exactTokenIndex >= 0) return { match: true, score: 2200 - q.length - exactTokenIndex };
+  const tokens = haystack.split(/\s+/).filter(Boolean);
+  const exactTokenIndex = tokens.findIndex((token) => token === term);
+  if (exactTokenIndex >= 0) return { match: true, score: 2200 - term.length - exactTokenIndex };
 
-  const prefixTokenIndex = tokens.findIndex((token) => token.startsWith(q));
+  const prefixTokenIndex = tokens.findIndex((token) => token.startsWith(term));
   if (prefixTokenIndex >= 0) {
     const token = tokens[prefixTokenIndex]!;
-    return { match: true, score: 1000 - q.length - prefixTokenIndex - (token.length - q.length) };
+    return { match: true, score: 1000 - term.length - prefixTokenIndex - (token.length - term.length) };
   }
 
-  if (t.includes(q)) return { match: true, score: 500 - q.length }; // substring match
+  if (haystack.includes(term)) return { match: true, score: 500 - term.length };
+
+  return matchWordPrefixRun(term, label);
+}
+
+/** Every word of the query has to match on its own; the whole phrase matching too ranks higher. */
+function fuzzyMatch(query: string, target: string, label: string): FuzzyMatchResult {
+  const q = query.toLowerCase().trim();
+  const haystack = target.toLowerCase();
+  const labelText = label.toLowerCase();
+  const terms = q.split(/\s+/).filter(Boolean);
+
+  if (terms.length === 0) return { match: true, score: 0 };
+  if (terms.length === 1) return matchTerm(terms[0]!, haystack, labelText);
 
-  let qi = 0;
   let score = 0;
-  for (let ti = 0; ti < t.length && qi < q.length; ti++) {
-    if (t[ti] === q[qi]) {
-      score += ti === 0 || t[ti - 1] === " " || t[ti - 1] === "-" ? 10 : 1;
-      qi++;
-    }
+  for (const term of terms) {
+    const result = matchTerm(term, haystack, labelText);
+    if (!result.match) return NO_MATCH;
+    score += result.score;
   }
-
-  return { match: qi === q.length, score };
+  if (haystack.includes(q)) score += PHRASE_BONUS;
+  return { match: true, score };
 }
 
-/** Filter and sort items by fuzzy match score */
+/**
+ * Filter and sort items by fuzzy match score. `getText` is the full haystack
+ * (label plus keywords, description, shortcut); `getLabel`, when given, confines
+ * the subsequence fallback to the label. Without it the fallback runs on the
+ * whole haystack.
+ */
 export function fuzzyFilter<T>(
   items: T[],
   query: string,
   getText: (item: T) => string,
+  getLabel?: (item: T) => string,
 ): T[] {
   if (!query) return items;
   return items
-    .map((item) => ({ item, ...fuzzyMatch(query, getText(item)) }))
+    .map((item) => {
+      const text = getText(item);
+      return { item, ...fuzzyMatch(query, text, getLabel ? getLabel(item) : text) };
+    })
     .filter((r) => r.match)
     .sort((a, b) => b.score - a.score)
     .map((r) => r.item);

package/src/utils/save-text-file.test.ts

@@ -0,0 +1,24 @@
+import { afterEach, expect, test } from "bun:test";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { saveTextFileToDirectory } from "./save-text-file";
+
+let directory: string | null = null;
+
+afterEach(async () => {
+  if (directory) await rm(directory, { recursive: true, force: true });
+  directory = null;
+});
+
+test("keeps existing exports instead of overwriting them", async () => {
+  directory = await mkdtemp(join(tmpdir(), "gloomberb-export-"));
+
+  const first = await saveTextFileToDirectory(directory, "prices.csv", "first");
+  const second = await saveTextFileToDirectory(directory, "prices.csv", "second");
+
+  expect(first).toBe("prices.csv");
+  expect(second).toBe("prices (2).csv");
+  expect(await readFile(join(directory, first), "utf-8")).toBe("first");
+  expect(await readFile(join(directory, second), "utf-8")).toBe("second");
+});

package/src/utils/save-text-file.ts

@@ -0,0 +1,36 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, extname, join } from "node:path";
+
+function safeFilename(name: string): string {
+  const safe = basename(name.replace(/\\/g, "/"))
+    .replace(/[<>:"|?*\u0000-\u001f]/g, "-")
+    .replace(/[. ]+$/g, "");
+  return !safe || safe === "." || safe === ".." ? "gloomberb-export.txt" : safe;
+}
+
+export async function saveTextFileToDirectory(
+  directory: string,
+  name: string,
+  text: string,
+): Promise<string> {
+  await mkdir(directory, { recursive: true });
+  const safeName = safeFilename(name);
+  const extension = extname(safeName);
+  const stem = safeName.slice(0, safeName.length - extension.length);
+
+  for (let copy = 1; ; copy += 1) {
+    const filename = copy === 1 ? safeName : `${stem} (${copy})${extension}`;
+    try {
+      await writeFile(join(directory, filename), text, { encoding: "utf-8", flag: "wx" });
+      return filename;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+    }
+  }
+}
+
+export async function saveTextFileToDownloads(name: string, text: string): Promise<string> {
+  const filename = await saveTextFileToDirectory(join(homedir(), "Downloads"), name, text);
+  return `~/Downloads/${filename}`;
+}

package/src/utils/shortcut-labels.ts

@@ -57,6 +57,20 @@ export function formatPrimaryShortcut(
   return [getPrimaryShortcutModifier(platform, mode), ...keyParts].join("+");
 }
 
+/**
+ * The single binding a host advertises for the command bar. Ctrl+P is the
+ * terminal's canonical binding; desktop hosts show the platform modifier with
+ * K, which the global shortcut accepts everywhere. Every surface that names the
+ * binding goes through here, so the header prompt and the empty-state hint can
+ * never quote two different keys at the same user.
+ */
+export function formatCommandBarShortcut(
+  mode: ShortcutDisplayMode = "platform",
+  platform: ShortcutPlatform = detectShortcutPlatform(),
+): string {
+  return mode === "terminal" ? "Ctrl+P" : formatPrimaryShortcut("K", platform, "platform");
+}
+
 export function formatPlatformShortcutLabel(
   label: string,
   platform: ShortcutPlatform = detectShortcutPlatform(),

package/src/components/chart/core/axis-format.ts

@@ -1,157 +0,0 @@
-import {
-  formatCompactMarketPriceWithCurrency,
-  formatMarketPrice,
-  formatMarketPriceWithCurrency,
-  resolveAssetDisplayKind,
-} from "../../../market-data/market/format";
-import type { ChartAxisMode } from "./types";
-
-export function formatPrice(
-  value: number,
-  assetCategory?: string,
-  priceRange?: number,
-  precisionOffset = 0,
-  minimumFractionDigits = 0,
-  fixedFractionDigits?: number,
-): string {
-  return formatMarketPrice(value, {
-    assetCategory,
-    fixedFractionDigits,
-    minimumFractionDigits,
-    precisionOffset,
-    priceRange,
-  });
-}
-
-export function formatPriceWithCurrency(
-  value: number,
-  currency = "USD",
-  assetCategory?: string,
-  priceRange?: number,
-  precisionOffset = 0,
-  minimumFractionDigits = 0,
-  fixedFractionDigits?: number,
-): string {
-  return formatMarketPriceWithCurrency(value, currency, {
-    assetCategory,
-    fixedFractionDigits,
-    minimumFractionDigits,
-    precisionOffset,
-    priceRange,
-  });
-}
-
-export function getAxisFractionDigitFloor(assetCategory: string | undefined, priceRange: number | undefined): number {
-  if (priceRange === undefined || !Number.isFinite(priceRange) || priceRange <= 0) return 0;
-
-  const kind = resolveAssetDisplayKind({ assetCategory });
-  const visibleStep = priceRange / 3;
-  if (!Number.isFinite(visibleStep) || visibleStep <= 0) return 0;
-
-  const offset = kind === "cash" ? 0 : 1;
-  return Math.max(0, Math.ceil(-Math.log10(visibleStep)) + offset);
-}
-
-export function resolveAxisFractionDigits(
-  prices: number[],
-  formatLabel: (value: number, fixedFractionDigits: number) => string,
-  minimumFractionDigits = 0,
-  maxFractionDigits = 8,
-): number {
-  for (let fixedFractionDigits = minimumFractionDigits; fixedFractionDigits <= maxFractionDigits; fixedFractionDigits += 1) {
-    const labels = prices.map((value) => formatLabel(value, fixedFractionDigits));
-    if (hasDistinctAxisLabels(labels)) return fixedFractionDigits;
-  }
-
-  return maxFractionDigits;
-}
-
-export function resolveChartAxisWidth(
-  labels: Array<string | null | undefined>,
-  minimumWidth: number,
-  maximumWidth: number,
-): number {
-  if (maximumWidth <= 0) return 0;
-
-  const longestLabel = labels.reduce((maxWidth, label) => (
-    Math.max(maxWidth, label?.length ?? 0)
-  ), 0);
-
-  return Math.min(Math.max(longestLabel, minimumWidth), maximumWidth);
-}
-
-export function formatAxisCell(label: string | null, width: number): string {
-  if (width <= 0) return "";
-  if (!label) return " ".repeat(width);
-  return label.length >= width ? label.slice(0, width) : label.padStart(width);
-}
-
-export function formatAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  basePrice: number,
-  currency = "USD",
-  assetCategory?: string,
-  priceRange?: number,
-  fixedFractionDigits?: number,
-): string {
-  if (axisMode === "percent" && basePrice !== 0) {
-    return formatPercentAxisValue(((value - basePrice) / basePrice) * 100);
-  }
-  return formatCompactMarketPriceWithCurrency(value, currency, {
-    assetCategory,
-    fixedFractionDigits,
-    priceRange,
-  });
-}
-
-export function formatCursorAxisValue(
-  value: number,
-  axisMode: ChartAxisMode,
-  basePrice: number,
-  currency = "USD",
-  assetCategory?: string,
-  priceRange?: number,
-): string {
-  if (axisMode === "percent" && basePrice !== 0) {
-    return formatPercentAxisValue(((value - basePrice) / basePrice) * 100);
-  }
-
-  return formatPriceWithCurrency(
-    value,
-    currency,
-    assetCategory,
-    priceRange,
-    2,
-    getCursorAxisMinimumFractionDigits(value, assetCategory),
-  );
-}
-
-function formatPercentAxisValue(value: number): string {
-  const abs = Math.abs(value);
-  const decimals = abs >= 100 ? 0 : abs >= 10 ? 1 : 2;
-  const prefix = value > 0 ? "+" : "";
-  return `${prefix}${value.toFixed(decimals)}%`;
-}
-
-function hasDistinctAxisLabels(labels: string[]): boolean {
-  return new Set(labels).size === labels.length;
-}
-
-function getCursorAxisMinimumFractionDigits(value: number, assetCategory?: string): number {
-  const kind = resolveAssetDisplayKind({ assetCategory });
-
-  switch (kind) {
-    case "cash":
-      return 4;
-    case "crypto":
-      if (Math.abs(value) >= 100) return 2;
-      return Math.abs(value) >= 1 ? 4 : 6;
-    case "equity":
-    case "contract":
-      return Math.abs(value) >= 1 ? 2 : 4;
-    case "other":
-    default:
-      return Math.abs(value) >= 1 ? 2 : 4;
-  }
-}