gloomberb 0.9.9 → 0.10.0

package/src/sync/core-contributors.ts

@@ -1,4 +1,5 @@
 import { scheduleConfigSave } from "../state/config-save-scheduler";
+import { stableStringify } from "../remote/revision";
 import type { AppConfig, BrokerInstanceConfig } from "../types/config";
 import type { PricePoint, TickerFinancials } from "../types/financials";
 import type { Portfolio, TickerMetadata, TickerPosition, TickerRecord, Watchlist } from "../types/ticker";
@@ -11,7 +12,18 @@ import {
   computeWeightedPortfolioReturns,
   type WeightedReturnSeries,
 } from "../plugins/builtin/analytics/metrics";
-import { getSyncedProfileAnalytics } from "./profile-analytics";
+import {
+  getSyncedProfileAnalytics,
+  setSyncedProfileAnalytics,
+} from "./profile-analytics";
+import {
+  addLegacyBuiltinDisabledPluginAliases,
+  addLegacyBuiltinPaneStatePluginAliases,
+  addLegacyBuiltinPluginOwnerAliases,
+  normalizeBuiltinDisabledPluginIds,
+  normalizeBuiltinPaneStatePluginOwners,
+  normalizeBuiltinPluginStateMap,
+} from "../plugins/ownership";
 
 const SENSITIVE_KEY_PATTERN = /(token|secret|password|credential|private|api[_-]?key|access[_-]?key|refresh[_-]?key|session|cookie|dataDir|path|directory|localPath)/i;
 
@@ -151,12 +163,19 @@ function collectCoreConfigPayload(config: AppConfig) {
     portfolios: config.portfolios.map(sanitizePortfolio),
     watchlists: config.watchlists.map(sanitizeWatchlist),
     layout: config.layout,
-    layouts: config.layouts,
+    layouts: config.layouts.map((savedLayout) => (
+      savedLayout.paneState
+        ? {
+          ...savedLayout,
+          paneState: addLegacyBuiltinPaneStatePluginAliases(savedLayout.paneState),
+        }
+        : savedLayout
+    )),
     activeLayoutIndex: config.activeLayoutIndex,
     brokerInstances: config.brokerInstances.map(sanitizeBrokerInstance),
-    disabledPlugins: config.disabledPlugins,
+    disabledPlugins: addLegacyBuiltinDisabledPluginAliases(config.disabledPlugins),
     disabledSources: config.disabledSources,
-    pluginConfig: config.pluginConfig,
+    pluginConfig: addLegacyBuiltinPluginOwnerAliases(config.pluginConfig),
     theme: config.theme,
     chartPreferences: config.chartPreferences,
     valueFlashingEnabled: config.valueFlashingEnabled,
@@ -295,32 +314,88 @@ function collectCoreCollectionsPayload(
   };
 }
 
-function mergeConfigPayload(config: AppConfig, payload: unknown): AppConfig | null {
+function hydrateProfileAnalytics(payload: Record<string, unknown>): void {
+  if (!isPlainObject(payload.analyticsByPortfolio)) return;
+  for (const [portfolioId, analytics] of Object.entries(payload.analyticsByPortfolio)) {
+    if (!isPlainObject(analytics)) continue;
+    setSyncedProfileAnalytics(portfolioId, {
+      oneYearReturn: typeof analytics.oneYearReturn === "number" ? analytics.oneYearReturn : null,
+      spyBeta: typeof analytics.spyBeta === "number" ? analytics.spyBeta : null,
+    });
+  }
+}
+
+function valuesEqual(left: unknown, right: unknown): boolean {
+  return stableStringify(left) === stableStringify(right);
+}
+
+function isPluginStateMap(value: unknown): value is Record<string, Record<string, unknown>> {
+  return isPlainObject(value) && Object.values(value).every(isPlainObject);
+}
+
+function normalizeSyncedLayouts(layouts: AppConfig["layouts"]): AppConfig["layouts"] {
+  return layouts.map((savedLayout) => {
+    if (!isPlainObject(savedLayout)) return savedLayout;
+    if (!isPluginStateMap(savedLayout.paneState)) return savedLayout;
+    return {
+      ...savedLayout,
+      paneState: normalizeBuiltinPaneStatePluginOwners(savedLayout.paneState),
+    };
+  });
+}
+
+function mergeConfigPayload(
+  config: AppConfig,
+  payload: unknown,
+  baselineConfig: AppConfig = config,
+): AppConfig | null {
   if (!isPlainObject(payload)) return null;
   const next: AppConfig = { ...config };
+  const canApply = <K extends keyof AppConfig>(key: K) => (
+    valuesEqual(config[key], baselineConfig[key])
+  );
   const assign = <K extends keyof AppConfig>(key: K) => {
-    if (key in payload) {
+    if (key in payload && canApply(key)) {
       next[key] = payload[key as string] as AppConfig[K];
     }
   };
 
   assign("baseCurrency");
   assign("refreshIntervalMinutes");
-  assign("layout");
-  assign("layouts");
-  assign("activeLayoutIndex");
-  assign("disabledPlugins");
+  assign("portfolios");
+  assign("watchlists");
   assign("disabledSources");
-  assign("pluginConfig");
   assign("theme");
   assign("chartPreferences");
   assign("valueFlashingEnabled");
   assign("recentTickers");
   assign("onboardingComplete");
 
-  if (Array.isArray(payload.portfolios)) next.portfolios = payload.portfolios as Portfolio[];
-  if (Array.isArray(payload.watchlists)) next.watchlists = payload.watchlists as Watchlist[];
-  if (Array.isArray(payload.brokerInstances)) {
+  if (
+    canApply("disabledPlugins")
+    && Array.isArray(payload.disabledPlugins)
+    && payload.disabledPlugins.every((pluginId) => typeof pluginId === "string")
+  ) {
+    next.disabledPlugins = normalizeBuiltinDisabledPluginIds(payload.disabledPlugins);
+  }
+  if (canApply("pluginConfig") && isPluginStateMap(payload.pluginConfig)) {
+    next.pluginConfig = normalizeBuiltinPluginStateMap(payload.pluginConfig);
+  }
+
+  const layoutStateUntouched = config.layout === baselineConfig.layout
+    && config.layouts === baselineConfig.layouts
+    && config.activeLayoutIndex === baselineConfig.activeLayoutIndex;
+  if (
+    layoutStateUntouched
+    && ["layout", "layouts", "activeLayoutIndex"].every((key) => key in payload)
+    && Array.isArray(payload.layouts)
+  ) {
+    next.layout = payload.layout as unknown as AppConfig["layout"];
+    next.layouts = normalizeSyncedLayouts(payload.layouts as AppConfig["layouts"]);
+    next.activeLayoutIndex = payload.activeLayoutIndex as number;
+  }
+
+  if (Array.isArray(payload.brokerInstances) && canApply("brokerInstances")) {
     const incoming = payload.brokerInstances as Array<Partial<BrokerInstanceConfig>>;
     const existingById = new Map(config.brokerInstances.map((instance) => [instance.id, instance]));
     next.brokerInstances = incoming.map((instance) => {
@@ -343,9 +418,9 @@ export const coreConfigSyncContributor: SyncContributor = {
   id: "core.config",
   schemaVersion: 1,
   collect: ({ state }) => collectCoreConfigPayload(state.config),
-  apply: (payload, { state, dispatch }) => {
-    const nextConfig = mergeConfigPayload(state.config, payload);
-    if (!nextConfig) return;
+  apply: (payload, { baselineState, state, dispatch }) => {
+    const nextConfig = mergeConfigPayload(state.config, payload, baselineState.config);
+    if (!nextConfig || valuesEqual(nextConfig, state.config)) return;
     dispatch({ type: "SET_CONFIG", config: nextConfig });
     scheduleConfigSave(nextConfig);
   },
@@ -360,18 +435,16 @@ export const coreCollectionsSyncContributor: SyncContributor = {
     state.financials,
     state.exchangeRates,
   ),
-  apply: async (payload, { state, dispatch, tickerRepository }) => {
+  apply: async (payload, { getState, isCurrent, dispatch, tickerRepository }) => {
     if (!isPlainObject(payload)) return;
-    const nextConfig = { ...state.config };
-    if (Array.isArray(payload.portfolios)) nextConfig.portfolios = payload.portfolios as Portfolio[];
-    if (Array.isArray(payload.watchlists)) nextConfig.watchlists = payload.watchlists as Watchlist[];
-
-    const nextTickers = new Map(state.tickers);
+    hydrateProfileAnalytics(payload);
+    const incomingRecords: TickerRecord[] = [];
     const rawTickers = Array.isArray(payload.tickers) ? payload.tickers : [];
     for (const rawTicker of rawTickers) {
+      if (!isCurrent()) return;
       if (!isPlainObject(rawTicker)) continue;
       const current = typeof rawTicker.ticker === "string"
-        ? nextTickers.get(rawTicker.ticker)
+        ? getState().tickers.get(rawTicker.ticker)
         : null;
       const metadata = hydrateTickerMetadata({
         ...current?.metadata,
@@ -380,12 +453,15 @@ export const coreCollectionsSyncContributor: SyncContributor = {
       });
       const record: TickerRecord = { metadata };
       await tickerRepository.saveTicker(record);
-      nextTickers.set(metadata.ticker, record);
+      incomingRecords.push(record);
     }
 
-    dispatch({ type: "SET_CONFIG", config: nextConfig });
+    if (!isCurrent() || incomingRecords.length === 0) return;
+    const nextTickers = new Map(getState().tickers);
+    for (const record of incomingRecords) {
+      nextTickers.set(record.metadata.ticker, record);
+    }
     dispatch({ type: "SET_TICKERS", tickers: nextTickers });
-    scheduleConfigSave(nextConfig);
   },
 };
 
@@ -397,4 +473,5 @@ export const __syncContributorInternalsForTests = {
   sanitizeUnknown,
   collectCoreConfigPayload,
   collectCoreCollectionsPayload,
+  mergeConfigPayload,
 };

package/src/sync/react.ts

@@ -6,6 +6,7 @@ import { cloudSyncController } from "./controller";
 
 interface CloudSyncRuntimeOptions {
   state: AppState;
+  getState: () => AppState;
   dispatch: Dispatch<AppAction>;
   tickerRepository: TickerRepository;
   pluginRegistry: PluginRegistry;
@@ -14,28 +15,25 @@ interface CloudSyncRuntimeOptions {
 
 export function useCloudSyncRuntime({
   state,
+  getState,
   dispatch,
   tickerRepository,
   pluginRegistry,
   initialized,
 }: CloudSyncRuntimeOptions): void {
   useEffect(() => {
-    cloudSyncController.setRuntime({
-      state,
+    return cloudSyncController.setRuntime({
+      getState,
       dispatch,
       tickerRepository,
       getContributors: () => pluginRegistry.getEnabledSyncContributors(),
       getTransport: () => pluginRegistry.getActiveSyncTransport(),
     });
-  }, [dispatch, pluginRegistry, state, tickerRepository]);
-
-  useEffect(() => () => {
-    cloudSyncController.clearRuntime();
-  }, []);
+  }, [dispatch, getState, pluginRegistry, tickerRepository]);
 
   useEffect(() => {
     if (!initialized) return;
-    void cloudSyncController.pullLatest();
+    void cloudSyncController.requestSync({ reason: "startup" });
   }, [initialized, pluginRegistry]);
 
   useEffect(() => {

package/src/sync/types.ts

@@ -25,7 +25,10 @@ export interface SyncCollectContext {
 
 export interface SyncApplyContext {
   snapshot: SyncSnapshot;
+  baselineState: AppState;
   state: AppState;
+  getState: () => AppState;
+  isCurrent: () => boolean;
   dispatch: Dispatch<AppAction>;
   tickerRepository: TickerRepository;
 }

package/src/time-series/alignment.ts

@@ -0,0 +1,158 @@
+import type { ResolvedSeries, TimeSeriesPoint } from "./types";
+
+export interface AlignmentOptions {
+  mode?: "union" | "intersection";
+  timeline?: readonly Date[];
+  carryForward?: boolean;
+  maxCarryMilliseconds?: number;
+  start?: Date;
+  end?: Date;
+}
+
+export interface AlignedSeriesValue {
+  point: TimeSeriesPoint;
+  value: number | null;
+  carried: boolean;
+}
+
+export interface AlignedTimeSeriesRow {
+  date: Date;
+  values: Record<string, AlignedSeriesValue | null>;
+}
+
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+export function scalarPointValue(point: TimeSeriesPoint): number | null {
+  return finiteNumber(point.value)
+    ? point.value
+    : finiteNumber(point.close)
+      ? point.close
+      : null;
+}
+
+function sortedUniquePoints(points: readonly TimeSeriesPoint[]): TimeSeriesPoint[] {
+  const byTime = new Map<number, TimeSeriesPoint>();
+  for (const point of points) {
+    const time = point.date.getTime();
+    if (Number.isFinite(time)) byTime.set(time, point);
+  }
+  return [...byTime.values()].sort((left, right) => left.date.getTime() - right.date.getTime());
+}
+
+export function effectiveTimeSeriesPointTime(point: TimeSeriesPoint): number {
+  const pointTime = point.date.getTime();
+  const availableTime = point.availableAt?.getTime();
+  return finiteNumber(availableTime) ? Math.max(pointTime, availableTime) : pointTime;
+}
+
+/**
+ * Aligns heterogeneous observations on one timeline. Step series carry their
+ * last known value forward only after `availableAt`; values are never filled
+ * backward before the first public observation.
+ */
+export function alignTimeSeries(
+  sourceSeries: readonly ResolvedSeries[],
+  options: AlignmentOptions = {},
+): AlignedTimeSeriesRow[] {
+  const series = sourceSeries.map((entry) => ({ ...entry, points: sortedUniquePoints(entry.points) }));
+  const start = options.start?.getTime() ?? Number.NEGATIVE_INFINITY;
+  const end = options.end?.getTime() ?? Number.POSITIVE_INFINITY;
+  const timeline = new Set<number>();
+  for (const date of options.timeline ?? []) {
+    const time = date.getTime();
+    if (Number.isFinite(time) && time >= start && time <= end) timeline.add(time);
+  }
+  if (!options.timeline) {
+    for (const entry of series) {
+      for (const point of entry.points) {
+        const time = point.date.getTime();
+        if (time >= start && time <= end) timeline.add(time);
+        const effectiveTime = effectiveTimeSeriesPointTime(point);
+        if (effectiveTime !== time && effectiveTime >= start && effectiveTime <= end) {
+          timeline.add(effectiveTime);
+        }
+      }
+    }
+  }
+
+  const exactMaps = series.map((entry) => (
+    new Map(entry.points.map((point) => [effectiveTimeSeriesPointTime(point), point]))
+  ));
+  const sortedTimes = [...timeline].sort((left, right) => left - right);
+  const rows: AlignedTimeSeriesRow[] = [];
+  for (const time of sortedTimes) {
+    const values: Record<string, AlignedSeriesValue | null> = {};
+    series.forEach((entry, seriesIndex) => {
+      const exact = exactMaps[seriesIndex]!.get(time);
+      if (exact) {
+        values[entry.id] = { point: exact, value: scalarPointValue(exact), carried: false };
+        return;
+      }
+      const allowCarry = options.carryForward ?? entry.interpolation === "step-after";
+      if (!allowCarry) {
+        values[entry.id] = null;
+        return;
+      }
+
+      let previous: TimeSeriesPoint | null = null;
+      let previousEligibleAt = Number.NEGATIVE_INFINITY;
+      for (const point of entry.points) {
+        const eligibleAt = effectiveTimeSeriesPointTime(point);
+        if (eligibleAt <= time && eligibleAt >= previousEligibleAt) {
+          previous = point;
+          previousEligibleAt = eligibleAt;
+        }
+      }
+      if (!previous) {
+        values[entry.id] = null;
+        return;
+      }
+      const age = time - previousEligibleAt;
+      if (options.maxCarryMilliseconds !== undefined && age > options.maxCarryMilliseconds) {
+        values[entry.id] = null;
+        return;
+      }
+      values[entry.id] = {
+        point: previous,
+        value: scalarPointValue(previous),
+        carried: true,
+      };
+    });
+    if (options.mode !== "intersection" || series.every((entry) => values[entry.id] !== null)) {
+      rows.push({ date: new Date(time), values });
+    }
+  }
+  return rows;
+}
+
+export function firstCommonValueDate(series: readonly ResolvedSeries[]): Date | null {
+  const row = alignTimeSeries(series, { mode: "intersection" }).find((entry) => (
+    series.every(({ id }) => finiteNumber(entry.values[id]?.value))
+  ));
+  return row ? new Date(row.date) : null;
+}
+
+/** Returns visible points and optionally the prior step anchor needed to draw continuity. */
+export function clipSeriesToWindow(
+  series: ResolvedSeries,
+  start: Date,
+  end: Date,
+  includeStepAnchor = true,
+): ResolvedSeries {
+  const startTime = start.getTime();
+  const endTime = end.getTime();
+  const sorted = sortedUniquePoints(series.points);
+  const visible = sorted.filter((point) => {
+    const time = point.date.getTime();
+    return time >= startTime && time <= endTime;
+  });
+  if (includeStepAnchor && series.interpolation === "step-after") {
+    const anchor = [...sorted].reverse().find((point) => (
+      effectiveTimeSeriesPointTime(point) <= startTime && point.date.getTime() < startTime
+    ));
+    if (anchor) visible.unshift(anchor);
+  }
+  return { ...series, points: visible };
+}

package/src/time-series/economic.ts

@@ -0,0 +1,49 @@
+import type { TimeSeriesPoint } from "./types";
+
+export interface FredObservationLike {
+  date: string;
+  value: string | number | null;
+  realtime_start?: string;
+  realtimeStart?: string;
+}
+
+export interface FredExtractionOptions {
+  timestampMode?: "available-at" | "period-end";
+  providerId?: string;
+}
+
+function parsedDate(value: unknown): Date | null {
+  if (typeof value !== "string") return null;
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? date : null;
+}
+
+/** Converts FRED observations or vintage observations without coupling to a network client. */
+export function extractFredSeries(
+  observations: readonly FredObservationLike[],
+  options: FredExtractionOptions = {},
+): TimeSeriesPoint[] {
+  const points: TimeSeriesPoint[] = [];
+  for (const observation of observations) {
+    const observedAt = parsedDate(observation.date);
+    const numericValue = typeof observation.value === "number"
+      ? observation.value
+      : typeof observation.value === "string" && observation.value.trim() !== ""
+        ? Number(observation.value)
+        : Number.NaN;
+    if (!observedAt || !Number.isFinite(numericValue)) continue;
+    const availableAt = parsedDate(observation.realtime_start ?? observation.realtimeStart);
+    points.push({
+      date: options.timestampMode !== "period-end" && availableAt ? availableAt : observedAt,
+      observedAt,
+      availableAt: availableAt ?? undefined,
+      value: numericValue,
+      periodLabel: observation.date,
+      provenance: {
+        providerId: options.providerId ?? "fred",
+        quality: "reported",
+      },
+    });
+  }
+  return points.sort((left, right) => left.date.getTime() - right.date.getTime());
+}