gloomberb 0.10.0 → 0.10.2

package/src/components/chart/core/data.ts

@@ -1,11 +1,5 @@
-import type { PricePoint, Quote } from "../../../types/financials";
-import { isQuoteStaleForCurrentSession } from "../../../market-data/quotes/freshness";
-import { hasLikelyQuoteUnitMismatch } from "../../../utils/currency-units";
-import {
-  CHART_RESOLUTION_STEP_MS,
-  type ManualChartResolution,
-} from "./resolution";
-
+export { appendLiveQuotePoint } from "../../../time-series/chart-data";
+export type { AppendLiveQuotePointOptions } from "../../../time-series/chart-data";
 export {
   bucketOhlcSeries,
   projectChartData,
@@ -17,154 +11,3 @@ export type {
   ProjectChartDataOptions,
   ProjectedChartPoint,
 } from "./projection";
-
-const MAX_LIVE_QUOTE_TAIL_AGE_MS = 7 * 24 * 60 * 60_000;
-const MAX_LIVE_QUOTE_CLOCK_SKEW_MS = 5 * 60_000;
-const MAX_INTRADAY_BAR_INTERVAL_MS = 6 * 60 * 60_000;
-const MIN_LIVE_QUOTE_TAIL_GAP_MS = 5 * 60_000;
-const MS_DAY = 86400_000;
-
-export type AppendLiveQuotePointOptions =
-  | {
-    now?: number;
-    mode?: "scalar";
-  }
-  | {
-    now?: number;
-    mode: "ohlc";
-    resolution: ManualChartResolution;
-  };
-
-function coerceDate(value: Date | string | number): Date {
-  return value instanceof Date ? value : new Date(value);
-}
-
-function getPointTime(point: Pick<PricePoint, "date">): number {
-  return coerceDate(point.date as Date | string | number).getTime();
-}
-
-function getActiveQuotePrice(quote: Quote): number {
-  if ((quote.marketState === "PRE" || quote.marketState === "PREPRE") && quote.preMarketPrice != null) {
-    return quote.preMarketPrice;
-  }
-  if ((quote.marketState === "POST" || quote.marketState === "POSTPOST") && quote.postMarketPrice != null) {
-    return quote.postMarketPrice;
-  }
-  return quote.price;
-}
-
-function quoteBelongsToLatestBar(
-  latestTime: number,
-  quoteTime: number,
-  resolution: ManualChartResolution,
-): boolean {
-  if (quoteTime < latestTime) return false;
-  if (resolution === "1mo") {
-    const latestDate = new Date(latestTime);
-    const quoteDate = new Date(quoteTime);
-    return latestDate.getUTCFullYear() === quoteDate.getUTCFullYear()
-      && latestDate.getUTCMonth() === quoteDate.getUTCMonth();
-  }
-  return quoteTime - latestTime < CHART_RESOLUTION_STEP_MS[resolution];
-}
-
-function finiteOrFallback(value: number | undefined, fallback: number): number {
-  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
-}
-
-function mergeQuoteIntoLatestBar(latest: PricePoint, quotePrice: number): PricePoint {
-  const open = finiteOrFallback(latest.open, latest.close);
-  const high = finiteOrFallback(latest.high, Math.max(open, latest.close));
-  const low = finiteOrFallback(latest.low, Math.min(open, latest.close));
-  return {
-    ...latest,
-    open,
-    high: Math.max(high, open, latest.close, quotePrice),
-    low: Math.min(low, open, latest.close, quotePrice),
-    close: quotePrice,
-  };
-}
-
-export function appendLiveQuotePoint(
-  points: PricePoint[],
-  quote: Quote | null | undefined,
-  options: AppendLiveQuotePointOptions = {},
-): PricePoint[] {
-  const now = options.now ?? Date.now();
-  if (!quote || isQuoteStaleForCurrentSession(quote, now)) return points;
-
-  const quoteTime = quote.lastUpdated;
-  const quotePrice = getActiveQuotePrice(quote);
-  if (
-    !Number.isFinite(quoteTime)
-    || !Number.isFinite(quotePrice)
-    || quotePrice <= 0
-    || quoteTime > now + MAX_LIVE_QUOTE_CLOCK_SKEW_MS
-    || now - quoteTime > MAX_LIVE_QUOTE_TAIL_AGE_MS
-  ) {
-    return points;
-  }
-
-  const latest = points.at(-1);
-  if (!latest) return points;
-
-  const latestTime = getPointTime(latest);
-  if (!Number.isFinite(latestTime) || quoteTime < latestTime) return points;
-
-  const previous = points.at(-2);
-  const latestInterval = previous ? latestTime - getPointTime(previous) : Number.NaN;
-  if (
-    latestInterval > 0
-    && latestInterval <= MAX_INTRADAY_BAR_INTERVAL_MS
-    && quoteTime - latestTime > Math.max(MIN_LIVE_QUOTE_TAIL_GAP_MS, latestInterval * 3)
-  ) {
-    return points;
-  }
-
-  const latestClose = latest.close;
-  if (hasLikelyQuoteUnitMismatch(
-    { currency: quote.currency, price: latestClose },
-    { currency: quote.currency, price: quotePrice },
-  )) {
-    return points;
-  }
-
-  if (options.mode === "ohlc") {
-    if (quoteBelongsToLatestBar(latestTime, quoteTime, options.resolution)) {
-      const merged = mergeQuoteIntoLatestBar(latest, quotePrice);
-      return [...points.slice(0, -1), merged];
-    }
-    return [
-      ...points,
-      {
-        date: new Date(quoteTime),
-        open: quotePrice,
-        high: quotePrice,
-        low: quotePrice,
-        close: quotePrice,
-      },
-    ];
-  }
-
-  if (quoteTime === latestTime) return points;
-
-  return [
-    ...points,
-    {
-      date: new Date(quoteTime),
-      close: quotePrice,
-    },
-  ];
-}
-
-/**
- * Given the visible time span in milliseconds, return a generic bar size label
- * for fetching higher-resolution data, or null if the base data is sufficient.
- */
-export function resolveBarSize(visibleTimeSpanMs: number): string | null {
-  if (visibleTimeSpanMs < MS_DAY) return "5m";
-  if (visibleTimeSpanMs < 3 * MS_DAY) return "15m";
-  if (visibleTimeSpanMs < 28 * MS_DAY) return "1h";
-  if (visibleTimeSpanMs < 90 * MS_DAY) return "1d";
-  return null;
-}

package/src/components/chart/core/date-window.ts

@@ -1,8 +1,9 @@
 import type { PricePoint } from "../../../types/financials";
-import { clampChartZoom, getVisiblePointCount } from "./viewport";
-import { TIME_RANGES, type ChartDateWindow, type TimeRange, type VisibleWindow } from "./types";
+import type { TimeRange, VisibleWindow } from "./types";
+import type { DateWindowRange } from "../../../time-series/date-window";
+import { subtractTimeRange } from "../../../time-series/date-window";
 
-export interface VisibleDateWindow {
+interface VisibleDateWindow {
   start: Date | null;
   end: Date | null;
   dates: Date[];
@@ -11,60 +12,6 @@ export interface VisibleDateWindow {
   totalDates: number;
 }
 
-export interface DateWindowRange extends ChartDateWindow {}
-
-export interface DateWindowViewport {
-  panOffset: number;
-  zoomLevel: number;
-}
-
-export function subtractTimeRange(endDate: Date, range: TimeRange): Date {
-  const startDate = new Date(endDate);
-  switch (range) {
-    case "1D":
-      startDate.setDate(startDate.getDate() - 1);
-      break;
-    case "1W":
-      startDate.setDate(startDate.getDate() - 7);
-      break;
-    case "1M":
-      startDate.setMonth(startDate.getMonth() - 1);
-      break;
-    case "3M":
-      startDate.setMonth(startDate.getMonth() - 3);
-      break;
-    case "6M":
-      startDate.setMonth(startDate.getMonth() - 6);
-      break;
-    case "1Y":
-      startDate.setFullYear(startDate.getFullYear() - 1);
-      break;
-    case "5Y":
-      startDate.setFullYear(startDate.getFullYear() - 5);
-      break;
-    case "ALL":
-      startDate.setFullYear(startDate.getFullYear() - 50);
-      break;
-  }
-  return startDate;
-}
-
-export function isDateWindowWithinTimeRange(startDate: Date, endDate: Date, maxRange: TimeRange): boolean {
-  if (maxRange === "ALL") return true;
-  return startDate.getTime() >= subtractTimeRange(endDate, maxRange).getTime();
-}
-
-export function getTimeRangeForDateWindow(
-  window: DateWindowRange | null,
-): TimeRange {
-  if (!window?.start || !window.end) return "ALL";
-  return TIME_RANGES.find((candidate) => isDateWindowWithinTimeRange(window.start!, window.end!, candidate)) ?? "ALL";
-}
-
-function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(max, value));
-}
-
 function coerceDate(value: Date | string | number): Date {
   return value instanceof Date ? value : new Date(value);
 }
@@ -149,29 +96,10 @@ function resolveMinimumPointWindow(
   return { startIdx, endIdx };
 }
 
-export function getPointDates(points: readonly Pick<PricePoint, "date">[]): Date[] {
+function getPointDates(points: readonly Pick<PricePoint, "date">[]): Date[] {
   return points.map((point) => coerceDate(point.date as Date | string | number));
 }
 
-export function getDateWindowBounds(dates: readonly Date[]): DateWindowRange | null {
-  if (dates.length === 0) return null;
-  return {
-    start: dates[0] ?? null,
-    end: dates[dates.length - 1] ?? null,
-  };
-}
-
-export function getMinimumDateStepMs(dates: readonly Date[]): number {
-  let minimum = Number.POSITIVE_INFINITY;
-  for (let index = 1; index < dates.length; index += 1) {
-    const delta = dates[index]!.getTime() - dates[index - 1]!.getTime();
-    if (delta > 0 && delta < minimum) {
-      minimum = delta;
-    }
-  }
-  return Number.isFinite(minimum) ? minimum : 1;
-}
-
 export function buildPresetDateWindow(dates: readonly Date[], presetRange: TimeRange): DateWindowRange | null {
   if (dates.length === 0) return null;
   if (presetRange === "ALL") {
@@ -191,134 +119,7 @@ export function buildPresetDateWindow(dates: readonly Date[], presetRange: TimeR
   };
 }
 
-export function sameDateWindow(
-  left: DateWindowRange | null | undefined,
-  right: DateWindowRange | null | undefined,
-  toleranceMs = 1,
-): boolean {
-  if (!left?.start || !left.end || !right?.start || !right.end) {
-    return left?.start === right?.start && left?.end === right?.end;
-  }
-  return Math.abs(left.start.getTime() - right.start.getTime()) <= toleranceMs
-    && Math.abs(left.end.getTime() - right.end.getTime()) <= toleranceMs;
-}
-
-export function clampDateWindowToBounds(
-  window: DateWindowRange | null | undefined,
-  bounds: DateWindowRange | null | undefined,
-  minimumSpanMs = 1,
-): DateWindowRange | null {
-  const normalizedWindow = normalizeDateWindowRange(window);
-  const normalizedBounds = normalizeDateWindowRange(bounds);
-  if (!normalizedWindow || !normalizedBounds) return null;
-
-  const availableSpanMs = Math.max(normalizedBounds.endMs - normalizedBounds.startMs, 0);
-  const effectiveMinimumSpanMs = availableSpanMs === 0
-    ? 0
-    : Math.min(Math.max(minimumSpanMs, 1), availableSpanMs);
-  const requestedSpanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 0);
-  const targetSpanMs = Math.min(
-    Math.max(requestedSpanMs, effectiveMinimumSpanMs),
-    availableSpanMs,
-  );
-
-  if (availableSpanMs === 0 || targetSpanMs === 0) {
-    return {
-      start: new Date(normalizedBounds.startMs),
-      end: new Date(normalizedBounds.endMs),
-    };
-  }
-
-  if (targetSpanMs >= availableSpanMs) {
-    return {
-      start: new Date(normalizedBounds.startMs),
-      end: new Date(normalizedBounds.endMs),
-    };
-  }
-
-  let startMs: number;
-  let endMs: number;
-
-  if (requestedSpanMs < targetSpanMs) {
-    const centerMs = normalizedWindow.startMs + (requestedSpanMs / 2);
-    startMs = centerMs - (targetSpanMs / 2);
-    endMs = centerMs + (targetSpanMs / 2);
-  } else {
-    startMs = normalizedWindow.startMs;
-    endMs = normalizedWindow.startMs + targetSpanMs;
-  }
-
-  if (startMs < normalizedBounds.startMs) {
-    startMs = normalizedBounds.startMs;
-    endMs = startMs + targetSpanMs;
-  } else if (endMs > normalizedBounds.endMs) {
-    endMs = normalizedBounds.endMs;
-    startMs = endMs - targetSpanMs;
-  }
-
-  return {
-    start: new Date(startMs),
-    end: new Date(endMs),
-  };
-}
-
-export function shiftDateWindow(
-  window: DateWindowRange | null | undefined,
-  shiftRatio: number,
-): DateWindowRange | null {
-  const normalizedWindow = normalizeDateWindowRange(window);
-  if (!normalizedWindow) return null;
-
-  const spanMs = Math.max(normalizedWindow.endMs - normalizedWindow.startMs, 1);
-  const shiftMs = spanMs * shiftRatio;
-
-  return {
-    start: new Date(normalizedWindow.startMs - shiftMs),
-    end: new Date(normalizedWindow.endMs - shiftMs),
-  };
-}
-
-function getCanonicalVisiblePointCount(dates: readonly Date[], presetRange: TimeRange): number {
-  if (dates.length === 0) return 0;
-  if (presetRange === "ALL") return dates.length;
-  const endDate = dates[dates.length - 1]!;
-  const threshold = subtractTimeRange(endDate, presetRange).getTime();
-  const firstVisibleIndex = dates.findIndex((date) => date.getTime() >= threshold);
-  if (firstVisibleIndex < 0) return dates.length;
-  return Math.max(dates.length - firstVisibleIndex, 1);
-}
-
-export function getCanonicalZoomLevel(dates: readonly Date[], presetRange: TimeRange): number {
-  if (dates.length === 0) return 1;
-  const visibleCount = getCanonicalVisiblePointCount(dates, presetRange);
-  return clampChartZoom(dates.length, dates.length / Math.max(visibleCount, 1));
-}
-
-export function buildVisibleDateWindow(
-  dates: readonly Date[],
-  panOffset: number,
-  zoomLevel: number,
-): VisibleDateWindow {
-  if (dates.length === 0) {
-    return { start: null, end: null, dates: [], startIdx: 0, endIdx: 0, totalDates: 0 };
-  }
-  const visibleCount = getVisiblePointCount(dates.length, zoomLevel);
-  const maxPan = Math.max(dates.length - visibleCount, 0);
-  const pan = clamp(panOffset, 0, maxPan);
-  const endIdx = dates.length - pan;
-  const startIdx = Math.max(endIdx - visibleCount, 0);
-  const visibleDates = dates.slice(startIdx, endIdx);
-  return {
-    start: visibleDates[0] ?? null,
-    end: visibleDates[visibleDates.length - 1] ?? null,
-    dates: visibleDates,
-    startIdx,
-    endIdx,
-    totalDates: dates.length,
-  };
-}
-
-export function buildVisibleDateWindowFromRange(
+function buildVisibleDateWindowFromRange(
   dates: readonly Date[],
   window: DateWindowRange | null | undefined,
   minimumPoints = 2,
@@ -352,26 +153,6 @@ export function buildVisibleDateWindowFromRange(
   };
 }
 
-export function resolveViewportForDateWindow(
-  dates: readonly Date[],
-  window: DateWindowRange | null | undefined,
-  minimumPoints = 2,
-): DateWindowViewport | null {
-  if (dates.length === 0) return null;
-  const visibleWindow = buildVisibleDateWindowFromRange(dates, window, minimumPoints);
-  if (visibleWindow.dates.length === 0) return null;
-
-  const visibleCount = Math.max(visibleWindow.dates.length, 1);
-  const zoomLevel = clampChartZoom(dates.length, dates.length / visibleCount);
-  const maxPanOffset = Math.max(dates.length - visibleCount, 0);
-  const panOffset = clamp(dates.length - visibleWindow.endIdx, 0, maxPanOffset);
-
-  return {
-    panOffset,
-    zoomLevel,
-  };
-}
-
 export function getVisibleWindowForDateRange(
   points: readonly PricePoint[],
   window: DateWindowRange | null | undefined,

package/src/components/chart/core/palette.ts

@@ -1,4 +1,5 @@
 import type { ChartColors } from "./types";
+import { blendHex } from "../../../theme/color-utils";
 
 interface ChartPaletteInput {
   bg: string;
@@ -17,18 +18,6 @@ export interface ResolvedChartPalette extends ChartColors {
   wickDown: string;
 }
 
-function blendHex(a: string, b: string, ratio: number): string {
-  const parse = (hex: string) => {
-    const h = hex.replace("#", "");
-    return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)] as const;
-  };
-
-  const [ar, ag, ab] = parse(a);
-  const [br, bg, bb] = parse(b);
-  const mix = (x: number, y: number) => Math.round(x + (y - x) * ratio).toString(16).padStart(2, "0");
-  return `#${mix(ar, br)}${mix(ag, bg)}${mix(ab, bb)}`;
-}
-
 export function resolveChartPalette(
   baseColors: ChartPaletteInput,
   trend: "positive" | "negative" | "neutral" = "positive",

package/src/components/chart/core/pointer.ts

@@ -1,5 +1,4 @@
 import type { NativeRendererHost as CliRenderer } from "../../../ui";
-import { sameCursorPosition, type ChartCursorMotionKind } from "../cursor-motion";
 
 type RendererMetricsHost = Pick<CliRenderer, "resolution" | "terminalWidth" | "terminalHeight">;
 
@@ -36,8 +35,6 @@ export interface ChartMouseEvent {
   };
 }
 
-export type MouseInteractionEvent = Pick<ChartMouseEvent, "stopPropagation" | "preventDefault">;
-
 export function consumeChartMouseEvent(event: Pick<ChartMouseEvent, "stopPropagation" | "preventDefault">): void {
   event.stopPropagation?.();
   event.preventDefault?.();
@@ -51,46 +48,10 @@ export interface LocalPlotPointer {
   hasPixelPrecision: boolean;
 }
 
-export interface DisplayCursorState {
-  cellX: number | null;
-  cellY: number | null;
-  pixelX: number | null;
-  pixelY: number | null;
-}
-
-export const EMPTY_DISPLAY_CURSOR: DisplayCursorState = {
-  cellX: null,
-  cellY: null,
-  pixelX: null,
-  pixelY: null,
-};
-
-export const PIXEL_CURSOR_SNAP_DISTANCE = 0.5;
-
-const globalAnimationFrame = globalThis as typeof globalThis & {
-  requestAnimationFrame?: (callback: (timestamp: number) => void) => number;
-  cancelAnimationFrame?: (handle: number) => void;
-};
-
 function clamp(value: number, min: number, max: number): number {
   return Math.max(min, Math.min(max, value));
 }
 
-export function requestAnimationFrameSafe(callback: (timestamp: number) => void): number {
-  if (typeof globalAnimationFrame.requestAnimationFrame === "function") {
-    return globalAnimationFrame.requestAnimationFrame(callback);
-  }
-  return globalThis.setTimeout(() => callback(Date.now()), 16) as unknown as number;
-}
-
-export function cancelAnimationFrameSafe(handle: number) {
-  if (typeof globalAnimationFrame.cancelAnimationFrame === "function") {
-    globalAnimationFrame.cancelAnimationFrame(handle);
-    return;
-  }
-  clearTimeout(handle);
-}
-
 function getRendererCellMetrics(renderer: RendererMetricsHost) {
   if (!renderer.resolution) return null;
   const cellWidth = renderer.resolution.width / Math.max(renderer.terminalWidth, 1);
@@ -129,47 +90,6 @@ function getPlotBounds(renderable: PlotRenderableLike | null): { x: number; y: n
   return { x, y, width: size.width, height: size.height };
 }
 
-export function getRenderablePixelSize(
-  renderable: RenderableSizeLike | null,
-  renderer: RendererMetricsHost,
-) {
-  const metrics = getRendererCellMetrics(renderer);
-  const size = getRenderableSize(renderable);
-  if (!size || !metrics) return null;
-  return {
-    pixelWidth: Math.max(size.width * metrics.cellWidth, 1),
-    pixelHeight: Math.max(size.height * metrics.cellHeight, 1),
-  };
-}
-
-export function projectCellCursorToLocalPixels(
-  cellX: number,
-  cellY: number,
-  renderable: RenderableSizeLike | null,
-  renderer: RendererMetricsHost,
-): { pixelX: number; pixelY: number } | null {
-  const pixelSize = getRenderablePixelSize(renderable, renderer);
-  const size = getRenderableSize(renderable);
-  if (!size || !pixelSize) return null;
-
-  return {
-    pixelX: size.width <= 1
-      ? 0
-      : clamp(
-        (cellX / Math.max(size.width - 1, 1)) * Math.max(pixelSize.pixelWidth - 1, 0),
-        0,
-        Math.max(pixelSize.pixelWidth - 1, 0),
-      ),
-    pixelY: size.height <= 1
-      ? 0
-      : clamp(
-        (cellY / Math.max(size.height - 1, 1)) * Math.max(pixelSize.pixelHeight - 1, 0),
-        0,
-        Math.max(pixelSize.pixelHeight - 1, 0),
-      ),
-  };
-}
-
 export function scaleLocalPixelCoordinate(value: number | null, sourceExtent: number, targetExtent: number): number | null {
   if (value === null) return null;
   if (targetExtent <= 1) return 0;
@@ -183,55 +103,6 @@ export function scaleLocalPixelCoordinate(value: number | null, sourceExtent: nu
   );
 }
 
-export function toCursorPosition(x: number | null, y: number | null) {
-  return { x, y };
-}
-
-export function sameDisplayCursorState(
-  left: DisplayCursorState,
-  right: DisplayCursorState,
-  cellEpsilon = 0,
-  pixelEpsilon = 0,
-): boolean {
-  return sameCursorPosition(toCursorPosition(left.cellX, left.cellY), toCursorPosition(right.cellX, right.cellY), cellEpsilon)
-    && sameCursorPosition(toCursorPosition(left.pixelX, left.pixelY), toCursorPosition(right.pixelX, right.pixelY), pixelEpsilon);
-}
-
-export function buildDisplayCursorState(
-  cellX: number | null,
-  cellY: number | null,
-  renderable: RenderableSizeLike | null,
-  renderer: RendererMetricsHost,
-  pixelX: number | null = null,
-  pixelY: number | null = null,
-): DisplayCursorState {
-  if (cellX === null || cellY === null) return EMPTY_DISPLAY_CURSOR;
-  if (pixelX !== null && pixelY !== null) {
-    return { cellX, cellY, pixelX, pixelY };
-  }
-  const derivedPixels = projectCellCursorToLocalPixels(cellX, cellY, renderable, renderer);
-  return {
-    cellX,
-    cellY,
-    pixelX: derivedPixels?.pixelX ?? null,
-    pixelY: derivedPixels?.pixelY ?? null,
-  };
-}
-
-export function resolveSelectionDisplayCursorState(
-  cursorX: number | null,
-  cursorY: number | null,
-  fallbackCursorX: number | null,
-  fallbackCursorY: number | null,
-  renderable: RenderableSizeLike | null,
-  renderer: RendererMetricsHost,
-): DisplayCursorState {
-  const resolvedCursorX = cursorY === null ? (fallbackCursorX ?? cursorX) : cursorX;
-  const resolvedCursorY = cursorY ?? fallbackCursorY;
-  if (resolvedCursorX === null) return EMPTY_DISPLAY_CURSOR;
-  return buildDisplayCursorState(resolvedCursorX, resolvedCursorY, renderable, renderer);
-}
-
 export function getLocalPlotPointer(
   event: ChartMouseEvent,
   renderable: PlotRenderableLike | null,
@@ -305,16 +176,3 @@ export function getGlobalMouseX(
   if (event.pixelX === undefined || !metrics) return event.x;
   return event.pixelX / metrics.cellWidth;
 }
-
-export function resolveCursorMotionKind(
-  event: ChartMouseEvent,
-  renderer: RendererMetricsHost,
-): ChartCursorMotionKind {
-  return event.pixelX !== undefined && event.pixelY !== undefined && getRendererCellMetrics(renderer)
-    ? "pixel"
-    : "cell";
-}
-
-export function buildBlankPlotLines(width: number, height: number): string[] {
-  return Array.from({ length: height }, () => " ".repeat(width));
-}