factorio-types 1.1.0 → 1.2.1

package/index.d.ts

@@ -3,13 +3,15 @@
 // 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="./dist/core.d.ts" />
+/// <reference path="./src/core.d.ts" />
+/// <reference path="./src/settings.d.ts" />
+/// <reference path="./src/serpent.d.ts" />
+/// <reference path="./src/lualib/noise.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/serpent.d.ts" />
 /// <reference path="./dist/prototypes.d.ts" />
 /// <reference path="./dist/types.d.ts" />
 /// <reference types="lua-types/jit" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-types",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Typescript declarations for the Factorio mod API",
   "main": "index.d.ts",
   "repository": "https://github.com/sguest/factorio-types.git",
@@ -8,13 +8,11 @@
   "license": "MIT",
   "scripts": {
     "validate": "tsc -p tsconfig.json",
-    "copy-source": "cpy src/*.d.ts dist",
-    "build": "ts-node json_parser/parser.ts && yarn run copy-source",
-    "rebuild": "ts-node json_parser/parser.ts -clean && yarn run copy-source"
+    "build": "ts-node json_parser/parser.ts",
+    "rebuild": "ts-node json_parser/parser.ts -clean"
   },
   "devDependencies": {
     "@types/node": "^15.12.2",
-    "cpy-cli": "^3.1.1",
     "node-html-parser": "^1.1.16",
     "ts-node": "^10.0.0",
     "typescript": "^5.4.2",
@@ -23,13 +21,14 @@
   "files": [
     "index.d.ts",
     "tsconfig.base.json",
+    "src/**/*.d.ts",
     "dist/**/*.d.ts"
   ],
-  "factorioVersion": "1.1.107",
+  "factorioVersion": "1.1.108",
   "dependencies": {
     "lua-types": "^2.13.1"
   },
   "peerDependencies": {
     "typescript-to-lua": "^1.25.1"
   }
-}
+}

package/{dist → src}/core.d.ts

@@ -5,6 +5,7 @@
 
 declare namespace table {
     function deepcopy<T>(this: void, value: T): T;
+    function compare(this: void, table1: object | [], table2: object | []): boolean;
 }
 
 declare const data: {
@@ -29,7 +30,46 @@ declare const serpent: Serpent;
 // can eventually fix these on a per-case basis
 type Table = any;
 
-// https://lua-api.factorio.com/latest/types/DataExtendMethod.html
+type uint = number;
+
+/*
+ * The data.extend method. It's the primary way to add prototypes to the data table.
+ * 
+ * The method has two positional function parameters:
+ * 
+ * - `self` :: [Data](prototype:Data): Usually provided by calling `data:extend(otherdata)`, which is syntax sugar for `data.extend(data, otherdata)`.
+ * 
+ * - `otherdata` :: array[[AnyPrototype](prototype:AnyPrototype)]: A continuous array of non-abstract prototypes.",
+ * @example
+ * ```
+ * data:extend({\n  {\n    type = \"item\",
+ *     name = \"a-thing\",
+ *     icon = \"__base__/graphics/icons/coal.png\",
+ *     icon_size = 64,
+ *     stack_size = 2
+ *   }
+ * })
+ * ```,
+ * @example
+ * ```
+ * local recipe_cat =
+ * {
+ *   type = \"recipe-category\",
+ *   name = \"my-category\"
+ * }
+ * local assembler =
+ * {
+ *   type = \"assembling-machine\",
+ *   name = \"cool-assembler\",
+ *   energy_usage = \"30kW\",
+ *   energy_source = {type = \"void\"},
+ *   crafting_speed = 1,
+ *   crafting_categories = {\"crafting\"}
+ * }
+ * 
+ * data:extend({recipe_cat, assembler})
+ * ```
+ */
 type DataExtendMethod = (data: prototype.Data, ...otherData: any[]) => void;
 
 // The docs and json definition make reference to these types but have no information as to what they are

package/src/lualib/noise.d.ts

@@ -0,0 +1,194 @@
+/** @noSelfInFile */
+/** @noResolution */
+declare module "noise" {
+    interface tileProps {
+        x: prototype.NoiseVariable,
+        y: prototype.NoiseVariable,
+        distance: prototype.NoiseExpression,
+        tier: prototype.NoiseExpression,
+    }
+
+    interface mapProps {
+        seed: prototype.NoiseVariable
+        width: prototype.NoiseVariable
+        height: prototype.NoiseVariable
+        starting_area_radius: prototype.NoiseVariable
+        segmentation_multiplier: prototype.NoiseVariable
+        terrace_elevation_offset: prototype.NoiseVariable
+        terrace_elevation_interval: prototype.NoiseVariable
+        /**
+         * Add this to your (presumably centered around 0) elevation to correct water coverage
+         */
+        wlc_elevation_offset: prototype.NoiseVariable
+        /**
+         * minimum elevation to be applied to areas outside the starting lake *after* the offset
+         */
+        wlc_elevation_minimum: prototype.NoiseVariable
+        water_level: prototype.NoiseVariable
+        finite_water_level: prototype.NoiseVariable
+    }
+
+    type NoiseOperand = prototype.NoiseExpression | number;
+
+    /**
+     * Emitted as overloaded operator - `noise.add(x, y)` becomes `x + y`
+     */
+    const add: LuaAddition<NoiseOperand, NoiseOperand, prototype.NoiseFunctionAdd>;
+    /**
+     * Emitted as overloaded operator - `noise.sub(x, y)` becomes `x - y`
+     */
+    const sub: LuaSubtraction<NoiseOperand, NoiseOperand, prototype.NoiseFunctionSubtract>;
+    /**
+     * Emitted as overloaded operator - `noise.mul(x, y)` becomes `x * y`
+     */
+    const mul: LuaMultiplication<NoiseOperand, NoiseOperand, prototype.NoiseFunctionMultiply>;
+    /**
+     * Emitted as overloaded operator - `noise.div(x, y)` becomes `x / y`
+     */
+    const div: LuaDivision<NoiseOperand, NoiseOperand, prototype.NoiseFunctionDivide>;
+    /**
+     * Emitted as overloaded operator - `noise.unm(x)` becomes `-x`
+     */
+    const unm: LuaNegation<NoiseOperand, prototype.NoiseFunctionSubtract>;
+    /**
+     * Emitted as overloaded operator - `noise.pow(x, y)` becomes `x ^ y`
+     */
+    const pow: LuaPower<NoiseOperand, NoiseOperand, prototype.NoiseFunctionExponentiate>;
+
+    type NoiseNumberLike = prototype.NoiseNumber | number;
+
+    /**
+     * @customName var
+     * @noSelf
+     * This is named "var" in lua and will compile as such thanks to annotations. However, var is a reserved word in typescript
+     */
+    function var_get(name: prototype.NoiseVariable['variable_name']): prototype.NoiseVariable
+
+    /**
+     * 
+     * @param level number of levels up *from the caller* we want to take our location from, defaulting to 1.
+     */
+    function csloc(level: number): { filename: string, line_number: number }
+
+    /**
+     * 'to noise expression'
+     * turns simple values into noise expressions and adds a metatable so you can do arithmetic operations on noise expresssions
+     */
+    function to_noise_expression(v: any, sloc: string): prototype.NoiseExpression
+
+    /**
+     * Call this to...define a noise function using lua syntax.
+     * Your lua function will be passed x, y, tile properties, and map properties.
+     * The arguments are 'noise expression' objects to which arithmetic operations may be applied.
+     */
+    function define_noise_function(callback: (x: prototype.NoiseVariable, y: prototype.NoiseVariable, tileProps: tileProps, mapProps: mapProps) => void): prototype.NoiseExpression
+
+    function clamp(v: NoiseNumberLike, min: NoiseNumberLike, max: NoiseNumberLike, sloc: string): prototype.NoiseFunctionClamp
+
+    function compile_time_log(...args: NoiseNumberLike[]): prototype.NoiseFunctionCompileTimeLog
+
+    /**
+     * Useful for preventing tail-calls
+     * because we want to not lose part of the stacktrace
+     * in order that csloc() gives the desired result
+     */
+    function ident(x: prototype.NoiseExpression): prototype.NoiseExpression
+
+    function min(...args: NoiseNumberLike[]): prototype.NoiseNumber
+
+    function max(...args: NoiseNumberLike[]): prototype.NoiseNumber
+
+    function ridge(v: NoiseNumberLike, min: NoiseNumberLike, max: NoiseNumberLike, sloc: string): prototype.NoiseFunctionRidge
+
+    function terrace(v: NoiseNumberLike, offset: prototype.ConstantNoiseNumber, width: prototype.ConstantNoiseNumber, strength: NoiseNumberLike): prototype.NoiseFunctionTerrace
+
+    /**
+     * Terrace at elevations at which the game will place cliffs
+     * if change in elevation is steep enough.
+     * strength = 0: no-op; strength = 1: vertical slopes between terrace elevations
+     */
+    function terrace_for_cliffs(
+        v: NoiseNumberLike,
+        strength: NoiseNumberLike,
+        map: {
+            terrace_elevation_offset: prototype.NoiseVariable,
+            terrace_elevation_interval: prototype.NoiseVariable
+        }): prototype.NoiseExpression
+
+    function make_array(list: any[]): prototype.NoiseExpression
+
+    function make_point_list(list: any[]): prototype.NoiseArrayConstruction
+
+    function distance_from(
+        maximum_distance: prototype.ConstantNoiseNumber | undefined,
+        points: prototype.NoiseArrayConstruction,
+        x: NoiseNumberLike,
+        y: NoiseNumberLike): prototype.NoiseFunctionDistanceFromNearestPoint
+
+    function get_control_setting(name: string): prototype.NoiseExpression
+
+    function absolute_value(val: NoiseNumberLike): prototype.NoiseFunctionAbsoluteValue
+
+    function autoplace_probabililty(autoplace: prototype.NoiseLiteralObject): prototype.NoiseFunctionAutoplaceProbability
+
+    function autoplace_richness(autoplace: prototype.NoiseLiteralObject): prototype.NoiseFunctionAutoplaceRichness
+
+    function fraction(num: NoiseNumberLike, den: NoiseNumberLike): prototype.NoiseNumber
+
+    function function_application(name: string, arguments: prototype.NoiseExpression[], sloc: string): prototype.NoiseFunctionApplication
+
+    function if_else_chain(...arugments: prototype.NoiseExpression[]): prototype.NoiseIfElseChain
+
+    function literal_expression(x: prototype.NoiseExpression): prototype.NoiseLiteralExpression
+
+    function literal_object(val: prototype.AutoplaceSpecification): prototype.NoiseLiteralObject
+
+    function literal_string(str: string, sloc: string): prototype.NoiseLiteralString
+
+    function noise_layer_name_to_id(name: prototype.NoiseLiteralString): prototype.NoiseFunctionNoiseLayerNameToID
+
+    function random(amplitude: prototype.ConstantNoiseNumber): prototype.NoiseFunctionRandomPenalty
+
+    function random_between(lower: NoiseNumberLike, upper: NoiseNumberLike): prototype.NoiseFunctionRandomPenalty
+
+    function random_penalty(source: NoiseNumberLike, random_penalty_amplitude: prototype.ConstantNoiseNumber, opts: prototype.RandomPenaltyArguments): prototype.NoiseFunctionRandomPenalty
+
+    function delimit_procedure(expression: prototype.NoiseExpression): prototype.NoiseProcedureDelimiter
+
+    function log2(power: NoiseNumberLike): prototype.NoiseFunctionLog2
+
+    function fmod(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionModulo
+
+    function floor(value: NoiseNumberLike): prototype.NoiseFunctionFloor
+
+    function ceil(value: NoiseNumberLike): prototype.NoiseFunctionCeil
+
+    function band(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseAnd
+
+    function bor(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseOr
+
+    function bxor(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseXor
+
+    function bnot(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseNot
+
+    function sin(value: NoiseNumberLike): prototype.NoiseFunctionSin
+
+    function cos(value: NoiseNumberLike): prototype.NoiseFunctionCos
+
+    function atan2(value: NoiseNumberLike): prototype.NoiseFunctionAtan2
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function less_than(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionLessThan
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function less_or_equal(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionLessOrEqual
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function equals(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionEquals
+}

package/src/settings.d.ts

@@ -0,0 +1,133 @@
+declare namespace settings {
+    type settingType =
+        /** This kind of seting is available in the prototype stage, and cannot be changed runtime. They have to be set to the same values for all players on a server.*/
+        'startup' |
+        /** This kind of setting is global to an entire save game and can be changed runtime. On servers, only admins can change these settings. */
+        'runtime-global' |
+        /** This kind of setting is only available runtime in the control.lua stage and each player has their own intance of this setting. When a player joins a server their local setting of "keep mod settings per save" determines if the local settings they have set are synced to the loaded save or if the save's settings are used. */
+        'runtime-per-user'
+
+    /**
+     * The base type for all settings. Defines common values
+     */
+    interface SettingBase extends prototype.PrototypeBase {
+        /**
+         * The hidden property can be used to hide mod settings from GUIs, so that they cannot be seen or changed by players.
+         * However, other mods can still access hidden settings.
+         */
+        hidden?: boolean
+        /**
+         * Determines the stage of game at which the setting is available and which tab it is shown in the mod settings menu.
+         */
+        setting_type: settingType
+    }
+
+    /**
+     * A true/false checkbox
+     */
+    interface BoolSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting, in this case whether the checkbox is checked or not.
+         */
+        default_value: boolean
+        /**
+         * Only loadoed if `hidden = true`. This forces the setting to be of this value. This can be useful for mod compatibility.
+         */
+        forced_value?: boolean
+    }
+
+    /**
+     * A signed 64 bit integer textfield (or selection dropdown)
+     */
+    interface IntSetting extends SettingBase {
+        /**
+         * Defines the value of the setting.
+         */
+        default_value: number
+
+        /**
+         * Defines the lowest possible number.
+         */
+        minimum_value?: number
+
+        /**
+         * Defines the highest possible number.
+         */
+        maximum_value?: number
+
+        /**
+         * Makes it possible to force the player to choose between the defined numbers, creates a dropdown instead of a textfield.
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: number[]
+    }
+
+    /**
+     * A double precision floating point textfield (or selection dropdown)
+     */
+    interface DoubleSetting extends SettingBase {
+        /**
+         * Defines the value of the setting.
+         */
+        default_value: number
+
+        /**
+         * Defines the lowest possible number.
+         */
+        minimum_value?: number
+
+        /**
+         * Defines the highest possible number.
+         */
+        maximum_value?: number
+
+        /**
+         * Makes it possible to force the player to choose between the defined numbers, creates a dropdown instead of a textfield.
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: number[]
+    }
+
+    /**
+     * A string textfield (or selection dropdown)
+     */
+    interface StringSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting.
+         */
+        default_value: string
+
+        /**
+         * Defines whether it's possible for the user to set the textfield to empty and apply the setting.
+         */
+        allow_blank?: boolean
+
+        /**
+         * Whether values that are input by the user should have whitespace removed from both ends of the string.
+         */
+        auto_trim?: boolean
+
+        /**
+         * Makes it possible to force the player to choose between the defined strings, creates a dropdown instead of a textfield. The strings in the dropdown can be localized (translated) and can have a tooltip
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: string[]
+    }
+
+    /**
+     * A color picker (sliders), with whole number textfields. Includes alpha.
+     */
+    interface ColorSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting.
+         */
+        default_value: prototype.Color
+    }
+
+    type dataExtendType =
+        ({ type: 'bool-setting' } & BoolSetting) |
+        ({ type: 'int-setting' } & IntSetting) |
+        ({ type: 'double-setting' } & DoubleSetting) |
+        ({ type: 'string-setting' } & StringSetting) |
+        ({ type: 'color-setting' } & ColorSetting)
+}

package/tsconfig.base.json

@@ -4,7 +4,7 @@
         "target": "esnext",
         "lib": ["esnext"],
         "strict": true,
-        "types": ["@typescript-to-lua/language-extensions"],
+        "types": ["factorio-types", "@typescript-to-lua/language-extensions"],
         "strictNullChecks": false
     },
     "tstl": {