@graphysdk/geom-candlestick 0.1.0

package/LICENSE.md

@@ -0,0 +1,17 @@
+# License
+
+This software is available under any of the following licenses, at your option,
+depending on which one's conditions you meet:
+
+- **PolyForm Noncommercial 1.0.0** — for noncommercial use (personal,
+  charitable, educational, research, government).
+  See [licenses/PolyForm-NonCommercial-1.0.0.md](licenses/PolyForm-NonCommercial-1.0.0.md)
+
+- **PolyForm Small Business 1.0.0** — free commercial use for organizations
+  under the size thresholds defined in the license.
+  See [licenses/PolyForm-Small-Business-1.0.0.md](licenses/PolyForm-Small-Business-1.0.0.md)
+
+- **PolyForm Free Trial 1.0.0** — a 32-day evaluation for anyone else.
+  See [licenses/PolyForm-Free-Trial-1.0.0.md](licenses/PolyForm-Free-Trial-1.0.0.md)
+
+For commercial use beyond these terms, contact [hello@graphy.dev](mailto:hello@graphy.dev) or visit [https://graphy.dev](https://graphy.dev).

package/README.md

@@ -0,0 +1,63 @@
+# @graphysdk/geom-candlestick
+
+> **Beta.** This geom is on a `0.x` version line: a minor release may change its aesthetics, style parts or look. Use a caret range (`^0.1.0`) to take only patches.
+
+A candlestick geom for the Graphy charting SDK. It draws each trading session's open, high, low and close as a body between the open and close and a wick from the low to the high, coloured by whether the session rose or fell.
+
+Learn more at [graphy.dev](https://graphy.dev).
+
+## Install
+
+```bash
+npm install @graphysdk/geom-candlestick @graphysdk/react
+```
+
+Requires React 19. Its only peer is `@graphysdk/react`.
+
+## Usage
+
+Data is one row per session. Map the session to `x`, and the four prices to `open`, `high`, `low` and `close`:
+
+```tsx
+import { createGraphyKit, GraphRenderer } from '@graphysdk/react';
+import { candlestick } from '@graphysdk/geom-candlestick';
+
+const kit = createGraphyKit({ plugins: [candlestick] });
+
+const spec = kit.pipe(
+  kit.createSpec({ x: 'date' }),
+  kit.geom.candlestick({ aes: { open: 'open', high: 'high', low: 'low', close: 'close' } }),
+  kit.scale.x.discrete(),
+  kit.scale.y.continuous()
+);
+
+export function Prices({ data }) {
+  return (
+    <kit.GraphProvider spec={spec} data={data}>
+      <GraphRenderer />
+    </kit.GraphProvider>
+  );
+}
+```
+
+Set `params: { width }` to change how much of its band each body spans, a fraction in `(0, 1]` defaulting to `0.6`, as on a bar.
+
+The close is the candle's `y`, so a highlight or headline that reads `y` reads the close. A `y` in the root mapping is ignored on the candlestick layer, with a warning.
+
+Colour the sessions with `kit.style.geom.candlestick.rising()` and `kit.style.geom.candlestick.falling()`, the wicks with `kit.style.geom.candlestick.wick()`, and the bodies' shared look with `kit.style.geom.candlestick()`.
+
+`color` is opt-in. Map it to `candlestickDirection` to colour the directions through a colour scale with a legend, or to a data column to colour the candles by its groups. A mapped colour beats the direction parts' built-in look and `defaults` entries; an `overrides` entry beats it.
+
+## Docs
+
+- [Candlestick](https://docs.graphy.dev/sdk-next/graph-types/candlestick)
+
+## Feedback
+
+This geom is released early to hear what works. Tell us on [Discord](https://discord.gg/yGmYCjkSr).
+
+## Licence
+
+This package is available under PolyForm Noncommercial, Small Business, or a 32-day Free Trial. Free Trial is local or internal evaluation only — it does not cover a public page. See [what you can do under the trial](https://docs.graphy.dev/licence/evaluation).
+
+For a commercial licence, [talk to us](https://graphy.dev/license).

package/dist/engine/candlestick.geom.d.ts

@@ -0,0 +1,114 @@
+import { AnchorContext, AnchorPosition, GeomCompileResult, GeomCompilerInput, GeomMappingValidationInput, GeomObservationPart, GeomStylePart, GeomStyleTarget, Observation, UserInputIssue, Geom } from '@graphysdk/react';
+/** Candlestick parameters. `width` is geometry: it sets how much of the band the compiler gives each body. */
+interface CandlestickGeomParams {
+    /** Body width as a fraction of the band the discrete scale allocates to the session, in `(0, 1]`. */
+    width?: number;
+}
+/** The body's own paint, under the colour its direction gives it. */
+declare const BODY_VOCABULARY: {
+    readonly alpha: "unitInterval";
+    readonly fillAlpha: "unitInterval";
+    readonly strokeWidth: "pixels";
+};
+declare const DIRECTION_VOCABULARY: {
+    readonly fill: "color";
+    readonly stroke: "color";
+};
+declare const WICK_VOCABULARY: {
+    readonly stroke: "color";
+    readonly alpha: "unitInterval";
+    readonly strokeWidth: "pixels";
+    readonly dashArray: "dashArray";
+};
+/** Named so the published types reach the observations and every part through `@graphysdk/react`, the package's one peer. */
+interface CandlestickStyleTarget extends GeomStyleTarget {
+    observation: GeomObservationPart<typeof BODY_VOCABULARY> & {
+        sharedPaint: false;
+    };
+    parts: {
+        rising: GeomStylePart<typeof DIRECTION_VOCABULARY>;
+        falling: GeomStylePart<typeof DIRECTION_VOCABULARY>;
+        wick: GeomStylePart<typeof WICK_VOCABULARY>;
+    };
+}
+/**
+ * A candlestick: one candle per trading session, a body between its open and close and a wick from its low to
+ * its high, coloured by whether the session rose or fell.
+ *
+ * Data is one row per session: `x` is the session and `open`, `high`, `low` and `close` its prices. The wick is
+ * the y interval, so it drives the price axis; open and close are scaled on the same axis. The sessions sit one
+ * per band, so a gap in trading (a weekend) takes no room. A horizontal candlestick is `coord.flip()`.
+ */
+export declare class CandlestickGeom extends Geom<CandlestickGeomParams> {
+    readonly type: "candlestick";
+    readonly defaultParams: CandlestickGeomParams;
+    readonly derivedVariables: "candlestickDirection"[];
+    /** Opt-in: unmapped, the direction parts give each candle its colour and no legend is drawn. */
+    readonly aesthetics: readonly [{
+        readonly kind: "visual";
+        readonly name: "color";
+    }];
+    readonly positionRoles: readonly [{
+        readonly axis: "x";
+        readonly role: "point";
+        readonly valueKind: "value";
+    }, {
+        readonly axis: "y";
+        readonly role: "min";
+        readonly valueKind: "value";
+        readonly aes: "low";
+    }, {
+        readonly axis: "y";
+        readonly role: "max";
+        readonly valueKind: "value";
+        readonly aes: "high";
+    }, {
+        readonly axis: "y";
+        readonly role: "scalar";
+        readonly valueKind: "value";
+        readonly aes: "open";
+    }, {
+        readonly axis: "y";
+        readonly role: "scalar";
+        readonly valueKind: "value";
+        readonly aes: "close";
+    }];
+    /** One candle per session, so there is nothing to dodge or stack. */
+    readonly supportedPositions: readonly ["identity"];
+    readonly supportedCoordTypes: readonly ["cartesian", "flip"];
+    /** The price axis fits the data: a candle encodes where prices sat, not a length from zero. */
+    readonly scaleConstraints: {
+        discreteMainAxis: boolean;
+    };
+    /**
+     * A hovered session is one unit. The wick runs from its low to its high inside the band, so the whole of it
+     * takes a press for the session, and no stroke runs on to the next one.
+     */
+    readonly spatialKind = "spanned-buckets";
+    readonly highlightStrategy: "observation-rerender";
+    /**
+     * The tooltip shows the session's four prices, as written in the data and formatted like the price axis, each
+     * labelled by its mapped column.
+     */
+    readonly tooltip: {
+        aes: "low" | "high" | "close" | "open";
+    }[];
+    readonly styleTarget: CandlestickStyleTarget;
+    /** A body spans `width` of its band, so an axis annotation aligned to an edge lands where the bodies end. */
+    readonly resolveBandFraction: Geom['resolveBandFraction'];
+    /**
+     * Substitutes an undrawable `width` and reports it, so the same spec can't diverge across renderers. Above `1`
+     * a body would overlap its neighbours, so it clamps to the full band; at or below `0` nothing is drawable, so
+     * the default takes over.
+     */
+    resolveParams(options: Parameters<Geom['resolveParams']>[0]): Record<string, unknown>;
+    /** Open and close are scalar positions, which no role requires, and a candle cannot be drawn without them. */
+    readonly validateMapping: ({ mapping }: GeomMappingValidationInput) => readonly UserInputIssue[];
+    /**
+     * Where the editor raises its annotation trigger and where an annotation on a candle lands: on the close, at
+     * the band centre, which is the price a session is read at.
+     */
+    readonly resolveAnchorPosition: (observation: Observation, { coordSystem }: AnchorContext) => AnchorPosition | null;
+    compile({ data, mapping, params }: GeomCompilerInput): GeomCompileResult;
+}
+export {};

package/dist/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});let i=require("@graphysdk/react"),v=require("react"),d=require("react/jsx-runtime");var x={direction:"candlestickDirection"},M=(t,e)=>{const o=e==="x"?(0,i.getX)(t):(0,i.getY)(t),r=e==="x"?(0,i.getXMin)(t):(0,i.getYMin)(t),s=e==="x"?(0,i.getXMax)(t):(0,i.getYMax)(t),n=e==="x"?(0,i.getYMin)(t):(0,i.getXMin)(t),l=e==="x"?(0,i.getYMax)(t):(0,i.getXMax)(t),c=(0,i.getScaledAesthetic)(t,"open"),a=(0,i.getScaledAesthetic)(t,"close");return o===null||r===null||s===null||n===null||l===null||c===null||a===null?null:{observation:t,band:o,bodyStart:r,bodyEnd:s,low:n,high:l,open:c,close:a,direction:t[x.direction]==="falling"?"falling":"rising"}},p=(t,e)=>{const o=[];for(const r of t){const s=M(r,e);s!==null&&o.push(s)}return o},A=1,B=1,_=.6,O=["open","high","low","close"],V={alpha:"unitInterval",fillAlpha:"unitInterval",strokeWidth:"pixels"},y={fill:"color",stroke:"color"},E={stroke:"color",alpha:"unitInterval",strokeWidth:"pixels",dashArray:"dashArray"},C=class extends i.Geom{constructor(...t){super(...t),this.type="candlestick",this.defaultParams={},this.derivedVariables=[x.direction],this.aesthetics=[{kind:"visual",name:"color"}],this.positionRoles=[{axis:"x",role:"point",valueKind:"value"},{axis:"y",role:"min",valueKind:"value",aes:"low"},{axis:"y",role:"max",valueKind:"value",aes:"high"},{axis:"y",role:"scalar",valueKind:"value",aes:"open"},{axis:"y",role:"scalar",valueKind:"value",aes:"close"}],this.supportedPositions=["identity"],this.supportedCoordTypes=["cartesian","flip"],this.scaleConstraints={discreteMainAxis:!0},this.spatialKind="spanned-buckets",this.highlightStrategy="observation-rerender",this.tooltip=O.map(e=>({aes:e})),this.styleTarget=(0,i.defineGeomStyleTarget)({observation:{vocabulary:V,sharedPaint:!1,aesthetics:{},rest:{alpha:1,fillAlpha:1,strokeWidth:A}},parts:{rising:{vocabulary:y,aesthetics:{fill:"color",stroke:"color"},rest:{fill:(0,i.token)("trendPositive"),stroke:(0,i.token)("trendPositive")}},falling:{vocabulary:y,aesthetics:{fill:"color",stroke:"color"},rest:{fill:(0,i.token)("trendNegative"),stroke:(0,i.token)("trendNegative")}},wick:{vocabulary:E,rest:{alpha:1,strokeWidth:B,dashArray:[]}}}}),this.resolveBandFraction=e=>f(e),this.validateMapping=({mapping:e})=>["open","close"].filter(o=>e[o]===void 0).map(o=>({code:"MISSING_AESTHETIC",message:`candlestick geom requires '${o}' to be mapped`})),this.resolveAnchorPosition=(e,{coordSystem:o})=>{const r=(0,i.readMainAxis)(o),s=M(e,r);return s===null?null:r==="x"?{x:s.band,y:s.close}:{x:s.close,y:s.band}}}resolveParams(t){const{width:e,...o}=super.resolveParams(t);if(e===void 0)return o;const r=typeof e=="number"&&Number.isFinite(e)?e:null;if(r!==null&&r>0&&r<=1)return{...o,width:r};const s=r!==null&&r>1?1:void 0;return t.diagnostics?.addWarning({code:"INVALID_GEOM_PARAM",message:`Candlestick width must be a fraction in (0, 1], got ${String(e)}; falling back to ${s??"the default band"}.`,context:{geom:this.type,param:"width",expected:"0 < width <= 1",actual:r??String(e)},suggestion:"Set params.width to a fraction of the session band in (0, 1]."}),{...o,...s!==void 0&&{width:s}}}compile({data:t,mapping:e,params:o}){const r=f(o)/2;return{data:T(t,b(e.open),b(e.close)).addConstantVariable(i.POSITION_VARIABLES.xMin,"numeric",-r).addConstantVariable(i.POSITION_VARIABLES.xMax,"numeric",r),mapping:{y:e.close}}}},f=({width:t})=>t??_,b=t=>t===void 0?null:typeof t=="string"?t:"variable"in t?t.variable:null,T=(t,e,o)=>{if(e===null||o===null||!t.hasVariable(e)||!t.hasVariable(o))return t;const r=t.getValues(e,{type:"numeric"}),s=t.getValues(o,{type:"numeric"}),n=r.map((l,c)=>{const a=s[c];return l===null||a===null||a===void 0?null:a>=l?"rising":"falling"});return t.addVariable(x.direction,"categorical",n)},D=5e-4,S=(t,e)=>{const o=(t.open+t.close)/2,r=Math.max(Math.abs(t.close-t.open),D)/2,s=(0,i.composePoint)(e,{main:t.bodyStart,cross:o-r}),n=(0,i.composePoint)(e,{main:t.bodyEnd,cross:o+r}),[l,c]=w((0,i.toViewBoxX)(s.x),(0,i.toViewBoxX)(n.x)),[a,h]=w((0,i.toViewBoxY)(s.y),(0,i.toViewBoxY)(n.y));return{x:l,y:a,width:c-l,height:h-a}},w=(t,e)=>t<=e?[t,e]:[e,t],W=({layer:t,coordSystem:e,panelRect:o,styleReaders:r})=>{const s=(0,i.readMainAxis)(e),n=p(t.data,s),l=r.part("wick"),c=l===void 0?[]:n.map(h=>{const u=P(h.band,h.low,s,o),g=P(h.band,h.high,s,o),I=l.get("strokeWidth",h.observation)??0;return{kind:"stroke",pathData:`M${u.x},${u.y}L${g.x},${g.y}`,width:I}}),a=n.map(h=>{const u=S(h,s),g=u.x*o.width;return{kind:"region",pathData:`M${g},${u.y*o.height}H${(u.x+u.width)*o.width}V${(u.y+u.height)*o.height}H${g}Z`}});return[...c,...a]},P=(t,e,o,r)=>{const s=(0,i.composePoint)(o,{main:t,cross:e});return(0,i.scalePointToPanel)((0,i.projectPointCartesian)(s.x,s.y),r)},k=t=>{const e=(0,i.createStableKeyGenerator)(t.data,t.mapping,t.id);return o=>e(o.observation)},m=({candles:t,mainAxis:e,styleReaders:o,getKey:r,isHovered:s=!1,shouldAnimateTransitions:n=!1})=>{const l=s?"hovered":void 0,c=o.part("wick");return(0,d.jsxs)(d.Fragment,{children:[c&&t.map(a=>(0,d.jsx)(j,{candle:a,mainAxis:e,readers:c,directionReaders:o.part(a.direction),state:l,shouldAnimateTransitions:n},r(a))),t.map(a=>(0,d.jsx)(Y,{candle:a,mainAxis:e,styleReaders:o,state:l,shouldAnimateTransitions:n},r(a)))]})},j=({candle:t,mainAxis:e,readers:o,directionReaders:r,state:s,shouldAnimateTransitions:n})=>{const l=(0,i.composePoint)(e,{main:t.band,cross:t.low}),c=(0,i.composePoint)(e,{main:t.band,cross:t.high}),a=o.get("strokeWidth",t.observation,s)??0,h=o.get("stroke",t.observation,s)??r?.get("stroke",t.observation,s);return(0,d.jsx)(i.GeomLine,{"data-testid":"candlestick-wick",x1:(0,i.toPercent)((0,i.toViewBoxX)(l.x)),y1:(0,i.toPercent)((0,i.toViewBoxY)(l.y)),x2:(0,i.toPercent)((0,i.toViewBoxX)(c.x)),y2:(0,i.toPercent)((0,i.toViewBoxY)(c.y)),stroke:h===void 0?void 0:(0,i.toPaintColor)(h),strokeOpacity:o.get("alpha",t.observation,s),strokeWidth:a,strokeDasharray:(0,i.toStrokeDasharray)(o.get("dashArray",t.observation,s),a),shouldAnimateTransitions:n})},Y=({candle:t,mainAxis:e,styleReaders:o,state:r,shouldAnimateTransitions:s})=>{const n=S(t,e),l=o.part(t.direction),c=l?.get("fill",t.observation,r),a=l?.get("stroke",t.observation,r);return(0,d.jsx)(i.GeomRect,{"data-testid":"candlestick-body",x:(0,i.toPercent)(n.x),y:(0,i.toPercent)(n.y),width:(0,i.toPercent)(n.width),height:(0,i.toPercent)(n.height),fill:c===void 0?void 0:(0,i.toPaintColor)(c),opacity:o.get("alpha",t.observation,r),fillOpacity:o.get("fillAlpha",t.observation,r),stroke:a===void 0?void 0:(0,i.toPaintColor)(a),strokeWidth:o.get("strokeWidth",t.observation,r),shouldAnimateTransitions:s})},K=({layer:t,sourceLayer:e,mainAxis:o,styleReaders:r})=>(0,d.jsx)(m,{candles:(0,v.useMemo)(()=>p(t.data,o),[t.data,o]),mainAxis:o,styleReaders:r,getKey:(0,v.useMemo)(()=>k(e),[e])}),H=({layer:t,primary:e,siblings:o,mainAxis:r,styleReaders:s})=>(0,d.jsx)("g",{"data-testid":"hovered-candles",children:(0,d.jsx)(m,{candles:p([e,...o].map(n=>n.observation),r),mainAxis:r,styleReaders:s,getKey:(0,v.useMemo)(()=>k(t),[t]),isHovered:!0})}),N=({layer:t,mainAxis:e,styleReaders:o,shouldAnimateTransitions:r,intro:s})=>{const n=(0,d.jsx)(m,{candles:(0,v.useMemo)(()=>p(t.data,e),[t.data,e]),mainAxis:e,styleReaders:o,getKey:(0,v.useMemo)(()=>k(t),[t]),shouldAnimateTransitions:r});return s?.type==="fade"?(0,d.jsx)(i.IntroFade,{intro:s,children:n}):n},X=(0,i.defineGeomRenderer)(new C,{coord:"cartesian",swatchShape:"square",guideMode:"band",render:({layer:t,coordSystem:e,styleReaders:o,shouldAnimateTransitions:r,intro:s})=>(0,d.jsx)(N,{layer:t,mainAxis:(0,i.readMainAxis)(e),styleReaders:o,shouldAnimateTransitions:r,intro:s}),renderHighlight:({layer:t,sourceLayer:e,coordSystem:o,styleReaders:r})=>(0,d.jsx)(K,{layer:t,sourceLayer:e,mainAxis:(0,i.readMainAxis)(o),styleReaders:r}),renderHover:({layer:t,primary:e,group:o,related:r,coordSystem:s,styleReaders:n})=>(0,d.jsx)(H,{layer:t,primary:e,siblings:[...o,...r],mainAxis:(0,i.readMainAxis)(s),styleReaders:n}),renderHoverCompanions:()=>null,getEditOutlineShapes:W});exports.CandlestickGeom=C;exports.candlestick=X;

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { CandlestickGeom } from './engine/candlestick.geom';
+export { candlestick } from './renderer/candlestick';

package/dist/index.mjs

@@ -0,0 +1,317 @@
+import { Geom as $, GeomLine as N, GeomRect as Y, IntroFade as L, POSITION_VARIABLES as P, composePoint as p, createStableKeyGenerator as G, defineGeomRenderer as X, defineGeomStyleTarget as R, getScaledAesthetic as S, getX as F, getXMax as M, getXMin as A, getY as U, getYMax as D, getYMin as E, projectPointCartesian as j, readMainAxis as v, scalePointToPanel as q, toPaintColor as b, toPercent as u, toStrokeDasharray as Z, toViewBoxX as y, toViewBoxY as m, token as f } from "@graphysdk/react";
+import { useMemo as k } from "react";
+import { Fragment as z, jsx as c, jsxs as J } from "react/jsx-runtime";
+var w = { direction: "candlestickDirection" }, K = (t, e) => {
+  const r = e === "x" ? F(t) : U(t), i = e === "x" ? A(t) : E(t), o = e === "x" ? M(t) : D(t), a = e === "x" ? E(t) : A(t), s = e === "x" ? D(t) : M(t), l = S(t, "open"), n = S(t, "close");
+  return r === null || i === null || o === null || a === null || s === null || l === null || n === null ? null : {
+    observation: t,
+    band: r,
+    bodyStart: i,
+    bodyEnd: o,
+    low: a,
+    high: s,
+    open: l,
+    close: n,
+    direction: t[w.direction] === "falling" ? "falling" : "rising"
+  };
+}, x = (t, e) => {
+  const r = [];
+  for (const i of t) {
+    const o = K(i, e);
+    o !== null && r.push(o);
+  }
+  return r;
+}, Q = 1, tt = 1, et = 0.6, rt = [
+  "open",
+  "high",
+  "low",
+  "close"
+], it = {
+  alpha: "unitInterval",
+  fillAlpha: "unitInterval",
+  strokeWidth: "pixels"
+}, _ = {
+  fill: "color",
+  stroke: "color"
+}, ot = {
+  stroke: "color",
+  alpha: "unitInterval",
+  strokeWidth: "pixels",
+  dashArray: "dashArray"
+}, at = class extends $ {
+  constructor(...t) {
+    super(...t), this.type = "candlestick", this.defaultParams = {}, this.derivedVariables = [w.direction], this.aesthetics = [{
+      kind: "visual",
+      name: "color"
+    }], this.positionRoles = [
+      {
+        axis: "x",
+        role: "point",
+        valueKind: "value"
+      },
+      {
+        axis: "y",
+        role: "min",
+        valueKind: "value",
+        aes: "low"
+      },
+      {
+        axis: "y",
+        role: "max",
+        valueKind: "value",
+        aes: "high"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "open"
+      },
+      {
+        axis: "y",
+        role: "scalar",
+        valueKind: "value",
+        aes: "close"
+      }
+    ], this.supportedPositions = ["identity"], this.supportedCoordTypes = ["cartesian", "flip"], this.scaleConstraints = { discreteMainAxis: !0 }, this.spatialKind = "spanned-buckets", this.highlightStrategy = "observation-rerender", this.tooltip = rt.map((e) => ({ aes: e })), this.styleTarget = R({
+      observation: {
+        vocabulary: it,
+        sharedPaint: !1,
+        aesthetics: {},
+        rest: {
+          alpha: 1,
+          fillAlpha: 1,
+          strokeWidth: Q
+        }
+      },
+      parts: {
+        rising: {
+          vocabulary: _,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: f("trendPositive"),
+            stroke: f("trendPositive")
+          }
+        },
+        falling: {
+          vocabulary: _,
+          aesthetics: {
+            fill: "color",
+            stroke: "color"
+          },
+          rest: {
+            fill: f("trendNegative"),
+            stroke: f("trendNegative")
+          }
+        },
+        wick: {
+          vocabulary: ot,
+          rest: {
+            alpha: 1,
+            strokeWidth: tt,
+            dashArray: []
+          }
+        }
+      }
+    }), this.resolveBandFraction = (e) => B(e), this.validateMapping = ({ mapping: e }) => ["open", "close"].filter((r) => e[r] === void 0).map((r) => ({
+      code: "MISSING_AESTHETIC",
+      message: `candlestick geom requires '${r}' to be mapped`
+    })), this.resolveAnchorPosition = (e, { coordSystem: r }) => {
+      const i = v(r), o = K(e, i);
+      return o === null ? null : i === "x" ? {
+        x: o.band,
+        y: o.close
+      } : {
+        x: o.close,
+        y: o.band
+      };
+    };
+  }
+  resolveParams(t) {
+    const { width: e, ...r } = super.resolveParams(t);
+    if (e === void 0) return r;
+    const i = typeof e == "number" && Number.isFinite(e) ? e : null;
+    if (i !== null && i > 0 && i <= 1) return {
+      ...r,
+      width: i
+    };
+    const o = i !== null && i > 1 ? 1 : void 0;
+    return t.diagnostics?.addWarning({
+      code: "INVALID_GEOM_PARAM",
+      message: `Candlestick width must be a fraction in (0, 1], got ${String(e)}; falling back to ${o ?? "the default band"}.`,
+      context: {
+        geom: this.type,
+        param: "width",
+        expected: "0 < width <= 1",
+        actual: i ?? String(e)
+      },
+      suggestion: "Set params.width to a fraction of the session band in (0, 1]."
+    }), {
+      ...r,
+      ...o !== void 0 && { width: o }
+    };
+  }
+  compile({ data: t, mapping: e, params: r }) {
+    const i = B(r) / 2;
+    return {
+      data: nt(t, O(e.open), O(e.close)).addConstantVariable(P.xMin, "numeric", -i).addConstantVariable(P.xMax, "numeric", i),
+      mapping: { y: e.close }
+    };
+  }
+}, B = ({ width: t }) => t ?? et, O = (t) => t === void 0 ? null : typeof t == "string" ? t : "variable" in t ? t.variable : null, nt = (t, e, r) => {
+  if (e === null || r === null || !t.hasVariable(e) || !t.hasVariable(r)) return t;
+  const i = t.getValues(e, { type: "numeric" }), o = t.getValues(r, { type: "numeric" }), a = i.map((s, l) => {
+    const n = o[l];
+    return s === null || n === null || n === void 0 ? null : n >= s ? "rising" : "falling";
+  });
+  return t.addVariable(w.direction, "categorical", a);
+}, st = 5e-4, H = (t, e) => {
+  const r = (t.open + t.close) / 2, i = Math.max(Math.abs(t.close - t.open), st) / 2, o = p(e, {
+    main: t.bodyStart,
+    cross: r - i
+  }), a = p(e, {
+    main: t.bodyEnd,
+    cross: r + i
+  }), [s, l] = T(y(o.x), y(a.x)), [n, d] = T(m(o.y), m(a.y));
+  return {
+    x: s,
+    y: n,
+    width: l - s,
+    height: d - n
+  };
+}, T = (t, e) => t <= e ? [t, e] : [e, t], lt = ({ layer: t, coordSystem: e, panelRect: r, styleReaders: i }) => {
+  const o = v(e), a = x(t.data, o), s = i.part("wick"), l = s === void 0 ? [] : a.map((d) => {
+    const h = W(d.band, d.low, o, r), g = W(d.band, d.high, o, r), V = s.get("strokeWidth", d.observation) ?? 0;
+    return {
+      kind: "stroke",
+      pathData: `M${h.x},${h.y}L${g.x},${g.y}`,
+      width: V
+    };
+  }), n = a.map((d) => {
+    const h = H(d, o), g = h.x * r.width;
+    return {
+      kind: "region",
+      pathData: `M${g},${h.y * r.height}H${(h.x + h.width) * r.width}V${(h.y + h.height) * r.height}H${g}Z`
+    };
+  });
+  return [...l, ...n];
+}, W = (t, e, r, i) => {
+  const o = p(r, {
+    main: t,
+    cross: e
+  });
+  return q(j(o.x, o.y), i);
+}, C = (t) => {
+  const e = G(t.data, t.mapping, t.id);
+  return (r) => e(r.observation);
+}, I = ({ candles: t, mainAxis: e, styleReaders: r, getKey: i, isHovered: o = !1, shouldAnimateTransitions: a = !1 }) => {
+  const s = o ? "hovered" : void 0, l = r.part("wick");
+  return /* @__PURE__ */ J(z, { children: [l && t.map((n) => /* @__PURE__ */ c(dt, {
+    candle: n,
+    mainAxis: e,
+    readers: l,
+    directionReaders: r.part(n.direction),
+    state: s,
+    shouldAnimateTransitions: a
+  }, i(n))), t.map((n) => /* @__PURE__ */ c(ct, {
+    candle: n,
+    mainAxis: e,
+    styleReaders: r,
+    state: s,
+    shouldAnimateTransitions: a
+  }, i(n)))] });
+}, dt = ({ candle: t, mainAxis: e, readers: r, directionReaders: i, state: o, shouldAnimateTransitions: a }) => {
+  const s = p(e, {
+    main: t.band,
+    cross: t.low
+  }), l = p(e, {
+    main: t.band,
+    cross: t.high
+  }), n = r.get("strokeWidth", t.observation, o) ?? 0, d = r.get("stroke", t.observation, o) ?? i?.get("stroke", t.observation, o);
+  return /* @__PURE__ */ c(N, {
+    "data-testid": "candlestick-wick",
+    x1: u(y(s.x)),
+    y1: u(m(s.y)),
+    x2: u(y(l.x)),
+    y2: u(m(l.y)),
+    stroke: d === void 0 ? void 0 : b(d),
+    strokeOpacity: r.get("alpha", t.observation, o),
+    strokeWidth: n,
+    strokeDasharray: Z(r.get("dashArray", t.observation, o), n),
+    shouldAnimateTransitions: a
+  });
+}, ct = ({ candle: t, mainAxis: e, styleReaders: r, state: i, shouldAnimateTransitions: o }) => {
+  const a = H(t, e), s = r.part(t.direction), l = s?.get("fill", t.observation, i), n = s?.get("stroke", t.observation, i);
+  return /* @__PURE__ */ c(Y, {
+    "data-testid": "candlestick-body",
+    x: u(a.x),
+    y: u(a.y),
+    width: u(a.width),
+    height: u(a.height),
+    fill: l === void 0 ? void 0 : b(l),
+    opacity: r.get("alpha", t.observation, i),
+    fillOpacity: r.get("fillAlpha", t.observation, i),
+    stroke: n === void 0 ? void 0 : b(n),
+    strokeWidth: r.get("strokeWidth", t.observation, i),
+    shouldAnimateTransitions: o
+  });
+}, ht = ({ layer: t, sourceLayer: e, mainAxis: r, styleReaders: i }) => /* @__PURE__ */ c(I, {
+  candles: k(() => x(t.data, r), [t.data, r]),
+  mainAxis: r,
+  styleReaders: i,
+  getKey: k(() => C(e), [e])
+}), ut = ({ layer: t, primary: e, siblings: r, mainAxis: i, styleReaders: o }) => /* @__PURE__ */ c("g", {
+  "data-testid": "hovered-candles",
+  children: /* @__PURE__ */ c(I, {
+    candles: x([e, ...r].map((a) => a.observation), i),
+    mainAxis: i,
+    styleReaders: o,
+    getKey: k(() => C(t), [t]),
+    isHovered: !0
+  })
+}), gt = ({ layer: t, mainAxis: e, styleReaders: r, shouldAnimateTransitions: i, intro: o }) => {
+  const a = /* @__PURE__ */ c(I, {
+    candles: k(() => x(t.data, e), [t.data, e]),
+    mainAxis: e,
+    styleReaders: r,
+    getKey: k(() => C(t), [t]),
+    shouldAnimateTransitions: i
+  });
+  return o?.type === "fade" ? /* @__PURE__ */ c(L, {
+    intro: o,
+    children: a
+  }) : a;
+}, ft = X(new at(), {
+  coord: "cartesian",
+  swatchShape: "square",
+  guideMode: "band",
+  render: ({ layer: t, coordSystem: e, styleReaders: r, shouldAnimateTransitions: i, intro: o }) => /* @__PURE__ */ c(gt, {
+    layer: t,
+    mainAxis: v(e),
+    styleReaders: r,
+    shouldAnimateTransitions: i,
+    intro: o
+  }),
+  renderHighlight: ({ layer: t, sourceLayer: e, coordSystem: r, styleReaders: i }) => /* @__PURE__ */ c(ht, {
+    layer: t,
+    sourceLayer: e,
+    mainAxis: v(r),
+    styleReaders: i
+  }),
+  renderHover: ({ layer: t, primary: e, group: r, related: i, coordSystem: o, styleReaders: a }) => /* @__PURE__ */ c(ut, {
+    layer: t,
+    primary: e,
+    siblings: [...r, ...i],
+    mainAxis: v(o),
+    styleReaders: a
+  }),
+  renderHoverCompanions: () => null,
+  getEditOutlineShapes: lt
+});
+export {
+  at as CandlestickGeom,
+  ft as candlestick
+};

package/dist/renderer/candlestick-edit-outline.d.ts

@@ -0,0 +1,3 @@
+import { EditOutlineShape, GeomEditOutlineShapesRendererInput } from '@graphysdk/react';
+/** What point and edit outlines round the candles they take: each wick as the stroke it is painted, and each body as its box. */
+export declare const getCandlestickEditOutlineShapes: ({ layer, coordSystem, panelRect, styleReaders, }: GeomEditOutlineShapesRendererInput) => EditOutlineShape[];

package/dist/renderer/candlestick-highlight.d.ts

@@ -0,0 +1,11 @@
+import { GeomStyleReaders, MainAxis, SceneLayer } from '@graphysdk/react';
+interface HighlightedCandlesProps {
+    layer: SceneLayer;
+    /** The whole layer the matched observations were taken from. */
+    sourceLayer: SceneLayer;
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+}
+/** Repaints the matched candles above the dimmed layer, each wick and body together. */
+export declare const HighlightedCandles: ({ layer, sourceLayer, mainAxis, styleReaders }: HighlightedCandlesProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/candlestick-hover.d.ts

@@ -0,0 +1,12 @@
+import { GeomStyleReaders, HoverHit, MainAxis, SceneLayer } from '@graphysdk/react';
+interface HoveredCandlesProps {
+    layer: SceneLayer;
+    primary: HoverHit;
+    /** Any other candle of the hovered session, from duplicate rows. */
+    siblings: readonly HoverHit[];
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+}
+/** The hovered session's candle, repainted above the dimmed layer. */
+export declare const HoveredCandles: ({ layer, primary, siblings, mainAxis, styleReaders }: HoveredCandlesProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/candlestick-layer.d.ts

@@ -0,0 +1,15 @@
+import { GeomStyleReaders, LayerIntroPlan, MainAxis, SceneLayer } from '@graphysdk/react';
+interface CandlestickLayerProps {
+    layer: SceneLayer;
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+    shouldAnimateTransitions: boolean;
+    intro: LayerIntroPlan | null | undefined;
+}
+/**
+ * The layer's own paint. The engine plans a plugin geom's entrance as a fade, so the whole layer comes up on
+ * one clock. The fade is independent of `shouldAnimateTransitions`: it rides the group rather than moving the
+ * candles, so it plays even when data changes snap.
+ */
+export declare const CandlestickLayer: ({ layer, mainAxis, styleReaders, shouldAnimateTransitions, intro, }: CandlestickLayerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/renderer/candlestick-paint.d.ts

@@ -0,0 +1,18 @@
+import { GeomStyleReaders, MainAxis } from '@graphysdk/react';
+import { Candle } from '../utils/read-candle';
+/** What one pass paints: every wick below, every body above them. */
+export interface CandlestickPaintProps {
+    candles: readonly Candle[];
+    mainAxis: MainAxis;
+    styleReaders: GeomStyleReaders;
+    /** What identifies each candle across a data change, so a spring moves a candle rather than swapping it. */
+    getKey: (candle: Candle) => string;
+    /** Paints in the `hovered` state. */
+    isHovered?: boolean;
+    /**
+     * Whether wicks and bodies spring to their new positions when the data changes. The hover and highlight
+     * repaints mount and unmount with the interaction, so only the layer's own paint animates.
+     */
+    shouldAnimateTransitions?: boolean;
+}
+export declare const CandlestickPaint: ({ candles, mainAxis, styleReaders, getKey, isHovered, shouldAnimateTransitions, }: CandlestickPaintProps) => import("react/jsx-runtime").JSX.Element;

package/dist/renderer/candlestick.d.ts

@@ -0,0 +1,15 @@
+import { BoundGeomRendererDefinition } from '@graphysdk/react';
+import { CandlestickGeom } from '../engine/candlestick.geom';
+/**
+ * The candlestick plugin: pass it to `createGraphyKit({ plugins: [candlestick] })` for `kit.geom.candlestick()`.
+ *
+ * @example
+ *   const kit = createGraphyKit({ plugins: [candlestick] });
+ *   const spec = kit.pipe(
+ *     kit.createSpec({ x: 'date' }),
+ *     kit.geom.candlestick({ aes: { open: 'open', high: 'high', low: 'low', close: 'close' } }),
+ *     kit.scale.x.discrete(),
+ *     kit.scale.y.continuous()
+ *   );
+ */
+export declare const candlestick: BoundGeomRendererDefinition<CandlestickGeom>;

package/dist/renderer/utils/candle-geometry.d.ts

@@ -0,0 +1,11 @@
+import { MainAxis } from '@graphysdk/react';
+import { Candle } from '../../utils/read-candle';
+/** A box in the `[0, 1]` view box, from its top left, y growing downward. */
+export interface ViewBoxRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** The body between the open and the close, across its share of the band. */
+export declare const readBodyBox: (candle: Candle, mainAxis: MainAxis) => ViewBoxRect;

package/dist/renderer/utils/candlestick-keys.d.ts

@@ -0,0 +1,7 @@
+import { SceneLayer } from '@graphysdk/react';
+import { Candle } from '../../utils/read-candle';
+/**
+ * A candle keys on its session, read from the raw value rather than the band: the band moves with the domain,
+ * the very change a candle should spring through, not remount on.
+ */
+export declare const createCandlestickKeys: (layer: SceneLayer) => ((candle: Candle) => string);

package/dist/utils/candlestick-columns.d.ts

@@ -0,0 +1,11 @@
+/** The column `compile()` writes and the renderer reads, beside the position columns. */
+export declare const CANDLESTICK_COLUMNS: {
+    /**
+     * Whether the session closed at or above its open (`'rising'`) or below it (`'falling'`). Compared in prices
+     * rather than scaled positions, so a reversed price axis still paints a rise as a rise. Authors name it in a
+     * `highlight` or an entry's `where`, so it is part of the geom's API. A data column of the same name is
+     * replaced.
+     */
+    readonly direction: "candlestickDirection";
+};
+export type CandlestickDirection = 'rising' | 'falling';

package/dist/utils/read-candle.d.ts

@@ -0,0 +1,24 @@
+import { MainAxis, Observation } from '@graphysdk/react';
+import { CandlestickDirection } from './candlestick-columns';
+/** A candle placed by its band on the main axis and its four prices on the other, each a `[0, 1]` fraction. */
+export interface Candle {
+    observation: Observation;
+    /** Where the wick stands on the main axis: the session's band centre. */
+    band: number;
+    /** The body's two edges on the main axis. */
+    bodyStart: number;
+    bodyEnd: number;
+    low: number;
+    high: number;
+    open: number;
+    close: number;
+    direction: CandlestickDirection;
+}
+/**
+ * Reads where a candle sits. The flip is already baked into the position columns, so under `coord.flip()` the
+ * band is `y`/`yMin`/`yMax` and the wick runs `xMin` to `xMax`; the open and close are scaled on the price axis
+ * whatever the flip.
+ */
+export declare const readCandle: (observation: Observation, mainAxis: MainAxis) => Candle | null;
+/** Reads every candle of a layer, skipping a session missing a price. */
+export declare const readCandles: (observations: Iterable<Observation>, mainAxis: MainAxis) => Candle[];

package/licenses/PolyForm-Free-Trial-1.0.0.md

@@ -0,0 +1,93 @@
+# PolyForm Free Trial License 1.0.0
+
+<https://polyformproject.org/licenses/free-trial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software
+to do everything you might do with the software that would
+otherwise infringe the licensor's copyright in it for any
+permitted purpose. However, you may only make changes or
+new works based on the software according to [Changes and New
+Works License](#changes-and-new-works-license), and you may
+not distribute copies of the software.
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## Free Trial
+
+Use to evaluate whether the software suits a particular
+application for less than 32 consecutive calendar days, on
+behalf of you or your company, is use for a permitted purpose.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+If you violate any of these terms, or do anything with the
+software not covered by your licenses, all your licenses
+end immediately.
+
+## No Liability
+
+_**As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.**_
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/licenses/PolyForm-NonCommercial-1.0.0.md

@@ -0,0 +1,131 @@
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose. However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software. Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software. For example:
+
+> Required Notice: Copyright Graphy Technologies Ltd. (https://graphy.dev)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for
+the benefit of public knowledge, personal study, private
+entertainment, hobby projects, amateur pursuits, or religious
+observance, without any anticipated commercial application,
+is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution,
+public research organization, public safety or health
+organization, environmental protection organization,
+or government institution is use for a permitted purpose
+regardless of the source of funding or obligations resulting
+from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice. Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+_**As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.**_
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/licenses/PolyForm-Small-Business-1.0.0.md

@@ -0,0 +1,121 @@
+# PolyForm Small Business License 1.0.0
+
+<https://polyformproject.org/licenses/small-business/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree
+to them as both strict obligations and conditions to all
+your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the
+software to do everything you might do with the software
+that would otherwise infringe the licensor's copyright
+in it for any permitted purpose. However, you may
+only distribute the software according to [Distribution
+License](#distribution-license) and make changes or new works
+based on the software according to [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license
+to distribute copies of the software. Your license
+to distribute covers distributing the software with
+changes and new works permitted by [Changes and New Works
+License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of
+the software from you also gets a copy of these terms or the
+URL for them above, as well as copies of any plain-text lines
+beginning with `Required Notice:` that the licensor provided
+with the software. For example:
+
+> Required Notice: Copyright Graphy Technologies Ltd. (https://graphy.dev)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to
+make changes and new works based on the software for any
+permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that
+covers patent claims the licensor can license, or becomes able
+to license, that you would infringe by using the software.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the
+law. These terms do not limit them.
+
+## Small Business
+
+Use of the software for the benefit of your company is use for
+a permitted purpose if your company has fewer than 100 total
+individuals working as employees and independent contractors,
+and less than 1,000,000 USD (2019) total revenue in the prior
+tax year. Adjust this revenue threshold for inflation according
+to the United States Bureau of Labor Statistics' consumer price
+index for all urban consumers, U.S. city average, for all items,
+not seasonally adjusted, with 1982–1984=100 reference base.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of
+your licenses to anyone else, or prevent the licensor from
+granting licenses to anyone else. These terms do not imply
+any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or
+contributes to infringement of any patent, your patent license
+for the software granted under these terms ends immediately. If
+your company makes such a claim, your patent license ends
+immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have
+violated any of these terms, or done anything with the software
+not covered by your licenses, your licenses can nonetheless
+continue if you come into full compliance with these terms,
+and take practical steps to correct past violations, within
+32 days of receiving notice. Otherwise, all your licenses
+end immediately.
+
+## No Liability
+
+_**As far as the law allows, the software comes as is, without
+any warranty or condition, and the licensor will not be liable
+to you for any damages arising out of these terms or the use
+or nature of the software, under any kind of legal claim.**_
+
+## Definitions
+
+The **licensor** is the individual or entity offering these
+terms, and the **software** is the software the licensor makes
+available under these terms.
+
+**You** refers to the individual or entity agreeing to these
+terms.
+
+**Your company** is any legal entity, sole proprietorship,
+or other kind of organization that you work for, plus all
+organizations that have control over, are under the control of,
+or are under common control with that organization. **Control**
+means ownership of substantially all the assets of an entity,
+or the power to direct its management and policies by vote,
+contract, or otherwise. Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the
+software under these terms.
+
+**Use** means anything you do with the software requiring one
+of your licenses.

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@graphysdk/geom-candlestick",
+  "author": "Graphy",
+  "description": "Candlestick geom for the Graphy charting SDK (beta)",
+  "homepage": "https://docs.graphy.dev/sdk-next/graph-types/candlestick",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "keywords": [
+    "graphy",
+    "chart",
+    "react",
+    "visualization",
+    "grammar-of-graphics",
+    "candlestick"
+  ],
+  "version": "0.1.0",
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "LICENSE.md",
+    "licenses",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "peerDependencies": {
+    "react": "^19.0.0",
+    "@graphysdk/react": "^1.9.0-beta.1790720825915"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.1",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "rollup-plugin-node-externals": "^8.1.1",
+    "vite": "^8.1.5",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.11",
+    "@graphysdk/react": "1.9.0-beta.1790720825915",
+    "@graphytools/typescript-config": "0.0.1",
+    "@graphysdk/viz-engine": "1.8.0",
+    "@graphytools/vitest-config": "1.0.0",
+    "@graphytools/eslint-config": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,js,jsx,json,css,md}": [
+      "prettier --write"
+    ],
+    "*.{ts,tsx}": [
+      "eslint --max-warnings=0 --fix"
+    ]
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "vitest run",
+    "test:watch": "TZ=utc vitest",
+    "lint": "eslint . --max-warnings 0",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "typecheck": "tsc --noEmit"
+  }
+}