@wayward/types 2.14.2-beta.dev.20241222.1 → 2.14.3-beta.dev.20241224.1

package/definitions/game/steamworks/ISteamworks.d.ts

@@ -21,6 +21,7 @@ export interface ISteamworksEvents {
     onSteamNetworkingMessagesSessionRequest(steamIdRemote: string): void;
     onSteamNetworkingMessagesSessionFailed(steamIdRemote: string, state: SteamNetworkingConnectionState, endReason: number): void;
     requestJoinServer(serverInfo: ServerInfo): any;
+    changeBuildId(): any;
 }
 export interface IModPath {
     path: string;

package/definitions/game/steamworks/Steamworks.d.ts

@@ -20,6 +20,7 @@ import { SteamStatArea } from "@wayward/game/steamworks/ISteamworks";
 import type { ISteamBeta } from "@wayward/hosts/shared/interfaces";
 import { type IMatchmakingServer, type INapiDiscordPresenceInfo, type IRemoteFile, type ISteamFriend, type ISteamId, type ISteamworksNetworking, type IWaywardPreload, type IWorkshopItem, type LobbyType } from "@wayward/hosts/shared/interfaces";
 import EventEmitter from "@wayward/utilities/event/EventEmitter";
+import type { IBuildId } from "@wayward/hosts/shared/globalTypes";
 export default class Steamworks extends EventEmitter.Host<ISteamworksEvents> {
     private readonly game;
     protected initialized: boolean;
@@ -88,6 +89,7 @@ export default class Steamworks extends EventEmitter.Host<ISteamworksEvents> {
     getMatchmakingServer(): IMatchmakingServer | undefined;
     getMatchmakingServerPort(): number;
     getSteamNetworking(): ISteamworksNetworking | undefined;
+    setBuildId(id?: string): void;
     initialize(): Promise<IWaywardPreload | undefined>;
     enableSafePaths(): void;
     onUnload(): void;
@@ -114,6 +116,19 @@ export default class Steamworks extends EventEmitter.Host<ISteamworksEvents> {
      * - {@link Island.saveBuildTime}
      */
     get buildTime(): number;
+    /**
+     * Returns the build ID of the game, not depending on any save that's currently loaded.
+     *
+     * **Note that this is NOT based on the deploy ID.** If a deploy reuses a previous build, for example due to no new commits happening,
+     * or due to the tests failing, this build ID will be for that previous build even if the deploy ID is different.
+     *
+     * Build IDs are saved in the following places:
+     * - {@link saveDataGlobal.gameLastPlayedBuildId}
+     * - {@link saveData.gameBuildId}
+     * - {@link Island.mapGenBuildId}
+     * - {@link Island.saveBuildId}
+     */
+    get buildId(): IBuildId | undefined;
     getPublishedMods(): IWorkshopItem[] | undefined;
     getStatInt(name: string): number | undefined;
     /**

package/definitions/game/ui/component/ContextMenu.d.ts

@@ -14,7 +14,7 @@ import Component from "@wayward/game/ui/component/Component";
 import type { TranslationGenerator } from "@wayward/game/ui/component/IComponent";
 import Text, { Heading } from "@wayward/game/ui/component/Text";
 import Bindable from "@wayward/game/ui/input/Bindable";
-import type { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type Tooltip from "@wayward/game/ui/tooltip/Tooltip";
 import type { IDraggableComponent, IDraggableEvents } from "@wayward/game/ui/util/Draggable";
 import Draggable from "@wayward/game/ui/util/Draggable";

package/definitions/game/ui/component/IComponent.d.ts

@@ -14,7 +14,8 @@ import type { ISerializedTranslation } from "@wayward/game/language/ITranslation
 import type Translation from "@wayward/game/language/Translation";
 import type Component from "@wayward/game/ui/component/Component";
 import type { IStringSection } from "@wayward/game/utilities/string/Interpolator";
-export interface IComponentEvents {
+import type { IEventSubscriberEvents } from "@wayward/utilities/event/EventEmitter";
+export interface IComponentEvents extends IEventSubscriberEvents {
     show(): any;
     hide(): any;
     toggleVisible(visible: boolean): any;

package/definitions/game/ui/screen/screens/game/component/ItemComponent.d.ts

@@ -8,29 +8,23 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
-import { Quality } from "@wayward/game/game/IObject";
 import { EquipType } from "@wayward/game/game/entity/IHuman";
 import type { ActionId } from "@wayward/game/game/entity/action/usable/IUsableAction";
-import type UsableAction from "@wayward/game/game/entity/action/usable/UsableAction";
-import type MerchantNPC from "@wayward/game/game/entity/npc/npcs/Merchant";
-import type { IContainer, ItemTypeExtra } from "@wayward/game/game/item/IItem";
 import { ItemType } from "@wayward/game/game/item/IItem";
 import type Item from "@wayward/game/game/item/Item";
 import type MagicalPropertyManager from "@wayward/game/game/magic/MagicalPropertyManager";
 import Component from "@wayward/game/ui/component/Component";
 import type ContextMenu from "@wayward/game/ui/component/ContextMenu";
 import Bindable from "@wayward/game/ui/input/Bindable";
+import { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type ActionBar from "@wayward/game/ui/screen/screens/game/static/ActionBar";
 import type { ActionSlot } from "@wayward/game/ui/screen/screens/game/static/actions/ActionSlot";
 import type { IDraggableEvents } from "@wayward/game/ui/util/Draggable";
 import Draggable from "@wayward/game/ui/util/Draggable";
-import type Sortable from "@wayward/game/ui/util/Sortable";
 import type { ISortableDraggableEvents } from "@wayward/game/ui/util/Sortable";
 import PerfCache from "@wayward/game/utilities/PerfCache";
 import Vector2 from "@wayward/game/utilities/math/Vector2";
-import WeakishSet from "@wayward/utilities/collection/set/WeakishSet";
 import type { Events, IEventEmitter } from "@wayward/utilities/event/EventEmitter";
-import EventEmitter from "@wayward/utilities/event/EventEmitter";
 type ItemSlotExtend = Omit<Component, "event"> & {
     event: IEventEmitter<Component, IItemSlotEvents>;
 };
@@ -104,33 +98,6 @@ export declare enum ItemClasses {
 export declare namespace ItemClasses {
     const IconLocation: (enumValue: ItemDetailIconLocation) => "item-component-icon-location-topleft" | "item-component-icon-location-bottomright";
 }
-export interface IItemComponentHandlerDescription {
-    noDrag?: true;
-    equipSlot?: EquipType;
-    hasHighlight?: SupplierOr<boolean>;
-    getItem?(): Item | undefined;
-    getItemType?(): ItemType | ItemTypeExtra | undefined;
-    getItemQuality?(): ArrayOr<Quality> | undefined;
-    getAction?(): UsableAction | undefined;
-    getActionSlot?(): ActionSlot | undefined;
-    getBindables?(bindables: Bindable[]): Bindable[];
-    getSortable?(): Sortable;
-    getStackQuantity?(): number;
-    getContainer?(): IContainer | undefined;
-    getStackItems?(): readonly Item[];
-    getStackDisplayItem?(): Item | undefined;
-    getDisplayItem?(): Item | undefined;
-    getDurability?(): number;
-    getCooldown?(): number;
-    isDamaged?(): boolean;
-    isDecayed?(): boolean;
-}
-export interface ItemComponentHandler extends IItemComponentHandlerDescription {
-}
-export declare class ItemComponentHandler {
-    readonly isItemComponentHandler = true;
-    constructor(description?: IItemComponentHandlerDescription);
-}
 export declare enum ItemTradeType {
     None = "",
     ToMerchant = "To",
@@ -164,19 +131,10 @@ export interface IItemComponentStaticEvents {
 }
 export default class ItemComponent extends Component implements ItemSlot {
     readonly handler: ItemComponentHandler;
-    static readonly eventGlobal: EventEmitter<null, IItemComponentStaticEvents>;
     static create<C extends ItemComponent = ItemComponent>(handler: ItemComponentHandler, ...params: any[]): C | undefined;
     static registerSlot(slot: ItemSlot): void;
     static getHovered(): ItemComponent | undefined;
     static QUALITY_CLASS_NAMES: PerfCache<string[]>;
-    private static readonly tradingByItem;
-    private static readonly tradingToMerchant;
-    private static readonly tradingFromMerchant;
-    static getTrading(merchant: MerchantNPC, type: ItemTradeType): WeakishSet<Item> | undefined;
-    static isTrading(item: Item, merchant: MerchantNPC): boolean;
-    static toggleTrading(items: Item[], merchant: MerchantNPC, trading: ItemTradeType): ItemTradeType;
-    private static sendMerchantChatMessage;
-    static clearTrading(merchant?: MerchantNPC): void;
     event: IEventEmitter<this, IItemComponentEvents>;
     readonly magicalIcon: Component<HTMLElement> | undefined;
     readonly protectedIcon: Component<HTMLElement> | undefined;
@@ -228,6 +186,7 @@ export default class ItemComponent extends Component implements ItemSlot {
     protected onUpdateDecay(): void;
     protected onUpdateQuality(): void;
     protected onTickEnd(): void;
+    protected onRooted(): void;
     protected onRootedAndAppend(): void;
     protected onLoadedOnIsland(): void;
     protected onActionBarItemSlottedMapUpdate(): void;

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentEventBus.d.ts

@@ -0,0 +1,36 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type { ItemRefreshType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type ActionBar from "@wayward/game/ui/screen/screens/game/static/ActionBar";
+import type { ActionSlot } from "@wayward/game/ui/screen/screens/game/static/actions/ActionSlot";
+import EventEmitter from "@wayward/utilities/event/EventEmitter";
+interface IItemComponentEventBusEvents {
+    update(type: ItemRefreshType): any;
+    changeHovered(): any;
+}
+declare namespace _ {
+    class ItemComponentEventBus extends EventEmitter.Host<IItemComponentEventBusEvents> {
+        private readonly items;
+        private readonly itemsForTickEndEvents;
+        registerItem(component: ItemComponent): void;
+        registerForTickEndEvents(component: ItemComponent): void;
+        deregisterForTickEndEvents(component: ItemComponent): void;
+        protected onUpdate(type: ItemRefreshType): void;
+        protected onSlotUpdate(actionBar: ActionBar, slot: ActionSlot): void;
+        protected onTickEnd(): void;
+        protected onLoadedOnIsland(): void;
+        protected onActionBarItemSlottedMapUpdate(): void;
+    }
+}
+type ItemComponentEventBus = _.ItemComponentEventBus;
+declare function ItemComponentEventBus(): ItemComponentEventBus;
+export default ItemComponentEventBus;

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentHandler.d.ts

@@ -0,0 +1,46 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type UsableAction from "@wayward/game/game/entity/action/usable/UsableAction";
+import type { EquipType } from "@wayward/game/game/entity/IHuman";
+import type { Quality } from "@wayward/game/game/IObject";
+import type { ItemTypeExtra, IContainer } from "@wayward/game/game/item/IItem";
+import { ItemType } from "@wayward/game/game/item/IItem";
+import type Item from "@wayward/game/game/item/Item";
+import type Bindable from "@wayward/game/ui/input/Bindable";
+import type { ActionSlot } from "@wayward/game/ui/screen/screens/game/static/actions/ActionSlot";
+import type Sortable from "@wayward/game/ui/util/Sortable";
+export interface IItemComponentHandlerDescription {
+    noDrag?: true;
+    equipSlot?: EquipType;
+    hasHighlight?: SupplierOr<boolean>;
+    getItem?(): Item | undefined;
+    getItemType?(): ItemType | ItemTypeExtra | undefined;
+    getItemQuality?(): ArrayOr<Quality> | undefined;
+    getAction?(): UsableAction | undefined;
+    getActionSlot?(): ActionSlot | undefined;
+    getBindables?(bindables: Bindable[]): Bindable[];
+    getSortable?(): Sortable;
+    getStackQuantity?(): number;
+    getContainer?(): IContainer | undefined;
+    getStackItems?(): readonly Item[];
+    getStackDisplayItem?(): Item | undefined;
+    getDisplayItem?(): Item | undefined;
+    getDurability?(): number;
+    getCooldown?(): number;
+    isDamaged?(): boolean;
+    isDecayed?(): boolean;
+}
+export interface ItemComponentHandler extends IItemComponentHandlerDescription {
+}
+export declare class ItemComponentHandler {
+    readonly isItemComponentHandler = true;
+    constructor(description?: IItemComponentHandlerDescription);
+}

package/definitions/game/ui/screen/screens/game/component/item/ItemComponentTradeManager.d.ts

@@ -0,0 +1,32 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+import type Human from "@wayward/game/game/entity/Human";
+import type MerchantNPC from "@wayward/game/game/entity/npc/npcs/Merchant";
+import type Item from "@wayward/game/game/item/Item";
+import { ItemTradeType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import WeakishSet from "@wayward/utilities/collection/set/WeakishSet";
+declare namespace _ {
+    class ItemComponentTradeManager {
+        private readonly tradingByItem;
+        private readonly tradingToMerchant;
+        private readonly tradingFromMerchant;
+        getTrading(merchant: MerchantNPC, type: ItemTradeType): WeakishSet<Item> | undefined;
+        getTradeType(item: Item): ItemTradeType | undefined;
+        isTrading(item: Item, merchant: MerchantNPC): boolean;
+        toggleTrading(items: Item[], merchant: MerchantNPC, trading: ItemTradeType): ItemTradeType;
+        private sendMerchantChatMessage;
+        clearTrading(merchant?: MerchantNPC): void;
+        onTrade(merchant: MerchantNPC, human: Human): void;
+    }
+}
+type ItemComponentTradeManager = _.ItemComponentTradeManager;
+declare function ItemComponentTradeManager(): ItemComponentTradeManager;
+export default ItemComponentTradeManager;

package/definitions/game/ui/screen/screens/game/dialog/EquipmentDialog.d.ts

@@ -14,8 +14,8 @@ import Component from "@wayward/game/ui/component/Component";
 import type { IBindHandlerApi } from "@wayward/game/ui/input/Bind";
 import Bindable from "@wayward/game/ui/input/Bindable";
 import Dialog from "@wayward/game/ui/screen/screens/game/component/Dialog";
-import type { IItemDropApi, IItemPickUpApi, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
-import ItemComponent, { ItemRefreshType } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { ItemRefreshType, type IItemDropApi, type IItemPickUpApi, type ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
 import EquipmentSlotTooltipHandler from "@wayward/game/ui/screen/screens/game/dialog/equipment/EquipmentSlotTooltip";
 import { MenuBarButtonType } from "@wayward/game/ui/screen/screens/game/static/menubar/IMenuBarButton";
 export declare enum EquipmentClasses {

package/definitions/game/ui/screen/screens/game/static/actions/ActionSlot.d.ts

@@ -25,8 +25,9 @@ import Component from "@wayward/game/ui/component/Component";
 import type { IRefreshable } from "@wayward/game/ui/component/Refreshable";
 import Text from "@wayward/game/ui/component/Text";
 import type { IBindHandlerApi } from "@wayward/game/ui/input/Bind";
-import type { IItemSlotEvents, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
-import ItemComponent, { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { type IItemSlotEvents, type ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import { ItemComponentHandler } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type ActionBar from "@wayward/game/ui/screen/screens/game/static/ActionBar";
 import { ActionSlotUpdateReason, IActionBarSlotData } from "@wayward/game/ui/screen/screens/game/static/actions/IActionBar";
 import type TooltipLocationHandler from "@wayward/game/ui/tooltip/TooltipLocationHandler";

package/definitions/game/ui/screen/screens/game/static/actions/ActionSlotConfigurationColumn.d.ts

@@ -22,8 +22,9 @@ import HorizontalLine from "@wayward/game/ui/component/HorizontalLine";
 import RangeChoiceList from "@wayward/game/ui/component/RangeChoiceList";
 import Text, { Heading, Paragraph } from "@wayward/game/ui/component/Text";
 import ItemDropdown from "@wayward/game/ui/component/dropdown/ItemDropdown";
-import type { IItemComponentHandlerDescription, IItemDropApi, IItemSlotEvents, ItemSlot } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type { IItemDropApi, ItemSlot, IItemSlotEvents } from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
 import ItemComponent from "@wayward/game/ui/screen/screens/game/component/ItemComponent";
+import type { IItemComponentHandlerDescription } from "@wayward/game/ui/screen/screens/game/component/item/ItemComponentHandler";
 import type { Events, IEventEmitter } from "@wayward/utilities/event/EventEmitter";
 export declare enum ActionSlotConfigurationColumnClasses {
     Main = "game-action-configuration-drawer-configuration-column",

package/definitions/game/utilities/Version.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import TranslationImpl from "@wayward/game/language/impl/TranslationImpl";
+import type { IBuildId } from "@wayward/hosts/shared/globalTypes";
 export interface IVersionInfo {
     str: Version.String;
     strSemver: Version.StringSemVer;
@@ -22,6 +23,12 @@ export interface IVersionInfo {
      * A number representing the patch (if beta) or minor (if release), used when the stage is not known
      */
     update?: number;
+    buildId?: IBuildId;
+}
+export declare namespace IVersionInfo {
+    interface WithBuildId extends IVersionInfo {
+        buildId: IBuildId;
+    }
 }
 declare namespace Version {
     export type Stage = "beta" | "release";
@@ -29,8 +36,10 @@ declare namespace Version {
     export type StringSemVer = `${bigint}.${bigint}.${bigint}-${Stage}` | `${bigint}.${bigint}.${bigint}`;
     export type Month = "jan" | "feb" | "mar" | "apr" | "may" | "jun" | "jul" | "aug" | "sep" | "oct" | "nov" | "dec";
     export type DateString = `${Month} ${bigint} ${bigint} ${bigint | "00"}:${bigint | "00"}`;
+    export type StringBuildId = `${String}-dev${bigint}.${bigint}` | `${String}-dev${bigint}`;
     export const versionInfoRegExp: RegExp;
     export const versionInfoRegExpSemver: RegExp;
+    export const versionInfoWithBuildIdRegExp: RegExp;
     /**
      * Returns whether the given version is compatible with the game's version. This is used to check, for example,
      * if a mod is compatible with the game's version.
@@ -46,20 +55,20 @@ declare namespace Version {
      * - Compatible versions in "beta" stage require identical stage, major, minor, and a patch less than or equal to the current patch.
      * - Compatible versions in "release" stage require identical stage and major, and a minor and patch less than or equal to the current minor and patch.
      */
-    export function is(versionA: IVersionInfo | Version.String | Version.StringSemVer, versionB: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+    export function is(versionA?: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId, versionB?: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
     /**
      * Returns whether the given `version` is `atLeast` another version. This can be used, for example,
      * to see if a save or mod was created/edited after a specific thing was implemented.
      */
-    export function isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer, atLeast: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+    export function isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId, atLeast: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
     /**
      * Returns if `checkVersion` is older than `isBefore`
      */
     export function isBefore(checkVersion: IVersionInfo | Version.String | Version.StringSemVer, isBefore: IVersionInfo | Version.String | Version.StringSemVer): boolean;
     export function createRawVersionInfo(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): IVersionInfo;
-    export function convertStringToRawInfo(version: Version.String | Version.StringSemVer): IVersionInfo;
+    export function convertStringToRawInfo(version: Version.String | Version.StringSemVer | Version.StringBuildId): IVersionInfo;
     export function create(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): Info;
-    export function getVersionInfo(version: IVersionInfo | Version.String | Version.StringSemVer): Info;
+    export function getVersionInfo(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): Info;
     export function isSameVersion(version: IVersionInfo, compareVersion: IVersionInfo): boolean;
     export function getVersionDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo, development?: boolean): TranslationImpl;
     export function getUpdateDisplayTranslation(version?: Version.String | Version.StringSemVer | IVersionInfo): TranslationImpl | undefined;
@@ -85,16 +94,16 @@ declare namespace Version {
          * Returns whether this version is greater than or equal to the given version. This can be used, for example,
          * to see if a save or mod was created/edited after a specific thing was implemented.
          */
-        isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        isAtLeast(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is greater than or equal to the given version. This can be used, for example,
          * to see if a save or mod was created/edited after a specific thing was implemented.
          */
-        is(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        is(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is older than the given version.
          */
-        isBefore(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
+        isBefore(version: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId): boolean;
         /**
          * Returns whether this version is older than the given build time.
          *

package/definitions/hosts/shared/globalTypes.d.ts

@@ -42,6 +42,10 @@ export interface IWaywardTitleBar {
     isMaximized: boolean;
     electron: IElectron;
 }
+export interface IBuildId {
+    date: number;
+    number: number;
+}
 declare global {
     interface Window {
         require: any;

package/definitions/hosts/shared/globals.d.ts

@@ -9,8 +9,8 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IWaywardTitle } from "@wayward/hosts/shared/globalTypes";
-export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 2, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
-export declare const gameVersion = "beta2.14.2";
+export declare const gameVersionStage = "beta", gameVersionMajor = 2, gameVersionMinor = 14, gameVersionPatch = 3, gameVersionName = "Runekeeper", gameVersionColor = 11015763;
+export declare const gameVersion = "beta2.14.3";
 export declare const gameVersionTitleMajor = "Wayward: Runekeeper";
 export declare const gameVersionTitleMinor: string;
 export declare const gameVersionTitle: string;

package/definitions/utilities/Errors.d.ts

@@ -14,6 +14,16 @@ declare namespace Errors {
     function getStack(error: unknown): string | undefined;
     function getName(error: unknown): string | undefined;
     function getMessage(error: unknown): string | undefined;
+    /**
+     * Returns the callsite stack string starting from the caller of this function.
+     * @param skip The number of additional callsite strings to skip
+     * @param truncate The maximum number of callsite strings to include
+     */
+    function stack(skip?: number, truncate?: number): string;
+    /**
+     * Returns the Error callsite string for the caller of the current function.
+     */
+    function caller(skip?: number): string;
 }
 export default Errors;
 export declare function ensureExhaustive(value: never): never;

package/definitions/utilities/Log.d.ts

@@ -123,6 +123,11 @@ declare namespace Log {
      * @param sources A list of sources to log to.
      */
     function trace(...sources: string[]): (...args: any[]) => void;
+    /**
+     * Warn about something once per session based on unique warning ids.
+     * This is like how node.js does warnings in console.
+     */
+    function warnOncePerSession(warningId: string | string[], ...message: any[]): void;
 }
 declare class NullLog extends BaseLog {
     setup(): void;

package/definitions/utilities/collection/map/IterableWeakMap.d.ts

@@ -0,0 +1,35 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+/**
+ * Strong keys are stored in a Map.
+ * Weak keys are stored in a WeakMap.
+ * Based on https://github.com/tc39/proposal-weakrefs?tab=readme-ov-file#iterable-weakmaps
+ */
+export declare class IterableWeakMap<K, V> implements Iterable<[K, V]> {
+    #private;
+    constructor(iterable?: Iterable<[K, V]>);
+    /**
+     * This is more of an estimate since we might be waiting for some garbage collection to happen
+     */
+    get size(): number;
+    /**
+     * This will cause keys that are cleaned up via garbage collection to be logged
+     */
+    enableLogging(): IterableWeakMap<K, V>;
+    get(key: K): V | undefined;
+    set(key: K, value: V): this;
+    delete(key: K): boolean;
+    [Symbol.iterator](): Generator<[K, V]>;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    private isWeakKey;
+}

package/definitions/utilities/collection/map/LimitedMap.d.ts

@@ -0,0 +1,45 @@
+/*!
+ * Copyright 2011-2024 Unlok
+ * https://www.unlok.ca
+ *
+ * Credits & Thanks:
+ * https://www.unlok.ca/credits-thanks/
+ *
+ * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
+ * https://github.com/WaywardGame/types/wiki
+ */
+type MapIt<K, V> = Iterable<readonly [K, V]>;
+type MapArr<K, V> = ReadonlyArray<readonly [K, V]>;
+export default class LimitedMap<K, V> extends Map<K, V> {
+    readonly maxSize: number;
+    constructor(maxSize: number);
+    constructor(iterable: MapIt<K, V> | null, maxSize: number);
+    constructor(entries: MapArr<K, V> | null, maxSize: number);
+    private disposeHandler?;
+    /**
+     * Set a handler that handles when the map exceeds its limit, deleting the oldest item.
+     *
+     * Return `false` from the handler to instead "bump" the first item to the end, and then try to delete the oldest item again.
+     *
+     * Returning `false` for every item will forcibly delete the oldest item.
+     */
+    setDisposeHandler(handler: (key: K, value: V, canCancel: boolean) => boolean | void): this;
+    /**
+     * 1. Sets the given key and value in the map.
+     * 2. If/while the map size exceeds the limit, the dispose handler is called for the oldest item.
+     * 3. If the handler returns `false`, the item is instead "bumped" to the end of the map.
+     * 4. If the handler returns `false` for every item, oldest items are forcibly deleted until the map no longer exceeds the limit.
+     */
+    set(key: K, value: V): this;
+    private bumping;
+    bump(key: K): boolean;
+    /**
+     * Deletes the item with the given key, and calls the dispose handler if it's been set.
+     */
+    delete(key: K): boolean;
+    /**
+     * Clears the map, calling the dispose handler for each item if it's been set.
+     */
+    clear(): void;
+}
+export {};

package/definitions/utilities/event/EventEmitter.d.ts

@@ -8,6 +8,7 @@
  * Wayward is a copyrighted and licensed work. Modification and/or distribution of any source files is prohibited. If you wish to modify the game in any way, please refer to the modding guide:
  * https://github.com/WaywardGame/types/wiki
  */
+import { IterableWeakMap } from "@wayward/utilities/collection/map/IterableWeakMap";
 import { PriorityMap } from "@wayward/utilities/collection/map/PriorityMap";
 export declare enum Priority {
     Lowest = -2000,
@@ -24,12 +25,16 @@ type Abstract<T> = Function & {
 };
 type Constructor<T> = new (...args: any[]) => T;
 type ClassOrAbstractClass<T> = Abstract<T> | Constructor<T>;
+export interface IEventSubscriberEvents {
+    releaseEventSubscriptions(): any;
+}
 export interface IEventEmitterHost<E> {
     event: IEventEmitter<this | null, E>;
 }
 export type IEventEmitterHostClass<E> = ClassOrAbstractClass<IEventEmitterHost<E>>;
 export type Events<T> = T extends IEventEmitterHost<infer E> ? E : T extends IEventEmitterHostClass<infer E> ? E : never;
-export type EventPriorityMap = PriorityMap<Map<string | Handler<any, any>, string | Handler<any, any>>>;
+export type EventPriorityMapKV = string | Handler<any, any>;
+export type EventPriorityMap = PriorityMap<Map<EventPriorityMapKV, EventPriorityMapKV> | IterableWeakMap<EventPriorityMapKV, EventPriorityMapKV>>;
 export interface ITrueEventEmitterHostClass<E> extends Class<any> {
     [SYMBOL_SUPERCLASSES]: Array<ITrueEventEmitterHostClass<E>>;
     [SYMBOL_SUBSCRIPTIONS]: Map<any, Map<keyof E, EventPriorityMap>>;
@@ -59,8 +64,14 @@ export interface IEventEmitter<H = any, E = any> {
     emitAsyncParallel<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<Array<(Extract<ReturnOf<E[K]>, Promise<any>> extends Promise<infer R> ? R : never) | Exclude<ReturnOf<E[K]>, Promise<any>>>> & {
         isResolved?: true;
     };
+    subscribe<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    /** @deprecated */
     subscribe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    subscribeUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    subscribeNext<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    /** @deprecated */
     subscribeNext<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeNextUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
     unsubscribe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): boolean;
     waitFor<K extends ArrayOr<keyof E>>(events: K, priority?: number): Promise<ArgsOf<K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>;
     race<K extends ArrayOr<keyof E>>(raceWith: Promise<any>, events: K, priority?: number): Promise<ArgsOf<K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>;
@@ -72,8 +83,14 @@ export interface IEventEmitter<H = any, E = any> {
 export interface IUntilSubscriber<H, E> {
     until(promise: Promise<any>): this;
     until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): this;
+    subscribe<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    /** @deprecated */
     subscribe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeNext<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    /** @deprecated */
     subscribeNext<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeNextUnsafe<K extends ArrayOr<keyof E>>(event: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
 }
 declare class EventEmitter<H, E> {
     private readonly host;
@@ -92,8 +109,15 @@ declare class EventEmitter<H, E> {
     emitReduce<K extends keyof E, A extends ReturnOf<E[K]> & Head<ArgsOf<E[K]>>>(event: K, arg: A, ...args: Tail<ArgsOf<E[K]>>): Extract<ReturnOf<E[K]> & Head<ArgsOf<E[K]>>, undefined> extends undefined ? (undefined extends A ? ReturnOf<E[K]> : A) : ReturnOf<E[K]>;
     emitAsync<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<any[]>;
     emitAsyncParallel<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): Promise<any[]>;
-    subscribe<K extends ArrayOr<keyof E>>(events: K, handler: keyof H | Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
-    subscribeNext<K extends ArrayOr<keyof E>>(events: K, handler: keyof H | Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeUnsafe<K extends ArrayOr<keyof E>>(events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    subscribe<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    /** @deprecated */
+    subscribe<K extends ArrayOr<keyof E>>(events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number, once?: boolean): H;
+    private subscribeInternal;
+    subscribeNextUnsafe<K extends ArrayOr<keyof E>>(events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    subscribeNext<K extends ArrayOr<keyof E>>(host: IEventEmitterHost<IEventSubscriberEvents>, events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
+    /** @deprecated */
+    subscribeNext<K extends ArrayOr<keyof E>>(events: K, handler: Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): H;
     unsubscribe<K extends ArrayOr<keyof E>>(events: K, handler: keyof H | Handler<H, K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>, priority?: number): boolean;
     waitFor<K extends ArrayOr<keyof E>>(events: K, priority?: number): Promise<ArgsOf<K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>;
     race<K extends ArrayOr<keyof E>>(raceWith: number | Promise<any>, events: K, priority?: number): Promise<ArgsOf<K extends any[] ? E[K[number]] : E[Extract<K, keyof E>]>>;