tickup 1.0.0

package/dist/components/TickUpHost.d.ts

@@ -0,0 +1,162 @@
+import React from 'react';
+import { Interval } from '../types/Interval';
+import { PriceRange, TimeRange, VisibleViewRanges } from '../types/Graph';
+import { DeepPartial, ChartTheme } from '../types/types';
+import { ChartOptions, TimeDetailLevel } from '../types/chartOptions';
+import { Mode } from '../contexts/ModeContext';
+import type { LiveDataApplyResult, LiveDataPlacement } from '../types/liveData';
+import type { DrawingInput, DrawingPatch, DrawingSpec } from './Drawing/drawHelper';
+import type { DrawingQuery, DrawingSnapshot } from './Drawing/drawingQuery';
+import type { ChartContextInfo } from '../types/chartContext';
+import type { IDrawingShape } from './Drawing/IDrawingShape';
+import { TickUpProductId } from '../types/tickupProducts';
+import type { TickUpChartEngine } from '../engines/TickUpEngine';
+/**
+ * Imperative API for {@link TickUpHost} and product components
+ * (`TickUpCommand`, `TickUpPulse`, …). Pass a React `ref` typed as this interface.
+ */
+export interface TickUpHostHandle {
+    addShape: (shape: DrawingInput) => void;
+    updateShape: (shapeId: string, newShape: DrawingInput | DrawingPatch) => void;
+    patchShape: (shapeId: string, patch: DrawingPatch) => void;
+    setDrawingsFromSpecs: (specs: DrawingSpec[]) => void;
+    deleteShape: (shapeId: string) => void;
+    addInterval: (interval: Interval) => void;
+    updateInterval: (index: number, newInterval: Interval) => void;
+    deleteInterval: (index: number) => void;
+    applyLiveData: (updates: Interval | Interval[], placement: LiveDataPlacement) => LiveDataApplyResult;
+    fitVisibleRangeToData: () => void;
+    /**
+     * If the last bar has moved past the right edge of the window, pans the view by the minimum amount
+     * so it stays visible (same time span when possible). No-op when already in view.
+     */
+    nudgeVisibleTimeRangeToLatest: (options?: {
+        trailingPaddingSec?: number;
+    }) => void;
+    getMainCanvasElement: () => HTMLCanvasElement | null;
+    getViewInfo: () => {
+        intervals: Interval[];
+        drawings: IDrawingShape[];
+        visibleRange: TimeRange & {
+            startIndex: number;
+            endIndex: number;
+        };
+        visiblePriceRange: PriceRange;
+        canvasSize: {
+            width: number;
+            height: number;
+            dpr: number;
+        };
+    } | null;
+    getDrawings: (query?: DrawingQuery) => DrawingSnapshot[];
+    getDrawingById: (id: string) => DrawingSnapshot | null;
+    getDrawingInstances: (query?: DrawingQuery) => IDrawingShape[];
+    /** Get the snapshot of the currently selected drawing (if any). */
+    getSelectedDrawing: () => DrawingSnapshot | null;
+    /** Get the ID of the currently selected drawing (if any). */
+    getSelectedDrawingId: () => string | null;
+    /** Select a drawing by its unique ID. */
+    selectShape: (id: string) => void;
+    /** Clear any currently active drawing selection. */
+    unselectShape: () => void;
+    /** Update the properties of the currently selected drawing (shortcut for patchShape + getSelectedDrawingId). */
+    updateSelectedShape: (patch: DrawingPatch) => void;
+    getChartContext: () => ChartContextInfo | null;
+    /** Visible time (unix seconds + bar indices) and price band — counterpart to {@link getCanvasSize}. */
+    getVisibleRanges: () => VisibleViewRanges | null;
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+        dpr: number;
+    } | null;
+    clearCanvas: () => void;
+    redrawCanvas: () => void;
+    reloadCanvas: () => void;
+    /** Merge an engine profile (e.g. {@link TickUpPrime}) into live chart options. */
+    setEngine: (engine: TickUpChartEngine) => void;
+    /** Forwarded to the stage — drawing toolbar modes (line, select, …). */
+    setInteractionMode: (mode: Mode) => void;
+    /** Deletes the selected drawing on the stage, if any. */
+    deleteSelectedDrawing: () => void;
+    /** Programmatically change the timeframe (e.g. '5m', '1h'). */
+    setInterval: (tf: string) => void;
+    /** Programmatically change the visible span (1D, 1M, All, …). */
+    setRange: (r: any) => void;
+    /** Open the styled alert popup with a custom title and message. */
+    showAlert: (title: string, message: string) => void;
+    /** Close the active alert popup. */
+    closeAlert: () => void;
+}
+/**
+ * Props for {@link TickUpHost} and the tier components (`TickUpPulse`, `TickUpFlow`, …).
+ * When `productId` is set, toolbar layout props (`showSidebar`, `showTopBar`, `showSettingsBar`) are fixed and omitted from product prop types.
+ */
+export type TickUpHostProps = {
+    intervalsArray?: Interval[];
+    initialNumberOfYTicks?: number;
+    initialXAxisHeight?: number;
+    initialYAxisWidth?: number;
+    initialTimeDetailLevel?: TimeDetailLevel;
+    initialTimeFormat12h?: boolean;
+    initialVisibleTimeRange?: TimeRange;
+    chartOptions?: DeepPartial<ChartOptions>;
+    /**
+     * Toolbar chrome — only honored when `productId` is omitted (legacy / unbundled host).
+     * When `productId` is set (TickUp Pulse, Flow, …), layout is fixed by product and these props are ignored.
+     */
+    showSidebar?: boolean;
+    showTopBar?: boolean;
+    /** When false hides the settings gear icon even if the top toolbar is visible */
+    showSettingsBar?: boolean;
+    /** Invoked when the user activates Refresh in the settings toolbar (e.g. reload quotes). */
+    onRefreshRequest?: () => void | Promise<void>;
+    /** Controlled toolbar symbol (optional). */
+    symbol?: string;
+    /** Initial toolbar symbol when uncontrolled. */
+    defaultSymbol?: string;
+    onSymbolChange?: (symbol: string) => void;
+    /**
+     * Invoked when the user submits symbol search (search button or Enter).
+     * Return `false` or reject the promise if the lookup failed — the toolbar reverts to the last good symbol
+     * and calls `onSymbolChange` with it (for controlled hosts). Return `true` or void on success.
+     */
+    onSymbolSearch?: (symbol: string) => void | boolean | Promise<void | boolean>;
+    /**
+     * Locks toolbar chrome to the product line: side drawing bar, top bar, and settings entry cannot be
+     * changed via props or settings for this instance. Omit for a host-controlled layout (see `showSidebar` / `showTopBar` / `showSettingsBar`).
+     */
+    productId?: TickUpProductId;
+    /**
+     * In-chart logo watermark (bundled transparent PNG, low opacity, no extra layout row).
+     * Forced on for `productId="desk"`. Default true. Set false to disable branding.
+     */
+    showAttribution?: boolean;
+    /** For `productId="prime"`: non-empty value hides the eval strip. */
+    licenseKey?: string | null;
+    /**
+     * Shell **light** / **dark** (toolbar, settings modal chrome, `GlobalStyle` page background).
+     * When set, the host is **controlled**: update this prop when {@link onThemeVariantChange} fires
+     * (e.g. from the settings toolbar sun/moon control).
+     */
+    themeVariant?: ChartTheme;
+    /**
+     * Initial shell theme when {@link themeVariant} is omitted (uncontrolled). Defaults to **`light`**.
+     */
+    defaultThemeVariant?: ChartTheme;
+    /** Notified when the user toggles shell theme from the toolbar. */
+    onThemeVariantChange?: (variant: ChartTheme) => void;
+    /** Current interval (e.g. '5m') */
+    interval?: string;
+    onIntervalChange?: (tf: string) => void;
+    /**
+     * Similar to onSymbolSearch, invoked when the interval is changed.
+     * Use this to replace the data feed for the new interval.
+     */
+    onIntervalSearch?: (tf: string) => void | boolean | Promise<void | boolean>;
+    /** Current range (e.g. '1M') */
+    range?: any;
+    onRangeChange?: (range: any) => void;
+    /** Optional explicit initial range name if any. */
+    initialRange?: any;
+};
+export declare const TickUpHost: React.ForwardRefExoticComponent<TickUpHostProps & React.RefAttributes<TickUpHostHandle>>;

package/dist/components/TickUpProducts.d.ts

@@ -0,0 +1,23 @@
+import React from 'react';
+import { type TickUpHostHandle, type TickUpHostProps } from './TickUpHost';
+/** Props disallowed on tier components: chrome is fixed per product (not overridable at init). */
+type TickUpProductChromeKeys = 'productId' | 'showSidebar' | 'showTopBar' | 'showSettingsBar';
+export type TickUpPulseProps = Omit<TickUpHostProps, TickUpProductChromeKeys | 'licenseKey'>;
+export type TickUpFlowProps = Omit<TickUpHostProps, TickUpProductChromeKeys | 'licenseKey'>;
+export type TickUpCommandProps = Omit<TickUpHostProps, TickUpProductChromeKeys | 'licenseKey'>;
+export type TickUpDeskProps = Omit<TickUpHostProps, TickUpProductChromeKeys | 'licenseKey'>;
+export type TickUpPrimeTierProps = Omit<TickUpHostProps, TickUpProductChromeKeys>;
+/** Minimal embed: candlestick/line plot and axes only (no toolbars). */
+export declare const TickUpPulse: React.ForwardRefExoticComponent<TickUpPulseProps & React.RefAttributes<TickUpHostHandle>>;
+/** Analysis layout: symbol bar and chart controls; no drawing tools sidebar. */
+export declare const TickUpFlow: React.ForwardRefExoticComponent<TickUpFlowProps & React.RefAttributes<TickUpHostHandle>>;
+/** Full interactive chart: drawings, settings, live data API (default product line). */
+export declare const TickUpCommand: React.ForwardRefExoticComponent<TickUpCommandProps & React.RefAttributes<TickUpHostHandle>>;
+/** Broker / embedded terminal: same capabilities as Command; attribution is always shown. */
+export declare const TickUpDesk: React.ForwardRefExoticComponent<TickUpDeskProps & React.RefAttributes<TickUpHostHandle>>;
+/**
+ * Licensed / evaluation tier: same shell as Command. Without `licenseKey`, an eval strip is shown.
+ * For **render engine** (neon canvas profile), use {@link TickUpPrime} with `setEngine` or `chartOptions.base.engine`.
+ */
+export declare const TickUpPrimeTier: React.ForwardRefExoticComponent<TickUpPrimeTierProps & React.RefAttributes<TickUpHostHandle>>;
+export {};

package/dist/components/Toolbar/Buttons.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { ButtonProps, ModeButtonProps } from "../../types/buttons";
+export declare const ModeButton: React.FC<ModeButtonProps>;
+export declare const Button: React.FC<ButtonProps>;

package/dist/components/Toolbar/ChartTypeSelectDropdown.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ChartType } from '../../types/chartOptions';
+interface Props {
+    value: ChartType;
+    onChange: (type: ChartType) => void;
+    className?: string;
+}
+export declare const ChartTypeSelectDropdown: React.FC<Props>;
+export {};

package/dist/components/Toolbar/IntervalSelect.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { ChartTheme } from '../../types/types';
+export type IntervalCategory = 'Minutes' | 'Hours' | 'Days' | 'Weeks' | 'Months';
+export declare const INTERVAL_LIST: {
+    category: IntervalCategory;
+    options: string[];
+}[];
+interface Props {
+    value: string;
+    onChange: (interval: string) => void;
+    themeVariant?: ChartTheme;
+    className?: string;
+}
+export declare const IntervalSelect: React.FC<Props>;
+export {};

package/dist/components/Toolbar/RangeSelector.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export type RangeKey = '1D' | '5D' | '1M' | '3M' | '6M' | 'YTD' | '1Y' | '5Y' | 'All';
+export interface RangeSelectorProps {
+    onRangeChange: (range: RangeKey) => void;
+    currentRange?: RangeKey;
+    isDark?: boolean;
+    showLabel?: boolean;
+}
+export declare const RangeSelector: React.FC<RangeSelectorProps>;

package/dist/components/Toolbar/SettingsToolbar.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { ChartType } from "../../types/chartOptions";
+import { ChartTheme } from '../../types/types';
+interface SettingToolbarProps {
+    handleChartTypeChange: (type: ChartType) => void;
+    selectedChartType?: ChartType;
+    openSettingsMenu: () => void;
+    /** When false the entire toolbar renders nothing */
+    showSettingsBar?: boolean;
+    language?: string;
+    locale?: string;
+    symbolInputRef?: React.RefObject<HTMLInputElement | null>;
+    /** Controlled symbol text (optional). */
+    symbol?: string;
+    /** Initial symbol when uncontrolled. */
+    defaultSymbol?: string;
+    /** Fired when the symbol field changes. */
+    onSymbolChange?: (symbol: string) => void;
+    /**
+     * When set, the search control and Enter in the symbol field call this with the trimmed symbol.
+     * When unset, search focuses/selects the symbol field only.
+     * Return **`false`** or a **rejected Promise** if the lookup failed — the field reverts to the last
+     * successfully displayed symbol and `onSymbolChange` is called with that value so controlled hosts stay in sync.
+     * Return **`true`** or **`undefined`** (void) for success.
+     */
+    onSymbolSearch?: (symbol: string) => void | boolean | Promise<void | boolean>;
+    /** Optional extra handler when search is activated (e.g. focus-only); ignored if `onSymbolSearch` is set. */
+    onSearch?: () => void;
+    /** Fit the time axis to all loaded bars. */
+    onFitVisibleRange?: () => void;
+    /** Download OHLCV as CSV. */
+    onExportDataCsv?: () => void;
+    /** Raster snapshot of the main price canvas. */
+    onSnapshotPng?: () => void;
+    onRefresh?: () => void | Promise<void>;
+    onToggleTheme?: () => void;
+    /** shell light/dark (and grey) — drives sun vs moon on the theme control. */
+    themeVariant?: ChartTheme;
+    /** Current selected interval tag (e.g. '5m') */
+    interval?: string;
+    /** Fired when user selects a new interval. */
+    onIntervalChange?: (interval: string) => void;
+    /** Optional 'search' handler to replace data feed on interval change. */
+    onIntervalSearch?: (tf: string) => void | boolean | Promise<void | boolean>;
+    /** Prime engine: glass-style toolbar surface */
+    primeGlass?: boolean;
+    primeGlassLight?: boolean;
+}
+export declare const SettingsToolbar: ({ handleChartTypeChange, selectedChartType, openSettingsMenu, showSettingsBar, language, locale, symbolInputRef, symbol, defaultSymbol, onSymbolChange, onSymbolSearch, onSearch, onFitVisibleRange, onExportDataCsv, onSnapshotPng, onRefresh, onToggleTheme, themeVariant, interval, onIntervalChange, onIntervalSearch, primeGlass, primeGlassLight, }: SettingToolbarProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/Toolbar/Toolbar.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface ToolbarProps {
+    language?: string;
+    locale?: string;
+    primeGlass?: boolean;
+    /** Light frosted Prime chrome when the plot uses `base.theme: ChartTheme.light`. */
+    primeGlassLight?: boolean;
+}
+export declare const Toolbar: React.FC<ToolbarProps>;
+export {};

package/dist/components/Toolbar/icons.d.ts

@@ -0,0 +1,79 @@
+import React from 'react';
+/**
+ * IconBase — a clean, scalable SVG wrapper that fills its container
+ * - No hardcoded pixels; uses 100%/100% so the parent controls size
+ * - preserveAspectRatio keeps shapes undistorted
+ * - vector-effect keeps stroke widths readable across scales
+ */
+export declare const IconBase: React.FC<{
+    active?: boolean;
+    name: string;
+    children: React.ReactNode;
+}>;
+export declare const IconLine: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconRect: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconCircle: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconTriangle: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconAngle: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconSelect: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconPencil: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconGear: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconCamera: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconSearch: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconRange: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconDownload: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconRefresh: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconTheme: React.FC<{
+    active?: boolean;
+}>;
+/** Sun — paired with {@link IconTheme} (moon) for light/dark toggle affordance. */
+export declare const IconSun: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconChartLine: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconChartBar: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconChartCandle: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconChartArea: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconArrowDown: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconClose: React.FC<{
+    active?: boolean;
+}>;
+export declare const IconSave: React.FC<{
+    active?: boolean;
+}>;

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { Placement, TooltipAlign, TooltipAxis } from '../types/buttons';
+type TooltipProps = {
+    content: React.ReactNode;
+    tooltipAxis: TooltipAxis;
+    placement?: Placement;
+    axis?: TooltipAxis;
+    align?: TooltipAlign;
+    offset?: number;
+    autoFlip?: boolean;
+    delayHideMs?: number;
+    children: React.ReactElement<any>;
+    className?: string;
+    dir?: 'ltr' | 'rtl';
+};
+export declare const Tooltip: React.FC<TooltipProps>;
+export {};

package/dist/contexts/ModeContext.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+export declare enum Mode {
+    none = 0,
+    drawLine = 1,
+    drawRectangle = 2,
+    drawCircle = 3,
+    drawTriangle = 4,
+    drawAngle = 5,
+    select = 6,
+    editShape = 7,
+    drawPolyline = 8,
+    drawArrow = 9,
+    drawCustomSymbol = 10,
+    drawText = 11
+}
+interface ModeContextProps {
+    mode: Mode;
+    setMode: (mode: Mode) => void;
+}
+export declare const ModeProvider: React.FC<{
+    children: React.ReactNode;
+}>;
+export declare const useMode: () => ModeContextProps;
+export {};

package/dist/engines/TickUpEngine.d.ts

@@ -0,0 +1,12 @@
+import type { DeepPartial } from '../types/types';
+import type { ChartOptions } from '../types/chartOptions';
+import type { TickUpRenderEngine } from '../types/chartOptions';
+/**
+ * Pluggable render / theme profile. Apply via {@link TickUpHostHandle.setEngine} or by merging
+ * {@link TickUpChartEngine.getChartOptionsPatch} into `chartOptions`.
+ */
+export interface TickUpChartEngine {
+    readonly id: TickUpRenderEngine | string;
+    /** Deep-partial merge applied on top of current chart options */
+    getChartOptionsPatch(): DeepPartial<ChartOptions>;
+}

package/dist/engines/prime/PrimeRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { DeepRequired } from '../../types/types';
+import type { ChartOptions } from '../../types/chartOptions';
+/** Core-only helper kept for compatibility with existing chart rendering checks. */
+export declare function isPrimeEngine(options: DeepRequired<ChartOptions>): boolean;

package/dist/engines/prime/TickUpPrime.d.ts

@@ -0,0 +1,15 @@
+import type { DeepPartial } from '../../types/types';
+import { ChartTheme } from '../../types/types';
+import type { ChartOptions } from '../../types/chartOptions';
+import type { TickUpChartEngine } from '../TickUpEngine';
+/**
+ * Core-only distribution stub: premium renderer internals are not bundled here.
+ * Consumers can still compile against the public Prime API names.
+ */
+export declare const TICKUP_PRIME_PRIMARY = "#3EC5FF";
+export declare const TICKUP_PRIME_SECONDARY = "#5A48DE";
+export declare const TICKUP_PRIME_TEXT = "#e7ebff";
+export declare function getTickUpPrimeThemePatch(theme?: ChartTheme): DeepPartial<ChartOptions>;
+export declare function createTickUpPrimeEngine(theme?: ChartTheme): TickUpChartEngine;
+export declare const TickUpPrime: TickUpChartEngine;
+export declare const TickUpStandardEngine: TickUpChartEngine;

package/dist/full.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Full public API: product shells (`TickUpCommand`, `TickUpHost`, …), optional shape classes,
+ * and deprecated aliases. Published as **`tickup/full`**.
+ *
+ * For canvas-focused integration, prefer the default **`tickup`** entry (see `index.ts`).
+ */
+export type { TickUpHostProps, TickUpHostHandle } from './components/TickUpHost';
+export { TickUpHost } from './components/TickUpHost';
+export { TickUpProductId } from './types/tickupProducts';
+export type { Interval } from './types/Interval';
+export { LiveDataPlacement } from './types/liveData';
+export type { LiveDataApplyResult } from './types/liveData';
+export { applyLiveDataMerge, normalizeInterval, normalizeIntervals, dedupeByTimePreferLast } from './utils/liveDataMerge';
+export type { ChartSnapshotMeta } from './utils/captureChartRegion';
+export { buildChartSnapshotFileName, sanitizeChartSnapshotToken, contrastingFooterTextColor, captureChartRegionToPngDataUrl, } from './utils/captureChartRegion';
+export type { TimeRange, VisibleViewRanges } from './types/Graph';
+export type { ChartDimensionsData } from './types/Graph';
+export type { OverlayWithCalc, OverlaySeries, OverlayOptions } from './types/overlay';
+export type { ShapeBaseArgs, Drawing } from './components/Drawing/types';
+export { ShapeType } from './components/Drawing/types';
+export type { DrawingSpec, DrawingPatch, DrawingInput } from './components/Drawing/drawHelper';
+export { drawingFromSpec, applyDrawingPatch, isDrawingPatch } from './components/Drawing/drawHelper';
+export type { DrawingSnapshot, DrawingQuery, DrawingWithZIndex } from './components/Drawing/drawingQuery';
+export { shapeToSnapshot, filterDrawingsWithMeta, queryDrawingsToSnapshots, filterDrawingInstances, } from './components/Drawing/drawingQuery';
+export type { ChartContextInfo } from './types/chartContext';
+export type { TickUpStageHandle, TickUpStageProps } from './components/Canvas/TickUpStage';
+export { TickUpStage } from './components/Canvas/TickUpStage';
+/** @deprecated Use {@link TickUpStageHandle} */
+export type { ChartStageHandle, ChartStageProps } from './components/Canvas/ChartStage';
+/** @deprecated Use {@link TickUpStage} */
+export { ChartStage } from './components/Canvas/ChartStage';
+export type { DrawingStyleOptions, DrawingPoint, CanvasPoint } from './types/Drawings';
+export type { IDrawingShape } from './components/Drawing/IDrawingShape';
+export type { LineShapeArgs, RectangleShapeArgs, CircleShapeArgs, TriangleShapeArgs, AngleShapeArgs, ArrowShapeArgs, PolylineShapeArgs, CustomSymbolShapeArgs, } from './types/Drawings';
+export { AxesPosition } from './types/types';
+export { AxesUnitPlacement, ChartType, CurrencyDisplay, NumberNotation, PriceMetricKind, TickUpRenderEngine, TimeDetailLevel, } from './types/chartOptions';
+export { StrokeLineStyle } from './types/overlay';
+export { TickUpWatermarkPlacement } from './branding/tickupWatermark';
+export { SettingsCategoryId } from './components/SettingsModal/SettingsModal';
+export { SettingsModalIconRole } from './components/SettingsModal/SettingsModal.styles';
+export { OverlayPriceKey, OverlayKind } from './types/overlay';
+export { TickUpPulse, TickUpFlow, TickUpCommand, TickUpDesk, TickUpPrimeTier, } from './components/TickUpProducts';
+export type { TickUpPulseProps, TickUpFlowProps, TickUpCommandProps, TickUpDeskProps, TickUpPrimeTierProps, } from './components/TickUpProducts';
+export type { TickUpChartEngine } from './engines/TickUpEngine';
+export { TickUpPrime, TickUpStandardEngine, createTickUpPrimeEngine, getTickUpPrimeThemePatch, } from './engines/prime/TickUpPrime';
+export { TICKUP_PRIME_PRIMARY, TICKUP_PRIME_SECONDARY, TICKUP_PRIME_TEXT } from './engines/prime/TickUpPrime';
+export { TickUpMark } from './branding/TickUpMark';
+export type { TickUpThemeVariant } from './branding/TickUpMark';
+export { TickUpAttribution } from './branding/TickUpAttribution';
+export type { TickUpAttributionProps } from './branding/TickUpAttribution';
+export { ShapePropertiesModal } from './components/ShapePropertiesModal/ShapePropertiesModal';
+export type { ShapePropertiesFormState } from './components/ShapePropertiesModal/applyShapeProperties';
+export type { ModalThemeVariant } from './components/SettingsModal/SettingsModal.styles';
+export { Mode, ModeProvider, useMode } from './contexts/ModeContext';
+export { withOverlayStyle, OverlaySpecs, overlay } from './components/Canvas/utils/drawOverlay';
+export { GlobalStyle } from './styles/App.styles';
+export { generateDrawingShapeId } from './components/Drawing/IDrawingShape';
+export { CustomSymbolShape } from './components/Drawing/CustomSymbolShape';
+export { LineShape } from './components/Drawing/LineShape';
+export { RectangleShape } from './components/Drawing/RectangleShape';
+export { CircleShape } from './components/Drawing/CircleShape';
+export { TriangleShape } from './components/Drawing/TriangleShape';
+export { AngleShape } from './components/Drawing/AngleShape';
+export { ArrowShape } from './components/Drawing/ArrowShape';
+export { Polyline } from './components/Drawing/Polyline';
+export { timeToX, xToTime, priceToY, yToPrice, interpolatedCloseAtTime, lerp, xFromCenter, xFromStart, } from './components/Canvas/utils/GraphHelpers';
+export type { ChartOptions } from './types/chartOptions';
+export type { DeepRequired } from './types/types';
+export { ChartTheme } from './types/types';
+export { RangeSelector } from './components/Toolbar/RangeSelector';
+export type { RangeKey } from './components/Toolbar/RangeSelector';

package/dist/hooks/useChartData.d.ts

@@ -0,0 +1,15 @@
+import { TimeRange } from "../types/Graph";
+import { Interval } from "../types/Interval";
+import { ChartRenderContext } from "../types/chartOptions";
+type VisibleRangeInput = TimeRange & Partial<{
+    startIndex: number;
+    endIndex: number;
+}>;
+export declare function useChartData(intervalsArray: Interval[], visibleRange: VisibleRangeInput, currentPoint: {
+    x: number;
+    y: number;
+} | null, canvasWidth: number, canvasHeight: number): {
+    renderContext: ChartRenderContext | null;
+    intervalSeconds: number;
+};
+export {};

package/dist/hooks/useElementSize.d.ts

@@ -0,0 +1,13 @@
+import type { RefObject } from "react";
+import type { CanvasSizes } from "../types/types";
+interface UseElementSizeReturn<T extends HTMLElement> {
+    ref: RefObject<T>;
+    size: CanvasSizes;
+}
+/**
+ * Measures an element's rendered size (CSS pixels, fractional allowed) using ResizeObserver.
+ * - Returns a stable ref to attach to the measured element
+ * - Updates on layout changes and window resize (covers DPR/zoom changes)
+ */
+export declare function useElementSize<T extends HTMLElement>(): UseElementSizeReturn<T>;
+export {};

package/dist/hooks/usePanAndZoom.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Interval } from "../types/Interval";
+import { TimeRange } from "../types/Graph";
+interface PanAndZoomHandlers {
+    onPanStart: () => void;
+    onPan: (dx: number) => void;
+    onPanEnd: (dx: number) => void;
+    onWheelStart: () => void;
+    onWheelEnd: () => void;
+}
+export declare function usePanAndZoom(canvasRef: React.RefObject<HTMLCanvasElement | null>, isEnabled: boolean, intervalsArray: Interval[], visibleRange: TimeRange, setVisibleRange: (range: TimeRange | ((prev: TimeRange) => TimeRange)) => void, intervalSeconds: number, handlers: PanAndZoomHandlers, getCssWidth?: () => number): void;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,47 @@
+/**
+ * **Default npm entry — basic charts:** `TickUpStage`, data helpers, overlays, drawings (types +
+ * factories), snapshots, and branding. Build your own chrome around the canvas.
+ *
+ * **Full product UI** (Pulse, Flow, Command, Desk, `TickUpHost`, shape classes, …) is
+ * published separately as `import … from 'tickup/full'`.
+ */
+export type { Interval } from './types/Interval';
+export { LiveDataPlacement } from './types/liveData';
+export type { LiveDataApplyResult } from './types/liveData';
+export { applyLiveDataMerge, normalizeInterval, normalizeIntervals, dedupeByTimePreferLast } from './utils/liveDataMerge';
+export type { ChartSnapshotMeta } from './utils/captureChartRegion';
+export { buildChartSnapshotFileName, sanitizeChartSnapshotToken, contrastingFooterTextColor, captureChartRegionToPngDataUrl, } from './utils/captureChartRegion';
+export type { TimeRange, VisibleViewRanges } from './types/Graph';
+export type { ChartDimensionsData } from './types/Graph';
+export type { OverlayWithCalc, OverlaySeries, OverlayOptions } from './types/overlay';
+export type { ShapeBaseArgs, Drawing } from './components/Drawing/types';
+export { ShapeType } from './components/Drawing/types';
+export type { DrawingSpec, DrawingPatch, DrawingInput } from './components/Drawing/drawHelper';
+export { drawingFromSpec, applyDrawingPatch, isDrawingPatch } from './components/Drawing/drawHelper';
+export type { DrawingSnapshot, DrawingQuery, DrawingWithZIndex } from './components/Drawing/drawingQuery';
+export { shapeToSnapshot, filterDrawingsWithMeta, queryDrawingsToSnapshots, filterDrawingInstances, } from './components/Drawing/drawingQuery';
+export type { ChartContextInfo } from './types/chartContext';
+export type { TickUpStageHandle, TickUpStageProps } from './components/Canvas/TickUpStage';
+export { TickUpStage } from './components/Canvas/TickUpStage';
+export type { DrawingStyleOptions, DrawingPoint, CanvasPoint } from './types/Drawings';
+export type { IDrawingShape } from './components/Drawing/IDrawingShape';
+export type { LineShapeArgs, RectangleShapeArgs, CircleShapeArgs, TriangleShapeArgs, AngleShapeArgs, ArrowShapeArgs, PolylineShapeArgs, CustomSymbolShapeArgs, } from './types/Drawings';
+export { AxesPosition, ChartTheme } from './types/types';
+export { AxesUnitPlacement, ChartType, CurrencyDisplay, NumberNotation, PriceMetricKind, TickUpRenderEngine, TimeDetailLevel, } from './types/chartOptions';
+export type { ChartOptions } from './types/chartOptions';
+export { StrokeLineStyle } from './types/overlay';
+export { TickUpWatermarkPlacement } from './branding/tickupWatermark';
+export type { DeepRequired } from './types/types';
+export { OverlayPriceKey, OverlayKind } from './types/overlay';
+export { TickUpMark } from './branding/TickUpMark';
+export type { TickUpThemeVariant } from './branding/TickUpMark';
+export { TickUpAttribution } from './branding/TickUpAttribution';
+export type { TickUpAttributionProps } from './branding/TickUpAttribution';
+export { Mode, ModeProvider, useMode } from './contexts/ModeContext';
+export { withOverlayStyle, OverlaySpecs, overlay } from './components/Canvas/utils/drawOverlay';
+export { GlobalStyle } from './styles/App.styles';
+export { generateDrawingShapeId } from './components/Drawing/IDrawingShape';
+export type { TickUpChartEngine } from './engines/TickUpEngine';
+export { TickUpPrime, TickUpStandardEngine, createTickUpPrimeEngine, getTickUpPrimeThemePatch, } from './engines/prime/TickUpPrime';
+export { TICKUP_PRIME_PRIMARY, TICKUP_PRIME_SECONDARY, TICKUP_PRIME_TEXT } from './engines/prime/TickUpPrime';
+export { timeToX, xToTime, priceToY, yToPrice, interpolatedCloseAtTime, lerp, xFromCenter, xFromStart, } from './components/Canvas/utils/GraphHelpers';

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};