@wayward/types 2.14.4-beta.dev.20250105.1 → 2.14.4-beta.dev.20250107.1

package/definitions/game/game/doodad/Doodad.d.ts

@@ -19,7 +19,7 @@ import type Human from "@wayward/game/game/entity/Human";
 import type { IEntityConstructorOptions } from "@wayward/game/game/entity/IEntity";
 import { EntityType } from "@wayward/game/game/entity/IEntity";
 import { SkillType } from "@wayward/game/game/entity/IHuman";
-import { EquipType } from "@wayward/game/game/entity/IHuman";
+import type { EquipType } from "@wayward/game/game/entity/IHuman";
 import { ActionType } from "@wayward/game/game/entity/action/IAction";
 import type Creature from "@wayward/game/game/entity/creature/Creature";
 import type Corpse from "@wayward/game/game/entity/creature/corpse/Corpse";
@@ -210,7 +210,7 @@ export default class Doodad extends EntityMovable<IDoodadDescription, DoodadType
     /**
      * Returns whether the doodad can be trampled
      */
-    canTrample(): boolean | undefined;
+    canTrample(): boolean;
     /**
      * Trampling growing things.
      */
@@ -323,6 +323,11 @@ export default class Doodad extends EntityMovable<IDoodadDescription, DoodadType
      * Regenerate (heal durability) over time
      */
     private processRegeneration;
+    /**
+     * Process the magical properties of the doodad when updating
+     * @param ticks the number of ticks to process
+     */
+    private processMagicalProperties;
     /**
      * Melt doodads (or things on doodads over time)
      * @param description Doodad description

package/definitions/game/game/doodad/DoodadUtilities.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * 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 Doodad from "@wayward/game/game/doodad/Doodad";
+import type { DoodadType } from "@wayward/game/game/doodad/IDoodad";
+import { GrowingStage } from "@wayward/game/game/doodad/IDoodad";
+import type Human from "@wayward/game/game/entity/Human";
+declare namespace DoodadUtilities {
+    type DoodadIn = Doodad | DoodadType;
+    export function hasGrownEnoughIfCanGrow(doodad: Doodad, requiredGrowthStage: GrowingStage): boolean;
+    export function hasGrownEnoughIfCanGrow(doodad: DoodadIn, requiredGrowthStage: GrowingStage): undefined;
+    export function wouldWalkingOnDealFireDamage(doodad: DoodadIn, human?: Human): boolean;
+    export function wouldWalkingOnDealNormalDamage(doodad: DoodadIn, human?: Human): boolean;
+    export function isDangerous(doodad: DoodadIn, human?: Human): boolean;
+    export function canCauseStatus(doodad: DoodadIn): boolean;
+    export {};
+}
+export default DoodadUtilities;

package/definitions/game/game/doodad/IDoodad.d.ts

@@ -528,6 +528,12 @@ export declare enum GrowingStage {
     Ripening = 5,
     Bare = 6
 }
+export declare namespace Growth {
+    function isAtLeast(growth: GrowingStage | undefined, stage: GrowingStage): boolean;
+    function isAtMost(growth: GrowingStage | undefined, stage: GrowingStage): boolean;
+    function isMoreThan(growth: GrowingStage | undefined, stage: GrowingStage): boolean;
+    function isLessThan(growth: GrowingStage | undefined, stage: GrowingStage): boolean;
+}
 export interface IHasBuilder {
     getBuilder(): Human | undefined;
 }

package/definitions/game/game/inspection/InfoProvider.d.ts

@@ -126,8 +126,6 @@ export declare abstract class InfoProvider extends EventEmitter.Host<IInfoProvid
      * Call when this info provider should be removed.
      */
     remove(): this;
-    onStoppingPlay(): void;
-    onPreMoveToIsland(): void;
     private _shouldDisplayWhenEmpty;
     protected shouldDisplayWhenEmpty(): boolean;
     setShouldDisplayWhenEmpty(shouldDisplayWhenEmpty?: boolean): this;

package/definitions/game/game/item/IItem.d.ts

@@ -1852,7 +1852,8 @@ export declare enum ItemTypeGroup {
     ExcludedFromRandom = -9856,
     Leaves = -9855,
     Flute = -9854,
-    All = -9853
+    InternalNoDropOnDoodadBreak = -9853,
+    All = -9852
 }
 export type StillContainerBaseItemType = ItemType.Waterskin | ItemType.GlassBottle | ItemType.ClayJug | ItemType.CoconutContainer;
 export interface IItemMovementResult {

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

@@ -94,7 +94,6 @@ export default class Component<E extends HTMLElement = HTMLElement> extends Even
      */
     get selectable(): SelectableLayer | false;
     constructor(elementType?: string, namespace?: Namespace);
-    toString(): string;
     /**
      * Alias of `.element.addEventListener`, except it returns `this` instead and prevents memory leaks
      */

package/definitions/game/ui/input/InputManager.d.ts

@@ -107,6 +107,7 @@ declare class InputManager extends EventEmitter.Host<IInputManagerEvents> {
     register(component: Component): this;
     deregister(): this;
     isRegistered(): boolean;
+    private didReset;
     reset(): void;
     /**
      * @param disabler Each `disableUntil` call should be given a unique `disabler`,

package/definitions/game/ui/input/Macros.d.ts

@@ -37,7 +37,7 @@ declare namespace Macros {
     function getCurrent(): Macro;
     function getTouch(): Macro;
     function reset(): void;
-    function setHandled(): void;
+    function setHandled(input: IInput): void;
     function setIsolated(_isolated?: boolean): void;
     function didRequestIsolation(): boolean;
     function handleInput(input: IInput, api: IBindHandlerApi): Macro | undefined;

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

@@ -69,6 +69,11 @@ export declare enum ItemRefreshType {
 export interface IItemComponentEvents extends Events<Component>, IDraggableEvents, IItemSlotEvents, ISortableDraggableEvents {
     deregisterHighlights(): any;
     refresh(type: ItemRefreshType): any;
+    /**
+     * Called when the item (within the item component) is changing.
+     * Usually during a refresh.
+     */
+    itemChange(): any;
 }
 export interface IItemComponentStaticEvents {
     update(type: ItemRefreshType): any;

package/definitions/utilities/Log.d.ts

@@ -129,11 +129,35 @@ declare namespace Log {
      * @param sources A list of sources to log to.
      */
     function trace(...sources: string[]): (...args: any[]) => void;
+    /**
+     * Warns about an occurrence of something, due to a specific caller, once per session.
+     * @param skip Number of callsites to skip. Automatically skips this function and its caller.
+     * If this is called from a function that is registered in `Errors.ts` as a skipped callsite, you might have to pass `-1`.
+     * @param id The ID of this warning. Can be `Log.simplify` strings.
+     */
+    function warnForCaller(skip: number, id: ArrayOr<string | SimplifyString>, ...message: 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;
+    function warnOncePerSession(warningId: ArrayOr<string | SimplifyString>, ...message: any[]): void;
+    interface SimplifyString extends String {
+        simplified: string;
+    }
+    namespace SimplifyString {
+        function is(value: unknown): value is SimplifyString;
+        function get(value: unknown): string;
+    }
+    function simplify(segments: TemplateStringsArray, ...interpolations: unknown[]): SimplifyString;
+    function simplify(mainLog: string, simplified: string): SimplifyString;
+    /**
+     * Returns a combination of the object's constructor and the result of calling `toString` on it.
+     *
+     * If the `toString` result is redundant or useless, it is omitted.
+     *
+     * The resulting string will be automatically simplified when reported to the error server.
+     */
+    function objectToString(object?: object): string;
 }
 declare class NullLog extends BaseLog {
     setup(): void;

package/definitions/utilities/object/Objects.d.ts

@@ -49,6 +49,14 @@ declare namespace Objects {
     };
     function getDirections(target: any, within: any): Generator<string[]>;
     function stringify(object: any, pretty?: boolean, noDepth?: boolean, maxIterations?: number): string;
+    namespace stringify {
+        const SYMBOL_EXCLUDED_PROPERTIES: unique symbol;
+        export function excludeProperties(...properties: string[]): {
+            [SYMBOL_EXCLUDED_PROPERTIES]: string[];
+        };
+        export function isExcluded(object: any, property: string): boolean;
+        export {};
+    }
     function mutable<T>(object: T): Mutable<T>;
     function removeUndefinedProperties<T extends object>(object: T): T;
     function filterProperties<T extends object>(object: T, filter: (key: keyof T, value: T[keyof T]) => any): T;

package/definitions/utilities/prototype/Array.d.ts

@@ -25,7 +25,8 @@ declare global {
         toggle(value: T, includes?: boolean): void;
         awaitAll(): Promise<Array<Awaited<T>>>;
         layerSort(sortInitializer: (sorter: ISorter<T>) => any): T[];
-        groupBy<GROUP>(grouper: (value: T, index: number, obj: T[]) => GROUP): Array<[GROUP, T[]]>;
+        groupBy<GROUP>(grouper: (value: T, index: number, array: T[]) => GROUP): Array<[GROUP, T[]]>;
+        groupBy<GROUP, R>(grouper: (value: T, index: number, array: T[]) => GROUP, mapper: (values: T[], group: GROUP) => R): Array<[GROUP, R]>;
         /**
          * Alias of `.toSet().toArray()`
          */

package/package.json

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