@alphacharts/drawings 0.0.0-stage → 0.1.0

package/dist/types/emitter.d.ts

@@ -0,0 +1,7 @@
+export declare class Emitter<E extends {
+    [K in keyof E]: unknown;
+}> {
+    private readonly map;
+    on<K extends keyof E>(type: K, fn: (e: E[K]) => void): () => void;
+    emit<K extends keyof E>(type: K, e: E[K]): void;
+}

package/dist/types/geometry.d.ts

@@ -0,0 +1,34 @@
+export interface Pt {
+    x: number;
+    y: number;
+}
+export declare function dist(x1: number, y1: number, x2: number, y2: number): number;
+/** Distance from (px, py) to the segment (x1,y1)-(x2,y2). */
+export declare function distToSegment(px: number, py: number, x1: number, y1: number, x2: number, y2: number): number;
+/**
+ * The part of the line through a→b to draw inside [-m, W+m]×[-m, H+m]:
+ * the segment itself, plus the ray beyond a (extA) and/or beyond b (extB).
+ * Null when nothing of it is inside.
+ */
+export declare function clipLine(x1: number, y1: number, x2: number, y2: number, extA: boolean, extB: boolean, W: number, H: number, m?: number): [number, number, number, number] | null;
+/** Flat [x0,y0,x1,y1,…] points of an ellipse (rotated by rot), n segments. */
+export declare function ellipsePoints(cx: number, cy: number, rx: number, ry: number, rot: number, n?: number): number[];
+/** Flat points along a circular arc from angle a0 to a1 (radians, y down). */
+export declare function arcPoints(cx: number, cy: number, r: number, a0: number, a1: number): number[];
+/** Quadratic Bézier points p0, control c, p1. */
+export declare function quadPoints(p0: Pt, c: Pt, p1: Pt, n?: number): number[];
+/** The quadratic control point that makes the curve p0→p1 pass through `through` at t = 0.5. */
+export declare function controlThrough(p0: Pt, through: Pt, p1: Pt): Pt;
+/** Circle through three points, or null when they are collinear. */
+export declare function circumcircle(a: Pt, b: Pt, c: Pt): {
+    cx: number;
+    cy: number;
+    r: number;
+} | null;
+export declare function pointInPolygon(px: number, py: number, pts: readonly number[]): boolean;
+/** Distance from a point to a polyline (flat xy), optionally closed. */
+export declare function distToPolyline(px: number, py: number, pts: readonly number[], close: boolean): number;
+/** Intersection of lines a1→a2 and b1→b2, or null when parallel. */
+export declare function intersect(a1: Pt, a2: Pt, b1: Pt, b2: Pt): Pt | null;
+/** Filled arrow head at (x2,y2) for a line coming from (x1,y1): flat polygon. */
+export declare function arrowHead(x1: number, y1: number, x2: number, y2: number, size: number): number[];

package/dist/types/history.d.ts

@@ -0,0 +1,87 @@
+import type { Drawing } from "./types.js";
+export declare class DrawingStore {
+    private items;
+    private index;
+    /** Back to front: later = on top. */
+    get list(): readonly Drawing[];
+    get(id: string): Drawing | undefined;
+    require(id: string): Drawing;
+    insert(d: Drawing, at: number): void;
+    remove(id: string): number;
+    /** Replace the drawing with the same id, in place in the order. */
+    replace(d: Drawing): void;
+    setOrder(ids: readonly string[]): void;
+    clear(): void;
+    snapshot(): string;
+}
+export declare const clone: <T>(v: T) => T;
+export interface Command {
+    readonly label: string;
+    /** Ids of drawings the command touches (for events). */
+    readonly ids: readonly string[];
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class AddCommand implements Command {
+    private readonly d;
+    private readonly at;
+    readonly label = "add";
+    readonly ids: readonly string[];
+    constructor(d: Drawing, at: number);
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class RemoveCommand implements Command {
+    readonly label = "remove";
+    readonly ids: readonly string[];
+    /** Ascending by index. */
+    private readonly entries;
+    constructor(entries: Array<{
+        d: Drawing;
+        at: number;
+    }>);
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class PatchCommand implements Command {
+    readonly label: string;
+    private readonly before;
+    private readonly after;
+    readonly ids: readonly string[];
+    constructor(label: string, before: Drawing[], after: Drawing[]);
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class ReorderCommand implements Command {
+    private readonly before;
+    private readonly after;
+    readonly label = "reorder";
+    readonly ids: readonly string[];
+    constructor(before: string[], after: string[]);
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class BatchCommand implements Command {
+    readonly label: string;
+    private readonly cmds;
+    readonly ids: readonly string[];
+    constructor(label: string, cmds: Command[]);
+    apply(s: DrawingStore): void;
+    revert(s: DrawingStore): void;
+}
+export declare class History {
+    private readonly store;
+    private readonly max;
+    private undoStack;
+    private redoStack;
+    constructor(store: DrawingStore, max?: number);
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    /** Apply a new command and make it undoable; clears redo. */
+    run(c: Command): void;
+    /** Record a command whose effect is already in the store (a finished drag). */
+    record(c: Command): void;
+    undo(): Command | undefined;
+    redo(): Command | undefined;
+    clear(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,26 @@
+export { DrawingsPlugin, DRAG_SLOP, DUPLICATE_BARS, TOLERANCE, WEAK_MAGNET_PX } from "./plugin.js";
+export type { DrawingPatch, DrawingsEvents, DrawingsOptions, MagnetMode, NewDrawing } from "./plugin.js";
+export { DrawingStore, History, AddCommand, BatchCommand, PatchCommand, RemoveCommand, ReorderCommand } from "./history.js";
+export type { Command } from "./history.js";
+export { ArrayBarSource } from "./source.js";
+export type { Bar, BarSource, ColumnarBars } from "./source.js";
+export { TemplateStore } from "./templates.js";
+export type { DrawingTemplate } from "./templates.js";
+export { DEFAULT_STYLE, SCHEMA_VERSION } from "./types.js";
+export type { Anchor, Dash, Drawing, DrawingStyle, DrawingsState, Gesture, Shape, Stroke, ToolCtx, ToolDef } from "./types.js";
+export { drawShapes, shapeDistance, shapeInRect, withAlpha } from "./shapes.js";
+export * as geometry from "./geometry.js";
+export { allTools } from "./tools/all.js";
+export { lineTools, trendLine, ray, infoLine, extendedLine, horizontalLine, horizontalRay, verticalLine, crossLine } from "./tools/lines.js";
+export { channelTools, parallelChannel, regressionTrendChannel, flatTopBottom, disjointChannel, pitchfork, schiffPitchfork, modifiedSchiffPitchfork, insidePitchfork, pitchfan, regression, regressionOf, forkGeometry, } from "./tools/channels.js";
+export { fibTools, fibRetracement, fibExtension, fibChannel, fibTimeZone, fibSpeedFan, fibTrendTime, fibCircles, fibSpiral, fibSpeedArcs, fibWedge, fibRetracementPrice, fibExtensionPrice, FIB_SEQUENCE, } from "./tools/fib.js";
+export { gannTools, gannBox, gannSquareFixed, gannSquare, gannFan, gannBoxPrice, gannFanPrice, GANN_RATIOS } from "./tools/gann.js";
+export { figureTools, rectangle, rotatedRectangle, ellipse, circle, triangle, arc, curve, doubleCurve, polyline, path, brush, highlighter, rotatedRectCorners, arcThrough, } from "./tools/figures.js";
+export { annotationTools, textTool, anchoredText, note, anchoredNote, callout, comment, priceLabel, priceNote, signpost, flagMark, arrow, arrowMarker, arrowMarkUp, arrowMarkDown, } from "./tools/annotations.js";
+export { positionTools, longPosition, shortPosition, forecast, projection, barsPattern, ghostFeed, positionStats, patternBars, ghostBars, projectionTarget, seeded, } from "./tools/position.js";
+export type { PositionStats, PositionInputs } from "./tools/position.js";
+export { measureTools, dateRange, priceRange, dateAndPriceRange } from "./tools/measure.js";
+export { patternTools, xabcd, cypher, abcd, trianglePattern, threeDrives, headAndShoulders, elliottImpulse, elliottCorrection, elliottTriangle, elliottDoubleCombo, elliottTripleCombo, xabcdRatios, cypherRatios, abcdRatios, driveRatios, waveLabel, } from "./tools/patterns.js";
+export { cycleTools, cyclicLines, timeCycles, sineLine, sineY } from "./tools/cycles.js";
+export { volumeTools, anchoredVwapTool, volumeProfileTool, anchoredVwap, volumeProfile, startIndex } from "./tools/volume.js";
+export { measure, fmtDuration, fmtTime } from "./tools/util.js";

package/dist/types/plugin.d.ts

@@ -0,0 +1,207 @@
+import type { ChartPlugin, LayoutStore, PluginApi, PluginPaneView, PluginPointer } from "@alphacharts/core";
+import { Emitter } from "./emitter.js";
+import type { BarSource } from "./source.js";
+import { TemplateStore } from "./templates.js";
+import { type Anchor, type Drawing, type DrawingStyle, type DrawingsState, type ToolDef } from "./types.js";
+export type MagnetMode = "off" | "weak" | "strong";
+export interface DrawingsOptions {
+    tools: readonly ToolDef[];
+    /** Plugin id (key in layout JSON). Default "drawings". */
+    id?: string;
+    /** Bars of the main series: needed by bar-reading tools, bar counts and the magnet. */
+    source?: BarSource;
+    /** Current chart interval in ms (for per-interval visibility); default: the source's. */
+    interval?: number;
+    magnet?: MagnetMode;
+    /** Stay in the tool after a drawing is finished. */
+    continuous?: boolean;
+    /** Templates and favourites storage. */
+    store?: LayoutStore;
+    /** A tool failed to draw or a gesture produced an invalid drawing. Default: console.error. */
+    onError?: (error: Error, drawing: Drawing | null) => void;
+}
+export interface DrawingsEvents {
+    created: Drawing;
+    changed: Drawing;
+    removed: Drawing;
+    selected: string[];
+    tool: string | null;
+    history: {
+        canUndo: boolean;
+        canRedo: boolean;
+    };
+}
+export interface NewDrawing {
+    tool: string;
+    anchors?: Anchor[];
+    pane?: number;
+    id?: string;
+    style?: Partial<DrawingStyle>;
+    props?: Record<string, unknown>;
+    locked?: boolean;
+    hidden?: boolean;
+    intervals?: number[] | null;
+}
+export type DrawingPatch = Partial<Pick<Drawing, "anchors" | "locked" | "hidden" | "intervals">> & {
+    style?: Partial<DrawingStyle>;
+    props?: Record<string, unknown>;
+};
+/** Pixels the pointer must travel before a press-release counts as a drag. */
+export declare const DRAG_SLOP = 4;
+/** Hit tolerance in CSS px by pointer type. */
+export declare const TOLERANCE: Record<string, number>;
+/** Weak magnet radius in CSS px. */
+export declare const WEAK_MAGNET_PX = 16;
+/** Duplicate offsets a copy by this many bars in time (never in price). */
+export declare const DUPLICATE_BARS = 5;
+export declare class DrawingsPlugin implements ChartPlugin {
+    private readonly options;
+    readonly id: string;
+    readonly events: Emitter<DrawingsEvents>;
+    private loading;
+    /**
+     * True while `fromJSON` emits its `removed` / `created` events: they describe
+     * a layout being loaded, not something the user drew or deleted, so a listener
+     * that mirrors drawings elsewhere (a sync between charts) must not act on them.
+     */
+    get restoring(): boolean;
+    readonly templates: TemplateStore | null;
+    private api;
+    private readonly tools;
+    private readonly store;
+    private readonly history;
+    private readonly selected;
+    private hover;
+    private tool;
+    private creating;
+    private drag;
+    private clipboard;
+    private nextId;
+    private last;
+    private source;
+    private intervalMs;
+    private magnetMode;
+    private readonly continuous;
+    private readonly onError;
+    private readonly reported;
+    private measureCanvas;
+    constructor(options: DrawingsOptions);
+    install(api: PluginApi): void;
+    uninstall(): void;
+    dataChanged(): void;
+    viewChanged(): void;
+    toolDef(id: string): ToolDef;
+    toolIds(): string[];
+    setSource(source: BarSource | null): void;
+    /** Current chart interval in ms; drawings with `intervals` show only when it is listed. */
+    setInterval(ms: number | null): void;
+    setMagnet(mode: MagnetMode): void;
+    magnet(): MagnetMode;
+    list(): Drawing[];
+    get(id: string): Drawing | undefined;
+    selection(): string[];
+    activeTool(): string | null;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    private newId;
+    private build;
+    /** Throws with context unless `d` is a valid drawing of a registered tool. */
+    validate(d: Drawing): void;
+    /** Create a drawing; returns a copy. Throws when invalid. */
+    add(spec: NewDrawing): Drawing;
+    /** Change a drawing (programmatic: locks do not apply). */
+    update(id: string, patch: DrawingPatch): Drawing;
+    private applyPatch;
+    /** Update several drawings as one undo step. */
+    updateMany(ids: readonly string[], patch: DrawingPatch): void;
+    remove(ids: readonly string[]): void;
+    clear(): void;
+    private exec;
+    private afterMutation;
+    undo(): boolean;
+    redo(): boolean;
+    private peekUndo;
+    private peekRedo;
+    select(ids: readonly string[]): void;
+    selectAll(): void;
+    setTool(id: string | null): void;
+    /** The anchor (time, price) under a pane pixel: for creating drawings from code at screen positions. */
+    anchorAt(pane: number, x: number, y: number): Anchor;
+    /** Pane pixel of an anchor. */
+    pixelOf(pane: number, a: Anchor): {
+        x: number;
+        y: number;
+    };
+    private reorder;
+    bringToFront(ids?: readonly string[]): void;
+    sendToBack(ids?: readonly string[]): void;
+    /** Move each selected drawing one step up past the nearest unselected one. */
+    bringForward(ids?: readonly string[]): void;
+    sendBackward(ids?: readonly string[]): void;
+    /** Copy the selection (or `ids`) to the plugin's clipboard; returns the copies. */
+    copy(ids?: readonly string[]): Drawing[];
+    /**
+     * Paste the clipboard as new drawings (one undo step) and select them. With
+     * `at`, the first copy's first anchor lands there and the others keep their
+     * offsets; without, the copies sit exactly on the originals.
+     */
+    paste(at?: {
+        time: number;
+        price: number;
+    }): Drawing[];
+    /** Copy + paste the selection shifted by DUPLICATE_BARS bars in time (price unchanged). */
+    duplicate(): Drawing[];
+    private barMs;
+    private pasteShifted;
+    /** Save a drawing's style as a named template for its tool. */
+    saveTemplate(id: string, name: string): Promise<void>;
+    /** Apply a saved template's style and props to drawings of that tool (one undo step). */
+    applyTemplate(ids: readonly string[], name: string): Promise<void>;
+    toJSON(): DrawingsState;
+    /** Throws what `fromJSON(state)` would, changing nothing (the core's `restoreState` calls it before it replaces anything). */
+    validateState(state: unknown): void;
+    private parseState;
+    fromJSON(state: unknown): void;
+    private render;
+    private report;
+    private measure;
+    private sourceInterval;
+    private ctxFor;
+    private visible;
+    private shapesOf;
+    private handlePoints;
+    private tolerance;
+    /**
+     * What is under a pane point: a handle of a selected drawing first (topmost
+     * selected wins), else the topmost visible drawing within `tol` px.
+     */
+    hitTest(pane: number, x: number, y: number, tol?: number): {
+        id: string;
+        handle: number | null;
+    } | null;
+    /** Snap a pointer position to the nearest bar's O/H/L/C according to the magnet mode. */
+    snap(e: Pick<PluginPointer, "pane" | "x" | "y" | "time" | "price">): Anchor;
+    drawPane(ctx: CanvasRenderingContext2D, view: PluginPaneView): void;
+    /** The drawing being created, with the rubber-band anchor filling the rest. */
+    private previewDrawing;
+    private constrainAll;
+    pointer(e: PluginPointer): boolean;
+    private onDown;
+    private beginCreate;
+    private onMove;
+    private dragMove;
+    private dragHandle;
+    private onUp;
+    private finishBox;
+    /** Select every visible drawing of a pane with a point inside the rectangle (CSS px). */
+    selectInRect(pane: number, x0: number, y0: number, x1: number, y1: number): string[];
+    private upCreate;
+    private onClick;
+    private onDouble;
+    private finishVariable;
+    cancelCreate(): void;
+    private commit;
+    cursor(pane: number, x: number, y: number): string | null;
+    key(e: KeyboardEvent): boolean;
+    private cancelDrag;
+}

package/dist/types/shapes.d.ts

@@ -0,0 +1,25 @@
+import type { Dash, DrawingStyle, Shape } from "./types.js";
+export declare function dashPattern(d: Dash, w: number): number[];
+/** `color` with its alpha replaced by `a` (0..1), as an rgba() string. */
+export declare function withAlpha(color: string, a: number): string;
+export declare function font(style: DrawingStyle, size?: number): string;
+export interface TextBox {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Text box of a text shape; `measure` returns the text width in px. */
+export declare function textBox(s: Extract<Shape, {
+    k: "text";
+}>, style: DrawingStyle, measure: (text: string, font: string) => number): TextBox;
+export declare function drawShapes(ctx: CanvasRenderingContext2D, shapes: readonly Shape[], style: DrawingStyle, W: number, H: number, opts?: {
+    widthBoost?: number;
+}): void;
+/**
+ * Distance 0 when (x, y) is inside a filled shape or a text box, else the
+ * distance to the nearest stroke; Infinity when the shape is not hittable.
+ */
+export declare function shapeDistance(s: Shape, x: number, y: number, W: number, H: number, style: DrawingStyle, measure: (t: string, f: string) => number): number;
+/** True when any outline vertex (or a text box corner) of the shape lies in the rectangle. */
+export declare function shapeInRect(s: Shape, x0: number, y0: number, x1: number, y1: number, W: number, H: number): boolean;

package/dist/types/source.d.ts

@@ -0,0 +1,60 @@
+export interface Bar {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface BarSource {
+    /** Bumps on every mutation: caches key on it. */
+    readonly version: number;
+    readonly length: number;
+    /** Bar at array position i (0 = oldest). Throws when out of range. */
+    at(i: number): Bar;
+    /** Bar whose time is nearest to `time`, or undefined when empty. */
+    nearest(time: number): Bar | undefined;
+    /** Fractional position of `time` in the bar sequence: integer at a bar, linear between bars, extrapolated by the median interval outside. */
+    logical(time: number): number;
+    /** Inverse of logical(). */
+    timeAtLogical(l: number): number;
+    /** Index range [lo, hi) of bars with from <= time <= to. */
+    range(from: number, to: number): [number, number];
+    /** Median bar interval in ms. */
+    readonly interval: number;
+}
+export interface ColumnarBars {
+    time: ArrayLike<number>;
+    open: ArrayLike<number>;
+    high: ArrayLike<number>;
+    low: ArrayLike<number>;
+    close: ArrayLike<number>;
+    volume?: ArrayLike<number> | undefined;
+}
+export declare class ArrayBarSource implements BarSource {
+    private t;
+    private o;
+    private h;
+    private l;
+    private c;
+    private v;
+    private ver;
+    private cachedInterval;
+    constructor(data?: ColumnarBars);
+    get version(): number;
+    get length(): number;
+    setData(d: ColumnarBars): void;
+    /** Same time replaces the last bar; a later time appends. */
+    update(b: Bar): void;
+    /** Older history, all earlier than the first bar. */
+    prepend(d: ColumnarBars): void;
+    private touch;
+    at(i: number): Bar;
+    /** First index with time >= t. */
+    private lower;
+    nearest(time: number): Bar | undefined;
+    get interval(): number;
+    logical(time: number): number;
+    timeAtLogical(l: number): number;
+    range(from: number, to: number): [number, number];
+}

package/dist/types/templates.d.ts

@@ -0,0 +1,25 @@
+import type { LayoutStore } from "@alphacharts/core";
+import type { Drawing, DrawingStyle } from "./types.js";
+export interface DrawingTemplate {
+    version: 1;
+    tool: string;
+    name: string;
+    style: DrawingStyle;
+    props: Record<string, unknown>;
+}
+export declare class TemplateStore {
+    private readonly store;
+    private readonly prefix;
+    constructor(store: LayoutStore, prefix?: string);
+    private key;
+    /** Save a drawing's style and props as a template for its tool. */
+    save(name: string, d: Drawing): Promise<void>;
+    load(tool: string, name: string): Promise<DrawingTemplate>;
+    list(tool?: string): Promise<Array<{
+        tool: string;
+        name: string;
+    }>>;
+    remove(tool: string, name: string): Promise<void>;
+    favourites(): Promise<string[]>;
+    setFavourite(tool: string, on: boolean): Promise<string[]>;
+}

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

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

package/dist/types/tools/annotations.d.ts

@@ -0,0 +1,16 @@
+import type { ToolDef } from "../types.js";
+export declare const textTool: ToolDef;
+export declare const anchoredText: ToolDef;
+export declare const note: ToolDef;
+export declare const anchoredNote: ToolDef;
+export declare const callout: ToolDef;
+export declare const comment: ToolDef;
+export declare const priceLabel: ToolDef;
+export declare const priceNote: ToolDef;
+export declare const signpost: ToolDef;
+export declare const flagMark: ToolDef;
+export declare const arrow: ToolDef;
+export declare const arrowMarker: ToolDef;
+export declare const arrowMarkUp: ToolDef;
+export declare const arrowMarkDown: ToolDef;
+export declare const annotationTools: ToolDef[];

package/dist/types/tools/channels.d.ts

@@ -0,0 +1,43 @@
+import type { Pt } from "../geometry.js";
+import type { BarSource } from "../source.js";
+import type { ToolDef } from "../types.js";
+export declare const parallelChannel: ToolDef;
+export interface Regression {
+    slope: number;
+    intercept: number;
+    /** Population standard deviation of the residuals. */
+    sigma: number;
+    n: number;
+}
+/** Ordinary least squares of y on x = 0..n-1. */
+export declare function regression(y: readonly number[]): Regression;
+export declare function regressionOf(source: BarSource, t0: number, t1: number): {
+    reg: Regression;
+    lo: number;
+    hi: number;
+};
+export declare const regressionTrendChannel: ToolDef;
+export declare const flatTopBottom: ToolDef;
+export declare const disjointChannel: ToolDef;
+export type ForkVariant = "standard" | "schiff" | "modifiedSchiff" | "inside";
+/**
+ * Where the median line starts and the points the two outer tines pass
+ * through. The median always runs to the midpoint M of B and C; tines are
+ * parallel to it.
+ * - standard: from A; tines through B and C.
+ * - schiff: from (A.x, midpoint price of A and B).
+ * - modifiedSchiff: from the midpoint of A and B.
+ * - inside: from A; tines through the midpoints of A–B and A–C.
+ */
+export declare function forkGeometry(v: ForkVariant, a: Pt, b: Pt, cc: Pt): {
+    origin: Pt;
+    m: Pt;
+    t1: Pt;
+    t2: Pt;
+};
+export declare const pitchfork: ToolDef;
+export declare const schiffPitchfork: ToolDef;
+export declare const modifiedSchiffPitchfork: ToolDef;
+export declare const insidePitchfork: ToolDef;
+export declare const pitchfan: ToolDef;
+export declare const channelTools: ToolDef[];

package/dist/types/tools/cycles.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDef } from "../types.js";
+export declare const cyclicLines: ToolDef;
+export declare const timeCycles: ToolDef;
+/** y of the sine through two consecutive extrema (x0,y0) and (x1,y1) at x. */
+export declare function sineY(x0: number, y0: number, x1: number, y1: number, x: number): number;
+export declare const sineLine: ToolDef;
+export declare const cycleTools: ToolDef[];

package/dist/types/tools/fib.d.ts

@@ -0,0 +1,22 @@
+import type { Anchor, Drawing, ToolDef } from "../types.js";
+import { FIB_BASIC, fillOf } from "./util.js";
+/** Retracement: level 0 is a1, level 1 is a0. */
+export declare const fibRetracementPrice: (a0: Anchor, a1: Anchor, r: number) => number;
+/** Trend-based extension: level 0 is c, 1 projects the full a→b move from c. */
+export declare const fibExtensionPrice: (a: Anchor, b: Anchor, c: Anchor, r: number) => number;
+export declare const FIB_SEQUENCE: number[];
+export declare const fibRetracement: ToolDef;
+export declare const fibExtension: ToolDef;
+export declare const fibChannel: ToolDef;
+export declare const fibTimeZone: ToolDef;
+export declare const FIB_FAN: number[];
+export declare const fibSpeedFan: ToolDef;
+export declare const fibTrendTime: ToolDef;
+export declare const fibCircles: ToolDef;
+export declare const fibSpiral: ToolDef;
+export declare const FIB_ARCS: number[];
+export declare const fibSpeedArcs: ToolDef;
+export declare const fibWedge: ToolDef;
+export declare const fibTools: ToolDef[];
+export { FIB_BASIC, fillOf };
+export type { Drawing };

package/dist/types/tools/figures.d.ts

@@ -0,0 +1,27 @@
+import { type Pt } from "../geometry.js";
+import type { ToolDef } from "../types.js";
+import { A, needDistinctTimes, px } from "./util.js";
+export declare const rectangle: ToolDef;
+/** Corners of the rectangle with edge a→b and perpendicular extent through c. */
+export declare function rotatedRectCorners(a: Pt, b: Pt, c: Pt): [Pt, Pt, Pt, Pt];
+export declare const rotatedRectangle: ToolDef;
+export declare const ellipse: ToolDef;
+export declare const circle: ToolDef;
+export declare const triangle: ToolDef;
+/** Arc from a to b through m on their circumcircle: [cx, cy, r, from, to] in radians, or null when collinear. */
+export declare function arcThrough(a: Pt, b: Pt, m: Pt): {
+    cx: number;
+    cy: number;
+    r: number;
+    a0: number;
+    a1: number;
+} | null;
+export declare const arc: ToolDef;
+export declare const curve: ToolDef;
+export declare const doubleCurve: ToolDef;
+export declare const polyline: ToolDef;
+export declare const path: ToolDef;
+export declare const brush: ToolDef;
+export declare const highlighter: ToolDef;
+export declare const figureTools: ToolDef[];
+export { A, needDistinctTimes, px };

package/dist/types/tools/gann.d.ts

@@ -0,0 +1,11 @@
+import type { Anchor, ToolDef } from "../types.js";
+/** Price at fraction r of the way from a0 to a1. */
+export declare const gannBoxPrice: (a0: Anchor, a1: Anchor, r: number) => number;
+/** Gann fan: the line through a0 whose slope is num/den times the 1×1 slope (a0→a1); its price at a1's time. */
+export declare const gannFanPrice: (a0: Anchor, a1: Anchor, num: number, den: number) => number;
+export declare const GANN_RATIOS: ReadonlyArray<readonly [number, number]>;
+export declare const gannBox: ToolDef;
+export declare const gannSquare: ToolDef;
+export declare const gannSquareFixed: ToolDef;
+export declare const gannFan: ToolDef;
+export declare const gannTools: ToolDef[];

package/dist/types/tools/lines.d.ts

@@ -0,0 +1,12 @@
+import type { ToolDef } from "../types.js";
+import { needDistinctTimes } from "./util.js";
+export declare const trendLine: ToolDef;
+export declare const ray: ToolDef;
+export declare const extendedLine: ToolDef;
+export declare const infoLine: ToolDef;
+export declare const horizontalLine: ToolDef;
+export declare const horizontalRay: ToolDef;
+export declare const verticalLine: ToolDef;
+export declare const crossLine: ToolDef;
+export declare const lineTools: ToolDef[];
+export { needDistinctTimes };

package/dist/types/tools/measure.d.ts

@@ -0,0 +1,7 @@
+import type { ToolDef } from "../types.js";
+import { measureLines } from "./util.js";
+export declare const dateRange: ToolDef;
+export declare const priceRange: ToolDef;
+export declare const dateAndPriceRange: ToolDef;
+export declare const measureTools: ToolDef[];
+export { measureLines };