@ringozz/react-godot 4.7.2-614 → 4.7.2-616

package/src/react-hooks.ts

@@ -1,164 +1,164 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-import type { Signal } from '@ringozz/godot';
-import type { Node } from '@ringozz/godot/Node';
-import type { Object as Instance } from '@ringozz/godot/Object';
-import { PropertyTweener } from '@ringozz/godot/PropertyTweener';
-import { Tween, type EaseType, type TransitionType } from '@ringozz/godot/Tween';
-import type React from 'react';
-import { useEffect, useMemo, useRef } from 'react';
-import { toValueType } from '@ringozz/godot/runtime';
-
-// Tween/PropertyTweener are only type-used here; value-reference them so their
-// `_R` class registration isn't tree-shaken (otherwise createTween's wrapper
-// falls back to an ancestor class and loses pause/play/tweenProperty).
-void Tween;
-void PropertyTweener;
-
-export function useMutableCallback<T>(fn: T): React.RefObject<T> {
-  const ref = useRef<T>(fn);
-  useEffect(() => void (ref.current = fn), [fn]);
-  return ref;
-}
-
-export function useSignal<T extends (...args: any[]) => any>(signal: Signal<T>, handler: T): void {
-  const ref = useMutableCallback(handler);
-  useEffect(() => {
-    const fn = ((...args: any[]) => ref.current(...args)) as T;
-    signal.connect(fn);
-    return () => signal.disconnect(fn);
-  // do not specify 'signal' dependency, because it changes often.
-  // specify invariant contents instead.
-  /* oxlint-disable-next-line react-hooks/exhaustive-deps */
-  }, [signal.getObjectId(), signal.getName()]);
-}
-
-// ---- useTween: tween-as-prop-value ----
-//
-// useTween(create, deps) returns [spring, tweenRef]. `spring` holds one
-// value-assigner per `to` key — a plain function spread onto the node
-// (`<Node3D {...spring} />`). Instance.assign (C++) treats any function on a
-// non-signal prop as a value-assigner and invokes it with (node, nativeName);
-// each contributes its own prop's tweener to one shared native Tween created on
-// the first invocation. `tweenRef.current` is that Tween (null until mounted).
-// Re-rendering with the same deps keeps the same assigners (the reconciler's
-// identity diff drops them, so nothing restarts); changing deps creates a new
-// tween (the previous one is killed).
-
-// Tweenable goal values: scalars and value-type tuples. `GodotVar` (the base of
-// *every* Godot object) is deliberately NOT a member — `useTween` always wraps
-// goals through `toValueType`, so callers pass plain numbers/tuples, and
-// including `GodotVar` would wrongly admit signals/`Node` refs/object props.
-//
-// When the caller passes a node instance type (e.g. `useTween<Node3D>`), `to`
-// /`from` are contextually typed against that node's settable props, so each
-// array goal infers as the property's value-type tuple (Vector3, Basis, …). A
-// bare `useTween(...)` call keeps the loose behavior below (`number[]` goals).
-type TweenValue = number | number[] | number[][];
-
-// Settable props whose value is a tweenable goal (`number`/value-type tuple).
-// Signals, `Node` refs and other Godot objects are not `TweenValue`s, so they
-// never leak into `spring` (`{...spring}` stays JSX-spreadable). Mapping over
-// `keyof T` lets `to` be contextually typed with the node's value-type tuples.
-type TweenableProps<T> = {
-  [K in keyof T as T[K] extends TweenValue ? K : never]: T[K];
-};
-
-export interface TweenConfig {
-  /** Seconds (default 1). */
-  duration?: number;
-  /** Tween.setTrans — the default for the tween's tweeners. */
-  transition?: TransitionType;
-  /** Tween.setEase — the default for the tween's tweeners. */
-  ease?: EaseType;
-  /** PropertyTweener.setCustomInterpolator — a [0,1]→[0,1] easing function. */
-  easing?: (t: number) => number;
-  /** Tween.setSpeedScale. */
-  speedScale?: number;
-}
-
-export interface TweenProps<P extends Record<string, unknown> = Record<string, TweenValue>> {
-  /** Start values, applied on the first build (mount) before animating to `to`. */
-  from?: Partial<P>;
-  /** Target values — one assigner is returned per key. */
-  to: P;
-  config?: TweenConfig;
-  /** Seconds; per-tweener PropertyTweener.setDelay. */
-  delay?: number;
-  /** Tween.setLoops (0 = infinite). */
-  loops?: number;
-  /** Snap to `to` instead of animating. */
-  immediate?: boolean;
-  onStart?: () => void;
-  /** Fires on natural completion only (Godot's `finished`); kills/unmount don't fire it. */
-  onFinished?: () => void;
-}
-
-export type Spring<P extends Record<string, unknown>> = { [K in keyof P]: P[K] };
-
-// tweenProperty/set reject generic JS arrays, so array goals are reconstructed
-// as the property's value type by `toValueType` (resolves the node's
-// property type and returns a GodotVar carrier the `_C` tween path unwraps;
-// non-array goals pass through unchanged).
-
-function makeSpring<P extends Record<string, unknown>>(
-  tweenRef: { current: Tween | null },
-  props: TweenProps<P>,
-): Spring<P> {
-  const config = props.config ?? {};
-  const spring = {} as Spring<P>;
-  let started = false;
-  let applyFrom = false;
-
-  for (const [key, value] of Object.entries(props.to)) {
-    const fromValue = props.from?.[key];
-    const assigner = (node: Instance, native: string) => {
-      if (props.immediate) {
-        tweenRef.current?.kill();
-        tweenRef.current = null;
-        node.set(native, toValueType(node, native, value));
-        return;
-      }
-      if (!started) {
-        started = true;
-        applyFrom = tweenRef.current === null; // first build (mount) ⇒ apply `from`
-        tweenRef.current?.kill();
-        const t = (node as unknown as Node).createTween();
-        tweenRef.current = t;
-        if (config.transition !== undefined) t.setTrans(config.transition);
-        if (config.ease !== undefined) t.setEase(config.ease);
-        if (config.speedScale !== undefined) t.setSpeedScale(config.speedScale);
-        if (props.loops !== undefined) t.setLoops(props.loops);
-        if (props.onFinished) t.finished.connect(props.onFinished);
-        t.bindNode(node as unknown as Node);
-        t.setParallel(true);
-        props.onStart?.();
-      }
-      const tw = tweenRef.current!.tweenProperty(node, native, toValueType(node, native, value), config.duration ?? 1);
-      if (applyFrom && fromValue !== undefined) tw.from(toValueType(node, native, fromValue));
-      if (props.delay !== undefined) tw.setDelay(props.delay);
-      if (config.easing) tw.setCustomInterpolator(config.easing);
-    };
-    spring[key as keyof P] = assigner as unknown as P[keyof P];
-  }
-  return spring;
-}
-
-export function useTween<
-  T extends Instance = any,
-  P extends Partial<TweenableProps<T>> = Partial<TweenableProps<T>>,
->(
-  create: () => TweenProps<P>,
-  deps: unknown[] = [],
-): [Spring<P>, React.RefObject<Tween | null>] {
-  const tweenRef = useRef<Tween | null>(null);
-  // 'create' is intentionally re-evaluated via `deps`, not listed here.
-  /* oxlint-disable-next-line react-hooks/exhaustive-deps */
-  const spring = useMemo(() => makeSpring(tweenRef, create()), deps);
-  // No unmount kill: the tween is `createTween()`-bound to the node, so Godot
-  // kills it when the node exits the tree. A `useEffect` cleanup would also run
-  // on StrictMode's synthetic mount teardown and kill the just-created tween.
-  return [spring, tweenRef];
-}
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+import type { Signal } from '@ringozz/godot';
+import type { Node } from '@ringozz/godot/Node';
+import type { Object as Instance } from '@ringozz/godot/Object';
+import { PropertyTweener } from '@ringozz/godot/PropertyTweener';
+import { Tween, type EaseType, type TransitionType } from '@ringozz/godot/Tween';
+import type React from 'react';
+import { useEffect, useMemo, useRef } from 'react';
+import { toValueType } from '@ringozz/godot/runtime';
+
+// Tween/PropertyTweener are only type-used here; value-reference them so their
+// `_R` class registration isn't tree-shaken (otherwise createTween's wrapper
+// falls back to an ancestor class and loses pause/play/tweenProperty).
+void Tween;
+void PropertyTweener;
+
+export function useMutableCallback<T>(fn: T): React.RefObject<T> {
+  const ref = useRef<T>(fn);
+  useEffect(() => void (ref.current = fn), [fn]);
+  return ref;
+}
+
+export function useSignal<T extends (...args: any[]) => any>(signal: Signal<T>, handler: T): void {
+  const ref = useMutableCallback(handler);
+  useEffect(() => {
+    const fn = ((...args: any[]) => ref.current(...args)) as T;
+    signal.connect(fn);
+    return () => signal.disconnect(fn);
+  // do not specify 'signal' dependency, because it changes often.
+  // specify invariant contents instead.
+  /* oxlint-disable-next-line react-hooks/exhaustive-deps */
+  }, [signal.getObjectId(), signal.getName()]);
+}
+
+// ---- useTween: tween-as-prop-value ----
+//
+// useTween(create, deps) returns [spring, tweenRef]. `spring` holds one
+// value-assigner per `to` key — a plain function spread onto the node
+// (`<Node3D {...spring} />`). Instance.assign (C++) treats any function on a
+// non-signal prop as a value-assigner and invokes it with (node, nativeName);
+// each contributes its own prop's tweener to one shared native Tween created on
+// the first invocation. `tweenRef.current` is that Tween (null until mounted).
+// Re-rendering with the same deps keeps the same assigners (the reconciler's
+// identity diff drops them, so nothing restarts); changing deps creates a new
+// tween (the previous one is killed).
+
+// Tweenable goal values: scalars and value-type tuples. `GodotVar` (the base of
+// *every* Godot object) is deliberately NOT a member — `useTween` always wraps
+// goals through `toValueType`, so callers pass plain numbers/tuples, and
+// including `GodotVar` would wrongly admit signals/`Node` refs/object props.
+//
+// When the caller passes a node instance type (e.g. `useTween<Node3D>`), `to`
+// /`from` are contextually typed against that node's settable props, so each
+// array goal infers as the property's value-type tuple (Vector3, Basis, …). A
+// bare `useTween(...)` call keeps the loose behavior below (`number[]` goals).
+type TweenValue = number | number[] | number[][];
+
+// Settable props whose value is a tweenable goal (`number`/value-type tuple).
+// Signals, `Node` refs and other Godot objects are not `TweenValue`s, so they
+// never leak into `spring` (`{...spring}` stays JSX-spreadable). Mapping over
+// `keyof T` lets `to` be contextually typed with the node's value-type tuples.
+type TweenableProps<T> = {
+  [K in keyof T as T[K] extends TweenValue ? K : never]: T[K];
+};
+
+export interface TweenConfig {
+  /** Seconds (default 1). */
+  duration?: number;
+  /** Tween.setTrans — the default for the tween's tweeners. */
+  transition?: TransitionType;
+  /** Tween.setEase — the default for the tween's tweeners. */
+  ease?: EaseType;
+  /** PropertyTweener.setCustomInterpolator — a [0,1]→[0,1] easing function. */
+  easing?: (t: number) => number;
+  /** Tween.setSpeedScale. */
+  speedScale?: number;
+}
+
+export interface TweenProps<P extends Record<string, unknown> = Record<string, TweenValue>> {
+  /** Start values, applied on the first build (mount) before animating to `to`. */
+  from?: Partial<P>;
+  /** Target values — one assigner is returned per key. */
+  to: P;
+  config?: TweenConfig;
+  /** Seconds; per-tweener PropertyTweener.setDelay. */
+  delay?: number;
+  /** Tween.setLoops (0 = infinite). */
+  loops?: number;
+  /** Snap to `to` instead of animating. */
+  immediate?: boolean;
+  onStart?: () => void;
+  /** Fires on natural completion only (Godot's `finished`); kills/unmount don't fire it. */
+  onFinished?: () => void;
+}
+
+export type Spring<P extends Record<string, unknown>> = { [K in keyof P]: P[K] };
+
+// tweenProperty/set reject generic JS arrays, so array goals are reconstructed
+// as the property's value type by `toValueType` (resolves the node's
+// property type and returns a GodotVar carrier the `_C` tween path unwraps;
+// non-array goals pass through unchanged).
+
+function makeSpring<P extends Record<string, unknown>>(
+  tweenRef: { current: Tween | null },
+  props: TweenProps<P>,
+): Spring<P> {
+  const config = props.config ?? {};
+  const spring = {} as Spring<P>;
+  let started = false;
+  let applyFrom = false;
+
+  for (const [key, value] of Object.entries(props.to)) {
+    const fromValue = props.from?.[key];
+    const assigner = (node: Instance, native: string) => {
+      if (props.immediate) {
+        tweenRef.current?.kill();
+        tweenRef.current = null;
+        node.set(native, toValueType(node, native, value));
+        return;
+      }
+      if (!started) {
+        started = true;
+        applyFrom = tweenRef.current === null; // first build (mount) ⇒ apply `from`
+        tweenRef.current?.kill();
+        const t = (node as unknown as Node).createTween();
+        tweenRef.current = t;
+        if (config.transition !== undefined) t.setTrans(config.transition);
+        if (config.ease !== undefined) t.setEase(config.ease);
+        if (config.speedScale !== undefined) t.setSpeedScale(config.speedScale);
+        if (props.loops !== undefined) t.setLoops(props.loops);
+        if (props.onFinished) t.finished.connect(props.onFinished);
+        t.bindNode(node as unknown as Node);
+        t.setParallel(true);
+        props.onStart?.();
+      }
+      const tw = tweenRef.current!.tweenProperty(node, native, toValueType(node, native, value), config.duration ?? 1);
+      if (applyFrom && fromValue !== undefined) tw.from(toValueType(node, native, fromValue));
+      if (props.delay !== undefined) tw.setDelay(props.delay);
+      if (config.easing) tw.setCustomInterpolator(config.easing);
+    };
+    spring[key as keyof P] = assigner as unknown as P[keyof P];
+  }
+  return spring;
+}
+
+export function useTween<
+  T extends Instance = any,
+  P extends Partial<TweenableProps<T>> = Partial<TweenableProps<T>>,
+>(
+  create: () => TweenProps<P>,
+  deps: unknown[] = [],
+): [Spring<P>, React.RefObject<Tween | null>] {
+  const tweenRef = useRef<Tween | null>(null);
+  // 'create' is intentionally re-evaluated via `deps`, not listed here.
+  /* oxlint-disable-next-line react-hooks/exhaustive-deps */
+  const spring = useMemo(() => makeSpring(tweenRef, create()), deps);
+  // No unmount kill: the tween is `createTween()`-bound to the node, so Godot
+  // kills it when the node exits the tree. A `useEffect` cleanup would also run
+  // on StrictMode's synthetic mount teardown and kill the just-created tween.
+  return [spring, tweenRef];
+}

package/src/react-jsx.ts

@@ -1,45 +1,45 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-import { jsxDEV as reactJsxDEV } from 'react/jsx-dev-runtime';
-import type * as ReactJSX from 'react/jsx-runtime';
-import { Fragment, jsx as reactJsx, jsxs as reactJsxs } from 'react/jsx-runtime';
-import type { ComponentProps, GodotConstructor } from './react-types.ts';
-import { GodotVar } from '@ringozz/godot/runtime';
-
-export function jsx(type: any, props?: any, key?: any) {
-  return reactJsx(GodotVar.isPrototypeOf(type) ? type.name : type, props, key);
-}
-
-export function jsxs(type: any, props?: any, key?: any) {
-  return reactJsxs(GodotVar.isPrototypeOf(type) ? type.name : type, props, key);
-}
-
-export function jsxDEV(type: any, props?: any, key?: any, isStatic?: any, source?: any, self?: any) {
-  return reactJsxDEV(GodotVar.isPrototypeOf(type) ? type.name : type, props, key, isStatic, source, self);
-}
-
-export { Fragment };
-
-// JSX namespace augmentation: these types are the public JSX contract for the
-// `@ringozz/react-godot/jsx-runtime` import source, consumed by TypeScript in
-// consumer files. They are intentionally not referenced within this module.
-/* oxlint-disable no-unused-vars */
-declare module '@ringozz/react-godot/jsx-runtime' {
-  export namespace JSX {
-    interface IntrinsicAttributes extends ReactJSX.JSX.IntrinsicAttributes { }
-    interface IntrinsicElements extends ReactJSX.JSX.IntrinsicElements { }
-    interface Element extends ReactJSX.JSX.Element { }
-
-    type ElementType =
-      | ReactJSX.JSX.ElementType
-      | GodotConstructor;
-
-    type LibraryManagedAttributes<C, P> =
-      C extends GodotConstructor
-      ? ComponentProps<C>
-      : ReactJSX.JSX.LibraryManagedAttributes<C, P>;
-  }
-}
-/* oxlint-enable no-unused-vars */
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+import { jsxDEV as reactJsxDEV } from 'react/jsx-dev-runtime';
+import type * as ReactJSX from 'react/jsx-runtime';
+import { Fragment, jsx as reactJsx, jsxs as reactJsxs } from 'react/jsx-runtime';
+import type { ComponentProps, GodotConstructor } from './react-types.ts';
+import { GodotVar } from '@ringozz/godot/runtime';
+
+export function jsx(type: any, props?: any, key?: any) {
+  return reactJsx(GodotVar.isPrototypeOf(type) ? type.name : type, props, key);
+}
+
+export function jsxs(type: any, props?: any, key?: any) {
+  return reactJsxs(GodotVar.isPrototypeOf(type) ? type.name : type, props, key);
+}
+
+export function jsxDEV(type: any, props?: any, key?: any, isStatic?: any, source?: any, self?: any) {
+  return reactJsxDEV(GodotVar.isPrototypeOf(type) ? type.name : type, props, key, isStatic, source, self);
+}
+
+export { Fragment };
+
+// JSX namespace augmentation: these types are the public JSX contract for the
+// `@ringozz/react-godot/jsx-runtime` import source, consumed by TypeScript in
+// consumer files. They are intentionally not referenced within this module.
+/* oxlint-disable no-unused-vars */
+declare module '@ringozz/react-godot/jsx-runtime' {
+  export namespace JSX {
+    interface IntrinsicAttributes extends ReactJSX.JSX.IntrinsicAttributes { }
+    interface IntrinsicElements extends ReactJSX.JSX.IntrinsicElements { }
+    interface Element extends ReactJSX.JSX.Element { }
+
+    type ElementType =
+      | ReactJSX.JSX.ElementType
+      | GodotConstructor;
+
+    type LibraryManagedAttributes<C, P> =
+      C extends GodotConstructor
+      ? ComponentProps<C>
+      : ReactJSX.JSX.LibraryManagedAttributes<C, P>;
+  }
+}
+/* oxlint-enable no-unused-vars */