@defold-typescript/types 0.1.0

package/generated/render.d.ts

@@ -0,0 +1,55 @@
+/** @noSelfInFile */
+import type { Hash, Matrix4, Opaque, Url } from "../src/core-types";
+
+declare global {
+  namespace render {
+    type constant_buffer = Opaque<"constant_buffer">;
+    type render_target = Opaque<"render_target">;
+    type texture = Opaque<"texture">;
+    const FRUSTUM_PLANES_ALL: number & { readonly __brand: "render.FRUSTUM_PLANES_ALL" };
+    const FRUSTUM_PLANES_SIDES: number & { readonly __brand: "render.FRUSTUM_PLANES_SIDES" };
+    const RENDER_TARGET_DEFAULT: number & { readonly __brand: "render.RENDER_TARGET_DEFAULT" };
+    const SORT_BACK_TO_FRONT: number & { readonly __brand: "render.SORT_BACK_TO_FRONT" };
+    const SORT_FRONT_TO_BACK: number & { readonly __brand: "render.SORT_FRONT_TO_BACK" };
+    const SORT_NONE: number & { readonly __brand: "render.SORT_NONE" };
+    function clear(buffers: Record<string | number, unknown>): void;
+    function constant_buffer(): Opaque<"constant_buffer">;
+    function delete_render_target(render_target: Opaque<"render_target">): void;
+    function disable_material(): void;
+    function disable_state(state: Opaque<"constant">): void;
+    function disable_texture(binding: Opaque<"texture"> | string | Hash): void;
+    function dispatch_compute(x: number, y: number, z: number, options?: { constants?: Opaque<"constant_buffer"> }): void;
+    function draw(predicate: number, options?: { frustum?: Matrix4; frustum_planes?: number; constants?: Opaque<"constant_buffer">; sort_order?: number }): void;
+    function draw_debug3d(options?: { frustum?: Matrix4; frustum_planes?: number }): void;
+    function enable_material(material_id: string | Hash): void;
+    function enable_state(state: Opaque<"constant">): void;
+    function enable_texture(binding: number | string | Hash, handle_or_name: Opaque<"texture"> | string | Hash, buffer_type?: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): void;
+    function get_height(): number;
+    function get_render_target_height(render_target: Opaque<"render_target">, buffer_type: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): number;
+    function get_render_target_width(render_target: Opaque<"render_target">, buffer_type: number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR0_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR1_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR2_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_COLOR3_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_DEPTH_BIT" } | number & { readonly __brand: "graphics.BUFFER_TYPE_STENCIL_BIT" }): number;
+    function get_width(): number;
+    function get_window_height(): number;
+    function get_window_width(): number;
+    function predicate(tags: Record<string | number, unknown>): number;
+    function render_target(name: string, parameters: Record<string | number, unknown>): Opaque<"render_target">;
+    function set_blend_func(source_factor: number, destination_factor: number): void;
+    function set_camera(camera?: Url | number, options?: { use_frustum?: boolean }): void;
+    function set_color_mask(red: boolean, green: boolean, blue: boolean, alpha: boolean): void;
+    function set_compute(compute?: string | Hash): void;
+    function set_cull_face(face_type: number): void;
+    function set_depth_func(func: number): void;
+    function set_depth_mask(depth: boolean): void;
+    function set_listener(callback?: (self: unknown, event_type: unknown) => void): void;
+    function set_polygon_offset(factor: number, units: number): void;
+    function set_projection(matrix: Matrix4): void;
+    function set_render_target(render_target: Opaque<"render_target">, options?: { transient?: Record<string | number, unknown> }): void;
+    function set_render_target_size(render_target: Opaque<"render_target">, width: number, height: number): void;
+    function set_stencil_func(func: number, ref: number, mask: number): void;
+    function set_stencil_mask(mask: number): void;
+    function set_stencil_op(sfail: number, dpfail: number, dppass: number): void;
+    function set_view(matrix: Matrix4): void;
+    function set_viewport(x: number, y: number, width: number, height: number): void;
+  }
+}
+
+export {};

package/generated/resource.d.ts

@@ -0,0 +1,33 @@
+/** @noSelfInFile */
+import type { Hash, Opaque } from "../src/core-types";
+
+declare global {
+  namespace resource {
+    function atlas(path?: string): Hash;
+    function buffer(path?: string): Hash;
+    function create_atlas(path: string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: Opaque<"constant">; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: { id?: string; width?: number; height?: number; pivot_x?: number; pivot_y?: number; rotated?: boolean }[]; vertices?: number[]; uvs?: number[]; indices?: number[] }): Hash;
+    function create_buffer(path: string, table?: { buffer?: Opaque<"buffer">; transfer_ownership?: boolean }): Hash;
+    function create_sound_data(path: string, options?: { data?: string; filesize?: number; partial?: boolean }): Hash;
+    function create_texture(path: string, table: { type?: number; width?: number; height?: number; depth?: number; format?: number; flags?: number; max_mipmaps?: number; compression_type?: number }, buffer: Opaque<"buffer">): Hash;
+    function create_texture_async(path: string | Hash, table: { type?: number; width?: number; height?: number; depth?: number; format?: number; flags?: number; max_mipmaps?: number; compression_type?: number }, buffer: Opaque<"buffer">, callback: (...args: unknown[]) => unknown): LuaMultiReturn<[Hash, number]>;
+    function font(path?: string): Hash;
+    function get_atlas(path: Hash | string): { texture: string | Hash; animations: { id: string; width: number; height: number; frame_start: number; frame_end: number; playback: Opaque<"constant">; fps: number; flip_vertical: boolean; flip_horizontal: boolean }[]; geometries: Record<string | number, unknown> };
+    function get_buffer(path: Hash | string): Opaque<"buffer">;
+    function get_render_target_info(path: Hash | string | number): { handle: number; width: number; height: number; depth: number; mipmaps: number; type: number; buffer_type: number; texture: Hash };
+    function get_text_metrics(url: Hash, text: string, options?: { width?: number; leading?: number; tracking?: number; line_break?: boolean }): Record<string | number, unknown>;
+    function get_texture_info(path: Hash | string | number): { handle: number; width: number; height: number; depth: number; page_count: number; mipmaps: number; flags: number; type: number };
+    function load(path: string): Opaque<"buffer">;
+    function material(path?: string): Hash;
+    function release(path: Hash | string): void;
+    function render_target(path?: string): Hash;
+    function set(path: string | Hash, buffer: Opaque<"buffer">): void;
+    function set_atlas(path: Hash | string, table: { texture?: string | Hash; animations?: { id?: string; width?: number; height?: number; frame_start?: number; frame_end?: number; playback?: Opaque<"constant">; fps?: number; flip_vertical?: boolean; flip_horizontal?: boolean }[]; geometries?: Record<string | number, unknown>; vertices?: number[]; uvs?: number[]; indices?: number[] }): void;
+    function set_buffer(path: Hash | string, buffer: Opaque<"buffer">, table?: { transfer_ownership?: boolean }): void;
+    function set_sound(path: Hash | string, buffer: string): void;
+    function set_texture(path: Hash | string, table: { type?: number; width?: number; height?: number; format?: number; x?: number; y?: number; z?: number; page?: number; mipmap?: number; compression_type?: number }, buffer: Opaque<"buffer">): void;
+    function texture(path?: string): Hash;
+    function tile_source(path?: string): Hash;
+  }
+}
+
+export {};

package/generated/socket.d.ts

@@ -0,0 +1,25 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace socket {
+    type client = Opaque<"client">;
+    type master = Opaque<"master">;
+    type unconnected = Opaque<"unconnected">;
+    const _SETSIZE: number & { readonly __brand: "socket._SETSIZE" };
+    const _VERSION: number & { readonly __brand: "socket._VERSION" };
+    function connect(address: string, port: number, locaddr?: string, locport?: number, family?: string): LuaMultiReturn<[Opaque<"client"> | unknown, string | unknown]>;
+    function gettime(): number;
+    function newtry(finalizer: () => void): (...args: unknown[]) => unknown;
+    function protect(func: (...args: unknown[]) => unknown): (arg0: unknown) => void;
+    function select(recvt: Record<string | number, unknown>, sendt: Record<string | number, unknown>, timeout?: number): LuaMultiReturn<[Record<string | number, unknown>, Record<string | number, unknown>, string | unknown]>;
+    function skip(d: number, ret1?: unknown, ret2?: unknown, retN?: unknown): LuaMultiReturn<[unknown, unknown, unknown]>;
+    function sleep(time: number): void;
+    function tcp(): LuaMultiReturn<[Opaque<"master"> | unknown, string | unknown]>;
+    function tcp6(): LuaMultiReturn<[Opaque<"master"> | unknown, string | unknown]>;
+    function udp(): LuaMultiReturn<[Opaque<"unconnected"> | unknown, string | unknown]>;
+    function udp6(): LuaMultiReturn<[Opaque<"unconnected"> | unknown, string | unknown]>;
+  }
+}
+
+export {};

package/generated/sound.d.ts

@@ -0,0 +1,28 @@
+/** @noSelfInFile */
+import type { Hash, Url } from "../src/core-types";
+
+declare global {
+  namespace sound {
+    function get_group_gain(group: string | Hash): number;
+    function get_group_name(group: string | Hash): string;
+    function get_groups(): Hash[];
+    function get_peak(group: string | Hash, window: number): LuaMultiReturn<[number, number]>;
+    function get_rms(group: string | Hash, window: number): LuaMultiReturn<[number, number]>;
+    function is_music_playing(): boolean;
+    function is_phone_call_active(): boolean;
+    function pause(url: string | Hash | Url, pause: boolean): void;
+    function play(url: string | Hash | Url, play_properties?: { delay?: number; gain?: number; pan?: number; speed?: number; start_time?: number; start_frame?: number }, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void): number;
+    function set_gain(url: string | Hash | Url, gain?: number): void;
+    function set_group_gain(group: string | Hash, gain: number): void;
+    function set_pan(url: string | Hash | Url, pan?: number): void;
+    function stop(url: string | Hash | Url, stop_properties?: { play_id?: number }): void;
+    interface properties {
+      gain: number;
+      pan: number;
+      sound: Hash;
+      speed: number;
+    }
+  }
+}
+
+export {};

package/generated/sprite.d.ts

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+import type { Hash, Url, Vector3, Vector4 } from "../src/core-types";
+
+declare global {
+  namespace sprite {
+    function play_flipbook(url: string | Hash | Url, id: string | Hash, complete_function?: (self: unknown, message_id: unknown, message: unknown, sender: unknown) => void, play_properties?: { offset?: number; playback_rate?: number }): void;
+    function set_hflip(url: string | Hash | Url, flip: boolean): void;
+    function set_vflip(url: string | Hash | Url, flip: boolean): void;
+    interface properties {
+      animation: Hash;
+      cursor: number;
+      frame_count: Hash;
+      image: Hash;
+      material: Hash;
+      playback_rate: number;
+      scale: Vector3;
+      size: Vector3;
+      slice: Vector4;
+    }
+  }
+}
+
+export {};

package/generated/sys.d.ts

@@ -0,0 +1,37 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace sys {
+    const NETWORK_CONNECTED: number & { readonly __brand: "sys.NETWORK_CONNECTED" };
+    const NETWORK_CONNECTED_CELLULAR: number & { readonly __brand: "sys.NETWORK_CONNECTED_CELLULAR" };
+    const NETWORK_DISCONNECTED: number & { readonly __brand: "sys.NETWORK_DISCONNECTED" };
+    function deserialize(buffer: string): Record<string | number, unknown>;
+    function exists(path: string): boolean;
+    function exit(code: number): void;
+    function get_application_info(app_string: string): { installed: boolean };
+    function get_application_path(): string;
+    function get_config_boolean(key: string, default_value?: boolean): boolean;
+    function get_config_int(key: string, default_value?: number): number;
+    function get_config_number(key: string, default_value?: number): number;
+    function get_config_string(key: string, default_value?: string): string;
+    function get_connectivity(): Opaque<"constant">;
+    function get_engine_info(): { version: string; version_sha1: string; is_debug: boolean };
+    function get_host_path(filename: string): string;
+    function get_ifaddrs(): { name: string; address: string; mac: string; up: boolean; running: boolean }[];
+    function get_save_file(application_id: string, file_name: string): string;
+    function get_sys_info(options?: { ignore_secure?: boolean }): { device_model: string; manufacturer: string; system_name: string; system_version: string; api_version: string; language: string; device_language: string; territory: string; gmt_offset: number; device_ident: string; user_agent: string };
+    function load(filename: string): Record<string | number, unknown>;
+    function load_resource(filename: string): LuaMultiReturn<[string | unknown, string | unknown]>;
+    function open_url(url: string, attributes?: { target?: string }): boolean;
+    function reboot(arg1?: string, arg2?: string, arg3?: string, arg4?: string, arg5?: string, arg6?: string): void;
+    function save(filename: string, table: Record<string | number, unknown>): void;
+    function serialize(table: Record<string | number, unknown>): string;
+    function set_connectivity_host(host: string): void;
+    function set_error_handler(error_handler: (source: unknown, message: unknown, traceback: unknown) => void): void;
+    function set_update_frequency(frequency: number): void;
+    function set_vsync_swap_interval(swap_interval: number): void;
+  }
+}
+
+export {};

package/generated/tilemap.d.ts

@@ -0,0 +1,24 @@
+/** @noSelfInFile */
+import type { Hash, Url } from "../src/core-types";
+
+declare global {
+  namespace tilemap {
+    const H_FLIP: number & { readonly __brand: "tilemap.H_FLIP" };
+    const ROTATE_180: number & { readonly __brand: "tilemap.ROTATE_180" };
+    const ROTATE_270: number & { readonly __brand: "tilemap.ROTATE_270" };
+    const ROTATE_90: number & { readonly __brand: "tilemap.ROTATE_90" };
+    const V_FLIP: number & { readonly __brand: "tilemap.V_FLIP" };
+    function get_bounds(url: string | Hash | Url): LuaMultiReturn<[number, number, number, number]>;
+    function get_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number): number;
+    function get_tile_info(url: string | Hash | Url, layer: string | Hash, x: number, y: number): Record<string | number, unknown>;
+    function get_tiles(url: string | Hash | Url, layer: string | Hash): Record<string | number, unknown>;
+    function set_tile(url: string | Hash | Url, layer: string | Hash, x: number, y: number, tile: number, transform_bitmask?: number): void;
+    function set_visible(url: string | Hash | Url, layer: string | Hash, visible: boolean): void;
+    interface properties {
+      material: Hash;
+      tile_source: Hash;
+    }
+  }
+}
+
+export {};

package/generated/timer.d.ts

@@ -0,0 +1,12 @@
+/** @noSelfInFile */
+declare global {
+  namespace timer {
+    const INVALID_TIMER_HANDLE: number & { readonly __brand: "timer.INVALID_TIMER_HANDLE" };
+    function cancel(handle: number): boolean;
+    function delay(delay: number, repeating: boolean, callback: (self: unknown, handle: unknown, time_elapsed: unknown) => void): number;
+    function get_info(handle: number): { time_remaining: number; delay: number; repeating: boolean } | unknown;
+    function trigger(handle: number): boolean;
+  }
+}
+
+export {};

package/generated/vmath.d.ts

@@ -0,0 +1,63 @@
+/** @noSelfInFile */
+import type { Matrix4, Quaternion, Vector, Vector3, Vector4 } from "../src/core-types";
+
+declare global {
+  namespace vmath {
+    function clamp(value: number | Vector3 | Vector4, min: number | Vector3 | Vector4, max: number | Vector3 | Vector4): number | Vector3 | Vector4;
+    function conj(q1: Quaternion): Quaternion;
+    function cross(v1: Vector3, v2: Vector3): Vector3;
+    function dot(v1: Vector3 | Vector4, v2: Vector3 | Vector4): number;
+    function euler_to_quat(x: number | Vector3, y: number, z: number): Quaternion;
+    function inv(m1: Matrix4): Matrix4;
+    function length(v: Vector3 | Vector4 | Quaternion): number;
+    function length_sqr(v: Vector3 | Vector4 | Quaternion): number;
+    function lerp(t: number, v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
+    function lerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
+    function lerp(t: number, n1: number, n2: number): number;
+    function matrix4(): Matrix4;
+    function matrix4(m1: Matrix4): Matrix4;
+    function matrix4_axis_angle(v: Vector3, angle: number): Matrix4;
+    function matrix4_compose(translation: Vector3 | Vector4, rotation: Quaternion, scale: Vector3): Matrix4;
+    function matrix4_frustum(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
+    function matrix4_look_at(eye: Vector3, look_at: Vector3, up: Vector3): Matrix4;
+    function matrix4_orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
+    function matrix4_perspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+    function matrix4_quat(q: Quaternion): Matrix4;
+    function matrix4_rotation_x(angle: number): Matrix4;
+    function matrix4_rotation_y(angle: number): Matrix4;
+    function matrix4_rotation_z(angle: number): Matrix4;
+    function matrix4_scale(scale: Vector3): Matrix4;
+    function matrix4_scale(scale: number): Matrix4;
+    function matrix4_scale(scale_x: number, scale_y: number, scale_z: number): Matrix4;
+    function matrix4_translation(position: Vector3 | Vector4): Matrix4;
+    function mul_per_elem(v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
+    function normalize(v1: Vector3 | Vector4 | Quaternion): Vector3 | Vector4 | Quaternion;
+    function ortho_inv(m1: Matrix4): Matrix4;
+    function project(v1: Vector3, v2: Vector3): number;
+    function quat(): Quaternion;
+    function quat(q1: Quaternion): Quaternion;
+    function quat(x: number, y: number, z: number, w: number): Quaternion;
+    function quat_axis_angle(v: Vector3, angle: number): Quaternion;
+    function quat_basis(x: Vector3, y: Vector3, z: Vector3): Quaternion;
+    function quat_from_to(v1: Vector3, v2: Vector3): Quaternion;
+    function quat_matrix4(matrix: Matrix4): Quaternion;
+    function quat_rotation_x(angle: number): Quaternion;
+    function quat_rotation_y(angle: number): Quaternion;
+    function quat_rotation_z(angle: number): Quaternion;
+    function quat_to_euler(q: Quaternion): LuaMultiReturn<[number, number, number]>;
+    function rotate(q: Quaternion, v1: Vector3): Vector3;
+    function slerp(t: number, v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
+    function slerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
+    function vector(t: number[]): Vector;
+    function vector3(): Vector3;
+    function vector3(n: number): Vector3;
+    function vector3(v1: Vector3): Vector3;
+    function vector3(x: number, y: number, z: number): Vector3;
+    function vector4(): Vector4;
+    function vector4(n: number): Vector4;
+    function vector4(v1: Vector4): Vector4;
+    function vector4(x: number, y: number, z: number, w: number): Vector4;
+  }
+}
+
+export {};

package/generated/webview.d.ts

@@ -0,0 +1,15 @@
+/** @noSelfInFile */
+declare global {
+  namespace webview {
+    function create(callback: (...args: unknown[]) => unknown): void;
+    function destroy(webview_id: number): void;
+    function eval(webview_id: number, code: string): void;
+    function is_visible(webview_id: number): void;
+    function open_raw(webview_id: number, html: string, options: Record<string | number, unknown>): void;
+    function set_position(webview_id: number, x: number, y: number, width: number, height: number): void;
+    function set_transparent(webview_id: number, transparent: boolean): void;
+    function set_visible(webview_id: number, visible: number): void;
+  }
+}
+
+export {};

package/generated/window.d.ts

@@ -0,0 +1,28 @@
+/** @noSelfInFile */
+import type { Opaque } from "../src/core-types";
+
+declare global {
+  namespace window {
+    const DIMMING_OFF: number & { readonly __brand: "window.DIMMING_OFF" };
+    const DIMMING_ON: number & { readonly __brand: "window.DIMMING_ON" };
+    const DIMMING_UNKNOWN: number & { readonly __brand: "window.DIMMING_UNKNOWN" };
+    const WINDOW_EVENT_DEICONIFIED: number & { readonly __brand: "window.WINDOW_EVENT_DEICONIFIED" };
+    const WINDOW_EVENT_FOCUS_GAINED: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_GAINED" };
+    const WINDOW_EVENT_FOCUS_LOST: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_LOST" };
+    const WINDOW_EVENT_ICONFIED: number & { readonly __brand: "window.WINDOW_EVENT_ICONFIED" };
+    const WINDOW_EVENT_RESIZED: number & { readonly __brand: "window.WINDOW_EVENT_RESIZED" };
+    function get_dim_mode(): Opaque<"constant">;
+    function get_display_scale(): number;
+    function get_mouse_lock(): boolean;
+    function get_safe_area(): { safe_area: { x: number; y: number; width: number; height: number; inset_left: number; inset_top: number; inset_right: number; inset_bottom: number } };
+    function get_size(): LuaMultiReturn<[number, number]>;
+    function set_dim_mode(mode: Opaque<"constant">): void;
+    function set_listener(callback?: (self: unknown, event: unknown, data: unknown) => void): void;
+    function set_mouse_lock(flag: boolean): void;
+    function set_position(x: number, y: number): void;
+    function set_size(width: number, height: number): void;
+    function set_title(title: string): void;
+  }
+}
+
+export {};

package/generated/zlib.d.ts

@@ -0,0 +1,9 @@
+/** @noSelfInFile */
+declare global {
+  namespace zlib {
+    function deflate(buf: string): string;
+    function inflate(buf: string): string;
+  }
+}
+
+export {};

package/index.d.ts

@@ -0,0 +1,63 @@
+import "./generated/builtin-messages";
+import "./src/msg-overloads";
+import "./src/go-overloads";
+import "./generated/b2d";
+import "./generated/buffer";
+import "./generated/camera";
+import "./generated/collectionfactory";
+import "./generated/collectionproxy";
+import "./generated/crash";
+import "./generated/factory";
+import "./generated/go";
+import "./generated/graphics";
+import "./generated/gui";
+import "./generated/http";
+import "./generated/iac";
+import "./generated/iap";
+import "./generated/image";
+import "./generated/json";
+import "./generated/label";
+import "./generated/liveupdate";
+import "./generated/model";
+import "./generated/msg";
+import "./generated/particlefx";
+import "./generated/physics";
+import "./generated/profiler";
+import "./generated/push";
+import "./generated/render";
+import "./generated/resource";
+import "./generated/socket";
+import "./generated/sound";
+import "./generated/sprite";
+import "./generated/sys";
+import "./generated/tilemap";
+import "./generated/timer";
+import "./generated/vmath";
+import "./generated/webview";
+import "./generated/window";
+import "./generated/zlib";
+
+export type { ApiFunction, ApiModule, ApiParameter, ApiVariable } from "./src/api-doc";
+export { parseDefoldApiDoc } from "./src/api-doc";
+export {
+  DEFOLD_TYPE_MAP,
+  type Hash,
+  type Matrix4,
+  type Quaternion,
+  type Url,
+  type Vector,
+  type Vector3,
+  type Vector4,
+} from "./src/core-types";
+export { type EmitOptions, emitDeclarations } from "./src/emit-dts";
+export {
+  defineGuiScript,
+  defineRenderScript,
+  defineScript,
+  type GuiScriptHooks,
+  type InputAction,
+  type InputTouch,
+  type RenderScriptHooks,
+  type ScriptHooks,
+} from "./src/lifecycle";
+export { type WrapOptions, wrapAsAmbientGlobal } from "./src/publish-dts";

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@defold-typescript/types",
+  "version": "0.1.0",
+  "description": "TypeScript types for the Defold engine's Lua APIs.",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./src/index.ts"
+    },
+    "./script": {
+      "types": "./generated/kinds/script.d.ts"
+    },
+    "./gui-script": {
+      "types": "./generated/kinds/gui-script.d.ts"
+    },
+    "./render-script": {
+      "types": "./generated/kinds/render-script.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "generated",
+    "scripts",
+    "api-targets.json",
+    "index.d.ts",
+    "!src/**/*.test.ts",
+    "!scripts/**/*.test.ts",
+    "!src/**/__snapshots__"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "regen": "bun scripts/regen.ts",
+    "sync-api-docs": "bun scripts/sync-api-docs.ts"
+  },
+  "devDependencies": {
+    "@typescript-to-lua/language-extensions": "1.19.0"
+  }
+}

package/scripts/doc-source.ts

@@ -0,0 +1,100 @@
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { readZip, refDocUrl, type ZipAccessor } from "./sync-api-docs";
+
+export type DocSourceProvenance = "cache" | "local" | "download";
+
+export interface ResolvedRefDoc {
+  zip: ZipAccessor;
+  zipPath: string;
+  provenance: DocSourceProvenance;
+}
+
+export type DownloadRefDoc = (version: string) => Promise<Uint8Array>;
+
+export type LocateLocalRefDoc = (version: string) => string | null;
+
+export function defaultDistributionRoots(
+  platform: NodeJS.Platform,
+  env: NodeJS.ProcessEnv = process.env,
+  home: () => string = homedir,
+): string[] {
+  switch (platform) {
+    case "darwin":
+      return ["/Applications/Defold", join(home(), "Applications", "Defold")];
+    case "linux":
+      return [join(home(), "Defold"), "/opt/Defold"];
+    case "win32":
+      return [env.LOCALAPPDATA, env.PROGRAMFILES]
+        .filter((root): root is string => Boolean(root))
+        .map((root) => join(root, "Defold"));
+    default:
+      return [];
+  }
+}
+
+export function localRefDocLocator(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform = process.platform,
+  home: () => string = homedir,
+): LocateLocalRefDoc {
+  const roots = [
+    ...(env.DEFOLD_TYPESCRIPT_LOCAL_DISTRIBUTION ? [env.DEFOLD_TYPESCRIPT_LOCAL_DISTRIBUTION] : []),
+    ...defaultDistributionRoots(platform, env, home),
+  ];
+  return (version) => {
+    for (const root of roots) {
+      const path = join(root, version, "ref-doc.zip");
+      if (existsSync(path)) {
+        return path;
+      }
+    }
+    return null;
+  };
+}
+
+export function refDocCacheDir(
+  env: NodeJS.ProcessEnv = process.env,
+  home: () => string = homedir,
+): string {
+  if (env.DEFOLD_TYPESCRIPT_CACHE) {
+    return join(env.DEFOLD_TYPESCRIPT_CACHE, "ref-doc");
+  }
+  return join(env.XDG_CACHE_HOME ?? join(home(), ".cache"), "defold-typescript", "ref-doc");
+}
+
+const fetchRefDoc: DownloadRefDoc = async (version) => {
+  const url = refDocUrl(version);
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`download failed: ${url} -> ${res.status} ${res.statusText}`);
+  }
+  return new Uint8Array(await res.arrayBuffer());
+};
+
+export async function resolveRefDoc(opts: {
+  version: string;
+  cacheDir: string;
+  download?: DownloadRefDoc;
+  locate?: LocateLocalRefDoc;
+  readZip?: typeof readZip;
+}): Promise<ResolvedRefDoc> {
+  const open = opts.readZip ?? readZip;
+  const zipPath = join(opts.cacheDir, opts.version, "ref-doc.zip");
+  if (existsSync(zipPath)) {
+    return { zip: open(zipPath), zipPath, provenance: "cache" };
+  }
+  const locate = opts.locate ?? localRefDocLocator();
+  const localPath = locate(opts.version);
+  if (localPath && existsSync(localPath)) {
+    mkdirSync(dirname(zipPath), { recursive: true });
+    copyFileSync(localPath, zipPath);
+    return { zip: open(zipPath), zipPath, provenance: "local" };
+  }
+  const download = opts.download ?? fetchRefDoc;
+  const bytes = await download(opts.version);
+  mkdirSync(dirname(zipPath), { recursive: true });
+  writeFileSync(zipPath, bytes);
+  return { zip: open(zipPath), zipPath, provenance: "download" };
+}