@defold-typescript/types 0.18.2 → 0.18.4

package/api-targets.json

@@ -73,7 +73,12 @@
         { "namespace": "tilemap", "fixture": "tilemap_doc.json", "outFile": "tilemap.d.ts" },
         { "namespace": "timer", "fixture": "timer_doc.json", "outFile": "timer.d.ts" },
         { "namespace": "types", "fixture": "types_doc.json", "outFile": "types.d.ts" },
-        { "namespace": "vmath", "fixture": "vmath_doc.json", "outFile": "vmath.d.ts" },
+        {
+          "namespace": "vmath",
+          "fixture": "vmath_doc.json",
+          "outFile": "vmath.d.ts",
+          "skipFunctions": ["clamp", "lerp", "slerp", "mul_per_elem", "normalize"]
+        },
         { "namespace": "webview", "fixture": "webview_doc.json", "outFile": "webview.d.ts" },
         { "namespace": "window", "fixture": "window_doc.json", "outFile": "window.d.ts" },
         { "namespace": "zlib", "fixture": "zlib_doc.json", "outFile": "zlib.d.ts" }

package/generated/kinds/gui-script.d.ts

@@ -41,6 +41,7 @@ import "../../src/engine-globals";
 import "../../src/go-overloads";
 import "../../src/message-guard";
 import "../../src/msg-overloads";
+import "../../src/vmath-overloads";
 import "../../src/window-event-guard";
 import "../builtin-messages";
 import "../gui";

package/generated/kinds/render-script.d.ts

@@ -41,6 +41,7 @@ import "../../src/engine-globals";
 import "../../src/go-overloads";
 import "../../src/message-guard";
 import "../../src/msg-overloads";
+import "../../src/vmath-overloads";
 import "../../src/window-event-guard";
 import "../builtin-messages";
 import "../render";

package/generated/kinds/script.d.ts

@@ -41,6 +41,7 @@ import "../../src/engine-globals";
 import "../../src/go-overloads";
 import "../../src/message-guard";
 import "../../src/msg-overloads";
+import "../../src/vmath-overloads";
 import "../../src/window-event-guard";
 import "../builtin-messages";
 

package/generated/vmath.d.ts

@@ -32,29 +32,6 @@ declare global {
    * : indexed by number 1 to the vector length. Example: `v[3]`
    */
   namespace vmath {
-    /**
-     * Clamp input value to be in range of [min, max]. In case if input value has vector3|vector4 type
-     * return new vector3|vector4 with clamped value at every vector's element.
-     * Min/max arguments can be vector3|vector4. In that case clamp excuted per every vector's element
-     *
-     * @param value - Input value or vector of values
-     * @param min - Min value(s) border
-     * @param max - Max value(s) border
-     * @returns Clamped value or vector
-     * @example
-     * ```ts
-     * const value1 = 56;
-     * print(vmath.clamp(value1, 89, 134)); // => 89
-     * const v2 = vmath.vector3(190, 190, -10);
-     * print(vmath.clamp(v2, -50, 150)); // => vmath.vector3(150, 150, -10)
-     * const v3 = vmath.vector4(30, -30, 45, 1);
-     * print(vmath.clamp(v3, 0, 20)); // => vmath.vector4(20, 0, 20, 1)
-     *
-     * const min_v = vmath.vector4(0, -10, -10, 1);
-     * print(vmath.clamp(v3, min_v, 20)); // => vmath.vector4(20, -10, 20, 1)
-     * ```
-     */
-    function clamp(value: number | Vector3 | Vector4, min: number | Vector3 | Vector4, max: number | Vector3 | Vector4): number | Vector3 | Vector4;
     /**
      * Calculates the conjugate of a quaternion. The result is a
      * quaternion with the same magnitudes but with the sign of
@@ -185,97 +162,6 @@ declare global {
      * ```
      */
     function length_sqr(v: Vector3 | Vector4 | Quaternion): number;
-    /**
-     * Linearly interpolate between two vectors. The function
-     * treats the vectors as positions and interpolates between
-     * the positions in a straight line. Lerp is useful to describe
-     * transitions from one place to another over time.
-     * The function does not clamp t between 0 and 1.
-     *
-     * @param t - interpolation parameter, 0-1
-     * @param v1 - vector to lerp from
-     * @param v2 - vector to lerp to
-     * @returns the lerped vector
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init() {
-     *     return { t: 0 };
-     *   },
-     *
-     *   update(self, dt) {
-     *     self.t = self.t + dt;
-     *     if (self.t <= 1) {
-     *       const startpos = vmath.vector3(0, 600, 0);
-     *       const endpos = vmath.vector3(600, 0, 0);
-     *       const pos = vmath.lerp(self.t, startpos, endpos);
-     *       go.set_position(pos, "go");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function lerp(t: number, v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
-    /**
-     * Linearly interpolate between two quaternions. Linear
-     * interpolation of rotations are only useful for small
-     * rotations. For interpolations of arbitrary rotations,
-     * vmath.slerp yields much better results.
-     * The function does not clamp t between 0 and 1.
-     *
-     * @param t - interpolation parameter, 0-1
-     * @param q1 - quaternion to lerp from
-     * @param q2 - quaternion to lerp to
-     * @returns the lerped quaternion
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init(self) {
-     *     self.t = 0;
-     *   },
-     *
-     *   update(self, dt) {
-     *     self.t = self.t + dt;
-     *     if (self.t <= 1) {
-     *       const startrot = vmath.quat_rotation_z(0);
-     *       const endrot = vmath.quat_rotation_z(3.141592653);
-     *       const rot = vmath.lerp(self.t, startrot, endrot);
-     *       go.set_rotation(rot, "go");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function lerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
-    /**
-     * Linearly interpolate between two values. Lerp is useful
-     * to describe transitions from one value to another over time.
-     * The function does not clamp t between 0 and 1.
-     *
-     * @param t - interpolation parameter, 0-1
-     * @param n1 - number to lerp from
-     * @param n2 - number to lerp to
-     * @returns the lerped number
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init(self) {
-     *     self.t = 0;
-     *   },
-     *
-     *   update(self, dt) {
-     *     self.t = self.t + dt;
-     *     if (self.t <= 1) {
-     *       const startx = 0;
-     *       const endx = 600;
-     *       const x = vmath.lerp(self.t, startx, endx);
-     *       go.set_position(vmath.vector3(x, 100, 0), "go");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function lerp(t: number, n1: number, n2: number): number;
     /**
      * The resulting identity matrix describes a transform with
      * no translation or rotation.
@@ -541,37 +427,6 @@ declare global {
      * ```
      */
     function matrix4_translation(position: Vector3 | Vector4): Matrix4;
-    /**
-     * Performs an element wise multiplication between two vectors of the same type
-     * The returned value is a vector defined as (e.g. for a vector3):
-     * `v = vmath.mul_per_elem(a, b) = vmath.vector3(a.x * b.x, a.y * b.y, a.z * b.z)`
-     *
-     * @param v1 - first vector
-     * @param v2 - second vector
-     * @returns multiplied vector
-     * @example
-     * ```ts
-     * const blend_color = vmath.mul_per_elem(color1, color2);
-     * ```
-     */
-    function mul_per_elem(v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
-    /**
-     * Normalizes a vector, i.e. returns a new vector with the same
-     * direction as the input vector, but with length 1.
-     * The length of the vector must be above 0, otherwise a
-     * division-by-zero will occur.
-     *
-     * @param v1 - vector to normalize
-     * @returns new normalized vector
-     * @example
-     * ```ts
-     * const vec = vmath.vector3(1, 2, 3);
-     * const norm_vec = vmath.normalize(vec);
-     * print(norm_vec); // => vmath.vector3(0.26726123690605, 0.5345224738121, 0.80178368091583)
-     * print(vmath.length(norm_vec)); // => 0.99999994039536
-     * ```
-     */
-    function normalize(v1: Vector3 | Vector4 | Quaternion): Vector3 | Vector4 | Quaternion;
     /**
      * The resulting matrix is the inverse of the supplied matrix.
      * The supplied matrix has to be an ortho-normal matrix, e.g.
@@ -799,73 +654,6 @@ declare global {
      * ```
      */
     function rotate(q: Quaternion, v1: Vector3): Vector3;
-    /**
-     * Spherically interpolates between two vectors. The difference to
-     * lerp is that slerp treats the vectors as directions instead of
-     * positions in space.
-     * The direction of the returned vector is interpolated by the angle
-     * and the magnitude is interpolated between the magnitudes of the
-     * from and to vectors.
-     * Slerp is computationally more expensive than lerp.
-     * The function does not clamp t between 0 and 1.
-     *
-     * @param t - interpolation parameter, 0-1
-     * @param v1 - vector to slerp from
-     * @param v2 - vector to slerp to
-     * @returns the slerped vector
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init() {
-     *     return { t: 0 };
-     *   },
-     *
-     *   update(self, dt) {
-     *     self.t = self.t + dt;
-     *     if (self.t <= 1) {
-     *       const startpos = vmath.vector3(0, 600, 0);
-     *       const endpos = vmath.vector3(600, 0, 0);
-     *       const pos = vmath.slerp(self.t, startpos, endpos);
-     *       go.set_position(pos, "go");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function slerp(t: number, v1: Vector3 | Vector4, v2: Vector3 | Vector4): Vector3 | Vector4;
-    /**
-     * Slerp travels the torque-minimal path maintaining constant
-     * velocity, which means it travels along the straightest path along
-     * the rounded surface of a sphere. Slerp is useful for interpolation
-     * of rotations.
-     * Slerp travels the torque-minimal path, which means it travels
-     * along the straightest path the rounded surface of a sphere.
-     * The function does not clamp t between 0 and 1.
-     *
-     * @param t - interpolation parameter, 0-1
-     * @param q1 - quaternion to slerp from
-     * @param q2 - quaternion to slerp to
-     * @returns the slerped quaternion
-     * @example
-     * ```ts
-     * export default defineScript({
-     *   init(self) {
-     *     self.t = 0;
-     *   },
-     *
-     *   update(self, dt) {
-     *     self.t = self.t + dt;
-     *     if (self.t <= 1) {
-     *       const startrot = vmath.quat_rotation_z(0);
-     *       const endrot = vmath.quat_rotation_z(3.141592653);
-     *       const rot = vmath.slerp(self.t, startrot, endrot);
-     *       go.set_rotation(rot, "go");
-     *     }
-     *   },
-     * });
-     * ```
-     */
-    function slerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
     /**
      * Creates a vector of arbitrary size. The vector is initialized
      * with numeric values from a table.

package/index.d.ts

@@ -42,6 +42,7 @@ import "./generated/tilemap";
 import "./generated/timer";
 import "./generated/types";
 import "./generated/vmath";
+import "./src/vmath-overloads";
 import "./generated/webview";
 import "./generated/window";
 import "./generated/zlib";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.18.2",
+  "version": "0.18.4",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {

package/scripts/regen.ts

@@ -244,6 +244,7 @@ const UNIVERSAL_EXTRA_IMPORTS: readonly string[] = [
   "../../src/message-guard",
   "../../src/window-event-guard",
   "../../src/go-overloads",
+  "../../src/vmath-overloads",
 ];
 
 export interface KindManifestEntry {

package/scripts/signature-store-fs.ts

@@ -21,6 +21,7 @@ export const DEBUG_SIGNATURES_PATH = resolve(import.meta.dir, "..", "signatures"
 export const PACKAGE_SIGNATURES_PATH = resolve(import.meta.dir, "..", "signatures", "package.json");
 export const BASE_SIGNATURES_PATH = resolve(import.meta.dir, "..", "signatures", "base.json");
 export const SOCKET_SIGNATURES_PATH = resolve(import.meta.dir, "..", "signatures", "socket.json");
+export const VMATH_SIGNATURES_PATH = resolve(import.meta.dir, "..", "signatures", "vmath.json");
 
 export function loadSignatureFile(path: string): SignatureStore {
   let raw: string;

package/src/emit-dts.ts

@@ -167,6 +167,12 @@ export const OVERLOAD_COVERED_SKIPS = new Set([
   // msg-overloads.d.ts supplies the typed msg.url shape (0 / 1-string / 3-arg
   // arities; the runtime-invalid two-arg form is intentionally omitted).
   "msg.url",
+  // vmath-overloads.d.ts supplies the generic covariant signatures.
+  "vmath.clamp",
+  "vmath.lerp",
+  "vmath.slerp",
+  "vmath.mul_per_elem",
+  "vmath.normalize",
 ]);
 
 // Element names whose `table` slot is a prose-only `a table mapping X to Y`

package/src/vmath-overloads.d.ts

@@ -0,0 +1,109 @@
+/** @noSelfInFile */
+
+import type { Quaternion, Vector3, Vector4 } from "./core-types";
+
+declare global {
+  namespace vmath {
+    /**
+     * Clamp input value to be in range of [min, max]. In case if input value has vector3|vector4 type
+     * return new vector3|vector4 with clamped value at every vector's element.
+     * Min/max arguments can be vector3|vector4. In that case clamp excuted per every vector's element
+     *
+     * @param value - Input value or vector of values
+     * @param min - Min value(s) border
+     * @param max - Max value(s) border
+     * @returns Clamped value or vector
+     */
+    function clamp<T extends number | Vector3 | Vector4>(
+      value: T,
+      min: number | T,
+      max: number | T,
+    ): T;
+    /**
+     * Linearly interpolate between two vectors. The function
+     * treats the vectors as positions and interpolates between
+     * the positions in a straight line. Lerp is useful to describe
+     * transitions from one place to another over time.
+     * The function does not clamp t between 0 and 1.
+     *
+     * @param t - interpolation parameter, 0-1
+     * @param v1 - vector to lerp from
+     * @param v2 - vector to lerp to
+     * @returns the lerped vector
+     */
+    function lerp<T extends Vector3 | Vector4>(t: number, v1: T, v2: T): T;
+    /**
+     * Linearly interpolate between two quaternions. Linear
+     * interpolation of rotations are only useful for small
+     * rotations. For interpolations of arbitrary rotations,
+     * vmath.slerp yields much better results.
+     * The function does not clamp t between 0 and 1.
+     *
+     * @param t - interpolation parameter, 0-1
+     * @param q1 - quaternion to lerp from
+     * @param q2 - quaternion to lerp to
+     * @returns the lerped quaternion
+     */
+    function lerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
+    /**
+     * Linearly interpolate between two values. Lerp is useful
+     * to describe transitions from one value to another over time.
+     * The function does not clamp t between 0 and 1.
+     *
+     * @param t - interpolation parameter, 0-1
+     * @param n1 - number to lerp from
+     * @param n2 - number to lerp to
+     * @returns the lerped number
+     */
+    function lerp(t: number, n1: number, n2: number): number;
+    /**
+     * Performs an element wise multiplication between two vectors of the same type
+     * The returned value is a vector defined as (e.g. for a vector3):
+     * `v = vmath.mul_per_elem(a, b) = vmath.vector3(a.x * b.x, a.y * b.y, a.z * b.z)`
+     *
+     * @param v1 - first vector
+     * @param v2 - second vector
+     * @returns multiplied vector
+     */
+    function mul_per_elem<T extends Vector3 | Vector4>(v1: T, v2: T): T;
+    /**
+     * Normalizes a vector, i.e. returns a new vector with the same
+     * direction as the input vector, but with length 1.
+     * The length of the vector must be above 0, otherwise a
+     * division-by-zero will occur.
+     *
+     * @param v1 - vector to normalize
+     * @returns new normalized vector
+     */
+    function normalize<T extends Vector3 | Vector4 | Quaternion>(v1: T): T;
+    /**
+     * Spherically interpolates between two vectors. The difference to
+     * lerp is that slerp treats the vectors as directions instead of
+     * positions in space.
+     * The direction of the returned vector is interpolated by the angle
+     * and the magnitude is interpolated between the magnitudes of the
+     * from and to vectors.
+     * Slerp is computationally more expensive than lerp.
+     * The function does not clamp t between 0 and 1.
+     *
+     * @param t - interpolation parameter, 0-1
+     * @param v1 - vector to slerp from
+     * @param v2 - vector to slerp to
+     * @returns the slerped vector
+     */
+    function slerp<T extends Vector3 | Vector4>(t: number, v1: T, v2: T): T;
+    /**
+     * Slerp travels the torque-minimal path maintaining constant
+     * velocity, which means it travels along the straightest path along
+     * the rounded surface of a sphere. Slerp is useful for interpolation
+     * of rotations.
+     * The function does not clamp t between 0 and 1.
+     *
+     * @param t - interpolation parameter, 0-1
+     * @param q1 - quaternion to slerp from
+     * @param q2 - quaternion to slerp to
+     * @returns the slerped quaternion
+     */
+    function slerp(t: number, q1: Quaternion, q2: Quaternion): Quaternion;
+  }
+}