diff --git a/project/Server.code-workspace b/project/Server.code-workspace index 2c833b46..b989ba88 100644 --- a/project/Server.code-workspace +++ b/project/Server.code-workspace @@ -74,9 +74,11 @@ "Tarkov", "toggleable", "tooshort", + "Ubgl", "unrestartable", "usec", "userbuilds", + "weapongen", "Wishlist" ] } diff --git a/project/src/di/Container.ts b/project/src/di/Container.ts index 41e578d3..9e13eb14 100644 --- a/project/src/di/Container.ts +++ b/project/src/di/Container.ts @@ -69,17 +69,17 @@ import { BotWeaponGenerator } from "@spt-aki/generators/BotWeaponGenerator"; import { FenceBaseAssortGenerator } from "@spt-aki/generators/FenceBaseAssortGenerator"; import { LocationGenerator } from "@spt-aki/generators/LocationGenerator"; import { LootGenerator } from "@spt-aki/generators/LootGenerator"; -import { PMCLootGenerator } from "@spt-aki/generators/PMCLootGenerator"; import { PlayerScavGenerator } from "@spt-aki/generators/PlayerScavGenerator"; +import { PMCLootGenerator } from "@spt-aki/generators/PMCLootGenerator"; import { RagfairAssortGenerator } from "@spt-aki/generators/RagfairAssortGenerator"; import { RagfairOfferGenerator } from "@spt-aki/generators/RagfairOfferGenerator"; import { RepeatableQuestGenerator } from "@spt-aki/generators/RepeatableQuestGenerator"; import { ScavCaseRewardGenerator } from "@spt-aki/generators/ScavCaseRewardGenerator"; -import { WeatherGenerator } from "@spt-aki/generators/WeatherGenerator"; import { BarrelInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/BarrelInventoryMagGen"; import { ExternalInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/ExternalInventoryMagGen"; import { InternalMagazineInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/InternalMagazineInventoryMagGen"; import { UbglExternalMagGen } from "@spt-aki/generators/weapongen/implementations/UbglExternalMagGen"; +import { WeatherGenerator } from "@spt-aki/generators/WeatherGenerator"; import { AssortHelper } from "@spt-aki/helpers/AssortHelper"; import { BotDifficultyHelper } from "@spt-aki/helpers/BotDifficultyHelper"; import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper"; @@ -124,10 +124,6 @@ import { PostAkiModLoader } from "@spt-aki/loaders/PostAkiModLoader"; import { PostDBModLoader } from "@spt-aki/loaders/PostDBModLoader"; import { PreAkiModLoader } from "@spt-aki/loaders/PreAkiModLoader"; import { IAsyncQueue } from "@spt-aki/models/spt/utils/IAsyncQueue"; -import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder"; -import { HttpRouter } from "@spt-aki/routers/HttpRouter"; -import { ImageRouter } from "@spt-aki/routers/ImageRouter"; -import { ItemEventRouter } from "@spt-aki/routers/ItemEventRouter"; import { BotDynamicRouter } from "@spt-aki/routers/dynamic/BotDynamicRouter"; import { BundleDynamicRouter } from "@spt-aki/routers/dynamic/BundleDynamicRouter"; import { CustomizationDynamicRouter } from "@spt-aki/routers/dynamic/CustomizationDynamicRouter"; @@ -137,6 +133,9 @@ import { InraidDynamicRouter } from "@spt-aki/routers/dynamic/InraidDynamicRoute import { LocationDynamicRouter } from "@spt-aki/routers/dynamic/LocationDynamicRouter"; import { NotifierDynamicRouter } from "@spt-aki/routers/dynamic/NotifierDynamicRouter"; import { TraderDynamicRouter } from "@spt-aki/routers/dynamic/TraderDynamicRouter"; +import { EventOutputHolder } from "@spt-aki/routers/EventOutputHolder"; +import { HttpRouter } from "@spt-aki/routers/HttpRouter"; +import { ImageRouter } from "@spt-aki/routers/ImageRouter"; import { CustomizationItemEventRouter } from "@spt-aki/routers/item_events/CustomizationItemEventRouter"; import { HealthItemEventRouter } from "@spt-aki/routers/item_events/HealthItemEventRouter"; import { HideoutItemEventRouter } from "@spt-aki/routers/item_events/HideoutItemEventRouter"; @@ -149,6 +148,7 @@ import { RagfairItemEventRouter } from "@spt-aki/routers/item_events/RagfairItem import { RepairItemEventRouter } from "@spt-aki/routers/item_events/RepairItemEventRouter"; import { TradeItemEventRouter } from "@spt-aki/routers/item_events/TradeItemEventRouter"; import { WishlistItemEventRouter } from "@spt-aki/routers/item_events/WishlistItemEventRouter"; +import { ItemEventRouter } from "@spt-aki/routers/ItemEventRouter"; import { HealthSaveLoadRouter } from "@spt-aki/routers/save_load/HealthSaveLoadRouter"; import { InraidSaveLoadRouter } from "@spt-aki/routers/save_load/InraidSaveLoadRouter"; import { InsuranceSaveLoadRouter } from "@spt-aki/routers/save_load/InsuranceSaveLoadRouter"; @@ -179,11 +179,11 @@ import { TraderStaticRouter } from "@spt-aki/routers/static/TraderStaticRouter"; import { WeatherStaticRouter } from "@spt-aki/routers/static/WeatherStaticRouter"; import { ConfigServer } from "@spt-aki/servers/ConfigServer"; import { DatabaseServer } from "@spt-aki/servers/DatabaseServer"; +import { AkiHttpListener } from "@spt-aki/servers/http/AkiHttpListener"; import { HttpServer } from "@spt-aki/servers/HttpServer"; import { RagfairServer } from "@spt-aki/servers/RagfairServer"; import { SaveServer } from "@spt-aki/servers/SaveServer"; import { WebSocketServer } from "@spt-aki/servers/WebSocketServer"; -import { AkiHttpListener } from "@spt-aki/servers/http/AkiHttpListener"; import { BotEquipmentFilterService } from "@spt-aki/services/BotEquipmentFilterService"; import { BotEquipmentModPoolService } from "@spt-aki/services/BotEquipmentModPoolService"; import { BotGenerationCacheService } from "@spt-aki/services/BotGenerationCacheService"; @@ -201,6 +201,13 @@ import { LocalisationService } from "@spt-aki/services/LocalisationService"; import { MailSendService } from "@spt-aki/services/MailSendService"; import { MatchBotDetailsCacheService } from "@spt-aki/services/MatchBotDetailsCacheService"; import { MatchLocationService } from "@spt-aki/services/MatchLocationService"; +import { CustomItemService } from "@spt-aki/services/mod/CustomItemService"; +import { DynamicRouterModService } from "@spt-aki/services/mod/dynamicRouter/DynamicRouterModService"; +import { HttpListenerModService } from "@spt-aki/services/mod/httpListener/HttpListenerModService"; +import { ImageRouteService } from "@spt-aki/services/mod/image/ImageRouteService"; +import { OnLoadModService } from "@spt-aki/services/mod/onLoad/OnLoadModService"; +import { OnUpdateModService } from "@spt-aki/services/mod/onUpdate/OnUpdateModService"; +import { StaticRouterModService } from "@spt-aki/services/mod/staticRouter/StaticRouterModService"; import { ModCompilerService } from "@spt-aki/services/ModCompilerService"; import { NotificationService } from "@spt-aki/services/NotificationService"; import { OpenZoneService } from "@spt-aki/services/OpenZoneService"; @@ -219,13 +226,6 @@ import { RepairService } from "@spt-aki/services/RepairService"; import { SeasonalEventService } from "@spt-aki/services/SeasonalEventService"; import { TraderAssortService } from "@spt-aki/services/TraderAssortService"; import { TraderPurchasePersisterService } from "@spt-aki/services/TraderPurchasePersisterService"; -import { CustomItemService } from "@spt-aki/services/mod/CustomItemService"; -import { DynamicRouterModService } from "@spt-aki/services/mod/dynamicRouter/DynamicRouterModService"; -import { HttpListenerModService } from "@spt-aki/services/mod/httpListener/HttpListenerModService"; -import { ImageRouteService } from "@spt-aki/services/mod/image/ImageRouteService"; -import { OnLoadModService } from "@spt-aki/services/mod/onLoad/OnLoadModService"; -import { OnUpdateModService } from "@spt-aki/services/mod/onUpdate/OnUpdateModService"; -import { StaticRouterModService } from "@spt-aki/services/mod/staticRouter/StaticRouterModService"; import { App } from "@spt-aki/utils/App"; import { AsyncQueue } from "@spt-aki/utils/AsyncQueue"; import { DatabaseImporter } from "@spt-aki/utils/DatabaseImporter"; @@ -235,428 +235,448 @@ import { HttpFileUtil } from "@spt-aki/utils/HttpFileUtil"; import { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil"; import { ImporterUtil } from "@spt-aki/utils/ImporterUtil"; import { JsonUtil } from "@spt-aki/utils/JsonUtil"; +import { WinstonMainLogger } from "@spt-aki/utils/logging/WinstonMainLogger"; +import { WinstonRequestLogger } from "@spt-aki/utils/logging/WinstonRequestLogger"; import { MathUtil } from "@spt-aki/utils/MathUtil"; import { ObjectId } from "@spt-aki/utils/ObjectId"; import { RandomUtil } from "@spt-aki/utils/RandomUtil"; import { TimeUtil } from "@spt-aki/utils/TimeUtil"; import { VFS } from "@spt-aki/utils/VFS"; import { Watermark, WatermarkLocale } from "@spt-aki/utils/Watermark"; -import { WinstonMainLogger } from "@spt-aki/utils/logging/WinstonMainLogger"; -import { WinstonRequestLogger } from "@spt-aki/utils/logging/WinstonRequestLogger"; /** * Handle the registration of classes to be used by the Dependency Injection code */ export class Container { - - public static registerPostLoadTypes(container: DependencyContainer, childContainer: DependencyContainer):void + public static registerPostLoadTypes(container: DependencyContainer, childContainer: DependencyContainer): void { container.register("AkiHttpListener", AkiHttpListener, {lifecycle: Lifecycle.Singleton}); childContainer.registerType("HttpListener", "AkiHttpListener"); } - public static registerTypes(depContainer: DependencyContainer): void + public static registerTypes(con: DependencyContainer): void { - depContainer.register("ApplicationContext", ApplicationContext, { lifecycle: Lifecycle.Singleton }); - Container.registerUtils(depContainer); - - Container.registerRouters(depContainer); - - Container.registerGenerators(depContainer); - - Container.registerHelpers(depContainer); - - Container.registerLoaders(depContainer); - - Container.registerCallbacks(depContainer); - - Container.registerServers(depContainer); - - Container.registerServices(depContainer); - - Container.registerControllers(depContainer); + con.register("ApplicationContext", ApplicationContext, {lifecycle: Lifecycle.Singleton}); + Container.registerUtils(con); + Container.registerRouters(con); + Container.registerGenerators(con); + Container.registerHelpers(con); + Container.registerLoaders(con); + Container.registerCallbacks(con); + Container.registerServers(con); + Container.registerServices(con); + Container.registerControllers(con); } - public static registerListTypes(depContainer: DependencyContainer): void + public static registerListTypes(con: DependencyContainer): void { - depContainer.register("OnLoadModService", { useValue: new OnLoadModService(depContainer) }); - depContainer.register("HttpListenerModService", { useValue: new HttpListenerModService(depContainer) }); - depContainer.register("OnUpdateModService", { useValue: new OnUpdateModService(depContainer) }); - depContainer.register("DynamicRouterModService", { useValue: new DynamicRouterModService(depContainer) }); - depContainer.register("StaticRouterModService", { useValue: new StaticRouterModService(depContainer) }); + con.register("OnLoadModService", {useValue: new OnLoadModService(con)}); + con.register("HttpListenerModService", {useValue: new HttpListenerModService(con)}); + con.register("OnUpdateModService", {useValue: new OnUpdateModService(con)}); + con.register("DynamicRouterModService", {useValue: new DynamicRouterModService(con)}); + con.register("StaticRouterModService", {useValue: new StaticRouterModService(con)}); - depContainer.registerType("OnLoad", "DatabaseImporter"); - depContainer.registerType("OnLoad", "PostDBModLoader"); - depContainer.registerType("OnLoad", "HandbookCallbacks"); - depContainer.registerType("OnLoad", "HttpCallbacks"); - depContainer.registerType("OnLoad", "PresetCallbacks"); - depContainer.registerType("OnLoad", "SaveCallbacks"); - depContainer.registerType("OnLoad", "TraderCallbacks"); // must occur prior to RagfairCallbacks - depContainer.registerType("OnLoad", "RagfairPriceService"); - depContainer.registerType("OnLoad", "RagfairCallbacks"); - depContainer.registerType("OnLoad", "ModCallbacks"); - depContainer.registerType("OnLoad", "GameCallbacks"); - depContainer.registerType("OnUpdate", "DialogueCallbacks"); - depContainer.registerType("OnUpdate", "HideoutCallbacks"); - depContainer.registerType("OnUpdate", "TraderCallbacks"); - depContainer.registerType("OnUpdate", "RagfairCallbacks"); - depContainer.registerType("OnUpdate", "InsuranceCallbacks"); - depContainer.registerType("OnUpdate", "SaveCallbacks"); + con.registerType("OnLoad", "DatabaseImporter"); + con.registerType("OnLoad", "PostDBModLoader"); + con.registerType("OnLoad", "HandbookCallbacks"); + con.registerType("OnLoad", "HttpCallbacks"); + con.registerType("OnLoad", "PresetCallbacks"); + con.registerType("OnLoad", "SaveCallbacks"); + con.registerType("OnLoad", "TraderCallbacks"); // Must occur prior to RagfairCallbacks + con.registerType("OnLoad", "RagfairPriceService"); + con.registerType("OnLoad", "RagfairCallbacks"); + con.registerType("OnLoad", "ModCallbacks"); + con.registerType("OnLoad", "GameCallbacks"); + con.registerType("OnUpdate", "DialogueCallbacks"); + con.registerType("OnUpdate", "HideoutCallbacks"); + con.registerType("OnUpdate", "TraderCallbacks"); + con.registerType("OnUpdate", "RagfairCallbacks"); + con.registerType("OnUpdate", "InsuranceCallbacks"); + con.registerType("OnUpdate", "SaveCallbacks"); - depContainer.registerType("StaticRoutes", "BotStaticRouter"); - depContainer.registerType("StaticRoutes", "ClientLogStaticRouter"); - depContainer.registerType("StaticRoutes", "CustomizationStaticRouter"); - depContainer.registerType("StaticRoutes", "DataStaticRouter"); - depContainer.registerType("StaticRoutes", "DialogStaticRouter"); - depContainer.registerType("StaticRoutes", "GameStaticRouter"); - depContainer.registerType("StaticRoutes", "HealthStaticRouter"); - depContainer.registerType("StaticRoutes", "InraidStaticRouter"); - depContainer.registerType("StaticRoutes", "InsuranceStaticRouter"); - depContainer.registerType("StaticRoutes", "ItemEventStaticRouter"); - depContainer.registerType("StaticRoutes", "LauncherStaticRouter"); - depContainer.registerType("StaticRoutes", "LocationStaticRouter"); - depContainer.registerType("StaticRoutes", "WeatherStaticRouter"); - depContainer.registerType("StaticRoutes", "MatchStaticRouter"); - depContainer.registerType("StaticRoutes", "QuestStaticRouter"); - depContainer.registerType("StaticRoutes", "RagfairStaticRouter"); - depContainer.registerType("StaticRoutes", "PresetStaticRouter"); - depContainer.registerType("StaticRoutes", "BundleStaticRouter"); - depContainer.registerType("StaticRoutes", "NotifierStaticRouter"); - depContainer.registerType("StaticRoutes", "ProfileStaticRouter"); - depContainer.registerType("StaticRoutes", "TraderStaticRouter"); - depContainer.registerType("DynamicRoutes", "BotDynamicRouter"); - depContainer.registerType("DynamicRoutes", "BundleDynamicRouter"); - depContainer.registerType("DynamicRoutes", "CustomizationDynamicRouter"); - depContainer.registerType("DynamicRoutes", "DataDynamicRouter"); - depContainer.registerType("DynamicRoutes", "HttpDynamicRouter"); - depContainer.registerType("DynamicRoutes", "InraidDynamicRouter"); - depContainer.registerType("DynamicRoutes", "LocationDynamicRouter"); - depContainer.registerType("DynamicRoutes", "NotifierDynamicRouter"); - depContainer.registerType("DynamicRoutes", "TraderDynamicRouter"); + con.registerType("StaticRoutes", "BotStaticRouter"); + con.registerType("StaticRoutes", "ClientLogStaticRouter"); + con.registerType("StaticRoutes", "CustomizationStaticRouter"); + con.registerType("StaticRoutes", "DataStaticRouter"); + con.registerType("StaticRoutes", "DialogStaticRouter"); + con.registerType("StaticRoutes", "GameStaticRouter"); + con.registerType("StaticRoutes", "HealthStaticRouter"); + con.registerType("StaticRoutes", "InraidStaticRouter"); + con.registerType("StaticRoutes", "InsuranceStaticRouter"); + con.registerType("StaticRoutes", "ItemEventStaticRouter"); + con.registerType("StaticRoutes", "LauncherStaticRouter"); + con.registerType("StaticRoutes", "LocationStaticRouter"); + con.registerType("StaticRoutes", "WeatherStaticRouter"); + con.registerType("StaticRoutes", "MatchStaticRouter"); + con.registerType("StaticRoutes", "QuestStaticRouter"); + con.registerType("StaticRoutes", "RagfairStaticRouter"); + con.registerType("StaticRoutes", "PresetStaticRouter"); + con.registerType("StaticRoutes", "BundleStaticRouter"); + con.registerType("StaticRoutes", "NotifierStaticRouter"); + con.registerType("StaticRoutes", "ProfileStaticRouter"); + con.registerType("StaticRoutes", "TraderStaticRouter"); + con.registerType("DynamicRoutes", "BotDynamicRouter"); + con.registerType("DynamicRoutes", "BundleDynamicRouter"); + con.registerType("DynamicRoutes", "CustomizationDynamicRouter"); + con.registerType("DynamicRoutes", "DataDynamicRouter"); + con.registerType("DynamicRoutes", "HttpDynamicRouter"); + con.registerType("DynamicRoutes", "InraidDynamicRouter"); + con.registerType("DynamicRoutes", "LocationDynamicRouter"); + con.registerType("DynamicRoutes", "NotifierDynamicRouter"); + con.registerType("DynamicRoutes", "TraderDynamicRouter"); - depContainer.registerType("IERouters", "CustomizationItemEventRouter"); - depContainer.registerType("IERouters", "HealthItemEventRouter"); - depContainer.registerType("IERouters", "HideoutItemEventRouter"); - depContainer.registerType("IERouters", "InsuranceItemEventRouter"); - depContainer.registerType("IERouters", "InventoryItemEventRouter"); - depContainer.registerType("IERouters", "NoteItemEventRouter"); - depContainer.registerType("IERouters", "PresetBuildItemEventRouter"); - depContainer.registerType("IERouters", "QuestItemEventRouter"); - depContainer.registerType("IERouters", "RagfairItemEventRouter"); - depContainer.registerType("IERouters", "RepairItemEventRouter"); - depContainer.registerType("IERouters", "TradeItemEventRouter"); - depContainer.registerType("IERouters", "WishlistItemEventRouter"); + con.registerType("IERouters", "CustomizationItemEventRouter"); + con.registerType("IERouters", "HealthItemEventRouter"); + con.registerType("IERouters", "HideoutItemEventRouter"); + con.registerType("IERouters", "InsuranceItemEventRouter"); + con.registerType("IERouters", "InventoryItemEventRouter"); + con.registerType("IERouters", "NoteItemEventRouter"); + con.registerType("IERouters", "PresetBuildItemEventRouter"); + con.registerType("IERouters", "QuestItemEventRouter"); + con.registerType("IERouters", "RagfairItemEventRouter"); + con.registerType("IERouters", "RepairItemEventRouter"); + con.registerType("IERouters", "TradeItemEventRouter"); + con.registerType("IERouters", "WishlistItemEventRouter"); - depContainer.registerType("Serializer", "ImageSerializer"); - depContainer.registerType("Serializer", "BundleSerializer"); - depContainer.registerType("Serializer", "NotifySerializer"); - depContainer.registerType("SaveLoadRouter", "HealthSaveLoadRouter"); - depContainer.registerType("SaveLoadRouter", "InraidSaveLoadRouter"); - depContainer.registerType("SaveLoadRouter", "InsuranceSaveLoadRouter"); - depContainer.registerType("SaveLoadRouter", "ProfileSaveLoadRouter"); + con.registerType("Serializer", "ImageSerializer"); + con.registerType("Serializer", "BundleSerializer"); + con.registerType("Serializer", "NotifySerializer"); + con.registerType("SaveLoadRouter", "HealthSaveLoadRouter"); + con.registerType("SaveLoadRouter", "InraidSaveLoadRouter"); + con.registerType("SaveLoadRouter", "InsuranceSaveLoadRouter"); + con.registerType("SaveLoadRouter", "ProfileSaveLoadRouter"); } - private static registerUtils(depContainer: DependencyContainer): void + private static registerUtils(con: DependencyContainer): void { // Utils - depContainer.register("App", App, { lifecycle: Lifecycle.Singleton }); - depContainer.register("DatabaseImporter", DatabaseImporter, { lifecycle: Lifecycle.Singleton }); - depContainer.register("HashUtil", HashUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ImporterUtil", ImporterUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("HttpResponseUtil", HttpResponseUtil); - depContainer.register("EncodingUtil", EncodingUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("JsonUtil", JsonUtil); - depContainer.register("WinstonLogger", WinstonMainLogger, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RequestsLogger", WinstonRequestLogger, { lifecycle: Lifecycle.Singleton }); - depContainer.register("MathUtil", MathUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ObjectId", ObjectId); - depContainer.register("RandomUtil", RandomUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("TimeUtil", TimeUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("VFS", VFS, { lifecycle: Lifecycle.Singleton }); - depContainer.register("WatermarkLocale", WatermarkLocale, { lifecycle: Lifecycle.Singleton }); - depContainer.register("Watermark", Watermark, { lifecycle: Lifecycle.Singleton }); - depContainer.register("AsyncQueue", AsyncQueue, { lifecycle: Lifecycle.Singleton }); - depContainer.register("HttpFileUtil", HttpFileUtil, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ModLoadOrder", ModLoadOrder, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ModTypeCheck", ModTypeCheck, { lifecycle: Lifecycle.Singleton }); + con.register("App", App, {lifecycle: Lifecycle.Singleton}); + con.register("DatabaseImporter", DatabaseImporter, {lifecycle: Lifecycle.Singleton}); + con.register("HashUtil", HashUtil, {lifecycle: Lifecycle.Singleton}); + con.register("ImporterUtil", ImporterUtil, {lifecycle: Lifecycle.Singleton}); + con.register("HttpResponseUtil", HttpResponseUtil); + con.register("EncodingUtil", EncodingUtil, {lifecycle: Lifecycle.Singleton}); + con.register("JsonUtil", JsonUtil); + con.register("WinstonLogger", WinstonMainLogger, {lifecycle: Lifecycle.Singleton}); + con.register("RequestsLogger", WinstonRequestLogger, {lifecycle: Lifecycle.Singleton}); + con.register("MathUtil", MathUtil, {lifecycle: Lifecycle.Singleton}); + con.register("ObjectId", ObjectId); + con.register("RandomUtil", RandomUtil, {lifecycle: Lifecycle.Singleton}); + con.register("TimeUtil", TimeUtil, {lifecycle: Lifecycle.Singleton}); + con.register("VFS", VFS, {lifecycle: Lifecycle.Singleton}); + con.register("WatermarkLocale", WatermarkLocale, {lifecycle: Lifecycle.Singleton}); + con.register("Watermark", Watermark, {lifecycle: Lifecycle.Singleton}); + con.register("AsyncQueue", AsyncQueue, {lifecycle: Lifecycle.Singleton}); + con.register("HttpFileUtil", HttpFileUtil, {lifecycle: Lifecycle.Singleton}); + con.register("ModLoadOrder", ModLoadOrder, {lifecycle: Lifecycle.Singleton}); + con.register("ModTypeCheck", ModTypeCheck, {lifecycle: Lifecycle.Singleton}); } - private static registerRouters(depContainer: DependencyContainer): void + private static registerRouters(con: DependencyContainer): void { // Routers - depContainer.register("HttpRouter", HttpRouter, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ImageRouter", ImageRouter); - depContainer.register("EventOutputHolder", EventOutputHolder, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ItemEventRouter", ItemEventRouter); + con.register("HttpRouter", HttpRouter, {lifecycle: Lifecycle.Singleton}); + con.register("ImageRouter", ImageRouter); + con.register("EventOutputHolder", EventOutputHolder, {lifecycle: Lifecycle.Singleton}); + con.register("ItemEventRouter", ItemEventRouter); // Dynamic routes - depContainer.register("BotDynamicRouter", { useClass: BotDynamicRouter }); - depContainer.register("BundleDynamicRouter", { useClass: BundleDynamicRouter }); - depContainer.register("CustomizationDynamicRouter", { useClass: CustomizationDynamicRouter }); - depContainer.register("DataDynamicRouter", { useClass: DataDynamicRouter }); - depContainer.register("HttpDynamicRouter", { useClass: HttpDynamicRouter }); - depContainer.register("InraidDynamicRouter", { useClass: InraidDynamicRouter }); - depContainer.register("LocationDynamicRouter", { useClass: LocationDynamicRouter }); - depContainer.register("NotifierDynamicRouter", { useClass: NotifierDynamicRouter }); - depContainer.register("TraderDynamicRouter", { useClass: TraderDynamicRouter }); + con.register("BotDynamicRouter", {useClass: BotDynamicRouter}); + con.register("BundleDynamicRouter", {useClass: BundleDynamicRouter}); + con.register("CustomizationDynamicRouter", {useClass: CustomizationDynamicRouter}); + con.register("DataDynamicRouter", {useClass: DataDynamicRouter}); + con.register("HttpDynamicRouter", {useClass: HttpDynamicRouter}); + con.register("InraidDynamicRouter", {useClass: InraidDynamicRouter}); + con.register("LocationDynamicRouter", {useClass: LocationDynamicRouter}); + con.register("NotifierDynamicRouter", {useClass: NotifierDynamicRouter}); + con.register("TraderDynamicRouter", {useClass: TraderDynamicRouter}); // Item event routes - depContainer.register("CustomizationItemEventRouter", { useClass: CustomizationItemEventRouter }); - depContainer.register("HealthItemEventRouter", { useClass: HealthItemEventRouter }); - depContainer.register("HideoutItemEventRouter", { useClass: HideoutItemEventRouter }); - depContainer.register("InsuranceItemEventRouter", { useClass: InsuranceItemEventRouter }); - depContainer.register("InventoryItemEventRouter", { useClass: InventoryItemEventRouter }); - depContainer.register("NoteItemEventRouter", { useClass: NoteItemEventRouter }); - depContainer.register("PresetBuildItemEventRouter", { useClass: PresetBuildItemEventRouter }); - depContainer.register("QuestItemEventRouter", { useClass: QuestItemEventRouter }); - depContainer.register("RagfairItemEventRouter", { useClass: RagfairItemEventRouter }); - depContainer.register("RepairItemEventRouter", { useClass: RepairItemEventRouter }); - depContainer.register("TradeItemEventRouter", { useClass: TradeItemEventRouter }); - depContainer.register("WishlistItemEventRouter", { useClass: WishlistItemEventRouter }); + con.register("CustomizationItemEventRouter", { + useClass: CustomizationItemEventRouter, + }); + con.register("HealthItemEventRouter", {useClass: HealthItemEventRouter}); + con.register("HideoutItemEventRouter", {useClass: HideoutItemEventRouter}); + con.register("InsuranceItemEventRouter", {useClass: InsuranceItemEventRouter}); + con.register("InventoryItemEventRouter", {useClass: InventoryItemEventRouter}); + con.register("NoteItemEventRouter", {useClass: NoteItemEventRouter}); + con.register("PresetBuildItemEventRouter", {useClass: PresetBuildItemEventRouter}); + con.register("QuestItemEventRouter", {useClass: QuestItemEventRouter}); + con.register("RagfairItemEventRouter", {useClass: RagfairItemEventRouter}); + con.register("RepairItemEventRouter", {useClass: RepairItemEventRouter}); + con.register("TradeItemEventRouter", {useClass: TradeItemEventRouter}); + con.register("WishlistItemEventRouter", {useClass: WishlistItemEventRouter}); // save load routes - depContainer.register("HealthSaveLoadRouter", { useClass: HealthSaveLoadRouter }); - depContainer.register("InraidSaveLoadRouter", { useClass: InraidSaveLoadRouter }); - depContainer.register("InsuranceSaveLoadRouter", { useClass: InsuranceSaveLoadRouter }); - depContainer.register("ProfileSaveLoadRouter", { useClass: ProfileSaveLoadRouter }); + con.register("HealthSaveLoadRouter", {useClass: HealthSaveLoadRouter}); + con.register("InraidSaveLoadRouter", {useClass: InraidSaveLoadRouter}); + con.register("InsuranceSaveLoadRouter", {useClass: InsuranceSaveLoadRouter}); + con.register("ProfileSaveLoadRouter", {useClass: ProfileSaveLoadRouter}); // Route serializers - depContainer.register("BundleSerializer", { useClass: BundleSerializer }); - depContainer.register("ImageSerializer", { useClass: ImageSerializer }); - depContainer.register("NotifySerializer", { useClass: NotifySerializer }); + con.register("BundleSerializer", {useClass: BundleSerializer}); + con.register("ImageSerializer", {useClass: ImageSerializer}); + con.register("NotifySerializer", {useClass: NotifySerializer}); // Static routes - depContainer.register("BotStaticRouter", { useClass: BotStaticRouter }); - depContainer.register("BundleStaticRouter", { useClass: BundleStaticRouter }); - depContainer.register("ClientLogStaticRouter", { useClass: ClientLogStaticRouter }); - depContainer.register("CustomizationStaticRouter", { useClass: CustomizationStaticRouter }); - depContainer.register("DataStaticRouter", { useClass: DataStaticRouter }); - depContainer.register("DialogStaticRouter", { useClass: DialogStaticRouter }); - depContainer.register("GameStaticRouter", { useClass: GameStaticRouter }); - depContainer.register("HealthStaticRouter", { useClass: HealthStaticRouter }); - depContainer.register("InraidStaticRouter", { useClass: InraidStaticRouter }); - depContainer.register("InsuranceStaticRouter", { useClass: InsuranceStaticRouter }); - depContainer.register("ItemEventStaticRouter", { useClass: ItemEventStaticRouter }); - depContainer.register("LauncherStaticRouter", { useClass: LauncherStaticRouter }); - depContainer.register("LocationStaticRouter", { useClass: LocationStaticRouter }); - depContainer.register("MatchStaticRouter", { useClass: MatchStaticRouter }); - depContainer.register("NotifierStaticRouter", { useClass: NotifierStaticRouter }); - depContainer.register("PresetStaticRouter", { useClass: PresetStaticRouter }); - depContainer.register("ProfileStaticRouter", { useClass: ProfileStaticRouter }); - depContainer.register("QuestStaticRouter", { useClass: QuestStaticRouter }); - depContainer.register("RagfairStaticRouter", { useClass: RagfairStaticRouter }); - depContainer.register("TraderStaticRouter", { useClass: TraderStaticRouter }); - depContainer.register("WeatherStaticRouter", { useClass: WeatherStaticRouter }); + con.register("BotStaticRouter", {useClass: BotStaticRouter}); + con.register("BundleStaticRouter", {useClass: BundleStaticRouter}); + con.register("ClientLogStaticRouter", {useClass: ClientLogStaticRouter}); + con.register("CustomizationStaticRouter", {useClass: CustomizationStaticRouter}); + con.register("DataStaticRouter", {useClass: DataStaticRouter}); + con.register("DialogStaticRouter", {useClass: DialogStaticRouter}); + con.register("GameStaticRouter", {useClass: GameStaticRouter}); + con.register("HealthStaticRouter", {useClass: HealthStaticRouter}); + con.register("InraidStaticRouter", {useClass: InraidStaticRouter}); + con.register("InsuranceStaticRouter", {useClass: InsuranceStaticRouter}); + con.register("ItemEventStaticRouter", {useClass: ItemEventStaticRouter}); + con.register("LauncherStaticRouter", {useClass: LauncherStaticRouter}); + con.register("LocationStaticRouter", {useClass: LocationStaticRouter}); + con.register("MatchStaticRouter", {useClass: MatchStaticRouter}); + con.register("NotifierStaticRouter", {useClass: NotifierStaticRouter}); + con.register("PresetStaticRouter", {useClass: PresetStaticRouter}); + con.register("ProfileStaticRouter", {useClass: ProfileStaticRouter}); + con.register("QuestStaticRouter", {useClass: QuestStaticRouter}); + con.register("RagfairStaticRouter", {useClass: RagfairStaticRouter}); + con.register("TraderStaticRouter", {useClass: TraderStaticRouter}); + con.register("WeatherStaticRouter", {useClass: WeatherStaticRouter}); } - private static registerGenerators(depContainer: DependencyContainer): void + private static registerGenerators(con: DependencyContainer): void { // Generators - depContainer.register("BotGenerator", BotGenerator); - depContainer.register("BotWeaponGenerator", BotWeaponGenerator); - depContainer.register("BotLootGenerator", BotLootGenerator); - depContainer.register("BotInventoryGenerator", BotInventoryGenerator); - depContainer.register("LocationGenerator", { useClass: LocationGenerator }); - depContainer.register("PMCLootGenerator", PMCLootGenerator, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ScavCaseRewardGenerator", ScavCaseRewardGenerator, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairAssortGenerator", { useClass: RagfairAssortGenerator }); - depContainer.register("RagfairOfferGenerator", { useClass: RagfairOfferGenerator }); - depContainer.register("WeatherGenerator", { useClass: WeatherGenerator }); - depContainer.register("PlayerScavGenerator", { useClass: PlayerScavGenerator }); - depContainer.register("LootGenerator", { useClass: LootGenerator }); - depContainer.register("FenceBaseAssortGenerator", { useClass: FenceBaseAssortGenerator }); - depContainer.register("BotLevelGenerator", { useClass: BotLevelGenerator }); - depContainer.register("BotEquipmentModGenerator", { useClass: BotEquipmentModGenerator }); - depContainer.register("RepeatableQuestGenerator", { useClass: RepeatableQuestGenerator }); - - - depContainer.register("BarrelInventoryMagGen", { useClass: BarrelInventoryMagGen }); - depContainer.register("ExternalInventoryMagGen", { useClass: ExternalInventoryMagGen }); - depContainer.register("InternalMagazineInventoryMagGen", { useClass: InternalMagazineInventoryMagGen }); - depContainer.register("UbglExternalMagGen", { useClass: UbglExternalMagGen }); - - depContainer.registerType("InventoryMagGen", "BarrelInventoryMagGen"); - depContainer.registerType("InventoryMagGen", "ExternalInventoryMagGen"); - depContainer.registerType("InventoryMagGen", "InternalMagazineInventoryMagGen"); - depContainer.registerType("InventoryMagGen", "UbglExternalMagGen"); + con.register("BotGenerator", BotGenerator); + con.register("BotWeaponGenerator", BotWeaponGenerator); + con.register("BotLootGenerator", BotLootGenerator); + con.register("BotInventoryGenerator", BotInventoryGenerator); + con.register("LocationGenerator", {useClass: LocationGenerator}); + con.register("PMCLootGenerator", PMCLootGenerator, {lifecycle: Lifecycle.Singleton}); + con.register("ScavCaseRewardGenerator", ScavCaseRewardGenerator, { + lifecycle: Lifecycle.Singleton, + }); + con.register("RagfairAssortGenerator", {useClass: RagfairAssortGenerator}); + con.register("RagfairOfferGenerator", {useClass: RagfairOfferGenerator}); + con.register("WeatherGenerator", {useClass: WeatherGenerator}); + con.register("PlayerScavGenerator", {useClass: PlayerScavGenerator}); + con.register("LootGenerator", {useClass: LootGenerator}); + con.register("FenceBaseAssortGenerator", {useClass: FenceBaseAssortGenerator}); + con.register("BotLevelGenerator", {useClass: BotLevelGenerator}); + con.register("BotEquipmentModGenerator", {useClass: BotEquipmentModGenerator}); + con.register("RepeatableQuestGenerator", {useClass: RepeatableQuestGenerator}); + con.register("BarrelInventoryMagGen", {useClass: BarrelInventoryMagGen}); + con.register("ExternalInventoryMagGen", {useClass: ExternalInventoryMagGen}); + con.register("InternalMagazineInventoryMagGen", { + useClass: InternalMagazineInventoryMagGen, + }); + con.register("UbglExternalMagGen", {useClass: UbglExternalMagGen}); + con.registerType("InventoryMagGen", "BarrelInventoryMagGen"); + con.registerType("InventoryMagGen", "ExternalInventoryMagGen"); + con.registerType("InventoryMagGen", "InternalMagazineInventoryMagGen"); + con.registerType("InventoryMagGen", "UbglExternalMagGen"); } - private static registerHelpers(depContainer: DependencyContainer): void + private static registerHelpers(con: DependencyContainer): void { // Helpers - depContainer.register("AssortHelper", { useClass: AssortHelper }); - depContainer.register("BotHelper", { useClass: BotHelper }); - depContainer.register("BotGeneratorHelper", { useClass: BotGeneratorHelper }); - depContainer.register("ContainerHelper", ContainerHelper); - depContainer.register("DialogueHelper", { useClass: DialogueHelper }); - depContainer.register("DurabilityLimitsHelper", { useClass: DurabilityLimitsHelper }); - depContainer.register("GameEventHelper", GameEventHelper); - depContainer.register("HandbookHelper", HandbookHelper, { lifecycle: Lifecycle.Singleton }); - depContainer.register("HealthHelper", { useClass: HealthHelper }); - depContainer.register("HideoutHelper", { useClass: HideoutHelper }); - depContainer.register("InRaidHelper", { useClass: InRaidHelper }); - depContainer.register("InventoryHelper", { useClass: InventoryHelper }); - depContainer.register("PaymentHelper", PaymentHelper); - depContainer.register("ItemHelper", { useClass: ItemHelper }); - depContainer.register("PresetHelper", PresetHelper, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ProfileHelper", { useClass: ProfileHelper }); - depContainer.register("QuestHelper", { useClass: QuestHelper }); - depContainer.register("QuestConditionHelper", QuestConditionHelper); - depContainer.register("RagfairHelper", { useClass: RagfairHelper }); - depContainer.register("RagfairSortHelper", { useClass: RagfairSortHelper }); - depContainer.register("RagfairSellHelper", { useClass: RagfairSellHelper }); - depContainer.register("RagfairOfferHelper", { useClass: RagfairOfferHelper }); - depContainer.register("RagfairServerHelper", { useClass: RagfairServerHelper }); - depContainer.register("RepairHelper", { useClass: RepairHelper }); - depContainer.register("TraderHelper", TraderHelper); - depContainer.register("TraderAssortHelper", TraderAssortHelper, { lifecycle: Lifecycle.Singleton }); - depContainer.register("TradeHelper", { useClass: TradeHelper }); - depContainer.register("NotifierHelper", { useClass: NotifierHelper }); - depContainer.register("UtilityHelper", UtilityHelper); - depContainer.register("WeightedRandomHelper", { useClass: WeightedRandomHelper }); - depContainer.register("HttpServerHelper", { useClass: HttpServerHelper }); - depContainer.register("NotificationSendHelper", { useClass: NotificationSendHelper }); - depContainer.register("SecureContainerHelper", { useClass: SecureContainerHelper }); - depContainer.register("ProbabilityHelper", { useClass: ProbabilityHelper }); - depContainer.register("BotWeaponGeneratorHelper", { useClass: BotWeaponGeneratorHelper }); - depContainer.register("BotDifficultyHelper", { useClass: BotDifficultyHelper }); - depContainer.register("RepeatableQuestHelper", { useClass: RepeatableQuestHelper }); + con.register("AssortHelper", {useClass: AssortHelper}); + con.register("BotHelper", {useClass: BotHelper}); + con.register("BotGeneratorHelper", {useClass: BotGeneratorHelper}); + con.register("ContainerHelper", ContainerHelper); + con.register("DialogueHelper", {useClass: DialogueHelper}); + con.register("DurabilityLimitsHelper", {useClass: DurabilityLimitsHelper}); + con.register("GameEventHelper", GameEventHelper); + con.register("HandbookHelper", HandbookHelper, {lifecycle: Lifecycle.Singleton}); + con.register("HealthHelper", {useClass: HealthHelper}); + con.register("HideoutHelper", {useClass: HideoutHelper}); + con.register("InRaidHelper", {useClass: InRaidHelper}); + con.register("InventoryHelper", {useClass: InventoryHelper}); + con.register("PaymentHelper", PaymentHelper); + con.register("ItemHelper", {useClass: ItemHelper}); + con.register("PresetHelper", PresetHelper, {lifecycle: Lifecycle.Singleton}); + con.register("ProfileHelper", {useClass: ProfileHelper}); + con.register("QuestHelper", {useClass: QuestHelper}); + con.register("QuestConditionHelper", QuestConditionHelper); + con.register("RagfairHelper", {useClass: RagfairHelper}); + con.register("RagfairSortHelper", {useClass: RagfairSortHelper}); + con.register("RagfairSellHelper", {useClass: RagfairSellHelper}); + con.register("RagfairOfferHelper", {useClass: RagfairOfferHelper}); + con.register("RagfairServerHelper", {useClass: RagfairServerHelper}); + con.register("RepairHelper", {useClass: RepairHelper}); + con.register("TraderHelper", TraderHelper); + con.register("TraderAssortHelper", TraderAssortHelper, {lifecycle: Lifecycle.Singleton}); + con.register("TradeHelper", {useClass: TradeHelper}); + con.register("NotifierHelper", {useClass: NotifierHelper}); + con.register("UtilityHelper", UtilityHelper); + con.register("WeightedRandomHelper", {useClass: WeightedRandomHelper}); + con.register("HttpServerHelper", {useClass: HttpServerHelper}); + con.register("NotificationSendHelper", {useClass: NotificationSendHelper}); + con.register("SecureContainerHelper", {useClass: SecureContainerHelper}); + con.register("ProbabilityHelper", {useClass: ProbabilityHelper}); + con.register("BotWeaponGeneratorHelper", {useClass: BotWeaponGeneratorHelper}); + con.register("BotDifficultyHelper", {useClass: BotDifficultyHelper}); + con.register("RepeatableQuestHelper", {useClass: RepeatableQuestHelper}); } - private static registerLoaders(depContainer: DependencyContainer): void + private static registerLoaders(con: DependencyContainer): void { // Loaders - depContainer.register("BundleLoader", BundleLoader, { lifecycle: Lifecycle.Singleton }); - depContainer.register("PreAkiModLoader", PreAkiModLoader, { lifecycle: Lifecycle.Singleton }); - depContainer.register("PostAkiModLoader", PostAkiModLoader, { lifecycle: Lifecycle.Singleton }); + con.register("BundleLoader", BundleLoader, {lifecycle: Lifecycle.Singleton}); + con.register("PreAkiModLoader", PreAkiModLoader, {lifecycle: Lifecycle.Singleton}); + con.register("PostAkiModLoader", PostAkiModLoader, {lifecycle: Lifecycle.Singleton}); } - private static registerCallbacks(depContainer: DependencyContainer): void + private static registerCallbacks(con: DependencyContainer): void { // Callbacks - depContainer.register("BotCallbacks", { useClass: BotCallbacks }); - depContainer.register("BundleCallbacks", { useClass: BundleCallbacks }); - depContainer.register("ClientLogCallbacks", { useClass: ClientLogCallbacks }); - depContainer.register("CustomizationCallbacks", { useClass: CustomizationCallbacks }); - depContainer.register("DataCallbacks", { useClass: DataCallbacks }); - depContainer.register("DialogueCallbacks", { useClass: DialogueCallbacks }); - depContainer.register("GameCallbacks", { useClass: GameCallbacks }); - depContainer.register("HandbookCallbacks", { useClass: HandbookCallbacks }); - depContainer.register("HealthCallbacks", { useClass: HealthCallbacks }); - depContainer.register("HideoutCallbacks", { useClass: HideoutCallbacks }); - depContainer.register("HttpCallbacks", { useClass: HttpCallbacks }); - depContainer.register("InraidCallbacks", { useClass: InraidCallbacks }); - depContainer.register("InsuranceCallbacks", { useClass: InsuranceCallbacks }); - depContainer.register("InventoryCallbacks", { useClass: InventoryCallbacks }); - depContainer.register("ItemEventCallbacks", { useClass: ItemEventCallbacks }); - depContainer.register("LauncherCallbacks", { useClass: LauncherCallbacks }); - depContainer.register("LocationCallbacks", { useClass: LocationCallbacks }); - depContainer.register("MatchCallbacks", { useClass: MatchCallbacks }); - depContainer.register("ModCallbacks", { useClass: ModCallbacks }); - depContainer.register("PostDBModLoader", { useClass: PostDBModLoader }); - depContainer.register("NoteCallbacks", { useClass: NoteCallbacks }); - depContainer.register("NotifierCallbacks", { useClass: NotifierCallbacks }); - depContainer.register("PresetBuildCallbacks", { useClass: PresetBuildCallbacks }); - depContainer.register("PresetCallbacks", { useClass: PresetCallbacks }); - depContainer.register("ProfileCallbacks", { useClass: ProfileCallbacks }); - depContainer.register("QuestCallbacks", { useClass: QuestCallbacks }); - depContainer.register("RagfairCallbacks", { useClass: RagfairCallbacks }); - depContainer.register("RepairCallbacks", { useClass: RepairCallbacks }); - depContainer.register("SaveCallbacks", { useClass: SaveCallbacks }); - depContainer.register("TradeCallbacks", { useClass: TradeCallbacks }); - depContainer.register("TraderCallbacks", { useClass: TraderCallbacks }); - depContainer.register("WeatherCallbacks", { useClass: WeatherCallbacks }); - depContainer.register("WishlistCallbacks", { useClass: WishlistCallbacks }); + con.register("BotCallbacks", {useClass: BotCallbacks}); + con.register("BundleCallbacks", {useClass: BundleCallbacks}); + con.register("ClientLogCallbacks", {useClass: ClientLogCallbacks}); + con.register("CustomizationCallbacks", {useClass: CustomizationCallbacks}); + con.register("DataCallbacks", {useClass: DataCallbacks}); + con.register("DialogueCallbacks", {useClass: DialogueCallbacks}); + con.register("GameCallbacks", {useClass: GameCallbacks}); + con.register("HandbookCallbacks", {useClass: HandbookCallbacks}); + con.register("HealthCallbacks", {useClass: HealthCallbacks}); + con.register("HideoutCallbacks", {useClass: HideoutCallbacks}); + con.register("HttpCallbacks", {useClass: HttpCallbacks}); + con.register("InraidCallbacks", {useClass: InraidCallbacks}); + con.register("InsuranceCallbacks", {useClass: InsuranceCallbacks}); + con.register("InventoryCallbacks", {useClass: InventoryCallbacks}); + con.register("ItemEventCallbacks", {useClass: ItemEventCallbacks}); + con.register("LauncherCallbacks", {useClass: LauncherCallbacks}); + con.register("LocationCallbacks", {useClass: LocationCallbacks}); + con.register("MatchCallbacks", {useClass: MatchCallbacks}); + con.register("ModCallbacks", {useClass: ModCallbacks}); + con.register("PostDBModLoader", {useClass: PostDBModLoader}); + con.register("NoteCallbacks", {useClass: NoteCallbacks}); + con.register("NotifierCallbacks", {useClass: NotifierCallbacks}); + con.register("PresetBuildCallbacks", {useClass: PresetBuildCallbacks}); + con.register("PresetCallbacks", {useClass: PresetCallbacks}); + con.register("ProfileCallbacks", {useClass: ProfileCallbacks}); + con.register("QuestCallbacks", {useClass: QuestCallbacks}); + con.register("RagfairCallbacks", {useClass: RagfairCallbacks}); + con.register("RepairCallbacks", {useClass: RepairCallbacks}); + con.register("SaveCallbacks", {useClass: SaveCallbacks}); + con.register("TradeCallbacks", {useClass: TradeCallbacks}); + con.register("TraderCallbacks", {useClass: TraderCallbacks}); + con.register("WeatherCallbacks", {useClass: WeatherCallbacks}); + con.register("WishlistCallbacks", {useClass: WishlistCallbacks}); } - private static registerServices(depContainer: DependencyContainer): void + private static registerServices(con: DependencyContainer): void { // Services - depContainer.register("ImageRouteService", ImageRouteService, { lifecycle: Lifecycle.Singleton }); + con.register("ImageRouteService", ImageRouteService, {lifecycle: Lifecycle.Singleton}); - depContainer.register("FenceService", FenceService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("PlayerService", { useClass: PlayerService }); - depContainer.register("PaymentService", { useClass: PaymentService }); - depContainer.register("InsuranceService", InsuranceService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("TraderAssortService", TraderAssortService, { lifecycle: Lifecycle.Singleton }); + con.register("FenceService", FenceService, {lifecycle: Lifecycle.Singleton}); + con.register("PlayerService", {useClass: PlayerService}); + con.register("PaymentService", {useClass: PaymentService}); + con.register("InsuranceService", InsuranceService, {lifecycle: Lifecycle.Singleton}); + con.register("TraderAssortService", TraderAssortService, {lifecycle: Lifecycle.Singleton}); - depContainer.register("RagfairPriceService", RagfairPriceService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairCategoriesService", RagfairCategoriesService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairOfferService", RagfairOfferService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairLinkedItemService", RagfairLinkedItemService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairRequiredItemsService", RagfairRequiredItemsService, { lifecycle: Lifecycle.Singleton }); + con.register("RagfairPriceService", RagfairPriceService, {lifecycle: Lifecycle.Singleton}); + con.register("RagfairCategoriesService", RagfairCategoriesService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("RagfairOfferService", RagfairOfferService, {lifecycle: Lifecycle.Singleton}); + con.register("RagfairLinkedItemService", RagfairLinkedItemService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("RagfairRequiredItemsService", RagfairRequiredItemsService, { + lifecycle: Lifecycle.Singleton, + }); - depContainer.register("NotificationService", NotificationService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("MatchLocationService", MatchLocationService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ModCompilerService", ModCompilerService); - depContainer.register("HashCacheService", HashCacheService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("LocaleService", LocaleService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ProfileFixerService", ProfileFixerService); - depContainer.register("RepairService", RepairService); - depContainer.register("BotLootCacheService", BotLootCacheService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("CustomItemService", CustomItemService); - depContainer.register("BotEquipmentFilterService", BotEquipmentFilterService); - depContainer.register("ProfileSnapshotService", ProfileSnapshotService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ItemFilterService", ItemFilterService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("BotGenerationCacheService", BotGenerationCacheService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("LocalisationService", LocalisationService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("CustomLocationWaveService", CustomLocationWaveService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("OpenZoneService", OpenZoneService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ItemBaseClassService", ItemBaseClassService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("BotEquipmentModPoolService", BotEquipmentModPoolService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("BotWeaponModLimitService", BotWeaponModLimitService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("SeasonalEventService", SeasonalEventService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("MatchBotDetailsCacheService", MatchBotDetailsCacheService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairTaxService", RagfairTaxService, { lifecycle: Lifecycle.Singleton }); - depContainer.register("TraderPurchasePersisterService", TraderPurchasePersisterService); - depContainer.register("PmcChatResponseService", PmcChatResponseService); - depContainer.register("GiftService", GiftService); - depContainer.register("MailSendService", MailSendService); + con.register("NotificationService", NotificationService, {lifecycle: Lifecycle.Singleton}); + con.register("MatchLocationService", MatchLocationService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("ModCompilerService", ModCompilerService); + con.register("HashCacheService", HashCacheService, {lifecycle: Lifecycle.Singleton}); + con.register("LocaleService", LocaleService, {lifecycle: Lifecycle.Singleton}); + con.register("ProfileFixerService", ProfileFixerService); + con.register("RepairService", RepairService); + con.register("BotLootCacheService", BotLootCacheService, {lifecycle: Lifecycle.Singleton}); + con.register("CustomItemService", CustomItemService); + con.register("BotEquipmentFilterService", BotEquipmentFilterService); + con.register("ProfileSnapshotService", ProfileSnapshotService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("ItemFilterService", ItemFilterService, {lifecycle: Lifecycle.Singleton}); + con.register("BotGenerationCacheService", BotGenerationCacheService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("LocalisationService", LocalisationService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("CustomLocationWaveService", CustomLocationWaveService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("OpenZoneService", OpenZoneService, {lifecycle: Lifecycle.Singleton}); + con.register("ItemBaseClassService", ItemBaseClassService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("BotEquipmentModPoolService", BotEquipmentModPoolService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("BotWeaponModLimitService", BotWeaponModLimitService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("SeasonalEventService", SeasonalEventService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("MatchBotDetailsCacheService", MatchBotDetailsCacheService, { + lifecycle: Lifecycle.Singleton, + }); + con.register("RagfairTaxService", RagfairTaxService, {lifecycle: Lifecycle.Singleton}); + con.register("TraderPurchasePersisterService", TraderPurchasePersisterService); + con.register("PmcChatResponseService", PmcChatResponseService); + con.register("GiftService", GiftService); + con.register("MailSendService", MailSendService); } - private static registerServers(depContainer: DependencyContainer): void + private static registerServers(con: DependencyContainer): void { // Servers - depContainer.register("DatabaseServer", DatabaseServer, { lifecycle: Lifecycle.Singleton }); - depContainer.register("HttpServer", HttpServer, { lifecycle: Lifecycle.Singleton }); - depContainer.register("WebSocketServer", WebSocketServer, { lifecycle: Lifecycle.Singleton }); - depContainer.register("RagfairServer", RagfairServer); - depContainer.register("SaveServer", SaveServer, { lifecycle: Lifecycle.Singleton }); - depContainer.register("ConfigServer", ConfigServer, { lifecycle: Lifecycle.Singleton }); + con.register("DatabaseServer", DatabaseServer, {lifecycle: Lifecycle.Singleton}); + con.register("HttpServer", HttpServer, {lifecycle: Lifecycle.Singleton}); + con.register("WebSocketServer", WebSocketServer, {lifecycle: Lifecycle.Singleton}); + con.register("RagfairServer", RagfairServer); + con.register("SaveServer", SaveServer, {lifecycle: Lifecycle.Singleton}); + con.register("ConfigServer", ConfigServer, {lifecycle: Lifecycle.Singleton}); } - private static registerControllers(depContainer: DependencyContainer): void + private static registerControllers(con: DependencyContainer): void { // Controllers - depContainer.register("BotController", { useClass: BotController }); - depContainer.register("ClientLogController", { useClass: ClientLogController }); - depContainer.register("CustomizationController", { useClass: CustomizationController }); - depContainer.register("DialogueController", { useClass: DialogueController }); - depContainer.register("GameController", { useClass: GameController }); - depContainer.register("HandbookController", { useClass: HandbookController }); - depContainer.register("HealthController", { useClass: HealthController }); - depContainer.register("HideoutController", { useClass: HideoutController }); - depContainer.register("InraidController", { useClass: InraidController }); - depContainer.register("InsuranceController", { useClass: InsuranceController }); - depContainer.register("InventoryController", { useClass: InventoryController }); - depContainer.register("LauncherController", { useClass: LauncherController }); - depContainer.register("LocationController", { useClass: LocationController }); - depContainer.register("MatchController", MatchController); - depContainer.register("NoteController", { useClass: NoteController }); - depContainer.register("NotifierController", { useClass: NotifierController }); - depContainer.register("PresetBuildController", { useClass: PresetBuildController }); - depContainer.register("PresetController", { useClass: PresetController }); - depContainer.register("ProfileController", { useClass: ProfileController }); - depContainer.register("QuestController", { useClass: QuestController }); - depContainer.register("RagfairController", { useClass: RagfairController }); - depContainer.register("RepairController", { useClass: RepairController }); - depContainer.register("RepeatableQuestController", { useClass: RepeatableQuestController }); - depContainer.register("TradeController", { useClass: TradeController }); - depContainer.register("TraderController", { useClass: TraderController }); - depContainer.register("WeatherController", { useClass: WeatherController }); - depContainer.register("WishlistController", WishlistController); + con.register("BotController", {useClass: BotController}); + con.register("ClientLogController", {useClass: ClientLogController}); + con.register("CustomizationController", {useClass: CustomizationController}); + con.register("DialogueController", {useClass: DialogueController}); + con.register("GameController", {useClass: GameController}); + con.register("HandbookController", {useClass: HandbookController}); + con.register("HealthController", {useClass: HealthController}); + con.register("HideoutController", {useClass: HideoutController}); + con.register("InraidController", {useClass: InraidController}); + con.register("InsuranceController", {useClass: InsuranceController}); + con.register("InventoryController", {useClass: InventoryController}); + con.register("LauncherController", {useClass: LauncherController}); + con.register("LocationController", {useClass: LocationController}); + con.register("MatchController", MatchController); + con.register("NoteController", {useClass: NoteController}); + con.register("NotifierController", {useClass: NotifierController}); + con.register("PresetBuildController", {useClass: PresetBuildController}); + con.register("PresetController", {useClass: PresetController}); + con.register("ProfileController", {useClass: ProfileController}); + con.register("QuestController", {useClass: QuestController}); + con.register("RagfairController", {useClass: RagfairController}); + con.register("RepairController", {useClass: RepairController}); + con.register("RepeatableQuestController", {useClass: RepeatableQuestController}); + con.register("TradeController", {useClass: TradeController}); + con.register("TraderController", {useClass: TraderController}); + con.register("WeatherController", {useClass: WeatherController}); + con.register("WishlistController", WishlistController); } } diff --git a/project/src/di/OnLoad.ts b/project/src/di/OnLoad.ts index 55631f4f..139f89b3 100644 --- a/project/src/di/OnLoad.ts +++ b/project/src/di/OnLoad.ts @@ -1,5 +1,5 @@ -export interface OnLoad +export interface OnLoad { onLoad(): Promise; getRoute(): string; -} \ No newline at end of file +} diff --git a/project/src/di/OnUpdate.ts b/project/src/di/OnUpdate.ts index 24dcdab9..57362acf 100644 --- a/project/src/di/OnUpdate.ts +++ b/project/src/di/OnUpdate.ts @@ -1,7 +1,5 @@ -export interface OnUpdate +export interface OnUpdate { - // eslint-disable-next-line @typescript-eslint/no-unused-vars onUpdate(timeSinceLastRun: number): Promise; - getRoute(): string; -} \ No newline at end of file +} diff --git a/project/src/di/Router.ts b/project/src/di/Router.ts index 397b5385..ae36542e 100644 --- a/project/src/di/Router.ts +++ b/project/src/di/Router.ts @@ -2,12 +2,11 @@ import { IPmcData } from "@spt-aki/models/eft/common/IPmcData"; import { IItemEventRouterResponse } from "@spt-aki/models/eft/itemEvent/IItemEventRouterResponse"; import { IAkiProfile } from "@spt-aki/models/eft/profile/IAkiProfile"; -export class Router +export class Router { - protected handledRoutes: HandledRoute[] = []; - public getTopLevelRoute(): string + public getTopLevelRoute(): string { return "aki"; } @@ -17,98 +16,96 @@ export class Router throw new Error("This method needs to be overrode by the router classes"); } - protected getInternalHandledRoutes(): HandledRoute[] + protected getInternalHandledRoutes(): HandledRoute[] { - if (this.handledRoutes.length === 0) + if (this.handledRoutes.length === 0) { this.handledRoutes = this.getHandledRoutes(); } return this.handledRoutes; } - public canHandle(url: string, partialMatch = false): boolean + public canHandle(url: string, partialMatch = false): boolean { if (partialMatch) { - return this.getInternalHandledRoutes().filter(r => r.dynamic).some(r => url.includes(r.route)); + return this.getInternalHandledRoutes().filter((r) => r.dynamic).some((r) => url.includes(r.route)); } - else + else { - return this.getInternalHandledRoutes().filter(r => !r.dynamic).some(r => r.route === url); + return this.getInternalHandledRoutes().filter((r) => !r.dynamic).some((r) => r.route === url); } } } -export class StaticRouter extends Router +export class StaticRouter extends Router { - constructor(private routes: RouteAction[]) + constructor(private routes: RouteAction[]) { super(); } - public handleStatic(url: string, info: any, sessionID: string, output: string): any + public handleStatic(url: string, info: any, sessionID: string, output: string): any { - return this.routes.find(route => route.url === url).action(url, info, sessionID, output); + return this.routes.find((route) => route.url === url).action(url, info, sessionID, output); } - public override getHandledRoutes(): HandledRoute[] - { - return this.routes.map(route => new HandledRoute(route.url, false)); + public override getHandledRoutes(): HandledRoute[] + { + return this.routes.map((route) => new HandledRoute(route.url, false)); } } -export class DynamicRouter extends Router +export class DynamicRouter extends Router { - constructor(private routes: RouteAction[]) + constructor(private routes: RouteAction[]) { super(); } - public handleDynamic(url: string, info: any, sessionID: string, output: string): any + public handleDynamic(url: string, info: any, sessionID: string, output: string): any { - return this.routes.find(r => url.includes(r.url)).action(url, info, sessionID, output); + return this.routes.find((r) => url.includes(r.url)).action(url, info, sessionID, output); } - public override getHandledRoutes(): HandledRoute[] - { - return this.routes.map(route => new HandledRoute(route.url, true)); + public override getHandledRoutes(): HandledRoute[] + { + return this.routes.map((route) => new HandledRoute(route.url, true)); } } // The name of this class should be ItemEventRouter, but that name is taken, // So instead I added the definition -export class ItemEventRouterDefinition extends Router +export class ItemEventRouterDefinition extends Router { - // eslint-disable-next-line @typescript-eslint/no-unused-vars public handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string): IItemEventRouterResponse { throw new Error("This method needs to be overrode by the router classes"); } } -export class SaveLoadRouter extends Router +export class SaveLoadRouter extends Router { - // eslint-disable-next-line @typescript-eslint/no-unused-vars public handleLoad(profile: IAkiProfile): IAkiProfile { throw new Error("This method needs to be overrode by the router classes"); } } -export class HandledRoute +export class HandledRoute { constructor( public route: string, - public dynamic: boolean + public dynamic: boolean, ) {} } -export class RouteAction +export class RouteAction { constructor( public url: string, - public action: (url: string, info: any, sessionID: string, output: string) => any - ) + public action: (url: string, info: any, sessionID: string, output: string) => any, + ) {} -} \ No newline at end of file +} diff --git a/project/src/di/Serializer.ts b/project/src/di/Serializer.ts index 38b2fe5c..33b79e72 100644 --- a/project/src/di/Serializer.ts +++ b/project/src/di/Serializer.ts @@ -1,16 +1,14 @@ import { IncomingMessage, ServerResponse } from "node:http"; -export class Serializer +export class Serializer { - // eslint-disable-next-line @typescript-eslint/no-unused-vars public serialize(sessionID: string, req: IncomingMessage, resp: ServerResponse, body: any): void { throw new Error("Should be extended and overrode"); } - // eslint-disable-next-line @typescript-eslint/no-unused-vars public canHandle(something: string): boolean { throw new Error("Should be extended and overrode"); } -} \ No newline at end of file +}