@defold-typescript/types 0.19.4 → 0.20.0

package/generated/versions/defold-1.12.4/webview.d.ts

@@ -0,0 +1,68 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions and constants for interacting with webview APIs
+   */
+  namespace webview {
+    /**
+     * Creates a webview instance. It can show HTML pages as well as evaluate Javascript. The view remains hidden until the first call. There can exist a maximum of 4 webviews at the same time.
+     * On iOS, the callback will never get a `webview.CALLBACK_RESULT_EVAL_ERROR`, due to the iOS SDK implementation."
+     *
+     * @param callback - A callback which receives info about finished requests taking the following parameters:
+     */
+    function create(callback: (...args: unknown[]) => unknown): void;
+    /**
+     * Destroys an instance of a webview.
+     *
+     * @param webview_id - The webview id (returned by the `webview.create()` call)
+     */
+    function destroy(webview_id: number): void;
+    /**
+     * Evaluates JavaScript within the context of the currently loaded page (if any). Once the request is done, the callback (registered in `webview.create()`) is invoked. The callback will get the result in the `data["result"]` field.
+     *
+     * @param webview_id - The webview id
+     * @param code - The JavaScript code to evaluate
+     */
+    function eval(webview_id: number, code: string): void;
+    /**
+     * Returns the visibility state of the webview.
+     *
+     * @param webview_id - The webview id
+     */
+    function is_visible(webview_id: number): void;
+    /**
+     * Opens a web page in the webview, using HTML data. Once the request is done, the callback (registered in `webview.create()`) is invoked.
+     *
+     * @param webview_id - The webview id
+     * @param html - The HTML data to display
+     * @param options - A table of options for the request. See `webview.open()`
+     */
+    function open_raw(webview_id: number, html: string, options: Record<string | number, unknown>): void;
+    /**
+     * Sets the position and size of the webview
+     *
+     * @param webview_id - The webview id
+     * @param x - The x position of the webview
+     * @param y - The y position of the webview
+     * @param width - The width of the webview (-1 to match screen width)
+     * @param height - The height of the webview (-1 to match screen height)
+     */
+    function set_position(webview_id: number, x: number, y: number, width: number, height: number): void;
+    /**
+     * Set transparency of webview background
+     *
+     * @param webview_id - The webview id
+     * @param transparent - If `true`, the webview background becomes transparent, otherwise opaque.
+     */
+    function set_transparent(webview_id: number, transparent: boolean): void;
+    /**
+     * Shows or hides a webview
+     *
+     * @param webview_id - The webview id
+     * @param visible - If `0`, hides the webview. If non zero, shows the view
+     */
+    function set_visible(webview_id: number, visible: number): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/window.d.ts

@@ -0,0 +1,198 @@
+/** @noSelfInFile */
+import type { Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions and constants to access the window, window event listeners
+   * and screen dimming.
+   */
+  namespace window {
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     */
+    const DIMMING_OFF: number & { readonly __brand: "window.DIMMING_OFF" };
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     */
+    const DIMMING_ON: number & { readonly __brand: "window.DIMMING_ON" };
+    /**
+     * Dimming mode is used to control whether or not a mobile device should dim the screen after a period without user interaction.
+     * This mode indicates that the dim mode can't be determined, or that the platform doesn't support dimming.
+     */
+    const DIMMING_UNKNOWN: number & { readonly __brand: "window.DIMMING_UNKNOWN" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is
+     * restored after being iconified.
+     */
+    const WINDOW_EVENT_DEICONIFIED: number & { readonly __brand: "window.WINDOW_EVENT_DEICONIFIED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen has
+     * gained focus.
+     * This event is also sent at game startup and the engine gives focus to the game.
+     */
+    const WINDOW_EVENT_FOCUS_GAINED: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_GAINED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen has lost focus.
+     */
+    const WINDOW_EVENT_FOCUS_LOST: number & { readonly __brand: "window.WINDOW_EVENT_FOCUS_LOST" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is
+     * iconified (reduced to an application icon in a toolbar, application tray or similar).
+     */
+    const WINDOW_EVENT_ICONFIED: number & { readonly __brand: "window.WINDOW_EVENT_ICONFIED" };
+    /**
+     * This event is sent to a window event listener when the game window or app screen is resized.
+     * The new size is passed along in the data field to the event listener.
+     */
+    const WINDOW_EVENT_RESIZED: number & { readonly __brand: "window.WINDOW_EVENT_RESIZED" };
+    /**
+     * Returns the current dimming mode set on a mobile device.
+     * The dimming mode specifies whether or not a mobile device should dim the screen after a period without user interaction.
+     * On platforms that does not support dimming, `window.DIMMING_UNKNOWN` is always returned.
+     *
+     * @returns The mode for screen dimming
+     *
+     * - `window.DIMMING_UNKNOWN`
+     *
+     * - `window.DIMMING_ON`
+     *
+     * - `window.DIMMING_OFF`
+     */
+    function get_dim_mode(): Opaque<"constant">;
+    /**
+     * This returns the content scale of the current display.
+     *
+     * @returns The display scale
+     */
+    function get_display_scale(): number;
+    /**
+     * This returns the current lock state of the mouse cursor
+     *
+     * @returns The lock state
+     */
+    function get_mouse_lock(): boolean;
+    /**
+     * This returns the safe area rectangle (x, y, width, height) and the inset
+     * values relative to the window edges. On platforms without a safe area,
+     * this returns the full window size and zero insets.
+     *
+     * @returns safe area data
+     *
+     * `safe_area`
+     * table table containing these keys:
+     *
+     * - number `x`
+     *
+     * - number `y`
+     *
+     * - number `width`
+     *
+     * - number `height`
+     *
+     * - number `inset_left`
+     *
+     * - number `inset_top`
+     *
+     * - number `inset_right`
+     *
+     * - number `inset_bottom`
+     */
+    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 } };
+    /**
+     * This returns the current window size (width and height).
+     */
+    function get_size(): LuaMultiReturn<[number, number]>;
+    /**
+     * Sets the dimming mode on a mobile device.
+     * The dimming mode specifies whether or not a mobile device should dim the screen after a period without user interaction. The dimming mode will only affect the mobile device while the game is in focus on the device, but not when the game is running in the background.
+     * This function has no effect on platforms that does not support dimming.
+     *
+     * @param mode - The mode for screen dimming
+     *
+     * - `window.DIMMING_ON`
+     *
+     * - `window.DIMMING_OFF`
+     */
+    function set_dim_mode(mode: Opaque<"constant">): void;
+    /**
+     * Sets a window event listener. Only one window event listener can be set at a time.
+     *
+     * @param callback - A callback which receives info about window events. Pass an empty function or `nil` if you no longer wish to receive callbacks.
+     *
+     * `self`
+     * object The calling script
+     * `event`
+     * constant The type of event. Can be one of these:
+     *
+     * - `window.WINDOW_EVENT_FOCUS_LOST`
+     *
+     * - `window.WINDOW_EVENT_FOCUS_GAINED`
+     *
+     * - `window.WINDOW_EVENT_RESIZED`
+     *
+     * - `window.WINDOW_EVENT_ICONIFIED`
+     *
+     * - `window.WINDOW_EVENT_DEICONIFIED`
+     *
+     * `data`
+     * table The callback value `data` is a table which currently holds these values
+     *
+     * - number `width`: The width of a resize event. nil otherwise.
+     *
+     * - number `height`: The height of a resize event. nil otherwise.
+     * @example
+     * ```ts
+     * function window_callback(self, event, data) {
+     *   if (event === window.WINDOW_EVENT_FOCUS_LOST) {
+     *     print("window.WINDOW_EVENT_FOCUS_LOST");
+     *   } else if (event === window.WINDOW_EVENT_FOCUS_GAINED) {
+     *     print("window.WINDOW_EVENT_FOCUS_GAINED");
+     *   } else if (event === window.WINDOW_EVENT_ICONFIED) {
+     *     print("window.WINDOW_EVENT_ICONFIED");
+     *   } else if (event === window.WINDOW_EVENT_DEICONIFIED) {
+     *     print("window.WINDOW_EVENT_DEICONIFIED");
+     *   } else if (event === window.WINDOW_EVENT_RESIZED) {
+     *     print("Window resized: ", data.width, data.height);
+     *   }
+     * }
+     *
+     * export default defineScript({
+     *   init() {
+     *     window.set_listener(window_callback);
+     *   },
+     * });
+     * ```
+     */
+    function set_listener(callback?: (self: unknown, event: typeof WINDOW_EVENT_FOCUS_LOST | typeof WINDOW_EVENT_FOCUS_GAINED | typeof WINDOW_EVENT_RESIZED | typeof WINDOW_EVENT_ICONFIED | typeof WINDOW_EVENT_DEICONIFIED, data: Record<string | number, unknown>) => void): void;
+    /**
+     * Set the locking state for current mouse cursor on a PC platform.
+     * This function locks or unlocks the mouse cursor to the center point of the window. While the cursor is locked,
+     * mouse position updates will still be sent to the scripts as usual.
+     *
+     * @param flag - The lock state for the mouse cursor
+     */
+    function set_mouse_lock(flag: boolean): void;
+    /**
+     * Sets the window position.
+     *
+     * @param x - Horizontal position of window
+     * @param y - Vertical position of window
+     */
+    function set_position(x: number, y: number): void;
+    /**
+     * Sets the window size. Works on desktop platforms only.
+     *
+     * @param width - Width of window
+     * @param height - Height of window
+     */
+    function set_size(width: number, height: number): void;
+    /**
+     * Sets the window title. Works on desktop platforms.
+     *
+     * @param title - The title, encoded as UTF-8
+     */
+    function set_title(title: string): void;
+  }
+}
+
+export {};

package/generated/versions/defold-1.12.4/zlib.d.ts

@@ -0,0 +1,40 @@
+/** @noSelfInFile */
+declare global {
+  /**
+   * Functions for compression and decompression of string buffers.
+   */
+  namespace zlib {
+    /**
+     * A lua error is raised is on error
+     *
+     * @param buf - buffer to deflate
+     * @returns deflated buffer
+     * @example
+     * ```ts
+     * const data = "This is a string with uncompressed data.";
+     * const compressed_data = zlib.deflate(data);
+     * let s = "";
+     * for (const c of compressed_data) {
+     *   s = s + "\\" + c.charCodeAt(0);
+     * }
+     * print(s); //> \120\94\11\201\200\44\86\0\162\68\133\226\146\162 ...
+     * ```
+     */
+    function deflate(buf: string): string;
+    /**
+     * A lua error is raised is on error
+     *
+     * @param buf - buffer to inflate
+     * @returns inflated buffer
+     * @example
+     * ```ts
+     * const data = "\120\94\11\201\200\44\86\0\162\68\133\226\146\162\204\188\116\133\242\204\146\12\133\210\188\228\252\220\130\162\212\226\226\212\20\133\148\196\146\68\61\0\44\67\14\201";
+     * const uncompressed_data = zlib.inflate(data);
+     * print(uncompressed_data); //> This is a string with uncompressed data.
+     * ```
+     */
+    function inflate(buf: string): string;
+  }
+}
+
+export {};

package/index.d.ts

@@ -7,10 +7,17 @@ import "./src/window-event-guard";
 import "./src/message-dispatch";
 import "./src/engine-globals";
 import "./generated/b2d";
+import "./generated/b2d_body";
+import "./generated/b2d_chain";
+import "./generated/b2d_fixture";
+import "./generated/b2d_joint";
+import "./generated/b2d_shape";
+import "./generated/b2d_world";
 import "./generated/buffer";
 import "./generated/camera";
 import "./generated/collectionfactory";
 import "./generated/collectionproxy";
+import "./generated/compute";
 import "./generated/crash";
 import "./generated/factory";
 import "./generated/go";
@@ -25,6 +32,7 @@ import "./generated/image";
 import "./generated/json";
 import "./generated/label";
 import "./generated/liveupdate";
+import "./generated/material";
 import "./generated/model";
 import "./generated/msg";
 import "./generated/particlefx";
@@ -47,6 +55,20 @@ import "./generated/webview";
 import "./generated/window";
 import "./generated/zlib";
 
+export {
+  type ApiAvailability,
+  type ApiSymbolIdentity,
+  type AvailabilityLabel,
+  type AvailabilityLabelKind,
+  availabilityLabel,
+  deriveAvailabilityMatrix,
+  groupByLogicalName,
+  isSignatureTransition,
+  type LogicalNameGroup,
+  normalizedFunctionSignature,
+  symbolIdentityKey,
+  type VersionSurface,
+} from "./src/api-availability";
 export type { ApiFunction, ApiModule, ApiParameter, ApiVariable } from "./src/api-doc";
 export { parseDefoldApiDoc } from "./src/api-doc";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.19.4",
+  "version": "0.20.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {
@@ -36,6 +36,8 @@
     "./timers": {
       "types": "./src/timers.d.ts"
     },
+    "./api-availability.json": "./api-availability.json",
+    "./api-signatures.json": "./api-signatures.json",
     "./package.json": "./package.json"
   },
   "files": [
@@ -43,6 +45,9 @@
     "generated",
     "scripts",
     "api-targets.json",
+    "api-migrations.json",
+    "api-availability.json",
+    "api-signatures.json",
     "index.d.ts",
     "!src/**/*.test.ts",
     "!scripts/**/*.test.ts",
@@ -55,6 +60,8 @@
     "build": "tsc -p tsconfig.build.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "regen": "bun scripts/regen.ts",
+    "generate-api-availability": "bun scripts/generate-api-availability.ts",
+    "import-defold-release": "bun scripts/import-defold-release.ts",
     "sync-api-docs": "bun scripts/sync-api-docs.ts",
     "ref-doc-delta": "bun scripts/ref-doc-delta.ts --target defold-1.9.8 --namespace label --present label.get_text --absent label.set_text"
   },

package/scripts/fidelity-audit.ts

@@ -1,11 +1,15 @@
 import { resolve } from "node:path";
 import { DEFOLD_TYPE_MAP } from "../src/core-types";
 import {
+  ARBITRARY_TABLE_SLOT_KEYS,
   ARBITRARY_TABLE_SLOTS,
+  applyFieldTypeOverrides,
   applyNestedFieldCurations,
   buildTableDocResolver,
   HANDLE_METHOD_LOCAL,
   HOMOGENEOUS_ARRAY_SLOTS,
+  isRecordsCollectionSlot,
+  isSlotLevelList,
   MAPPING_TABLE_SLOTS,
   type NestedMapping,
   OVERLOAD_COVERED_SKIPS,
@@ -18,9 +22,9 @@ import {
 import { parseMessagesDoc } from "../src/emit-messages";
 import {
   collectConstantFqns,
+  FIDELITY_BASELINE_MANIFEST,
   generateModuleDeclaration,
   MESSAGES_MANIFEST,
-  MODULE_MANIFEST,
   type ModuleManifestEntry,
 } from "./regen";
 
@@ -163,10 +167,10 @@ function auditEntry(
             for (const field of tableSlotCuration.value) {
               if (field.fields !== undefined) {
                 for (const nested of field.fields) {
-                  if (nested.numberList === true) continue;
+                  if (nested.numberList === true || nested.tsType !== undefined) continue;
                   considerTypes(nested.types);
                 }
-              } else if (field.numberList !== true) {
+              } else if (field.numberList !== true && field.tsType === undefined) {
                 considerTypes(field.types);
               }
             }
@@ -197,15 +201,37 @@ function auditEntry(
           for (const field of tableSlotCuration.fields) {
             if (field.fields !== undefined) {
               for (const nested of field.fields) {
-                if (nested.numberList === true) continue;
+                if (nested.numberList === true || nested.tsType !== undefined) continue;
                 considerTypes(nested.types);
               }
-            } else if (field.numberList !== true) {
+            } else if (field.numberList !== true && field.tsType === undefined) {
               considerTypes(field.types);
             }
           }
           continue;
         }
+        // A keyed-object slot is recovered by emit-dts into `Record<string, { … }>`
+        // where the inner fields are parser-recovered — not a bare `Record`, so
+        // don't count it. Feed the parsed inner field types back through
+        // considerTypes so an unmapped inner token still surfaces under
+        // unknownTokens (mirrors the parser-recovered branch below).
+        if (tableSlotCuration?.kind === "keyed-object") {
+          const rawParsed = doc !== undefined ? parseTableFields(doc, resolver) : null;
+          if (rawParsed !== null && slot !== undefined) {
+            const parsed = applyFieldTypeOverrides(slot.element, slot.kind, slot.name, rawParsed);
+            for (const field of parsed) {
+              if (field.fields !== undefined) {
+                for (const nested of field.fields) {
+                  if (nested.numberList === true || nested.tsType !== undefined) continue;
+                  considerTypes(nested.types);
+                }
+              } else if (field.numberList !== true && field.tsType === undefined) {
+                considerTypes(field.types);
+              }
+            }
+          }
+          continue;
+        }
         if (homogeneousElement !== undefined) {
           considerTypes(
             typeof homogeneousElement === "string" ? [homogeneousElement] : homogeneousElement,
@@ -215,7 +241,12 @@ function auditEntry(
         const parsed = doc !== undefined ? parseTableFields(doc, resolver) : null;
         const fields =
           parsed !== null && slot !== undefined
-            ? applyNestedFieldCurations(slot.element, slot.kind, slot.name, parsed)
+            ? applyFieldTypeOverrides(
+                slot.element,
+                slot.kind,
+                slot.name,
+                applyNestedFieldCurations(slot.element, slot.kind, slot.name, parsed),
+              )
             : parsed;
         if (fields !== null) {
           // A recovered field carrying nested fields (the mixed `<dl>`+`<ul>`
@@ -232,23 +263,49 @@ function auditEntry(
           for (const field of fields) {
             if (field.fields !== undefined) {
               for (const nested of field.fields) {
-                if (nested.numberList === true) continue;
+                if (nested.numberList === true || nested.tsType !== undefined) continue;
                 considerTypes(nested.types, undefined, arbitraryTable);
               }
-            } else if (field.numberList === true) {
-              // Recovered as `number[]` by inlineTableType — no longer a
-              // `Record`, so skip it. Re-counting its `table` token here would
-              // double-count a slot the emitted surface no longer loses.
+            } else if (field.numberList === true || field.tsType !== undefined) {
+              // Recovered as `number[]` (numberList) or pinned via a field-type
+              // override (tsType) by inlineTableType — no longer a `Record`, so
+              // skip it. Re-counting its `table` token here would double-count a
+              // slot the emitted surface no longer loses.
             } else {
               considerTypes(field.types, undefined, arbitraryTable);
             }
           }
+          // A records-collection return slot ("… of tables" / "table of tables")
+          // whose inner record the parser recovered but the emitter did not wrap
+          // (isSlotLevelList false) still lost its outer array layer — the emitted
+          // shape is a bare object. The oracle (isRecordsCollectionSlot) is
+          // intentionally broader than the emitter's wrap trigger (isSlotLevelList):
+          // a records-collection wording the trigger stops recognizing re-surfaces
+          // here as a counted loss, keeping the gate coupled to the emitted surface.
+          // array / array-object / mapping / homogeneous curations already
+          // `continue`d above, so reaching here means none applied.
+          if (
+            slot?.kind === "return" &&
+            doc !== undefined &&
+            isRecordsCollectionSlot(doc) &&
+            !isSlotLevelList(doc)
+          ) {
+            recordTables += 1;
+          }
           continue;
         }
         // A slot on a serialization/JSON passthrough function is a genuinely
         // arbitrary lua table — its emitted `Record<string | number, unknown>`
         // is faithful, not a loss — so it is not counted under recordTables.
         if (arbitraryTable) continue;
+        // A per-slot arbitrary allowlist entry (an undocumented table slot on an
+        // otherwise-documented element) is faithful `Record` too — not a loss.
+        if (
+          slot !== undefined &&
+          ARBITRARY_TABLE_SLOT_KEYS.has(`${slot.element}:${slot.kind}:${slot.name}`)
+        ) {
+          continue;
+        }
         recordTables += 1;
         continue;
       }
@@ -382,7 +439,7 @@ function tableSlotKey(elementName: string, slotKind: "param" | "return", slotNam
 }
 
 export function buildFidelityReport(
-  manifest: readonly ModuleManifestEntry[] = MODULE_MANIFEST,
+  manifest: readonly ModuleManifestEntry[] = FIDELITY_BASELINE_MANIFEST,
 ): Record<string, FidelityEntry> {
   const report: Record<string, FidelityEntry> = {};
   const knownConstantFqns = collectConstantFqns(manifest);

package/scripts/fidelity-baseline.json

@@ -15,6 +15,46 @@
     "droppedMembers": 0,
     "optionalAsRequired": 0
   },
+  "b2d.chain": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
+  "b2d.fixture": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
+  "b2d.joint": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
+  "b2d.shape": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
+  "b2d.world": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
   "buffer": {
     "droppedElements": 0,
     "unknownTokens": [],
@@ -47,6 +87,14 @@
     "droppedMembers": 0,
     "optionalAsRequired": 0
   },
+  "compute": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
   "crash": {
     "droppedElements": 0,
     "unknownTokens": [],
@@ -159,6 +207,14 @@
     "droppedMembers": 0,
     "optionalAsRequired": 0
   },
+  "material": {
+    "droppedElements": 0,
+    "unknownTokens": [],
+    "recordTables": 0,
+    "multiReturn": 0,
+    "droppedMembers": 0,
+    "optionalAsRequired": 0
+  },
   "model": {
     "droppedElements": 0,
     "unknownTokens": [],