@octanejs/recharts 0.1.41 → 0.1.42

package/src/util/{svgPropertiesNoEvents.js → svgPropertiesNoEvents.ts}

@@ -1,9 +1,8 @@
-// Vendored from recharts@3.9.2 es6/util/svgPropertiesNoEvents.js with ONE
-// adaptation: `isValidElement` comes from octane (this file inspects OCTANE
-// element descriptors at runtime, not React elements). Everything else is
-// verbatim — update by re-vendoring when the recharts devDependency moves.
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
 import { isValidElement } from 'octane';
-var SVGElementPropKeys = [
+import type { OctaneElement } from './OctaneTypes';
+
+const SVGElementPropKeys = [
 	'aria-activedescendant',
 	'aria-atomic',
 	'aria-autocomplete',
@@ -312,20 +311,32 @@ var SVGElementPropKeys = [
 	'ref',
 	'key',
 	'angle',
-];
-var SVGElementPropKeySet = new Set(SVGElementPropKeys);
-export function isSvgElementPropKey(key) {
+] as const;
+
+export type SVGElementPropKeysType = (typeof SVGElementPropKeys)[number];
+
+const SVGElementPropKeySet = new Set<string>(SVGElementPropKeys);
+
+export function isSvgElementPropKey(key: PropertyKey): boolean {
 	if (typeof key !== 'string') {
 		return false;
 	}
 	return SVGElementPropKeySet.has(key);
 }
+
+export type DataAttributeKeyType = `data-${string}`;
+
+export type SVGPropsNoEvents<T> = Pick<
+	T,
+	Extract<keyof T, SVGElementPropKeysType | DataAttributeKeyType>
+>;
+
 /**
  * Checks if the property is a data attribute.
  * @param key The property key.
  * @returns True if the key starts with 'data-', false otherwise.
  */
-export function isDataAttribute(key) {
+export function isDataAttribute(key: PropertyKey): key is DataAttributeKeyType {
 	return typeof key === 'string' && key.startsWith('data-');
 }
 
@@ -334,50 +345,64 @@ export function isDataAttribute(key) {
  * @param obj - The object to filter
  * @returns A new object containing only valid SVG properties, excluding event handlers.
  */
-export function svgPropertiesNoEvents(obj) {
+export function svgPropertiesNoEvents<T extends Record<PropertyKey, any>>(
+	obj: T | boolean,
+): SVGPropsNoEvents<T> {
 	if (typeof obj !== 'object' || obj === null) {
-		return {};
+		return {} as SVGPropsNoEvents<T>;
 	}
-	var result = {};
-	for (var key in obj) {
+	const result: Record<PropertyKey, any> = {};
+
+	for (const key in obj) {
 		if (Object.prototype.hasOwnProperty.call(obj, key)) {
 			if (isSvgElementPropKey(key) || isDataAttribute(key)) {
 				result[key] = obj[key];
 			}
 		}
 	}
-	return result;
+	return result as SVGPropsNoEvents<T>;
 }
 
 /**
  * Function to filter SVG properties from various input types.
  * The input types can be:
  * - A record of string keys to any values, in which case it returns a record of only SVG properties
- * - A React element, in which case it returns the props of the element filtered to only SVG properties
+ * - An Octane element, in which case it returns the props of the element filtered to only SVG properties
  * - Anything else, in which case it returns null
  *
- * This function has a wide-open return type, because it will read and filter the props of an arbitrary React element.
- * This can be SVG, HTML, whatnot, with arbitrary values, so we can't type it more specifically.
- *
- * If you wish to have a type-safe version, use svgPropertiesNoEvents directly with a typed object.
+ * Known prop bags retain their property types. Unknown input keeps the broad
+ * return type because arbitrary element props may contain non-SVG values.
  *
- * @param input - The input to filter, which can be a record, a React element, or other types.
+ * @param input - The input to filter, which can be a record, an Octane element, or other types.
  * @returns A record of SVG properties if the input is a record or React element, otherwise null.
  */
-export function svgPropertiesNoEventsFromUnknown(input) {
+type UnknownSvgProps = Partial<Record<SVGElementPropKeysType, unknown>> | null;
+export type SVGPropsFromUnknown<T> = unknown extends T
+	? UnknownSvgProps
+	: T extends string | number | boolean | bigint | symbol | null | undefined
+		? null
+		: T extends OctaneElement<infer P>
+			? SVGPropsNoEvents<P>
+			: T extends readonly unknown[] | ((...args: never[]) => unknown)
+				? null
+				: T extends object
+					? SVGPropsNoEvents<T>
+					: null;
+
+export function svgPropertiesNoEventsFromUnknown<T>(input: T): SVGPropsFromUnknown<T>;
+export function svgPropertiesNoEventsFromUnknown(input: unknown): UnknownSvgProps {
 	if (input == null) {
 		return null;
 	}
-	if (
-		/*#__PURE__*/ isValidElement(input) &&
-		typeof input.props === 'object' &&
-		input.props !== null
-	) {
-		var p = input.props;
+
+	if (isValidElement(input) && typeof input.props === 'object' && input.props !== null) {
+		const p: Partial<Record<PropertyKey, unknown>> = input.props;
 		return svgPropertiesNoEvents(p);
 	}
+
 	if (typeof input === 'object' && !Array.isArray(input)) {
 		return svgPropertiesNoEvents(input);
 	}
+
 	return null;
 }

package/src/util/tooltip/translate.ts

@@ -1,5 +1,6 @@
+import type { CSSProperties } from '../OctaneTypes';
 import { clsx } from 'clsx';
-import { CSSProperties } from 'octane';
+
 import { isNumber } from '../DataUtils';
 import { Coordinate, CartesianViewBox, AllowInDimension } from '../types';
 

package/src/util/typedDataKey.ts

@@ -0,0 +1,49 @@
+// Adapted from recharts@3.9.2, commit b3451050c027a23957ffa50a2665c9119df21e47.
+/**
+ * Extracts values from data objects.
+ * Has two generics:
+ * - DataPointType: The type of the data object.
+ * - DataValueType: The type of the value to extract.
+ *
+ * The wall of text below may be simplified to:
+ * - string (must be a key of DataPointType)
+ * - number (must be a key of DataPointType)
+ * - function that takes DataPointType and returns DataValueType `(obj: DataPointType) => DataValueType)`
+ *
+ * The actual implementation is more complex to allow for better type inference and autocomplete.
+ */
+export type TypedDataKey<DataPointType = any, DataValueType = unknown> =
+	/*
+	 * If T is any or unknown, we allow loose typing.
+	 * Either an arbitrary string|number key or a function that takes T and returns R.
+	 * We will follow the generics provided by the user in this case.
+	 */
+	unknown extends DataPointType
+		? string | number | ((obj: DataPointType) => DataValueType)
+		: /*
+			 * If T has a string index signature, we allow any key.
+			 * This handles cases like Record<string, any>.
+			 */
+			string extends keyof DataPointType
+			? string | number | ((obj: DataPointType) => DataValueType)
+			: /*
+				 * Otherwise, we extract keys from T whose values extend R.
+				 * This allows for strongly typed access to known properties.
+				 * This part also enables Intellisense/autocomplete for known keys.
+				 */
+				| {
+						[K in keyof DataPointType]: DataPointType[K] extends DataValueType
+							? K extends string | number
+								? K
+								: never
+							: never;
+				  }[keyof DataPointType]
+				/*
+				 * Additionally, if T is an array or readonly array, we allow numeric string keys for convenience.
+				 */
+				| (DataPointType extends ReadonlyArray<infer E>
+						? E extends DataValueType
+							? `${number}`
+							: never
+						: never)
+				| ((obj: DataPointType) => DataValueType);