@defold-typescript/types 0.5.5 → 0.6.0

package/generated/particlefx.d.ts

@@ -2,6 +2,10 @@
 import type { Hash, Url, Vector4 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions and properties for controlling particle effect component playback and
+   * shader constants.
+   */
   namespace particlefx {
     /**
      * The emitter is not spawning any particles, but has particles that are still alive.
@@ -40,19 +44,21 @@ declare global {
      * - `particlefx.EMITTER_STATE_SPAWNING`
      * - `particlefx.EMITTER_STATE_POSTSPAWN`
      * @example
-     * ```lua
-     * How to play a particle fx when a game object is created.
-     * The callback receives the hash of the path to the particlefx, the hash of the id
-     * of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
-     * local function emitter_state_change(self, id, emitter, state)
-     *   if emitter == hash("exhaust") and state == particlefx.EMITTER_STATE_POSTSPAWN then
-     *     -- exhaust is done spawning particles...
-     *   end
-     * end
+     * ```ts
+     * // How to play a particle fx when a game object is created.
+     * // The callback receives the hash of the path to the particlefx, the hash of the id
+     * // of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
+     * function emitter_state_change(self, id, emitter, state) {
+     *   if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *     // exhaust is done spawning particles...
+     *   }
+     * }
      *
-     * function init(self)
-     *     particlefx.play("#particlefx", emitter_state_change)
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.play("#particlefx", emitter_state_change);
+     *   },
+     * });
      * ```
      */
     function play(url: string | Hash | Url, emitter_state_function?: (self: unknown, id: unknown, emitter: unknown, state: unknown) => void): void;
@@ -66,14 +72,18 @@ declare global {
      * @param emitter - the id of the emitter
      * @param constant - the name of the constant
      * @example
-     * ```lua
-     * The following examples assumes that the particle FX has id "particlefx", it
-     * contains an emitter with the id "emitter" and that the default-material in builtins is used, which defines the constant "tint".
-     * If you assign a custom material to the sprite, you can reset the constants defined there in the same manner.
-     * How to reset the tinting of particles from an emitter:
-     * function init(self)
-     *     particlefx.reset_constant("#particlefx", "emitter", "tint")
-     * end
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to reset the tinting of particles from an emitter:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.reset_constant("#particlefx", "emitter", "tint");
+     *   },
+     * });
      * ```
      */
     function reset_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash): void;
@@ -89,14 +99,18 @@ declare global {
      * @param constant - the name of the constant
      * @param value - the value of the constant
      * @example
-     * ```lua
-     * The following examples assumes that the particle FX has id "particlefx", it
-     * contains an emitter with the id "emitter" and that the default-material in builtins is used, which defines the constant "tint".
-     * If you assign a custom material to the sprite, you can reset the constants defined there in the same manner.
-     * How to tint particles from an emitter red:
-     * function init(self)
-     *     particlefx.set_constant("#particlefx", "emitter", "tint", vmath.vector4(1, 0, 0, 1))
-     * end
+     * ```ts
+     * // The following examples assume that the particle FX has id "particlefx", it
+     * // contains an emitter with the id "emitter" and that the default-material in
+     * // builtins is used, which defines the constant "tint".
+     * // If you assign a custom material to the sprite, you can reset the constants
+     * // defined there in the same manner.
+     * // How to tint particles from an emitter red:
+     * export default defineScript({
+     *   init(self) {
+     *     particlefx.set_constant("#particlefx", "emitter", "tint", vmath.vector4(1, 0, 0, 1));
+     *   },
+     * });
      * ```
      */
     function set_constant(url: string | Hash | Url, emitter: string | Hash, constant: string | Hash, value: Vector4): void;
@@ -109,12 +123,14 @@ declare global {
      * @param options - Options when stopping the particle fx. Supported options:
      * - boolean `clear`: instantly clear spawned particles
      * @example
-     * ```lua
-     * How to stop a particle fx when a game object is deleted and immediately also clear
-     * any spawned particles:
-     * function final(self)
-     *     particlefx.stop("#particlefx", { clear = true })
-     * end
+     * ```ts
+     * // How to stop a particle fx when a game object is deleted and immediately also
+     * // clear any spawned particles:
+     * export default defineScript({
+     *   final(self) {
+     *     particlefx.stop("#particlefx", { clear: true });
+     *   },
+     * });
      * ```
      */
     function stop(url: string | Hash | Url, options?: { clear?: boolean }): void;

package/generated/physics.d.ts

@@ -2,6 +2,11 @@
 import type { Hash, Url, Vector3 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions and messages for collision object physics interaction
+   * with other objects (collisions and ray-casting) and control of
+   * physical behaviors.
+   */
   namespace physics {
     /**
      * The following properties are available when connecting a joint of `JOINT_TYPE_FIXED` type:
@@ -62,13 +67,15 @@ declare global {
      *
      * @returns gravity vector of collection
      * @example
-     * ```lua
-     * function init(self)
-     *     local gravity = physics.get_gravity()
-     *     -- Inverse gravity!
-     *     gravity = -gravity
-     *     physics.set_gravity(gravity)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     let gravity = physics.get_gravity();
+     *     // Inverse gravity!
+     *     gravity = -gravity;
+     *     physics.set_gravity(gravity);
+     *   },
+     * });
      * ```
      */
     function get_gravity(): Vector3;
@@ -178,25 +185,27 @@ declare global {
      * boolean Set to `true` to return all ray cast hits. If `false`, it will only return the closest hit.
      * @returns It returns a list. If missed it returns `nil`. See ray_cast_response for details on the returned values.
      * @example
-     * ```lua
-     * How to perform a ray cast synchronously:
-     * function init(self)
-     *     self.groups = {hash("world"), hash("enemy")}
-     * end
+     * ```ts
+     * // How to perform a ray cast synchronously:
+     * export default defineScript({
+     *   init(self) {
+     *     self.groups = [hash("world"), hash("enemy")];
+     *   },
      *
-     * function update(self, dt)
-     *     -- request ray cast
-     *     local result = physics.raycast(from, to, self.groups, {all=true})
-     *     if result ~= nil then
-     *         -- act on the hit (see 'ray_cast_response')
-     *         for _,result in ipairs(results) do
-     *             handle_result(result)
-     *         end
-     *     end
-     * end
+     *   update(self, dt) {
+     *     // request ray cast
+     *     const result = physics.raycast(from, to, self.groups, { all: true });
+     *     if (result !== undefined) {
+     *       // act on the hit (see 'ray_cast_response')
+     *       for (const result of results) {
+     *         handle_result(result);
+     *       }
+     *     }
+     *   },
+     * });
      * ```
      */
-    function raycast(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, options?: { all?: boolean }): Record<string | number, unknown> | unknown;
+    function raycast(from: Vector3, to: Vector3, groups: Hash[], options?: { all?: boolean }): Record<string | number, unknown> | unknown;
     /**
      * Ray casts are used to test for intersections against collision objects in the physics world.
      * Collision objects of types kinematic, dynamic and static are tested against. Trigger objects
@@ -213,28 +222,30 @@ declare global {
      * @param groups - a lua table containing the hashed groups for which to test collisions against
      * @param request_id - a number in range [0,255]. It will be sent back in the response for identification, 0 by default
      * @example
-     * ```lua
-     * How to perform a ray cast asynchronously:
-     * function init(self)
-     *     self.my_groups = {hash("my_group1"), hash("my_group2")}
-     * end
+     * ```ts
+     * // How to perform a ray cast asynchronously:
+     * export default defineScript({
+     *   init(self) {
+     *     self.my_groups = [hash("my_group1"), hash("my_group2")];
+     *   },
      *
-     * function update(self, dt)
-     *     -- request ray cast
-     *     physics.raycast_async(my_start, my_end, self.my_groups)
-     * end
+     *   update(self, dt) {
+     *     // request ray cast
+     *     physics.raycast_async(my_start, my_end, self.my_groups);
+     *   },
      *
-     * function on_message(self, message_id, message, sender)
-     *     -- check for the response
-     *     if message_id == hash("ray_cast_response") then
-     *         -- act on the hit
-     *     elseif message_id == hash("ray_cast_missed") then
-     *         -- act on the miss
-     *     end
-     * end
+     *   on_message(self, message_id, message, sender) {
+     *     // check for the response
+     *     if (message_id === hash("ray_cast_response")) {
+     *       // act on the hit
+     *     } else if (message_id === hash("ray_cast_missed")) {
+     *       // act on the miss
+     *     }
+     *   },
+     * });
      * ```
      */
-    function raycast_async(from: Vector3, to: Vector3, groups: Record<string | number, unknown>, request_id?: number): void;
+    function raycast_async(from: Vector3, to: Vector3, groups: Hash[], request_id?: number): void;
     /**
      * Only one physics world event listener can be set at a time.
      *
@@ -251,82 +262,85 @@ declare global {
      * `data`
      * table The callback value data is a table that contains event-related data. See the documentation for details on the messages.
      * @example
-     * ```lua
-     * local function physics_world_listener(self, events)
-     *   for _,event in ipairs(events):
-     *       local event_type = event['type']
-     *       if event_type == hash("contact_point_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  distance = 2.1490633487701,
-     *           --  applied_impulse = 0
-     *           --  a = { --[[0x113f7c6c0]]
-     *           --    group = hash: [box],
-     *           --    id = hash: [/box]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(0.379, 0.925, -0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(480, 144, 0),
-     *           --    relative_velocity = vmath.vector3(-0, -0, -0),
-     *           --  },
-     *           --  b = { --[[0x113f7c840]]
-     *           --    group = hash: [circle],
-     *           --    id = hash: [/circle]
-     *           --    mass = 0,
-     *           --    normal = vmath.vector3(-0.379, -0.925, 0),
-     *           --    position = vmath.vector3(517.337, 235.068, 0),
-     *           --    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
-     *           --    relative_velocity = vmath.vector3(0, 0, 0),
-     *           --  },
-     *           -- }
-     *       elseif event == hash("collision_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  a = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(183, 666, 0),
-     *           --          id = hash: [/go1]
-     *           --      },
-     *           --  b = {
-     *           --          group = hash: [default],
-     *           --          position = vmath.vector3(185, 704.05865478516, 0),
-     *           --          id = hash: [/go2]
-     *           --      }
-     *           -- }
-     *       elseif event ==  hash("trigger_event") then
-     *           pprint(event)
-     *           -- {
-     *           --  enter = true,
-     *           --  b = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go2]
-     *           --  },
-     *           --  a = {
-     *           --      group = hash: [default],
-     *           --      id = hash: [/go1]
-     *           --  }
-     *           -- },
-     *       elseif event ==  hash("ray_cast_response") then
-     *           pprint(event)
-     *           --{
-     *           --  group = hash: [default],
-     *           --  request_id = 0,
-     *           --  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
-     *           --  fraction = 0.68759721517563,
-     *           --  normal = vmath.vector3(0, 1, 0),
-     *           --  id = hash: [/go]
-     *           -- }
-     *       elseif event ==  hash("ray_cast_missed") then
-     *           pprint(event)
-     *           -- {
-     *           --  request_id = 0
-     *           --},
-     *       end
-     * end
+     * ```ts
+     * function physics_world_listener(self, events) {
+     *   for (const event of events) {
+     *     const event_type = event["type"];
+     *     if (event_type === hash("contact_point_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  distance = 2.1490633487701,
+     *       //  applied_impulse = 0
+     *       //  a = { --[[0x113f7c6c0]]
+     *       //    group = hash: [box],
+     *       //    id = hash: [/box]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(0.379, 0.925, -0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(480, 144, 0),
+     *       //    relative_velocity = vmath.vector3(-0, -0, -0),
+     *       //  },
+     *       //  b = { --[[0x113f7c840]]
+     *       //    group = hash: [circle],
+     *       //    id = hash: [/circle]
+     *       //    mass = 0,
+     *       //    normal = vmath.vector3(-0.379, -0.925, 0),
+     *       //    position = vmath.vector3(517.337, 235.068, 0),
+     *       //    instance_position = vmath.vector3(-0.0021, 0, -0.0022),
+     *       //    relative_velocity = vmath.vector3(0, 0, 0),
+     *       //  },
+     *       // }
+     *     } else if (event === hash("collision_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  a = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(183, 666, 0),
+     *       //          id = hash: [/go1]
+     *       //      },
+     *       //  b = {
+     *       //          group = hash: [default],
+     *       //          position = vmath.vector3(185, 704.05865478516, 0),
+     *       //          id = hash: [/go2]
+     *       //      }
+     *       // }
+     *     } else if (event === hash("trigger_event")) {
+     *       pprint(event);
+     *       // {
+     *       //  enter = true,
+     *       //  b = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go2]
+     *       //  },
+     *       //  a = {
+     *       //      group = hash: [default],
+     *       //      id = hash: [/go1]
+     *       //  }
+     *       // },
+     *     } else if (event === hash("ray_cast_response")) {
+     *       pprint(event);
+     *       // {
+     *       //  group = hash: [default],
+     *       //  request_id = 0,
+     *       //  position = vmath.vector3(249.92222595215, 249.92222595215, 0),
+     *       //  fraction = 0.68759721517563,
+     *       //  normal = vmath.vector3(0, 1, 0),
+     *       //  id = hash: [/go]
+     *       // }
+     *     } else if (event === hash("ray_cast_missed")) {
+     *       pprint(event);
+     *       // {
+     *       //  request_id = 0
+     *       // },
+     *     }
+     *   }
+     * }
      *
-     * function init(self)
-     *     physics.set_event_listener(physics_world_listener)
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     physics.set_event_listener(physics_world_listener);
+     *   },
+     * });
      * ```
      */
     function set_event_listener(callback?: (self: unknown, events: unknown) => void): void;
@@ -337,11 +351,13 @@ declare global {
      *
      * @param gravity - the new gravity vector
      * @example
-     * ```lua
-     * function init(self)
-     *     -- Set "upside down" gravity for this collection.
-     *     physics.set_gravity(vmath.vector3(0, 10.0, 0))
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     // Set "upside down" gravity for this collection.
+     *     physics.set_gravity(vmath.vector3(0, 10.0, 0));
+     *   },
+     * });
      * ```
      */
     function set_gravity(gravity: Vector3): void;
@@ -364,11 +380,13 @@ declare global {
      * @param url - the collision object that should flip its shapes
      * @param flip - `true` if the collision object should flip its shapes, `false` if not
      * @example
-     * ```lua
-     * function init(self)
-     *     self.fliph = true -- set on some condition
-     *     physics.set_hflip("#collisionobject", self.fliph)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     self.fliph = true; // set on some condition
+     *     physics.set_hflip("#collisionobject", self.fliph);
+     *   },
+     * });
      * ```
      */
     function set_hflip(url: string | Hash | Url, flip: boolean): void;
@@ -432,11 +450,13 @@ declare global {
      * @param url - the collision object that should flip its shapes
      * @param flip - `true` if the collision object should flip its shapes, `false` if not
      * @example
-     * ```lua
-     * function init(self)
-     *     self.flipv = true -- set on some condition
-     *     physics.set_vflip("#collisionobject", self.flipv)
-     * end
+     * ```ts
+     * export default defineScript({
+     *   init(self) {
+     *     self.flipv = true; // set on some condition
+     *     physics.set_vflip("#collisionobject", self.flipv);
+     *   },
+     * });
      * ```
      */
     function set_vflip(url: string | Hash | Url, flip: boolean): void;
@@ -447,8 +467,8 @@ declare global {
      * @param collisionobject - the collision object whose mass needs to be updated.
      * @param mass - the new mass value to set for the collision object.
      * @example
-     * ```lua
-     *  physics.update_mass("#collisionobject", 14)
+     * ```ts
+     * physics.update_mass("#collisionobject", 14);
      * ```
      */
     function update_mass(collisionobject: string | Hash | Url, mass: number): void;

package/generated/profiler.d.ts

@@ -2,6 +2,10 @@
 import type { Opaque } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for getting profiling data in runtime.
+   * More detailed [profiling](https://www.defold.com/manuals/profiling/) and [debugging](http://www.defold.com/manuals/debugging/) information available in the manuals.
+   */
   namespace profiler {
     /**
      * pause on current frame
@@ -31,8 +35,8 @@ declare global {
      * logs the current frame to the console
      *
      * @example
-     * ```lua
-     * profiler.dump_frame()
+     * ```ts
+     * profiler.dump_frame();
      * ```
      */
     function dump_frame(): void;
@@ -43,9 +47,9 @@ declare global {
      *
      * @param enabled - true to enable, false to disable
      * @example
-     * ```lua
-     * -- Show the profiler UI
-     * profiler.enable(true)
+     * ```ts
+     * // Show the profiler UI
+     * profiler.enable(true);
      * ```
      */
     function enable(enabled: boolean): void;
@@ -57,9 +61,9 @@ declare global {
      *
      * @param enabled - true to enable, false to disable
      * @example
-     * ```lua
-     * -- Show the profiler UI
-     * profiler.enable_ui(true)
+     * ```ts
+     * // Show the profiler UI
+     * profiler.enable_ui(true);
      * ```
      */
     function enable_ui(enabled: boolean): void;
@@ -92,12 +96,12 @@ declare global {
      *
      * @returns used by the application
      * @example
-     * ```lua
-     * Get memory usage before and after loading a collection:
-     * print(profiler.get_memory_usage())
-     * msg.post("#collectionproxy", "load")
-     * ...
-     * print(profiler.get_memory_usage()) -- will report a higher number than the initial call
+     * ```ts
+     * // Get memory usage before and after loading a collection:
+     * print(profiler.get_memory_usage());
+     * msg.post("#collectionproxy", "load");
+     * // ...
+     * print(profiler.get_memory_usage()); // will report a higher number than the initial call
      * ```
      */
     function get_memory_usage(): number;
@@ -106,8 +110,8 @@ declare global {
      *
      * @param text - the string to send to the connected profiler
      * @example
-     * ```lua
-     * profiler.log_text("Event: " .. name)
+     * ```ts
+     * profiler.log_text(`Event: ${name}`);
      * ```
      */
     function log_text(text: string): void;
@@ -116,10 +120,10 @@ declare global {
      *
      * @returns the number of recorded frames, zero if on-screen profiler is disabled
      * @example
-     * ```lua
-     * -- Show the last recorded frame
-     * local recorded_frame_count = profiler.recorded_frame_count()
-     * profiler.view_recorded_frame(recorded_frame_count)
+     * ```ts
+     * // Show the last recorded frame
+     * const recorded_frame_count = profiler.recorded_frame_count();
+     * profiler.view_recorded_frame(recorded_frame_count);
      * ```
      */
     function recorded_frame_count(): number;
@@ -128,11 +132,11 @@ declare global {
      *
      * @param name - The name of the scope
      * @example
-     * ```lua
-     * -- Go back one frame
-     * profiler.scope_begin("test_function")
-     *   test_function()
-     * profiler.scope_end()
+     * ```ts
+     * // Go back one frame
+     * profiler.scope_begin("test_function");
+     * test_function();
+     * profiler.scope_end();
      * ```
      */
     function scope_begin(name: string): void;
@@ -152,14 +156,14 @@ declare global {
      * You can also use the `view_recorded_frame` function to display a recorded frame. Doing so stops the recording as well.
      * Every time you switch to recording mode the recording buffer is cleared.
      * @example
-     * ```lua
-     * function start_recording()
-     *      profiler.set_ui_mode(profiler.MODE_RECORD)
-     * end
+     * ```ts
+     * function start_recording() {
+     *   profiler.set_ui_mode(profiler.MODE_RECORD);
+     * }
      *
-     * function stop_recording()
-     *      profiler.set_ui_mode(profiler.MODE_PAUSE)
-     * end
+     * function stop_recording() {
+     *   profiler.set_ui_mode(profiler.MODE_PAUSE);
+     * }
      * ```
      */
     function set_ui_mode(mode: Opaque<"constant">): void;
@@ -170,9 +174,9 @@ declare global {
      * - `profiler.VIEW_MODE_FULL` The default mode which displays all the ui profiler details
      * - `profiler.VIEW_MODE_MINIMIZED` Minimized mode which only shows the top header (fps counters and ui profiler mode)
      * @example
-     * ```lua
-     * -- Minimize the profiler view
-     * profiler.set_ui_view_mode(profiler.VIEW_MODE_MINIMIZED)
+     * ```ts
+     * // Minimize the profiler view
+     * profiler.set_ui_view_mode(profiler.VIEW_MODE_MINIMIZED);
      * ```
      */
     function set_ui_view_mode(mode: Opaque<"constant">): void;
@@ -190,9 +194,9 @@ declare global {
      *
      * @param visible - true to include it in the display, false to hide it.
      * @example
-     * ```lua
-     * -- Exclude frame wait time form the profiler ui
-     * profiler.set_ui_vsync_wait_visible(false)
+     * ```ts
+     * // Exclude frame wait time from the profiler ui
+     * profiler.set_ui_vsync_wait_visible(false);
      * ```
      */
     function set_ui_vsync_wait_visible(visible: boolean): void;
@@ -204,9 +208,9 @@ declare global {
      * - `distance` The offset from the currently displayed frame (this is truncated between zero and the number of recorded frames)
      * - `frame` The frame index in the recording buffer (1 is first recorded frame)
      * @example
-     * ```lua
-     * -- Go back one frame
-     * profiler.view_recorded_frame({distance = -1})
+     * ```ts
+     * // Go back one frame
+     * profiler.view_recorded_frame({ distance: -1 });
      * ```
      */
     function view_recorded_frame(frame_index: Record<string | number, unknown>): void;