@octanejs/recharts 0.1.40 → 0.1.42

package/src/index.ts

@@ -3,15 +3,12 @@
 // Recharts 3 splits cleanly along the same seam as the other octane bindings:
 // its chart STATE is framework-agnostic (Redux Toolkit slices + reselect
 // selectors; d3 math via victory-vendor; es-toolkit utilities) and its React
-// layer is components + hooks over an isolated redux store. This package
-// MIRRORS upstream's file layout under src/: framework-agnostic modules are
-// vendored verbatim (`.js`, marked with a "Vendored verbatim" header) and the
-// React layer is re-implemented on octane (`.ts`/`.tsrx`) at the same paths —
-// so upstream's relative imports resolve unchanged, vendored or ported.
-// The store runs through @octanejs/redux.
-//
-// Port status: Phase 1 (static BarChart + LineChart pipeline) — see
-// docs/recharts-port-plan.md for the phase map.
+// layer is components + hooks over an isolated redux store. The authored
+// TypeScript modules retain the reviewed upstream layout and native Octane
+// component contracts. The store runs through @octanejs/redux, and consumers
+// typecheck and compile the same .ts/.tsrx source that is executed.
+import type { Props as NativeAreaProps } from './cartesian/Area.tsrx';
+import type { Props as NativePieProps } from './polar/Pie.tsrx';
 export { Surface } from './container/Surface.tsrx';
 export { Layer } from './container/Layer.tsrx';
 export { Cell } from './component/Cell';
@@ -71,34 +68,37 @@ export { PolarRadiusAxis } from './polar/PolarRadiusAxis.tsrx';
 export { Sankey } from './chart/Sankey.tsrx';
 export { SunburstChart } from './chart/SunburstChart.tsrx';
 
-// Public prop contracts used by component-library wrappers. The runtime port
-// accepts the same prop bags as Recharts; keep these structural while the
-// generated declaration surface is expanded component by component.
-export type AreaProps<DataPointType = any, ValueAxisType = any> = Record<string, any>;
-export type BarProps = Record<string, any>;
-export type BarShapeProps = Record<string, any>;
-export type BrushProps = Record<string, any>;
-export type CartesianGridProps = Record<string, any>;
-export type DotProps = Record<string, any>;
-export type FunnelProps = Record<string, any>;
-export type LabelListProps = Record<string, any>;
-export type LabelProps = Record<string, any>;
-export type LineProps = Record<string, any>;
-export type PieLabel = (props: Record<string, any>) => unknown;
-export type PieProps<DataPointType = any, DataValueType = any> = Record<string, any>;
-export type PolarAngleAxisProps = Record<string, any>;
-export type PolarGridProps = Record<string, any>;
-export type PolarRadiusAxisProps = Record<string, any>;
-export type RadarProps = Record<string, any>;
-export type RadialBarProps = Record<string, any>;
-export type ReferenceLineProps = Record<string, any>;
-export type SankeyProps = Record<string, any>;
-export type ScatterProps = Record<string, any>;
-export type SunburstChartProps = Record<string, any>;
-export type TreemapProps = Record<string, any>;
-export type XAxisProps = Record<string, any>;
-export type YAxisProps = Record<string, any>;
-export type ZAxisProps = Record<string, any>;
+// Public aliases come from each component's implementation, not a parallel
+// declaration facade. Keep the previously defaulted Area/Pie generic aliases.
+export type AreaProps<DataPointType = unknown, ValueAxisType = unknown> = NativeAreaProps<
+	DataPointType,
+	ValueAxisType
+>;
+export type PieProps<DataPointType = unknown, DataValueType = unknown> = NativePieProps<
+	DataPointType,
+	DataValueType
+>;
+export type { Props as BarProps, BarShapeProps } from './cartesian/Bar.tsrx';
+export type { Props as CartesianGridProps } from './cartesian/CartesianGrid.tsrx';
+export type { Props as DotProps } from './shape/Dot.tsrx';
+export type { Props as FunnelProps } from './cartesian/Funnel.tsrx';
+export type { Props as LabelListProps } from './component/LabelList.tsrx';
+export type { Props as LabelProps } from './component/Label.tsrx';
+export type { Props as LineProps } from './cartesian/Line.tsrx';
+export type { PieLabel, PieLabelRenderProps } from './polar/Pie.tsrx';
+export type { Props as PolarAngleAxisProps } from './polar/PolarAngleAxis.tsrx';
+export type { Props as PolarGridProps } from './polar/PolarGrid.tsrx';
+export type { Props as PolarRadiusAxisProps } from './polar/PolarRadiusAxis.tsrx';
+export type { Props as RadarProps } from './polar/Radar.tsrx';
+export type { RadialBarProps } from './polar/RadialBar.tsrx';
+export type { Props as ReferenceLineProps } from './cartesian/ReferenceLine.tsrx';
+export type { Props as SankeyProps } from './chart/Sankey.tsrx';
+export type { Props as ScatterProps } from './cartesian/Scatter.tsrx';
+export type { SunburstChartProps } from './chart/SunburstChart.tsrx';
+export type { Props as XAxisProps } from './cartesian/XAxis.tsrx';
+export type { Props as YAxisProps } from './cartesian/YAxis.tsrx';
+export type { Props as ZAxisProps } from './cartesian/ZAxis.tsrx';
+export type { RechartsProps, BrushProps, TreemapProps } from './legacy-props';
 export { CartesianAxis } from './cartesian/CartesianAxis.tsrx';
 export { BarStack } from './cartesian/BarStack.tsrx';
 export { LineDrawShape } from './cartesian/LineDrawShape.tsrx';

package/src/internal.ts

@@ -6,27 +6,11 @@
 
 // Memoized: subSlot runs on EVERY hook call every render; the cache returns the
 // identical Symbol.for-interned value without the concat + registry lookup.
-const subSlotCache = new Map<symbol, Map<string, symbol>>();
-// Tag-only symbols for the slotless-caller case (see below).
-const bareTagCache = new Map<string, symbol>();
+import { createSubSlot } from 'octane';
 
-export function subSlot(slot: symbol | undefined, tag: string): symbol {
-	// No inherited slot (the caller was NOT compiled — e.g. a vendored wrapper
-	// hook): return a stable TAG-ONLY symbol rather than undefined. The runtime
-	// combines it with the ambient withSlot path, so sibling base hooks inside
-	// one composed hook stay DISTINCT per tag. Returning undefined here made
-	// them all resolve to the bare path — one shared slot, state collision.
-	if (slot === undefined) {
-		let bare = bareTagCache.get(tag);
-		if (bare === undefined) bareTagCache.set(tag, (bare = Symbol.for(':' + tag)));
-		return bare;
-	}
-	let byTag = subSlotCache.get(slot);
-	if (byTag === undefined) subSlotCache.set(slot, (byTag = new Map()));
-	let sym = byTag.get(tag);
-	if (sym === undefined) byTag.set(tag, (sym = Symbol.for((slot.description ?? '') + ':' + tag)));
-	return sym;
-}
+// A stable tag-only symbol keeps sibling base hooks distinct when an
+// uncompiled caller relies on the ambient withSlot path.
+export const subSlot = createSubSlot({ slotlessPrefix: ':' });
 
 // Split the compiler-injected trailing slot off a hook's runtime args, returning
 // the user args (everything before it) and the slot.

package/src/legacy-props.ts

@@ -0,0 +1,129 @@
+import type { OctaneNode } from 'octane';
+
+type Render = OctaneNode | ((...args: any[]) => OctaneNode);
+type Handler = (...args: any[]) => void;
+
+/**
+ * Legacy broad prop bag retained for source compatibility only.
+ * @deprecated Use the specific exported component prop type instead.
+ * No rendered component uses this interface as its props contract.
+ */
+export interface RechartsProps {
+	accessibilityLayer?: boolean;
+	allowDecimals?: boolean;
+	activeBar?: Render | Record<string, unknown>;
+	activeDot?: Render;
+	activeIndex?: number;
+	activeShape?: Render | Record<string, unknown>;
+	angle?: number;
+	animationBegin?: number;
+	animationDuration?: number;
+	animationEasing?: string;
+	aspect?: number;
+	axisLine?: boolean | Record<string, unknown>;
+	barCategoryGap?: number | string;
+	barGap?: number | string;
+	barSize?: number | string;
+	baseValue?: number | 'dataMin' | 'dataMax';
+	background?: Render | Record<string, unknown>;
+	children?: OctaneNode;
+	className?: string;
+	color?: string;
+	connectNulls?: boolean;
+	content?: Render | Record<string, unknown>;
+	cursor?: Render | Record<string, unknown>;
+	cx?: number | string;
+	cy?: number | string;
+	data?: readonly unknown[];
+	dataKey?: string | number | ((entry: unknown) => unknown);
+	debounce?: number;
+	domain?: readonly unknown[];
+	dot?: Render | Record<string, unknown>;
+	dy?: number | string;
+	endAngle?: number;
+	fill?: string;
+	fillOpacity?: number;
+	fontFamily?: string;
+	fontSize?: number | string;
+	formatter?: (...args: any[]) => OctaneNode;
+	height?: number | string;
+	hide?: boolean;
+	horizontal?: boolean;
+	id?: string;
+	innerRadius?: number | string;
+	interval?: number | string;
+	isAnimationActive?: boolean;
+	label?: Render | Record<string, unknown>;
+	labelLine?: boolean | Record<string, unknown>;
+	labelFormatter?: (...args: any[]) => OctaneNode;
+	layout?: 'horizontal' | 'vertical' | 'centric' | 'radial';
+	legendType?: string;
+	line?: boolean | Record<string, unknown>;
+	link?: Render | Record<string, unknown>;
+	linkCurvature?: number;
+	margin?: number | { top?: number; right?: number; bottom?: number; left?: number };
+	maxBarSize?: number;
+	maxHeight?: number;
+	minTickGap?: number;
+	minHeight?: number | string;
+	minPointSize?: number | ((value: unknown) => number);
+	minWidth?: number | string;
+	name?: string | number;
+	nameKey?: string | number | ((entry: unknown) => unknown);
+	node?: Render | Record<string, unknown>;
+	nodePadding?: number;
+	nodeWidth?: number;
+	onAnimationEnd?: Handler;
+	onAnimationStart?: Handler;
+	onClick?: Handler;
+	onMouseEnter?: Handler;
+	onMouseLeave?: Handler;
+	onResize?: (width: number, height: number) => void;
+	orientation?: string;
+	outerRadius?: number | string;
+	offset?: number;
+	paddingAngle?: number;
+	padding?: number | { top?: number; right?: number; bottom?: number; left?: number };
+	payload?: Record<string, any> | readonly Record<string, any>[];
+	position?: string | { x?: number; y?: number };
+	radius?: number | readonly number[];
+	range?: readonly number[];
+	ref?: unknown;
+	reversed?: boolean;
+	ringPadding?: number;
+	scale?: string | ((value: unknown) => unknown);
+	shape?: Render | Record<string, unknown>;
+	stackId?: string | number;
+	stackOffset?: string;
+	startAngle?: number;
+	stroke?: string;
+	strokeDasharray?: string | number;
+	strokeOpacity?: number;
+	strokeWidth?: number;
+	style?: object;
+	syncId?: string | number;
+	textAnchor?: string;
+	textOptions?: Record<string, unknown>;
+	tick?: Render | Record<string, unknown>;
+	tickCount?: number;
+	tickFormatter?: (value: any, index: number) => string;
+	tickLine?: boolean | Record<string, unknown>;
+	ticks?: readonly unknown[];
+	tooltipType?: string;
+	type?: string;
+	unit?: string | number;
+	valueKey?: string | number | ((entry: unknown) => unknown);
+	vertical?: boolean;
+	verticalAlign?: 'top' | 'middle' | 'bottom';
+	iterations?: number;
+	width?: number | string;
+	xAxisId?: string | number;
+	yAxisId?: string | number;
+	zAxisId?: string | number;
+}
+
+/** @deprecated Brush is not implemented by the Octane runtime port. */
+export type BrushProps = RechartsProps;
+
+/** @deprecated Treemap is not implemented by the Octane runtime port. */
+export type TreemapProps = RechartsProps;