369 lines
12 KiB
TypeScript
369 lines
12 KiB
TypeScript
|
|
declare module "godot-jsb" {
|
|
import {
|
|
Callable,
|
|
MethodFlags,
|
|
MultiplayerAPI,
|
|
MultiplayerPeer,
|
|
Object as GObject,
|
|
PackedByteArray,
|
|
PropertyInfo,
|
|
Signal,
|
|
StringName,
|
|
Variant,
|
|
} from "godot";
|
|
|
|
const CAMEL_CASE_BINDINGS_ENABLED: boolean;
|
|
|
|
const DEV_ENABLED: boolean;
|
|
const TOOLS_ENABLED: boolean;
|
|
|
|
/** version of GodotJS */
|
|
const version: string;
|
|
|
|
/** impl currently used */
|
|
const impl: string;
|
|
|
|
/**
|
|
* Create godot Callable without a bound object.
|
|
* @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
|
|
*/
|
|
function callable<F extends Function>(fn: F): Callable<F>;
|
|
|
|
/**
|
|
* Create godot Callable with a bound object `self`.
|
|
* @deprecated [WARNING] avoid using this function directly, use `Callable.create` instead.
|
|
*/
|
|
function callable<S extends GObject, F extends (this: S, ...args: any[]) => any>(self: S, fn: F): Callable<F>;
|
|
|
|
/**
|
|
* 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;
|
|
|
|
type AsyncModuleSourceLoaderResolveFunc = (source: string) => void;
|
|
type AsyncModuleSourceLoaderRejectFunc = (error: string) => void;
|
|
|
|
/**
|
|
* Set a callback function to handle the load of source code of asynchronous modules.
|
|
* Only use this function if it's not set in C++.
|
|
*/
|
|
function set_async_module_loader(
|
|
fn: (
|
|
module_id: string,
|
|
resolve: AsyncModuleSourceLoaderResolveFunc,
|
|
reject: AsyncModuleSourceLoaderRejectFunc,
|
|
) => void,
|
|
): void;
|
|
|
|
interface MinimalCommonJSModule {
|
|
exports: any;
|
|
loaded: boolean;
|
|
id: string;
|
|
}
|
|
|
|
/**
|
|
* Import a CommonJS module asynchronously.
|
|
*
|
|
* NOTE: Only the source code is loaded asynchronously, the module is still evaluated on the script thread.
|
|
* NOTE: Calling the $import() function without a async module loader set in advance will return undefined.
|
|
* @param module_id the module id to import
|
|
* @example
|
|
* ```js
|
|
* // [init.js]
|
|
* import * as jsb from "godot-jsb";
|
|
* jsb.set_async_module_loader((id, resolve, reject) => {
|
|
* console.log("[test] async module loader start", id);
|
|
* // here should be the actual async loading of the module, HTTP request, etc.
|
|
* // we just simulate it with a timeout
|
|
* setTimeout(() => {
|
|
* console.log("[test] async module loader resolve", id);
|
|
* resolve("exports.foo = function () { console.log('hello, module imported'); }");
|
|
* }, 3000);
|
|
* });
|
|
* // [somescript.js]
|
|
* jsb.$import("http://localhost/async_loaded.js").then(mod => {
|
|
* console.log("[test] async module loader", mod);
|
|
* mod.exports.foo();
|
|
* });
|
|
* ```
|
|
*/
|
|
function $import(module_id: string): Promise<MinimalCommonJSModule>;
|
|
|
|
interface ScriptPropertyInfo {
|
|
name: string;
|
|
type: Variant.Type;
|
|
class_?: Function;
|
|
hint?: number;
|
|
hint_string?: string;
|
|
usage?: number;
|
|
cache?: boolean;
|
|
}
|
|
|
|
export namespace internal {
|
|
type OnReadyEvaluatorFunc = (self: any) => any;
|
|
type GObjectConstructor = abstract new (...args: any[]) => GObject;
|
|
|
|
function add_script_signal(prototype: GObject, name: string): void;
|
|
function add_script_property(prototype: GObject, details: ScriptPropertyInfo): void;
|
|
function add_script_ready(
|
|
prototype: GObject,
|
|
details: {
|
|
name: string;
|
|
evaluator: string | OnReadyEvaluatorFunc;
|
|
},
|
|
): void;
|
|
function add_script_tool(constructor: GObjectConstructor): void;
|
|
function add_script_icon(constructor: GObjectConstructor, path: string): void;
|
|
function add_script_rpc(
|
|
prototype: GObject,
|
|
property_key: string,
|
|
config: {
|
|
rpc_mode?: MultiplayerAPI.RPCMode;
|
|
call_local?: boolean;
|
|
transfer_mode?: MultiplayerPeer.TransferMode;
|
|
channel?: number;
|
|
},
|
|
): void;
|
|
|
|
function create_script_signal_getter(name: string): (this: GObject) => Signal;
|
|
function create_script_cached_property_updater(name: string): (this: GObject, value?: unknown) => void;
|
|
|
|
// 0: deprecated, 1: experimental, 2: help
|
|
function set_script_doc(
|
|
target: GObjectConstructor,
|
|
property_key: undefined,
|
|
field: 0 | 1 | 2,
|
|
message: string,
|
|
): void;
|
|
function set_script_doc(target: GObject, property_key: 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;
|
|
|
|
namespace names {
|
|
/**
|
|
* Get the transformed name of a Godot class
|
|
*/
|
|
function get_class<T extends string>(godot_class: T): T;
|
|
/**
|
|
* Get the transformed name of a Godot enum
|
|
*/
|
|
function get_enum<T extends string>(godot_enum: T): T;
|
|
/**
|
|
* Get the transformed name of a Godot enum
|
|
*/
|
|
function get_enum_value<T extends string>(godot_enum_value: T): T;
|
|
/**
|
|
* Get the transformed name of a Godot class member
|
|
*/
|
|
function get_member<T extends string>(godot_member: T): T;
|
|
/**
|
|
* Get the internal Godot name/identifier from a transformed name i.e. the inverse of the other accessors.
|
|
*/
|
|
function get_internal_mapping(name: string): string;
|
|
/**
|
|
* Get the transformed name of a Godot function parameter
|
|
*/
|
|
function get_parameter<T extends string>(parameter: T): T;
|
|
/**
|
|
* Get the transformed type name of a Variant.Type
|
|
*/
|
|
function get_variant_type<T extends string>(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: Record<string, number>;
|
|
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 {
|
|
internal_name: string;
|
|
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 PropertySetGetInfo {
|
|
internal_name: string;
|
|
name: string;
|
|
|
|
type: Variant.Type;
|
|
index: number;
|
|
setter: string;
|
|
getter: string;
|
|
|
|
info: PropertyInfo;
|
|
}
|
|
|
|
interface PrimitiveGetSetInfo {
|
|
name: string;
|
|
type: Variant.Type;
|
|
}
|
|
|
|
interface SignalInfo {
|
|
internal_name: string;
|
|
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 {
|
|
internal_name: string;
|
|
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 get_input_actions(): Array<string>;
|
|
|
|
function delete_file(filepath: string): void;
|
|
|
|
const VERSION_DOCS_URL: string;
|
|
}
|
|
}
|
|
|
|
// Globals
|
|
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
|
|
interface Console {
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert_static) */
|
|
assert(condition?: boolean, ...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */
|
|
debug(...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static) */
|
|
error(...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */
|
|
info(...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static) */
|
|
log(...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */
|
|
time(label?: string): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */
|
|
timeEnd(label?: string): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */
|
|
trace(...data: any[]): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static) */
|
|
warn(...data: any[]): void;
|
|
}
|
|
declare const console: Console;
|
|
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearInterval) */
|
|
declare function clearInterval(id: number | undefined): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/clearTimeout) */
|
|
declare function clearTimeout(id: number | undefined): void;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setInterval) */
|
|
declare function setInterval(handler: () => void, timeout?: number, ...arguments: any[]): number;
|
|
/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Window/setTimeout) */
|
|
declare function setTimeout(handler: () => void, timeout?: number, ...arguments: any[]): number;
|