factorio-types 1.2.54 → 1.2.55

package/README.md

@@ -23,7 +23,7 @@ This library includes [tsconfig.base.json](https://github.com/sguest/factorio-ty
 
 ## Stages
 
-Factorio mods and the api go through [three distinct stages](https://lua-api.factorio.com/latest/). Types are organized into namespaces `runtime`, `prototype`, and `settings` representing the types to be used in each stage. These types, and therefore their corresponding namespaces, are a compile-time-only feature as lua does not have types, however using a type from the wrong namespace during the wrong stage is likely to result in a runtime error as you will be attempting to access something Factorio does not let you access at that time.
+Factorio mods and the api go through [three distinct stages](https://lua-api.factorio.com/latest/). Types are organized into namespaces `runtime`, `prototype`, and `settings` representing the types to be used in each stage. These types, and therefore their corresponding namespaces, are a compile-time-only feature as lua does not have types, so accessing a _type_ during the wrong phase is safe. Sometimes this is OK, such as when referencing utility functions that operate on values without interacting with game API like math functions. However, many game APIs will only work with types from the correct phase, so using an API that takes types from the wrong phase should be a red flag that you might encounter a runtime error.
 
 Note there is some overlap between the types for the Settings and Prototype phases since both regularly provide prototype data to `data.extend()`, and in fact the settings-phase prototypes extend `prototype.PrototypeBase`. However, you should only be providing types from the `settings` namespace during the settings phase, and from the `prototype` namespace during the prototype phase.
 
@@ -70,6 +70,20 @@ end
 
 Factorio makes various lua functions available to mods via [LuaLib](https://github.com/wube/factorio-data/tree/master/core/lualib)
 
-Unlike the main parts of the factorio API, these do not exist as ambient globals but instead must be imported
+Unlike the main parts of the factorio API, these do not exist as ambient globals but instead must be imported. If you inherit the recommended [tsconfig.base.json](https://github.com/sguest/factorio-types/blob/master/tsconfig.base.json), these import paths will all be set to `noResolvePaths`, meaning TSTL will not attempt to resolve them and will simply emit `require` statements that will allow Factorio to load the lualib files at runtime.
 
-The `noise` lualib definitions were previous present in this library. However, as of version 2.0.7, `noise.lua` was [removed from lualib in the factorio-data repo](https://github.com/wube/factorio-data/commit/7522d3763e76e09ce1a46cba676dfc2b6d12b127). This was accompanied by many of the required supporting types being removed from the prototype definitions, and therefore the noise definitions have been removed from this library, at least temporarily.
+```typescript
+import { split } from 'util';
+
+let splitStr = split('a|b', '|');
+```
+
+```typescript
+import * as util from 'util';
+
+let result = util.split_whitespace('a b');
+```
+
+The LuaLib definitions are not part of the machine-readable API spec that feeds the generation of the rest of the types in this repo. The devs [have said](https://forums.factorio.com/viewtopic.php?p=599930#p599930) better docs for lualib are in their longterm plans, but for now the only documentation is the files themselves in the `factorio-data` repo and any associated comments. Therefore, the lualib docs are hand-written by reading through the files and are more likely to contain errors. If you encounter any errors, please raise an issue and/or pull request.
+
+The `noise` lualib definitions were previously present in this library. However, as of version 2.0.7, `noise.lua` was [removed from lualib in the factorio-data repo](https://github.com/wube/factorio-data/commit/7522d3763e76e09ce1a46cba676dfc2b6d12b127). This was accompanied by many of the required supporting types being removed from the prototype definitions, and therefore the noise definitions have been removed from this library, at least temporarily.

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+// Type definitions for Factorio modding API
+// Factorio API reference https://lua-api.factorio.com/latest/index.html
+// Generated from JSON source https://lua-api.factorio.com/latest/runtime-api.json and https://lua-api.factorio.com/latest/prototype-api.json
+// Definition source https://github.com/sguest/factorio-types
+
+/// <reference path="./global.d.ts" />
+/// <reference path="./classes.d.ts" />
+/// <reference path="./concepts.d.ts" />
+/// <reference path="./defines.d.ts" />
+/// <reference path="./events.d.ts" />
+/// <reference path="./prototypes.d.ts" />
+/// <reference path="./types.d.ts" />
+/// <reference path="./datacollection.d.ts" />

package/index.d.ts

@@ -3,15 +3,6 @@
 // Generated from JSON source https://lua-api.factorio.com/latest/runtime-api.json and https://lua-api.factorio.com/latest/prototype-api.json
 // Definition source https://github.com/sguest/factorio-types
 
-/// <reference path="./src/core.d.ts" />
-/// <reference path="./src/settings.d.ts" />
-/// <reference path="./src/serpent.d.ts" />
-/// <reference path="./dist/global.d.ts" />
-/// <reference path="./dist/classes.d.ts" />
-/// <reference path="./dist/concepts.d.ts" />
-/// <reference path="./dist/defines.d.ts" />
-/// <reference path="./dist/events.d.ts" />
-/// <reference path="./dist/prototypes.d.ts" />
-/// <reference path="./dist/types.d.ts" />
-/// <reference path="./dist/datacollection.d.ts" />
+/// <reference path="./src/index.d.ts" />
+/// <reference path="./dist/index.d.ts" />
 /// <reference types="lua-types/jit" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-types",
-  "version": "1.2.54",
+  "version": "1.2.55",
   "description": "Typescript declarations for the Factorio mod API",
   "main": "index.d.ts",
   "repository": "https://github.com/sguest/factorio-types.git",
@@ -30,4 +30,4 @@
   "peerDependencies": {
     "typescript-to-lua": "^1.26.0"
   }
-}
+}

package/src/core.d.ts

@@ -8,17 +8,22 @@ declare namespace table {
     function compare(this: void, table1: object | [], table2: object | []): boolean;
 }
 
-declare const data: {
-    raw: prototype.dataCollection,
+interface DataType {
+    raw: prototype.dataCollection;
     extend(values: prototype.dataExtendType[]): void,
-};
+}
+
+declare const data: DataType;
 
 /**
  * Mapping of currently loaded mods to their version. Only exists at the data stage.
  */
 declare const mods: { [key: string] : string}
 
-declare const global: { [key: string]: any };
+/**
+ * Mod-specific storage lookup that is persisted to save files https://lua-api.factorio.com/latest/auxiliary/storage.html
+ */
+declare const storage: { [key: string]: any };
 
 declare function log(str: runtime.LocalisedString): void;
 

package/src/index.d.ts

@@ -0,0 +1,9 @@
+// Type definitions for Factorio modding API
+// Factorio API reference https://lua-api.factorio.com/latest/index.html
+// src mappings manually written to cover aspects not in the machine-readable API spec
+// Definition source https://github.com/sguest/factorio-types
+
+/// <reference path="./core.d.ts" />
+/// <reference path="./settings.d.ts" />
+/// <reference path="./serpent.d.ts" />
+/// <reference path="./lualib/index.d.ts" />

package/src/lualib/autoplace_utils.d.ts

@@ -0,0 +1,32 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/autoplace_utils.lua
+declare module "autoplace_utils" {
+    export interface AutoplacePeakValue {
+        influence: number;
+        richness_influence: number;
+        min_influence: number;
+        temperature_optimal: number;
+        temperature_range: number;
+        temperature_max_range: number;
+        water_optimal: number;
+        water_range: number;
+        water_max_range: number;
+    }
+
+    export type RectangleSpecification = [[number, number], [number, number], number?];
+
+    /**
+     * Add a list of autoplace peaks based on rectangles to the table ret.
+     * Rectangles is a table of rectangle specifications:
+     *  {{max_temp, max_water}, {min_temp, min_water}, influence}
+     * temperatures range from 35 to -25 (°C), water from 0 to 1.
+     * the peak resulting from each rectangle has a preset influence
+     * within the rectangle and goes to zero after 5°C or 0.1 water level outside
+     * of the rectangle.
+     * Influence is optional and has default value of default_influence or 1.
+     */
+    export function peaks(
+        this: void,
+        rectangles: RectangleSpecification[],
+        ret: AutoplacePeakValue[],
+        default_influence?: number): AutoplacePeakValue[];
+}

package/src/lualib/collision-mask-defaults.d.ts

@@ -0,0 +1,181 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/collision-mask-defaults.lua
+declare module "collision-mask-defaults" {
+    interface MaskType {
+        ["agricultural-tower"]: prototype.CollisionMaskConnector,
+        ["ammo-turret"]: prototype.CollisionMaskConnector,
+        ["arithmetic-combinator"]: prototype.CollisionMaskConnector,
+        ["artillery-turret"]: prototype.CollisionMaskConnector,
+        ["assembling-machine"]: prototype.CollisionMaskConnector,
+        ["asteroid-chunk"]: prototype.CollisionMaskConnector,
+        ["asteroid-collector"]: prototype.CollisionMaskConnector,
+        ["asteroid"]: prototype.CollisionMaskConnector,
+        ["beacon"]: prototype.CollisionMaskConnector,
+        ["boiler"]: prototype.CollisionMaskConnector,
+        ["burner-generator"]: prototype.CollisionMaskConnector,
+        ["decider-combinator"]: prototype.CollisionMaskConnector,
+        ["electric-energy-interface"]: prototype.CollisionMaskConnector,
+        ["electric-turret"]: prototype.CollisionMaskConnector,
+        ["fluid-turret"]: prototype.CollisionMaskConnector,
+        ["furnace"]: prototype.CollisionMaskConnector,
+        ["generator"]: prototype.CollisionMaskConnector,
+        ["heat-interface"]: prototype.CollisionMaskConnector,
+        ["infinity-pipe"]: prototype.CollisionMaskConnector,
+        ["inserter"]: prototype.CollisionMaskConnector,
+        ["lab"]: prototype.CollisionMaskConnector,
+        ["market"]: prototype.CollisionMaskConnector,
+        ["mining-drill"]: prototype.CollisionMaskConnector,
+        ["offshore-pump"]: prototype.CollisionMaskConnector,
+        ["pipe-to-ground"]: prototype.CollisionMaskConnector,
+        ["pipe"]: prototype.CollisionMaskConnector,
+        ["plant"]: prototype.CollisionMaskConnector,
+        ["fusion-generator"]: prototype.CollisionMaskConnector,
+        ["fusion-reactor"]: prototype.CollisionMaskConnector,
+        ["power-switch"]: prototype.CollisionMaskConnector,
+        ["programmable-speaker"]: prototype.CollisionMaskConnector,
+        ["pump"]: prototype.CollisionMaskConnector,
+        ["radar"]: prototype.CollisionMaskConnector,
+        ["reactor"]: prototype.CollisionMaskConnector,
+        ["rocket-silo-rocket-shadow"]: prototype.CollisionMaskConnector,
+        ["rocket-silo-rocket"]: prototype.CollisionMaskConnector,
+        ["selector-combinator"]: prototype.CollisionMaskConnector,
+        ["simple-entity-with-force"]: prototype.CollisionMaskConnector,
+        ["simple-entity-with-owner"]: prototype.CollisionMaskConnector,
+        ["simple-entity"]: prototype.CollisionMaskConnector,
+        ["storage-tank"]: prototype.CollisionMaskConnector,
+        ["thruster"]: prototype.CollisionMaskConnector,
+        ["tree"]: prototype.CollisionMaskConnector,
+        ["turret"]: prototype.CollisionMaskConnector,
+        ["unit-spawner"]: prototype.CollisionMaskConnector,
+        ["valve"]: prototype.CollisionMaskConnector,
+        ["wall"]: prototype.CollisionMaskConnector,
+        ["display-panel"]: prototype.CollisionMaskConnector,
+
+        ["accumulator"]: prototype.CollisionMaskConnector,
+        ["cargo-pod"]: prototype.CollisionMaskConnector,
+        ["constant-combinator"]: prototype.CollisionMaskConnector,
+        ["electric-pole"]: prototype.CollisionMaskConnector,
+        ["lamp"]: prototype.CollisionMaskConnector,
+        ["solar-panel"]: prototype.CollisionMaskConnector,
+        ["train-stop"]: prototype.CollisionMaskConnector,
+
+        ["cargo-bay"]: prototype.CollisionMaskConnector,
+        ["cargo-landing-pad"]: prototype.CollisionMaskConnector,
+        ["lightning-attractor"]: prototype.CollisionMaskConnector,
+        ["roboport"]: prototype.CollisionMaskConnector,
+        ["rocket-silo"]: prototype.CollisionMaskConnector,
+        ["space-platform-hub"]: prototype.CollisionMaskConnector,
+
+        ["container"]: prototype.CollisionMaskConnector,
+        ["infinity-container"]: prototype.CollisionMaskConnector,
+        ["linked-container"]: prototype.CollisionMaskConnector,
+        ["proxy-container"]: prototype.CollisionMaskConnector,
+        ["logistic-container"]: prototype.CollisionMaskConnector,
+        ["temporary-container"]: prototype.CollisionMaskConnector,
+
+        ["linked-belt"]: prototype.CollisionMaskConnector,
+        ["loader-1x1"]: prototype.CollisionMaskConnector,
+        ["loader"]: prototype.CollisionMaskConnector,
+        ["splitter"]: prototype.CollisionMaskConnector,
+        ["lane-splitter"]: prototype.CollisionMaskConnector,
+        ["transport-belt"]: prototype.CollisionMaskConnector,
+        ["underground-belt"]: prototype.CollisionMaskConnector,
+
+        ["curved-rail-a"]: prototype.CollisionMaskConnector,
+        ["curved-rail-b"]: prototype.CollisionMaskConnector,
+        ["half-diagonal-rail"]: prototype.CollisionMaskConnector,
+        ["legacy-curved-rail"]: prototype.CollisionMaskConnector,
+        ["legacy-straight-rail"]: prototype.CollisionMaskConnector,
+        ["straight-rail"]: prototype.CollisionMaskConnector,
+
+        ["rail-ramp"]: prototype.CollisionMaskConnector,
+        ["rail-ramp/allow_on_deep_oil_ocean"]: prototype.CollisionMaskConnector,
+
+        ["rail-support"]: prototype.CollisionMaskConnector,
+        ["rail-support/allow_on_deep_oil_ocean"]: prototype.CollisionMaskConnector,
+
+        ["elevated-curved-rail-a"]: prototype.CollisionMaskConnector,
+        ["elevated-curved-rail-b"]: prototype.CollisionMaskConnector,
+        ["elevated-half-diagonal-rail"]: prototype.CollisionMaskConnector,
+        ["elevated-straight-rail"]: prototype.CollisionMaskConnector,
+
+        ["rail-chain-signal"]: prototype.CollisionMaskConnector,
+        ["rail-signal"]: prototype.CollisionMaskConnector,
+
+        ["rail-chain-signal/elevated"]: prototype.CollisionMaskConnector,
+        ["rail-signal/elevated"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon"]: prototype.CollisionMaskConnector,
+        ["locomotive"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["locomotive/transition"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["locomotive/elevated"]: prototype.CollisionMaskConnector,
+
+        ["gate"]: prototype.CollisionMaskConnector,
+        ["gate/opened"]: prototype.CollisionMaskConnector,
+
+        ["arrow"]: prototype.CollisionMaskConnector,
+        ["artillery-flare"]: prototype.CollisionMaskConnector,
+        ["artillery-projectile"]: prototype.CollisionMaskConnector,
+        ["beam"]: prototype.CollisionMaskConnector,
+        ["capture-robot"]: prototype.CollisionMaskConnector,
+        ["character-corpse"]: prototype.CollisionMaskConnector,
+        ["combat-robot"]: prototype.CollisionMaskConnector,
+        ["construction-robot"]: prototype.CollisionMaskConnector,
+        ["explosion"]: prototype.CollisionMaskConnector,
+        ["fire"]: prototype.CollisionMaskConnector,
+        ["highlight-box"]: prototype.CollisionMaskConnector,
+        ["item-request-proxy"]: prototype.CollisionMaskConnector,
+        ["leaf-particle"]: prototype.CollisionMaskConnector,
+        ["lightning"]: prototype.CollisionMaskConnector,
+        ["logistic-robot"]: prototype.CollisionMaskConnector,
+        ["particle-source"]: prototype.CollisionMaskConnector,
+        ["particle"]: prototype.CollisionMaskConnector,
+        ["projectile"]: prototype.CollisionMaskConnector,
+        ["projectile/hit"]: prototype.CollisionMaskConnector,
+        ["smoke-with-trigger"]: prototype.CollisionMaskConnector,
+        ["smoke"]: prototype.CollisionMaskConnector,
+        ["speech-bubble"]: prototype.CollisionMaskConnector,
+        ["sticker"]: prototype.CollisionMaskConnector,
+        ["stream"]: prototype.CollisionMaskConnector,
+        ["tile"]: prototype.CollisionMaskConnector,
+
+        ["car"]: prototype.CollisionMaskConnector,
+        ["character"]: prototype.CollisionMaskConnector,
+        ["character/flying"]: prototype.CollisionMaskConnector,
+        ["cliff"]: prototype.CollisionMaskConnector,
+        ["corpse"]: prototype.CollisionMaskConnector,
+        ["deconstructible-tile-proxy"]: prototype.CollisionMaskConnector,
+        ["entity-ghost"]: prototype.CollisionMaskConnector,
+        ["fish"]: prototype.CollisionMaskConnector,
+        ["heat-pipe"]: prototype.CollisionMaskConnector,
+        ["item-entity"]: prototype.CollisionMaskConnector,
+        ["land-mine"]: prototype.CollisionMaskConnector,
+        ["player-port"]: prototype.CollisionMaskConnector,
+        ["rail-remnants"]: prototype.CollisionMaskConnector,
+        ["resource"]: prototype.CollisionMaskConnector,
+        ["spider-leg"]: prototype.CollisionMaskConnector,
+        ["spider-unit"]: prototype.CollisionMaskConnector,
+        ["spider-vehicle"]: prototype.CollisionMaskConnector,
+        ["tile-ghost"]: prototype.CollisionMaskConnector,
+        ["unit"]: prototype.CollisionMaskConnector,
+        ["segment"]: prototype.CollisionMaskConnector,
+        ["segmented-unit"]: prototype.CollisionMaskConnector,
+        ["decorative"]: prototype.CollisionMaskConnector,
+    }
+
+    const masks: MaskType;
+
+    export default masks;
+}

package/src/lualib/collision-mask-util.d.ts

@@ -0,0 +1,23 @@
+declare module "collision-mask-util" {
+    export function get_default_mask(this: void, type: string): prototype.CollisionMaskConnector;
+
+    export function get_mask(
+        this: void,
+        entity_prototpe: { collision_mask: prototype.CollisionMaskConnector, type: string }): prototype.CollisionMaskConnector;
+
+    export function masks_collide(this: void, mask1: prototype.CollisionMaskConnector, mask2: prototype.CollisionMaskConnector): boolean;
+
+    export function masks_are_same(this: void, mask1: prototype.CollisionMaskConnector, mask2: prototype.CollisionMaskConnector): boolean;
+
+    export function collect_prototypes_with_mask(this: void, mask: prototype.CollisionMaskConnector): prototype.AnyPrototype[];
+
+    export function collect_prototypes_with_layer(this: void, layer: prototype.CollisionLayerID): prototype.AnyPrototype[];
+
+    export function collect_prototypes_colliding_with_mask(this: void, mask: prototype.CollisionMaskConnector): prototype.AnyPrototype[];
+
+    export function replace_layer_in_all_prototypes(this: void, old_name: prototype.CollisionLayerID, new_name: prototype.CollisionLayerID): void;
+
+    export function new_mask(this: void): prototype.CollisionMaskConnector;
+
+    export function migrate_from_before_1_2_0(this: void, old_mask: Record<prototype.CollisionLayerID, true>): prototype.CollisionMaskConnector; 
+}

package/src/lualib/crash-site.d.ts

@@ -0,0 +1,35 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/crash-site.lua
+declare module "crash-site" {
+    export interface ShipPart {
+        name: string;
+        angle_deviation: number;
+        variations?: number;
+        max_distance?: number;
+        min_separation?: number;
+        fire_count?: number;
+        explosion_count?: number;
+        repeat_count?: number;
+        scale_lifetime?: boolean;
+    }
+
+    export function create_crash_site(
+        this: void,
+        surface: runtime.LuaSurface,
+        position: runtime.MapPosition,
+        ship_items: runtime.ItemStackIdentification[],
+        part_items: runtime.ItemStackIdentification[],
+        ship_parts: ShipPart[]): void;
+
+    export function create_cutscene(
+        this: void,
+        player: runtime.LuaPlayer,
+        goal_position: runtime.MapPosition): void
+    
+    export function is_crash_site_cutscene(this: void, event: runtime.on_cutscene_waypoint_reached): boolean;
+
+    export function on_player_display_refresh(
+        this: void,
+        event: runtime.on_player_display_resolution_changed | runtime.on_player_display_scale_changed): void;
+
+    export function default_ship_parts(): ShipPart[];
+}

package/src/lualib/data-duplicate-checker.d.ts

@@ -0,0 +1,6 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/data-duplicate-checker.lua
+declare module "data-duplicate-checker" {
+    export function check_for_duplicates(this: void, prototypes: Record<string, prototype.AnyPrototype>, overwrite: prototype.AnyPrototype): void;
+
+    export function check_for_overwrites(this: void, prototypes: Record<string, prototype.AnyPrototype>, overwrite: prototype.AnyPrototype): void;
+}

package/src/lualib/event_handler.d.ts

@@ -0,0 +1,16 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/event_handler.lua
+declare module "event_handler" {
+    // Looking at the implementation of these functions, the objects seem close to LuaBootstrap as they have many of the same members
+    // on_configuration_changed, on_init, on_load, etc
+    // they also have a few additional fields not mentioned elsewhere
+    // hopefull this type is close enough
+    export type Library = Partial<runtime.LuaBootstrap> & {
+        add_remote_interface?: (this: void) => void;
+        add_commands?: (this: void) => void;
+        events: Record<string, runtime.LuaEventType>;
+    }
+
+    export function add_lib(this: void, lib: Library): void;
+
+    export function add_libraries(this: void, libs: Record<string, Library>): void;
+}

package/src/lualib/index.d.ts

@@ -0,0 +1,22 @@
+// Type definitions for Factorio modding API
+// Factorio API reference https://lua-api.factorio.com/latest/index.html
+// src mappings manually written to cover aspects not in the machine-readable API spec
+// Definition source https://github.com/sguest/factorio-types
+
+/// <reference path="./autoplace_utils.d.ts" />
+/// <reference path="./collision-mask-defaults.d.ts" />
+/// <reference path="./collision-mask-util.d.ts" />
+/// <reference path="./crash-site.d.ts" />
+/// <reference path="./data-duplicate-checker.d.ts" />
+/// <reference path="./event_handler.d.ts" />
+/// <reference path="./kill-score.d.ts" />
+/// <reference path="./math2d.d.ts" />
+/// <reference path="./math3d.d.ts" />
+/// <reference path="./meld.d.ts" />
+/// <reference path="./mod-gui.d.ts" />
+/// <reference path="./production-score.d.ts" />
+/// <reference path="./resource-autoplace.d.ts" />
+/// <reference path="./silo-script.d.ts" />
+/// <reference path="./space-finish-script.d.ts" />
+/// <reference path="./surface-render-parameter-effects.d.ts" />
+/// <reference path="./util.d.ts" />

package/src/lualib/kill-score.d.ts

@@ -0,0 +1,8 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/kill-score.lua
+declare module "kill-score" {
+    export function generate_entity_prices(this: void, param?: { prices?: Record<string,number>, item_prices?: Record<string, number> }): Record<string, number>
+
+    export function get_kill_scores(this: void, price_list?: Record<string, number>): Record<string, number>;
+
+    export function get_default_prices(this: void): Record<string, number>;
+}

package/src/lualib/math2d.d.ts

@@ -0,0 +1,41 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/math2d.lua
+declare module "math2d" {
+    export const projection_constant = 0.7071067811865;
+
+    export const vector: {
+        from_orientation(this: void, orientation: number, length: number): runtime.Vector;
+        to_orientation(this: void, vec: runtime.Vector): number;
+        length(this: void, vec: runtime.Vector): number;
+        projected(this: void, vec: runtime.Vector): runtime.Vector;
+    }
+
+    export const position: {
+        /**
+         * Takes a position that might be either a two element array, or a table
+         * with x and y keys, and returns a position with x and y keys.
+         */
+        ensure_xy(this: void, pos: runtime.MapPosition): { x: number, y: number };
+        distance_squared(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): number;
+        distance(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): number;
+        rotate_vector(this: void, vector: runtime.Vector, angle_in_deg: number): runtime.Vector;
+        subtract(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): runtime.MapPosition;
+        add(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): runtime.MapPosition;
+        multiply_scalar(this: void, vec: runtime.Vector, scalar: number): runtime.Vector;
+        divide_scalar(this: void, vec: runtime.Vector, scalar: number): runtime.Vector;
+        vector_length(this: void, vec: runtime.Vector): number;
+        get_normalized(this: void, vec: runtime.Vector): runtime.Vector;
+    }
+
+    export const bounding_box: {
+        /**
+         * Takes a bounding box with positions that might be either two element arrays, or tables
+         * with x and y keys, and returns a bounding box with positions with x and y keys
+         */
+        ensure_xy(this: void, bounding_box: runtime.BoundingBox): {left_top: {x : number, y: number}, right_bottom: {x: number, y: number}};
+        get_centre(this: void, box: runtime.BoundingBox): runtime.MapPosition;
+        contains_point(this: void, box: runtime.BoundingBox, point: runtime.MapPosition): boolean;
+        contains_box(this: void, box: runtime.BoundingBox, other: runtime.BoundingBox): boolean;
+        collides_with(this: void, box1: runtime.BoundingBox, box2: runtime.BoundingBox): boolean;
+        create_from_centre(this: void, centre: runtime.MapPosition, width: number, height: number): runtime.BoundingBox;
+    }
+}

package/src/lualib/math3d.d.ts

@@ -0,0 +1,64 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/math3d.lua
+
+// The Vector4 type doesn't exist at runtime so the vector4 references it from prototype instead of runtime like the rest of the file
+// However, this is all just math and the Vector/Vector3D types are all equivalent between prototype and runtime stages
+// Therefore this is a case where mixing and matching prototype and runtime stage members is OK
+declare module "math3d" {
+    export const projection_constant = 0.7071067811865;
+
+    export function project_vec3(this: void, vec3: runtime.Vector3D): runtime.Vector;
+
+    export const vector4: {
+        zero: [0, 0, 0, 0];
+        dot_product(this: void, u: prototype.Vector4f, v: prototype.Vector4f): number;
+        add(this: void, u: prototype.Vector4f, v: prototype.Vector4f): prototype.Vector4f;
+        sub(this: void, u: prototype.Vector4f, v: prototype.Vector4f): prototype.Vector4f;
+        from_vec3(this: void, u: prototype.Vector3D): prototype.Vector4f;
+    }
+
+    export const vector3: {
+        zero: [0, 0, 0];
+        dot_product(this: void, u: runtime.Vector3D, v: runtime.Vector3D): number;
+        add(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        sub(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        mul(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        cross_product(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        angle(this: void, u: runtime.Vector3D, v: runtime.Vector3D): number;
+    }
+
+    export const vector2: {
+        zero: [0, 0];
+        dot_product(this: void, u: runtime.Vector, v: runtime.Vector): number;
+        add(this: void, u: runtime.Vector, v: runtime.Vector): runtime.Vector;
+        sub(this: void, u: runtime.Vector, v: runtime.Vector): runtime.Vector;
+        mul(this: void, u: runtime.Vector, k: runtime.Vector): runtime.Vector;
+        rotate(this: void, v: runtime.Vector, phi: number): runtime.Vector;
+    }
+
+    export type Matrix4x4 = [
+        [number, number, number, number],
+        [number, number, number, number],
+        [number, number, number, number],
+        [number, number, number, number],
+    ];
+
+    export const matrix4x4: {
+        identity: [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1],
+        ];
+        rotation_x(this: void, phi: number): Matrix4x4;
+        rotation_y(this: void, phi: number): Matrix4x4;
+        rotation_z(this: void, phi: number): Matrix4x4;
+        translation(this: void, x: number, y: number, z: number): Matrix4x4;
+        translation_vec3(this: void, vec3: runtime.Vector3D): Matrix4x4;
+        scale(this: void, x: number, y: number, z: number): Matrix4x4;
+        column(this: void, mat: Matrix4x4, index: number): [number, number, number, number];
+        transpose(this: void, mat: Matrix4x4): Matrix4x4;
+        mul_mat(this: void, m1: Matrix4x4, m2: Matrix4x4): Matrix4x4;
+        mul_vec3(this: void, mat: Matrix4x4, vec: runtime.Vector3D): runtime.Vector3D;
+        compose(this: void, list: Matrix4x4[]): Matrix4x4;
+    }
+}

package/src/lualib/meld.d.ts

@@ -0,0 +1,33 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/meld.lua
+
+// Lots of "any" types in this declaration - it's not immediately obvious what it's supposed to do and not many example usages in the base mod
+declare module "meld" {
+
+    export const control_marker: {};
+
+    export const controler_handlers: {
+        delete(this: void, target: any, k: string, v: any): void;
+        overwrite(this: void, target: any, k: string, v: any): any;
+        invoke(this: void, target: any, k: string, v: any): any;
+        append(this: void, target: any, k: string, v: any): void;
+    };
+
+    function _delete(this: void): void;
+    export { _delete as delete };
+
+    export function overwrite(this: void, _new: any): any;
+
+    export function invoke(this: void, fct: any): any;
+
+    export function append(this: void, data: any): any;
+
+    /**
+     * recursive table merge but it reuses target table (this: void, does not deepcopy it). When target is not to be reused or more than
+     *  2 tables are to be merged, consider using util.merge. When there is conflict of 2 values, a value from the source will
+     *  win overwriting the existing value. There are also control structures available for extra operations that would not
+     *  be possible under normal merge rules
+     */
+    export function meld(this: void, target: Table, source: Table): Table
+}
+
+declare function meld(this: Table, target: Table, source: Table): void;

package/src/lualib/mod-gui.d.ts

@@ -0,0 +1,25 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/mod-gui.lua
+
+/*
+Hello script explorer, if you are looking to upgrade your mod to use the mod gui, its pretty simple.
+
+Typically you will have something like:
+player.gui.left.add{...}
+
+All you will need to do, is change it to:
+mod_gui.get_frame_flow(player).add{...}
+
+And for buttons its just the same:
+mod_gui.get_button_flow(player).add{...}
+
+It should be as simple as find and replace.
+
+Any other questions please feel free to ask on the modding help forum.
+*/
+declare module "mod-gui" {
+    export const button_style = "mod_gui_button";
+    export const frame_style = "non_draggable_frame"
+
+    export function get_button_flow(this: void, player: runtime.LuaPlayer): runtime.LuaGuiElement;
+    export function get_frame_flow(this: void, player: runtime.LuaPlayer): runtime.LuaGuiElement;
+}

package/src/lualib/production-score.d.ts

@@ -0,0 +1,13 @@
+declare module "production-score" {
+    export function generate_price_list(this: void, param?: {
+        seed_prices?: Record<string, number>,
+        ingedient_exponent?: number,
+        raw_resource_price?: number,
+        resource_ignore?: Record<string, string>,
+        round?: (this: void, num: number) => number,
+        energy_addition?: (this: void, recipe: runtime.LuaRecipe, cost: number) => number,
+        normalise?: (this: void, num: number) => number,
+    }): Record<string, number>;
+
+    export function get_production_scores(this: void, price_list?: Record<string,number>): Record<string, number>;
+}

package/src/lualib/resource-autoplace.d.ts

@@ -0,0 +1,35 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/resource-autoplace.lua
+declare module "resource-autoplace" {
+    /**
+     * Indicate that a patch set exists and optionally that it also needs a separate starting patch set.
+     * Call this to initialize patch sets' indexes in a more deterministic order
+     * (see resources.lua for an example) before calling resource_autoplace_settings.
+     */
+    export function initialize_patch_set(this: void, patch_set_name: string, has_starting_area_placement: boolean, autoplace_set_name: string): void
+
+    /**
+     * Creates and returns an AutoplaceSpecification that will generate spot-based ore patches.
+     * @param params.name name for the type, used as the default autoplace control name and patch set name (each of which can be overridden separately)
+     * @param params.base_density amount of stuff, on average, to be placed per tile
+     * @param params.patch_set_name name of the patch set; patches sets of the same name and seed1 will overlap; default: name
+     * @param params.autoplace_control_name name of the corresponding autoplace control; default: name
+     * @param params.random_probability probability of placement at any given tile within a patch; default: 1
+     * @param params.base_spots_per_km2 number of patches per square kilometer near the starting area
+     * @param params.has_starting_area_placement true|false|nil - yes, no, and there is no special starting area, respectively
+     * @param params.seed1 random seed to use when generating patch positions; default: 100
+     */
+    export function resource_autoplace_settings(this: void, params: {
+        name: string,
+        base_density: number,
+        patch_set_name?: string,
+        autoplace_control_name?: string,
+        random_probability?: number,
+        base_spots_per_km2?: number,
+        has_starting_area_placement?: boolean | null,
+        seed1?: number,
+    }): {
+        order: string,
+        probability_expression: string,
+        richness_expression: string,
+    }
+}

package/src/lualib/silo-script.d.ts

@@ -0,0 +1,19 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/silo-script.lua
+declare module "silo-script" {
+    export const events: { [defines.events.on_rocket_launched]: (this: void, event: runtime.on_rocket_launched) => void };
+
+    export function on_configuration_changed(this: void): void;
+
+    export function on_init(this: void): void;
+
+    export function on_load(this: void): void;
+
+    /** legacy */
+    export function get_events(this: void): { [defines.events.on_rocket_launched]: (this: void, event: runtime.on_rocket_launched) => void };
+
+    /** legacy */
+    export function add_remote_interface(this: void): void;
+
+    /** legacy */
+    export function add_commands(this: void): void;
+}

package/src/lualib/space-finish-script.d.ts

@@ -0,0 +1,10 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/space-finish-script.lua
+declare module "space-finish-script" {
+    export const events: { [defines.events.on_space_platform_changed_state]: (this: void, event: runtime.on_space_platform_changed_state) => void }
+
+    export function on_configuration_changed(this: void): void;
+
+    export function on_init(this: void): void;
+
+    export function on_load(this: void): void;
+}

package/src/lualib/surface-render-parameter-effects.d.ts

@@ -0,0 +1,6 @@
+// github.com/wube/factorio-data/blob/master/core/lualib/surface-render-parameter-effects.lua
+declare module "surface-render-parameter-effects" {
+    export function default_clouds_effect_properties(this: void): prototype.CloudsEffectProperties;
+
+    export function default_fog_effect_properties(this: void): prototype.FogEffectProperties;
+}

package/src/lualib/util.d.ts

@@ -0,0 +1,167 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/util.lua
+declare module "util" {
+    export const table: {
+        deepcopy<T>(this: void, value: T): T;
+        compare(this: void, table1: object | [], table2: object | []): boolean;
+    }
+
+    export function copy<T>(this: void, value: T): T;
+
+    export function distance(this: void, position1: runtime.MapPosition, position2: runtime.MapPosition): number;
+
+    export function positiontostr(this: void, pos: runtime.MapPosition): string;
+
+    export function formattime(this: void, ticks: number): string;
+
+    /** supports 'rrggbb', 'rgb', 'rrggbbaa', 'rgba', 'ww', 'w' */
+    export function color(this: void, hex: string): runtime.Color;
+
+    export function premul_color(this: void, color: runtime.Color): runtime.Color;
+
+    export function mix_color(this: void, c1: runtime.Color, c2: runtime.Color): runtime.Color;
+
+    export function multiply_color(this: void, c1: runtime.Color, n?: number): runtime.Color;
+
+    export function get_color_with_alpha(this: void, color: runtime.Color, alpha: number, normalized_alpha: number): runtime.Color;
+
+    export const direction_vectors: Record<defines.direction, runtime.MapPosition>;
+
+    export function moveposition(this: void, position: runtime.MapPosition, direction: defines.direction, distance: number): runtime.MapPosition;
+
+    /** orientation of 1 = 360 degrees */
+    export function rotate_position(this: void, position: runtime.MapPosition, orientation: number): runtime.MapPosition;
+
+    export function oppositedirection(this: void, direction: defines.direction): defines.direction;
+
+    export function multiplystripes<T>(this: void, count: number, stripes: T[]): T[];
+
+    export function by_pixel(this: void, x: number, y: number): { x: number, y: number }
+
+    export function by_pixel_hr(this: void, x: number, y: number): { x: number, y: number }
+
+    export function foreach_sprite_definition<T>(this: void, table_: T, fun_: (table: T) => void): T
+
+    export function add_shift<T>(this: void, a: [T, T], b: [T, T]): [T, T];
+
+    export function add_shift_offset<T>(this: void, offset_: [T, T], table_: [T, T]): [T, T];
+
+    export function mul_shift(this: void, shift: runtime.MapPosition, scale: number): runtime.MapPosition;
+
+    export function format_number(this: void, amount: number, append_suffix: boolean): string;
+
+    export function increment(this: void, t: number[], k: number, v: number): void;
+
+    export function conditional_return<T>(this: void, value: bool, data: T): T | false;
+
+    /**
+     * Recursively merges and/or deep-copies tables.
+     * Entries in later tables override entries in earlier ones, unless
+     * both entries are themselves tables, in which case they are recursively merged.
+     * Non-merged tables are deep-copies, so that the result is brand new.
+     */
+    export function merge(this: void, tables: object[]): object;
+
+    export function insert_safe(this: void, entity: runtime.LuaEntity, item_dict: Record<string, number>): void;
+
+    export function remove_safe(this: void, entity: runtime.LuaEntity, item_dict: Record<string, number>): void;
+
+    export function split_whitespace(this: void, string: string): string[];
+
+    export function split(this: void, inputstr: string, sep: string): string[];
+
+    export function string_starts_with(this: void, str: string, start: string): boolean;
+
+    export function string_replace(this: void, str: string, what: string, _with: string): string;
+
+    export function clamp(this: void, x: number, lower: number, upper: number): number;
+
+    export function get_walkable_tile(this: void): string;
+
+    /**
+     * This function takes 2 icons tables, and adds the second to the first, but applies scale, shift and tint to the entire second set.
+     * This allows you to manulipate the entire second icons table in the same way as you would manipulate a single icon when adding to the icons table.
+     */
+    export function combine_icons(
+        this: void,
+        icons1: prototype.IconData[],
+        icons2: prototype.IconData[],
+        inputs: {
+            scale?: number,
+            shift?: number,
+            tint?: runtime.Color,
+        },
+        default_icon_size?: prototype.SpriteSizeType): prototype.IconData[]
+
+    export function technology_icon_constant_damage(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_speed(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_movement_speed(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_range(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_planet(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_equipment(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_followers(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_capacity(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_stack_size(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_productivity(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_recipe_productivity(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_braking_force(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function technology_icon_constant_mining(this: void, technology_icon: prototype.FileName): prototype.IconData[];
+
+    export function parse_energy(this: void, energy: string): number;
+
+    export function product_amount(this: void, product: prototype.ProductPrototype): number;
+
+    export function empty_sprite(this: void): prototype.IconData;
+
+    export function empty_animation(this: void, animation_length: number): prototype.RotatedAnimation;
+
+    export function empty_icon(this: void): prototype.IconData;
+
+    export function draw_as_glow<T extends prototype.AnimationPrototype | prototype.SpritePrototype>(this: void, layer: T): T;
+
+    export function sprite_load(this: void, path: prototype.FileName, table: prototype.SpriteSheet): prototype.SpriteSheet;
+
+    export function spritesheets_to_pictures(this: void, spritesheets: prototype.SpriteSheet[]): prototype.SpriteSheet[];
+
+    /**
+     * Does not handle:
+     *  explicit tile filters in "selection-tool" items
+     *  ItemPrototype::place_as_tile
+     *  TilePrototype::next_direction
+     *  TilePrototype::transition_merges_with_tile
+     *  general tile transitions, only removes tile names from water_tile_type_names
+     */
+    export function remove_tile_references(this: void, data: DataType, array_of_tiles_to_remove: string[]): void;
+
+    export function remove_from_list<T>(this: void, list: T[], value: T): boolean;
+
+    export function list_to_map<T extends string | number | symbol>(this: void, list: T[]): Record<T, true>;
+
+    export function normalize_recipe_product<T extends prototype.ProductPrototype>(this: void, raw_product: T): T;
+
+    export function normalize_recipe_products(this: void, recipe: prototype.RecipePrototype): prototype.ProductPrototype[];
+
+    /**
+     * Returns the normalized main product or nil if the recipe definition is invalid or there is no main product
+     */
+    export function get_recipe_main_product(this: void, recipe: prototype.RecipePrototype, normalized_products: prototype.ProductPrototype[]): prototype.ProductPrototype;
+
+    export function is_sprite_def(this: void, array: any): array is prototype.AnimationPrototype | prototype.SpriteParameters;
+
+    /**
+     * Recursively tint all sprite definitions in the given table.
+     * If `tint` is `false`, all tinting will be removed
+     */
+    export function recursive_tint(this: void, array: Array<prototype.AnimationPrototype | prototype.SpriteParameters>, tint: prototype.Color | false): Array<prototype.AnimationPrototype | prototype.SpriteParameters>
+}

package/src/serpent.d.ts

@@ -4,9 +4,9 @@
 // Definition source https://github.com/sguest/factorio-types
 
 interface Serpent {
-    dump(this: void, a: object, options: SerpentOptions): string
-    line(this: void, a: object, options: SerpentOptions): string
-    block(this: void, a: object, options: SerpentOptions): string
+    dump(this: void, a: object, options?: SerpentOptions): string
+    line(this: void, a: object, options?: SerpentOptions): string
+    block(this: void, a: object, options?: SerpentOptions): string
     load(this: void, str: string, options?: {safe?: boolean}): string
 }
 
@@ -17,6 +17,7 @@ interface SerpentOptions {
     sparse?: boolean
     compact?: boolean
     fatal?: boolean
+    fixradix?: boolean
     nocode?: boolean
     nohuge?: boolean
     maxlevel?: number

package/tsconfig.base.json

@@ -11,5 +11,24 @@
         "luaTarget": "JIT",
         "noImplicitSelf": true,
         "noImplicitGlobalVariables": true,
+        "noResolvePaths": [
+            "autoplace_utils",
+            "collision-mask-defaults",
+            "collision-mask-util",
+            "crash-site",
+            "data-duplicate-checker",
+            "event_handler",
+            "kill-score",
+            "math2d",
+            "math3d",
+            "meld",
+            "mod-gui",
+            "production-score",
+            "resource-autoplace",
+            "silo-script",
+            "space-finish-script",
+            "surface-render-parameter-effects",
+            "util"
+        ]
     },
 }