@alphacharts/indicators 0.0.0-stage → 0.1.0

package/dist/types/all.d.ts

@@ -0,0 +1,3 @@
+import { ALL_STUDIES } from "./studies/all.js";
+export { ALL_STUDIES };
+export declare function registerAllStudies(): void;

package/dist/types/chart/studies.d.ts

@@ -0,0 +1,165 @@
+import { type Chart, type ChartPlugin, type DataChange, type PluginApi, type PluginPaneView, type Series, type SeriesType } from "@alphacharts/core";
+import { type StudyRunner } from "../runner.js";
+import type { InputValue, Params, StudyDef } from "../types.js";
+export declare const PLUGIN_ID = "alphacharts.studies";
+type AnySeries = Series<SeriesType>;
+type SourceSeries = Series<"candles" | "bars" | "line" | "area" | "histogram">;
+export interface AddStudyOptions {
+    /** Volume series (histogram or line) for studies that need volume. */
+    volume?: Series<"histogram" | "line" | "area">;
+    /** Instance id; default `s<n>`. Layout state is keyed by it. */
+    id?: string;
+    /** Batch evaluation off the UI thread; ticks always run inline. */
+    runner?: StudyRunner;
+    /** Called once when the study is dropped or disposed (removed, source removed, layout restored over it). */
+    onDispose?: () => void;
+    /**
+     * Whether `StudiesPlugin.toJSON` saves this study (default true). A study
+     * that something else rebuilds on restore (a script, through
+     * `restoreScript`) sets it false: the plugin could not recreate it, and a
+     * layout holding it would be refused.
+     */
+    persist?: boolean;
+}
+export interface PlotStyle {
+    color?: string;
+    width?: number;
+}
+export declare class Study {
+    private readonly host;
+    readonly id: string;
+    private readonly source;
+    private readonly volume;
+    private readonly ownRunner?;
+    private readonly onDispose?;
+    readonly def: StudyDef;
+    private params;
+    private engine;
+    private outs;
+    private lines;
+    private styles;
+    private shown;
+    private pane;
+    private scaleId;
+    private version;
+    private job;
+    /** A tick arrived while a job was pending (caught up on adoption). */
+    private dirty;
+    /** A replace/prepend arrived while a job was pending: the job's data is stale. */
+    private structural;
+    /** Set when a computation failed: the study stops following the source and says why. */
+    error: Error | null;
+    private ready_;
+    disposed: boolean;
+    /** Decimals a separate-pane study's axis and labels show when its def does not set `minMove`: two, more when the values are small. */
+    private decimals;
+    /** Whether the plugin saves this study (see `AddStudyOptions.persist`). */
+    persist: boolean;
+    inputs(): Params;
+    get visible(): boolean;
+    /** Resolves when the last requested computation has been applied to the chart. */
+    ready(): Promise<void>;
+    /**
+     * Redraw from the engine's columns after they were written from outside (a
+     * computation that arrives late, e.g. a script worker): the last bar when
+     * `onlyLast`, else every bar.
+     */
+    refresh(onlyLast?: boolean): void;
+    /** Output series, in plot order. */
+    series(): readonly AnySeries[];
+    /** Change inputs; unspecified ones keep their value. Validated before anything changes. */
+    setInputs(partial: Readonly<Record<string, InputValue>>): void;
+    setVisible(visible: boolean): void;
+    setStyle(plotKey: string, style: PlotStyle): void;
+    remove(): void;
+    /** The last computed value of each column (undefined while in warm-up), by column name. */
+    lastValues(): Record<string, number | undefined>;
+    /** Output column `name` over the source bars (a view: copy it to keep it). */
+    column(name: string): Float64Array;
+    /** Bar times of the columns. */
+    times(): Float64Array;
+    /** The study as saved: its id, definition, inputs, source series ids, visibility and styles. `StudiesPlugin.toJSON` is a list of these. */
+    state(): {
+        visible: boolean;
+        styles: Record<string, PlotStyle>;
+        volume?: string;
+        id: string;
+        study: string;
+        inputs: Record<string, InputValue>;
+        source: string;
+    };
+    private get ohlc();
+    private checkSource;
+    /** Whether `d` is the store of one of this study's inputs. */
+    private watches;
+    private bars;
+    private barAt;
+    /** Recompute everything from the source's bars. */
+    private recompute;
+    /** Bring an adopted engine up to the source's current last bars (ticks that arrived during the job). */
+    private catchUp;
+    private fullLoad;
+    private title;
+    private retitle;
+    private color;
+    private seriesOptions;
+    private createSeries;
+    private syncAll;
+    private writeSeries;
+    /** Show enough decimals for values below 1 (three significant digits); only ever grows. A def's own `minMove` wins; an overlay reads like its source. */
+    private widen;
+    /** The output series that draws `column`, or undefined when no plot does (a column that is only an input to others). */
+    seriesOfColumn(column: string): AnySeries | undefined;
+    /** After one appended or revised bar: one point per output series. */
+    private tickSync;
+    private drawMarkers;
+}
+export declare class StudiesPlugin implements ChartPlugin {
+    readonly chart: Chart;
+    readonly runner: StudyRunner | undefined;
+    private readonly resolve;
+    readonly id = "alphacharts.studies";
+    api: PluginApi | null;
+    private readonly studies;
+    private counter;
+    constructor(chart: Chart, runner: StudyRunner | undefined, resolve: (id: string) => StudyDef);
+    install(api: PluginApi): void;
+    uninstall(): void;
+    dataChanged(c: DataChange): void;
+    drawPane(ctx: CanvasRenderingContext2D, view: PluginPaneView): void;
+    list(): Study[];
+    get(id: string): Study | undefined;
+    /** Lowest pane index >= 1 holding no series (reuses a gap), else a new pane. */
+    freePane(): number;
+    add(def: StudyDef, inputs: Readonly<Record<string, InputValue>>, source: SourceSeries, o?: AddStudyOptions, saved?: {
+        visible?: boolean;
+        styles?: Record<string, PlotStyle>;
+    }): Study;
+    removeStudy(id: string): void;
+    /** Drop studies whose source series was removed from the chart. */
+    private reap;
+    /** Never hand out an id at or below `n` again: ids of removed studies stay retired, so an alert that still names one cannot land on a different study. */
+    reserveIds(n: number): void;
+    /** The highest `s<n>` number handed out or restored so far. */
+    idHighWater(): number;
+    private nextId;
+    toJSON(): unknown;
+    /** Throws what `fromJSON(state)` would, changing nothing: the layout is refused whole when a study cannot be rebuilt. */
+    validateState(state: unknown, ctx: {
+        seriesIds: readonly string[];
+    }): void;
+    /** Called after the chart restored its series: rebuild each study over the restored series. */
+    fromJSON(state: unknown): void;
+}
+/** Install the studies plugin on a chart (idempotent). Restoring a layout that holds studies needs this first. */
+export declare function installStudies(chart: Chart, opts?: {
+    runner?: StudyRunner;
+    resolve?: (id: string) => StudyDef;
+}): StudiesPlugin;
+/**
+ * Add a study over `source`. `study` is a definition (tree-shakable) or the id of
+ * a registered one. Throws on unknown inputs, out-of-range values or a source
+ * that lacks what the study needs.
+ */
+export declare function addStudy(chart: Chart, source: SourceSeries, study: StudyDef | string, inputs?: Readonly<Record<string, InputValue>>, opts?: AddStudyOptions): Study;
+export {};

package/dist/types/define.d.ts

@@ -0,0 +1,46 @@
+import type { InputDef, LineStyleName, MarkerShape, PlotDef, StudyDef } from "./types.js";
+export declare const int: (key: string, def: number, min?: number, max?: number, label?: string) => InputDef;
+export declare const float: (key: string, def: number, min?: number, max?: number, step?: number, label?: string) => InputDef;
+export declare const bool: (key: string, def: boolean, label?: string) => InputDef;
+export declare const select: (key: string, def: string, options: readonly string[], label?: string) => InputDef;
+export declare const source: (def?: string, key?: string) => InputDef;
+export declare const COLORS: {
+    readonly blue: "#2962FF";
+    readonly orange: "#FF6D00";
+    readonly red: "#F23645";
+    readonly green: "#089981";
+    readonly purple: "#9C27B0";
+    readonly teal: "#00897B";
+    readonly yellow: "#FBC02D";
+    readonly pink: "#E91E63";
+    readonly gray: "#787B86";
+    readonly lime: "#8BC34A";
+    readonly cyan: "#00BCD4";
+    readonly brown: "#795548";
+};
+export declare const line: (col: string, color: string, o?: {
+    title?: string;
+    key?: string;
+    width?: number;
+    style?: LineStyleName;
+    offset?: number;
+    connect?: boolean;
+}) => PlotDef;
+export declare const hist: (col: string, color: string, colorDown?: string, o?: {
+    title?: string;
+    key?: string;
+}) => PlotDef;
+export declare const areaPlot: (col: string, color: string, o?: {
+    title?: string;
+    key?: string;
+}) => PlotDef;
+export declare const band: (key: string, upper: string, lower: string, color: string, fill: string, title?: string) => PlotDef;
+export declare const fillBetween: (key: string, a: string, b: string, color: string, title?: string) => PlotDef;
+export declare const hline: (key: string, value: number | ((p: import("./types.js").Params) => number), color?: string, style?: LineStyleName) => PlotDef;
+export declare const markers: (col: string, shape: MarkerShape, position: "value" | "above" | "below" | "sign", color: string, o?: {
+    title?: string;
+    key?: string;
+    offset?: number;
+    text?: boolean;
+}) => PlotDef;
+export declare function defineStudy(def: StudyDef): StudyDef;

package/dist/types/engine/graph.d.ts

@@ -0,0 +1,101 @@
+export type Ref = Col | number;
+export declare class Col {
+    v: Float64Array;
+    constructor(cap: number);
+}
+export declare class Node extends Col {
+    /** Evaluate bars [from, to). */
+    run: (from: number, to: number) => void;
+}
+export type SourceName = "open" | "high" | "low" | "close" | "hl2" | "hlc3" | "ohlc4" | "hlcc4";
+export declare const SOURCE_NAMES: readonly SourceName[];
+export declare class Graph {
+    /** Bars currently loaded. */
+    n: number;
+    private cap;
+    /** Every column (inputs, aux, nodes) in creation order: the unit of transfer between threads. */
+    readonly cols: Col[];
+    private readonly nodes;
+    readonly time: Col;
+    readonly open: Col;
+    readonly high: Col;
+    readonly low: Col;
+    readonly close: Col;
+    readonly volume: Col;
+    private readonly sources;
+    constructor(cap?: number);
+    /** An auxiliary column (state a node keeps per bar). */
+    col(): Col;
+    /** Make room for `n` bars; existing values are kept. */
+    reserve(n: number): void;
+    /** Evaluate bars [from, to) on every node. `to` bars must already be loaded. */
+    run(from: number, to: number): void;
+    /** Forget all values (new data is loaded from bar 0). */
+    clear(): void;
+    /** Replace every column by transferred buffers (same builder, same order). */
+    adopt(buffers: readonly Float64Array[], n: number): void;
+    /** A node whose evaluation is `body`; the body reads other columns' `.v` when it runs. */
+    node(body: (self: Node, from: number, to: number) => void): Node;
+    /** Per-bar function of the index; it may read any column at <= i (own columns at <= i-1). */
+    calc(fn: (i: number) => number): Node;
+    /** A constant as a column-compatible value. */
+    private val;
+    src(name: SourceName): Node;
+    map(x: Col, f: (x: number) => number): Node;
+    map2(x: Ref, y: Ref, f: (x: number, y: number) => number): Node;
+    add(x: Ref, y: Ref): Node;
+    sub(x: Ref, y: Ref): Node;
+    mul(x: Ref, y: Ref): Node;
+    /** x / y; a zero divisor gives NaN (absent), never Infinity. */
+    div(x: Ref, y: Ref): Node;
+    max2(x: Ref, y: Ref): Node;
+    min2(x: Ref, y: Ref): Node;
+    abs(x: Col): Node;
+    neg(x: Col): Node;
+    lag(x: Col, k: number): Node;
+    change(x: Col, k?: number): Node;
+    /** Consecutive valid (non-NaN) values of x ending at each bar. */
+    validRun(x: Col): Col;
+    /** Sum over the last p bars (NaN until p valid bars). */
+    sum(x: Col, p: number): Node;
+    sma(x: Col, p: number): Node;
+    /**
+     * Recursive smoothing y = y' + alpha (x - y'), seeded with the simple mean of
+     * the first p valid values (TA-Lib's EMA/Wilder seeding; also Pine's).
+     */
+    smooth(x: Col, p: number, alpha: number): Node;
+    ema(x: Col, p: number): Node;
+    /** Wilder's smoothing (RMA / SMMA). */
+    rma(x: Col, p: number): Node;
+    /** Linearly weighted mean, newest bar weighted p. */
+    wma(x: Col, p: number): Node;
+    /** Highest value over the last p bars. */
+    highest(x: Col, p: number): Node;
+    lowest(x: Col, p: number): Node;
+    /** Bars since the highest/lowest value in the window (0 = this bar); ties pick the most recent. */
+    highestBars(x: Col, p: number, oldest?: boolean): Node;
+    lowestBars(x: Col, p: number, oldest?: boolean): Node;
+    /** `oldest`: ties pick the oldest bar (TA-Lib's MAXINDEX/MININDEX) instead of the newest (Aroon). */
+    private extreme;
+    /**
+     * Population variance over p bars (TA-Lib VAR): mean-centred two-pass over the
+     * window, because running sums of squares lose ~1e-8 relative on price series.
+     */
+    variance(x: Col, p: number): Node;
+    stdev(x: Col, p: number): Node;
+    /**
+     * Least-squares line over the last p bars against x = 0..p-1 (oldest..newest).
+     * `value` is the line at the newest bar; `slope` per bar; `intercept` at the oldest bar.
+     */
+    linreg(x: Col, p: number): {
+        value: Node;
+        slope: Node;
+        intercept: Node;
+    };
+    /** A node that mirrors an aux column (so it can be returned as an output). */
+    alias(c: Col): Node;
+    /** True range: max(h-l, |h-c'|, |l-c'|); the first bar has no previous close, so is absent (TA-Lib TRANGE). */
+    tr(): Node;
+    atr(p: number): Node;
+}
+export declare function checkPeriod(p: number): void;

package/dist/types/engine/kernels.d.ts

@@ -0,0 +1,9 @@
+import type { Kernels } from "@alphacharts/wasm";
+export type BatchKernels = Pick<Kernels, "sumState" | "variance" | "highest" | "lowest" | "highestBars" | "lowestBars" | "linreg">;
+/** Route eligible batch runs through `k`; null restores the JS loops. */
+export declare function setKernels(k: BatchKernels | null): void;
+export declare function kernels(): BatchKernels | null;
+/** Below this many bars the call overhead beats the win. */
+export declare const KERNEL_MIN_BARS = 4096;
+/** A kernel run needs the whole series from bar 0 and no absent values. */
+export declare function eligible(x: Float64Array, from: number, to: number): boolean;

package/dist/types/engine/study.d.ts

@@ -0,0 +1,31 @@
+import { Graph, type Col } from "./graph.js";
+import type { BarColumns, BarInput, InputValue, Params, StudyDef } from "../types.js";
+/** Validate `given` against the study's inputs and fill defaults. Throws on anything unknown or out of range. */
+export declare function resolveParams(def: StudyDef, given?: Readonly<Record<string, InputValue>>): Params;
+/** A study bound to parameters and a graph: appends, revises and batch-loads bars. */
+export declare class StudyEngine {
+    readonly def: StudyDef;
+    readonly graph: Graph;
+    readonly outputs: readonly Col[];
+    readonly params: Params;
+    constructor(def: StudyDef, params?: Readonly<Record<string, InputValue>>);
+    get length(): number;
+    /** Replace all bars and compute. */
+    load(d: BarColumns): void;
+    /**
+     * Like `load`, but evaluates in chunks of `chunk` bars and awaits `pause()`
+     * between them, so a runner can service cancel messages. Stops quietly and
+     * returns false when `cancelled()` turns true.
+     */
+    loadChunked(d: BarColumns, chunk: number, pause: () => Promise<void>, cancelled: () => boolean): Promise<boolean>;
+    /** Append a bar (time later than the last). */
+    push(b: BarInput): void;
+    /** Replace the last bar (a tick revision). */
+    reviseLast(b: BarInput): void;
+    /** Output column `k` as a view over the bars loaded (valid until the next push that grows the graph). */
+    column(k: number): Float64Array;
+    private write;
+    private requireColumns;
+}
+/** One-shot: run a study over columns and return its output columns (copies, length n). */
+export declare function runStudy(def: StudyDef, params: Readonly<Record<string, InputValue>>, d: BarColumns): Float64Array[];

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from "./types.js";
+export { Graph, Col, Node, SOURCE_NAMES } from "./engine/graph.js";
+export type { Ref, SourceName } from "./engine/graph.js";
+export { StudyEngine, resolveParams, runStudy } from "./engine/study.js";
+export { registerStudy, registerStudies, getStudy, listStudies, validateDef } from "./registry.js";
+export { defineStudy } from "./define.js";
+export { addStudy, installStudies, StudiesPlugin, Study, PLUGIN_ID } from "./chart/studies.js";
+export type { AddStudyOptions, PlotStyle } from "./chart/studies.js";
+export { InlineRunner, WorkerRunner, createRunner, serveWorker, CancelledError, CHUNK } from "./runner.js";
+export type { StudyRunner, RunRequest, RunResult, WorkerLike } from "./runner.js";
+export { enableWasm, disableWasm } from "./wasm.js";
+export { setKernels } from "./engine/kernels.js";

package/dist/types/registry.d.ts

@@ -0,0 +1,7 @@
+import type { StudyDef } from "./types.js";
+export declare function registerStudy(def: StudyDef): void;
+export declare function registerStudies(defs: readonly StudyDef[]): void;
+export declare function getStudy(id: string): StudyDef;
+export declare function listStudies(): StudyDef[];
+/** Catch an inconsistent definition when it is registered, not when it is drawn. */
+export declare function validateDef(def: StudyDef): void;

package/dist/types/runner.d.ts

@@ -0,0 +1,82 @@
+import type { BarColumns, InputValue, StudyDef } from "./types.js";
+export declare const CHUNK: number;
+export interface RunRequest {
+    studyId: string;
+    params: Readonly<Record<string, InputValue>>;
+    /** Transferred to the runner when it is a worker: do not use afterwards. */
+    bars: BarColumns;
+}
+export interface RunResult {
+    n: number;
+    /** All graph columns (inputs, state, outputs), in registration order. */
+    buffers: Float64Array[];
+}
+export declare class CancelledError extends Error {
+    constructor();
+}
+export interface StudyRunner {
+    /** Whether this runner can evaluate `def` (a worker only knows built-ins). */
+    canRun(def: StudyDef): boolean;
+    /** Rejects with CancelledError when `cancel(handle)` is called first. */
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel(): void;
+    };
+    dispose(): void;
+}
+/** Main-thread fallback: same chunked evaluation, same cancellation. */
+export declare class InlineRunner implements StudyRunner {
+    canRun(): boolean;
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel: () => undefined;
+    };
+    dispose(): void;
+}
+export interface WorkerLike {
+    postMessage(msg: unknown, transfer?: Transferable[]): void;
+    addEventListener(type: "message", fn: (e: {
+        data: unknown;
+    }) => void): void;
+    addEventListener(type: "error", fn: (e: {
+        message?: string;
+    }) => void): void;
+    terminate(): void;
+}
+type WorkerReply = {
+    type: "result";
+    id: number;
+    n: number;
+    buffers: Float64Array[];
+} | {
+    type: "cancelled";
+    id: number;
+} | {
+    type: "error";
+    id: number;
+    message: string;
+};
+/** Runs built-in studies in a Web Worker. `isBuiltin` says which ids the worker knows. */
+export declare class WorkerRunner implements StudyRunner {
+    private readonly worker;
+    private readonly isBuiltin;
+    private nextId;
+    /** Set once the worker has failed: later runs reject at once instead of waiting on a dead worker. */
+    private dead;
+    private readonly pending;
+    constructor(worker: WorkerLike, isBuiltin: (def: StudyDef) => boolean);
+    canRun(def: StudyDef): boolean;
+    run(def: StudyDef, req: RunRequest): {
+        promise: Promise<RunResult>;
+        cancel: () => void;
+    };
+    dispose(): void;
+}
+/** Worker-side message handler: wire it to `self.onmessage` (see worker.ts). */
+export declare function serveWorker(post: (msg: WorkerReply, transfer?: Transferable[]) => void, find: (id: string) => StudyDef | undefined): (data: unknown) => void;
+/**
+ * A worker runner when Workers exist and start, otherwise the inline fallback.
+ * `factory` creates the worker (default: dist/worker.js next to this module).
+ */
+export declare function createRunner(builtinIds: ReadonlySet<string>, factory?: () => WorkerLike): StudyRunner;
+export {};

package/dist/types/studies/all.d.ts

@@ -0,0 +1,2 @@
+import type { StudyDef } from "../types.js";
+export declare const ALL_STUDIES: readonly StudyDef[];

package/dist/types/studies/cycle.d.ts

@@ -0,0 +1,7 @@
+export declare const htDcPeriod: import("../types.js").StudyDef;
+export declare const htDcPhase: import("../types.js").StudyDef;
+export declare const htPhasor: import("../types.js").StudyDef;
+export declare const htSine: import("../types.js").StudyDef;
+export declare const htTrendline: import("../types.js").StudyDef;
+export declare const htTrendMode: import("../types.js").StudyDef;
+export declare const mama: import("../types.js").StudyDef;

package/dist/types/studies/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./overlap.js";
+export * from "./momentum.js";
+export * from "./volume.js";
+export * from "./volatility.js";
+export * from "./price.js";
+export * from "./statistic.js";
+export * from "./math.js";
+export * from "./cycle.js";
+export * from "./sar.js";
+export * from "./patterns.js";
+export * from "./tv-trend.js";
+export * from "./tv-osc.js";
+export * from "./tv-volume.js";

package/dist/types/studies/ma.d.ts

@@ -0,0 +1,26 @@
+import type { Col, Graph, Node } from "../engine/graph.js";
+export declare const MA_TYPES: readonly ["sma", "ema", "wma", "rma", "dema", "tema", "trima", "kama", "t3"];
+export type MaType = (typeof MA_TYPES)[number];
+/** Kaufman's adaptive MA: efficiency ratio over p bars, fast/slow smoothing limits. TA-Lib seeds with the bar before the first output. */
+export declare function kama(g: Graph, x: Col, p: number, fast?: number, slow?: number): Node;
+/** Tillson T3: six EMAs, volume factor `a`. */
+export declare function t3(g: Graph, x: Col, p: number, a?: number): Node;
+export declare function dema(g: Graph, x: Col, p: number): Node;
+export declare function tema(g: Graph, x: Col, p: number): Node;
+/** Triangular MA: an SMA of an SMA with the periods TA-Lib splits p into. */
+export declare function trima(g: Graph, x: Col, p: number): Node;
+/**
+ * EMA that starts at the first bar `gate` is valid, seeded with the simple
+ * mean of the p values ending there (TA-Lib seeds MACD's fast EMA at the slow
+ * EMA's first bar this way).
+ */
+export declare function emaGated(g: Graph, x: Col, p: number, alpha: number, gate: Col): Node;
+/** EMA seeded with the first value instead of a mean (TA-Lib ADOSC). */
+export declare function emaFirst(g: Graph, x: Col, alpha: number): Node;
+/** One moving average of the given type. */
+export declare function ma(g: Graph, type: MaType, x: Col, p: number): Node;
+/**
+ * `ma`, except that an EMA starts where `gate` first has a value (TA-Lib's APO,
+ * PPO and MACD compute the fast average from the slow average's first bar).
+ */
+export declare function maGated(g: Graph, type: MaType, x: Col, p: number, gate: Col): Node;

package/dist/types/studies/math.d.ts

@@ -0,0 +1,28 @@
+import type { Col } from "../engine/graph.js";
+export declare const acos: import("../types.js").StudyDef;
+export declare const asin: import("../types.js").StudyDef;
+export declare const atan: import("../types.js").StudyDef;
+export declare const ceil: import("../types.js").StudyDef;
+export declare const cos: import("../types.js").StudyDef;
+export declare const cosh: import("../types.js").StudyDef;
+export declare const exp: import("../types.js").StudyDef;
+export declare const floor: import("../types.js").StudyDef;
+export declare const ln: import("../types.js").StudyDef;
+export declare const log10: import("../types.js").StudyDef;
+export declare const sin: import("../types.js").StudyDef;
+export declare const sinh: import("../types.js").StudyDef;
+export declare const sqrt: import("../types.js").StudyDef;
+export declare const tan: import("../types.js").StudyDef;
+export declare const tanh: import("../types.js").StudyDef;
+export declare const add: import("../types.js").StudyDef;
+export declare const sub: import("../types.js").StudyDef;
+export declare const mult: import("../types.js").StudyDef;
+export declare const div: import("../types.js").StudyDef;
+export declare const max: import("../types.js").StudyDef;
+export declare const min: import("../types.js").StudyDef;
+export declare const sum: import("../types.js").StudyDef;
+export declare const maxindex: import("../types.js").StudyDef;
+export declare const minindex: import("../types.js").StudyDef;
+export declare const minmax: import("../types.js").StudyDef;
+export declare const minmaxindex: import("../types.js").StudyDef;
+export type { Col };

package/dist/types/studies/momentum.d.ts

@@ -0,0 +1,30 @@
+export declare const rsi: import("../types.js").StudyDef;
+export declare const cmo: import("../types.js").StudyDef;
+export declare const mom: import("../types.js").StudyDef;
+export declare const roc: import("../types.js").StudyDef;
+export declare const rocp: import("../types.js").StudyDef;
+export declare const rocr: import("../types.js").StudyDef;
+export declare const rocr100: import("../types.js").StudyDef;
+export declare const trix: import("../types.js").StudyDef;
+export declare const apo: import("../types.js").StudyDef;
+export declare const ppo: import("../types.js").StudyDef;
+export declare const macd: import("../types.js").StudyDef;
+export declare const macdfix: import("../types.js").StudyDef;
+export declare const macdext: import("../types.js").StudyDef;
+export declare const stoch: import("../types.js").StudyDef;
+export declare const stochf: import("../types.js").StudyDef;
+export declare const stochrsi: import("../types.js").StudyDef;
+export declare const willr: import("../types.js").StudyDef;
+export declare const cci: import("../types.js").StudyDef;
+export declare const bop: import("../types.js").StudyDef;
+export declare const mfi: import("../types.js").StudyDef;
+export declare const ultosc: import("../types.js").StudyDef;
+export declare const aroon: import("../types.js").StudyDef;
+export declare const aroonosc: import("../types.js").StudyDef;
+export declare const adx: import("../types.js").StudyDef;
+export declare const adxr: import("../types.js").StudyDef;
+export declare const dx: import("../types.js").StudyDef;
+export declare const plusDi: import("../types.js").StudyDef;
+export declare const minusDi: import("../types.js").StudyDef;
+export declare const plusDm: import("../types.js").StudyDef;
+export declare const minusDm: import("../types.js").StudyDef;

package/dist/types/studies/overlap.d.ts

@@ -0,0 +1,14 @@
+export declare const sma: import("../types.js").StudyDef;
+export declare const ema: import("../types.js").StudyDef;
+export declare const wma: import("../types.js").StudyDef;
+export declare const dema: import("../types.js").StudyDef;
+export declare const tema: import("../types.js").StudyDef;
+export declare const trima: import("../types.js").StudyDef;
+export declare const kama: import("../types.js").StudyDef;
+export declare const t3: import("../types.js").StudyDef;
+export declare const ma: import("../types.js").StudyDef;
+export declare const bbands: import("../types.js").StudyDef;
+export declare const bbpb: import("../types.js").StudyDef;
+export declare const bbw: import("../types.js").StudyDef;
+export declare const midpoint: import("../types.js").StudyDef;
+export declare const midprice: import("../types.js").StudyDef;

package/dist/types/studies/patterns.d.ts

@@ -0,0 +1,62 @@
+import type { StudyDef } from "../types.js";
+export declare const cdl2Crows: StudyDef;
+export declare const cdl3BlackCrows: StudyDef;
+export declare const cdl3Inside: StudyDef;
+export declare const cdl3LineStrike: StudyDef;
+export declare const cdl3Outside: StudyDef;
+export declare const cdl3StarsInSouth: StudyDef;
+export declare const cdl3WhiteSoldiers: StudyDef;
+export declare const cdlAbandonedBaby: StudyDef;
+export declare const cdlAdvanceBlock: StudyDef;
+export declare const cdlBeltHold: StudyDef;
+export declare const cdlBreakaway: StudyDef;
+export declare const cdlClosingMarubozu: StudyDef;
+export declare const cdlConcealBabySwall: StudyDef;
+export declare const cdlCounterAttack: StudyDef;
+export declare const cdlDarkCloudCover: StudyDef;
+export declare const cdlDoji: StudyDef;
+export declare const cdlDojiStar: StudyDef;
+export declare const cdlDragonflyDoji: StudyDef;
+export declare const cdlEngulfing: StudyDef;
+export declare const cdlEveningDojiStar: StudyDef;
+export declare const cdlEveningStar: StudyDef;
+export declare const cdlGapSideSideWhite: StudyDef;
+export declare const cdlGravestoneDoji: StudyDef;
+export declare const cdlHammer: StudyDef;
+export declare const cdlHangingMan: StudyDef;
+export declare const cdlHarami: StudyDef;
+export declare const cdlHaramiCross: StudyDef;
+export declare const cdlHighWave: StudyDef;
+export declare const cdlHikkake: StudyDef;
+export declare const cdlHikkakeMod: StudyDef;
+export declare const cdlHomingPigeon: StudyDef;
+export declare const cdlIdentical3Crows: StudyDef;
+export declare const cdlInNeck: StudyDef;
+export declare const cdlInvertedHammer: StudyDef;
+export declare const cdlKicking: StudyDef;
+export declare const cdlKickingByLength: StudyDef;
+export declare const cdlLadderBottom: StudyDef;
+export declare const cdlLongLeggedDoji: StudyDef;
+export declare const cdlLongLine: StudyDef;
+export declare const cdlMarubozu: StudyDef;
+export declare const cdlMatchingLow: StudyDef;
+export declare const cdlMatHold: StudyDef;
+export declare const cdlMorningDojiStar: StudyDef;
+export declare const cdlMorningStar: StudyDef;
+export declare const cdlOnNeck: StudyDef;
+export declare const cdlPiercing: StudyDef;
+export declare const cdlRickshawMan: StudyDef;
+export declare const cdlRiseFall3Methods: StudyDef;
+export declare const cdlSeparatingLines: StudyDef;
+export declare const cdlShootingStar: StudyDef;
+export declare const cdlShortLine: StudyDef;
+export declare const cdlSpinningTop: StudyDef;
+export declare const cdlStalledPattern: StudyDef;
+export declare const cdlStickSandwich: StudyDef;
+export declare const cdlTakuri: StudyDef;
+export declare const cdlTasukiGap: StudyDef;
+export declare const cdlThrusting: StudyDef;
+export declare const cdlTriStar: StudyDef;
+export declare const cdlUnique3River: StudyDef;
+export declare const cdlUpsideGap2Crows: StudyDef;
+export declare const cdlXSideGap3Methods: StudyDef;