@wayward/types 2.14.4-beta.dev.20241231.1 → 2.14.4-beta.dev.20250101.1

package/definitions/game/save/data/ISaveDataGlobal.d.ts

@@ -32,9 +32,10 @@ export interface IOptions {
     currentGame: number;
     customTitleBar: boolean;
     defaultCursor: boolean;
+    developerLogMessagesForContainerDesyncs: boolean;
     developerMode: boolean;
     developerModeContextMenu: boolean;
-    developerLogMessagesForContainerDesyncs: boolean;
+    developerReportErrorsToWaywardTeam: boolean;
     dialogOpacity: number;
     directionTurnDelay: number;
     disableAcrylicTransparency: boolean;

package/definitions/game/ui/{screen/screens/splash → component}/Notice.d.ts

@@ -27,11 +27,13 @@ export declare enum NoticeClasses {
     Markdown = "notice-markdown"
 }
 export default class Notice extends Component {
-    static await(noticeClass: Class<Notice>, appendTo: Component): Promise<any>;
+    static await(noticeClass: Class<Notice>, appendTo: Component | HTMLElement): Promise<boolean>;
     readonly sections: Component<HTMLElement>;
     readonly footer: Component<HTMLElement>;
     readonly footerContent: Component<HTMLElement>;
-    readonly dismissButton: Button;
+    private returnValue;
+    readonly proceedButton: Button;
+    get cancelButton(): Button;
     constructor();
     addSection(initializer: (section: NoticeSection) => any): this;
     hideAndRemove(): Promise<void>;

package/definitions/game/ui/screen/screens/SplashScreen.d.ts

@@ -9,7 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import Screen from "@wayward/game/ui/screen/Screen";
-import Notice from "@wayward/game/ui/screen/screens/splash/Notice";
+import Notice from "@wayward/game/ui/component/Notice";
 export default class SplashScreen extends Screen {
     static getNotices(): Array<Class<Notice>>;
     static show(): Promise<void>;

package/definitions/game/ui/screen/screens/game/DialogManager.d.ts

@@ -13,12 +13,15 @@ import type { IDialogStates } from "@wayward/game/ui/screen/screens/GameScreen";
 import type { DialogById } from "@wayward/game/ui/screen/screens/game/DialogMap";
 import { DialogId } from "@wayward/game/ui/screen/screens/game/Dialogs";
 import Dialog from "@wayward/game/ui/screen/screens/game/component/Dialog";
-export default class DialogManager {
+import type { IEventSubscriberEvents } from "@wayward/utilities/event/EventEmitter";
+import EventEmitter from "@wayward/utilities/event/EventEmitter";
+type IDialogManagerEvents = IEventSubscriberEvents;
+export default class DialogManager extends EventEmitter.Host<IDialogManagerEvents> {
     private readonly map;
     /**
      * Flag set when the dialog manager / parent screen is being removed
      */
-    private removing;
+    private disposing;
     private readonly screenRef;
     get screen(): Screen;
     constructor(screen: Screen);
@@ -31,7 +34,7 @@ export default class DialogManager {
     open<DIALOG extends Dialog>(id: DialogId, initializer?: (dialog: DIALOG) => any, subId?: string, highlightIfAlreadyOpen?: boolean): DIALOG;
     isVisible(id: DialogId, subId?: string): boolean | undefined;
     close(id: DialogId | `${DialogId}` | `${DialogId},${string}`, subId?: string): boolean;
-    closeAll(removing?: boolean): boolean;
+    closeAll(): boolean;
     toggle<ID extends DialogId>(id: ID, force?: boolean, initializer?: (dialog: DialogById[ID]) => any, subId?: string, highlightIfAlreadyOpen?: boolean): this;
     toggle<DIALOG extends Dialog>(id: DialogId, force?: boolean, initializer?: (dialog: DIALOG) => any, subId?: string, highlightIfAlreadyOpen?: boolean): this;
     toggleAll(states: IDialogStates, loaded?: boolean): this;
@@ -40,4 +43,6 @@ export default class DialogManager {
     private breakKey;
     private getKey;
     private updateDialogId;
+    dispose(): void;
 }
+export {};

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

@@ -13,8 +13,9 @@ import { type ItemRefreshType } from "@wayward/game/ui/screen/screens/game/compo
 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 type { IEventSubscriberEvents } from "@wayward/utilities/event/EventEmitter";
 import EventEmitter from "@wayward/utilities/event/EventEmitter";
-interface IItemComponentEventBusEvents {
+interface IItemComponentEventBusEvents extends IEventSubscriberEvents {
     update(type: ItemRefreshType): any;
     changeHovered(): any;
 }

package/definitions/game/ui/screen/screens/menu/menus/options/ErrorReportingNotice.d.ts

@@ -0,0 +1,14 @@
+/*!
+ * 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 Notice from "@wayward/game/ui/component/Notice";
+export default class ErrorReportingNotice extends Notice {
+    constructor();
+}

package/definitions/game/ui/screen/screens/menu/menus/options/TabDeveloper.d.ts

@@ -23,6 +23,8 @@ export default class TabDeveloper extends Tab implements IRefreshable {
     private readonly buttonToggleTraceRecording;
     private readonly buttonDisposeReflection;
     private readonly blockLogSourceFiltering;
+    private readonly checkButtonReportErrors;
+    private onTryEnableReportErrors;
     private readonly blockUIExperiments;
     constructor();
     refresh(): this;

package/definitions/game/ui/screen/screens/splash/DevelopmentBranchNotice.d.ts

@@ -8,7 +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 Notice from "@wayward/game/ui/screen/screens/splash/Notice";
+import Notice from "@wayward/game/ui/component/Notice";
 export default class DevelopmentBranchNotice extends Notice {
     constructor();
 }

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

@@ -80,7 +80,7 @@ declare namespace Version {
     export interface Info extends IVersionInfo {
     }
     export class Info {
-        constructor(info: IVersionInfo | Version.String | Version.StringSemVer);
+        constructor(info: IVersionInfo | Version.String | Version.StringSemVer | Version.StringBuildId);
         /**
          * Returns whether this 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.

package/definitions/lint/condition-complexity.d.mts

@@ -0,0 +1,26 @@
+declare namespace _default {
+    export namespace meta {
+        export let type: string;
+        export namespace docs {
+            let description: string;
+            let category: string;
+            let recommended: boolean;
+        }
+        export { messages };
+        export let schema: never[];
+        export let fixable: string;
+    }
+    export { createRuleListener as create };
+}
+export default _default;
+export type Context = TSESLint.RuleContext<keyof typeof messages, []>;
+declare namespace messages {
+    let conditionTooComplexVariable: string;
+    let conditionTooComplexFunction: string;
+}
+/**
+ * @param {Context} context
+ * @returns {TSESLint.RuleListener}
+ */
+declare function createRuleListener(context: Context): TSESLint.RuleListener;
+import type { TSESLint } from '@typescript-eslint/utils';

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

@@ -64,11 +64,11 @@ 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;
+    subscribe<K extends ArrayOr<keyof E>>(this: IEventEmitter<IEventEmitterHost<IEventSubscriberEvents>, 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;
+    subscribeNext<K extends ArrayOr<keyof E>>(this: IEventEmitter<IEventEmitterHost<IEventSubscriberEvents>, 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;
@@ -94,11 +94,13 @@ export interface IUntilSubscriber<H, E> {
 }
 declare class EventEmitter<H, E> {
     private readonly host;
-    static RECORD_MODE: boolean;
     private readonly hostClass;
-    private readonly subscriptions;
-    private readonly subscriptionsRecord;
-    private readonly cachedEmitSelfHandlers;
+    /**
+     * We're not always initializing these since they're not always needed.
+     */
+    private subscriptions?;
+    private cachedEmitSelfHandlers?;
+    private cachedClassHandlers?;
     constructor(host: H);
     raw(): IEventEmitter<H, E>;
     emitSelf<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
@@ -125,8 +127,11 @@ declare class EventEmitter<H, E> {
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
     private copyFrom;
-    private readonly cachedClassHandlers;
     protected handlersForEvent<K extends keyof E>(event: K, ignoreClassSubscriptions?: true): Array<keyof H | WeakHandler<any, any>>;
+    /**
+     * Deletes an event from the cached handler maps and deletes the maps if they are empty.
+     */
+    private deleteCachedHandler;
 }
 declare namespace EventEmitter {
     class Host<E> implements IEventEmitterHost<E> {

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.14.4-beta.dev.20241231.1",
+	"version": "2.14.4-beta.dev.20250101.1",
 	"license": "MIT",
 	"repository": {
 		"type": "git",