@defold-typescript/library-types 0.18.1

package/generated/defmath.defmath.d.ts

@@ -0,0 +1,194 @@
+/** @noSelfInFile **/
+
+/** 
+ * @see {@link https://github.com/subsoap/defmath|Github Source}
+ * @noResolution
+ */
+declare module "defmath.defmath" {
+  /**
+   * Angle-Diff (gets the smallest angle between two angles, using radians)
+   */
+  export function anglediff_rad(rad1: number, rad2: number): number;
+  
+  /**
+   * Angle-Diff (gets the smallest angle between two angles, using degrees)
+   */
+  export function anglediff_deg(deg1: number, deg2: number): number;
+  
+  /**
+   * Round
+   */
+  export function round(x: number): number;
+
+  /**
+   * Round to decimal point
+   */
+  export function round_decimal(number: number, decimal: number): number;
+  
+  /**
+   * Clamp
+   */
+  export function clamp(x: number, min: number, max: number): number;
+
+
+  /**
+   * Sign
+   */
+  export function sign(x: number): number;
+
+  /**
+   * Checks if two numbers have the same sign
+   */
+  export function same_sign(a: number, b: number): boolean;
+
+  /**
+   * Vect to Quat
+   */
+  export function vect_to_quat(vect: Vector3 | Vector4): Quaternion;
+
+
+  /**
+   * Vect to Quat + 90 degrees (perpendicular)
+   */
+  export function vect_to_quat90(vect: Vector3 | Vector4): Quaternion;
+
+  /**
+   * Random float from -1 to 1
+   */
+  export function rand11(): number;
+
+  /**
+   * Random float in range
+   */
+  export function rand_range(min: number, max: number): number;
+
+  /**
+   * Linear interpolation
+   */
+  export function lerp(start: number, stop: number, amount: number): number;
+
+  /**
+   * Distance between two 2d points
+   */
+  export function dist2d(x1: number, y1: number, x2: number, y2: number): number;
+
+  /**
+   * Distance between two 3d points
+   */
+  export function dist3d(x1: number, y1: number, z1: number, x2: number, y2: number, z2: number): number;
+  
+  /** 
+   * Angle in radians of vector between two points
+   */
+  export function angle_of_vector_between_two_points(x1: number, y1: number, x2: number, y2: number): number;
+
+  /**
+   * Clears bad RNG and sets seed to be based on OS time
+   */
+  export function setup_rng(): void;
+
+  /**
+   * Check if number is within range
+   */
+  export function is_within_range(number: number, min: number, max: number): boolean;
+
+  /**
+   * Convert radians to degrees
+   */
+  export function radians_to_degrees(radian: number): number;
+
+  /**
+   * Convert degrees to radians
+   */
+  export function degrees_to_radians(degrees: number): number;
+
+  /**
+   * Wrap a number to betwen 0 and a range bound
+   */
+  export function wrap(number: number, bound: number): number;
+
+  /**
+   * Bound a number so that it is no larger than max and no smaller than min
+   */
+  export function bound(number: number, min: number, max: number): number;
+
+  /**
+   * Adds an amount to a value within the value going over max or below min
+   */
+  export function bound_add(number: number, amount: number, min: number, max: number): number;
+  
+  /**
+   * Sums a set of values
+   */
+  export function sum(...vararg: number[]): number;
+
+  /**
+   * Average of set of values
+   */
+  export function average(...vararg: number[]): number;
+
+  /**
+   * Get difference between two values
+   */
+  export function difference(a: number, b: number): number;
+
+  /**
+   * if a number is even
+   */
+  export function is_even(number: number): boolean;
+  
+  /**
+   * if a number is odd
+   */
+  export function is_odd(number: number): boolean;
+
+  /**
+   * Wrap an angle between -180 and +180
+   */
+  export function wrap_angle(angle: number): number;
+
+  /**
+   * Angle between vmath vectors in radians
+   */
+  export function angle_between_vectors(vector1: Vector3 | Vector4, vector2: Vector3 | Vector4): number;
+
+  /**
+   * Average midpoint of a set of vmath vectors
+   */
+  export function average_midpoint_of_vectors(...vararg: Array<Vector3 | Vector4>): LuaMultiReturn<[number, number]>;
+
+  /**
+   * Fraction of
+   */
+  export function fraction_of(a: number, b: number): number;
+
+  /**
+   * Percent of
+   */
+  export function percent_of(a: number, b: number): number;
+
+  /**
+   * Used for MinMax Range
+   */
+  export function min_max(min: number, max: number, value: number): number;
+
+  export function min_value(smallest: number, value: number): number;
+
+  export function max_value(largest: number, value: number): number;
+
+  /**
+   * Used to find a point in a triangle
+   * x0, y0 are the points that are being checked against the rest to see if it's inside
+   */
+  export function in_triangle(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;
+
+  /**
+   * arr must be 6 in length: top x/y, bottom right x/y, bottom left x/y
+   */
+  export function box_intersect(ax: number, ay: number, awidth: number, aheight: number, bx: number, by: number, bwidth: number, bheight: number): boolean;
+
+  /**
+   * see if a single point is within a rotated rectangle
+   */
+  export function check_point_in_rect(rx: number, ry: number, rw: number, rh: number, rot: number, px: number, py: number): boolean;
+}

package/generated/defsave.defsave.d.ts

@@ -0,0 +1,31 @@
+/** @noSelfInFile **/
+
+/**
+ * Save and load config and user data persistently between a Defold project's sessions
+ * @see {@link https://github.com/subsoap/defsave|Github Source}
+ * @noResolution
+ */
+declare module "defsave.defsave" {
+  export let appname: string;
+
+  export function set_appname(name: string): void;
+
+  export function load(config: string): unknown;
+
+  export function get(config: string, name: string): unknown;
+
+  export function set(config: string, name: string, value: any): void;
+
+  export function save(config: string): void;
+
+  /**
+   * You can save all files at once. By default, it will only actually save files with changes, but you can force saving all files by setting the force flag to true.
+   * @param all_files false only saves changed files and true saves all files
+   */
+  export function save_all(all_files?: boolean): void;
+
+  /**
+   * In your update, if you want autosave to be enabled, you will need to include
+   */
+  export function update(dt: number): void;
+}

package/generated/deftest.deftest.d.ts

@@ -0,0 +1,47 @@
+/** @noSelfInFile **/
+
+/**
+ * Unit testing in Defold
+ * @see {@link https://github.com/britzl/deftest|Github Source}
+ * @noResolution
+ */
+declare module 'deftest.deftest' {
+	export function add(...args: ((...args: any[]) => unknown)[]): void;
+	export function run(options?: {
+		coverage?: {
+			enabled?: boolean,
+		}
+		pattern?: string,
+	}): void;
+}
+
+declare function describe(title: string, tests: () => void): void
+declare function before(before: () => void): void
+declare function after(after: () => void): void
+declare function test(title: string, test: () => void): void
+declare function assert_equal<T>(a: T, b: T): void
+declare function assert_blank(value: any): void
+declare function assert_empty(obj: Record<any, any>): void
+declare function assert_error(func: any): void
+declare function assert_not_error(func: any): void
+declare function assert_false(value: boolean): void
+declare function assert_not_false(value: boolean): void
+declare function assert_not_true(value: boolean): void
+declare function assert_true(value: boolean): void
+declare function assert_greater_than(a: number, b: number): void
+declare function assert_gte(a: number, b: number): void
+declare function assert_less_than(a: number, b: number): void
+declare function assert_lte(a: number, b: number): void
+declare function assert_match(a: number, b: number): void
+declare function assert_nil(value: any): void
+declare function assert_type<T>(a: T, b: T): void
+declare function assert_not_blank(value: any): void
+declare function assert_not_empty(value: any): void
+declare function assert_not_equal<T>(a: T, b: T): void
+declare function assert_not_greater_than(a: number, b: number): void
+declare function assert_not_gte(a: number, b: number): void
+declare function assert_not_less_than(a: number, b: number): void
+declare function assert_not_lte(a: number, b: number): void
+declare function assert_not_match(a: number, b: number): void
+declare function assert_not_nil(value: any): void
+declare function assert_not_type<T>(a: T, b: T): void

package/generated/dicebag.dicebag.d.ts

@@ -0,0 +1,90 @@
+/** @noSelfInFile **/
+
+/**
+ * Dicebag is a Defold extension containing probability functions designed specifically for games.
+ * @see {@link https://github.com/8bitskull/dicebag|Github Source}
+ * @noResolution
+ */
+declare module "dicebag.dicebag" {
+  /**
+   * Sets up the randomseed and clears the first number of random rolls.
+   * @param seed optional seed, if not specified a seed will be generated using socket.gettime().
+   * @returns the number used to seed the random function.
+   */
+  export function set_up_rng(seed?: number): number;
+
+  /**
+   * Flip a coin.
+   * @returns true or false (50% chance).
+   */
+  export function flip_coin(): boolean;
+
+  /**
+   * Roll a number of dice, D&D-style. An example would be rolling 3d6+2. Returns the sum of the resulting roll.
+   * @param num_dice Number of dice to roll.
+   * @param num_sides Number of sides on the dice.
+   * @param modifier Number to add to the result.
+   * @returns Sum of rolled dice plus modifier.
+   */
+  export function roll_dice(num_dice: number, num_sides: number, modifier: number): number;
+
+  /**
+   * Roll a number of dice and choose one (or more) of the highest (advantage) or lowest (disadvantage) results. Returns the sum of the relevant dice rolls.
+   * @param num_sides Number of sides on the dice.
+   * @param advantage If true, the highest rolls will be selected, otherwise the lowest values will be selected.
+   * @param num_dice Number of dice to roll.
+   * @param num_results How many of the highest (advantage) or lowest (disadvantage) dice to sum up.
+   * @returns Sum of the highest (advantage) or lowest (disadvantage) dice rolls
+   */
+  export function roll_special_dice(num_sides: number, advantage: number, num_dice: number, num_results: number): number;
+
+ /**
+   * Roll custom dice. The dice can have sides with different weights and different values.
+   * @param num_dice How many dice to roll.
+   * @param sides A table describing the sides of the die in the format `[[weight1, value1], [weight2, value2], ...]`.
+   * @returns The sum of the values as specified in the table `sides`.
+   */
+ export function roll_custom_dice(num_dice: number, sides: Array<[number, number]>): number;
+
+  /**
+   * Create a marble bag of green (success) and red (fails) 'marbles'. This allows you to, for example, make an unlikely event more and more likely the more fails are accumulated.
+   * @param id A unique identifier for the marble bag.
+   * @param num_success The number of success marbles in the bag.
+   * @param num_fails The number of fails marbles in the bag.
+   * @param reset_on_success Whether or not the bag should reset when a successful result is drawn. If false or nil the bag will reset when all marbles have been drawn.
+   */
+  export function bag_create(id: string | number | Hash, num_success: number, num_fails: number, reset_on_success: boolean): void;
+
+  /**
+   * Draw a marble from a previously created bag.
+   * @param id A unique identifier for the marble bag.
+   * @returns True or false
+   */
+  export function bag_draw(id: string | number | Hash): boolean;
+
+  /**
+   * Manually reset a marble bag. Will also be called when a marble bag is empty, or a success is drawn in a bag where `reset_on_success` is true.
+   * @param id A unique identifier for the marble bag.
+   */
+  export function bag_reset(id: string | number | Hash): void;
+
+  /**
+   * Create a rollable table. This is similar to a marble bag, except each entry can have a different weight, and can return any value (not just a boolean).
+   * @param id A unique identifier for the rollable table.
+   * @param rollable_table A table of weights, values and reset flags.
+   */
+  export function table_create(id: string | number | Hash, rollable_table: Array<[number, any, boolean?]>): void;
+
+  /**
+   * Draw a random value from the rollable table created in `table_create`. The value will be removed from the table. If `reset_on_roll` is true, the table will reset. Otherwise, the table will reset when all values are drawn.
+   * @param id A unique identifier for the rollable table.
+   * @returns The value specified in `table_create`.
+   */
+  export function table_roll(id: string | number | Hash): any;
+
+  /**
+   * Manually reset a rollable table. Will also be called when the rollable table is empty, or a drawn value where `reset_on_roll` is true.
+   * @param id A unique identifier for the rollable table.
+   */
+  export function table_reset(id: string | number | Hash): void;
+}

package/generated/event.event.d.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/**
+ * Cross-Context Defold Event System
+ * @see {@link https://github.com/Insality/defold-event|Github Source}
+ * @noResolution
+ */
+declare module 'event.event' {
+	interface LoggerInstance {
+		trace(this: any, message: string, data?: {}): void;
+		debug(this: any, message: string, data?: {}): void;
+		info(this: any, message: string, data?: {}): void;
+		warn(this: any, message: string, data?: {}): void;
+		error(this: any, message: string, data?: {}): void;
+	}
+	export function set_logger(logger: LoggerInstance): void;
+	/**
+	 * Generate a new event instance. This instance can then be used to subscribe to and trigger events.
+	 */
+	export function create(
+		this: void,
+		callback: (this: any) => void,
+		callback_context?: any,
+	): EventInstance;
+	class EventInstance {
+		/**
+		 * Subscribe a callback to the event. The callback will be invoked whenever the event is triggered.
+		 */
+		subscribe(callback: (this: any) => void, callback_context?: any): void;
+		/**
+		 * Remove a previously subscribed callback from the event.
+		 */
+		unsubscribe(callback: (this: any) => void, callback_context?: any): void;
+		/**
+		 * Determine if a specific callback is currently subscribed to the event.
+		 */
+		is_subscribed(
+			callback: (this: any) => void,
+			callback_context?: any,
+		): boolean;
+		/**
+		 * Trigger the event, causing all subscribed callbacks to be executed.
+		 */
+		trigger(...args: any[]): void;
+		/**
+		 * Check if the event has no subscribed callbacks.
+		 */
+		is_empty(): boolean;
+		/**
+		 * Remove all callbacks subscribed to the event, effectively resetting it.
+		 */
+		clear(): void;
+	}
+}

package/generated/gooey.gooey.d.ts

@@ -0,0 +1,261 @@
+/** @noSelfInFile */
+
+/**
+ * This is a definition stub with incomplete or untested signatures.
+ * Contributions to improve the accuracy of these types are welcome.
+ * @see {@link https://github.com/britzl/gooey|Github Source}
+ * @noResolution
+ */
+declare module 'gooey.gooey' {
+	type table = {};
+
+	type ButtonState = {
+		node: Opaque<"node">;
+		node_id: Hash;
+		enabled: boolean;
+		consumed: boolean;
+		clicked: boolean;
+		over: boolean;
+		over_now: boolean;
+		out_now: boolean;
+		pressed: boolean;
+		pressed_now: boolean;
+		long_pressed: boolean;
+		released_now: boolean;
+	};
+
+	type CheckboxState = {
+		node: Opaque<"node">;
+		node_id: Hash;
+		enabled: boolean;
+		consumed: boolean;
+		clicked: boolean;
+		over: boolean;
+		over_now: boolean;
+		out_now: boolean;
+		checked: boolean;
+		pressed: boolean;
+		pressed_now: boolean;
+		long_pressed: boolean;
+		released_now: boolean;
+		checked_now: boolean;
+		unchecked_now: boolean;
+	};
+
+	type RadioState = {
+		node: Opaque<"node">;
+		node_id: Hash;
+		enabled: boolean;
+		consumed: boolean;
+		clicked: boolean;
+		over: boolean;
+		over_now: boolean;
+		out_now: boolean;
+		selected: boolean;
+		pressed: boolean;
+		pressed_now: boolean;
+		long_pressed: boolean;
+		released_now: boolean;
+		selected_now: boolean;
+		deselected_now: boolean;
+	};
+
+	type ListState = {
+		id: string;
+		enabled: boolean;
+		consumed: boolean;
+		items: {
+			root: Opaque<"node">;
+			nodes: LuaMap<Hash, Opaque<"node">>;
+			data: unknown;
+			index: number;
+		}[];
+		over: boolean;
+		over_item: {
+			root: Opaque<"node">;
+			nodes: LuaMap<Hash, Opaque<"node">>;
+			data: unknown;
+			index: number;
+		};
+		over_item_now: {
+			root: Opaque<"node">;
+			nodes: LuaMap<Hash, Opaque<"node">>;
+			data: unknown;
+			index: number;
+		};
+		out_item_now: {
+			root: Opaque<"node">;
+			nodes: LuaMap<Hash, Opaque<"node">>;
+			data: unknown;
+			index: number;
+		};
+		selected_item: number | undefined;
+		pressed_item: number | undefined;
+		pressed_item_now: number | undefined;
+		long_pressed: boolean;
+		released_item_now: number | undefined;
+		scroll: Vector3;
+		is_horizontal: boolean;
+	};
+
+	type ScrollbarState = {
+		enabled: boolean;
+		pressed: boolean;
+		pressed_now: boolean;
+		released_now: boolean;
+		over: boolean;
+		over_now: boolean;
+		out_now: boolean;
+		clicked: boolean;
+		scroll: Vector3;
+	};
+
+	type InputState = {
+		node: Opaque<"node">;
+		node_id: Hash | string;
+		enabled: boolean;
+		consumed: boolean;
+		over: boolean;
+		over_now: boolean;
+		out_now: boolean;
+		selected: boolean;
+		pressed: boolean;
+		pressed_now: boolean;
+		long_pressed: boolean;
+		released_now: boolean;
+		selected_now: boolean;
+		deselected_now: boolean;
+		text: string;
+		marked_text: string;
+		keyboard_type: number;
+		masked_text: string;
+		masked_marked_text: string;
+		text_width: number;
+		marked_text_width: number;
+		total_width: number;
+	};
+
+	export function button(
+		node_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		fn: (button: ButtonState) => void,
+		refresh_fn?: (button: ButtonState) => void,
+	): ButtonState;
+
+	export function checkbox(
+		node_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		fn: (checkbox: CheckboxState) => void,
+		refresh_fn?: (checkbox: CheckboxState) => void,
+	): CheckboxState;
+
+	export function radio(
+		node_id: Hash | string,
+		group: string,
+		action_id: Hash,
+		action: table,
+		fn: (radio: RadioState) => void,
+		refresh_fn?: (radio: RadioState) => void,
+	): RadioState;
+
+	export function static_list(
+		list_id: string,
+		stencil_id: Hash | string,
+		item_ids: (Hash | string)[],
+		action_id: Hash,
+		action: table,
+		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,
+		action_id: Hash,
+		action: table,
+		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,
+		action_id: Hash,
+		action: table,
+		config: { carousel?: boolean } | undefined,
+		fn: (list: ListState) => void,
+		refresh_fn?: (list: ListState) => void,
+	): ListState;
+
+	export function vertical_dynamic_list(
+		list_id: string,
+		root_id: string,
+		stencil_id: Hash | string,
+		item_id: Hash | string,
+		data: table,
+		action_id: Hash,
+		action: table,
+		config: { carousel?: boolean } | undefined,
+		fn: (list: ListState) => void,
+		refresh_fn?: (list: ListState) => void,
+	): ListState;
+
+	export function horizontal_static_list(
+		list_id: string,
+		stencil_id: Hash | string,
+		item_ids: (Hash | string)[],
+		action_id: Hash,
+		action: table,
+		config: undefined,
+		fn: (list: ListState) => void,
+		refresh_fn?: (list: ListState) => void,
+	): ListState;
+
+	export function vertical_static_list(
+		list_id: string,
+		stencil_id: Hash | string,
+		item_ids: (Hash | string)[],
+		action_id: Hash,
+		action: table,
+		config: undefined,
+		fn: (list: ListState) => void,
+		refresh_fn?: (list: ListState) => void,
+	): ListState;
+
+	export function vertical_scrollbar(
+		handle_id: Hash | string,
+		bounds_id: Hash | string,
+		action_id: Hash,
+		action: table,
+		fn: (scrollbar: ScrollbarState) => void,
+		refresh_fn?: (scrollbar: ScrollbarState) => void,
+	): ScrollbarState;
+
+	export function input(
+		node_id: Hash | string,
+		keyboard_type: number,
+		action_id: Hash,
+		action: table,
+		config?: {
+			max_length?: number;
+			empty_text?: string;
+			allowed_characters?: string;
+			use_marked_text?: boolean;
+		},
+		refresh_fn?: (input: InputState) => void,
+	): InputState;
+
+	export function group(group_id: string, fn: () => void): table;
+}

package/generated/immutable.immutable.d.ts

@@ -0,0 +1,13 @@
+/** @noSelfInFile **/
+
+/**
+ * Runtime immutable Lua table implementation 
+ * @see {@link https://github.com/paweljarosz/lua-immutable|Github Source}
+ * @noResolution
+ * @example `import * as IMMUTABLE from 'immutable.immutable'`
+ */
+declare module 'immutable.immutable' {
+	type table = object | any[] | LuaTable | LuaSet | LuaMap;
+	export function make<T extends table>(original_table: T): Readonly<T>;
+	export function is_immutable(table_to_check: table): boolean;
+}