@wayward/types 2.14.3-beta.dev.20241226.1 → 2.14.4-beta

package/definitions/utilities/Log.d.ts

@@ -9,6 +9,7 @@
  * https://github.com/WaywardGame/types/wiki
  */
 import type { IFileSystem } from "@wayward/hosts/shared/ipc/fileSystem";
+import Version from "@wayward/utilities/Version";
 export declare enum LogLineType {
     Debug = 0,
     Error = 1,
@@ -24,6 +25,7 @@ export interface ILog {
     trace(...args: any[]): void;
     warn(...args: any[]): void;
     setSources(...sources: string[]): void;
+    ifEnabled(logger: (log: this) => any): void;
 }
 export interface ILogLine {
     type: LogLineType;
@@ -35,6 +37,7 @@ declare abstract class BaseLog implements ILog {
     info: (...args: any[]) => void;
     trace: (...args: any[]) => void;
     warn: (...args: any[]) => void;
+    ifEnabled: (logger: (log: this) => any) => void;
     protected sources: string[];
     constructor(...sources: Array<BaseLog | string>);
     setSources(...sources: Array<BaseLog | string>): void;
@@ -85,7 +88,9 @@ declare namespace Log {
         Memory = 2
     }
     function setMemoryLog(memoryLog: MemoryLog | undefined): void;
-    function disableFileLogging(source: string): void;
+    function setTimestampType(type: "full" | "build"): void;
+    function disableFileLogger(): void;
+    function disableFileLoggingForSource(source: string): void;
     function initializeGameState(): void;
     function setCallback(cb?: (...args: any[]) => void): void;
     function addPreConsoleCallback(cb: (...args: any[]) => void): void;
@@ -93,7 +98,7 @@ declare namespace Log {
     /**
      * Setups file logging
      */
-    function setupFileLogger(fileSystem: IFileSystem, logsPath: string): void;
+    function setupFileLogger(fileSystem: IFileSystem, logsPath: string): Promise<void>;
     /**
      * Flushes pending logs to disk if the file logger is active
      */
@@ -118,16 +123,43 @@ declare namespace Log {
      * @param sources A list of sources to log to.
      */
     function debug(...sources: string[]): (...args: any[]) => void;
+    function ifEnabled(...sources: string[]): (logger: (log: ILog) => any) => void;
+    function ifEnabled<LOG extends ILog>(log: LOG, ...sources: string[]): (logger: (log: LOG) => any) => void;
     /**
      * Returns a method that can be used to `Log.trace` with the given sources.
      * @param sources A list of sources to log to.
      */
     function trace(...sources: string[]): (...args: any[]) => void;
+    function shouldSendErrorReport(versionInfo?: Version.Info | undefined): boolean;
+    /**
+     * 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/{game/utilities → utilities}/Version.d.ts

@@ -8,8 +8,8 @@
  * 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 TranslationImpl from "@wayward/game/language/impl/TranslationImpl";
-import type { IBuildId } from "@wayward/hosts/shared/globalTypes";
+import type { IBuild, IBuildId } from "@wayward/hosts/shared/globalTypes";
+import type { IFileSystem } from "@wayward/hosts/shared/ipc/fileSystem";
 export interface IVersionInfo {
     str: Version.String;
     strSemver: Version.StringSemVer;
@@ -31,6 +31,7 @@ export declare namespace IVersionInfo {
     }
 }
 declare namespace Version {
+    export function readBuildFile(path?: string, fs?: IFileSystem): Promise<IBuild | undefined>;
     export type Stage = "beta" | "release";
     export type String = `${Stage}${bigint}.${bigint}.${bigint}` | `${Stage}${bigint}.${bigint}` | `${Stage}${bigint}`;
     export type StringSemVer = `${bigint}.${bigint}.${bigint}-${Stage}` | `${bigint}.${bigint}.${bigint}`;
@@ -68,20 +69,17 @@ declare namespace Version {
     export function createRawVersionInfo(stage: Version.Stage, major: number, minor: number, patch?: number, date?: Date): 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 | Version.StringBuildId): 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;
     const timezones: {
         nz: string;
         pt: string;
         build: string;
     };
-    export function isTimeBefore(date: Date, dateStr: DateString, timezone: keyof typeof timezones): boolean;
     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.
@@ -111,8 +109,6 @@ declare namespace Version {
          */
         isBefore(dateStr: DateString, timezone: keyof typeof timezones): boolean;
         equals(version: IVersionInfo | Version.String | Version.StringSemVer): boolean;
-        getTranslation(): TranslationImpl;
-        getUpdateTranslation(): TranslationImpl | undefined;
     }
     export {};
 }

package/definitions/utilities/dev/DebugShared.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * 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
+ */
+declare namespace DebugShared {
+    const SYMBOL_JIT: unique symbol;
+    export interface JIT<A extends any[] = []> {
+        (): any;
+        (...args: A): any;
+        [SYMBOL_JIT]: true;
+    }
+    export function isJIT(value: unknown): value is JIT;
+    export function JIT<A extends any[]>(debug: JIT, fn: (debug: any, ...args: A) => any): JIT<A>;
+    export function JIT<A extends any[]>(fn: (...args: A) => any): JIT<A>;
+    export {};
+}
+export default DebugShared;

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

@@ -49,6 +49,7 @@ type Handler<H, F> = (host: H, ...args: ArgsOf<F>) => ReturnOf<F>;
 type WeakHandler<H, F> = WeakRef<Handler<H, F>>;
 type UndefinedFromVoid<V> = V extends void ? undefined : V;
 export interface IEventEmitter<H = any, E = any> {
+    readonly closed?: boolean;
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     /**
      * Emit an event only to the subscribers of this emitter instance.
@@ -64,11 +65,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;
@@ -79,6 +80,14 @@ export interface IEventEmitter<H = any, E = any> {
     until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): IUntilSubscriber<H, E>;
     until(promise: Promise<any>): IUntilSubscriber<H, E>;
     hasHandlersForEvent(...events: Array<keyof E>): boolean;
+    /**
+     * Re-opens a closed event emitter
+     */
+    open(): void;
+    /**
+     * Closes an event emitter, which will prevent any further subscriptions from being made.
+     */
+    close(): void;
 }
 export interface IUntilSubscriber<H, E> {
     until(promise: Promise<any>): this;
@@ -94,12 +103,32 @@ 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?;
+    /**
+     * Set to true when the event emitted is closed.
+     * This means no more events will be emitted and no more subscriptions can be made.
+     * Public so that the interface can expose a readonly version of this.
+     */
+    closed?: boolean;
     constructor(host: H);
+    /**
+     * Re-opens a closed event emitter
+     */
+    open(): void;
+    /**
+     * Closes an event emitter, which will prevent any further subscriptions from being made.
+     */
+    close(): void;
+    /**
+     * @returns True if closed
+     */
+    private throwErrorIfClosed;
     raw(): IEventEmitter<H, E>;
     emitSelf<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
     emit<K extends keyof E>(event: K, ...args: ArgsOf<E[K]>): H;
@@ -125,8 +154,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/definitions/utilities/memory/ILifetime.d.ts

@@ -16,5 +16,9 @@ export declare enum ExpectedLifetime {
     /**
      * should only exist while playing the game
      */
-    WhilePlaying = 1
+    WhilePlaying = 1,
+    /**
+     * The object is expected to last until the next garbage collection system
+     */
+    UntilNextGarbageCollection = 2
 }

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

@@ -49,6 +49,15 @@ 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: Array<string | object>): {
+            [SYMBOL_EXCLUDED_PROPERTIES]: string[];
+        };
+        export function isExcluded(object: any, property: string): boolean;
+        export function getExcluded(object: any): string[];
+        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/definitions/utilities/prototype/Define.d.ts

@@ -11,6 +11,8 @@
 type Implementation<P, K extends keyof P> = (this: P, ...args: P[K] extends (...args: infer A) => any ? A : []) => P[K] extends (...args: any[]) => infer R ? R : never;
 declare function Define<P, K extends string & keyof P>(proto: P, key: K, implementation: Implementation<P, K>): void;
 declare namespace Define {
+    export function set<P, K extends string & keyof P>(proto: P, key: K, value: P[K]): P[K];
+    export function set<V>(proto: any, key: PropertyKey, value: V): V;
     export function all<P, K extends string & keyof P>(protos: P[], key: K, implementation: Implementation<P, K>): void;
     interface IMagicImplementation<O, K extends string & keyof O> {
         get(this: O): O[K];

package/definitions/utilities/random/IRandom.d.ts

@@ -23,7 +23,7 @@ export interface IRandomGenerator<T = any> {
     pushSeed(seed?: T): void;
     popSeed(): T;
     get(): number;
-    advance?(): this;
+    advance?(times?: number): this;
     asPCG?: PCGSeededGenerator;
 }
 export declare enum RandomInstance {

package/definitions/utilities/random/Random.d.ts

@@ -97,5 +97,5 @@ export declare class Random<G extends IRandomGenerator = IRandomGenerator> {
      * @returns number between provided min/max, rounded.
      */
     intInRangeExponential(min: number, max: number, steepness?: number): number;
-    advance(): this;
+    advance(times?: number): this;
 }

package/definitions/utilities/random/RandomUtilities.d.ts

@@ -21,7 +21,7 @@ export declare function convertStringToSeed(seed: string | number): number;
 /**
  * Creates a seeded random generator with the latest one available
  */
-export declare function createLatestSeededRandom(requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number): Random<PCGSeededGenerator> | Random<LegacySeededGenerator>;
+export declare function createLatestSeededRandom(requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number, advance?: number): Random<PCGSeededGenerator> | Random<LegacySeededGenerator>;
 interface SeededGeneratorMap {
     [SeedType.PCG]: PCGSeededGenerator;
     [SeedType.Legacy]: LegacySeededGenerator;
@@ -29,7 +29,7 @@ interface SeededGeneratorMap {
 /**
  * Creates seeded random generator for the given type
  */
-export declare function createSeededRandom<TYPE extends SeedType = SeedType>(seedType: TYPE, requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number): Random<SeededGeneratorMap[TYPE]>;
+export declare function createSeededRandom<TYPE extends SeedType = SeedType>(seedType: TYPE, requiresSynchronization: RandomSychronizationCheck, seed?: Uint16Array | number, advance?: number): Random<SeededGeneratorMap[TYPE]>;
 /**
  * Random without seeds
  */

package/definitions/utilities/random/SeededGenerator.d.ts

@@ -40,5 +40,5 @@ export declare abstract class SeededGenerator<T> implements IRandomGenerator {
     getHistory(): Array<IRandomHistory<T>> | undefined;
     takeHistory(): Array<IRandomHistory<T>> | undefined;
     stopHistory(): Array<IRandomHistory<T>>;
-    advance(): this;
+    advance(times?: number): this;
 }

package/definitions/utilities/{typesglobal → types}/Types.d.ts

@@ -19,6 +19,9 @@ interface PartialUnionizer<TYPES extends any[]> {
 }
 declare global {
     type PartialUnion<TYPES extends any[]> = TYPES[number] & PartialUnionizer<TYPES>[Extract<TYPES["length"], keyof PartialUnionizer<TYPES>>];
+    type MappedOmit<T, K extends keyof T> = {
+        [P in keyof T as P extends K ? never : P]: T[P];
+    };
 }
 declare const _default: {};
 export default _default;

package/definitions/utilities/types.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * 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 "@wayward/utilities/types/Class";
+import "@wayward/utilities/types/Descriptions";
+import "@wayward/utilities/types/Function";
+import "@wayward/utilities/types/Immutable";
+import "@wayward/utilities/types/Iterables";
+import "@wayward/utilities/types/Misc";
+import "@wayward/utilities/types/Objects";
+import "@wayward/utilities/types/Types";

package/package.json

@@ -1,17 +1,17 @@
 {
 	"name": "@wayward/types",
 	"description": "TypeScript declarations for Wayward, used for modding.",
-	"version": "2.14.3-beta.dev.20241226.1",
+	"version": "2.14.4-beta",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/WaywardGame/types.git"
 	},
 	"scripts": {
-		"clean": "rimraf ./definitions ./*.tsbuildinfo"
+		"clean": "npx rimraf ./definitions ./*.tsbuildinfo"
 	},
 	"dependencies": {
-		"@types/node": "22.7.5",
+		"@types/node": "22.13.10",
 		"@wayward/goodstream": "0.10.0"
 	},
 	"devDependencies": {