@pibbl/core 0.0.2 → 0.0.3-alpha.109.1

package/dist/features/viz/lib/financial-oscillators.d.ts

@@ -0,0 +1,171 @@
+import type { LineAccessor } from "./types.js";
+/**
+ * Shared inputs for source-aligned closing-price oscillators.
+ *
+ * @see {@link RelativeStrengthIndexPoint}
+ * @see {@link MovingAverageConvergenceDivergencePoint}
+ */
+export interface OscillatorOptions<D> {
+    /**
+     * Numeric property or callback that supplies each closing observation.
+     *
+     * @see {@link LineAccessor}
+     */
+    readonly value: LineAccessor<D>;
+    /**
+     * Excludes a row before its accessor runs and resets the current warmup.
+     *
+     * @param datum - Source observation under consideration.
+     * @param index - Zero-based source index.
+     * @param data - Complete caller-supplied source data.
+     * @returns Whether the observation participates in the consecutive calculation.
+     * @see {@link LineAccessor}
+     */
+    readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;
+}
+/**
+ * Inputs for Wilder's relative strength index.
+ *
+ * @see {@link OscillatorOptions}
+ * @see {@link RelativeStrengthIndexPoint}
+ */
+export interface RelativeStrengthIndexOptions<D> extends OscillatorOptions<D> {
+    /**
+     * Positive safe number of consecutive price changes used by Wilder smoothing.
+     *
+     * @see {@link relativeStrengthIndex}
+     */
+    readonly period: number;
+}
+/**
+ * Inputs for moving average convergence/divergence.
+ *
+ * @see {@link OscillatorOptions}
+ * @see {@link MovingAverageConvergenceDivergencePoint}
+ */
+export interface MovingAverageConvergenceDivergenceOptions<D> extends OscillatorOptions<D> {
+    /** Positive safe EMA period shorter than slowPeriod. */
+    readonly fastPeriod: number;
+    /** Positive safe EMA period longer than fastPeriod. */
+    readonly slowPeriod: number;
+    /** Positive safe EMA period used to smooth available MACD observations. */
+    readonly signalPeriod: number;
+}
+/**
+ * Inputs for the rolling stochastic oscillator.
+ *
+ * @see {@link StochasticOscillatorPoint}
+ * @see {@link LineAccessor}
+ */
+export interface StochasticOscillatorOptions<D> {
+    /** Numeric property or callback that supplies each high. See {@link LineAccessor}. */
+    readonly high: LineAccessor<D>;
+    /** Numeric property or callback that supplies each low. See {@link LineAccessor}. */
+    readonly low: LineAccessor<D>;
+    /** Numeric property or callback that supplies each close. See {@link LineAccessor}. */
+    readonly close: LineAccessor<D>;
+    /** Positive safe count of consecutive OHLC rows in the raw %K range. */
+    readonly lookbackPeriod: number;
+    /** Positive safe count of raw %K values in the smoothed %K average. */
+    readonly kPeriod: number;
+    /** Positive safe count of smoothed %K values in the %D average. */
+    readonly dPeriod: number;
+    /**
+     * Excludes a row before its accessors run and resets all oscillator warmup.
+     *
+     * @param datum - Source observation under consideration.
+     * @param index - Zero-based source index.
+     * @param data - Complete caller-supplied source data.
+     * @returns Whether the observation participates in consecutive windows.
+     * @see {@link LineAccessor}
+     */
+    readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;
+}
+/**
+ * One source-aligned relative strength index observation.
+ *
+ * @see {@link RelativeStrengthIndexOptions}
+ */
+export interface RelativeStrengthIndexPoint<D> {
+    /** Caller-owned original observation. */
+    readonly datum: D;
+    /** Original source index, including rows that become gaps. */
+    readonly sourceIndex: number;
+    /** Wilder RSI from zero through 100, or null during warmup and gaps. */
+    readonly rsi: number | null;
+}
+/**
+ * One source-aligned moving average convergence/divergence observation.
+ *
+ * @see {@link MovingAverageConvergenceDivergenceOptions}
+ */
+export interface MovingAverageConvergenceDivergencePoint<D> {
+    /** Caller-owned original observation. */
+    readonly datum: D;
+    /** Original source index, including rows that become gaps. */
+    readonly sourceIndex: number;
+    /** Fast EMA minus slow EMA, or null before both are seeded. */
+    readonly macd: number | null;
+    /** EMA of available MACD values, or null during signal warmup. */
+    readonly signal: number | null;
+    /** MACD minus its signal, or null before the signal is available. */
+    readonly histogram: number | null;
+}
+/**
+ * One source-aligned stochastic oscillator observation.
+ *
+ * @see {@link StochasticOscillatorOptions}
+ */
+export interface StochasticOscillatorPoint<D> {
+    /** Caller-owned original observation. */
+    readonly datum: D;
+    /** Original source index, including rows that become gaps. */
+    readonly sourceIndex: number;
+    /** Unsmoothed %K from zero through 100, or null during warmup/a zero range. */
+    readonly rawK: number | null;
+    /** SMA-smoothed %K, or null during warmup/a zero range. */
+    readonly k: number | null;
+    /** SMA of smoothed %K, or null during warmup/a zero range. */
+    readonly d: number | null;
+}
+/**
+ * Derives source-aligned Wilder relative strength index observations.
+ *
+ * The first RSI follows a full `period` of consecutive price changes, requiring `period + 1`
+ * consecutive prices. Flat average gain/loss yields 50; gain-only yields 100 and loss-only yields
+ * 0. Missing, nonfinite, and excluded rows produce null and reset the seed.
+ *
+ * @param data - Source observations, retained in their original order.
+ * @param options - Closing value accessor, Wilder period, and optional participation callback.
+ * @returns Frozen source-aligned RSI observations.
+ * @see {@link RelativeStrengthIndexOptions}
+ * @see {@link RelativeStrengthIndexPoint}
+ */
+export declare function relativeStrengthIndex<D>(data: readonly D[], options: RelativeStrengthIndexOptions<D>): readonly RelativeStrengthIndexPoint<D>[];
+/**
+ * Derives source-aligned MACD, signal, and histogram observations from SMA-seeded EMAs.
+ *
+ * Missing, nonfinite, and excluded rows produce null fields and reset all EMA warmup. The MACD
+ * value appears once both price EMAs are seeded; signal and histogram wait for their own EMA seed.
+ *
+ * @param data - Source observations, retained in their original order.
+ * @param options - Closing value accessor, ordered EMA periods, and participation callback.
+ * @returns Frozen source-aligned MACD observations.
+ * @see {@link MovingAverageConvergenceDivergenceOptions}
+ * @see {@link MovingAverageConvergenceDivergencePoint}
+ */
+export declare function movingAverageConvergenceDivergence<D>(data: readonly D[], options: MovingAverageConvergenceDivergenceOptions<D>): readonly MovingAverageConvergenceDivergencePoint<D>[];
+/**
+ * Derives source-aligned rolling stochastic %K, smoothed %K, and %D observations.
+ *
+ * %K uses the trailing high/low range. A zero range yields null raw %K and resets only the %K/%D
+ * smoothing warmup, while its complete OHLC row remains in the rolling range. Missing, nonfinite,
+ * and excluded rows reset every window; malformed finite candles reject.
+ *
+ * @param data - Source OHLC observations, retained in their original order.
+ * @param options - OHLC accessors, rolling periods, and optional participation callback.
+ * @returns Frozen source-aligned stochastic oscillator observations.
+ * @see {@link StochasticOscillatorOptions}
+ * @see {@link StochasticOscillatorPoint}
+ */
+export declare function stochasticOscillator<D>(data: readonly D[], options: StochasticOscillatorOptions<D>): readonly StochasticOscillatorPoint<D>[];

package/dist/features/viz/lib/financial-oscillators.js

@@ -0,0 +1,265 @@
+import { finiteCoordinate, pointAccessor, pointData } from "./point-data.js";
+function positivePeriod(period, name) {
+  if (!Number.isSafeInteger(period) || period <= 0)
+    throw new RangeError(`${name} must be a positive safe integer.`);
+}
+function mean(values) {
+  let scale = 0;
+  for (const value of values) scale = Math.max(scale, Math.abs(value));
+  if (scale === 0) return 0;
+  let sum = 0;
+  for (const value of values) sum += value / scale;
+  const result = sum / values.length * scale;
+  if (!Number.isFinite(result))
+    throw new RangeError("oscillator derived value must be finite.");
+  return result;
+}
+function weighted(previous, next, alpha) {
+  const scale = Math.max(Math.abs(previous), Math.abs(next));
+  if (scale === 0) return 0;
+  const result = (previous / scale * (1 - alpha) + next / scale * alpha) * scale;
+  if (!Number.isFinite(result))
+    throw new RangeError("oscillator derived value must be finite.");
+  return result;
+}
+function rollingPush(values, value, period) {
+  values.push(value);
+  if (values.length > period) values.shift();
+}
+function oscillatorValues(data, options) {
+  const rows = pointData(data, "oscillator");
+  const value = pointAccessor(options.value);
+  return Object.freeze(
+    rows.map((datum, index) => {
+      if (!(options.defined?.(datum, index, rows) ?? true)) return null;
+      const observed = value(datum, index, rows);
+      return finiteCoordinate(observed) ? observed : null;
+    })
+  );
+}
+function relativeStrengthIndex(data, options) {
+  positivePeriod(options.period, "RSI period");
+  const values = oscillatorValues(data, options);
+  const gains = [], losses = [];
+  let previous;
+  let averageGain, averageLoss;
+  return Object.freeze(
+    data.map((datum, sourceIndex) => {
+      const value = values[sourceIndex];
+      if (value === null) {
+        gains.length = 0;
+        losses.length = 0;
+        previous = void 0;
+        averageGain = void 0;
+        averageLoss = void 0;
+        return Object.freeze({ datum, sourceIndex, rsi: null });
+      }
+      if (previous === void 0) {
+        previous = value;
+        return Object.freeze({ datum, sourceIndex, rsi: null });
+      }
+      const change = value - previous;
+      if (!Number.isFinite(change))
+        throw new RangeError("RSI change must be finite.");
+      previous = value;
+      const gain = Math.max(change, 0), loss = Math.max(-change, 0);
+      if (averageGain === void 0 || averageLoss === void 0) {
+        gains.push(gain);
+        losses.push(loss);
+        if (gains.length < options.period)
+          return Object.freeze({ datum, sourceIndex, rsi: null });
+        averageGain = mean(gains);
+        averageLoss = mean(losses);
+      } else {
+        averageGain = weighted(averageGain, gain, 1 / options.period);
+        averageLoss = weighted(averageLoss, loss, 1 / options.period);
+      }
+      const rsi = averageGain === 0 && averageLoss === 0 ? 50 : averageLoss === 0 ? 100 : averageGain === 0 ? 0 : 100 - 100 / (1 + averageGain / averageLoss);
+      if (!Number.isFinite(rsi))
+        throw new RangeError("RSI derived value must be finite.");
+      return Object.freeze({ datum, sourceIndex, rsi });
+    })
+  );
+}
+function movingAverageConvergenceDivergence(data, options) {
+  positivePeriod(options.fastPeriod, "MACD fastPeriod");
+  positivePeriod(options.slowPeriod, "MACD slowPeriod");
+  positivePeriod(options.signalPeriod, "MACD signalPeriod");
+  if (options.fastPeriod >= options.slowPeriod)
+    throw new RangeError("MACD fastPeriod must be less than slowPeriod.");
+  const values = oscillatorValues(data, options);
+  const fastSeed = [], slowSeed = [], signalSeed = [];
+  const fastAlpha = 2 / (options.fastPeriod + 1), slowAlpha = 2 / (options.slowPeriod + 1);
+  const signalAlpha = 2 / (options.signalPeriod + 1);
+  let fast, slow, signal;
+  const reset = () => {
+    fastSeed.length = 0;
+    slowSeed.length = 0;
+    signalSeed.length = 0;
+    fast = void 0;
+    slow = void 0;
+    signal = void 0;
+  };
+  return Object.freeze(
+    data.map((datum, sourceIndex) => {
+      const value = values[sourceIndex];
+      if (value === null) {
+        reset();
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          macd: null,
+          signal: null,
+          histogram: null
+        });
+      }
+      if (fast === void 0) {
+        fastSeed.push(value);
+        if (fastSeed.length === options.fastPeriod) fast = mean(fastSeed);
+      } else fast = weighted(fast, value, fastAlpha);
+      if (slow === void 0) {
+        slowSeed.push(value);
+        if (slowSeed.length === options.slowPeriod) slow = mean(slowSeed);
+      } else slow = weighted(slow, value, slowAlpha);
+      if (fast === void 0 || slow === void 0)
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          macd: null,
+          signal: null,
+          histogram: null
+        });
+      const macd = fast - slow;
+      if (!Number.isFinite(macd))
+        throw new RangeError("MACD derived value must be finite.");
+      if (signal === void 0) {
+        signalSeed.push(macd);
+        if (signalSeed.length === options.signalPeriod)
+          signal = mean(signalSeed);
+      } else signal = weighted(signal, macd, signalAlpha);
+      const histogram = signal === void 0 ? null : macd - signal;
+      if (histogram !== null && !Number.isFinite(histogram))
+        throw new RangeError("MACD histogram must be finite.");
+      return Object.freeze({
+        datum,
+        sourceIndex,
+        macd,
+        signal: signal ?? null,
+        histogram
+      });
+    })
+  );
+}
+function stochasticValues(data, options) {
+  const rows = pointData(data, "stochastic oscillator");
+  const high = pointAccessor(options.high), low = pointAccessor(options.low), close = pointAccessor(options.close);
+  return Object.freeze(
+    rows.map((datum, index) => {
+      if (!(options.defined?.(datum, index, rows) ?? true)) return null;
+      const highValue = high(datum, index, rows);
+      const lowValue = low(datum, index, rows);
+      const closeValue = close(datum, index, rows);
+      if (!finiteCoordinate(highValue) || !finiteCoordinate(lowValue) || !finiteCoordinate(closeValue))
+        return null;
+      const values = {
+        high: highValue,
+        low: lowValue,
+        close: closeValue
+      };
+      if (values.low > values.high || values.close < values.low || values.close > values.high)
+        throw new RangeError(
+          "stochastic oscillator requires low <= close <= high."
+        );
+      return Object.freeze(values);
+    })
+  );
+}
+function stochasticOscillator(data, options) {
+  positivePeriod(options.lookbackPeriod, "stochastic lookbackPeriod");
+  positivePeriod(options.kPeriod, "stochastic kPeriod");
+  positivePeriod(options.dPeriod, "stochastic dPeriod");
+  const values = stochasticValues(data, options);
+  const window = [], kValues = [], dValues = [];
+  const reset = () => {
+    window.length = 0;
+    kValues.length = 0;
+    dValues.length = 0;
+  };
+  const resetSmoothing = () => {
+    kValues.length = 0;
+    dValues.length = 0;
+  };
+  return Object.freeze(
+    data.map((datum, sourceIndex) => {
+      const value = values[sourceIndex];
+      if (value === null) {
+        reset();
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          rawK: null,
+          k: null,
+          d: null
+        });
+      }
+      window.push(value);
+      if (window.length > options.lookbackPeriod) window.shift();
+      if (window.length < options.lookbackPeriod)
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          rawK: null,
+          k: null,
+          d: null
+        });
+      let high = -Infinity, low = Infinity;
+      for (const row of window) {
+        high = Math.max(high, row.high);
+        low = Math.min(low, row.low);
+      }
+      const scale = Math.max(
+        Math.abs(high),
+        Math.abs(low),
+        Math.abs(value.close)
+      );
+      if (scale === 0) {
+        resetSmoothing();
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          rawK: null,
+          k: null,
+          d: null
+        });
+      }
+      const scaledLow = low / scale;
+      const scaledRange = high / scale - scaledLow;
+      if (scaledRange === 0) {
+        resetSmoothing();
+        return Object.freeze({
+          datum,
+          sourceIndex,
+          rawK: null,
+          k: null,
+          d: null
+        });
+      }
+      const rawK = (value.close / scale - scaledLow) / scaledRange * 100;
+      if (!Number.isFinite(rawK))
+        throw new RangeError("stochastic %K must be finite.");
+      rollingPush(kValues, rawK, options.kPeriod);
+      const k = kValues.length === options.kPeriod ? mean(kValues) : null;
+      if (k === null)
+        return Object.freeze({ datum, sourceIndex, rawK, k: null, d: null });
+      rollingPush(dValues, k, options.dPeriod);
+      const d = dValues.length === options.dPeriod ? mean(dValues) : null;
+      return Object.freeze({ datum, sourceIndex, rawK, k, d });
+    })
+  );
+}
+export {
+  movingAverageConvergenceDivergence,
+  relativeStrengthIndex,
+  stochasticOscillator
+};
+//# sourceMappingURL=financial-oscillators.js.map

package/dist/features/viz/lib/financial-oscillators.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/financial-oscillators.ts"],
+  "sourcesContent": ["import type { LineAccessor } from \"./types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\n\n/**\n * Shared inputs for source-aligned closing-price oscillators.\n *\n * @see {@link RelativeStrengthIndexPoint}\n * @see {@link MovingAverageConvergenceDivergencePoint}\n */\nexport interface OscillatorOptions<D> {\n  /**\n   * Numeric property or callback that supplies each closing observation.\n   *\n   * @see {@link LineAccessor}\n   */\n  readonly value: LineAccessor<D>;\n  /**\n   * Excludes a row before its accessor runs and resets the current warmup.\n   *\n   * @param datum - Source observation under consideration.\n   * @param index - Zero-based source index.\n   * @param data - Complete caller-supplied source data.\n   * @returns Whether the observation participates in the consecutive calculation.\n   * @see {@link LineAccessor}\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n}\n\n/**\n * Inputs for Wilder's relative strength index.\n *\n * @see {@link OscillatorOptions}\n * @see {@link RelativeStrengthIndexPoint}\n */\nexport interface RelativeStrengthIndexOptions<D> extends OscillatorOptions<D> {\n  /**\n   * Positive safe number of consecutive price changes used by Wilder smoothing.\n   *\n   * @see {@link relativeStrengthIndex}\n   */\n  readonly period: number;\n}\n\n/**\n * Inputs for moving average convergence/divergence.\n *\n * @see {@link OscillatorOptions}\n * @see {@link MovingAverageConvergenceDivergencePoint}\n */\nexport interface MovingAverageConvergenceDivergenceOptions<\n  D,\n> extends OscillatorOptions<D> {\n  /** Positive safe EMA period shorter than slowPeriod. */\n  readonly fastPeriod: number;\n  /** Positive safe EMA period longer than fastPeriod. */\n  readonly slowPeriod: number;\n  /** Positive safe EMA period used to smooth available MACD observations. */\n  readonly signalPeriod: number;\n}\n\n/**\n * Inputs for the rolling stochastic oscillator.\n *\n * @see {@link StochasticOscillatorPoint}\n * @see {@link LineAccessor}\n */\nexport interface StochasticOscillatorOptions<D> {\n  /** Numeric property or callback that supplies each high. See {@link LineAccessor}. */\n  readonly high: LineAccessor<D>;\n  /** Numeric property or callback that supplies each low. See {@link LineAccessor}. */\n  readonly low: LineAccessor<D>;\n  /** Numeric property or callback that supplies each close. See {@link LineAccessor}. */\n  readonly close: LineAccessor<D>;\n  /** Positive safe count of consecutive OHLC rows in the raw %K range. */\n  readonly lookbackPeriod: number;\n  /** Positive safe count of raw %K values in the smoothed %K average. */\n  readonly kPeriod: number;\n  /** Positive safe count of smoothed %K values in the %D average. */\n  readonly dPeriod: number;\n  /**\n   * Excludes a row before its accessors run and resets all oscillator warmup.\n   *\n   * @param datum - Source observation under consideration.\n   * @param index - Zero-based source index.\n   * @param data - Complete caller-supplied source data.\n   * @returns Whether the observation participates in consecutive windows.\n   * @see {@link LineAccessor}\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n}\n\n/**\n * One source-aligned relative strength index observation.\n *\n * @see {@link RelativeStrengthIndexOptions}\n */\nexport interface RelativeStrengthIndexPoint<D> {\n  /** Caller-owned original observation. */\n  readonly datum: D;\n  /** Original source index, including rows that become gaps. */\n  readonly sourceIndex: number;\n  /** Wilder RSI from zero through 100, or null during warmup and gaps. */\n  readonly rsi: number | null;\n}\n\n/**\n * One source-aligned moving average convergence/divergence observation.\n *\n * @see {@link MovingAverageConvergenceDivergenceOptions}\n */\nexport interface MovingAverageConvergenceDivergencePoint<D> {\n  /** Caller-owned original observation. */\n  readonly datum: D;\n  /** Original source index, including rows that become gaps. */\n  readonly sourceIndex: number;\n  /** Fast EMA minus slow EMA, or null before both are seeded. */\n  readonly macd: number | null;\n  /** EMA of available MACD values, or null during signal warmup. */\n  readonly signal: number | null;\n  /** MACD minus its signal, or null before the signal is available. */\n  readonly histogram: number | null;\n}\n\n/**\n * One source-aligned stochastic oscillator observation.\n *\n * @see {@link StochasticOscillatorOptions}\n */\nexport interface StochasticOscillatorPoint<D> {\n  /** Caller-owned original observation. */\n  readonly datum: D;\n  /** Original source index, including rows that become gaps. */\n  readonly sourceIndex: number;\n  /** Unsmoothed %K from zero through 100, or null during warmup/a zero range. */\n  readonly rawK: number | null;\n  /** SMA-smoothed %K, or null during warmup/a zero range. */\n  readonly k: number | null;\n  /** SMA of smoothed %K, or null during warmup/a zero range. */\n  readonly d: number | null;\n}\n\nfunction positivePeriod(period: number, name: string): void {\n  if (!Number.isSafeInteger(period) || period <= 0)\n    throw new RangeError(`${name} must be a positive safe integer.`);\n}\n\nfunction mean(values: readonly number[]): number {\n  let scale = 0;\n  for (const value of values) scale = Math.max(scale, Math.abs(value));\n  if (scale === 0) return 0;\n  let sum = 0;\n  for (const value of values) sum += value / scale;\n  const result = (sum / values.length) * scale;\n  if (!Number.isFinite(result))\n    throw new RangeError(\"oscillator derived value must be finite.\");\n  return result;\n}\n\nfunction weighted(previous: number, next: number, alpha: number): number {\n  const scale = Math.max(Math.abs(previous), Math.abs(next));\n  if (scale === 0) return 0;\n  const result =\n    ((previous / scale) * (1 - alpha) + (next / scale) * alpha) * scale;\n  if (!Number.isFinite(result))\n    throw new RangeError(\"oscillator derived value must be finite.\");\n  return result;\n}\n\nfunction rollingPush(values: number[], value: number, period: number): void {\n  values.push(value);\n  if (values.length > period) values.shift();\n}\n\nfunction oscillatorValues<D>(\n  data: readonly D[],\n  options: OscillatorOptions<D>,\n): readonly (number | null)[] {\n  const rows = pointData(data, \"oscillator\");\n  const value = pointAccessor(options.value);\n  return Object.freeze(\n    rows.map((datum, index) => {\n      if (!(options.defined?.(datum, index, rows) ?? true)) return null;\n      const observed = value(datum, index, rows);\n      return finiteCoordinate(observed) ? observed : null;\n    }),\n  );\n}\n\n/**\n * Derives source-aligned Wilder relative strength index observations.\n *\n * The first RSI follows a full `period` of consecutive price changes, requiring `period + 1`\n * consecutive prices. Flat average gain/loss yields 50; gain-only yields 100 and loss-only yields\n * 0. Missing, nonfinite, and excluded rows produce null and reset the seed.\n *\n * @param data - Source observations, retained in their original order.\n * @param options - Closing value accessor, Wilder period, and optional participation callback.\n * @returns Frozen source-aligned RSI observations.\n * @see {@link RelativeStrengthIndexOptions}\n * @see {@link RelativeStrengthIndexPoint}\n */\nexport function relativeStrengthIndex<D>(\n  data: readonly D[],\n  options: RelativeStrengthIndexOptions<D>,\n): readonly RelativeStrengthIndexPoint<D>[] {\n  positivePeriod(options.period, \"RSI period\");\n  const values = oscillatorValues(data, options);\n  const gains: number[] = [],\n    losses: number[] = [];\n  let previous: number | undefined;\n  let averageGain: number | undefined, averageLoss: number | undefined;\n  return Object.freeze(\n    data.map((datum, sourceIndex) => {\n      const value = values[sourceIndex];\n      if (value === null) {\n        gains.length = 0;\n        losses.length = 0;\n        previous = undefined;\n        averageGain = undefined;\n        averageLoss = undefined;\n        return Object.freeze({ datum, sourceIndex, rsi: null });\n      }\n      if (previous === undefined) {\n        previous = value;\n        return Object.freeze({ datum, sourceIndex, rsi: null });\n      }\n      const change = value - previous;\n      if (!Number.isFinite(change))\n        throw new RangeError(\"RSI change must be finite.\");\n      previous = value;\n      const gain = Math.max(change, 0),\n        loss = Math.max(-change, 0);\n      if (averageGain === undefined || averageLoss === undefined) {\n        gains.push(gain);\n        losses.push(loss);\n        if (gains.length < options.period)\n          return Object.freeze({ datum, sourceIndex, rsi: null });\n        averageGain = mean(gains);\n        averageLoss = mean(losses);\n      } else {\n        averageGain = weighted(averageGain, gain, 1 / options.period);\n        averageLoss = weighted(averageLoss, loss, 1 / options.period);\n      }\n      const rsi =\n        averageGain === 0 && averageLoss === 0\n          ? 50\n          : averageLoss === 0\n            ? 100\n            : averageGain === 0\n              ? 0\n              : 100 - 100 / (1 + averageGain / averageLoss);\n      if (!Number.isFinite(rsi))\n        throw new RangeError(\"RSI derived value must be finite.\");\n      return Object.freeze({ datum, sourceIndex, rsi });\n    }),\n  );\n}\n\n/**\n * Derives source-aligned MACD, signal, and histogram observations from SMA-seeded EMAs.\n *\n * Missing, nonfinite, and excluded rows produce null fields and reset all EMA warmup. The MACD\n * value appears once both price EMAs are seeded; signal and histogram wait for their own EMA seed.\n *\n * @param data - Source observations, retained in their original order.\n * @param options - Closing value accessor, ordered EMA periods, and participation callback.\n * @returns Frozen source-aligned MACD observations.\n * @see {@link MovingAverageConvergenceDivergenceOptions}\n * @see {@link MovingAverageConvergenceDivergencePoint}\n */\nexport function movingAverageConvergenceDivergence<D>(\n  data: readonly D[],\n  options: MovingAverageConvergenceDivergenceOptions<D>,\n): readonly MovingAverageConvergenceDivergencePoint<D>[] {\n  positivePeriod(options.fastPeriod, \"MACD fastPeriod\");\n  positivePeriod(options.slowPeriod, \"MACD slowPeriod\");\n  positivePeriod(options.signalPeriod, \"MACD signalPeriod\");\n  if (options.fastPeriod >= options.slowPeriod)\n    throw new RangeError(\"MACD fastPeriod must be less than slowPeriod.\");\n  const values = oscillatorValues(data, options);\n  const fastSeed: number[] = [],\n    slowSeed: number[] = [],\n    signalSeed: number[] = [];\n  const fastAlpha = 2 / (options.fastPeriod + 1),\n    slowAlpha = 2 / (options.slowPeriod + 1);\n  const signalAlpha = 2 / (options.signalPeriod + 1);\n  let fast: number | undefined,\n    slow: number | undefined,\n    signal: number | undefined;\n  const reset = () => {\n    fastSeed.length = 0;\n    slowSeed.length = 0;\n    signalSeed.length = 0;\n    fast = undefined;\n    slow = undefined;\n    signal = undefined;\n  };\n  return Object.freeze(\n    data.map((datum, sourceIndex) => {\n      const value = values[sourceIndex];\n      if (value === null) {\n        reset();\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          macd: null,\n          signal: null,\n          histogram: null,\n        });\n      }\n      if (fast === undefined) {\n        fastSeed.push(value);\n        if (fastSeed.length === options.fastPeriod) fast = mean(fastSeed);\n      } else fast = weighted(fast, value, fastAlpha);\n      if (slow === undefined) {\n        slowSeed.push(value);\n        if (slowSeed.length === options.slowPeriod) slow = mean(slowSeed);\n      } else slow = weighted(slow, value, slowAlpha);\n      if (fast === undefined || slow === undefined)\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          macd: null,\n          signal: null,\n          histogram: null,\n        });\n      const macd = fast - slow;\n      if (!Number.isFinite(macd))\n        throw new RangeError(\"MACD derived value must be finite.\");\n      if (signal === undefined) {\n        signalSeed.push(macd);\n        if (signalSeed.length === options.signalPeriod)\n          signal = mean(signalSeed);\n      } else signal = weighted(signal, macd, signalAlpha);\n      const histogram = signal === undefined ? null : macd - signal;\n      if (histogram !== null && !Number.isFinite(histogram))\n        throw new RangeError(\"MACD histogram must be finite.\");\n      return Object.freeze({\n        datum,\n        sourceIndex,\n        macd,\n        signal: signal ?? null,\n        histogram,\n      });\n    }),\n  );\n}\n\ninterface OhlcValue {\n  readonly high: number;\n  readonly low: number;\n  readonly close: number;\n}\n\nfunction stochasticValues<D>(\n  data: readonly D[],\n  options: StochasticOscillatorOptions<D>,\n): readonly (OhlcValue | null)[] {\n  const rows = pointData(data, \"stochastic oscillator\");\n  const high = pointAccessor(options.high),\n    low = pointAccessor(options.low),\n    close = pointAccessor(options.close);\n  return Object.freeze(\n    rows.map((datum, index) => {\n      if (!(options.defined?.(datum, index, rows) ?? true)) return null;\n      const highValue = high(datum, index, rows);\n      const lowValue = low(datum, index, rows);\n      const closeValue = close(datum, index, rows);\n      if (\n        !finiteCoordinate(highValue) ||\n        !finiteCoordinate(lowValue) ||\n        !finiteCoordinate(closeValue)\n      )\n        return null;\n      const values: OhlcValue = {\n        high: highValue,\n        low: lowValue,\n        close: closeValue,\n      };\n      if (\n        values.low > values.high ||\n        values.close < values.low ||\n        values.close > values.high\n      )\n        throw new RangeError(\n          \"stochastic oscillator requires low <= close <= high.\",\n        );\n      return Object.freeze(values);\n    }),\n  );\n}\n\n/**\n * Derives source-aligned rolling stochastic %K, smoothed %K, and %D observations.\n *\n * %K uses the trailing high/low range. A zero range yields null raw %K and resets only the %K/%D\n * smoothing warmup, while its complete OHLC row remains in the rolling range. Missing, nonfinite,\n * and excluded rows reset every window; malformed finite candles reject.\n *\n * @param data - Source OHLC observations, retained in their original order.\n * @param options - OHLC accessors, rolling periods, and optional participation callback.\n * @returns Frozen source-aligned stochastic oscillator observations.\n * @see {@link StochasticOscillatorOptions}\n * @see {@link StochasticOscillatorPoint}\n */\nexport function stochasticOscillator<D>(\n  data: readonly D[],\n  options: StochasticOscillatorOptions<D>,\n): readonly StochasticOscillatorPoint<D>[] {\n  positivePeriod(options.lookbackPeriod, \"stochastic lookbackPeriod\");\n  positivePeriod(options.kPeriod, \"stochastic kPeriod\");\n  positivePeriod(options.dPeriod, \"stochastic dPeriod\");\n  const values = stochasticValues(data, options);\n  const window: OhlcValue[] = [],\n    kValues: number[] = [],\n    dValues: number[] = [];\n  const reset = () => {\n    window.length = 0;\n    kValues.length = 0;\n    dValues.length = 0;\n  };\n  const resetSmoothing = () => {\n    kValues.length = 0;\n    dValues.length = 0;\n  };\n  return Object.freeze(\n    data.map((datum, sourceIndex) => {\n      const value = values[sourceIndex];\n      if (value === null) {\n        reset();\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          rawK: null,\n          k: null,\n          d: null,\n        });\n      }\n      window.push(value);\n      if (window.length > options.lookbackPeriod) window.shift();\n      if (window.length < options.lookbackPeriod)\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          rawK: null,\n          k: null,\n          d: null,\n        });\n      let high = -Infinity,\n        low = Infinity;\n      for (const row of window) {\n        high = Math.max(high, row.high);\n        low = Math.min(low, row.low);\n      }\n      const scale = Math.max(\n        Math.abs(high),\n        Math.abs(low),\n        Math.abs(value.close),\n      );\n      if (scale === 0) {\n        resetSmoothing();\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          rawK: null,\n          k: null,\n          d: null,\n        });\n      }\n      const scaledLow = low / scale;\n      const scaledRange = high / scale - scaledLow;\n      if (scaledRange === 0) {\n        resetSmoothing();\n        return Object.freeze({\n          datum,\n          sourceIndex,\n          rawK: null,\n          k: null,\n          d: null,\n        });\n      }\n      const rawK = ((value.close / scale - scaledLow) / scaledRange) * 100;\n      if (!Number.isFinite(rawK))\n        throw new RangeError(\"stochastic %K must be finite.\");\n      rollingPush(kValues, rawK, options.kPeriod);\n      const k = kValues.length === options.kPeriod ? mean(kValues) : null;\n      if (k === null)\n        return Object.freeze({ datum, sourceIndex, rawK, k: null, d: null });\n      rollingPush(dValues, k, options.dPeriod);\n      const d = dValues.length === options.dPeriod ? mean(dValues) : null;\n      return Object.freeze({ datum, sourceIndex, rawK, k, d });\n    }),\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/graph/bipartite.d.ts

@@ -0,0 +1,14 @@
+import type { PibblNode } from "@pibbl/core";
+import type { BipartiteData, BipartiteGraphProps, BipartiteLayout, BipartiteOptions } from "./types.js";
+/** Arranges two explicit entity sets in columns, retaining side-qualified identity.
+ * @param graph - Explicit left and right entities with cross-set edges. See {@link BipartiteData}.
+ * @param options - Accessors, dimensions, and column spacing. See {@link BipartiteOptions}.
+ * @returns Immutable side-aware nodes and routed edges. See {@link BipartiteLayout}.
+ */
+export declare function layoutBipartite<L, R, E>(graph: BipartiteData<L, R, E>, options: BipartiteOptions<L, R, E>): BipartiteLayout<L, R, E>;
+/** Render left/right entity sets and their cross-set relationships.
+ * @param props - Entity data and presentation.
+ * @returns Canvas node.
+ * @see {@link layoutBipartite}
+ */
+export declare function BipartiteGraph<L, R, E>(props: BipartiteGraphProps<L, R, E>): PibblNode;