@wayward/types 2.12.0-beta.dev.20220922.1 → 2.12.0-beta.dev.20220923.1

package/definitions/game/game/entity/action/actions/Cast.d.ts

@@ -17,7 +17,7 @@ export interface ICastCanUse extends IActionUsable {
     ranged: IRanged;
     itemRange: number;
     maxFishingRange: number;
-    gatherableTreasures?: TreasureGathering.IGatherable[];
+    canGatherTreasure?: TreasureGathering.ICanGather;
 }
 declare const _default: Action<[ActionArgument.ItemInventory], import("../../Human").default, void, ICastCanUse, [import("../../../item/Item").default]>;
 export default _default;

package/definitions/game/game/entity/action/actions/helper/TreasureGathering.d.ts

@@ -28,16 +28,21 @@ declare namespace TreasureGathering {
         NoTreasure = 1,
         NoMapsForTreasure = 2
     }
-    interface IGatherablesResult {
+    interface ICanGather {
         gatherables?: IGatherable[];
         result?: GatherablesResult;
     }
-    function getGatherable(executor: Human, itemRange: number, requireMap: boolean, maxRange?: number): IGatherablesResult;
+    function canGather(executor: Human, itemRange: number, requireMap: boolean, maxRange?: number): ICanGather;
     enum Result {
         NoTreasure = 0,
         NotYet = 1,
         Gathered = 2
     }
-    function gather({ map, mapItem, treasure, position: { x, y, z }, maxRange, toolRange }: IGatherable, action: IActionHandlerApi<Human>, tool?: Item): Result;
+    interface IGatherResult {
+        result: Result;
+        position?: IVector3;
+        treasure?: ITreasure;
+    }
+    function gather(action: IActionHandlerApi<Human>, itemRange: number, requireMap: boolean, tool?: Item, canGather?: ICanGather): IGatherResult;
 }
 export default TreasureGathering;

package/definitions/game/game/entity/action/usable/UsableAction.d.ts

@@ -276,17 +276,22 @@ declare class UsableAction<REQUIREMENTS extends IUsableActionRequirements = IUsa
     getIcon(provided: IUsableActionPossibleUsing): IIcon | undefined;
     getHighlightSelectors(using?: IUsableActionPossibleUsing): HighlightSelector[];
     private translator?;
-    getTranslation(using?: IUsableActionUsing<REQUIREMENTS>, which?: ActionTranslation): Translation | undefined;
+    getTranslation(using?: IUsableActionPossibleUsing, which?: ActionTranslation, context?: UsableActionTranslationContext): Translation | undefined;
     getOrder(using?: IUsableActionPossibleUsing): number;
 }
+export declare enum UsableActionTranslationContext {
+    None = 0,
+    Use = 1
+}
+export declare type UsableActionTranslationArguments = [using: IUsableActionPossibleUsing, action: UsableAction, context: UsableActionTranslationContext];
 export declare class UsableActionTranslator {
     readonly id: ActionId;
     private nameSupplier?;
     private descriptionSupplier?;
     constructor(id: ActionId);
-    name(supplier: SupplierOr<Translation, [using: IUsableActionPossibleUsing, action: UsableAction]>): this;
-    description(supplier: SupplierOr<Translation, [using: IUsableActionPossibleUsing, action: UsableAction]>): this;
-    get(action: UsableAction, using?: IUsableActionPossibleUsing, which?: ActionTranslation): Translation | undefined;
+    name(supplier: SupplierOr<Translation, UsableActionTranslationArguments>): this;
+    description(supplier: SupplierOr<Translation, UsableActionTranslationArguments>): this;
+    get(action: UsableAction, using?: IUsableActionPossibleUsing, which?: ActionTranslation, context?: UsableActionTranslationContext): Translation | undefined;
 }
 export interface IUsableActionFactory<REQUIREMENTS extends IUsableActionRequirements> {
     create: <DEFINITION extends IUsableActionDefinition<REQUIREMENTS>>(action: DEFINITION) => UsableAction<REQUIREMENTS, DEFINITION>;

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

@@ -11,11 +11,12 @@
 import type { IInspector, InfoDisplayLevel } from "game/inspection/IInfoProvider";
 import { TextContext } from "language/ITranslation";
 export declare class InfoProviderContext {
-    readonly textContext: TextContext;
-    readonly maxDisplayLevel: InfoDisplayLevel;
     static readonly UI: new (inspector: IInspector, maxDisplayLevel: InfoDisplayLevel) => InfoProviderContext;
     static readonly RAW: new (inspector: IInspector, maxDisplayLevel: InfoDisplayLevel) => InfoProviderContext;
-    private readonly _inspector;
+    protected readonly _inspector: WeakRef<IInspector>;
+    readonly textContext: TextContext;
+    readonly maxDisplayLevel: InfoDisplayLevel;
+    constructor(context: InfoProviderContext);
     constructor(textContext: TextContext, inspector: IInspector, maxDisplayLevel: InfoDisplayLevel);
     get inspector(): IInspector | undefined;
 }

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

@@ -30,6 +30,30 @@ import StatInspection from "game/inspection/inspections/StatInspection";
 import TileEventInspection from "game/inspection/inspections/TileEventInspection";
 import TileInspection from "game/inspection/inspections/TileInspection";
 import type { IVector3 } from "utilities/math/IVector";
+declare const inspectionTypeMap: {
+    12: typeof ActionInspection;
+    14: typeof CorpseInspection;
+    15: typeof CorpsesInspection;
+    3: typeof CreatureInspection;
+    10: typeof ItemInspection;
+    4: typeof DoodadInspection;
+    7: typeof EquipSlotInspection;
+    6: typeof PlayerInspection;
+    21: typeof IslandInspection;
+    8: typeof ItemInspection;
+    13: typeof ItemsInspection;
+    11: typeof ItemInspection;
+    19: typeof MilestoneInspection;
+    2: typeof NPCInspection;
+    1: typeof PlayerInspection;
+    9: typeof RecipeInspection;
+    0: typeof SelfInspection;
+    18: typeof SkillInspection;
+    20: typeof StatInspection;
+    17: typeof TileInspection;
+    5: typeof TileEventInspection;
+    16: typeof TileEventInspection.Minors;
+};
 export declare type InspectionClass = Class<Inspection<any>> & {
     isWorldInspection?(inspectType: InspectType): boolean;
     getFromTile?(position: IVector3, context: InfoProviderContext, inspectType: InspectType): ArrayOr<Inspection<any>>;
@@ -67,6 +91,7 @@ declare const _default: {
     16: typeof TileEventInspection.Minors;
 } & Record<InspectType, InspectionClass>;
 export default _default;
+export declare type ResolvedInspection<TYPE extends InspectType> = InstanceOf<(typeof inspectionTypeMap)[TYPE]>;
 export declare module Inspections {
     function get(...args: any[]): Inspection<any> | undefined;
     function isWorldInspection(type: InspectType): boolean;

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

@@ -21,7 +21,30 @@ export default abstract class InspectionsHandler extends EventEmitter.Host<IInsp
     protected readonly inspectionsMap: Map<InspectType, HashSet<Inspection<any>>>;
     static makeInspectionsSet(...values: Array<IterableOr<Inspection<any> | undefined>>): HashSet<Inspection<any>>;
     constructor(context: InfoProviderContext, inspectionsMap?: Map<InspectType, HashSet<Inspection<any>>>);
-    get(inspectType: InspectType): HashSet<Inspection<any>> | undefined;
+    get<TYPE extends InspectType>(inspectType: InspectType): HashSet<InstanceOf<{
+        12: typeof import("./inspections/ActionInspection").default;
+        14: typeof import("./inspections/CorpseInspection").default;
+        15: typeof import("./inspections/CorpsesInspection").default;
+        3: typeof import("./inspections/CreatureInspection").default;
+        10: typeof import("./inspections/ItemInspection").default;
+        4: typeof import("./inspections/DoodadInspection").default;
+        7: typeof import("./inspections/EquipSlotInspection").default;
+        6: typeof import("./inspections/PlayerInspection").default;
+        21: typeof import("./inspections/IslandInspection").default;
+        8: typeof import("./inspections/ItemInspection").default;
+        13: typeof import("./inspections/ItemsInspection").default;
+        11: typeof import("./inspections/ItemInspection").default;
+        19: typeof import("./inspections/MilestoneInspection").default;
+        2: typeof import("./inspections/NPCInspection").default;
+        1: typeof import("./inspections/PlayerInspection").default;
+        9: typeof import("./inspections/RecipeInspection").default;
+        0: typeof import("./inspections/SelfInspection").default;
+        18: typeof import("./inspections/SkillInspection").default;
+        20: typeof import("./inspections/StatInspection").default;
+        17: typeof import("./inspections/TileInspection").default;
+        5: typeof import("./inspections/TileEventInspection").default;
+        16: typeof import("./inspections/TileEventInspection").default.Minors;
+    }[TYPE]>> | undefined;
     set(inspectType: InspectType, inspections: HashSet<Inspection<any>>): Map<InspectType, HashSet<Inspection<any>>>;
     [Symbol.iterator](): IterableIterator<[InspectType, HashSet<Inspection<any>>]>;
     types(): import("@wayward/goodstream").default<InspectType>;

package/definitions/game/game/inspection/infoProviders/item/ItemDetails.d.ts

@@ -19,7 +19,7 @@ export default class ItemDetailsInfoProvider extends InfoProvider {
     private readonly description;
     constructor(item: Item | ItemType);
     getClass(): string[];
-    get(): (0 | LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider | ItemWorthInfoProvider)[];
+    get(): (0 | import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue | ItemWorthInfoProvider)[];
     private getInsulation;
     private getPreservation;
     private getGroupings;

package/definitions/game/game/inspection/infoProviders/stat/AttackInfo.d.ts

@@ -15,7 +15,7 @@ export default class AttackInfo extends InfoProvider {
     private readonly human?;
     constructor(human?: Human | undefined);
     getClass(): string[];
-    get(): (LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider)[];
+    get(): (import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue)[];
     private getTactics;
     private getMainHand;
     private getOffHand;

package/definitions/game/game/inspection/inspections/ActionInspection.d.ts

@@ -10,9 +10,10 @@
  */
 import { ActionType } from "game/entity/action/IAction";
 import type { IUsableActionPossibleUsing } from "game/entity/action/usable/UsableAction";
+import { UsableActionTranslationContext } from "game/entity/action/usable/UsableAction";
 import { InspectType } from "game/inspection/IInspection";
 import { InfoProvider } from "game/inspection/InfoProvider";
-import type { InfoProviderContext } from "game/inspection/InfoProviderContext";
+import { InfoProviderContext } from "game/inspection/InfoProviderContext";
 import Inspection from "game/inspection/Inspection";
 import type { EnumReferenceResolved } from "game/reference/IReferenceManager";
 import { ReferenceType } from "game/reference/IReferenceManager";
@@ -24,7 +25,8 @@ export default class ActionInspection extends Inspection<ActionType | string | u
     private readonly item?;
     using?: IUsableActionPossibleUsing;
     constructor(value?: string | EnumReferenceResolved<ReferenceType.Action>, slot?: ActionSlot | undefined);
-    setUsing(using?: IUsableActionPossibleUsing): void;
+    setUsing(using?: IUsableActionPossibleUsing): this;
+    setContext(context: UsableActionTranslationContext): this;
     getId(): string;
     get(context: InfoProviderContext): ArrayOr<TranslationGenerator | InfoProvider>;
     private getTranslation;

package/definitions/game/game/inspection/inspections/CorpseInspection.d.ts

@@ -19,7 +19,7 @@ export default class CorpseInspection extends Inspection<Corpse> {
     static getFromTile(position: IVector3): CorpseInspection[];
     static handles(type: InspectType, corpse: unknown): boolean;
     constructor(corpse: Corpse);
-    get(context: InfoProviderContext): (0 | LabelledValue | import("game/inspection/InfoProvider").SimpleInfoProvider)[];
+    get(context: InfoProviderContext): (0 | import("game/inspection/InfoProvider").SimpleInfoProvider | LabelledValue)[];
     private getDecay;
     private decay;
     private shouldRefreshDecay;

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

@@ -249,6 +249,10 @@ export interface IItemDescription extends IObjectDescription, IModdable, ITemper
      */
     firedWith?: ItemTypeGroup;
     vehicle?: IItemVehicle;
+    /**
+     * If set to true, this item will not grant quality bonuses (durability/quality bonuses) when used in a craft. Aptitude and tiers will still apply.
+     */
+    noCraftingQualityBonus?: boolean;
     onEquip?(item: Item): void;
     onUnequip?(item: Item): void;
 }

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

@@ -46,7 +46,7 @@ export default class Button extends Component implements IDisableable {
     constructor(elementType?: string, listenForEvents?: boolean);
     setDisplayMode(mode: ButtonClasses.DisplayModeButtonList, zoomClass: ButtonClasses.ListIconsZoom2To3): this;
     setDisplayMode(mode: ButtonClasses.DisplayModeBlock | ButtonClasses.DisplayModeIcon | ButtonClasses.DisplayModeButtonList | false): this;
-    setActionless(isActionless?: boolean): this;
+    setActionless(isActionless?: boolean, setDisabled?: boolean): this;
     isButtonList(): boolean;
     setDisabled(val?: boolean, reason?: string): this;
     setActive(val?: boolean, reason?: string): this;

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

@@ -30,6 +30,7 @@ export default abstract class InspectionsTooltipHandler<INSPECTIONS_LIST extends
     private lastMousePosition?;
     initializeTooltip(tooltip: Tooltip, ...args: TOOLTIP_ARGS): Promise<void>;
     remove(tooltip?: IInspectionsTooltipHandlerCurrent<INSPECTIONS_LIST, TOOLTIP_ARGS> | undefined): Promise<void>;
+    onInitInspections(handler: (inspections: INSPECTIONS_LIST) => any): void;
     protected abstract initializeInspections(...args: TOOLTIP_ARGS): INSPECTIONS_LIST | undefined;
     protected onUpdateTooltipPosition(position: Vector2): void;
     protected getTooltipClass(): string[];

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

@@ -140,7 +140,7 @@ export default abstract class Dialog extends Component implements IDialog {
      */
     private description;
     constructor(id: number, subId?: string);
-    addScrollableWrapper(initializer?: (wrapper: Component) => any): Component<HTMLElement>;
+    addScrollableWrapper(type?: "scroll" | "auto", initializer?: (wrapper: Component) => any): Component<HTMLElement>;
     addSettingsPanel(): Component<HTMLElement>;
     showSettingsPanel(): this;
     resetSizeAndPosition(): void;

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

@@ -14,6 +14,7 @@ import type { InspectType } from "game/inspection/IInspection";
 import type { InfoProviderContext } from "game/inspection/InfoProviderContext";
 import type Inspection from "game/inspection/Inspection";
 import type InspectionsHandler from "game/inspection/InspectionsHandler";
+import type { ResolvedInspection } from "game/inspection/InspectionTypeMap";
 import Component from "ui/component/Component";
 import type { TranslationGenerator } from "ui/component/IComponent";
 import type HashSet from "utilities/collection/set/HashSet";
@@ -22,6 +23,7 @@ export interface ITileInspectionsEvents extends Events<Component> {
     updateInspectTypeFilter(): any;
     updateDisplayLevel(): any;
 }
+export declare type InspectionsHandlerOf<INSPECTIONS_LIST extends InspectionsList> = INSPECTIONS_LIST extends InspectionsList<infer INSPECTIONS_HANDLER> ? INSPECTIONS_HANDLER : never;
 export default abstract class InspectionsList<INSPECTIONS_HANDLER extends InspectionsHandler = InspectionsHandler> extends Component {
     protected readonly context: InfoProviderContext;
     readonly event: IEventEmitter<this, ITileInspectionsEvents>;
@@ -34,6 +36,7 @@ export default abstract class InspectionsList<INSPECTIONS_HANDLER extends Inspec
     private readonly inspectTypeWrappers;
     private readonly previouslyRefreshed;
     constructor(context: InfoProviderContext);
+    get<TYPE extends InspectType>(type: TYPE): HashSet<ResolvedInspection<TYPE>> | undefined;
     setInspectTypeFilter(filter?: (inspectType: InspectType) => boolean): this;
     refreshInspectTypeFilter(): this;
     deregister(): void;

package/definitions/game/ui/tooltip/Tooltip.d.ts

@@ -53,6 +53,7 @@ export default class Tooltip extends Component {
      */
     setMaxWidth(maxWidth?: number | `${number}vw`): this;
     setText(translation: GetterOfOr<Translation | UiTranslation>, ...args: any[]): this;
+    private delay;
     setDelay(delay: number): this;
     getLastBlock(): TooltipBlock;
     getBlocks(): import("@wayward/goodstream").default<TooltipBlock>;

package/package.json

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