@ringozz/godot 4.7.2-614 → 4.7.2-616

package/src/editor.ts

@@ -0,0 +1,107 @@
+#!/usr/bin/env bun
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+import { spawnSync } from 'node:child_process';
+import { chmodSync, copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, symlinkSync } from 'node:fs';
+import { homedir, tmpdir } from 'node:os';
+import { delimiter, dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const SELF = realpathSync(fileURLToPath(import.meta.url));
+const IS_WINDOWS = process.platform === 'win32';
+const BIN_DIR = join(homedir(), '.local', 'bin');
+const MANAGED = join(BIN_DIR, `godot${IS_WINDOWS ? '.exe' : ''}`);
+
+const { version_major, version_minor, version_patch, version_status } = JSON.parse(
+    readFileSync(join(dirname(SELF), '..', 'package.json'), 'utf-8'),
+).godot;
+const TAG = `${version_major}.${version_minor}.${version_patch}-${version_status}`;
+
+const TARGETS: Record<string, { asset: string; exe: string }> = {
+    'darwin-arm64': { asset: `Godot_v${TAG}_macos.universal.zip`, exe: 'Godot.app/Contents/MacOS/Godot' },
+    'darwin-x64': { asset: `Godot_v${TAG}_macos.universal.zip`, exe: 'Godot.app/Contents/MacOS/Godot' },
+    'win32-x64': { asset: `Godot_v${TAG}_win64.exe.zip`, exe: `Godot_v${TAG}_win64.exe` },
+    'linux-x64': { asset: `Godot_v${TAG}_linux.x86_64.zip`, exe: `Godot_v${TAG}_linux.x86_64` },
+    'linux-arm64': { asset: `Godot_v${TAG}_linux.arm64.zip`, exe: `Godot_v${TAG}_linux.arm64` },
+};
+
+const EXTRACTORS: Record<string, (archive: string, dest: string) => [string, string[]]> = {
+    darwin: (archive, dest) => ['ditto', ['-x', '-k', archive, dest]],
+    win32: (archive, dest) => ['tar', ['-xf', archive, '-C', dest]],
+    linux: (archive, dest) => ['unzip', ['-o', '-q', archive, '-d', dest]],
+};
+
+function systemGodot(): string | null {
+    const path = (process.env.PATH ?? '')
+        .split(delimiter)
+        .filter((dir) => {
+            try {
+                return realpathSync(join(resolve(dir), `godot${IS_WINDOWS ? '.exe' : ''}`)) !== SELF;
+            } catch {
+                return true;
+            }
+        });
+    return Bun.which('godot', { PATH: path.join(delimiter) });
+}
+
+function extract(archive: string, dest: string): void {
+    const make = EXTRACTORS[process.platform];
+    if (!make) throw new Error(`godot: no extractor for ${process.platform}.`);
+    const [tool, args] = make(archive, dest);
+    const { error, status } = spawnSync(tool, args, { stdio: ['ignore', 'inherit', 'inherit'] });
+    if (error) throw new Error(`godot: '${tool}' is required to extract the editor (${error.message}).`);
+    if (status !== 0) throw new Error(`godot: '${tool}' failed with exit code ${status}.`);
+}
+
+function install(stage: string, source: string): void {
+    mkdirSync(BIN_DIR, { recursive: true });
+    rmSync(MANAGED, { force: true });
+    if (process.platform !== 'darwin') {
+        copyFileSync(source, MANAGED);
+        if (!IS_WINDOWS) chmodSync(MANAGED, 0o755);
+        return;
+    }
+    const bundle = join(BIN_DIR, 'Godot.app');
+    rmSync(bundle, { recursive: true, force: true });
+    cpSync(join(stage, 'Godot.app'), bundle, { recursive: true });
+    symlinkSync(join('Godot.app', 'Contents', 'MacOS', 'Godot'), MANAGED);
+}
+
+async function provision(): Promise<void> {
+    const target = TARGETS[`${process.platform}-${process.arch}`];
+    if (!target) throw new Error(`godot: no prebuilt editor for ${process.platform}/${process.arch}; set GODOT_PATH.`);
+    const url = `https://github.com/godotengine/godot-builds/releases/download/${TAG}/${target.asset}`;
+    const stage = mkdtempSync(join(tmpdir(), 'godot-editor-'));
+    try {
+        console.error(`godot: downloading ${url}`);
+        const response = await fetch(url);
+        if (!response.ok) throw new Error(`godot: download failed (${response.status} ${response.statusText}) for ${url}`);
+        await Bun.write(join(stage, target.asset), response);
+        console.error('godot: extracting');
+        extract(join(stage, target.asset), stage);
+        const source = join(stage, target.exe);
+        if (!existsSync(source)) throw new Error(`godot: expected ${source} after extraction.`);
+        install(stage, source);
+        console.error(`godot: installed ${MANAGED}`);
+    } finally {
+        rmSync(stage, { recursive: true, force: true });
+    }
+}
+
+async function resolveEditor(): Promise<string> {
+    if (process.env.GODOT_PATH) return process.env.GODOT_PATH;
+    if (!process.env.GODOT_NODE_WRAPPER) {
+        const system = systemGodot();
+        if (system) return system;
+    }
+    if (!existsSync(MANAGED)) await provision();
+    return MANAGED;
+}
+
+if (import.meta.main) {
+    const exe = await resolveEditor();
+    const result = spawnSync(exe, process.argv.slice(2), { stdio: 'inherit', env: { ...process.env, GODOT_NODE_WRAPPER: '1' } });
+    process.exit(result.status ?? 1);
+}

package/src/index.ts

@@ -1,50 +1,54 @@
-/**********************************************************************
- Copyright (c) Vladimir Davidovich. All rights reserved.
-***********************************************************************/
-
-export * from '../gen/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, cleanupHooks, getGodot, requestAnimationFrame } from './runtime.ts';
-
-// ---- make sure these classes are not tree-shaked ----
-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?.();
-    while (cleanupHooks.size) {
-        const hooks = Array.from(cleanupHooks); cleanupHooks.clear();
-        await Promise.all(hooks.map((hook) => hook()));
-    }
-
-    // Let pending Napi wrapper finalizers run before tearing down the engine:
-    // Bun.gc(true) marks unreachable wrappers but their ~GodotVar/~Variant
-    // (which unrefs RefCounted objects) only runs on later macrotasks — and one
-    // wrapper's finalizer can free others. Freeing the engine first would report
-    // every still-referenced RefCounted as leaked, so drain a few gc+tick rounds.
-    for (let i = 0; i < 4; i++) {
-        console.log(gc());
-        await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-    return godot.free();
-}
+/**********************************************************************
+ Copyright (c) Vladimir Davidovich. All rights reserved.
+***********************************************************************/
+
+export * from '../gen/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, cleanupHooks, getGodot, requestAnimationFrame } from './runtime.ts';
+import { InputEventMouseButton } from '../gen/classes/InputEventMouseButton.ts';
+import { InputEventMouseMotion } from '../gen/classes/InputEventMouseMotion.ts';
+
+// ---- make sure these classes are not tree-shaked ----
+void HeapTypes;
+void GodotInstance;
+void SceneTree;
+void Window;
+void InputEventMouseButton;
+void InputEventMouseMotion;
+
+// ---- 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?.();
+    while (cleanupHooks.size) {
+        const hooks = Array.from(cleanupHooks); cleanupHooks.clear();
+        await Promise.all(hooks.map((hook) => hook()));
+    }
+
+    // Let pending Napi wrapper finalizers run before tearing down the engine:
+    // Bun.gc(true) marks unreachable wrappers but their ~GodotVar/~Variant
+    // (which unrefs RefCounted objects) only runs on later macrotasks — and one
+    // wrapper's finalizer can free others. Freeing the engine first would report
+    // every still-referenced RefCounted as leaked, so drain a few gc+tick rounds.
+    for (let i = 0; i < 4; i++) {
+        console.log(gc());
+        await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+    return godot.free();
+}