@ringozz/react-godot 4.7.2-592 → 4.7.2-594

package/README.md

@@ -304,7 +304,7 @@ return <Node3D {...spring} />;
 ```
 
 - **`spring`** holds one function per `to` key (spread them all onto the node; each contributes its own prop's tweener to the shared `Tween`). Array values are converted to the property's value type.
-- **Node-typed goals**: call `useTween<Node3D>(...)` so `to`/`from` are typed against that node's props — `position: [0, 2, 0]` and nested `basis: [[…]]` infer as `Vector3`/`Basis`, with no `as Vector3` casts. A bare `useTween(...)` keeps array goals loose (`number[]`).
+- **Node-typed goals**: call `useTween<Node3D>(...)` so `to`/`from` are typed against that node's props — `position: [0, 2, 0]` and nested `basis: [[…]]` infer as `Vector3`/`Basis`, with no `as Vector3` casts. Only scalar-number and value-type props are tweenable (signals, `Node` refs, bools, strings, containers are rejected); the returned `spring` is that whole prop set (all optional), so `{...spring}` stays JSX-spreadable. A bare `useTween(...)` keeps array goals loose (`number[]`).
 - **`tweenRef.current`** is the **live native Godot `Tween`**, created when the node mounts (null before that): `tweenRef.current?.kill()`, `?.pause()`, `?.play()`, `?.setSpeedScale(n)`, `?.isRunning()`, `?.finished`…
 - **`config`** maps to the Godot Tween API: `duration` (seconds), `transition`/`ease` (`TransitionType`/`EaseType` — the tween's defaults), `easing` (a `[0,1]→[0,1]` function → `setCustomInterpolator`), `speedScale`.
 - **`onStart`** fires when the tween is created/bound (on mount or when `deps` change), before it starts stepping.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ringozz/react-godot",
   "author": "Vladimir Davidovich",
-  "version": "4.7.2-592",
+  "version": "4.7.2-594",
   "description": "A React renderer for Godot Engine via @ringozz/godot",
   "publishConfig": {
     "access": "public"
@@ -23,7 +23,7 @@
     "*.md"
   ],
   "dependencies": {
-    "@ringozz/godot": "^4.7.2-592",
+    "@ringozz/godot": "^4.7.2-594",
     "@types/react-reconciler": "^0.33.0",
     "react-reconciler": "^0.33.0"
   },

package/src/react-hooks.ts

@@ -6,10 +6,10 @@ 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, type GodotVar } from '@ringozz/godot/runtime';
+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
@@ -47,18 +47,21 @@ export function useSignal<T extends (...args: any[]) => any>(signal: Signal<T>,
 // identity diff drops them, so nothing restarts); changing deps creates a new
 // tween (the previous one is killed).
 
-// Value-type goals are named tuples on the JS side — flat ones are `number[]`,
-// nested ones (Transform2D/Basis/Transform3D/Projection/AABB) are `number[][]`.
+// 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).
-export type TweenValue = number | number[] | number[][] | GodotVar;
+type TweenValue = number | number[] | number[][];
 
-// Settable props whose value is tween-compatible (numeric, value-type tuples,
-// GodotVar); excludes bool/string/signal/container/method props. Mapping over
-// `keyof N` lets `to` be contextually typed with the node's value-type tuples.
+// 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];
 };