@vue-godot/cli 0.0.1

package/templates/typings/jsb.editor.bundle.d.ts

@@ -0,0 +1,73 @@
+declare module "jsb.editor.codegen" {
+    import * as jsb from "godot-jsb";
+    export class TypeDB {
+        singletons: {
+            [name: string]: jsb.editor.SingletonInfo;
+        };
+        classes: {
+            [name: string]: jsb.editor.ClassInfo;
+        };
+        primitive_types: {
+            [name: string]: jsb.editor.PrimitiveClassInfo;
+        };
+        primitive_type_names: {
+            [type: number]: string;
+        };
+        globals: {
+            [name: string]: jsb.editor.GlobalConstantInfo;
+        };
+        utilities: {
+            [name: string]: jsb.editor.MethodBind;
+        };
+        class_docs: {
+            [name: string]: jsb.editor.ClassDoc | false;
+        };
+        constructor();
+        find_doc(class_name: string): jsb.editor.ClassDoc | undefined;
+        is_primitive_type(name: string): boolean;
+        is_valid_method_name(name: string): boolean;
+        make_classname(class_name: string, used_as_input: boolean): string;
+        make_typename(info: jsb.editor.PropertyInfo, used_as_input: boolean): string;
+        make_arg(info: jsb.editor.PropertyInfo, type_replacer?: (name: string) => string): string;
+        make_literal_value(value: jsb.editor.DefaultArgumentInfo): string;
+        replace_type_inplace(name: string | undefined, type_replacer?: (name: string) => string): string;
+        make_arg_default_value(method_info: jsb.editor.MethodBind, index: number, type_replacer?: (name: string) => string): string;
+        make_args(method_info: jsb.editor.MethodBind, type_replacer?: (name: string) => string): string;
+        make_return(method_info: jsb.editor.MethodBind, type_replacer?: (name: string) => string): string;
+        make_signal_type(method_info: jsb.editor.MethodBind): string;
+    }
+    export class TSDCodeGen {
+        private _split_index;
+        private _outDir;
+        private _splitter;
+        private _types;
+        constructor(outDir: string);
+        private make_path;
+        private new_splitter;
+        private split;
+        private cleanup;
+        has_class(name?: string): boolean;
+        emit(): Promise<void>;
+        private emit_utility;
+        private emit_global;
+        private emit_mock;
+        private emit_singleton;
+        private emit_godot_primitive;
+        private emit_godot_class;
+    }
+    export class SceneTSDCodeGen {
+        private _out_dir;
+        private _scene_paths;
+        private _types;
+        constructor(out_dir: string, scene_paths: string[]);
+        private make_path;
+        emit(): Promise<void>;
+        private emit_children_node_types;
+        private emit_scene_node_types;
+    }
+}
+declare module "jsb.editor.main" {
+    import { PackedStringArray } from "godot";
+    export function auto_complete(pattern: string): PackedStringArray;
+    export function run_npm_install(): void;
+}

package/templates/typings/jsb.runtime.bundle.d.ts

@@ -0,0 +1,91 @@
+declare module "godot.annotations" {
+    import { PropertyHint, PropertyUsageFlags, Variant, MultiplayerAPI, MultiplayerPeer } from "godot";
+    import * as jsb from "godot-jsb";
+    export interface EnumPlaceholder {
+    }
+    export interface TypePairPlaceholder {
+    }
+    export function EnumType(type: any): EnumPlaceholder;
+    export function TypePair(key: ClassDescriptor, value: ClassDescriptor): TypePairPlaceholder;
+    export type ClassDescriptor = Function | Symbol | EnumPlaceholder | TypePairPlaceholder;
+    /**
+     *
+     */
+    export function signal(): (target: any, key: string) => void;
+    export function export_multiline(): (target: any, key: string) => void;
+    export function export_range(min: number, max: number, step?: number, ...extra_hints: string[]): (target: any, key: string) => void;
+    export function export_range_i(min: number, max: number, step?: number, ...extra_hints: string[]): (target: any, key: string) => void;
+    /** String as a path to a file, custom filter provided as hint. */
+    export function export_file(filter: string): (target: any, key: string) => void;
+    export function export_dir(filter: string): (target: any, key: string) => void;
+    export function export_global_file(filter: string): (target: any, key: string) => void;
+    export function export_global_dir(filter: string): (target: any, key: string) => void;
+    export function export_exp_easing(hint?: "" | "attenuation" | "positive_only" | "attenuation,positive_only"): (target: any, key: string) => void;
+    /**
+     * A Shortcut for `export_(Variant.Type.TYPE_ARRAY, { class_: clazz })`
+     */
+    export function export_array(clazz: ClassDescriptor): (target: any, key: string) => void;
+    /**
+     * A Shortcut for `export_(Variant.Type.TYPE_DICTIONARY, { class_: [key_class, value_class] })`
+     */
+    export function export_dictionary(key_class: ClassDescriptor, value_class: ClassDescriptor): (target: any, key: string) => void;
+    export function export_object(class_: ClassDescriptor): (target: any, key: string) => void;
+    /**
+     * [low level export]
+     */
+    export function export_(type: Variant.Type, details?: {
+        class_?: ClassDescriptor;
+        hint?: PropertyHint;
+        hint_string?: string;
+        usage?: PropertyUsageFlags;
+    }): (target: any, key: string) => void;
+    /**
+     * In Godot, class members can be exported.
+     * This means their value gets saved along with the resource (such as the scene) they're attached to.
+     * They will also be available for editing in the property editor.
+     * Exporting is done by using the `@export_var` (or `@export_`) annotation.
+     */
+    export function export_var(type: Variant.Type, details?: {
+        class_?: ClassDescriptor;
+        hint?: PropertyHint;
+        hint_string?: string;
+        usage?: PropertyUsageFlags;
+    }): (target: any, key: string) => void;
+    /**
+     * NOTE only int value enums are allowed
+     */
+    export function export_enum(enum_type: any): (target: any, key: string) => void;
+    /**
+     * NOTE only int value enums are allowed
+     */
+    export function export_flags(enum_type: any): (target: any, key: string) => void;
+    export interface RPCConfig {
+        mode?: MultiplayerAPI.RPCMode;
+        sync?: "call_remote" | "call_local";
+        transfer_mode?: MultiplayerPeer.TransferMode;
+        transfer_channel?: number;
+    }
+    export function rpc(config?: RPCConfig): (target: any, propertyKey?: PropertyKey, descriptor?: PropertyDescriptor) => void;
+    /**
+     * auto initialized on ready (before _ready called)
+     * @param evaluator for now, only string is accepted
+     */
+    export function onready(evaluator: string | jsb.internal.OnReadyEvaluatorFunc): (target: any, key: string) => void;
+    export function tool(): (target: any) => void;
+    export function icon(path: string): (target: any) => void;
+    export function deprecated(message?: string): (target: any, propertyKey?: PropertyKey, descriptor?: PropertyDescriptor) => void;
+    export function experimental(message?: string): (target: any, propertyKey?: PropertyKey, descriptor?: PropertyDescriptor) => void;
+    export function help(message?: string): (target: any, propertyKey?: PropertyKey, descriptor?: PropertyDescriptor) => void;
+}
+declare module "godot.typeloader" {
+    /**
+     * @param type the loaded type or function in godot module
+     */
+    export type TypeLoadedCallback = (type: any) => void;
+    export function on_type_loaded(type_name: string | string[], callback: TypeLoadedCallback): void;
+}
+declare module "jsb.core" { }
+declare const ProxyTarget: unique symbol;
+declare const proxy_unwrap: (value: any) => any;
+declare const proxyable_prototypes: any[];
+declare const proxy_wrap: (value: any) => any;

package/templates/vue/src/App.vue

@@ -0,0 +1,5 @@
+<template>
+  <Label :text="'Hello from Vue + Godot!'"></Label>
+</template>
+
+<script setup lang="ts"></script>

package/templates/vue/src/env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from '@vue/runtime-core'
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}

package/templates/vue/src/main.ts

@@ -0,0 +1,10 @@
+import { createApp } from '@vue-godot/runtime-tscn'
+import { Control } from 'godot'
+import App from './App.vue'
+
+export default class Root extends Control {
+  _ready() {
+    const app = createApp(App)
+    app.mount(this)
+  }
+}

package/templates/vue/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "vue": ["{{NODE_MODULES}}/@vue/runtime-core/dist/runtime-core.d.ts"],
+      "godot": ["../typings/godot.mix.d.ts"]
+    }
+  },
+  "include": ["src/**/*.ts", "src/**/*.vue", "../typings/**/*.d.ts"]
+}

package/templates/vue/vite.config.ts

@@ -0,0 +1,38 @@
+import vue from '@vitejs/plugin-vue'
+import { defineConfig } from 'vite'
+
+export default defineConfig({
+  plugins: [
+    vue({
+      template: {
+        compilerOptions: {
+          // treat all tags with uppercase letters as custom elements
+          isCustomElement: (tag) => tag[0] === tag[0].toUpperCase(),
+        },
+      },
+    }),
+  ],
+  define: {
+    'process.env': {},
+  },
+  resolve: {
+    // `vue` → `@vue/runtime-core` so the DOM renderer is tree-shaken
+    alias: { vue: '@vue/runtime-core' },
+  },
+  build: {
+    lib: {
+      entry: 'vue/src/main.ts',
+      formats: ['cjs'],
+      fileName: () => 'app.js',
+    },
+    // everything provided by the engine/runtime stays external
+    rollupOptions: {
+      external: ['godot'],
+      output: {
+        exports: 'named',
+      },
+    },
+    target: 'es2020',
+    minify: false,
+  },
+})