@defold-typescript/library-types 0.23.0 → 0.25.0

package/generated/event.d.ts

@@ -39,25 +39,25 @@ declare module 'event.event' {
 		 * event_2 = event.create()
 		 * event_2:subscribe(event_1) -- Now event2 will trigger event1
 		 */
-		subscribe(callback: unknown | event, callback_context?: unknown | undefined): boolean;
+		subscribe(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
 		/**
 		 * Subscribe a callback for a single trigger. After the first trigger the callback is automatically unsubscribed.
 		 * on_click_event:subscribe_once(function(self) print("one-time click!") end, self)
 		 */
-		subscribe_once(callback: unknown | event, callback_context?: unknown | undefined): boolean;
+		subscribe_once(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
 		/**
 		 * Remove a previously subscribed callback from the event.
 		 * The callback_context should be the same as the one used when subscribing the callback.
 		 * If there is no callback_context provided, all callbacks with the same function will be unsubscribed.
 		 * on_click_event:unsubscribe(callback, self)
 		 */
-		unsubscribe(callback: unknown | event, callback_context?: unknown | undefined): boolean;
+		unsubscribe(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): boolean;
 		/**
 		 * Determine if a specific callback is currently subscribed to the event.
 		 * The callback_context should be the same as the one used when subscribing the callback.
 		 * local is_subscribed = on_click_event:is_subscribed(callback, self)
 		 */
-		is_subscribed(callback: unknown | event, callback_context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
+		is_subscribed(callback: ((...args: any[]) => unknown) | event, callback_context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
 		/**
 		 * Trigger the event, causing all subscribed callbacks to be executed.
 		 * Any parameters passed to trigger will be forwarded to the callbacks.
@@ -107,12 +107,12 @@ declare module 'event.event' {
 		 * Returns a new promise that will be resolved or rejected based on the handlers' return values.
 		 * load_data():next(function(data) return process(data) end):next(display):catch(show_error)
 		 */
-		next(on_resolved?: unknown | promise | event | undefined, on_rejected?: unknown | promise | event | undefined, context?: unknown | undefined): promise;
+		next(on_resolved?: ((...args: any[]) => unknown) | promise | event | undefined, on_rejected?: ((...args: any[]) => unknown) | promise | event | undefined, context?: unknown | undefined): promise;
 		/**
 		 * Attach a rejection handler to the promise. Equivalent to next(nil, on_rejected).
 		 * load_data():catch(function(err) print("Failed:", err) end)
 		 */
-		"catch"(on_rejected: unknown | event, context?: unknown | undefined): promise;
+		"catch"(on_rejected: ((...args: any[]) => unknown) | event, context?: unknown | undefined): promise;
 		/**
 		 * Attach a handler that is called regardless of whether the promise is resolved or rejected.
 		 * The handler is called with the resolved value or rejection reason.
@@ -120,7 +120,7 @@ declare module 'event.event' {
 		 * The handler return value is ignored.
 		 * load_data():finally(function() hide_loading_spinner() end)
 		 */
-		"finally"(on_finally: unknown | event, context?: unknown | undefined): promise;
+		"finally"(on_finally: ((...args: any[]) => unknown) | event, context?: unknown | undefined): promise;
 		/**
 		 * Check if the promise is in pending state.
 		 */
@@ -208,7 +208,7 @@ declare module 'event.event' {
 		 * my_queue:push(save_data)
 		 * my_queue:push(save_data, function() print("saved!") end)
 		 */
-		push(data: unknown, on_handle?: unknown | event | undefined, context?: unknown | undefined): void;
+		push(data: unknown, on_handle?: ((...args: any[]) => unknown) | event | undefined, context?: unknown | undefined): void;
 		/**
 		 * Subscribe a handler to this queue instance. When an event is pushed to this queue,
 		 * the handler will be called. If there are already events in the queue, they will be processed immediately.
@@ -219,35 +219,35 @@ declare module 'event.event' {
 		 * end
 		 * my_queue:subscribe(on_save, self)
 		 */
-		subscribe(handler: unknown | event, context?: unknown | undefined): boolean;
+		subscribe(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
 		/**
 		 * Subscribe a handler until it handles one event. The handler is invoked for each event in the queue until it returns non-nil (handles an event)
 		 * then it is automatically unsubscribed and will not be invoked again, even if more events remain in the queue.
 		 * my_queue:subscribe_once(function(self, data) return process(data) end, self)
 		 */
-		subscribe_once(handler: unknown | event, context?: unknown | undefined): boolean;
+		subscribe_once(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
 		/**
 		 * Unsubscribe a handler from this queue instance.
 		 * my_queue:unsubscribe(on_save, self)
 		 */
-		unsubscribe(handler: unknown | event, context?: unknown | undefined): boolean;
+		unsubscribe(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): boolean;
 		/**
 		 * Check if a handler is subscribed to this queue instance.
 		 * local ok = my_queue:is_subscribed(on_save, self)
 		 */
-		is_subscribed(handler: unknown | event, context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
+		is_subscribed(handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): LuaMultiReturn<[boolean, number | undefined]>;
 		/**
 		 * Process all events in this queue immediately. Subscribers will not be called in this function.
 		 * Events can be handled and removed in event handler callback. If event is handled, it will be removed from the queue.
 		 * my_queue:process(function(self, data) return handle(data) end, self)
 		 */
-		process(event_handler: unknown | event, context?: unknown | undefined): void;
+		process(event_handler: ((...args: any[]) => unknown) | event, context?: unknown | undefined): void;
 		/**
 		 * Process exactly one queued event with a specific handler (subscribers will NOT be called).
 		 * If the handler returns non-nil the event will be removed from the queue.
 		 * local handled = my_queue:process_next(function(data) return handle(data) end)
 		 */
-		process_next(event_handler?: unknown | event | undefined, context?: unknown | undefined): boolean;
+		process_next(event_handler?: ((...args: any[]) => unknown) | event | undefined, context?: unknown | undefined): boolean;
 		/**
 		 * Get all pending events in this queue.
 		 * for _, event_data in ipairs(my_queue:get_events()) do
@@ -298,7 +298,7 @@ declare module 'event.event' {
 	 * local e = event.create()
 	 * local e = event.create(function(self) print("ok") end, self)
 	 */
-	export function create(this: void, callback?: unknown | event | undefined, callback_context?: unknown | undefined): event;
+	export function create(this: void, callback?: ((...args: any[]) => unknown) | event | undefined, callback_context?: unknown | undefined): event;
 	/**
 	 * Check if the table is an event instance.
 	 * if event.is_event(my_value) then

package/generated/{gooey.gooey.d.ts → gooey.d.ts}

@@ -135,6 +135,38 @@ declare module 'gooey.gooey' {
 		total_width: number;
 	};
 
+	/** What `create_theme` hands back: the helpers it installs, over any component
+	 * carrying a node. `is_enabled` and `set_enabled` return nothing when it does not. */
+	type Theme = {
+		is_enabled: (component: { node?: Opaque<"node"> }) => boolean | undefined;
+		set_enabled: (component: { node?: Opaque<"node"> }, enabled: boolean) => void;
+		acquire_input: () => void;
+		release_input: () => void;
+		group: (
+			group_id: Hash | string,
+			action_id: Hash,
+			action: table,
+			group_fn: () => void,
+		) => table;
+	};
+
+	/**
+	 * Check if a node is enabled. This is done by not only looking at the state of the
+	 * node itself but also it's ancestors all the way up the hierarchy.
+	 */
+	export function is_enabled(node: Opaque<"node">): boolean;
+
+	/** Convenience function to acquire input focus */
+	export function acquire_input(): void;
+
+	/** Convenience function to release input focus */
+	export function release_input(): void;
+
+	export function create_theme(): Theme;
+
+	/** Mask text by replacing every character with a mask character */
+	export function mask_text(text: string, mask: string): string;
+
 	export function button(
 		node_id: Hash | string,
 		action_id: Hash,
@@ -151,6 +183,15 @@ declare module 'gooey.gooey' {
 		refresh_fn?: (checkbox: CheckboxState) => void,
 	): CheckboxState;
 
+	/** Wraps the `gooey.radio` calls of one group; `fn` receives the group's id and the
+	 * input it was called with, not a radio state (`README.md:265`). */
+	export function radiogroup(
+		group_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		fn: (group_id: Hash | string, action_id: Hash, action: table) => void,
+	): table;
+
 	export function radio(
 		node_id: Hash | string,
 		group: string,
@@ -169,12 +210,10 @@ declare module 'gooey.gooey' {
 		config: { horizontal?: boolean } | undefined,
 		fn: (list: ListState) => void,
 		refresh_fn?: (list: ListState) => void,
-		is_horizontal?: boolean,
 	): ListState;
 
 	export function dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -183,12 +222,10 @@ declare module 'gooey.gooey' {
 		config: { horizontal?: boolean; carousel?: boolean } | undefined,
 		fn: (list: ListState) => void,
 		refresh_fn?: (list: ListState) => void,
-		is_horizontal?: boolean,
 	): ListState;
 
 	export function horizontal_dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -201,7 +238,6 @@ declare module 'gooey.gooey' {
 
 	export function vertical_dynamic_list(
 		list_id: string,
-		root_id: string,
 		stencil_id: Hash | string,
 		item_id: Hash | string,
 		data: table,
@@ -239,6 +275,17 @@ declare module 'gooey.gooey' {
 		bounds_id: Hash | string,
 		action_id: Hash,
 		action: table,
+		config: table | undefined,
+		fn: (scrollbar: ScrollbarState) => void,
+		refresh_fn?: (scrollbar: ScrollbarState) => void,
+	): ScrollbarState;
+
+	export function horizontal_scrollbar(
+		handle_id: Hash | string,
+		bounds_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		config: table | undefined,
 		fn: (scrollbar: ScrollbarState) => void,
 		refresh_fn?: (scrollbar: ScrollbarState) => void,
 	): ScrollbarState;
@@ -257,5 +304,13 @@ declare module 'gooey.gooey' {
 		refresh_fn?: (input: InputState) => void,
 	): InputState;
 
-	export function group(group_id: string, fn: () => void): table;
+	export function group(
+		group_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		group_fn: () => void,
+	): table;
+
+	/** Move a group's focus to the component at `index`, refreshing it. */
+	export function set_focus(group: table, index: number): void;
 }

package/generated/in.onscreen.d.ts

@@ -32,6 +32,11 @@ declare module 'in.onscreen' {
 		on_input: (action_id: Hash, action: {}) => boolean;
 	};
 
+	/**
+	 * Create an instance of the onscreen controls.
+	 * @param config Optional settings. `touch` is the action id bound to single touch.
+	 * @returns The instance the register and input functions operate on.
+	 */
 	function create(config?: { touch: Hash }): OnscreenInstance;
 
 	export function reset(instance?: OnscreenInstance): void;

package/generated/in.textbox.d.ts

@@ -18,6 +18,10 @@ declare module 'in.textbox' {
 	): Opaque<"node">;
 	export function unregister(node_or_string?: Opaque<"node"> | string): void;
 	export function effect(node: Opaque<"node">, scale: { x: number; y: number }): void;
+	/**
+	 * Get a registered textbox's text, or set it first when `text` is given.
+	 * Returns the text the box holds after the call.
+	 */
 	export function text(
 		node_or_string: Opaque<"node"> | string,
 		text?: string,

package/generated/lang.d.ts

@@ -11,7 +11,7 @@ declare module 'lang.lang' {
 	}
 	interface lang {
 		state: lang_state;
-		on_lang_changed: unknown;
+		on_lang_changed: (...args: any[]) => unknown;
 	}
 	interface lang_state {
 		lang: string;
@@ -19,7 +19,7 @@ declare module 'lang.lang' {
 	interface lang_data {
 		path?: string | LuaTable | undefined;
 		id: string;
-		loader?: unknown | undefined;
+		loader?: ((...args: any[]) => unknown) | undefined;
 	}
 	/**
 	 * Global callback after language is loaded and translations are ready.
@@ -33,15 +33,15 @@ declare module 'lang.lang' {
 	/**
 	 * Load additional locale pack and refresh current language
 	 */
-	export function load_langs(this: void, pack_id: string, langs: lang_data[], on_lang_changed?: unknown | undefined): void;
+	export function load_langs(this: void, pack_id: string, langs: lang_data[], on_lang_changed?: ((...args: any[]) => unknown) | undefined): void;
 	/**
 	 * Set current language
 	 */
-	export function set_lang(this: void, lang_id: string, on_lang_changed?: unknown | undefined): void;
+	export function set_lang(this: void, lang_id: string, on_lang_changed?: ((...args: any[]) => unknown) | undefined): void;
 	/**
 	 * Set next language from lang list and return it's code
 	 */
-	export function set_next_lang(this: void, on_lang_changed?: unknown | undefined): string;
+	export function set_next_lang(this: void, on_lang_changed?: ((...args: any[]) => unknown) | undefined): string;
 	/**
 	 * Get next language from lang list and return it's code
 	 */

package/generated/log.d.ts

@@ -32,5 +32,5 @@ declare module 'log.log' {
 	/**
 	 * Return the basename of the current file
 	 */
-	export function get_default_logger_name(this: void, debuginfo: unknown): string;
+	export function get_default_logger_name(this: void, debuginfo: debug.FunctionInfo): string;
 }

package/generated/metrics.fps.d.ts

@@ -12,5 +12,23 @@ declare module 'metrics.fps' {
     draw: () => void;
   }
 
-  export function create(samples?: number, format?: string, position?: string, color?: string): Metrics;
+  /** Where `draw()` places the text, and the default `create()` uses when given no position. */
+  export const POSITION: Vector3;
+
+  /** The `string.format` pattern the FPS reading is rendered through. */
+  export const FORMAT: string;
+
+  /** The colour `draw()` renders the text in, and the default `create()` uses when given no colour. */
+  export const COLOR: Vector4;
+
+  export function create(samples?: number, format?: string, position?: Vector3, color?: Vector4): Metrics;
+
+  /** Call this once per frame. Once enough samples have been collected it is possible to call fps() to get the current FPS. */
+  export function update(): void;
+
+  /** Get the current FPS, based on collected samples. */
+  export function fps(): number;
+
+  /** Draw fps count text using `draw_debug_text`. */
+  export function draw(): void;
 }

package/generated/metrics.mem.d.ts

@@ -12,5 +12,23 @@ declare module 'metrics.mem' {
     draw: () => void;
   }
 
-  export function create(format?: string, position?: string, color?: string): Metrics;
+  /** Where `draw()` places the text, and the default `create()` uses when given no position. */
+  export const POSITION: Vector3;
+
+  /** The `string.format` pattern the memory reading is rendered through. */
+  export const FORMAT: string;
+
+  /** The colour `draw()` renders the text in, and the default `create()` uses when given no colour. */
+  export const COLOR: Vector4;
+
+  export function create(format?: string, position?: Vector3, color?: Vector4): Metrics;
+
+  /** Call this to get a new memory usage reading. */
+  export function update(): void;
+
+  /** Get the current memory usage, in kilobytes. */
+  export function mem(): number;
+
+  /** Draw memory usage text using `draw_debug_text`. */
+  export function draw(): void;
 }

package/generated/monarch.monarch.d.ts

@@ -40,6 +40,36 @@ declare module 'monarch.monarch' {
 	type Callback = () => void;
 
 	// transition messages
+	/**
+	 * Post this back to Monarch from a transition listener once the transition
+	 * has finished. Monarch will not proceed until it arrives.
+	 */
+	export const TRANSITION_DONE: Hash;
+	/** Sent to a screen's transition url when the screen should transition in. */
+	export const TRANSITION_SHOW_IN: Hash;
+	/** Sent to a screen's transition url when the screen should transition out. */
+	export const TRANSITION_SHOW_OUT: Hash;
+	/**
+	 * Sent to a screen's transition url when the screen above it was popped and
+	 * this screen should transition back in.
+	 */
+	export const TRANSITION_BACK_IN: Hash;
+	/**
+	 * Sent to a screen's transition url when this screen is being popped and
+	 * should transition back out.
+	 */
+	export const TRANSITION_BACK_OUT: Hash;
+
+	// focus messages
+	/** Sent to a screen's focus url when the screen gains focus. */
+	export const FOCUS_GAINED: Hash;
+	/** Sent to a screen's focus url when the screen loses focus. */
+	export const FOCUS_LOST: Hash;
+
+	/**
+	 * @deprecated Use the flat `TRANSITION_*` constants instead — Monarch marks
+	 * this grouping deprecated in its own source.
+	 */
 	export const TRANSITION: {
 		DONE: Hash;
 		SHOW_IN: Hash;
@@ -48,13 +78,20 @@ declare module 'monarch.monarch' {
 		BACK_OUT: Hash;
 	};
 
-	// focus messages
+	/**
+	 * @deprecated Use the flat `FOCUS_*` constants instead — Monarch marks this
+	 * grouping deprecated in its own source.
+	 */
 	export const FOCUS: {
 		GAINED: Hash;
 		LOST: Hash;
 	};
 
 	// listener messages
+	/**
+	 * Sent to every url registered with `add_listener` when a screen begins
+	 * transitioning in, carrying `screen` and `previous_screen` ids.
+	 */
 	export const SCREEN_TRANSITION_IN_STARTED: Hash;
 	export const SCREEN_TRANSITION_IN_FINISHED: Hash;
 	export const SCREEN_TRANSITION_OUT_STARTED: Hash;
@@ -126,6 +163,12 @@ declare module 'monarch.monarch' {
 		settings: RegisterProxyOptions,
 	): void;
 
+	/**
+	 * Alias of {@link register_proxy}, kept for the pre-factory API.
+	 * Typed through the function it aliases so the two cannot drift apart.
+	 */
+	export const register: typeof register_proxy;
+
 	/**
 	 * Register a new screen contained in a collection factory.
 	 * This is done automatically by the screen_factory.script. It is expected that

package/generated/monarch.transitions.easings.d.ts

@@ -61,5 +61,4 @@ declare module 'monarch.transitions.easings' {
 	export function QUART(): Easing;
 	export function QUINT(): Easing;
 	export function SINE(): Easing;
-	export function create(name: EasingIn | EasingOut): Easing;
 }

package/generated/monarch.transitions.gui.d.ts

@@ -135,18 +135,102 @@ declare module 'monarch.transitions.gui' {
 		complete_function?: (this: any, node: Opaque<"node">) => void,
 	) => void;
 
-	export const slide_in_right: TransitionInFn;
-	export const slide_in_left: TransitionInFn;
-	export const slide_in_top: TransitionInFn;
-	export const slide_in_bottom: TransitionInFn;
-	export const slide_out_right: TransitionOutFn;
-	export const slide_out_left: TransitionOutFn;
-	export const slide_out_top: TransitionOutFn;
-	export const slide_out_bottom: TransitionOutFn;
-	export const scale_in: TransitionInFn;
-	export const scale_out: TransitionOutFn;
-	export const fade_in: TransitionInFn;
-	export const fade_out: TransitionOutFn;
+	export function slide_in_right(
+		node: Opaque<"node">,
+		to: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_in_left(
+		node: Opaque<"node">,
+		to: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_in_top(
+		node: Opaque<"node">,
+		to: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_in_bottom(
+		node: Opaque<"node">,
+		to: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_out_right(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_out_left(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_out_top(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function slide_out_bottom(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function scale_in(
+		node: Opaque<"node">,
+		to: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function scale_out(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function fade_in(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
+	export function fade_out(
+		node: Opaque<"node">,
+		from: Vector3,
+		easing: GuiEasing,
+		duration: number,
+		delay?: number,
+		complete_function?: (this: any, node: Opaque<"node">) => void,
+	): void;
 
 	export function in_right_out_left(
 		node: Opaque<"node">,