@ringozz/godot 4.7.1-8 → 4.7.1-9

package/src/debug.ts

@@ -1,236 +1,236 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-import { Rect2, str, varToStr, Vector3 } from './index.ts';
-import { CanvasItem } from '../gen/classes/CanvasItem.ts';
-import { ClassDB } from '../gen/classes/ClassDB.ts';
-import { Control } from '../gen/classes/Control.ts';
-import { DisplayServer } from '../gen/classes/DisplayServer.ts';
-import { Engine } from '../gen/classes/Engine.ts';
-import { Node } from '../gen/classes/Node.ts';
-import { Node3D } from '../gen/classes/Node3D.ts';
-import { OS } from '../gen/classes/OS.ts';
-import { Time } from '../gen/classes/Time.ts';
-
-/**
- * Dump a Godot value or object as a string.
- * Value types (vectors, arrays, dictionaries, …) render via Godot's `str()`.
- * Objects dump via Godot's `var_to_str` — its own property walk + recursion —
- * with the node's `name` prepended when present.
- *
- * @param obj - Any Godot wrapper (Node, Resource, …), value type, or plain value
- */
-export function dumpStr(obj: unknown): string {
-    if (obj == null || typeof obj !== 'object') return String(obj);
-
-    // Value types & heap containers (Vector3, Array, Dictionary, …) have no getClass() —
-    // let Godot's str() render them.
-    if (!(obj as any).getClass) return str(obj as any);
-
-    const dump = varToStr(obj as any);
-    let name: unknown;
-    try { name = (obj as any).name; } catch { name = undefined; }
-    return name === undefined || name === null || name === '' ? dump : `${name}: ${dump}`;
-}
-
-/**
- * Serialize a scene subtree as a tree-formatted string.
- *
- * @param node - Root node to start from
- * @param depth - Max depth (default 99)
- */
-export function dumpTreeStr(node: Node, depth = 99): string {
-    const lines: string[] = [];
-    (function walk(n: Node, d: number, ind: string) {
-        if (d <= 0) return;
-        lines.push(`${ind}${n.getClass()} "${n.name}" (${n.getChildCount()} children)`);
-        for (let i = 0; i < n.getChildCount(); i++) {
-            const c = n.getChild(i);
-            if (c) walk(c as Node, d - 1, ind + '  ');
-        }
-    })(node, depth, '');
-    return lines.join('\n');
-}
-
-/**
- * Return a snapshot of engine runtime stats as a formatted string.
- *
- * Includes process frames, FPS, physics frames, node count, time scale,
- * and main-loop class. Never throws: `Engine.getMainLoop()` can be null or
- * throw while the engine is starting/stopping, in which case those rows show `N/A`.
- */
-export function statsStr(): string {
-    let tree: any = null;
-    try { tree = Engine.getMainLoop(); } catch { tree = null; }
-    return [
-        `Frames:     ${Engine.getProcessFrames()}`,
-        `FPS:        ${Engine.getFramesPerSecond()}`,
-        `Physics:    ${Engine.getPhysicsFrames()}`,
-        `Nodes:      ${tree?.getNodeCount?.() ?? 'N/A'}`,
-        `Time scale: ${Engine.timeScale}`,
-        `Main loop:  ${tree ? tree.getClass() : 'N/A'}`,
-    ].join('\n');
-}
-
-/**
- * Run `gc()` and report how much heap was freed.
- * Requires the `--expose-gc` Node.js flag.
- */
-export function gc(): string {
-    const before = globalThis.process?.memoryUsage?.().heapUsed;
-    if (globalThis.Bun)
-        globalThis.Bun.gc(true);
-    else if (globalThis.gc)
-        globalThis.gc({ type: 'major', execution: 'sync' });
-    else
-        return 'gc() unavailable — need --expose-gc';
-
-    const after = globalThis.process?.memoryUsage?.().heapUsed;
-    const freed = typeof before === 'number' && typeof after === 'number' ? (before - after) / 1024 : 0;
-    return `GC: freed ${freed.toFixed(0)} KB`;
-}
-
-/**
- * `DOMRect` is not a global in Bun (desktop), but `getBoundingClientRect()`
- * constructs one. Install a minimal spec-compatible polyfill on desktop so the
- * helper works identically on desktop and web (browsers already define it).
- */
-function ensureDOMRect(): void {
-    if (typeof (globalThis as any).DOMRect !== 'undefined') return;
-    (globalThis as any).DOMRect = class DOMRect {
-        x: number;
-        y: number;
-        width: number;
-        height: number;
-        constructor(x = 0, y = 0, width = 0, height = 0) {
-            this.x = x;
-            this.y = y;
-            this.width = width;
-            this.height = height;
-        }
-        get left() { return this.x; }
-        get top() { return this.y; }
-        get right() { return this.x + this.width; }
-        get bottom() { return this.y + this.height; }
-        toJSON() { return { x: this.x, y: this.y, width: this.width, height: this.height }; }
-    };
-}
-
-/**
- * Bootstrap the debugging environment.
- *
- * - Exposes common singletons (`Engine`, `OS`, `ClassDB`, `Time`) and all
- *   debug utility functions on `globalThis.$` so they're reachable from
- *   breakpoints in any module.
- * - Registers an `uncaughtException` handler that logs but keeps the process
- *   alive for interactive debugging.
- * - Polyfills `DOMRect` (needed by `getBoundingClientRect()` on desktop).
- */
-export function initDebug(): void {
-    globalThis.process?.on?.('uncaughtException', (err, origin) => {
-        console.error(`\n✗ ${origin}:`, err.stack);
-    });
-
-    ensureDOMRect();
-
-    Object.defineProperty(CanvasItem.prototype, 'getBoundingClientRect', {
-        configurable: true,
-        value(this: CanvasItem): DOMRect | null {
-            const scale = DisplayServer.screenGetScale();
-            if (this instanceof Control) {
-                const rc = (this as Control).getGlobalRect();
-                return new DOMRect(
-                    rc.position.x / scale, rc.position.y / scale,
-                    rc.size.x / scale, rc.size.y / scale,
-                );
-            }
-
-            if (typeof (this as any).getRect !== 'function') return null;
-
-            const rect = (this as any).getRect() as Rect2;
-            const t = this.getScreenTransform();
-
-            const pos = rect.position;
-            const sz = rect.size;
-            const tx = t.x;
-            const ty = t.y;
-            const to = t.origin;
-
-            const x0 = pos.x, y0 = pos.y;
-            const x1 = x0 + sz.x, y1 = y0 + sz.y;
-            const txx = tx.x, txy = tx.y;
-            const tyx = ty.x, tyy = ty.y;
-            const tox = to.x, toy = to.y;
-
-            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-            const accum = (px: number, py: number) => {
-                if (px < minX) minX = px; if (py < minY) minY = py;
-                if (px > maxX) maxX = px; if (py > maxY) maxY = py;
-            };
-
-            accum(txx * x0 + tyx * y0 + tox, txy * x0 + tyy * y0 + toy);
-            accum(txx * x1 + tyx * y0 + tox, txy * x1 + tyy * y0 + toy);
-            accum(txx * x0 + tyx * y1 + tox, txy * x0 + tyy * y1 + toy);
-            accum(txx * x1 + tyx * y1 + tox, txy * x1 + tyy * y1 + toy);
-
-            return new DOMRect(
-                minX / scale, minY / scale,
-                (maxX - minX) / scale, (maxY - minY) / scale,
-            );
-        },
-    });
-
-    Object.defineProperty(Node3D.prototype, 'getBoundingClientRect', {
-        configurable: true,
-        value(this: Node3D): DOMRect | null {
-            if (typeof (this as any).getAabb !== 'function') return null;
-
-            const aabb = (this as any).getAabb();
-            const gt = this.globalTransform;
-            const viewport = this.getViewport();
-            if (!viewport) return null;
-            const camera = viewport.getCamera3d();
-            if (!camera) return null;
-            const scale = DisplayServer.screenGetScale();
-
-            const b = gt.basis;
-            const bx = b.x, by = b.y, bz = b.z;
-            const o = gt.origin;
-            const p = aabb.position, e = aabb.end;
-
-            const [px, py, pz] = [p.x, p.y, p.z];
-            const [ex, ey, ez] = [e.x, e.y, e.z];
-            const [bxx, bxy, bxz] = [bx.x, bx.y, bx.z];
-            const [byx, byy, byz] = [by.x, by.y, by.z];
-            const [bzx, bzy, bzz] = [bz.x, bz.y, bz.z];
-            const [ox, oy, oz] = [o.x, o.y, o.z];
-
-            const corners = [
-                [px, py, pz], [ex, py, pz], [px, ey, pz], [ex, ey, pz],
-                [px, py, ez], [ex, py, ez], [px, ey, ez], [ex, ey, ez],
-            ];
-
-            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-
-            for (const [cx, cy, cz] of corners) {
-                const wx = bxx * cx + byx * cy + bzx * cz + ox;
-                const wy = bxy * cx + byy * cy + bzy * cz + oy;
-                const wz = bxz * cx + byz * cy + bzz * cz + oz;
-                const s = camera.unprojectPosition(new Vector3(wx, wy, wz));
-                if (s.x < minX) minX = s.x; if (s.y < minY) minY = s.y;
-                if (s.x > maxX) maxX = s.x; if (s.y > maxY) maxY = s.y;
-            }
-
-            return new DOMRect(
-                minX / scale, minY / scale,
-                (maxX - minX) / scale, (maxY - minY) / scale,
-            );
-        },
-    });
-
-    (globalThis as any).$ = {
-        Engine, OS, ClassDB, Time,
-        dumpStr, dumpTreeStr, statsStr, gc,
-    };
-}
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+import { Rect2, str, varToStr, Vector3 } from './index.ts';
+import { CanvasItem } from '../gen/classes/CanvasItem.ts';
+import { ClassDB } from '../gen/classes/ClassDB.ts';
+import { Control } from '../gen/classes/Control.ts';
+import { DisplayServer } from '../gen/classes/DisplayServer.ts';
+import { Engine } from '../gen/classes/Engine.ts';
+import { Node } from '../gen/classes/Node.ts';
+import { Node3D } from '../gen/classes/Node3D.ts';
+import { OS } from '../gen/classes/OS.ts';
+import { Time } from '../gen/classes/Time.ts';
+
+/**
+ * Dump a Godot value or object as a string.
+ * Value types (vectors, arrays, dictionaries, …) render via Godot's `str()`.
+ * Objects dump via Godot's `var_to_str` — its own property walk + recursion —
+ * with the node's `name` prepended when present.
+ *
+ * @param obj - Any Godot wrapper (Node, Resource, …), value type, or plain value
+ */
+export function dumpStr(obj: unknown): string {
+    if (obj == null || typeof obj !== 'object') return String(obj);
+
+    // Value types & heap containers (Vector3, Array, Dictionary, …) have no getClass() —
+    // let Godot's str() render them.
+    if (!(obj as any).getClass) return str(obj as any);
+
+    const dump = varToStr(obj as any);
+    let name: unknown;
+    try { name = (obj as any).name; } catch { name = undefined; }
+    return name === undefined || name === null || name === '' ? dump : `${name}: ${dump}`;
+}
+
+/**
+ * Serialize a scene subtree as a tree-formatted string.
+ *
+ * @param node - Root node to start from
+ * @param depth - Max depth (default 99)
+ */
+export function dumpTreeStr(node: Node, depth = 99): string {
+    const lines: string[] = [];
+    (function walk(n: Node, d: number, ind: string) {
+        if (d <= 0) return;
+        lines.push(`${ind}${n.getClass()} "${n.name}" (${n.getChildCount()} children)`);
+        for (let i = 0; i < n.getChildCount(); i++) {
+            const c = n.getChild(i);
+            if (c) walk(c as Node, d - 1, ind + '  ');
+        }
+    })(node, depth, '');
+    return lines.join('\n');
+}
+
+/**
+ * Return a snapshot of engine runtime stats as a formatted string.
+ *
+ * Includes process frames, FPS, physics frames, node count, time scale,
+ * and main-loop class. Never throws: `Engine.getMainLoop()` can be null or
+ * throw while the engine is starting/stopping, in which case those rows show `N/A`.
+ */
+export function statsStr(): string {
+    let tree: any = null;
+    try { tree = Engine.getMainLoop(); } catch { tree = null; }
+    return [
+        `Frames:     ${Engine.getProcessFrames()}`,
+        `FPS:        ${Engine.getFramesPerSecond()}`,
+        `Physics:    ${Engine.getPhysicsFrames()}`,
+        `Nodes:      ${tree?.getNodeCount?.() ?? 'N/A'}`,
+        `Time scale: ${Engine.timeScale}`,
+        `Main loop:  ${tree ? tree.getClass() : 'N/A'}`,
+    ].join('\n');
+}
+
+/**
+ * Run `gc()` and report how much heap was freed.
+ * Requires the `--expose-gc` Node.js flag.
+ */
+export function gc(): string {
+    const before = globalThis.process?.memoryUsage?.().heapUsed;
+    if (globalThis.Bun)
+        globalThis.Bun.gc(true);
+    else if (globalThis.gc)
+        globalThis.gc({ type: 'major', execution: 'sync' });
+    else
+        return 'gc() unavailable — need --expose-gc';
+
+    const after = globalThis.process?.memoryUsage?.().heapUsed;
+    const freed = typeof before === 'number' && typeof after === 'number' ? (before - after) / 1024 : 0;
+    return `GC: freed ${freed.toFixed(0)} KB`;
+}
+
+/**
+ * `DOMRect` is not a global in Bun (desktop), but `getBoundingClientRect()`
+ * constructs one. Install a minimal spec-compatible polyfill on desktop so the
+ * helper works identically on desktop and web (browsers already define it).
+ */
+function ensureDOMRect(): void {
+    if (typeof (globalThis as any).DOMRect !== 'undefined') return;
+    (globalThis as any).DOMRect = class DOMRect {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        constructor(x = 0, y = 0, width = 0, height = 0) {
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+        }
+        get left() { return this.x; }
+        get top() { return this.y; }
+        get right() { return this.x + this.width; }
+        get bottom() { return this.y + this.height; }
+        toJSON() { return { x: this.x, y: this.y, width: this.width, height: this.height }; }
+    };
+}
+
+/**
+ * Bootstrap the debugging environment.
+ *
+ * - Exposes common singletons (`Engine`, `OS`, `ClassDB`, `Time`) and all
+ *   debug utility functions on `globalThis.$` so they're reachable from
+ *   breakpoints in any module.
+ * - Registers an `uncaughtException` handler that logs but keeps the process
+ *   alive for interactive debugging.
+ * - Polyfills `DOMRect` (needed by `getBoundingClientRect()` on desktop).
+ */
+export function initDebug(): void {
+    globalThis.process?.on?.('uncaughtException', (err, origin) => {
+        console.error(`\n✗ ${origin}:`, err.stack);
+    });
+
+    ensureDOMRect();
+
+    Object.defineProperty(CanvasItem.prototype, 'getBoundingClientRect', {
+        configurable: true,
+        value(this: CanvasItem): DOMRect | null {
+            const scale = DisplayServer.screenGetScale();
+            if (this instanceof Control) {
+                const rc = (this as Control).getGlobalRect();
+                return new DOMRect(
+                    rc.position.x / scale, rc.position.y / scale,
+                    rc.size.x / scale, rc.size.y / scale,
+                );
+            }
+
+            if (typeof (this as any).getRect !== 'function') return null;
+
+            const rect = (this as any).getRect() as Rect2;
+            const t = this.getScreenTransform();
+
+            const pos = rect.position;
+            const sz = rect.size;
+            const tx = t.x;
+            const ty = t.y;
+            const to = t.origin;
+
+            const x0 = pos.x, y0 = pos.y;
+            const x1 = x0 + sz.x, y1 = y0 + sz.y;
+            const txx = tx.x, txy = tx.y;
+            const tyx = ty.x, tyy = ty.y;
+            const tox = to.x, toy = to.y;
+
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+            const accum = (px: number, py: number) => {
+                if (px < minX) minX = px; if (py < minY) minY = py;
+                if (px > maxX) maxX = px; if (py > maxY) maxY = py;
+            };
+
+            accum(txx * x0 + tyx * y0 + tox, txy * x0 + tyy * y0 + toy);
+            accum(txx * x1 + tyx * y0 + tox, txy * x1 + tyy * y0 + toy);
+            accum(txx * x0 + tyx * y1 + tox, txy * x0 + tyy * y1 + toy);
+            accum(txx * x1 + tyx * y1 + tox, txy * x1 + tyy * y1 + toy);
+
+            return new DOMRect(
+                minX / scale, minY / scale,
+                (maxX - minX) / scale, (maxY - minY) / scale,
+            );
+        },
+    });
+
+    Object.defineProperty(Node3D.prototype, 'getBoundingClientRect', {
+        configurable: true,
+        value(this: Node3D): DOMRect | null {
+            if (typeof (this as any).getAabb !== 'function') return null;
+
+            const aabb = (this as any).getAabb();
+            const gt = this.globalTransform;
+            const viewport = this.getViewport();
+            if (!viewport) return null;
+            const camera = viewport.getCamera3d();
+            if (!camera) return null;
+            const scale = DisplayServer.screenGetScale();
+
+            const b = gt.basis;
+            const bx = b.x, by = b.y, bz = b.z;
+            const o = gt.origin;
+            const p = aabb.position, e = aabb.end;
+
+            const [px, py, pz] = [p.x, p.y, p.z];
+            const [ex, ey, ez] = [e.x, e.y, e.z];
+            const [bxx, bxy, bxz] = [bx.x, bx.y, bx.z];
+            const [byx, byy, byz] = [by.x, by.y, by.z];
+            const [bzx, bzy, bzz] = [bz.x, bz.y, bz.z];
+            const [ox, oy, oz] = [o.x, o.y, o.z];
+
+            const corners = [
+                [px, py, pz], [ex, py, pz], [px, ey, pz], [ex, ey, pz],
+                [px, py, ez], [ex, py, ez], [px, ey, ez], [ex, ey, ez],
+            ];
+
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+
+            for (const [cx, cy, cz] of corners) {
+                const wx = bxx * cx + byx * cy + bzx * cz + ox;
+                const wy = bxy * cx + byy * cy + bzy * cz + oy;
+                const wz = bxz * cx + byz * cy + bzz * cz + oz;
+                const s = camera.unprojectPosition(new Vector3(wx, wy, wz));
+                if (s.x < minX) minX = s.x; if (s.y < minY) minY = s.y;
+                if (s.x > maxX) maxX = s.x; if (s.y > maxY) maxY = s.y;
+            }
+
+            return new DOMRect(
+                minX / scale, minY / scale,
+                (maxX - minX) / scale, (maxY - minY) / scale,
+            );
+        },
+    });
+
+    (globalThis as any).$ = {
+        Engine, OS, ClassDB, Time,
+        dumpStr, dumpTreeStr, statsStr, gc,
+    };
+}

package/src/index.ts

@@ -1,40 +1,40 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-export * from '../gen/index.ts';
-import * as ValueTypes from '../gen/value-types/index.ts';
-import * as HeapTypes from '../gen/heap-types/index.ts';
-import { Engine } from '../gen/classes/Engine.ts';
-import { GodotInstance } from '../gen/classes/GodotInstance.ts';
-import { SceneTree } from '../gen/classes/SceneTree.ts';
-import { Window } from '../gen/classes/Window.ts';
-import { gc } from './debug.ts';
-import { cancelAnimationFrame, getGodot, requestAnimationFrame } from './runtime.ts';
-
-// ---- make sure these classes are not tree-shaked ----
-void ValueTypes;
-void HeapTypes;
-void GodotInstance;
-void SceneTree;
-void Window;
-
-// ---- globalThis browser-compat API ----
-Object.assign(globalThis as any, { requestAnimationFrame, cancelAnimationFrame });
-
-// ---- GodotInstance frame pump (engine already started by C++ InitModule) ----
-export async function runGodot(signal?: AbortSignal, unmount?: () => PromiseLike<void>) {
-    signal?.throwIfAborted();
-    signal?.addEventListener('abort', () => {
-        (Engine.getMainLoop() as SceneTree)?.quit();
-    }, { once: true });
-
-    const godot = getGodot();
-    while (!godot.iteration())
-        await new Promise(requestAnimationFrame);
-
-    await unmount?.();
-    console.log(gc());
-    return godot.free();
-}
-
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+export * from '../gen/index.ts';
+import * as ValueTypes from '../gen/value-types/index.ts';
+import * as HeapTypes from '../gen/heap-types/index.ts';
+import { Engine } from '../gen/classes/Engine.ts';
+import { GodotInstance } from '../gen/classes/GodotInstance.ts';
+import { SceneTree } from '../gen/classes/SceneTree.ts';
+import { Window } from '../gen/classes/Window.ts';
+import { gc } from './debug.ts';
+import { cancelAnimationFrame, getGodot, requestAnimationFrame } from './runtime.ts';
+
+// ---- make sure these classes are not tree-shaked ----
+void ValueTypes;
+void HeapTypes;
+void GodotInstance;
+void SceneTree;
+void Window;
+
+// ---- globalThis browser-compat API ----
+Object.assign(globalThis as any, { requestAnimationFrame, cancelAnimationFrame });
+
+// ---- GodotInstance frame pump (engine already started by C++ InitModule) ----
+export async function runGodot(signal?: AbortSignal, unmount?: () => PromiseLike<void>) {
+    signal?.throwIfAborted();
+    signal?.addEventListener('abort', () => {
+        (Engine.getMainLoop() as SceneTree)?.quit();
+    }, { once: true });
+
+    const godot = getGodot();
+    while (!godot.iteration())
+        await new Promise(requestAnimationFrame);
+
+    await unmount?.();
+    console.log(gc());
+    return godot.free();
+}
+