@alphacharts/drawings 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,32 @@
+import type { Anchor, ToolDef } from "../types.js";
+export declare function xabcdRatios(x: Anchor, a: Anchor, b: Anchor, c: Anchor, d: Anchor): {
+    abXa: number | null;
+    bcAb: number | null;
+    cdBc: number | null;
+    adXa: number | null;
+};
+export declare function cypherRatios(x: Anchor, a: Anchor, b: Anchor, c: Anchor, d: Anchor): {
+    abXa: number | null;
+    xcXa: number | null;
+    cdXc: number | null;
+};
+export declare function abcdRatios(a: Anchor, b: Anchor, c: Anchor, d: Anchor): {
+    bcAb: number | null;
+    cdBc: number | null;
+};
+export declare function driveRatios(pts: readonly Anchor[]): (number | null)[];
+export declare const xabcd: ToolDef;
+export declare const cypher: ToolDef;
+export declare const abcd: ToolDef;
+export declare const trianglePattern: ToolDef;
+export declare const threeDrives: ToolDef;
+export declare const headAndShoulders: ToolDef;
+export type Degree = "minuette" | "minor" | "intermediate" | "primary";
+/** Wave label for a degree: minuette ((1)), minor 1, intermediate (1), primary [1]. */
+export declare function waveLabel(degree: Degree, n: string): string;
+export declare const elliottImpulse: ToolDef;
+export declare const elliottCorrection: ToolDef;
+export declare const elliottTriangle: ToolDef;
+export declare const elliottDoubleCombo: ToolDef;
+export declare const elliottTripleCombo: ToolDef;
+export declare const patternTools: ToolDef[];

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

@@ -0,0 +1,55 @@
+import type { Bar } from "../source.js";
+import type { Anchor, Drawing, ToolDef } from "../types.js";
+export type Side = "long" | "short";
+export interface PositionInputs {
+    accountSize?: number | null;
+    /** Percent of the account risked between entry and stop. */
+    riskPercent?: number | undefined;
+    lotSize?: number | undefined;
+}
+export interface PositionStats {
+    /** Price distance entry→stop and entry→target (both ≥ 0). */
+    risk: number;
+    reward: number;
+    /** reward / risk, or null when risk is 0. */
+    rr: number | null;
+    riskPct: number;
+    rewardPct: number;
+    /** Units to trade so that a stop-out loses at most accountSize·riskPercent/100; null without an account size or with 0 risk. */
+    qty: number | null;
+    /** qty × reward and qty × risk. */
+    profit: number | null;
+    loss: number | null;
+}
+export declare function positionStats(side: Side, entry: number, target: number, stop: number, o?: PositionInputs): PositionStats;
+export declare function statsOf(side: Side, d: Drawing): PositionStats;
+export declare const longPosition: ToolDef;
+export declare const shortPosition: ToolDef;
+export declare const forecast: ToolDef;
+/** The end of the projected move: same Δprice as a0→a1, started at a2. */
+export declare function projectionTarget(a0: Anchor, a1: Anchor, a2: Anchor): number;
+export declare const projection: ToolDef;
+/** Bars of [lo, hi) shifted so that the first bar's close sits at `price`; times keep their offsets from the first bar. */
+export declare function patternBars(bars: readonly Bar[], price: number): Array<{
+    offsetMs: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}>;
+export declare const barsPattern: ToolDef;
+/** mulberry32: a small seeded PRNG so a ghost feed redraws identically. */
+export declare function seeded(seed: number): () => number;
+/**
+ * `count` synthetic bars: each is a randomly drawn bar of `history` with its
+ * open-relative high/low/close added to the previous synthetic close,
+ * starting from `start`. Deterministic for a seed.
+ */
+export declare function ghostBars(history: readonly Bar[], start: number, count: number, seed: number): Array<{
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+}>;
+export declare const ghostFeed: ToolDef;
+export declare const positionTools: ToolDef[];

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

@@ -0,0 +1,64 @@
+import type { Pt } from "../geometry.js";
+import type { BarSource } from "../source.js";
+import type { Anchor, Drawing, DrawingStyle, Shape, Stroke, ToolCtx, ToolDef } from "../types.js";
+/** Anchor i of a drawing; a missing one is a bug in the caller, not a default. */
+export declare function A(d: Drawing, i: number): Anchor;
+export declare const px: (c: ToolCtx, a: Anchor) => Pt;
+export declare const pxs: (c: ToolCtx, d: Drawing) => Pt[];
+export declare function prop<T>(d: Drawing, key: string): T;
+export declare function numProp(d: Drawing, key: string): number;
+export declare function levelsProp(d: Drawing): number[];
+export declare function line(a: Pt, b: Pt, o?: Stroke & {
+    extA?: boolean;
+    extB?: boolean;
+}): Shape;
+export declare function poly(pts: readonly Pt[], o?: Stroke & {
+    close?: boolean;
+    fill?: string | null;
+}): Shape;
+/** A filled polygon with no outline and no hit-test (bands, shading). */
+export declare function shade(pts: readonly Pt[], fill: string): Shape;
+export declare function text(x: number, y: number, t: string, o?: Omit<Extract<Shape, {
+    k: "text";
+}>, "k" | "x" | "y" | "text">): Shape;
+/** Filled arrow head at b for a shaft from a (hit-test off: the shaft carries the hit). */
+export declare function head(a: Pt, b: Pt, size: number, color: string): Shape;
+/** extendLeft/extendRight are in time terms: map them to the ends of the segment a→b (a may be the later one). */
+export declare function extension(style: DrawingStyle, a: Pt, b: Pt): {
+    extA: boolean;
+    extB: boolean;
+};
+export declare const lerp: (a: Pt, b: Pt, t: number) => Pt;
+export declare const mid: (a: Pt, b: Pt) => Pt;
+export declare function fillOf(style: DrawingStyle, alpha?: number): string;
+export declare function fmtTime(t: number): string;
+/** Whole days/hours/minutes (seconds under a minute) of a duration in ms. */
+export declare function fmtDuration(ms: number): string;
+export interface Measure {
+    dPrice: number;
+    /** Δ/|from|·100, or null when the start price is 0. */
+    pct: number | null;
+    /** Bars from a0 to a1 (fractional between bars), or null without a bar source. */
+    bars: number | null;
+    dTime: number;
+}
+export declare function measure(a0: Anchor, a1: Anchor, source: BarSource | null): Measure;
+export declare function barsText(bars: number): string;
+/** "+12.50 (+0.05%)", then "34 bars, 2h 5m" when known. */
+export declare function measureLines(m: Measure, c: ToolCtx): string[];
+/** Ratio b/a of two price moves, or null when a is 0. */
+export declare function ratio(num: number, den: number): number | null;
+export declare function ratioText(r: number | null): string;
+export declare const FIB_COLORS: Record<string, string>;
+export declare const fibColor: (r: number) => string;
+export declare const FIB_RETRACEMENT: number[];
+export declare const FIB_BASIC: number[];
+/** Tool factory: fills the optional members so definitions stay short. */
+export declare function tool(t: ToolDef): ToolDef;
+export declare const lineDefaults: (style?: Partial<DrawingStyle>, props?: Record<string, unknown>) => () => {
+    style: Partial<DrawingStyle>;
+    props: Record<string, unknown>;
+};
+export declare function needDistinctTimes(d: Drawing, i: number, j: number): void;
+/** Validate every anchor is finite. */
+export declare function finiteAnchors(d: Drawing): void;

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

@@ -0,0 +1,31 @@
+import type { BarSource } from "../source.js";
+import type { ToolDef } from "../types.js";
+export interface VwapSeries {
+    times: Float64Array;
+    values: Float64Array;
+}
+/**
+ * VWAP from bar `start` to the last bar: Σ(typical·volume) / Σ(volume), typical
+ * = (high + low + close) / 3. Bars before the first with volume have no value (NaN).
+ */
+export declare function anchoredVwap(src: BarSource, start: number): VwapSeries;
+/** Index of the bar the anchor sits on: the last bar at or before its time (the first bar if it is earlier than all). */
+export declare function startIndex(src: BarSource, time: number): number | null;
+export declare const anchoredVwapTool: ToolDef;
+export interface VolumeProfile {
+    low: number;
+    high: number;
+    rowHeight: number;
+    volumes: number[];
+    poc: number;
+}
+/**
+ * Bar-level volume profile of bars [lo, hi): a bar's volume is spread over
+ * the rows its [low, high] range overlaps, in proportion to the overlap
+ * (all of it in one row when low = high). This approximates real traded-at-
+ * price volume, which a bar series does not contain. The row volumes sum to
+ * the bars' total volume.
+ */
+export declare function volumeProfile(src: BarSource, lo: number, hi: number, rows: number): VolumeProfile;
+export declare const volumeProfileTool: ToolDef;
+export declare const volumeTools: ToolDef[];

package/dist/types/types.d.ts

@@ -0,0 +1,156 @@
+import type { BarSource } from "./source.js";
+export interface Anchor {
+    /** UTC ms. Not required to be a bar time: it may sit between bars or past the last bar. */
+    time: number;
+    price: number;
+}
+export type Dash = "solid" | "dashed" | "dotted";
+export interface DrawingStyle {
+    color: string;
+    /** CSS px. */
+    width: number;
+    dash: Dash;
+    /** CSS colour with alpha, or null for no fill. */
+    fill: string | null;
+    textColor: string;
+    /** CSS px. */
+    fontSize: number;
+    bold: boolean;
+    italic: boolean;
+    text: string;
+    extendLeft: boolean;
+    extendRight: boolean;
+}
+export interface Drawing {
+    id: string;
+    tool: string;
+    pane: number;
+    anchors: Anchor[];
+    style: DrawingStyle;
+    /** Tool-specific, JSON-safe (levels, account size, seeds …). */
+    props: Record<string, unknown>;
+    locked: boolean;
+    hidden: boolean;
+    /** Chart intervals (bar length in ms) the drawing shows on; null = all. */
+    intervals: number[] | null;
+}
+export interface Stroke {
+    color?: string;
+    width?: number;
+    dash?: Dash;
+    /** false: drawn but not hit-testable (decorations, fills). Default true. */
+    hit?: boolean;
+}
+export type Shape = (Stroke & {
+    k: "line";
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+    extA?: boolean;
+    extB?: boolean;
+}) | (Stroke & {
+    k: "poly";
+    pts: number[];
+    close?: boolean;
+    fill?: string | null;
+    round?: boolean;
+}) | (Stroke & {
+    k: "ellipse";
+    cx: number;
+    cy: number;
+    rx: number;
+    ry: number;
+    rot?: number;
+    fill?: string | null;
+}) | (Stroke & {
+    k: "arc";
+    cx: number;
+    cy: number;
+    r: number;
+    a0: number;
+    a1: number;
+    fill?: string | null;
+}) | (Stroke & {
+    k: "text";
+    x: number;
+    y: number;
+    text: string;
+    align?: "left" | "center" | "right";
+    base?: "top" | "middle" | "bottom";
+    /** Text colour (default: the drawing's text colour). */
+    textColor?: string;
+    size?: number;
+    bg?: string | null;
+    /** Border of the background box. */
+    border?: string | null;
+    pad?: number;
+    /**
+     * A label that gives way: when the pane draws it over another stacking label it is moved down just clear of it
+     * (the price labels of several levels close in price do not print over one another).
+     */
+    stack?: boolean;
+});
+export interface ToolCtx {
+    /** Pane size in CSS px. */
+    readonly W: number;
+    readonly H: number;
+    readonly dpr: number;
+    X(time: number): number;
+    Y(price: number): number;
+    T(x: number): number;
+    P(y: number): number;
+    /** The series' price formatter. */
+    fmt(price: number): string;
+    /** Bars of the main series, for tools that read them (and bar counts). */
+    readonly source: BarSource | null;
+    /** Current chart interval in ms, if known. */
+    readonly interval: number | null;
+}
+export type Gesture = 
+/** Press, drag, release: anchors 0 and 1 (a click then a click works too). Further anchors by click. */
+"drag"
+/** One click per anchor. */
+ | "clicks"
+/** One click. */
+ | "single"
+/** Press-drag-release collecting points. */
+ | "freehand";
+export interface ToolDef {
+    readonly id: string;
+    readonly label: string;
+    readonly family: string;
+    readonly gesture: Gesture;
+    /** Anchors (the minimum for variable tools). 0 for screen-anchored tools. */
+    readonly anchors: number;
+    /** Any number of anchors ≥ `anchors`: finish with double-click or Enter. */
+    readonly variable?: boolean;
+    /** Positioned by props.fx / props.fy (fractions of the pane), not by time and price. */
+    readonly screen?: boolean;
+    /** Reads bars: the plugin must have a BarSource. */
+    readonly needsSource?: boolean;
+    /** No handles (brush strokes: moving the whole stroke only). */
+    readonly noHandles?: boolean;
+    defaults(): {
+        style?: Partial<DrawingStyle>;
+        props?: Record<string, unknown>;
+    };
+    shapes(d: Drawing, c: ToolCtx): Shape[];
+    /** Throw (with context) when anchors or props are not valid for the tool. */
+    validate?(d: Drawing): void;
+    /** Called after anchor `i` was set by an edit; enforce invariants. */
+    constrain?(d: Drawing, i: number): void;
+    /** Fill props that depend on the view when the drawing is created (may throw). */
+    onCreate?(d: Drawing, c: ToolCtx): void;
+    /** Pixel positions of the edit handles, when they differ from the anchors. */
+    handlePoints?(d: Drawing, c: ToolCtx): Array<{
+        x: number;
+        y: number;
+    }>;
+}
+export declare const DEFAULT_STYLE: DrawingStyle;
+export declare const SCHEMA_VERSION = 1;
+export interface DrawingsState {
+    version: typeof SCHEMA_VERSION;
+    drawings: Drawing[];
+}

package/package.json

@@ -1,6 +1,55 @@
 {
   "name": "@alphacharts/drawings",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "description": "Chart drawing tools for alphacharts: 82 tools, undo/redo, magnet and templates.",
+  "keywords": [
+    "drawings",
+    "trendline",
+    "fibonacci",
+    "chart",
+    "trading"
+  ],
+  "license": "MIT",
+  "author": "Alphabench",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alphabench/alphacharts.git",
+    "directory": "packages/drawings"
+  },
+  "homepage": "https://github.com/alphabench/alphacharts#readme",
+  "bugs": {
+    "url": "https://github.com/alphabench/alphacharts/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "@alphacharts/core": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "5.9.3",
+    "vite": "8.3.1",
+    "vitest": "5.0.2",
+    "@alphacharts/core": "0.1.1"
+  },
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json",
+    "typecheck:dist": "tsc -p tsconfig.dist.json",
+    "test": "vitest run"
+  }
 }