trendkit 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,501 @@
+import { Time, Logical, IChartApi, ISeriesApi, SeriesType } from 'lightweight-charts';
+
+/**
+ * A point a drawing is pinned to.
+ *
+ * ANCHORED IN DATA SPACE, NEVER PIXELS. A trendline drawn through two candles
+ * has to stay through those candles when the user pans, zooms or resizes the
+ * window; a pixel offset would slide off them immediately. So a point is a
+ * price and a time, and pixel positions are recomputed every frame.
+ *
+ * `logical` is the bar INDEX, carried alongside `time` for one specific case:
+ * a user can drag a handle past the last bar, into the empty space on the
+ * right where the chart projects future sessions. There is no `Time` there to
+ * convert, and `timeToCoordinate` returns null. The logical index keeps
+ * counting, so it is what resolves the point when time cannot.
+ *
+ * Both are stored rather than deriving one from the other, because the
+ * mapping between them is not stable: it changes whenever bars are added, and
+ * an index recorded against yesterday's data means a different day tomorrow.
+ * Time is the durable identity; logical is the fallback for points that have
+ * no time.
+ */
+interface Point {
+    /** Session the point sits on. Null only for points beyond the last bar. */
+    time: Time | null;
+    /** Bar index, fractional between bars. Survives past the end of the data. */
+    logical: Logical;
+    /** Y position, in the instrument's own units. */
+    price: number;
+}
+/** A point already resolved to canvas pixels, ready to draw. */
+interface ScreenPoint {
+    x: number;
+    y: number;
+}
+/** Every drawing kind v1 understands. */
+type ToolId = "trendline" | "horizontal-ray" | "fibonacci" | "rectangle" | "measure";
+/** Per-drawing appearance. Everything optional; the theme supplies defaults. */
+interface DrawingStyle {
+    colour?: string;
+    lineWidth?: number;
+    lineStyle?: "solid" | "dashed" | "dotted";
+    /** Fill for shapes that have an interior (rectangle, Fibonacci bands). */
+    fill?: string;
+}
+/**
+ * One drawing.
+ *
+ * Deliberately a plain data object rather than a class with behaviour. It is
+ * what `toJSON` emits, so it has to survive a round trip through storage
+ * belonging to someone else's application -- and a class would not.
+ */
+interface Drawing {
+    id: string;
+    tool: ToolId;
+    points: Point[];
+    style?: DrawingStyle;
+    /** Set while a drawing is being created and not yet committed. */
+    draft?: boolean;
+    /** User-supplied label, where the tool renders one. */
+    text?: string;
+}
+
+/**
+ * The persisted form.
+ *
+ * Versioned from the first release. Drawings end up in someone else's
+ * database, and the day the shape has to change, a stored blob with no
+ * version is one you can only guess at. A number costs nothing now and is
+ * unobtainable later.
+ */
+interface TrendkitSnapshot {
+    version: 1;
+    drawings: Drawing[];
+}
+
+/**
+ * The drawings, and who is selected.
+ *
+ * A plain observable rather than a state library: this ships to other
+ * people's applications, and a library that drags in its own store is a
+ * library people refuse on bundle size alone.
+ */
+declare class DrawingStore {
+    private items;
+    private selected;
+    private readonly listeners;
+    /** Undo history. Snapshots, not diffs -- drawings are small and few. */
+    private readonly past;
+    private readonly future;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    /** Snapshot for undo. Called before any mutation that should be undoable. */
+    private checkpoint;
+    all(): readonly Drawing[];
+    selectedId(): string | null;
+    get(id: string): Drawing | undefined;
+    add(drawing: Drawing, options?: {
+        undoable?: boolean;
+    }): void;
+    update(id: string, patch: Partial<Drawing>, options?: {
+        undoable?: boolean;
+    }): void;
+    remove(id: string, options?: {
+        undoable?: boolean;
+    }): void;
+    select(id: string | null): void;
+    replaceAll(drawings: Drawing[]): void;
+    undo(): void;
+    redo(): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+}
+
+/**
+ * Colours, supplied by the host application.
+ *
+ * Deliberately not read from CSS custom properties, even though that would be
+ * convenient for a Tailwind app. The chart is a canvas: it cannot inherit CSS,
+ * and a library that reached into `getComputedStyle` would work in exactly one
+ * kind of host and silently produce black-on-black anywhere else.
+ */
+interface Theme {
+    /** Default colour for new drawings. */
+    accent: string;
+    /** Outline and fill of a selected drawing's handles. */
+    selection: string;
+    /** Label text. */
+    text: string;
+    /** Label plate behind text. */
+    labelBackground: string;
+    /** Fill for shapes with an interior. Should carry its own alpha. */
+    fill: string;
+}
+/**
+ * Light-mode defaults.
+ *
+ * The accent is the same teal Lightweight Charts uses for rising candles, so
+ * a drawing on a default chart looks deliberate rather than pasted on.
+ */
+declare const LIGHT_THEME: Theme;
+declare const DARK_THEME: Theme;
+
+/**
+ * What a tool needs in order to draw itself and answer hit tests.
+ *
+ * Passed fresh on every frame. Tools must not hold on to it: the coordinate
+ * mapping it wraps is only valid for the frame it was built in.
+ */
+interface RenderContext {
+    ctx: CanvasRenderingContext2D;
+    /** Device pixels per CSS pixel. Every coordinate must be scaled by this. */
+    ratio: number;
+    /** Canvas size in MEDIA (CSS) pixels. */
+    width: number;
+    height: number;
+    theme: Theme;
+    /** Resolve a data-space anchor to pixels, or null if it is off the scale. */
+    toScreen: (point: Point) => ScreenPoint | null;
+    /**
+     * Price to a y coordinate, with no time component.
+     *
+     * Separate from `toScreen` because a horizontal level -- a Fibonacci rung,
+     * a ray -- has a price but no meaningful time, and faking one risks
+     * resolving to null for an index that happens to be off the scale.
+     */
+    toY: (price: number) => number | null;
+}
+/** A drawing tool: how to render it, and how to decide the pointer is on it. */
+interface Tool {
+    id: string;
+    /** How many anchors before the drawing is complete. */
+    pointCount: number;
+    /**
+     * Discarded on pointer-up instead of being kept.
+     *
+     * For the measure tool, which answers "how far is it from here to there"
+     * and has no reason to persist afterwards -- keeping it would litter the
+     * chart with the arithmetic of decisions already made.
+     */
+    transient?: boolean;
+    draw(drawing: Drawing, selected: boolean, context: RenderContext): void;
+    /**
+     * Prices this drawing should label on the price scale.
+     *
+     * A horizontal support line is far more useful when the axis says 1,240.50
+     * next to it -- that is the number a trader types into an order ticket.
+     */
+    axisPrices?(drawing: Drawing): readonly number[];
+    /**
+     * Distance in CSS pixels from the pointer to this drawing's body, or null
+     * if it is not hittable right now. Handles are hit-tested generically by
+     * the primitive, since every tool's handles behave identically.
+     */
+    distance(drawing: Drawing, at: ScreenPoint, context: Omit<RenderContext, "ctx">): number | null;
+}
+
+/**
+ * A straight line between two points.
+ *
+ * What it is for: connecting successive higher lows, or successive lower
+ * highs, to see the slope of a move and where price would have to break to
+ * end it. It is the most-drawn object on any chart, and the one every other
+ * two-anchor tool is built from.
+ */
+declare const Trendline: Tool;
+
+/**
+ * A horizontal line from its anchor to the right edge, forever.
+ *
+ * The support/resistance line, and probably the most-used object on any
+ * chart. It marks a price at which something happened -- a high that stopped
+ * an advance, a low that held twice -- and the claim is that the same price
+ * matters again when it is next reached. Extending only to the RIGHT is the
+ * point: the level was established at the anchor and is being projected
+ * forward, so drawing it back over history would assert something the past
+ * has already disproved or confirmed.
+ */
+declare const HorizontalRay: Tool;
+
+declare const Fibonacci: Tool;
+
+/**
+ * A rectangle between two corners.
+ *
+ * Used to mark a supply or demand zone: a price BAND, rather than the single
+ * line a horizontal ray gives you, where buying or selling previously
+ * overwhelmed the other side. The band matters because the orders that made
+ * it were filled across a range, not at one exact price, so a level drawn as
+ * a hairline is a false precision the market never had.
+ */
+declare const Rectangle: Tool;
+
+/**
+ * Drag to measure: how far, how long, how much.
+ *
+ * Reports the move in rupees and percent, and its duration in SESSIONS
+ * rather than calendar days -- a trader sizing a position cares how many
+ * bars the move took, and the weekend in the middle of it is not one of
+ * them. The logical index counts bars, so the difference between two
+ * anchors is the session count directly.
+ *
+ * Transient: it disappears on release. A measurement answers a question in
+ * the moment; keeping it would litter the chart with the arithmetic of
+ * decisions already made.
+ */
+declare const Measure: Tool;
+
+/** The minimum this needs from a bar. Nothing here looks at OHLC. */
+interface Bar {
+    time: Time;
+    close: number;
+}
+type IndicatorSpec = {
+    type: "rsi";
+    period?: number;
+    colour?: string;
+} | {
+    type: "macd";
+    fastPeriod?: number;
+    slowPeriod?: number;
+    signalPeriod?: number;
+} | {
+    type: "bollinger";
+    period?: number;
+    multiplier?: number;
+    colour?: string;
+};
+interface AttachedIndicator {
+    /** Recompute from a new set of bars. */
+    setData(bars: readonly Bar[]): void;
+    /** Remove every series it created, and its pane if it made one. */
+    remove(): void;
+}
+/**
+ * Compute an indicator and render it.
+ *
+ * RSI and MACD get their OWN pane; Bollinger overlays the price pane. That
+ * split is not cosmetic -- RSI is 0-100 and MACD oscillates around zero, and
+ * neither shares units with a price in rupees. Putting them on the price
+ * scale would flatten the candles into a line at the top of the chart.
+ * Bollinger is in price units, so it belongs on the price pane and nowhere
+ * else.
+ *
+ * Every recompute is a full recompute, deliberately. Measured at 2,000 bars:
+ * RSI 0.16ms, MACD 0.21ms, Bollinger 0.24ms -- 0.61ms for all three, against
+ * a 16.7ms frame. An incremental path would mean a second code path to keep
+ * correct, with its own seeding and off-by-one risks around the window
+ * boundary, for a saving nobody can perceive. Worth revisiting only if
+ * intraday data makes the series an order of magnitude longer.
+ */
+declare function addIndicator(chart: IChartApi, spec: IndicatorSpec, bars: readonly Bar[]): AttachedIndicator;
+
+/**
+ * Relative Strength Index.
+ *
+ * What it measures: the size of recent gains against the size of recent
+ * losses, scaled to 0-100. Above 70 is conventionally "overbought" and below
+ * 30 "oversold" -- though in a strong trend RSI can sit above 70 for weeks,
+ * which is why treating those lines as sell and buy signals is how people
+ * lose money shorting uptrends.
+ *
+ * More useful in practice: 50 as a trend divider, and DIVERGENCE -- price
+ * making a new high while RSI does not, which says the new high came on
+ * weaker momentum than the last one.
+ *
+ * Averages use Wilder's smoothing, not an SMA or a standard EMA. See
+ * `wilder()` -- getting this wrong shifts the value by several points, which
+ * is the difference between 68 and 71 on a line someone trades.
+ */
+declare function rsi(closes: readonly number[], period?: number): (number | null)[];
+
+interface MacdResult {
+    /** Fast EMA minus slow EMA. */
+    macd: (number | null)[];
+    /** EMA of the MACD line. */
+    signal: (number | null)[];
+    /** MACD minus signal. The bars. */
+    histogram: (number | null)[];
+}
+/**
+ * Moving Average Convergence Divergence.
+ *
+ * Three things drawn together: the distance between a fast and a slow moving
+ * average (the MACD line), a smoothing of that distance (the signal line),
+ * and the gap between those two (the histogram).
+ *
+ * What it says: the MACD line crossing zero means the two averages crossed,
+ * i.e. the trend changed. The histogram crossing zero means the MACD crossed
+ * its signal, which happens earlier and is the more-watched event. The
+ * histogram shrinking while price still rises is the divergence traders look
+ * for -- the move continuing, but with less behind it each bar.
+ *
+ * Defaults are Appel's original 12/26/9, chosen for a six-day trading week
+ * and never updated. They persist because everyone watches them, which is
+ * the only reason they matter.
+ */
+declare function macd(closes: readonly number[], fastPeriod?: number, slowPeriod?: number, signalPeriod?: number): MacdResult;
+
+interface BollingerResult {
+    upper: (number | null)[];
+    middle: (number | null)[];
+    lower: (number | null)[];
+}
+/**
+ * Bollinger Bands.
+ *
+ * A moving average with a band either side at a fixed number of standard
+ * deviations. Because the width is derived from recent volatility, the bands
+ * widen when the market gets noisy and contract when it goes quiet.
+ *
+ * The contraction is the part worth watching. A "squeeze" -- bands at their
+ * narrowest in months -- says volatility has collapsed, and volatility
+ * historically reverts, so a large move often follows. It says nothing about
+ * DIRECTION, which is why a squeeze is a reason to pay attention rather than
+ * a reason to buy.
+ *
+ * Price touching a band is not a signal either: with 2 standard deviations,
+ * roughly 5% of bars close outside by construction. In a strong trend price
+ * "walks the band" for weeks.
+ *
+ * Deviation is POPULATION, not sample -- see `stdev()`.
+ */
+declare function bollinger(closes: readonly number[], period?: number, multiplier?: number): BollingerResult;
+
+/**
+ * The moving averages and smoothing every indicator is built from.
+ *
+ * All of these emit `null` until their window is full, rather than starting
+ * with a partial average. A "20-period average" computed from 3 points is
+ * not a 20-period average, and drawing it anyway shows a level that never
+ * existed -- which on a chart someone trades from is worse than a gap.
+ */
+/** Simple moving average. `null` for the first `period - 1` positions. */
+declare function sma(values: readonly number[], period: number): (number | null)[];
+/**
+ * Exponential moving average, seeded with an SMA.
+ *
+ * The seed matters and is the usual source of disagreement between two
+ * implementations of the same indicator. An EMA is recursive, so it needs a
+ * first value from somewhere; seeding with a simple average of the first
+ * `period` points is what Appel's original MACD does and what charting
+ * platforms follow. Seeding with the first data point instead converges to
+ * the same curve eventually but is visibly wrong for the first hundred bars.
+ */
+declare function ema(values: readonly number[], period: number): (number | null)[];
+/**
+ * Wilder's smoothing. Used by RSI, ATR and ADX -- and ONLY by them.
+ *
+ * It is an EMA with k = 1/period rather than 2/(period+1), which makes a
+ * 14-period Wilder average behave like a 27-period EMA. Using a plain EMA or
+ * an SMA in RSI is the most common way to get an indicator that looks
+ * plausible and disagrees with every other platform by several points --
+ * enough to move an RSI across the 70 line that someone is trading off.
+ */
+declare function wilder(values: readonly number[], period: number): (number | null)[];
+/**
+ * Rolling POPULATION standard deviation.
+ *
+ * Population (÷n), not sample (÷n−1). Bollinger's bands are defined over the
+ * window itself rather than a sample drawn from a larger population, and
+ * using the sample formula widens every band slightly -- small, consistent,
+ * and wrong.
+ */
+declare function stdev(values: readonly number[], period: number): (number | null)[];
+
+/**
+ * Pure geometry, in screen pixels.
+ *
+ * Everything here is deliberately free of chart, canvas and DOM: hit-testing
+ * is where a drawing library feels precise or infuriating, and it is far
+ * easier to get right when it can be asserted on directly.
+ */
+/**
+ * Shortest distance from a point to a line SEGMENT.
+ *
+ * Segment, not infinite line -- the difference is the whole reason this is
+ * not two lines of code. Distance to an infinite line would report the
+ * pointer as "on" a trendline while hovering somewhere far off the end of it,
+ * which in practice means clicking empty chart selects a drawing that is not
+ * visibly there.
+ *
+ * Standard projection onto the segment, with the parameter clamped to [0, 1]
+ * so anything past either end measures to that endpoint instead.
+ */
+declare function distanceToSegment(p: ScreenPoint, a: ScreenPoint, b: ScreenPoint): number;
+/**
+ * Distance to the OUTLINE of a rectangle, zero when inside it.
+ *
+ * Zero inside rather than distance-to-nearest-edge, so a filled zone can be
+ * grabbed anywhere in its body -- which is how every other charting tool
+ * behaves and therefore what people expect.
+ */
+declare function distanceToRect(p: ScreenPoint, a: ScreenPoint, b: ScreenPoint): number;
+/**
+ * The Fibonacci retracement levels, as fractions of the move.
+ *
+ * What they mean: after a move from A to B, traders watch for the pullback to
+ * pause at one of these fractions of it before the move resumes. 0.618 is the
+ * one most watched -- the golden ratio -- with 0.5 close behind despite not
+ * being a Fibonacci number at all. The levels have no predictive mechanism;
+ * they matter because enough participants place orders at them that they
+ * become self-fulfilling often enough to be worth drawing.
+ */
+declare const FIB_LEVELS: readonly [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+/**
+ * Price at each Fibonacci level between two prices.
+ *
+ * Level 0 sits at `from` and level 1 at `to`, so dragging bottom-to-top and
+ * top-to-bottom produce mirrored ladders -- which is correct. Traders draw
+ * low-to-high in an uptrend and high-to-low in a downtrend, and expect 0 to
+ * land on the end they started from.
+ */
+declare function fibonacciPrices(from: number, to: number): number[];
+/**
+ * Percentage change between two prices.
+ *
+ * Signed, and relative to where the move started, which is what a trader
+ * reading a measure tool means by "how far did it go".
+ */
+declare function percentChange(from: number, to: number): number;
+
+interface TrendkitOptions {
+    chart: IChartApi;
+    /** The series drawings are anchored to. Normally the candlestick series. */
+    series: ISeriesApi<SeriesType>;
+    /** Tools to enable. Only what you pass is bundled and only what you pass draws. */
+    tools: Tool[];
+    theme?: Theme;
+    /**
+     * Snap new anchors to the nearest OHLC within this many pixels. 0 disables.
+     *
+     * On by default because traders anchor to actual highs and lows, and
+     * hitting an exact value by hand is impossible at normal zoom. Hold shift
+     * while drawing to place freehand.
+     */
+    magnetPx?: number;
+}
+
+interface Trendkit {
+    store: DrawingStore;
+    /** Arm a tool; the next drag on the chart draws one, then disarms. */
+    setActiveTool(tool: ToolId | null): void;
+    activeTool(): ToolId | null;
+    setTheme(theme: Theme): void;
+    toJSON(): TrendkitSnapshot;
+    fromJSON(snapshot: TrendkitSnapshot): void;
+    /** Detach from the chart. Call before the chart itself is removed. */
+    destroy(): void;
+}
+/**
+ * Attach drawing tools to a Lightweight Charts series.
+ *
+ * Persistence is deliberately left to the caller: `toJSON` and `fromJSON` are
+ * the whole story, and where the result goes -- an API, localStorage, a file
+ * -- is an application decision. A library that picks one is a library people
+ * have to work around.
+ */
+declare function createTrendkit(options: TrendkitOptions): Trendkit;
+
+export { type AttachedIndicator, type Bar, type BollingerResult, DARK_THEME, type Drawing, type DrawingStyle, FIB_LEVELS, Fibonacci, HorizontalRay, type IndicatorSpec, LIGHT_THEME, type MacdResult, Measure, type Point, Rectangle, type RenderContext, type ScreenPoint, type Theme, type Tool, type ToolId, type Trendkit, type TrendkitOptions, type TrendkitSnapshot, Trendline, addIndicator, bollinger, createTrendkit, distanceToRect, distanceToSegment, ema, fibonacciPrices, macd, percentChange, rsi, sma, stdev, wilder };

package/dist/index.js

@@ -0,0 +1 @@
+export { DARK_THEME, FIB_LEVELS, Fibonacci, HorizontalRay, LIGHT_THEME, Measure, Rectangle, Trendline, addIndicator, bollinger, createTrendkit, distanceToRect, distanceToSegment, ema, fibonacciPrices, macd, percentChange, rsi, sma, stdev, wilder } from './chunk-AEC4653J.js';

package/dist/react/index.d.ts

@@ -0,0 +1,35 @@
+import { IChartApi, ISeriesApi, SeriesType } from 'lightweight-charts';
+import { Tool, Theme, Trendkit } from '../index.js';
+
+interface UseTrendkitOptions {
+    /**
+     * Null until the chart exists.
+     *
+     * Charts are almost always created in an effect, so on the first render
+     * there is nothing to attach to. Accepting null is what lets a caller
+     * write this as one hook rather than a conditional one.
+     */
+    chart: IChartApi | null | undefined;
+    series: ISeriesApi<SeriesType> | null | undefined;
+    tools: Tool[];
+    theme?: Theme;
+    magnetPx?: number;
+}
+/**
+ * Attach trendkit to a chart for the lifetime of a component.
+ *
+ * Returns null until both the chart and series are available, then the kit.
+ * Re-attaches when the chart or series identity changes -- which is what
+ * happens when a host recreates its chart to switch theme, and is exactly
+ * when a primitive left attached to a destroyed chart would throw.
+ *
+ * `tools` is intentionally NOT in the dependency list. Callers write it
+ * inline as an array literal, which is a new reference on every render, and
+ * depending on it would tear the kit down and rebuild it sixty times a
+ * second -- losing the selection and every in-progress drag. The tool set is
+ * read once at attach; changing which tools are available means remounting,
+ * which is a thing nobody does mid-session.
+ */
+declare function useTrendkit(options: UseTrendkitOptions): Trendkit | null;
+
+export { Trendkit, type UseTrendkitOptions, useTrendkit };

package/dist/react/index.js

@@ -0,0 +1,29 @@
+import { createTrendkit } from '../chunk-AEC4653J.js';
+import { useState, useEffect } from 'react';
+
+function useTrendkit(options) {
+  const { chart, series, theme, magnetPx } = options;
+  const [kit, setKit] = useState(null);
+  useEffect(() => {
+    if (chart === null || chart === void 0) return;
+    if (series === null || series === void 0) return;
+    const instance = createTrendkit({
+      chart,
+      series,
+      tools: options.tools,
+      ...theme === void 0 ? {} : { theme },
+      ...magnetPx === void 0 ? {} : { magnetPx }
+    });
+    setKit(instance);
+    return () => {
+      instance.destroy();
+      setKit(null);
+    };
+  }, [chart, series, magnetPx]);
+  useEffect(() => {
+    if (kit !== null && theme !== void 0) kit.setTheme(theme);
+  }, [kit, theme]);
+  return kit;
+}
+
+export { useTrendkit };

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "trendkit",
+  "version": "0.1.0",
+  "description": "Drawing tools and indicators for TradingView's Lightweight Charts \u2014 trendlines, rays, Fibonacci, zones and a measure tool, built on the v5 plugin API.",
+  "keywords": [
+    "lightweight-charts",
+    "trading",
+    "charts",
+    "drawing-tools",
+    "trendline",
+    "fibonacci",
+    "technical-analysis",
+    "candlestick",
+    "finance"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "vite examples/vanilla",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint .",
+    "format": "prettier --write .",
+    "verify": "npm run typecheck && npm run lint && npm run test && npm run build",
+    "prepublishOnly": "npm run verify && node scripts/check-package.mjs"
+  },
+  "peerDependencies": {
+    "lightweight-charts": ">=5.0.0",
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "@types/react": "^19.3.0",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "eslint": "^9",
+    "lightweight-charts": "^5.2.1",
+    "prettier": "^3",
+    "tsup": "^8",
+    "typescript": "^5",
+    "vite": "^7",
+    "vitest": "^3.2.7"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/darshansachaniya/trendkit.git"
+  },
+  "homepage": "https://github.com/darshansachaniya/trendkit#readme",
+  "bugs": {
+    "url": "https://github.com/darshansachaniya/trendkit/issues"
+  },
+  "author": "Darshan Sachaniya",
+  "engines": {
+    "node": ">=18"
+  }
+}