@defold-typescript/types 0.5.4 → 0.6.0

package/api-targets.json

@@ -27,7 +27,7 @@
           "namespace": "go",
           "fixture": "go_doc.json",
           "outFile": "go.d.ts",
-          "skipFunctions": ["get", "set"]
+          "skipFunctions": ["get", "set", "property"]
         },
         { "namespace": "graphics", "fixture": "graphics_doc.json", "outFile": "graphics.d.ts" },
         { "namespace": "gui", "fixture": "gui_doc.json", "outFile": "gui.d.ts" },

package/generated/b2d.d.ts

@@ -2,6 +2,9 @@
 import type { Hash, Opaque, Url } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for interacting with Box2D.
+   */
   namespace b2d {
     type b2Body = Opaque<"b2Body">;
     type b2World = Opaque<"b2World">;

package/generated/buffer.d.ts

@@ -2,6 +2,9 @@
 import type { Hash, Opaque } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for manipulating buffers and streams
+   */
   namespace buffer {
     /**
      * Float, single precision, 4 bytes
@@ -51,13 +54,13 @@ declare global {
      * @param srcoffset - the offset to start copying data from
      * @param count - the number of elements to copy
      * @example
-     * ```lua
-     * How to copy elements (e.g. vertices) from one buffer to another
-     * -- copy entire buffer
-     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, #srcbuffer)
+     * ```ts
+     * // How to copy elements (e.g. vertices) from one buffer to another
+     * // copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, srcbuffer.length);
      *
-     * -- copy last 10 elements to the front of another buffer
-     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, #srcbuffer - 10, 10)
+     * // copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, srcbuffer.length - 10, 10);
      * ```
      */
     function copy_buffer(dst: Opaque<"buffer">, dstoffset: number, src: Opaque<"buffer">, srcoffset: number, count: number): void;
@@ -72,12 +75,12 @@ declare global {
      * @param srcoffset - the offset to start copying data from (measured in value type)
      * @param count - the number of values to copy (measured in value type)
      * @example
-     * ```lua
-     * How to update a texture of a sprite:
-     * -- copy entire stream
-     * local srcstream = buffer.get_stream(srcbuffer, hash("xyz"))
-     * local dststream = buffer.get_stream(dstbuffer, hash("xyz"))
-     * buffer.copy_stream(dststream, 0, srcstream, 0, #srcstream)
+     * ```ts
+     * // How to update a texture of a sprite:
+     * // copy entire stream
+     * const srcstream = buffer.get_stream(srcbuffer, hash("xyz"));
+     * const dststream = buffer.get_stream(dstbuffer, hash("xyz"));
+     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length);
      * ```
      */
     function copy_stream(dst: Opaque<"bufferstream">, dstoffset: number, src: Opaque<"bufferstream">, srcoffset: number, count: number): void;
@@ -94,21 +97,24 @@ declare global {
      * - number `count`: The number of values each element should hold
      * @returns the new buffer
      * @example
-     * ```lua
-     * How to create and initialize a buffer
-     * function init(self)
-     *   local size = 128
-     *   self.image = buffer.create( size * size, { {name=hash("rgb"), type=buffer.VALUE_TYPE_UINT8, count=3 } })
-     *   self.imagestream = buffer.get_stream(self.image, hash("rgb"))
+     * ```ts
+     * // How to create and initialize a buffer
+     * export default defineScript({
+     *   init(self) {
+     *     const size = 128;
+     *     self.image = buffer.create(size * size, [{ name: hash("rgb"), type: buffer.VALUE_TYPE_UINT8, count: 3 }]);
+     *     self.imagestream = buffer.get_stream(self.image, hash("rgb"));
      *
-     *   for y=0,self.height-1 do
-     *      for x=0,self.width-1 do
-     *          local index = y * self.width * 3 + x * 3 + 1
-     *          self.imagestream[index + 0] = self.r
-     *          self.imagestream[index + 1] = self.g
-     *          self.imagestream[index + 2] = self.b
-     *      end
-     *   end
+     *     for (let y = 0; y < self.height; y++) {
+     *       for (let x = 0; x < self.width; x++) {
+     *         const index = y * self.width * 3 + x * 3;
+     *         self.imagestream[index + 0] = self.r;
+     *         self.imagestream[index + 1] = self.g;
+     *         self.imagestream[index + 2] = self.b;
+     *       }
+     *     }
+     *   },
+     * });
      * ```
      */
     function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; count?: number }): Opaque<"buffer">;
@@ -126,11 +132,11 @@ declare global {
      * @param buf - the buffer to get the metadata from
      * @param metadata_name - name of the metadata entry
      * @example
-     * ```lua
-     * How to get a metadata entry from a buffer
-     * -- retrieve a metadata entry named "somefloats" and its nomeric type
-     * local values, type = buffer.get_metadata(buf, hash("somefloats"))
-     * if metadata then print(#metadata.." values in 'somefloats'") end
+     * ```ts
+     * // How to get a metadata entry from a buffer
+     * // retrieve a metadata entry named "somefloats" and its numeric type
+     * const [values, type] = buffer.get_metadata(buf, hash("somefloats"));
+     * if (values) print(`${values.length} values in 'somefloats'`);
      * ```
      */
     function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | unknown, Opaque<"constant"> | unknown]>;
@@ -151,13 +157,13 @@ declare global {
      * @param values - actual metadata, an array of numeric values
      * @param value_type - type of values when stored
      * @example
-     * ```lua
-     * How to set a metadata entry on a buffer
-     * -- create a new metadata entry with three floats
-     * buffer.set_metadata(buf, hash("somefloats"), {1.5, 3.2, 7.9}, buffer.VALUE_TYPE_FLOAT32)
-     * -- ...
-     * -- update to a new set of values
-     * buffer.set_metadata(buf, hash("somefloats"), {-2.5, 10.0, 32.2}, buffer.VALUE_TYPE_FLOAT32)
+     * ```ts
+     * // How to set a metadata entry on a buffer
+     * // create a new metadata entry with three floats
+     * buffer.set_metadata(buf, hash("somefloats"), [1.5, 3.2, 7.9], buffer.VALUE_TYPE_FLOAT32);
+     * // ...
+     * // update to a new set of values
+     * buffer.set_metadata(buf, hash("somefloats"), [-2.5, 10.0, 32.2], buffer.VALUE_TYPE_FLOAT32);
      * ```
      */
     function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: Opaque<"constant">): void;

package/generated/builtin-messages.d.ts

@@ -19,7 +19,7 @@ declare global {
     load: Record<string, never>;
     model_animation_done: { animation_id: Hash; playback: number };
     play_animation: { id: Hash };
-    play_sound: { delay?: number; gain?: number; play_id?: number };
+    play_sound: { delay?: number; gain?: number; play_id?: number; start_time?: number; start_frame?: number };
     proxy_loaded: Record<string, never>;
     proxy_unloaded: Record<string, never>;
     ray_cast_missed: { group: Hash; request_id: number };

package/generated/camera.d.ts

@@ -1,5 +1,8 @@
 /** @noSelfInFile */
 declare global {
+  /**
+   * Functions for interacting with camera components.
+   */
   namespace camera {
   }
 }

package/generated/collectionfactory.d.ts

@@ -2,6 +2,10 @@
 import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for controlling collection factory components which are
+   * used to dynamically spawn collections into the runtime.
+   */
   namespace collectionfactory {
     /**
      * loaded
@@ -38,40 +42,43 @@ declare global {
      * @param scale - uniform scaling to apply to the newly spawned collection (must be greater than 0).
      * @returns a table mapping the id:s from the collection to the new instance id:s
      * @example
-     * ```lua
-     * How to spawn a collection of game objects:
-     * function init(self)
-     *   -- Spawn a small group of enemies.
-     *   local pos = vmath.vector3(100, 12.5, 0)
-     *   local rot = vmath.quat_rotation_z(math.pi / 2)
-     *   local scale = 0.5
-     *   local props = {}
-     *   props[hash("/enemy_leader")] = { health = 1000.0 }
-     *   props[hash("/enemy_1")] = { health = 200.0 }
-     *   props[hash("/enemy_2")] = { health = 400.0, color = hash("green") }
+     * ```ts
+     * // How to spawn a collection of game objects:
+     * export default defineScript({
+     *   init(self) {
+     *     // Spawn a small group of enemies.
+     *     const pos = vmath.vector3(100, 12.5, 0);
+     *     const rot = vmath.quat_rotation_z(Math.PI / 2);
+     *     const scale = 0.5;
+     *     const props = {
+     *       [hash("/enemy_leader")]: { health: 1000.0 },
+     *       [hash("/enemy_1")]: { health: 200.0 },
+     *       [hash("/enemy_2")]: { health: 400.0, color: hash("green") },
+     *     };
      *
-     *   local self.enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale)
-     *   -- enemy_ids now map to the spawned instance ids:
-     *   --
-     *   -- pprint(self.enemy_ids)
-     *   --
-     *   -- DEBUG:SCRIPT:
-     *   -- {
-     *   --   hash: [/enemy_leader] = hash: [/collection0/enemy_leader],
-     *   --   hash: [/enemy_1] = hash: [/collection0/enemy_1],
-     *   --   hash: [/enemy_2] = hash: [/collection0/enemy_2]
-     *   -- }
+     *     self.enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale);
+     *     // enemy_ids now map to the spawned instance ids:
+     *     //
+     *     // pprint(self.enemy_ids)
+     *     //
+     *     // DEBUG:SCRIPT:
+     *     // {
+     *     //   hash: [/enemy_leader] = hash: [/collection0/enemy_leader],
+     *     //   hash: [/enemy_1] = hash: [/collection0/enemy_1],
+     *     //   hash: [/enemy_2] = hash: [/collection0/enemy_2]
+     *     // }
      *
-     *   -- Send "attack" message to the leader. First look up its instance id.
-     *   local leader_id = self.enemy_ids[hash("/enemy_leader")]
-     *   msg.post(leader_id, "attack")
-     * end
+     *     // Send "attack" message to the leader. First look up its instance id.
+     *     const leader_id = self.enemy_ids[hash("/enemy_leader")];
+     *     msg.post(leader_id, "attack");
+     *   },
+     * });
      *
-     * How to delete a spawned collection:
-     * go.delete(self.enemy_ids)
+     * // How to delete a spawned collection:
+     * go.delete(self.enemy_ids);
      * ```
      */
-    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): Record<string | number, unknown>;
+    function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): LuaMap<Hash, Hash>;
     /**
      * This returns status of the collection factory.
      * Calling this function when the factory is not marked as dynamic loading always returns COMP_COLLECTION_FACTORY_STATUS_LOADED.
@@ -96,9 +103,9 @@ declare global {
      * `result`
      * boolean True if resource were loaded successfully
      * @example
-     * ```lua
-     * How to load resources of a collection factory prototype.
-     * collectionfactory.load("#factory", function(self, url, result) end)
+     * ```ts
+     * // How to load resources of a collection factory prototype.
+     * collectionfactory.load("#factory", (self, url, result) => {});
      * ```
      */
     function load(url?: string | Hash | Url, complete_function?: (self: unknown, url: unknown, result: unknown) => void): void;
@@ -109,11 +116,11 @@ declare global {
      * @param url - the collection factory component
      * @param prototype - the path to the new prototype, or `nil`
      * @example
-     * ```lua
-     * How to unload the previous prototypes resources, and then spawn a new collection
-     * collectionfactory.unload("#factory") -- unload the previous resources
-     * collectionfactory.set_prototype("#factory", "/main/levels/level1.collectionc")
-     * local ids = collectionfactory.create("#factory", go.get_world_position(), vmath.quat())
+     * ```ts
+     * // How to unload the previous prototype's resources, and then spawn a new collection:
+     * collectionfactory.unload("#factory"); // unload the previous resources
+     * collectionfactory.set_prototype("#factory", "/main/levels/level1.collectionc");
+     * const ids = collectionfactory.create("#factory", go.get_world_position(), vmath.quat());
      * ```
      */
     function set_prototype(url?: string | Hash | Url, prototype?: string): void;
@@ -123,9 +130,9 @@ declare global {
      *
      * @param url - the collection factory component to unload
      * @example
-     * ```lua
-     * How to unload resources of a collection factory prototype loaded with collectionfactory.load
-     * collectionfactory.unload("#factory")
+     * ```ts
+     * // How to unload resources of a collection factory prototype loaded with collectionfactory.load:
+     * collectionfactory.unload("#factory");
      * ```
      */
     function unload(url?: string | Hash | Url): void;

package/generated/collectionproxy.d.ts

@@ -2,6 +2,10 @@
 import type { Hash, Url } from "../src/core-types";
 
 declare global {
+  /**
+   * Messages for controlling and interacting with collection proxies
+   * which are used to dynamically load collections into the runtime.
+   */
   namespace collectionproxy {
     /**
      * It's impossible to change the collection if the collection is already loaded.
@@ -27,13 +31,13 @@ declare global {
      * @returns the resources, or an empty list if the
      * collection was not excluded.
      * @example
-     * ```lua
-     * local function print_resources(self, cproxy)
-     *     local resources = collectionproxy.get_resources(cproxy)
-     *     for _, v in ipairs(resources) do
-     *         print("Resource: " .. v)
-     *     end
-     * end
+     * ```ts
+     * function print_resources(self, cproxy) {
+     *   const resources = collectionproxy.get_resources(cproxy);
+     *   for (const v of resources) {
+     *     print(`Resource: ${v}`);
+     *   }
+     * }
      * ```
      */
     function get_resources(collectionproxy: Url): Record<string | number, unknown>;
@@ -46,17 +50,18 @@ declare global {
      * @param url - the collection proxy component
      * @param prototype - the path to the new collection, or `nil`
      * @example
-     * ```lua
-     * The example assume the script belongs to an instance with collection-proxy-component with id "proxy".
-     * local ok, error = collectionproxy.set_collection("/go#collectionproxy", "/LU/3.collectionc")
-     *  if ok then
-     *      print("The collection has been changed to /LU/3.collectionc")
-     *  else
-     *      print("Error changing collection to /LU/3.collectionc ", error)
-     *  end
-     *  msg.post("/go#collectionproxy", "load")
-     *  msg.post("/go#collectionproxy", "init")
-     *  msg.post("/go#collectionproxy", "enable")
+     * ```ts
+     * // The example assumes the script belongs to an instance with a
+     * // collection-proxy-component with id "proxy".
+     * const [ok, error] = collectionproxy.set_collection("/go#collectionproxy", "/LU/3.collectionc");
+     * if (ok) {
+     *   print("The collection has been changed to /LU/3.collectionc");
+     * } else {
+     *   print("Error changing collection to /LU/3.collectionc ", error);
+     * }
+     * msg.post("/go#collectionproxy", "load");
+     * msg.post("/go#collectionproxy", "init");
+     * msg.post("/go#collectionproxy", "enable");
      * ```
      */
     function set_collection(url?: string | Hash | Url, prototype?: string): LuaMultiReturn<[boolean, number]>;

package/generated/crash.d.ts

@@ -1,5 +1,8 @@
 /** @noSelfInFile */
 declare global {
+  /**
+   * Native crash logging functions and constants.
+   */
   namespace crash {
     /**
      * android build fingerprint

package/generated/factory.d.ts

@@ -2,6 +2,10 @@
 import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../src/core-types";
 
 declare global {
+  /**
+   * Functions for controlling factory components which are used to
+   * dynamically spawn game objects into the runtime.
+   */
   namespace factory {
     /**
      * loaded
@@ -30,21 +34,25 @@ declare global {
      * @param scale - the scale of the new game object (must be greater than 0), the scale of the game object containing the factory is used by default, or if the value is `nil`
      * @returns the global id of the spawned game object
      * @example
-     * ```lua
-     * How to create a new game object:
-     * function init(self)
-     *     -- create a new game object and provide property values
-     *     self.my_created_object = factory.create("#factory", nil, nil, {my_value = 1})
-     *     -- communicate with the object
-     *     msg.post(self.my_created_object, "hello")
-     * end
+     * ```ts
+     * // How to create a new game object:
+     * export default defineScript({
+     *   init(self) {
+     *     // create a new game object and provide property values
+     *     self.my_created_object = factory.create("#factory", undefined, undefined, { my_value: 1 });
+     *     // communicate with the object
+     *     msg.post(self.my_created_object, "hello");
+     *   },
+     * });
      *
-     * And then let the new game object have a script attached:
-     * go.property("my_value", 0)
+     * // And then let the new game object have a script attached:
+     * go.property("my_value", 0);
      *
-     * function init(self)
-     *     -- do something with self.my_value which is now one
-     * end
+     * export default defineScript({
+     *   init(self) {
+     *     // do something with self.my_value which is now one
+     *   },
+     * });
      * ```
      */
     function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): Hash;
@@ -73,9 +81,9 @@ declare global {
      * `result`
      * boolean True if resources were loaded successfully
      * @example
-     * ```lua
-     * How to load resources of a factory prototype.
-     * factory.load("#factory", function(self, url, result) end)
+     * ```ts
+     * // How to load resources of a factory prototype.
+     * factory.load("#factory", (self, url, result) => {});
      * ```
      */
     function load(url?: string | Hash | Url, complete_function?: (self: unknown, url: unknown, result: unknown) => void): void;
@@ -85,11 +93,11 @@ declare global {
      * @param url - the factory component
      * @param prototype - the path to the new prototype, or `nil`
      * @example
-     * ```lua
-     * How to unload the previous prototypes resources, and then spawn a new game object
-     * factory.unload("#factory") -- unload the previous resources
-     * factory.set_prototype("#factory", "/main/levels/enemyA.goc")
-     * local id = factory.create("#factory", go.get_world_position(), vmath.quat())
+     * ```ts
+     * // How to unload the previous prototype's resources, and then spawn a new game object:
+     * factory.unload("#factory"); // unload the previous resources
+     * factory.set_prototype("#factory", "/main/levels/enemyA.goc");
+     * const id = factory.create("#factory", go.get_world_position(), vmath.quat());
      * ```
      */
     function set_prototype(url?: string | Hash | Url, prototype?: string): void;
@@ -99,9 +107,9 @@ declare global {
      *
      * @param url - the factory component to unload
      * @example
-     * ```lua
-     * How to unload resources of a factory prototype loaded with factory.load
-     * factory.unload("#factory")
+     * ```ts
+     * // How to unload resources of a factory prototype loaded with factory.load:
+     * factory.unload("#factory");
      * ```
      */
     function unload(url?: string | Hash | Url): void;