@vue-godot/cli 0.0.1

package/dist/integrate.js

@@ -0,0 +1,153 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as readline from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+/* ------------------------------------------------------------------ */
+/*  Helpers                                                           */
+/* ------------------------------------------------------------------ */
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** Resolve the bundled templates/ directory (lives next to dist/). */
+export function getTemplatesDir() {
+    // In the built package: dist/integrate.js → ../templates
+    return path.resolve(__dirname, '..', 'templates');
+}
+/**
+ * Walk up the directory tree from `from` until we find a `node_modules` dir.
+ */
+function findNodeModules(from) {
+    let dir = path.resolve(from);
+    while (true) {
+        const candidate = path.join(dir, 'node_modules');
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/**
+ * Recursively copy a directory, applying placeholder replacements to every
+ * text file. Binary files are copied as-is.
+ */
+export function copyTemplateDir(srcDir, destDir, replacements, cwd) {
+    fs.mkdirSync(destDir, { recursive: true });
+    for (const entry of fs.readdirSync(srcDir, { withFileTypes: true })) {
+        const srcPath = path.join(srcDir, entry.name);
+        const destPath = path.join(destDir, entry.name);
+        if (entry.isDirectory()) {
+            copyTemplateDir(srcPath, destPath, replacements, cwd);
+        }
+        else {
+            let content = fs.readFileSync(srcPath, 'utf-8');
+            for (const [placeholder, value] of Object.entries(replacements)) {
+                content = content.replaceAll(placeholder, value);
+            }
+            fs.writeFileSync(destPath, content);
+            console.log(`  created ${path.relative(cwd, destPath)}`);
+        }
+    }
+}
+export function newPackageJson(name) {
+    return {
+        name,
+        version: '1.0.0',
+        type: 'commonjs',
+        scripts: {
+            dev: 'vite build --watch -c vue/vite.config.ts',
+            build: 'vite build -c vue/vite.config.ts',
+            postinstall: 'npm run build',
+            'gen:types': 'vue-godot gen-types',
+        },
+        devDependencies: {
+            '@vue-godot/cli': '*',
+            '@types/node': '^20.11.18',
+            '@vitejs/plugin-vue': '^5.2.4',
+            vite: '^6.3.5',
+        },
+        dependencies: {
+            '@vue-godot/runtime-tscn': '^0.0.2',
+            '@vue/runtime-core': '^3.5.14',
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/*  Main                                                              */
+/* ------------------------------------------------------------------ */
+export async function integrate(options) {
+    const { targetDir, force } = options;
+    const absTarget = path.resolve(targetDir);
+    const vueDir = path.join(absTarget, 'vue');
+    /* --- guard: target directory must exist --- */
+    if (!fs.existsSync(absTarget)) {
+        console.error(`Target directory does not exist: ${absTarget}`);
+        process.exit(1);
+    }
+    /* --- vue/ already present? --- */
+    if (fs.existsSync(vueDir)) {
+        if (!force) {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await rl.question(`Directory "${vueDir}" already exists. Overwrite? (y/N) `);
+            rl.close();
+            if (answer.trim().toLowerCase() !== 'y') {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        fs.rmSync(vueDir, { recursive: true });
+    }
+    /* --- resolve node_modules relative path for tsconfig --- */
+    const nodeModules = findNodeModules(absTarget);
+    let nodeModulesRelPath;
+    if (nodeModules) {
+        nodeModulesRelPath = path.relative(vueDir, nodeModules);
+    }
+    else {
+        // fallback: assume node_modules lives in the parent of target
+        nodeModulesRelPath = '../node_modules';
+    }
+    /* --- copy template tree with placeholder substitution --- */
+    const templatesDir = getTemplatesDir();
+    const vueTplDir = path.join(templatesDir, 'vue');
+    if (!fs.existsSync(vueTplDir)) {
+        console.error(`Template directory not found: ${vueTplDir}\nThe CLI package may not be installed correctly.`);
+        process.exit(1);
+    }
+    copyTemplateDir(vueTplDir, vueDir, { '{{NODE_MODULES}}': nodeModulesRelPath }, process.cwd());
+    /* --- package.json --- */
+    const pkgJsonPath = path.join(absTarget, 'package.json');
+    if (fs.existsSync(pkgJsonPath)) {
+        const existing = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+        existing.scripts = existing.scripts || {};
+        existing.scripts.dev ??= 'vite build --watch -c vue/vite.config.ts';
+        existing.scripts.build ??= 'vite build -c vue/vite.config.ts';
+        existing.scripts.postinstall ??= 'npm run build';
+        existing.scripts['gen:types'] ??= 'vue-godot gen-types';
+        existing.devDependencies = existing.devDependencies || {};
+        existing.devDependencies['@vue-godot/cli'] ??= '*';
+        existing.devDependencies['@types/node'] ??= '^20.11.18';
+        existing.devDependencies['@vitejs/plugin-vue'] ??= '^5.2.4';
+        existing.devDependencies['vite'] ??= '^6.3.5';
+        existing.dependencies = existing.dependencies || {};
+        existing.dependencies['@vue-godot/runtime-tscn'] ??= '^0.0.2';
+        existing.dependencies['@vue/runtime-core'] ??= '^3.5.14';
+        fs.writeFileSync(pkgJsonPath, JSON.stringify(existing, null, 2) + '\n');
+        console.log(`  updated ${path.relative(process.cwd(), pkgJsonPath)}`);
+    }
+    else {
+        const name = path.basename(absTarget);
+        fs.writeFileSync(pkgJsonPath, JSON.stringify(newPackageJson(name), null, 2) + '\n');
+        console.log(`  created ${path.relative(process.cwd(), pkgJsonPath)}`);
+    }
+    console.log(`\n✔ Vue integration scaffolded in ${path.relative(process.cwd(), vueDir)}`);
+    console.log(`\nNext steps:`);
+    console.log(`  1. npm install        (runs initial build and creates dist/app.js)`);
+    console.log(`  2. npm run gen:types`);
+    console.log(`  3. npm run dev          (rebuilds on change; Godot hot-reloads dist/app.js)`);
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@vue-godot/cli",
+  "version": "0.0.1",
+  "description": "CLI tool for vue-godot projects — generates types, scaffolds projects, and more",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "vue-godot": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "templates"
+  ],
+  "scripts": {
+    "build": "npx tsc -p ."
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2"
+  },
+  "keywords": [
+    "vue",
+    "godot",
+    "cli"
+  ],
+  "author": "Portwatcher",
+  "license": "MIT"
+}

package/templates/godot/.editorconfig

@@ -0,0 +1,4 @@
+root = true
+
+[*]
+charset = utf-8

package/templates/godot/.gitattributes

@@ -0,0 +1,2 @@
+# Normalize EOL for all files that Git considers text files.
+* text=auto eol=lf

package/templates/godot/app.tscn

@@ -0,0 +1,12 @@
+[gd_scene load_steps=2 format=3]
+
+[ext_resource type="Script" path="res://dist/app.js" id="1_script"]
+
+[node name="app" type="Control"]
+layout_mode = 3
+anchors_preset = 15
+anchor_right = 1.0
+anchor_bottom = 1.0
+grow_horizontal = 2
+grow_vertical = 2
+script = ExtResource("1_script")

package/templates/godot/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128"><rect width="124" height="124" x="2" y="2" fill="#363d52" stroke="#212532" stroke-width="4" rx="14"/><g fill="#fff" transform="translate(12.322 12.322)scale(.101)"><path d="M105 673v33q407 354 814 0v-33z"/><path fill="#478cbf" d="m105 673 152 14q12 1 15 14l4 67 132 10 8-61q2-11 15-15h162q13 4 15 15l8 61 132-10 4-67q3-13 15-14l152-14V427q30-39 56-81-35-59-83-108-43 20-82 47-40-37-88-64 7-51 8-102-59-28-123-42-26 43-46 89-49-7-98 0-20-46-46-89-64 14-123 42 1 51 8 102-48 27-88 64-39-27-82-47-48 49-83 108 26 42 56 81zm0 33v39c0 276 813 276 814 0v-39l-134 12-5 69q-2 10-14 13l-162 11q-12 0-16-11l-10-65H446l-10 65q-4 11-16 11l-162-11q-12-3-14-13l-5-69z"/><path d="M483 600c0 34 58 34 58 0v-86c0-34-58-34-58 0z"/><circle cx="725" cy="526" r="90"/><circle cx="299" cy="526" r="90"/></g><g fill="#414042" transform="translate(12.322 12.322)scale(.101)"><circle cx="307" cy="532" r="60"/><circle cx="717" cy="532" r="60"/></g></svg>

package/templates/godot/project.godot

@@ -0,0 +1,16 @@
+; Engine configuration file.
+; It's best edited using the editor UI and not directly,
+; since the parameters that go here are not all obvious.
+;
+; Format:
+;   [section] ; section goes between []
+;   param=value ; assign values to parameters
+
+config_version=5
+
+[application]
+
+config/name="{{PROJECT_NAME}}"
+run/main_scene="res://app.tscn"
+config/features=PackedStringArray("4.4", "Forward Plus")
+config/icon="res://icon.svg"

package/templates/typings/.gdignore

@@ -0,0 +1 @@
+

package/templates/typings/app.nodes.gen.d.ts

@@ -0,0 +1,5 @@
+declare module "godot" {
+    interface SceneNodes {
+        "app.tscn": {},
+    }
+}

package/templates/typings/godot.minimal.d.ts

@@ -0,0 +1,282 @@
+
+declare module "godot-jsb" {
+    import { Object as GDObject, PackedByteArray, PropertyUsageFlags, PropertyHint, MethodFlags, Variant, Callable0, Callable1, Callable2, Callable3, Callable4, Callable5, StringName, MultiplayerAPI, MultiplayerPeer } from "godot";
+
+    const DEV_ENABLED: boolean;
+    const TOOLS_ENABLED: boolean;
+
+    /** version of GodotJS */
+    const version: string;
+
+    /** impl currently used */
+    const impl: string;
+
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<R = void>(self: GDObject, fn: () => R): Callable0<R>;
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, R = void>(self: GDObject, fn: (v1: T1) => R): Callable1<T1, R>;
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, R = void>(self: GDObject, fn: (v1: T1, v2: T2) => R): Callable2<T1, T2, R>;
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, R = void>(self: GDObject, fn: (v1: T1, v2: T2, v3: T3) => R): Callable3<T1, T2, T3, R>;
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, T4, R = void>(self: GDObject, fn: (v1: T1, v2: T2, v3: T3, v4: T4) => R): Callable4<T1, T2, T3, T4, R>;
+    /**
+     * Create godot Callable with a bound object `self`. 
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, T4, T5, R = void>(self: GDObject, fn: (v1: T1, v2: T2, v3: T3, v4: T4, v5: T5) => R): Callable5<T1, T2, T3, T4, T5, R>;
+
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<R = void>(fn: () => R): Callable0<R>;
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, R = void>(fn: (v1: T1) => R): Callable1<T1, R>;
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, R = void>(fn: (v1: T1, v2: T2) => R): Callable2<T1, T2, R>;
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, R = void>(fn: (v1: T1, v2: T2, v3: T3) => R): Callable3<T1, T2, T3, R>;
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, T4, R = void>(fn: (v1: T1, v2: T2, v3: T3, v4: T4) => R): Callable4<T1, T2, T3, T4, R>;
+    /**
+     * Create godot Callable without a bound object.
+     * @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
+     */
+    function callable<T1, T2, T3, T4, T5, R = void>(fn: (v1: T1, v2: T2, v3: T3, v4: T4, v5: T5) => R): Callable5<T1, T2, T3, T4, T5, R>;
+
+    /**
+     * Explicitly convert a `PackedByteArray`(aka `Vector<uint8_t>`) into a javascript `ArrayBuffer` 
+     * @deprecated [WARNING] This free function '_to_array_buffer' is deprecated and will be removed in a future version, use 'PackedByteArray.to_array_buffer()' instead. 
+     */
+    function to_array_buffer(packed: PackedByteArray): ArrayBuffer;
+
+    interface ScriptPropertyInfo {
+        name: string;
+        type: Variant.Type;
+        class_?: Function;
+        hint?: number;
+        hint_string?: string;
+        usage?: number;
+    }
+
+    namespace internal {
+        type OnReadyEvaluatorFunc = (self: any) => any;
+
+        interface RPCConfig {
+            mode?: MultiplayerAPI.RPCMode, 
+            sync?: boolean, 
+            transfer_mode?: MultiplayerPeer.TransferMode, 
+            transfer_channel?: number, 
+        }
+
+        function add_script_signal(target: any, name: string): void;
+        function add_script_property(target: any, details: ScriptPropertyInfo): void;
+        function add_script_ready(target: any, details: { name: string, evaluator: string | OnReadyEvaluatorFunc }): void;
+        function add_script_tool(target: any): void;
+        function add_script_icon(target: any, path: string): void;
+        function add_script_rpc(target: any, propertyKey: string, config: RPCConfig): void;
+
+        // 0: deprecated, 1: experimental, 2: help
+        function set_script_doc(target: any, propertyKey?: string, field: 0 | 1 | 2, message: string): void;
+
+        function add_module(id: string, obj: any): void;
+        function find_module(id: string): any;
+        function notify_microtasks_run(): void;
+
+        /**
+         * Get the transformed type name of a Variant.Type
+         */
+        function get_type_name(type: Variant.Type): StringName;
+    }
+
+    namespace editor {
+        interface PrimitiveConstantInfo {
+            name: string;
+            type: Variant.Type;
+            value: number; /* only if type is literal */
+        }
+
+        interface ConstantInfo {
+            name: string;
+            value: number; /** int64_t */
+        }
+
+        interface EnumInfo {
+            name: string;
+
+            literals: Array<string>;
+            is_bitfield: boolean;
+        }
+
+        interface DefaultArgumentInfo {
+            type: Variant.Type;
+            value: any;
+        }
+
+        // we treat godot MethodInfo/MethodBind as the same thing here for simplicity
+        //NOTE some fields will not be set if it's actually a MethodInfo struct
+        interface MethodBind {
+            id: number;
+            name: string;
+
+            hint_flags: MethodFlags;
+            is_static: boolean;
+            is_const: boolean;
+            is_vararg: boolean;
+            argument_count: number; /** int32_t */
+
+            args_: Array<PropertyInfo>;
+            default_arguments?: Array<DefaultArgumentInfo>;
+            return_: PropertyInfo | undefined;
+        }
+
+        interface PropertyInfo {
+            name: string;
+            type: Variant.Type;
+            class_name: string;
+            hint: PropertyHint;
+            hint_string: string;
+            usage: PropertyUsageFlags;
+        }
+
+        interface PropertySetGetInfo {
+            name: string;
+
+            type: Variant.Type;
+            index: number;
+            setter: string;
+            getter: string;
+
+            info: PropertyInfo;
+        }
+
+        interface PrimitiveGetSetInfo {
+            name: string;
+            type: Variant.Type;
+        }
+
+        interface SignalInfo {
+            name: string;
+            method_: MethodBind;
+        }
+
+        interface ArgumentInfo {
+            name: string;
+            type: Variant.Type;
+        }
+
+        interface ConstructorInfo {
+            arguments: Array<ArgumentInfo>
+        }
+
+        interface OperatorInfo {
+            name: string;
+            return_type: Variant.Type;
+            left_type: Variant.Type;
+            right_type: Variant.Type;
+        }
+
+        interface BasicClassInfo {
+            name: string;
+            methods: Array<MethodBind>;
+            enums?: Array<EnumInfo>;
+        }
+
+        // godot class
+        interface ClassInfo extends BasicClassInfo {
+            super: string;
+
+            properties: Array<PropertySetGetInfo>;
+            virtual_methods: Array<MethodBind>;
+            signals: Array<SignalInfo>;
+            constants?: Array<ConstantInfo>;
+        }
+
+        // variant class
+        interface PrimitiveClassInfo extends BasicClassInfo {
+            // self type
+            type: Variant.Type;
+
+            // valid only if has_indexing
+            element_type?: Variant.Type;
+
+            // true only if is_keyed
+            is_keyed: boolean;
+
+            constructors: Array<ConstructorInfo>;
+            operators: Array<OperatorInfo>;
+            properties: Array<PrimitiveGetSetInfo>;
+            constants?: Array<PrimitiveConstantInfo>;
+        }
+
+        interface SingletonInfo {
+            name: string;
+            class_name: string;
+            user_created: boolean;
+            editor_only: boolean;
+        }
+
+        interface GlobalConstantInfo {
+            name: string;
+            values: { [name: string]: number /** int64_t */ };
+        }
+
+        interface ClassDoc {
+            brief_description: string;
+
+            constants: { [name: string]: { description: string } };
+            methods: { [name: string]: { description: string } };
+            properties: { [name: string]: { description: string } };
+            signals: { [name: string]: { description: string } };
+        }
+
+        function get_class_doc(class_name: string): ClassDoc | undefined;
+
+        /**
+         * get a list of all classes registered in ClassDB
+         */
+        function get_classes(): Array<ClassInfo>;
+
+        function get_primitive_types(): Array<PrimitiveClassInfo>;
+
+        function get_singletons(): Array<SingletonInfo>;
+
+        function get_global_constants(): Array<GlobalConstantInfo>;
+
+        function get_utility_functions(): Array<MethodBind>;
+
+        function delete_file(filepath: string): void;
+
+        const VERSION_DOCS_URL: string;
+    }
+}
+