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

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/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

@@ -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>]>>;

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

@@ -10,7 +10,7 @@
  */
 import type { EventBusManager } from "@wayward/utilities/event/EventBusManager";
 import type EventEmitter from "@wayward/utilities/event/EventEmitter";
-import type { Events, IEventEmitterHost, IEventEmitterHostClass } from "@wayward/utilities/event/EventEmitter";
+import type { Events, IEventEmitterHost, IEventEmitterHostClass, IEventSubscriberEvents } from "@wayward/utilities/event/EventEmitter";
 type HostOrHostClass = IEventEmitterHost<any> | IEventEmitterHostClass<any>;
 type HostFromHostOrHostClass<H> = H extends {
     event: EventEmitter<null, any>;
@@ -55,7 +55,17 @@ export declare class EventManager<EventBus extends number, EventBuses extends Re
     waitFor<E extends EmitterOrBus<EventBus>, K extends Event<EventBus, EventBuses, E>>(emitter: E, event: K, priority?: number): Promise<Parameters<Handler<EventBus, EventBuses, E, K>>>;
     until<E2>(emitter: IEventEmitterHost<E2>, ...events: Array<keyof E2>): IEventManagerUntil<EventBus, EventBuses>;
     until(promise: Promise<any>): IEventManagerUntil<EventBus, EventBuses>;
+    registerEventBusSubscriber(subscriber: IEventEmitterHost<IEventSubscriberEvents>): void;
+    /**
+     * @deprecated This subscriber object will not be automatically cleaned up!
+     *
+     * If this is intentional, switch to {@link registerEventBusSubscriberUnsafe}.
+     *
+     *  Otherwise, this subscriber object needs to be an {@link IEventEmitterHost}<{@link IEventSubscriberEvents}> —
+     * the `"releaseEventSubscriptions"` call will automatically clean up this subscriber.
+     */
     registerEventBusSubscriber(subscriber: object): void;
+    registerEventBusSubscriberUnsafe(subscriber: object): void;
     deregisterEventBusSubscriber(subscriber: object): boolean;
 }
 declare const SYMBOL_EVENT_HANDLERS: unique symbol;

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/package.json

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