@abdullahjaswal/tickyr-charts-solid 0.1.0

package/dist/viewport/category-axis.d.ts

@@ -0,0 +1,32 @@
+import { XAxisTick } from '../rendering/draw/axis';
+/** Breathing room (CSS px) between the y-axis spine and the leftmost /
+ *  rightmost bar's edge. Without it, the first bar visually touches the
+ *  axis (the half-slot inset alone gives a tiny gap that disappears at
+ *  high bar counts). 6 px matches the cross-chart `gapUnit × 3` rhythm -
+ *  same breathing room the spec wants between any two adjacent
+ *  rectangular marks, applied at the chart edges. */
+export declare const AXIS_BAR_GAP_PX = 6;
+export interface CategoryLayout {
+    /** Pixel position of each bar's center. Bar `i` is at `centerPx[i]`. */
+    readonly centerPx: Float64Array;
+    /** Slot width in CSS px - the equal share each bar gets along the
+     *  category axis after `AXIS_BAR_GAP_PX` is reserved on each side. */
+    readonly slotWidth: number;
+    /** First bar's center pixel. Equals `innerLeft + halfSlot` where
+     *  `halfSlot = slotWidth/2 + AXIS_BAR_GAP_PX`. */
+    readonly firstCenterPx: number;
+    /** Last bar's center pixel. */
+    readonly lastCenterPx: number;
+}
+/** Compute the per-slot layout for N bars across the [innerLeft,
+ *  innerRight] range, leaving `AXIS_BAR_GAP_PX` of breathing room at
+ *  each edge. */
+export declare function computeCategoryLayout(N: number, innerLeft: number, innerRight: number): CategoryLayout;
+/** Generate an x-axis tick per bar (or every Kth at high N). Each tick
+ *  carries the bar's actual time as `atMs` and a formatted label.
+ *  Stride = `ceil(N / targetLabelCount)` so the rendered label count
+ *  stays close to the requested target regardless of bar count.
+ *
+ *  Caller is responsible for `xToPx` mapping (the lib's `xToPxLinear`
+ *  does the work consistently with `computeCategoryLayout`). */
+export declare function buildBarPositionTicks(times: Float64Array, N: number, targetLabelCount: number, formatLabel: (atMs: number) => string): XAxisTick[];

package/dist/viewport/clip-ticks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Filter ticks to those whose mapped pixel position lies in `[loPx, hiPx]`.
+ * Bounds inclusive on both ends - a tick exactly at the boundary is on the
+ * chart frame and should render.
+ *
+ * Allocates a fresh array; called at layout time, not per frame.
+ */
+export declare function clipTicks<T>(ticks: readonly T[], mapToPx: (tick: T) => number, loPx: number, hiPx: number): T[];

package/dist/viewport/index.d.ts

@@ -0,0 +1,6 @@
+export { type LinearScale, linearScale } from './scales/linear';
+export { type TimeScale, createWallClockTimeScale } from './scales/time';
+export { type Viewport, type ViewportSizerOptions, computeViewport, } from './viewport-sizer';
+export { type VisibleWindow, visibleWindow } from './visible-window';
+export { niceTicks, type NiceTick, type NiceTicksOptions } from './nice-ticks';
+export { clipTicks } from './clip-ticks';

package/dist/viewport/nice-ticks.d.ts

@@ -0,0 +1,9 @@
+export interface NiceTick {
+    value: number;
+    label: string;
+}
+export interface NiceTicksOptions {
+    target?: number;
+    format?: (v: number, step: number) => string;
+}
+export declare function niceTicks(min: number, max: number, options?: NiceTicksOptions): NiceTick[];

package/dist/viewport/nice-time-ticks.d.ts

@@ -0,0 +1,7 @@
+import { XAxisTick } from '../rendering/draw/axis';
+export interface NiceTimeTicksOptions {
+    target?: number;
+    locale?: string;
+    timeZone?: string;
+}
+export declare function niceTimeTicks(startMs: number, endMs: number, options?: NiceTimeTicksOptions): XAxisTick[];

package/dist/viewport/orientation.d.ts

@@ -0,0 +1,56 @@
+export type Orientation = "vertical" | "horizontal";
+/** Per-corner radii for `drawBar` - top-left, top-right, bottom-right,
+ *  bottom-left. Following the Canvas2D convention: the first two are
+ *  the top edge corners (left → right), the last two are the bottom
+ *  edge corners (right → left). */
+export interface CornerRadii {
+    tl: number;
+    tr: number;
+    br: number;
+    bl: number;
+}
+/** Bar-on-baseline corner rule. The corners
+ *  on the away-from-baseline edge round; the corners that sit flush on
+ *  the baseline stay sharp.
+ *
+ *  Vertical positive (bar rises UP from baseline at bottom):
+ *    away-from-baseline edge = top → tl, tr round; bl, br flush.
+ *  Vertical negative (bar drops DOWN from baseline at top):
+ *    away-from-baseline edge = bottom → bl, br round; tl, tr flush.
+ *  Horizontal positive (bar extends RIGHT from baseline at left):
+ *    away-from-baseline edge = right → tr, br round; tl, bl flush.
+ *  Horizontal negative (bar extends LEFT from baseline at right):
+ *    away-from-baseline edge = left → tl, bl round; tr, br flush.
+ *
+ *  Caller passes `r` = the resolved cornerRadius; the helper picks the
+ *  two corners that round and zeros the others. */
+export declare function cornersForBaseline(orientation: Orientation, positive: boolean, r: number): CornerRadii;
+/** Stacked-segment edge-only corner rule (stack
+ *  variant). Only the OUTERMOST band in a stack rounds the corners that
+ *  face away from the baseline; all inner segment-to-segment edges stay
+ *  sharp so neighbors butt together cleanly.
+ *
+ *  Vertical positive stack: outermost = max-top band → round tl, tr.
+ *  Vertical negative stack: outermost = min-top band → round bl, br.
+ *  Horizontal positive stack: outermost = max-right band → round tr, br.
+ *  Horizontal negative stack: outermost = min-left band → round tl, bl.
+ *
+ *  Inner bands return all-zero radii. */
+export declare function cornersForStackBand(orientation: Orientation, stackPositive: boolean, isOutermost: boolean, r: number): CornerRadii;
+/** Computes a bar's pixel rect given:
+ *    - `slotCenter`: pixel position on the category axis (x in vert,
+ *      y in horz)
+ *    - `slotMarkSpan`: the bar's extent ALONG the category axis (its
+ *      "thickness")
+ *    - `pxA`, `pxB`: two pixel positions along the value axis (e.g.,
+ *      the baseline pixel and the value pixel; or the segment top and
+ *      segment baseline for a stacked band). Order doesn't matter -
+ *      the smaller becomes the rect's "top/left" edge.
+ *
+ *  Returns `{ x, y, w, h }` ready for `drawBar`. */
+export declare function barRect(orientation: Orientation, slotCenter: number, slotMarkSpan: number, pxA: number, pxB: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};

package/dist/viewport/padded-domain.d.ts

@@ -0,0 +1,16 @@
+export interface PadDomainOpts {
+    /** Domain-space value where the chart anchors visual content (e.g.,
+     *  bars sit on `0`, area fill sits at `baselineY`). When this value
+     *  is at or below `min`, the lower side gets no padding (the anchor
+     *  sits flush with the bottom edge). When at or above `max`, the
+     *  upper side gets no padding. Both-extreme is also supported (no
+     *  padding applied at all - degenerate case, lib clamps it). */
+    readonly anchorValue?: number;
+    /** Padding ratio of the visible range. Default `0.05`. */
+    readonly padding?: number;
+}
+export interface PaddedDomain {
+    readonly min: number;
+    readonly max: number;
+}
+export declare function padDomain(min: number, max: number, opts?: PadDomainOpts): PaddedDomain;

package/dist/viewport/scales/linear.d.ts

@@ -0,0 +1,9 @@
+export interface LinearScale {
+    toPx(v: number): number;
+    fromPx(p: number): number;
+    readonly domainMin: number;
+    readonly domainMax: number;
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+}
+export declare function linearScale(domainMin: number, domainMax: number, rangeStart: number, rangeEnd: number): LinearScale;

package/dist/viewport/scales/log.d.ts

@@ -0,0 +1,9 @@
+export interface LogScale {
+    toPx(v: number): number;
+    fromPx(p: number): number;
+    readonly domainMin: number;
+    readonly domainMax: number;
+    readonly rangeStart: number;
+    readonly rangeEnd: number;
+}
+export declare function logScale(domainMin: number, domainMax: number, rangeStart: number, rangeEnd: number): LogScale;

package/dist/viewport/scales/time.d.ts

@@ -0,0 +1,7 @@
+export interface TimeScale {
+    toPx(tMs: number): number;
+    fromPx(p: number): number;
+    free(): void;
+    [Symbol.dispose](): void;
+}
+export declare function createWallClockTimeScale(startMs: number, endMs: number, rangeStart: number, rangeEnd: number): Promise<TimeScale>;

package/dist/viewport/viewport-sizer.d.ts

@@ -0,0 +1,15 @@
+export interface Viewport {
+    cssWidth: number;
+    cssHeight: number;
+    dpr: number;
+    backingWidth: number;
+    backingHeight: number;
+}
+export interface ViewportSizerOptions {
+    cssWidth: number;
+    cssHeight: number;
+    dpr: number;
+    dprCap?: number;
+    fastMode?: boolean;
+}
+export declare function computeViewport(opts: ViewportSizerOptions): Viewport;

package/dist/viewport/visible-window.d.ts

@@ -0,0 +1,5 @@
+export interface VisibleWindow {
+    startIdx: number;
+    endIdx: number;
+}
+export declare function visibleWindow(times: Float64Array, t0: number, t1: number): Promise<VisibleWindow>;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@abdullahjaswal/tickyr-charts-solid",
+  "version": "0.1.0",
+  "description": "Tickyr Charts for SolidJS: opinionated, canvas-rendered trading and financial-data charts, powered by a vendored Rust/WASM engine.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AbdullahJaswal/tickyr-charts.git",
+    "directory": "packages/solid"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/solid/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/solid/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "dependencies": {
+    "d3-array": "^3.2.4",
+    "d3-format": "^3.1.2",
+    "d3-scale": "^4.0.2",
+    "d3-shape": "^3.2.0",
+    "d3-time-format": "^4.1.0",
+    "d3-zoom": "^3.0.0"
+  },
+  "peerDependencies": {
+    "solid-js": "^1.9.0"
+  }
+}