@octanejs/visx 0.1.0

package/src/internal/spring.tsrx

@@ -0,0 +1,190 @@
+import { createElement, useEffect, useRef, useState } from 'octane';
+
+type AnyRecord = Record<string, any>;
+
+export class SpringValue<T> {
+	private readonly value: T;
+
+	constructor(value: T) {
+		this.value = value;
+	}
+
+	get(): T {
+		return this.value;
+	}
+
+	to<U>(interpolator: (value: T) => U): DerivedValue<U> {
+		return new DerivedValue(() => interpolator(this.value));
+	}
+}
+
+class DerivedValue<T> {
+	private readonly read: () => T;
+
+	constructor(read: () => T) {
+		this.read = read;
+	}
+
+	get(): T {
+		return this.read();
+	}
+}
+
+function valueOf(value: any): any {
+	if (value && typeof value.get === 'function') return value.get();
+	if (Array.isArray(value)) return value.map(valueOf);
+	if (value && typeof value === 'object') {
+		const result: AnyRecord = {};
+		for (const [key, child] of Object.entries(value)) result[key] = valueOf(child);
+		return result;
+	}
+	return value;
+}
+
+function animatedHost(tag: string) {
+	return function AnimatedHost(props: AnyRecord) {
+		const { children, ...hostProps } = valueOf(props);
+		if (children === undefined) return createElement(tag, hostProps);
+		return createElement(tag, hostProps, ...(Array.isArray(children) ? children : [children]));
+	};
+}
+
+export const animated = new Proxy(Object.create(null), {
+	get(target, property: string) {
+		return target[property] ??= animatedHost(property);
+	},
+}) as Record<string, (props: AnyRecord) => unknown>;
+
+export function to<T extends readonly unknown[], R>(
+	inputs: T,
+	interpolator: (...values: { [K in keyof T]: T[K] extends SpringValue<infer V> ? V : T[K] }) => R,
+): DerivedValue<R> {
+	return new DerivedValue(() => interpolator(...inputs.map(valueOf) as any));
+}
+
+function springTarget(config: AnyRecord): AnyRecord {
+	if (config.to && typeof config.to === 'object') return config.to;
+	const { from: _from, to: _to, reset: _reset, delay: _delay, config: _config, ...target } = config;
+	return target;
+}
+
+function interpolate(from: AnyRecord, target: AnyRecord, progress: number): AnyRecord {
+	const result: AnyRecord = {};
+	for (const key of new Set([...Object.keys(from), ...Object.keys(target)])) {
+		const start = from[key];
+		const end = target[key];
+		result[key] = typeof start === 'number' && typeof end === 'number'
+			? start + (end - start) * progress
+			: progress < 1
+				? start ?? end
+				: end;
+	}
+	return result;
+}
+
+function targetKey(value: AnyRecord): string {
+	return JSON.stringify(
+		value,
+		(_key, child) => (typeof child === 'function' ? '[function]' : child),
+	);
+}
+
+export function useSpring(config: AnyRecord): AnyRecord {
+	const target = springTarget(config);
+	const key = targetKey(target);
+	const targetRef = useRef(target);
+	const keyRef = useRef(key);
+	const mountedRef = useRef(false);
+	const [values, setValues] = useState(target);
+
+	useEffect(() => {
+		if (!mountedRef.current) {
+			mountedRef.current = true;
+			targetRef.current = target;
+			keyRef.current = key;
+			return;
+		}
+		if (keyRef.current === key) return;
+		const start =
+			config.reset && config.from ? config.from : targetRef.current;
+		targetRef.current = target;
+		keyRef.current = key;
+		if (typeof requestAnimationFrame === 'undefined') {
+			setValues(target);
+			return;
+		}
+		const startedAt = performance.now() + (config.delay ?? 0);
+		let frame = 0;
+		const tick = (now: number) => {
+			const progress = Math.max(0, Math.min(1, (now - startedAt) / 250));
+			setValues(interpolate(start, target, progress));
+			if (progress < 1) frame = requestAnimationFrame(tick);
+		};
+		frame = requestAnimationFrame(tick);
+		return () => cancelAnimationFrame(frame);
+	}, [key]);
+
+	const wrapped: AnyRecord = {};
+	for (const [name, value] of Object.entries(values)) wrapped[name] = new SpringValue(value);
+	return wrapped;
+}
+
+function transitionStyle(
+	config: AnyRecord,
+	item: any,
+	phase: 'from' | 'enter' | 'update' | 'leave',
+) {
+	const candidate = config[phase] ?? config.update ?? config.enter;
+	return typeof candidate === 'function' ? candidate(item) : candidate ?? {};
+}
+
+/**
+ * React-spring-compatible transition projection. It keeps leaving entries for
+ * one animation frame and interpolates numeric style fields in one hook cell,
+ * so keyed Visx series retain their enter/update/leave behavior without hooks
+ * inside item loops.
+ */
+export function useTransition(items: any[], config: AnyRecord) {
+	const keyFor = config.keys ?? config.key ?? ((item: any, index: number) => item?.key ?? index);
+	const projected = items.map(
+		(item, index) => ({
+			item,
+			key: keyFor(item, index),
+			style: transitionStyle(config, item, 'update'),
+		}),
+	);
+	const signature = targetKey(projected.map(({ key, style }) => ({ key, style })));
+	const signatureRef = useRef(signature);
+	const [entries, setEntries] = useState(projected);
+
+	useEffect(() => {
+		if (signatureRef.current === signature) return;
+		signatureRef.current = signature;
+		setEntries((previous) => {
+			const previousByKey = new Map(previous.map((entry) => [entry.key, entry]));
+			const next = projected.map(
+				(entry) => ({
+					...entry,
+					style: previousByKey.has(entry.key)
+						? transitionStyle(config, entry.item, 'update')
+						: transitionStyle(config, entry.item, 'enter'),
+				}),
+			);
+			const liveKeys = new Set(next.map((entry) => entry.key));
+			const leaving = previous.filter((entry) => !liveKeys.has(entry.key)).map(
+				(entry) => ({ ...entry, style: transitionStyle(config, entry.item, 'leave') }),
+			);
+			if (leaving.length && typeof requestAnimationFrame !== 'undefined') {
+				requestAnimationFrame(() => setEntries(next));
+			}
+			return [...next, ...leaving];
+		});
+	}, [signature]);
+
+	return (renderer: (style: AnyRecord, item: any, state: { key: any }, index: number) => unknown) =>
+		entries.map((entry, index) => {
+			const style: AnyRecord = {};
+			for (const [name, value] of Object.entries(entry.style)) style[name] = new SpringValue(value);
+			return renderer(style, entry.item, { key: entry.key }, index);
+		});
+}

package/src/internal/spring.tsrx.d.ts

@@ -0,0 +1,28 @@
+// Generated by scripts/generate-tsrx-types.mjs.
+type AnyRecord = Record<string, any>;
+export declare class SpringValue<T> {
+    private readonly value;
+    constructor(value: T);
+    get(): T;
+    to<U>(interpolator: (value: T) => U): DerivedValue<U>;
+}
+declare class DerivedValue<T> {
+    private readonly read;
+    constructor(read: () => T);
+    get(): T;
+}
+export declare const animated: Record<string, (props: AnyRecord) => unknown>;
+export declare function to<T extends readonly unknown[], R>(inputs: T, interpolator: (...values: {
+    [K in keyof T]: T[K] extends SpringValue<infer V> ? V : T[K];
+}) => R): DerivedValue<R>;
+export declare function useSpring(config: AnyRecord): AnyRecord;
+/**
+ * React-spring-compatible transition projection. It keeps leaving entries for
+ * one animation frame and interpolates numeric style fields in one hook cell,
+ * so keyed Visx series retain their enter/update/leave behavior without hooks
+ * inside item loops.
+ */
+export declare function useTransition(items: any[], config: AnyRecord): (renderer: (style: AnyRecord, item: any, state: {
+    key: any;
+}, index: number) => unknown) => unknown[];
+export {};

package/src/internal/useMeasure.tsrx

@@ -0,0 +1,120 @@
+import { useCallback, useEffect, useRef, useState } from 'octane';
+
+export type RectReadOnly = {
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+	top: number;
+	right: number;
+	bottom: number;
+	left: number;
+};
+
+export type ResizeObserverConstructor =
+	new (callback: ResizeObserverCallback) => Pick<ResizeObserver, | 'observe'
+	| 'unobserve'
+	| 'disconnect'>;
+
+export type Options = {
+	debounce?: number | { scroll?: number; resize?: number };
+	scroll?: boolean;
+	polyfill?: ResizeObserverConstructor;
+	offsetSize?: boolean;
+};
+
+const ZERO_RECT: RectReadOnly = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0,
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0,
+};
+
+function sameRect(a: RectReadOnly, b: RectReadOnly): boolean {
+	return a.x === b.x && a.y === b.y && a.width === b.width && a.height === b.height &&
+		a.top === b.top &&
+		a.right === b.right &&
+		a.bottom === b.bottom &&
+		a.left === b.left;
+}
+
+export default function useMeasure(options: Options = {}) {
+	const elementRef = useRef<HTMLElement | SVGElement | null>(null);
+	const frameRef = useRef<number | null>(null);
+	const cleanupRef = useRef<(() => void) | null>(null);
+	const [bounds, setBounds] = useState<RectReadOnly>(ZERO_RECT);
+
+	const refresh = useCallback(() => {
+		const element = elementRef.current;
+		if (!element || typeof element.getBoundingClientRect !== 'function') return;
+		const rect = element.getBoundingClientRect();
+		const width =
+			options.offsetSize && 'offsetWidth' in element
+				? (element as HTMLElement).offsetWidth
+				: rect.width;
+		const height =
+			options.offsetSize && 'offsetHeight' in element
+				? (element as HTMLElement).offsetHeight
+				: rect.height;
+		const next: RectReadOnly = {
+			x: rect.x,
+			y: rect.y,
+			width,
+			height,
+			top: rect.top,
+			right: rect.left + width,
+			bottom: rect.top + height,
+			left: rect.left,
+		};
+		setBounds((previous) => (sameRect(previous, next) ? previous : next));
+	}, [options.offsetSize]);
+
+	const scheduleRefresh = useCallback(() => {
+		if (typeof requestAnimationFrame === 'undefined') {
+			refresh();
+			return;
+		}
+		if (frameRef.current != null) cancelAnimationFrame(frameRef.current);
+		frameRef.current = requestAnimationFrame(() => {
+			frameRef.current = null;
+			refresh();
+		});
+	}, [refresh]);
+
+	const detach = useCallback(() => {
+		cleanupRef.current?.();
+		cleanupRef.current = null;
+	}, []);
+
+	const ref = useCallback((element: HTMLElement | SVGElement | null) => {
+		detach();
+		elementRef.current = element;
+		if (!element || typeof window === 'undefined') return;
+
+		const ResizeObserverImpl = options.polyfill ?? window.ResizeObserver;
+		const observer = ResizeObserverImpl ? new ResizeObserverImpl(scheduleRefresh) : null;
+		observer?.observe(element);
+		window.addEventListener('resize', scheduleRefresh);
+		if (options.scroll) window.addEventListener('scroll', scheduleRefresh, true);
+		scheduleRefresh();
+
+		cleanupRef.current = () => {
+			observer?.disconnect();
+			window.removeEventListener('resize', scheduleRefresh);
+			if (options.scroll) window.removeEventListener('scroll', scheduleRefresh, true);
+			if (frameRef.current != null) {
+				cancelAnimationFrame(frameRef.current);
+				frameRef.current = null;
+			}
+			if (elementRef.current === element) elementRef.current = null;
+		};
+	}, [detach, options.polyfill, options.scroll, scheduleRefresh]);
+
+	useEffect(() => () => detach(), [detach]);
+
+	return [ref, bounds, refresh] as const;
+}

package/src/internal/useMeasure.tsrx.d.ts

@@ -0,0 +1,22 @@
+// Generated by scripts/generate-tsrx-types.mjs.
+export type RectReadOnly = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type ResizeObserverConstructor = new (callback: ResizeObserverCallback) => Pick<ResizeObserver, 'observe' | 'unobserve' | 'disconnect'>;
+export type Options = {
+    debounce?: number | {
+        scroll?: number;
+        resize?: number;
+    };
+    scroll?: boolean;
+    polyfill?: ResizeObserverConstructor;
+    offsetSize?: boolean;
+};
+export default function useMeasure(options?: Options): readonly [(element: HTMLElement | SVGElement | null) => void, RectReadOnly, () => void];

package/src/kernel/accessors/normalizeAccessor.ts

@@ -0,0 +1,59 @@
+export type Accessor<D, V> = (datum: D, index: number, data: readonly D[]) => V;
+export type AccessorKey<D> = Extract<keyof D, string>;
+export type AccessorInput<D, V> = AccessorKey<D> | Accessor<D, V>;
+
+const stringAccessorCache = new Map<string, Accessor<unknown, unknown>>();
+const identifierPattern = '[A-Za-z_$][\\w$]*';
+const propertyPattern = '[A-Za-z_$][\\w$]*';
+const simpleArrowPattern = new RegExp(
+	`^\\(?\\s*(${identifierPattern})\\s*\\)?\\s*=>\\s*\\1\\.(${propertyPattern})$`,
+);
+const blockArrowPattern = new RegExp(
+	`^\\(?\\s*(${identifierPattern})\\s*\\)?\\s*=>\\s*\\{\\s*return\\s+\\1\\.(${propertyPattern})\\s*;?\\s*\\}$`,
+);
+const functionPattern = new RegExp(
+	`^function(?:\\s+${identifierPattern})?\\s*\\(\\s*(${identifierPattern})[^)]*\\)\\s*\\{\\s*return\\s+\\1\\.(${propertyPattern})\\s*;?\\s*\\}$`,
+);
+
+function getStringAccessor(key: string) {
+	let accessor = stringAccessorCache.get(key);
+
+	if (!accessor) {
+		accessor = (datum: unknown) => (datum as Record<string, unknown>)[key];
+		stringAccessorCache.set(key, accessor);
+	}
+
+	return accessor;
+}
+
+function inferSimplePropertyKey(accessor: Accessor<unknown, unknown>) {
+	const source = Function.prototype.toString.call(accessor).replace(/\s+/g, ' ').trim();
+	const match =
+		source.match(simpleArrowPattern) ??
+		source.match(blockArrowPattern) ??
+		source.match(functionPattern);
+
+	return match?.[2];
+}
+
+export default function normalizeAccessor<D, V>(accessor: AccessorInput<D, V>): Accessor<D, V> {
+	const input = accessor as unknown;
+
+	if (typeof input === 'string') {
+		return getStringAccessor(input) as Accessor<D, V>;
+	}
+
+	if (typeof input === 'symbol') {
+		throw new TypeError('@octanejs/visx/kernel: symbol accessors are not supported in v1.');
+	}
+
+	if (typeof input !== 'function') {
+		throw new TypeError('@octanejs/visx/kernel: accessors must be a string key or function.');
+	}
+
+	const inferredKey = inferSimplePropertyKey(input as Accessor<unknown, unknown>);
+
+	return inferredKey
+		? (getStringAccessor(inferredKey) as Accessor<D, V>)
+		: (input as Accessor<D, V>);
+}

package/src/kernel/domain/useDomain.tsrx

@@ -0,0 +1,111 @@
+import { useMemo } from 'octane';
+import normalizeAccessor from '../accessors/normalizeAccessor';
+import type { AccessorInput } from '../accessors/normalizeAccessor';
+import useStructuralMemo from '../memo/useStructuralMemo.tsrx';
+import { devWarn } from '../warnings';
+
+const SOURCE = '[@octanejs/visx/kernel/useDomain]';
+
+export type DomainType = 'linear' | 'time' | 'band';
+export type LinearDomain = readonly [number, number];
+export type TimeDomain = readonly [Date, Date];
+export type BandDomain = readonly string[];
+export type DomainForType<T extends DomainType> =
+	T extends 'band' ? BandDomain : T extends 'time' ? TimeDomain : LinearDomain;
+
+export type UseDomainOptions<D, V, T extends DomainType> = {
+	accessor: AccessorInput<D, V>;
+	data: readonly D[];
+	type: T;
+};
+
+function warnEmptyData(totalValues: number) {
+	devWarn('EMPTY_DATA', 'No valid values available to form a domain.', SOURCE, { totalValues });
+}
+
+function warnNaNInData(invalidValues: number, totalValues: number) {
+	devWarn('NAN_IN_DATA', 'Encountered invalid values while computing a domain.', SOURCE, {
+		invalidValues,
+		totalValues,
+	});
+}
+
+function getNumber(value: unknown) {
+	if (value == null) {
+		return undefined;
+	}
+
+	const number =
+		value instanceof Date ? value.getTime() : Number(value);
+	return Number.isFinite(number) ? number : undefined;
+}
+
+function getTime(value: unknown) {
+	if (value == null) {
+		return undefined;
+	}
+
+	const time =
+		value instanceof Date ? value.getTime() : new Date(value as string | number).getTime();
+	return Number.isFinite(time) ? time : undefined;
+}
+
+function extent(values: readonly number[]): LinearDomain {
+	let min = values[0];
+	let max = values[0];
+
+	values.forEach((value) => {
+		if (value < min) min = value;
+		if (value > max) max = value;
+	});
+
+	return [min, max];
+}
+
+export default function useDomain<D, V, T extends DomainType>({
+	accessor,
+	data,
+	type,
+}: UseDomainOptions<D, V, T>): DomainForType<T> {
+	const stableData = useStructuralMemo(data, 1);
+	const stableAccessor = useStructuralMemo(normalizeAccessor(accessor), 0);
+	const domain = useMemo(() => {
+		if (type === 'band') {
+			const values = Array.from(
+				new Set(stableData.map((datum, index) => stableAccessor(datum, index, stableData)).filter(
+					(value) => value != null,
+				).map(String)),
+			);
+
+			if (values.length === 0) warnEmptyData(stableData.length);
+
+			return values;
+		}
+
+		let invalidValues = 0;
+		const values = stableData.flatMap((datum, index) => {
+			const value = stableAccessor(datum, index, stableData);
+			const number =
+				type === 'time' ? getTime(value) : getNumber(value);
+
+			if (number === undefined) {
+				if (value != null) invalidValues += 1;
+				return [];
+			}
+
+			return [number];
+		});
+
+		if (invalidValues > 0) warnNaNInData(invalidValues, stableData.length);
+
+		if (values.length === 0) {
+			warnEmptyData(stableData.length);
+			return type === 'time' ? [new Date(0), new Date(0)] : [0, 0];
+		}
+
+		const [min, max] = extent(values);
+		return type === 'time' ? [new Date(min), new Date(max)] : [min, max];
+	}, [stableAccessor, stableData, type]);
+
+	return useStructuralMemo(domain, 1) as unknown as DomainForType<T>;
+}

package/src/kernel/domain/useDomain.tsrx.d.ts

@@ -0,0 +1,13 @@
+// Generated by scripts/generate-tsrx-types.mjs.
+import type { AccessorInput } from '../accessors/normalizeAccessor';
+export type DomainType = 'linear' | 'time' | 'band';
+export type LinearDomain = readonly [number, number];
+export type TimeDomain = readonly [Date, Date];
+export type BandDomain = readonly string[];
+export type DomainForType<T extends DomainType> = T extends 'band' ? BandDomain : T extends 'time' ? TimeDomain : LinearDomain;
+export type UseDomainOptions<D, V, T extends DomainType> = {
+    accessor: AccessorInput<D, V>;
+    data: readonly D[];
+    type: T;
+};
+export default function useDomain<D, V, T extends DomainType>({ accessor, data, type, }: UseDomainOptions<D, V, T>): DomainForType<T>;

package/src/kernel/format/formatNumber.ts

@@ -0,0 +1,8 @@
+export type FormatNumberOptions = Intl.NumberFormatOptions & {
+	locale?: Intl.LocalesArgument;
+};
+
+export default function formatNumber(value: number, options: FormatNumberOptions = {}) {
+	const { locale, ...numberOptions } = options;
+	return new Intl.NumberFormat(locale, numberOptions).format(value);
+}

package/src/kernel/ids/useStableId.tsrx

@@ -0,0 +1,7 @@
+import { useId } from 'octane';
+
+export default function useStableId(prefix = 'visx') {
+	const reactId = useId().replace(/:/g, '');
+
+	return prefix ? `${prefix}-${reactId}` : reactId;
+}

package/src/kernel/ids/useStableId.tsrx.d.ts

@@ -0,0 +1,2 @@
+// Generated by scripts/generate-tsrx-types.mjs.
+export default function useStableId(prefix?: string): string;

package/src/kernel/index.ts

@@ -0,0 +1,25 @@
+// @octanejs/visx/kernel
+export { default as normalizeAccessor } from './accessors/normalizeAccessor';
+export { default as useDomain } from './domain/useDomain.tsrx';
+export { default as formatNumber } from './format/formatNumber';
+export { default as useStableId } from './ids/useStableId.tsrx';
+export { default as useStructuralMemo } from './memo/useStructuralMemo.tsrx';
+export { default as createPath } from './path/createPath';
+export { default as toPath2D } from './path/toPath2D';
+export { default as useLatestRef } from './refs/useLatestRef.tsrx';
+export { default as useStableCallback } from './refs/useStableCallback.tsrx';
+export { setWarnHandler } from './warnings';
+
+export type { Accessor, AccessorInput, AccessorKey } from './accessors/normalizeAccessor';
+export type {
+	BandDomain,
+	DomainForType,
+	DomainType,
+	LinearDomain,
+	TimeDomain,
+	UseDomainOptions,
+} from './domain/useDomain.tsrx';
+export type { FormatNumberOptions } from './format/formatNumber';
+export type { StructuralMemoDepth } from './memo/useStructuralMemo.tsrx';
+export type { PathBuilder } from './path/createPath';
+export type { KernelWarning, WarnCode, WarnDetails, WarnHandler } from './warnings';

package/src/kernel/memo/shallowEqual.ts

@@ -0,0 +1,65 @@
+type ShallowValue = Record<PropertyKey, unknown> | readonly unknown[];
+
+function isObjectLike(value: unknown): value is ShallowValue {
+	return typeof value === 'object' && value !== null;
+}
+
+function shallowValueEqual(previous: unknown, next: unknown) {
+	if (previous instanceof Date || next instanceof Date) {
+		return (
+			previous instanceof Date &&
+			next instanceof Date &&
+			Object.is(previous.getTime(), next.getTime())
+		);
+	}
+
+	return Object.is(previous, next);
+}
+
+function shallowEqualArrays(previous: readonly unknown[], next: readonly unknown[]) {
+	if (previous.length !== next.length) {
+		return false;
+	}
+
+	return previous.every((value, index) => shallowValueEqual(value, next[index]));
+}
+
+export default function shallowEqual(previous: unknown, next: unknown) {
+	if (Object.is(previous, next)) {
+		return true;
+	}
+
+	if (!isObjectLike(previous) || !isObjectLike(next)) {
+		return false;
+	}
+
+	if (previous instanceof Date || next instanceof Date) {
+		return (
+			previous instanceof Date &&
+			next instanceof Date &&
+			Object.is(previous.getTime(), next.getTime())
+		);
+	}
+
+	if (Array.isArray(previous) || Array.isArray(next)) {
+		return Array.isArray(previous) && Array.isArray(next)
+			? shallowEqualArrays(previous, next)
+			: false;
+	}
+
+	const previousKeys = Object.keys(previous);
+	const nextKeys = Object.keys(next);
+
+	if (previousKeys.length !== nextKeys.length) {
+		return false;
+	}
+
+	const previousRecord = previous as Record<string, unknown>;
+	const nextRecord = next as Record<string, unknown>;
+
+	return previousKeys.every(
+		(key) =>
+			Object.prototype.hasOwnProperty.call(nextRecord, key) &&
+			shallowValueEqual(previousRecord[key], nextRecord[key]),
+	);
+}

package/src/kernel/memo/useStructuralMemo.tsrx

@@ -0,0 +1,18 @@
+import { useRef } from 'octane';
+import shallowEqual from './shallowEqual';
+
+export type StructuralMemoDepth = 0 | 1;
+
+function isEqual(previous: unknown, next: unknown, depth: StructuralMemoDepth) {
+	return depth === 0 ? Object.is(previous, next) : shallowEqual(previous, next);
+}
+
+export default function useStructuralMemo<T>(value: T, depth: StructuralMemoDepth = 1): T {
+	const valueRef = useRef(value);
+
+	if (!isEqual(valueRef.current, value, depth)) {
+		valueRef.current = value;
+	}
+
+	return valueRef.current;
+}

package/src/kernel/memo/useStructuralMemo.tsrx.d.ts

@@ -0,0 +1,3 @@
+// Generated by scripts/generate-tsrx-types.mjs.
+export type StructuralMemoDepth = 0 | 1;
+export default function useStructuralMemo<T>(value: T, depth?: StructuralMemoDepth): T;