spt/server
spt/server
0
0
Fork 0
mirror of https://github.com/sp-tarkov/server.git synced 2025-02-13 09:50:43 -05:00
Code

Formatting of DI classes.

Browse Source
This commit is contained in:
Refringe 2023-11-10 16:58:55 -05:00
parent 87bb07cfd9
commit 3ef51e771b
No known key found for this signature in database
GPG Key ID: 64E03E5F892C6F9E
6 changed files with 419 additions and 404 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
project/Server.code-workspace
View File

@ -74,9 +74,11 @@
"Tarkov", "Tarkov",
"toggleable", "toggleable",
"tooshort", "tooshort",
"Ubgl",
"unrestartable", "unrestartable",
"usec", "usec",
"userbuilds", "userbuilds",
"weapongen",
"Wishlist" "Wishlist"
] ]
} }

742
project/src/di/Container.ts
View File

@ -69,17 +69,17 @@ import { BotWeaponGenerator } from "@spt-aki/generators/BotWeaponGenerator";
import { FenceBaseAssortGenerator } from "@spt-aki/generators/FenceBaseAssortGenerator"; import { FenceBaseAssortGenerator } from "@spt-aki/generators/FenceBaseAssortGenerator";
import { LocationGenerator } from "@spt-aki/generators/LocationGenerator"; import { LocationGenerator } from "@spt-aki/generators/LocationGenerator";
import { LootGenerator } from "@spt-aki/generators/LootGenerator"; import { LootGenerator } from "@spt-aki/generators/LootGenerator";
import { PMCLootGenerator } from "@spt-aki/generators/PMCLootGenerator";
import { PlayerScavGenerator } from "@spt-aki/generators/PlayerScavGenerator"; import { PlayerScavGenerator } from "@spt-aki/generators/PlayerScavGenerator";
import { PMCLootGenerator } from "@spt-aki/generators/PMCLootGenerator";
import { RagfairAssortGenerator } from "@spt-aki/generators/RagfairAssortGenerator"; import { RagfairAssortGenerator } from "@spt-aki/generators/RagfairAssortGenerator";
import { RagfairOfferGenerator } from "@spt-aki/generators/RagfairOfferGenerator"; import { RagfairOfferGenerator } from "@spt-aki/generators/RagfairOfferGenerator";
import { RepeatableQuestGenerator } from "@spt-aki/generators/RepeatableQuestGenerator"; import { RepeatableQuestGenerator } from "@spt-aki/generators/RepeatableQuestGenerator";
import { ScavCaseRewardGenerator } from "@spt-aki/generators/ScavCaseRewardGenerator"; import { ScavCaseRewardGenerator } from "@spt-aki/generators/ScavCaseRewardGenerator";
import { WeatherGenerator } from "@spt-aki/generators/WeatherGenerator";
import { BarrelInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/BarrelInventoryMagGen"; import { BarrelInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/BarrelInventoryMagGen";
import { ExternalInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/ExternalInventoryMagGen"; import { ExternalInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/ExternalInventoryMagGen";
import { InternalMagazineInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/InternalMagazineInventoryMagGen"; import { InternalMagazineInventoryMagGen } from "@spt-aki/generators/weapongen/implementations/InternalMagazineInventoryMagGen";
import { UbglExternalMagGen } from "@spt-aki/generators/weapongen/implementations/UbglExternalMagGen"; import { UbglExternalMagGen } from "@spt-aki/generators/weapongen/implementations/UbglExternalMagGen";
import { WeatherGenerator } from "@spt-aki/generators/WeatherGenerator";
import { AssortHelper } from "@spt-aki/helpers/AssortHelper"; import { AssortHelper } from "@spt-aki/helpers/AssortHelper";
import { BotDifficultyHelper } from "@spt-aki/helpers/BotDifficultyHelper"; import { BotDifficultyHelper } from "@spt-aki/helpers/BotDifficultyHelper";
import { BotGeneratorHelper } from "@spt-aki/helpers/BotGeneratorHelper"; 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 { PostDBModLoader } from "@spt-aki/loaders/PostDBModLoader";
import { PreAkiModLoader } from "@spt-aki/loaders/PreAkiModLoader"; import { PreAkiModLoader } from "@spt-aki/loaders/PreAkiModLoader";
import { IAsyncQueue } from "@spt-aki/models/spt/utils/IAsyncQueue"; 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 { BotDynamicRouter } from "@spt-aki/routers/dynamic/BotDynamicRouter";
import { BundleDynamicRouter } from "@spt-aki/routers/dynamic/BundleDynamicRouter"; import { BundleDynamicRouter } from "@spt-aki/routers/dynamic/BundleDynamicRouter";
import { CustomizationDynamicRouter } from "@spt-aki/routers/dynamic/CustomizationDynamicRouter"; 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 { LocationDynamicRouter } from "@spt-aki/routers/dynamic/LocationDynamicRouter";
import { NotifierDynamicRouter } from "@spt-aki/routers/dynamic/NotifierDynamicRouter"; import { NotifierDynamicRouter } from "@spt-aki/routers/dynamic/NotifierDynamicRouter";
import { TraderDynamicRouter } from "@spt-aki/routers/dynamic/TraderDynamicRouter"; 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 { CustomizationItemEventRouter } from "@spt-aki/routers/item_events/CustomizationItemEventRouter";
import { HealthItemEventRouter } from "@spt-aki/routers/item_events/HealthItemEventRouter"; import { HealthItemEventRouter } from "@spt-aki/routers/item_events/HealthItemEventRouter";
import { HideoutItemEventRouter } from "@spt-aki/routers/item_events/HideoutItemEventRouter"; 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 { RepairItemEventRouter } from "@spt-aki/routers/item_events/RepairItemEventRouter";
import { TradeItemEventRouter } from "@spt-aki/routers/item_events/TradeItemEventRouter"; import { TradeItemEventRouter } from "@spt-aki/routers/item_events/TradeItemEventRouter";
import { WishlistItemEventRouter } from "@spt-aki/routers/item_events/WishlistItemEventRouter"; 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 { HealthSaveLoadRouter } from "@spt-aki/routers/save_load/HealthSaveLoadRouter";
import { InraidSaveLoadRouter } from "@spt-aki/routers/save_load/InraidSaveLoadRouter"; import { InraidSaveLoadRouter } from "@spt-aki/routers/save_load/InraidSaveLoadRouter";
import { InsuranceSaveLoadRouter } from "@spt-aki/routers/save_load/InsuranceSaveLoadRouter"; 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 { WeatherStaticRouter } from "@spt-aki/routers/static/WeatherStaticRouter";
import { ConfigServer } from "@spt-aki/servers/ConfigServer"; import { ConfigServer } from "@spt-aki/servers/ConfigServer";
import { DatabaseServer } from "@spt-aki/servers/DatabaseServer"; import { DatabaseServer } from "@spt-aki/servers/DatabaseServer";
import { AkiHttpListener } from "@spt-aki/servers/http/AkiHttpListener";
import { HttpServer } from "@spt-aki/servers/HttpServer"; import { HttpServer } from "@spt-aki/servers/HttpServer";
import { RagfairServer } from "@spt-aki/servers/RagfairServer"; import { RagfairServer } from "@spt-aki/servers/RagfairServer";
import { SaveServer } from "@spt-aki/servers/SaveServer"; import { SaveServer } from "@spt-aki/servers/SaveServer";
import { WebSocketServer } from "@spt-aki/servers/WebSocketServer"; import { WebSocketServer } from "@spt-aki/servers/WebSocketServer";
import { AkiHttpListener } from "@spt-aki/servers/http/AkiHttpListener";
import { BotEquipmentFilterService } from "@spt-aki/services/BotEquipmentFilterService"; import { BotEquipmentFilterService } from "@spt-aki/services/BotEquipmentFilterService";
import { BotEquipmentModPoolService } from "@spt-aki/services/BotEquipmentModPoolService"; import { BotEquipmentModPoolService } from "@spt-aki/services/BotEquipmentModPoolService";
import { BotGenerationCacheService } from "@spt-aki/services/BotGenerationCacheService"; 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 { MailSendService } from "@spt-aki/services/MailSendService";
import { MatchBotDetailsCacheService } from "@spt-aki/services/MatchBotDetailsCacheService"; import { MatchBotDetailsCacheService } from "@spt-aki/services/MatchBotDetailsCacheService";
import { MatchLocationService } from "@spt-aki/services/MatchLocationService"; 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 { ModCompilerService } from "@spt-aki/services/ModCompilerService";
import { NotificationService } from "@spt-aki/services/NotificationService"; import { NotificationService } from "@spt-aki/services/NotificationService";
import { OpenZoneService } from "@spt-aki/services/OpenZoneService"; 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 { SeasonalEventService } from "@spt-aki/services/SeasonalEventService";
import { TraderAssortService } from "@spt-aki/services/TraderAssortService"; import { TraderAssortService } from "@spt-aki/services/TraderAssortService";
import { TraderPurchasePersisterService } from "@spt-aki/services/TraderPurchasePersisterService"; 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 { App } from "@spt-aki/utils/App";
import { AsyncQueue } from "@spt-aki/utils/AsyncQueue"; import { AsyncQueue } from "@spt-aki/utils/AsyncQueue";
import { DatabaseImporter } from "@spt-aki/utils/DatabaseImporter"; 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 { HttpResponseUtil } from "@spt-aki/utils/HttpResponseUtil";
import { ImporterUtil } from "@spt-aki/utils/ImporterUtil"; import { ImporterUtil } from "@spt-aki/utils/ImporterUtil";
import { JsonUtil } from "@spt-aki/utils/JsonUtil"; 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 { MathUtil } from "@spt-aki/utils/MathUtil";
import { ObjectId } from "@spt-aki/utils/ObjectId"; import { ObjectId } from "@spt-aki/utils/ObjectId";
import { RandomUtil } from "@spt-aki/utils/RandomUtil"; import { RandomUtil } from "@spt-aki/utils/RandomUtil";
import { TimeUtil } from "@spt-aki/utils/TimeUtil"; import { TimeUtil } from "@spt-aki/utils/TimeUtil";
import { VFS } from "@spt-aki/utils/VFS"; import { VFS } from "@spt-aki/utils/VFS";
import { Watermark, WatermarkLocale } from "@spt-aki/utils/Watermark"; 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 * Handle the registration of classes to be used by the Dependency Injection code
*/ */
export class Container export class Container
{ {
public static registerPostLoadTypes(container: DependencyContainer, childContainer: DependencyContainer): void
public static registerPostLoadTypes(container: DependencyContainer, childContainer: DependencyContainer):void
{ {
container.register<AkiHttpListener>("AkiHttpListener", AkiHttpListener, {lifecycle: Lifecycle.Singleton}); container.register<AkiHttpListener>("AkiHttpListener", AkiHttpListener, {lifecycle: Lifecycle.Singleton});
childContainer.registerType("HttpListener", "AkiHttpListener"); childContainer.registerType("HttpListener", "AkiHttpListener");
} }
public static registerTypes(depContainer: DependencyContainer): void public static registerTypes(con: DependencyContainer): void
{ {
depContainer.register("ApplicationContext", ApplicationContext, { lifecycle: Lifecycle.Singleton }); con.register("ApplicationContext", ApplicationContext, {lifecycle: Lifecycle.Singleton});
Container.registerUtils(depContainer); Container.registerUtils(con);
Container.registerRouters(con);
Container.registerRouters(depContainer); Container.registerGenerators(con);
Container.registerHelpers(con);
Container.registerGenerators(depContainer); Container.registerLoaders(con);
Container.registerCallbacks(con);
Container.registerHelpers(depContainer); Container.registerServers(con);
Container.registerServices(con);
Container.registerLoaders(depContainer); Container.registerControllers(con);
Container.registerCallbacks(depContainer);
Container.registerServers(depContainer);
Container.registerServices(depContainer);
Container.registerControllers(depContainer);
} }
public static registerListTypes(depContainer: DependencyContainer): void public static registerListTypes(con: DependencyContainer): void
{ {
depContainer.register("OnLoadModService", { useValue: new OnLoadModService(depContainer) }); con.register("OnLoadModService", {useValue: new OnLoadModService(con)});
depContainer.register("HttpListenerModService", { useValue: new HttpListenerModService(depContainer) }); con.register("HttpListenerModService", {useValue: new HttpListenerModService(con)});
depContainer.register("OnUpdateModService", { useValue: new OnUpdateModService(depContainer) }); con.register("OnUpdateModService", {useValue: new OnUpdateModService(con)});
depContainer.register("DynamicRouterModService", { useValue: new DynamicRouterModService(depContainer) }); con.register("DynamicRouterModService", {useValue: new DynamicRouterModService(con)});
depContainer.register("StaticRouterModService", { useValue: new StaticRouterModService(depContainer) }); con.register("StaticRouterModService", {useValue: new StaticRouterModService(con)});
depContainer.registerType("OnLoad", "DatabaseImporter"); con.registerType("OnLoad", "DatabaseImporter");
depContainer.registerType("OnLoad", "PostDBModLoader"); con.registerType("OnLoad", "PostDBModLoader");
depContainer.registerType("OnLoad", "HandbookCallbacks"); con.registerType("OnLoad", "HandbookCallbacks");
depContainer.registerType("OnLoad", "HttpCallbacks"); con.registerType("OnLoad", "HttpCallbacks");
depContainer.registerType("OnLoad", "PresetCallbacks"); con.registerType("OnLoad", "PresetCallbacks");
depContainer.registerType("OnLoad", "SaveCallbacks"); con.registerType("OnLoad", "SaveCallbacks");
depContainer.registerType("OnLoad", "TraderCallbacks"); // must occur prior to RagfairCallbacks con.registerType("OnLoad", "TraderCallbacks"); // Must occur prior to RagfairCallbacks
depContainer.registerType("OnLoad", "RagfairPriceService"); con.registerType("OnLoad", "RagfairPriceService");
depContainer.registerType("OnLoad", "RagfairCallbacks"); con.registerType("OnLoad", "RagfairCallbacks");
depContainer.registerType("OnLoad", "ModCallbacks"); con.registerType("OnLoad", "ModCallbacks");
depContainer.registerType("OnLoad", "GameCallbacks"); con.registerType("OnLoad", "GameCallbacks");
depContainer.registerType("OnUpdate", "DialogueCallbacks"); con.registerType("OnUpdate", "DialogueCallbacks");
depContainer.registerType("OnUpdate", "HideoutCallbacks"); con.registerType("OnUpdate", "HideoutCallbacks");
depContainer.registerType("OnUpdate", "TraderCallbacks"); con.registerType("OnUpdate", "TraderCallbacks");
depContainer.registerType("OnUpdate", "RagfairCallbacks"); con.registerType("OnUpdate", "RagfairCallbacks");
depContainer.registerType("OnUpdate", "InsuranceCallbacks"); con.registerType("OnUpdate", "InsuranceCallbacks");
depContainer.registerType("OnUpdate", "SaveCallbacks"); con.registerType("OnUpdate", "SaveCallbacks");
depContainer.registerType("StaticRoutes", "BotStaticRouter"); con.registerType("StaticRoutes", "BotStaticRouter");
depContainer.registerType("StaticRoutes", "ClientLogStaticRouter"); con.registerType("StaticRoutes", "ClientLogStaticRouter");
depContainer.registerType("StaticRoutes", "CustomizationStaticRouter"); con.registerType("StaticRoutes", "CustomizationStaticRouter");
depContainer.registerType("StaticRoutes", "DataStaticRouter"); con.registerType("StaticRoutes", "DataStaticRouter");
depContainer.registerType("StaticRoutes", "DialogStaticRouter"); con.registerType("StaticRoutes", "DialogStaticRouter");
depContainer.registerType("StaticRoutes", "GameStaticRouter"); con.registerType("StaticRoutes", "GameStaticRouter");
depContainer.registerType("StaticRoutes", "HealthStaticRouter"); con.registerType("StaticRoutes", "HealthStaticRouter");
depContainer.registerType("StaticRoutes", "InraidStaticRouter"); con.registerType("StaticRoutes", "InraidStaticRouter");
depContainer.registerType("StaticRoutes", "InsuranceStaticRouter"); con.registerType("StaticRoutes", "InsuranceStaticRouter");
depContainer.registerType("StaticRoutes", "ItemEventStaticRouter"); con.registerType("StaticRoutes", "ItemEventStaticRouter");
depContainer.registerType("StaticRoutes", "LauncherStaticRouter"); con.registerType("StaticRoutes", "LauncherStaticRouter");
depContainer.registerType("StaticRoutes", "LocationStaticRouter"); con.registerType("StaticRoutes", "LocationStaticRouter");
depContainer.registerType("StaticRoutes", "WeatherStaticRouter"); con.registerType("StaticRoutes", "WeatherStaticRouter");
depContainer.registerType("StaticRoutes", "MatchStaticRouter"); con.registerType("StaticRoutes", "MatchStaticRouter");
depContainer.registerType("StaticRoutes", "QuestStaticRouter"); con.registerType("StaticRoutes", "QuestStaticRouter");
depContainer.registerType("StaticRoutes", "RagfairStaticRouter"); con.registerType("StaticRoutes", "RagfairStaticRouter");
depContainer.registerType("StaticRoutes", "PresetStaticRouter"); con.registerType("StaticRoutes", "PresetStaticRouter");
depContainer.registerType("StaticRoutes", "BundleStaticRouter"); con.registerType("StaticRoutes", "BundleStaticRouter");
depContainer.registerType("StaticRoutes", "NotifierStaticRouter"); con.registerType("StaticRoutes", "NotifierStaticRouter");
depContainer.registerType("StaticRoutes", "ProfileStaticRouter"); con.registerType("StaticRoutes", "ProfileStaticRouter");
depContainer.registerType("StaticRoutes", "TraderStaticRouter"); con.registerType("StaticRoutes", "TraderStaticRouter");
depContainer.registerType("DynamicRoutes", "BotDynamicRouter"); con.registerType("DynamicRoutes", "BotDynamicRouter");
depContainer.registerType("DynamicRoutes", "BundleDynamicRouter"); con.registerType("DynamicRoutes", "BundleDynamicRouter");
depContainer.registerType("DynamicRoutes", "CustomizationDynamicRouter"); con.registerType("DynamicRoutes", "CustomizationDynamicRouter");
depContainer.registerType("DynamicRoutes", "DataDynamicRouter"); con.registerType("DynamicRoutes", "DataDynamicRouter");
depContainer.registerType("DynamicRoutes", "HttpDynamicRouter"); con.registerType("DynamicRoutes", "HttpDynamicRouter");
depContainer.registerType("DynamicRoutes", "InraidDynamicRouter"); con.registerType("DynamicRoutes", "InraidDynamicRouter");
depContainer.registerType("DynamicRoutes", "LocationDynamicRouter"); con.registerType("DynamicRoutes", "LocationDynamicRouter");
depContainer.registerType("DynamicRoutes", "NotifierDynamicRouter"); con.registerType("DynamicRoutes", "NotifierDynamicRouter");
depContainer.registerType("DynamicRoutes", "TraderDynamicRouter"); con.registerType("DynamicRoutes", "TraderDynamicRouter");
depContainer.registerType("IERouters", "CustomizationItemEventRouter"); con.registerType("IERouters", "CustomizationItemEventRouter");
depContainer.registerType("IERouters", "HealthItemEventRouter"); con.registerType("IERouters", "HealthItemEventRouter");
depContainer.registerType("IERouters", "HideoutItemEventRouter"); con.registerType("IERouters", "HideoutItemEventRouter");
depContainer.registerType("IERouters", "InsuranceItemEventRouter"); con.registerType("IERouters", "InsuranceItemEventRouter");
depContainer.registerType("IERouters", "InventoryItemEventRouter"); con.registerType("IERouters", "InventoryItemEventRouter");
depContainer.registerType("IERouters", "NoteItemEventRouter"); con.registerType("IERouters", "NoteItemEventRouter");
depContainer.registerType("IERouters", "PresetBuildItemEventRouter"); con.registerType("IERouters", "PresetBuildItemEventRouter");
depContainer.registerType("IERouters", "QuestItemEventRouter"); con.registerType("IERouters", "QuestItemEventRouter");
depContainer.registerType("IERouters", "RagfairItemEventRouter"); con.registerType("IERouters", "RagfairItemEventRouter");
depContainer.registerType("IERouters", "RepairItemEventRouter"); con.registerType("IERouters", "RepairItemEventRouter");
depContainer.registerType("IERouters", "TradeItemEventRouter"); con.registerType("IERouters", "TradeItemEventRouter");
depContainer.registerType("IERouters", "WishlistItemEventRouter"); con.registerType("IERouters", "WishlistItemEventRouter");
depContainer.registerType("Serializer", "ImageSerializer"); con.registerType("Serializer", "ImageSerializer");
depContainer.registerType("Serializer", "BundleSerializer"); con.registerType("Serializer", "BundleSerializer");
depContainer.registerType("Serializer", "NotifySerializer"); con.registerType("Serializer", "NotifySerializer");
depContainer.registerType("SaveLoadRouter", "HealthSaveLoadRouter"); con.registerType("SaveLoadRouter", "HealthSaveLoadRouter");
depContainer.registerType("SaveLoadRouter", "InraidSaveLoadRouter"); con.registerType("SaveLoadRouter", "InraidSaveLoadRouter");
depContainer.registerType("SaveLoadRouter", "InsuranceSaveLoadRouter"); con.registerType("SaveLoadRouter", "InsuranceSaveLoadRouter");
depContainer.registerType("SaveLoadRouter", "ProfileSaveLoadRouter"); con.registerType("SaveLoadRouter", "ProfileSaveLoadRouter");
} }
private static registerUtils(depContainer: DependencyContainer): void private static registerUtils(con: DependencyContainer): void
{ {
// Utils // Utils
depContainer.register<App>("App", App, { lifecycle: Lifecycle.Singleton }); con.register<App>("App", App, {lifecycle: Lifecycle.Singleton});
depContainer.register<DatabaseImporter>("DatabaseImporter", DatabaseImporter, { lifecycle: Lifecycle.Singleton }); con.register<DatabaseImporter>("DatabaseImporter", DatabaseImporter, {lifecycle: Lifecycle.Singleton});
depContainer.register<HashUtil>("HashUtil", HashUtil, { lifecycle: Lifecycle.Singleton }); con.register<HashUtil>("HashUtil", HashUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<ImporterUtil>("ImporterUtil", ImporterUtil, { lifecycle: Lifecycle.Singleton }); con.register<ImporterUtil>("ImporterUtil", ImporterUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<HttpResponseUtil>("HttpResponseUtil", HttpResponseUtil); con.register<HttpResponseUtil>("HttpResponseUtil", HttpResponseUtil);
depContainer.register<EncodingUtil>("EncodingUtil", EncodingUtil, { lifecycle: Lifecycle.Singleton }); con.register<EncodingUtil>("EncodingUtil", EncodingUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<JsonUtil>("JsonUtil", JsonUtil); con.register<JsonUtil>("JsonUtil", JsonUtil);
depContainer.register<WinstonMainLogger>("WinstonLogger", WinstonMainLogger, { lifecycle: Lifecycle.Singleton }); con.register<WinstonMainLogger>("WinstonLogger", WinstonMainLogger, {lifecycle: Lifecycle.Singleton});
depContainer.register<WinstonRequestLogger>("RequestsLogger", WinstonRequestLogger, { lifecycle: Lifecycle.Singleton }); con.register<WinstonRequestLogger>("RequestsLogger", WinstonRequestLogger, {lifecycle: Lifecycle.Singleton});
depContainer.register<MathUtil>("MathUtil", MathUtil, { lifecycle: Lifecycle.Singleton }); con.register<MathUtil>("MathUtil", MathUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<ObjectId>("ObjectId", ObjectId); con.register<ObjectId>("ObjectId", ObjectId);
depContainer.register<RandomUtil>("RandomUtil", RandomUtil, { lifecycle: Lifecycle.Singleton }); con.register<RandomUtil>("RandomUtil", RandomUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<TimeUtil>("TimeUtil", TimeUtil, { lifecycle: Lifecycle.Singleton }); con.register<TimeUtil>("TimeUtil", TimeUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<VFS>("VFS", VFS, { lifecycle: Lifecycle.Singleton }); con.register<VFS>("VFS", VFS, {lifecycle: Lifecycle.Singleton});
depContainer.register<WatermarkLocale>("WatermarkLocale", WatermarkLocale, { lifecycle: Lifecycle.Singleton }); con.register<WatermarkLocale>("WatermarkLocale", WatermarkLocale, {lifecycle: Lifecycle.Singleton});
depContainer.register<Watermark>("Watermark", Watermark, { lifecycle: Lifecycle.Singleton }); con.register<Watermark>("Watermark", Watermark, {lifecycle: Lifecycle.Singleton});
depContainer.register<IAsyncQueue>("AsyncQueue", AsyncQueue, { lifecycle: Lifecycle.Singleton }); con.register<IAsyncQueue>("AsyncQueue", AsyncQueue, {lifecycle: Lifecycle.Singleton});
depContainer.register<HttpFileUtil>("HttpFileUtil", HttpFileUtil, { lifecycle: Lifecycle.Singleton }); con.register<HttpFileUtil>("HttpFileUtil", HttpFileUtil, {lifecycle: Lifecycle.Singleton});
depContainer.register<ModLoadOrder>("ModLoadOrder", ModLoadOrder, { lifecycle: Lifecycle.Singleton }); con.register<ModLoadOrder>("ModLoadOrder", ModLoadOrder, {lifecycle: Lifecycle.Singleton});
depContainer.register<ModTypeCheck>("ModTypeCheck", ModTypeCheck, { lifecycle: Lifecycle.Singleton }); con.register<ModTypeCheck>("ModTypeCheck", ModTypeCheck, {lifecycle: Lifecycle.Singleton});
} }
private static registerRouters(depContainer: DependencyContainer): void private static registerRouters(con: DependencyContainer): void
{ {
// Routers // Routers
depContainer.register<HttpRouter>("HttpRouter", HttpRouter, { lifecycle: Lifecycle.Singleton }); con.register<HttpRouter>("HttpRouter", HttpRouter, {lifecycle: Lifecycle.Singleton});
depContainer.register<ImageRouter>("ImageRouter", ImageRouter); con.register<ImageRouter>("ImageRouter", ImageRouter);
depContainer.register<EventOutputHolder>("EventOutputHolder", EventOutputHolder, { lifecycle: Lifecycle.Singleton }); con.register<EventOutputHolder>("EventOutputHolder", EventOutputHolder, {lifecycle: Lifecycle.Singleton});
depContainer.register<ItemEventRouter>("ItemEventRouter", ItemEventRouter); con.register<ItemEventRouter>("ItemEventRouter", ItemEventRouter);
// Dynamic routes // Dynamic routes
depContainer.register<BotDynamicRouter>("BotDynamicRouter", { useClass: BotDynamicRouter }); con.register<BotDynamicRouter>("BotDynamicRouter", {useClass: BotDynamicRouter});
depContainer.register<BundleDynamicRouter>("BundleDynamicRouter", { useClass: BundleDynamicRouter }); con.register<BundleDynamicRouter>("BundleDynamicRouter", {useClass: BundleDynamicRouter});
depContainer.register<CustomizationDynamicRouter>("CustomizationDynamicRouter", { useClass: CustomizationDynamicRouter }); con.register<CustomizationDynamicRouter>("CustomizationDynamicRouter", {useClass: CustomizationDynamicRouter});
depContainer.register<DataDynamicRouter>("DataDynamicRouter", { useClass: DataDynamicRouter }); con.register<DataDynamicRouter>("DataDynamicRouter", {useClass: DataDynamicRouter});
depContainer.register<HttpDynamicRouter>("HttpDynamicRouter", { useClass: HttpDynamicRouter }); con.register<HttpDynamicRouter>("HttpDynamicRouter", {useClass: HttpDynamicRouter});
depContainer.register<InraidDynamicRouter>("InraidDynamicRouter", { useClass: InraidDynamicRouter }); con.register<InraidDynamicRouter>("InraidDynamicRouter", {useClass: InraidDynamicRouter});
depContainer.register<LocationDynamicRouter>("LocationDynamicRouter", { useClass: LocationDynamicRouter }); con.register<LocationDynamicRouter>("LocationDynamicRouter", {useClass: LocationDynamicRouter});
depContainer.register<NotifierDynamicRouter>("NotifierDynamicRouter", { useClass: NotifierDynamicRouter }); con.register<NotifierDynamicRouter>("NotifierDynamicRouter", {useClass: NotifierDynamicRouter});
depContainer.register<TraderDynamicRouter>("TraderDynamicRouter", { useClass: TraderDynamicRouter }); con.register<TraderDynamicRouter>("TraderDynamicRouter", {useClass: TraderDynamicRouter});
// Item event routes // Item event routes
depContainer.register<CustomizationItemEventRouter>("CustomizationItemEventRouter", { useClass: CustomizationItemEventRouter }); con.register<CustomizationItemEventRouter>("CustomizationItemEventRouter", {
depContainer.register<HealthItemEventRouter>("HealthItemEventRouter", { useClass: HealthItemEventRouter }); useClass: CustomizationItemEventRouter,
depContainer.register<HideoutItemEventRouter>("HideoutItemEventRouter", { useClass: HideoutItemEventRouter }); });
depContainer.register<InsuranceItemEventRouter>("InsuranceItemEventRouter", { useClass: InsuranceItemEventRouter }); con.register<HealthItemEventRouter>("HealthItemEventRouter", {useClass: HealthItemEventRouter});
depContainer.register<InventoryItemEventRouter>("InventoryItemEventRouter", { useClass: InventoryItemEventRouter }); con.register<HideoutItemEventRouter>("HideoutItemEventRouter", {useClass: HideoutItemEventRouter});
depContainer.register<NoteItemEventRouter>("NoteItemEventRouter", { useClass: NoteItemEventRouter }); con.register<InsuranceItemEventRouter>("InsuranceItemEventRouter", {useClass: InsuranceItemEventRouter});
depContainer.register<PresetBuildItemEventRouter>("PresetBuildItemEventRouter", { useClass: PresetBuildItemEventRouter }); con.register<InventoryItemEventRouter>("InventoryItemEventRouter", {useClass: InventoryItemEventRouter});
depContainer.register<QuestItemEventRouter>("QuestItemEventRouter", { useClass: QuestItemEventRouter }); con.register<NoteItemEventRouter>("NoteItemEventRouter", {useClass: NoteItemEventRouter});
depContainer.register<RagfairItemEventRouter>("RagfairItemEventRouter", { useClass: RagfairItemEventRouter }); con.register<PresetBuildItemEventRouter>("PresetBuildItemEventRouter", {useClass: PresetBuildItemEventRouter});
depContainer.register<RepairItemEventRouter>("RepairItemEventRouter", { useClass: RepairItemEventRouter }); con.register<QuestItemEventRouter>("QuestItemEventRouter", {useClass: QuestItemEventRouter});
depContainer.register<TradeItemEventRouter>("TradeItemEventRouter", { useClass: TradeItemEventRouter }); con.register<RagfairItemEventRouter>("RagfairItemEventRouter", {useClass: RagfairItemEventRouter});
depContainer.register<WishlistItemEventRouter>("WishlistItemEventRouter", { useClass: WishlistItemEventRouter }); con.register<RepairItemEventRouter>("RepairItemEventRouter", {useClass: RepairItemEventRouter});
con.register<TradeItemEventRouter>("TradeItemEventRouter", {useClass: TradeItemEventRouter});
con.register<WishlistItemEventRouter>("WishlistItemEventRouter", {useClass: WishlistItemEventRouter});
// save load routes // save load routes
depContainer.register<HealthSaveLoadRouter>("HealthSaveLoadRouter", { useClass: HealthSaveLoadRouter }); con.register<HealthSaveLoadRouter>("HealthSaveLoadRouter", {useClass: HealthSaveLoadRouter});
depContainer.register<InraidSaveLoadRouter>("InraidSaveLoadRouter", { useClass: InraidSaveLoadRouter }); con.register<InraidSaveLoadRouter>("InraidSaveLoadRouter", {useClass: InraidSaveLoadRouter});
depContainer.register<InsuranceSaveLoadRouter>("InsuranceSaveLoadRouter", { useClass: InsuranceSaveLoadRouter }); con.register<InsuranceSaveLoadRouter>("InsuranceSaveLoadRouter", {useClass: InsuranceSaveLoadRouter});
depContainer.register<ProfileSaveLoadRouter>("ProfileSaveLoadRouter", { useClass: ProfileSaveLoadRouter }); con.register<ProfileSaveLoadRouter>("ProfileSaveLoadRouter", {useClass: ProfileSaveLoadRouter});
// Route serializers // Route serializers
depContainer.register<BundleSerializer>("BundleSerializer", { useClass: BundleSerializer }); con.register<BundleSerializer>("BundleSerializer", {useClass: BundleSerializer});
depContainer.register<ImageSerializer>("ImageSerializer", { useClass: ImageSerializer }); con.register<ImageSerializer>("ImageSerializer", {useClass: ImageSerializer});
depContainer.register<NotifySerializer>("NotifySerializer", { useClass: NotifySerializer }); con.register<NotifySerializer>("NotifySerializer", {useClass: NotifySerializer});
// Static routes // Static routes
depContainer.register<BotStaticRouter>("BotStaticRouter", { useClass: BotStaticRouter }); con.register<BotStaticRouter>("BotStaticRouter", {useClass: BotStaticRouter});
depContainer.register<BundleStaticRouter>("BundleStaticRouter", { useClass: BundleStaticRouter }); con.register<BundleStaticRouter>("BundleStaticRouter", {useClass: BundleStaticRouter});
depContainer.register<ClientLogStaticRouter>("ClientLogStaticRouter", { useClass: ClientLogStaticRouter }); con.register<ClientLogStaticRouter>("ClientLogStaticRouter", {useClass: ClientLogStaticRouter});
depContainer.register<CustomizationStaticRouter>("CustomizationStaticRouter", { useClass: CustomizationStaticRouter }); con.register<CustomizationStaticRouter>("CustomizationStaticRouter", {useClass: CustomizationStaticRouter});
depContainer.register<DataStaticRouter>("DataStaticRouter", { useClass: DataStaticRouter }); con.register<DataStaticRouter>("DataStaticRouter", {useClass: DataStaticRouter});
depContainer.register<DialogStaticRouter>("DialogStaticRouter", { useClass: DialogStaticRouter }); con.register<DialogStaticRouter>("DialogStaticRouter", {useClass: DialogStaticRouter});
depContainer.register<GameStaticRouter>("GameStaticRouter", { useClass: GameStaticRouter }); con.register<GameStaticRouter>("GameStaticRouter", {useClass: GameStaticRouter});
depContainer.register<HealthStaticRouter>("HealthStaticRouter", { useClass: HealthStaticRouter }); con.register<HealthStaticRouter>("HealthStaticRouter", {useClass: HealthStaticRouter});
depContainer.register<InraidStaticRouter>("InraidStaticRouter", { useClass: InraidStaticRouter }); con.register<InraidStaticRouter>("InraidStaticRouter", {useClass: InraidStaticRouter});
depContainer.register<InsuranceStaticRouter>("InsuranceStaticRouter", { useClass: InsuranceStaticRouter }); con.register<InsuranceStaticRouter>("InsuranceStaticRouter", {useClass: InsuranceStaticRouter});
depContainer.register<ItemEventStaticRouter>("ItemEventStaticRouter", { useClass: ItemEventStaticRouter }); con.register<ItemEventStaticRouter>("ItemEventStaticRouter", {useClass: ItemEventStaticRouter});
depContainer.register<LauncherStaticRouter>("LauncherStaticRouter", { useClass: LauncherStaticRouter }); con.register<LauncherStaticRouter>("LauncherStaticRouter", {useClass: LauncherStaticRouter});
depContainer.register<LocationStaticRouter>("LocationStaticRouter", { useClass: LocationStaticRouter }); con.register<LocationStaticRouter>("LocationStaticRouter", {useClass: LocationStaticRouter});
depContainer.register<MatchStaticRouter>("MatchStaticRouter", { useClass: MatchStaticRouter }); con.register<MatchStaticRouter>("MatchStaticRouter", {useClass: MatchStaticRouter});
depContainer.register<NotifierStaticRouter>("NotifierStaticRouter", { useClass: NotifierStaticRouter }); con.register<NotifierStaticRouter>("NotifierStaticRouter", {useClass: NotifierStaticRouter});
depContainer.register<PresetStaticRouter>("PresetStaticRouter", { useClass: PresetStaticRouter }); con.register<PresetStaticRouter>("PresetStaticRouter", {useClass: PresetStaticRouter});
depContainer.register<ProfileStaticRouter>("ProfileStaticRouter", { useClass: ProfileStaticRouter }); con.register<ProfileStaticRouter>("ProfileStaticRouter", {useClass: ProfileStaticRouter});
depContainer.register<QuestStaticRouter>("QuestStaticRouter", { useClass: QuestStaticRouter }); con.register<QuestStaticRouter>("QuestStaticRouter", {useClass: QuestStaticRouter});
depContainer.register<RagfairStaticRouter>("RagfairStaticRouter", { useClass: RagfairStaticRouter }); con.register<RagfairStaticRouter>("RagfairStaticRouter", {useClass: RagfairStaticRouter});
depContainer.register<TraderStaticRouter>("TraderStaticRouter", { useClass: TraderStaticRouter }); con.register<TraderStaticRouter>("TraderStaticRouter", {useClass: TraderStaticRouter});
depContainer.register<WeatherStaticRouter>("WeatherStaticRouter", { useClass: WeatherStaticRouter }); con.register<WeatherStaticRouter>("WeatherStaticRouter", {useClass: WeatherStaticRouter});
} }
private static registerGenerators(depContainer: DependencyContainer): void private static registerGenerators(con: DependencyContainer): void
{ {
// Generators // Generators
depContainer.register<BotGenerator>("BotGenerator", BotGenerator); con.register<BotGenerator>("BotGenerator", BotGenerator);
depContainer.register<BotWeaponGenerator>("BotWeaponGenerator", BotWeaponGenerator); con.register<BotWeaponGenerator>("BotWeaponGenerator", BotWeaponGenerator);
depContainer.register<BotLootGenerator>("BotLootGenerator", BotLootGenerator); con.register<BotLootGenerator>("BotLootGenerator", BotLootGenerator);
depContainer.register<BotInventoryGenerator>("BotInventoryGenerator", BotInventoryGenerator); con.register<BotInventoryGenerator>("BotInventoryGenerator", BotInventoryGenerator);
depContainer.register<LocationGenerator>("LocationGenerator", { useClass: LocationGenerator }); con.register<LocationGenerator>("LocationGenerator", {useClass: LocationGenerator});
depContainer.register<PMCLootGenerator>("PMCLootGenerator", PMCLootGenerator, { lifecycle: Lifecycle.Singleton }); con.register<PMCLootGenerator>("PMCLootGenerator", PMCLootGenerator, {lifecycle: Lifecycle.Singleton});
depContainer.register<ScavCaseRewardGenerator>("ScavCaseRewardGenerator", ScavCaseRewardGenerator, { lifecycle: Lifecycle.Singleton }); con.register<ScavCaseRewardGenerator>("ScavCaseRewardGenerator", ScavCaseRewardGenerator, {
depContainer.register<RagfairAssortGenerator>("RagfairAssortGenerator", { useClass: RagfairAssortGenerator }); lifecycle: Lifecycle.Singleton,
depContainer.register<RagfairOfferGenerator>("RagfairOfferGenerator", { useClass: RagfairOfferGenerator }); });
depContainer.register<WeatherGenerator>("WeatherGenerator", { useClass: WeatherGenerator }); con.register<RagfairAssortGenerator>("RagfairAssortGenerator", {useClass: RagfairAssortGenerator});
depContainer.register<PlayerScavGenerator>("PlayerScavGenerator", { useClass: PlayerScavGenerator }); con.register<RagfairOfferGenerator>("RagfairOfferGenerator", {useClass: RagfairOfferGenerator});
depContainer.register<LootGenerator>("LootGenerator", { useClass: LootGenerator }); con.register<WeatherGenerator>("WeatherGenerator", {useClass: WeatherGenerator});
depContainer.register<FenceBaseAssortGenerator>("FenceBaseAssortGenerator", { useClass: FenceBaseAssortGenerator }); con.register<PlayerScavGenerator>("PlayerScavGenerator", {useClass: PlayerScavGenerator});
depContainer.register<BotLevelGenerator>("BotLevelGenerator", { useClass: BotLevelGenerator }); con.register<LootGenerator>("LootGenerator", {useClass: LootGenerator});
depContainer.register<BotEquipmentModGenerator>("BotEquipmentModGenerator", { useClass: BotEquipmentModGenerator }); con.register<FenceBaseAssortGenerator>("FenceBaseAssortGenerator", {useClass: FenceBaseAssortGenerator});
depContainer.register<RepeatableQuestGenerator>("RepeatableQuestGenerator", { useClass: RepeatableQuestGenerator }); con.register<BotLevelGenerator>("BotLevelGenerator", {useClass: BotLevelGenerator});
con.register<BotEquipmentModGenerator>("BotEquipmentModGenerator", {useClass: BotEquipmentModGenerator});
con.register<RepeatableQuestGenerator>("RepeatableQuestGenerator", {useClass: RepeatableQuestGenerator});
depContainer.register<BarrelInventoryMagGen>("BarrelInventoryMagGen", { useClass: BarrelInventoryMagGen });
depContainer.register<ExternalInventoryMagGen>("ExternalInventoryMagGen", { useClass: ExternalInventoryMagGen });
depContainer.register<InternalMagazineInventoryMagGen>("InternalMagazineInventoryMagGen", { useClass: InternalMagazineInventoryMagGen });
depContainer.register<UbglExternalMagGen>("UbglExternalMagGen", { useClass: UbglExternalMagGen });
depContainer.registerType("InventoryMagGen", "BarrelInventoryMagGen");
depContainer.registerType("InventoryMagGen", "ExternalInventoryMagGen");
depContainer.registerType("InventoryMagGen", "InternalMagazineInventoryMagGen");
depContainer.registerType("InventoryMagGen", "UbglExternalMagGen");
con.register<BarrelInventoryMagGen>("BarrelInventoryMagGen", {useClass: BarrelInventoryMagGen});
con.register<ExternalInventoryMagGen>("ExternalInventoryMagGen", {useClass: ExternalInventoryMagGen});
con.register<InternalMagazineInventoryMagGen>("InternalMagazineInventoryMagGen", {
useClass: InternalMagazineInventoryMagGen,
});
con.register<UbglExternalMagGen>("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 // Helpers
depContainer.register<AssortHelper>("AssortHelper", { useClass: AssortHelper }); con.register<AssortHelper>("AssortHelper", {useClass: AssortHelper});
depContainer.register<BotHelper>("BotHelper", { useClass: BotHelper }); con.register<BotHelper>("BotHelper", {useClass: BotHelper});
depContainer.register<BotGeneratorHelper>("BotGeneratorHelper", { useClass: BotGeneratorHelper }); con.register<BotGeneratorHelper>("BotGeneratorHelper", {useClass: BotGeneratorHelper});
depContainer.register<ContainerHelper>("ContainerHelper", ContainerHelper); con.register<ContainerHelper>("ContainerHelper", ContainerHelper);
depContainer.register<DialogueHelper>("DialogueHelper", { useClass: DialogueHelper }); con.register<DialogueHelper>("DialogueHelper", {useClass: DialogueHelper});
depContainer.register<DurabilityLimitsHelper>("DurabilityLimitsHelper", { useClass: DurabilityLimitsHelper }); con.register<DurabilityLimitsHelper>("DurabilityLimitsHelper", {useClass: DurabilityLimitsHelper});
depContainer.register<GameEventHelper>("GameEventHelper", GameEventHelper); con.register<GameEventHelper>("GameEventHelper", GameEventHelper);
depContainer.register<HandbookHelper>("HandbookHelper", HandbookHelper, { lifecycle: Lifecycle.Singleton }); con.register<HandbookHelper>("HandbookHelper", HandbookHelper, {lifecycle: Lifecycle.Singleton});
depContainer.register<HealthHelper>("HealthHelper", { useClass: HealthHelper }); con.register<HealthHelper>("HealthHelper", {useClass: HealthHelper});
depContainer.register<HideoutHelper>("HideoutHelper", { useClass: HideoutHelper }); con.register<HideoutHelper>("HideoutHelper", {useClass: HideoutHelper});
depContainer.register<InRaidHelper>("InRaidHelper", { useClass: InRaidHelper }); con.register<InRaidHelper>("InRaidHelper", {useClass: InRaidHelper});
depContainer.register<InventoryHelper>("InventoryHelper", { useClass: InventoryHelper }); con.register<InventoryHelper>("InventoryHelper", {useClass: InventoryHelper});
depContainer.register<PaymentHelper>("PaymentHelper", PaymentHelper); con.register<PaymentHelper>("PaymentHelper", PaymentHelper);
depContainer.register<ItemHelper>("ItemHelper", { useClass: ItemHelper }); con.register<ItemHelper>("ItemHelper", {useClass: ItemHelper});
depContainer.register<PresetHelper>("PresetHelper", PresetHelper, { lifecycle: Lifecycle.Singleton }); con.register<PresetHelper>("PresetHelper", PresetHelper, {lifecycle: Lifecycle.Singleton});
depContainer.register<ProfileHelper>("ProfileHelper", { useClass: ProfileHelper }); con.register<ProfileHelper>("ProfileHelper", {useClass: ProfileHelper});
depContainer.register<QuestHelper>("QuestHelper", { useClass: QuestHelper }); con.register<QuestHelper>("QuestHelper", {useClass: QuestHelper});
depContainer.register<QuestConditionHelper>("QuestConditionHelper", QuestConditionHelper); con.register<QuestConditionHelper>("QuestConditionHelper", QuestConditionHelper);
depContainer.register<RagfairHelper>("RagfairHelper", { useClass: RagfairHelper }); con.register<RagfairHelper>("RagfairHelper", {useClass: RagfairHelper});
depContainer.register<RagfairSortHelper>("RagfairSortHelper", { useClass: RagfairSortHelper }); con.register<RagfairSortHelper>("RagfairSortHelper", {useClass: RagfairSortHelper});
depContainer.register<RagfairSellHelper>("RagfairSellHelper", { useClass: RagfairSellHelper }); con.register<RagfairSellHelper>("RagfairSellHelper", {useClass: RagfairSellHelper});
depContainer.register<RagfairOfferHelper>("RagfairOfferHelper", { useClass: RagfairOfferHelper }); con.register<RagfairOfferHelper>("RagfairOfferHelper", {useClass: RagfairOfferHelper});
depContainer.register<RagfairServerHelper>("RagfairServerHelper", { useClass: RagfairServerHelper }); con.register<RagfairServerHelper>("RagfairServerHelper", {useClass: RagfairServerHelper});
depContainer.register<RepairHelper>("RepairHelper", { useClass: RepairHelper }); con.register<RepairHelper>("RepairHelper", {useClass: RepairHelper});
depContainer.register<TraderHelper>("TraderHelper", TraderHelper); con.register<TraderHelper>("TraderHelper", TraderHelper);
depContainer.register<TraderAssortHelper>("TraderAssortHelper", TraderAssortHelper, { lifecycle: Lifecycle.Singleton }); con.register<TraderAssortHelper>("TraderAssortHelper", TraderAssortHelper, {lifecycle: Lifecycle.Singleton});
depContainer.register<TradeHelper>("TradeHelper", { useClass: TradeHelper }); con.register<TradeHelper>("TradeHelper", {useClass: TradeHelper});
depContainer.register<NotifierHelper>("NotifierHelper", { useClass: NotifierHelper }); con.register<NotifierHelper>("NotifierHelper", {useClass: NotifierHelper});
depContainer.register<UtilityHelper>("UtilityHelper", UtilityHelper); con.register<UtilityHelper>("UtilityHelper", UtilityHelper);
depContainer.register<WeightedRandomHelper>("WeightedRandomHelper", { useClass: WeightedRandomHelper }); con.register<WeightedRandomHelper>("WeightedRandomHelper", {useClass: WeightedRandomHelper});
depContainer.register<HttpServerHelper>("HttpServerHelper", { useClass: HttpServerHelper }); con.register<HttpServerHelper>("HttpServerHelper", {useClass: HttpServerHelper});
depContainer.register<NotificationSendHelper>("NotificationSendHelper", { useClass: NotificationSendHelper }); con.register<NotificationSendHelper>("NotificationSendHelper", {useClass: NotificationSendHelper});
depContainer.register<SecureContainerHelper>("SecureContainerHelper", { useClass: SecureContainerHelper }); con.register<SecureContainerHelper>("SecureContainerHelper", {useClass: SecureContainerHelper});
depContainer.register<ProbabilityHelper>("ProbabilityHelper", { useClass: ProbabilityHelper }); con.register<ProbabilityHelper>("ProbabilityHelper", {useClass: ProbabilityHelper});
depContainer.register<BotWeaponGeneratorHelper>("BotWeaponGeneratorHelper", { useClass: BotWeaponGeneratorHelper }); con.register<BotWeaponGeneratorHelper>("BotWeaponGeneratorHelper", {useClass: BotWeaponGeneratorHelper});
depContainer.register<BotDifficultyHelper>("BotDifficultyHelper", { useClass: BotDifficultyHelper }); con.register<BotDifficultyHelper>("BotDifficultyHelper", {useClass: BotDifficultyHelper});
depContainer.register<RepeatableQuestHelper>("RepeatableQuestHelper", { useClass: RepeatableQuestHelper }); con.register<RepeatableQuestHelper>("RepeatableQuestHelper", {useClass: RepeatableQuestHelper});
} }
private static registerLoaders(depContainer: DependencyContainer): void private static registerLoaders(con: DependencyContainer): void
{ {
// Loaders // Loaders
depContainer.register<BundleLoader>("BundleLoader", BundleLoader, { lifecycle: Lifecycle.Singleton }); con.register<BundleLoader>("BundleLoader", BundleLoader, {lifecycle: Lifecycle.Singleton});
depContainer.register<PreAkiModLoader>("PreAkiModLoader", PreAkiModLoader, { lifecycle: Lifecycle.Singleton }); con.register<PreAkiModLoader>("PreAkiModLoader", PreAkiModLoader, {lifecycle: Lifecycle.Singleton});
depContainer.register<PostAkiModLoader>("PostAkiModLoader", PostAkiModLoader, { lifecycle: Lifecycle.Singleton }); con.register<PostAkiModLoader>("PostAkiModLoader", PostAkiModLoader, {lifecycle: Lifecycle.Singleton});
} }
private static registerCallbacks(depContainer: DependencyContainer): void private static registerCallbacks(con: DependencyContainer): void
{ {
// Callbacks // Callbacks
depContainer.register<BotCallbacks>("BotCallbacks", { useClass: BotCallbacks }); con.register<BotCallbacks>("BotCallbacks", {useClass: BotCallbacks});
depContainer.register<BundleCallbacks>("BundleCallbacks", { useClass: BundleCallbacks }); con.register<BundleCallbacks>("BundleCallbacks", {useClass: BundleCallbacks});
depContainer.register<ClientLogCallbacks>("ClientLogCallbacks", { useClass: ClientLogCallbacks }); con.register<ClientLogCallbacks>("ClientLogCallbacks", {useClass: ClientLogCallbacks});
depContainer.register<CustomizationCallbacks>("CustomizationCallbacks", { useClass: CustomizationCallbacks }); con.register<CustomizationCallbacks>("CustomizationCallbacks", {useClass: CustomizationCallbacks});
depContainer.register<DataCallbacks>("DataCallbacks", { useClass: DataCallbacks }); con.register<DataCallbacks>("DataCallbacks", {useClass: DataCallbacks});
depContainer.register<DialogueCallbacks>("DialogueCallbacks", { useClass: DialogueCallbacks }); con.register<DialogueCallbacks>("DialogueCallbacks", {useClass: DialogueCallbacks});
depContainer.register<GameCallbacks>("GameCallbacks", { useClass: GameCallbacks }); con.register<GameCallbacks>("GameCallbacks", {useClass: GameCallbacks});
depContainer.register<HandbookCallbacks>("HandbookCallbacks", { useClass: HandbookCallbacks }); con.register<HandbookCallbacks>("HandbookCallbacks", {useClass: HandbookCallbacks});
depContainer.register<HealthCallbacks>("HealthCallbacks", { useClass: HealthCallbacks }); con.register<HealthCallbacks>("HealthCallbacks", {useClass: HealthCallbacks});
depContainer.register<HideoutCallbacks>("HideoutCallbacks", { useClass: HideoutCallbacks }); con.register<HideoutCallbacks>("HideoutCallbacks", {useClass: HideoutCallbacks});
depContainer.register<HttpCallbacks>("HttpCallbacks", { useClass: HttpCallbacks }); con.register<HttpCallbacks>("HttpCallbacks", {useClass: HttpCallbacks});
depContainer.register<InraidCallbacks>("InraidCallbacks", { useClass: InraidCallbacks }); con.register<InraidCallbacks>("InraidCallbacks", {useClass: InraidCallbacks});
depContainer.register<InsuranceCallbacks>("InsuranceCallbacks", { useClass: InsuranceCallbacks }); con.register<InsuranceCallbacks>("InsuranceCallbacks", {useClass: InsuranceCallbacks});
depContainer.register<InventoryCallbacks>("InventoryCallbacks", { useClass: InventoryCallbacks }); con.register<InventoryCallbacks>("InventoryCallbacks", {useClass: InventoryCallbacks});
depContainer.register<ItemEventCallbacks>("ItemEventCallbacks", { useClass: ItemEventCallbacks }); con.register<ItemEventCallbacks>("ItemEventCallbacks", {useClass: ItemEventCallbacks});
depContainer.register<LauncherCallbacks>("LauncherCallbacks", { useClass: LauncherCallbacks }); con.register<LauncherCallbacks>("LauncherCallbacks", {useClass: LauncherCallbacks});
depContainer.register<LocationCallbacks>("LocationCallbacks", { useClass: LocationCallbacks }); con.register<LocationCallbacks>("LocationCallbacks", {useClass: LocationCallbacks});
depContainer.register<MatchCallbacks>("MatchCallbacks", { useClass: MatchCallbacks }); con.register<MatchCallbacks>("MatchCallbacks", {useClass: MatchCallbacks});
depContainer.register<ModCallbacks>("ModCallbacks", { useClass: ModCallbacks }); con.register<ModCallbacks>("ModCallbacks", {useClass: ModCallbacks});
depContainer.register<PostDBModLoader>("PostDBModLoader", { useClass: PostDBModLoader }); con.register<PostDBModLoader>("PostDBModLoader", {useClass: PostDBModLoader});
depContainer.register<NoteCallbacks>("NoteCallbacks", { useClass: NoteCallbacks }); con.register<NoteCallbacks>("NoteCallbacks", {useClass: NoteCallbacks});
depContainer.register<NotifierCallbacks>("NotifierCallbacks", { useClass: NotifierCallbacks }); con.register<NotifierCallbacks>("NotifierCallbacks", {useClass: NotifierCallbacks});
depContainer.register<PresetBuildCallbacks>("PresetBuildCallbacks", { useClass: PresetBuildCallbacks }); con.register<PresetBuildCallbacks>("PresetBuildCallbacks", {useClass: PresetBuildCallbacks});
depContainer.register<PresetCallbacks>("PresetCallbacks", { useClass: PresetCallbacks }); con.register<PresetCallbacks>("PresetCallbacks", {useClass: PresetCallbacks});
depContainer.register<ProfileCallbacks>("ProfileCallbacks", { useClass: ProfileCallbacks }); con.register<ProfileCallbacks>("ProfileCallbacks", {useClass: ProfileCallbacks});
depContainer.register<QuestCallbacks>("QuestCallbacks", { useClass: QuestCallbacks }); con.register<QuestCallbacks>("QuestCallbacks", {useClass: QuestCallbacks});
depContainer.register<RagfairCallbacks>("RagfairCallbacks", { useClass: RagfairCallbacks }); con.register<RagfairCallbacks>("RagfairCallbacks", {useClass: RagfairCallbacks});
depContainer.register<RepairCallbacks>("RepairCallbacks", { useClass: RepairCallbacks }); con.register<RepairCallbacks>("RepairCallbacks", {useClass: RepairCallbacks});
depContainer.register<SaveCallbacks>("SaveCallbacks", { useClass: SaveCallbacks }); con.register<SaveCallbacks>("SaveCallbacks", {useClass: SaveCallbacks});
depContainer.register<TradeCallbacks>("TradeCallbacks", { useClass: TradeCallbacks }); con.register<TradeCallbacks>("TradeCallbacks", {useClass: TradeCallbacks});
depContainer.register<TraderCallbacks>("TraderCallbacks", { useClass: TraderCallbacks }); con.register<TraderCallbacks>("TraderCallbacks", {useClass: TraderCallbacks});
depContainer.register<WeatherCallbacks>("WeatherCallbacks", { useClass: WeatherCallbacks }); con.register<WeatherCallbacks>("WeatherCallbacks", {useClass: WeatherCallbacks});
depContainer.register<WishlistCallbacks>("WishlistCallbacks", { useClass: WishlistCallbacks }); con.register<WishlistCallbacks>("WishlistCallbacks", {useClass: WishlistCallbacks});
} }
private static registerServices(depContainer: DependencyContainer): void private static registerServices(con: DependencyContainer): void
{ {
// Services // Services
depContainer.register<ImageRouteService>("ImageRouteService", ImageRouteService, { lifecycle: Lifecycle.Singleton }); con.register<ImageRouteService>("ImageRouteService", ImageRouteService, {lifecycle: Lifecycle.Singleton});
depContainer.register<FenceService>("FenceService", FenceService, { lifecycle: Lifecycle.Singleton }); con.register<FenceService>("FenceService", FenceService, {lifecycle: Lifecycle.Singleton});
depContainer.register<PlayerService>("PlayerService", { useClass: PlayerService }); con.register<PlayerService>("PlayerService", {useClass: PlayerService});
depContainer.register<PaymentService>("PaymentService", { useClass: PaymentService }); con.register<PaymentService>("PaymentService", {useClass: PaymentService});
depContainer.register<InsuranceService>("InsuranceService", InsuranceService, { lifecycle: Lifecycle.Singleton }); con.register<InsuranceService>("InsuranceService", InsuranceService, {lifecycle: Lifecycle.Singleton});
depContainer.register<TraderAssortService>("TraderAssortService", TraderAssortService, { lifecycle: Lifecycle.Singleton }); con.register<TraderAssortService>("TraderAssortService", TraderAssortService, {lifecycle: Lifecycle.Singleton});
depContainer.register<RagfairPriceService>("RagfairPriceService", RagfairPriceService, { lifecycle: Lifecycle.Singleton }); con.register<RagfairPriceService>("RagfairPriceService", RagfairPriceService, {lifecycle: Lifecycle.Singleton});
depContainer.register<RagfairCategoriesService>("RagfairCategoriesService", RagfairCategoriesService, { lifecycle: Lifecycle.Singleton }); con.register<RagfairCategoriesService>("RagfairCategoriesService", RagfairCategoriesService, {
depContainer.register<RagfairOfferService>("RagfairOfferService", RagfairOfferService, { lifecycle: Lifecycle.Singleton }); lifecycle: Lifecycle.Singleton,
depContainer.register<RagfairLinkedItemService>("RagfairLinkedItemService", RagfairLinkedItemService, { lifecycle: Lifecycle.Singleton }); });
depContainer.register<RagfairRequiredItemsService>("RagfairRequiredItemsService", RagfairRequiredItemsService, { lifecycle: Lifecycle.Singleton }); con.register<RagfairOfferService>("RagfairOfferService", RagfairOfferService, {lifecycle: Lifecycle.Singleton});
con.register<RagfairLinkedItemService>("RagfairLinkedItemService", RagfairLinkedItemService, {
lifecycle: Lifecycle.Singleton,
});
con.register<RagfairRequiredItemsService>("RagfairRequiredItemsService", RagfairRequiredItemsService, {
lifecycle: Lifecycle.Singleton,
});
depContainer.register<NotificationService>("NotificationService", NotificationService, { lifecycle: Lifecycle.Singleton }); con.register<NotificationService>("NotificationService", NotificationService, {lifecycle: Lifecycle.Singleton});
depContainer.register<MatchLocationService>("MatchLocationService", MatchLocationService, { lifecycle: Lifecycle.Singleton }); con.register<MatchLocationService>("MatchLocationService", MatchLocationService, {
depContainer.register<ModCompilerService>("ModCompilerService", ModCompilerService); lifecycle: Lifecycle.Singleton,
depContainer.register<HashCacheService>("HashCacheService", HashCacheService, { lifecycle: Lifecycle.Singleton }); });
depContainer.register<LocaleService>("LocaleService", LocaleService, { lifecycle: Lifecycle.Singleton }); con.register<ModCompilerService>("ModCompilerService", ModCompilerService);
depContainer.register<ProfileFixerService>("ProfileFixerService", ProfileFixerService); con.register<HashCacheService>("HashCacheService", HashCacheService, {lifecycle: Lifecycle.Singleton});
depContainer.register<RepairService>("RepairService", RepairService); con.register<LocaleService>("LocaleService", LocaleService, {lifecycle: Lifecycle.Singleton});
depContainer.register<BotLootCacheService>("BotLootCacheService", BotLootCacheService, { lifecycle: Lifecycle.Singleton }); con.register<ProfileFixerService>("ProfileFixerService", ProfileFixerService);
depContainer.register<CustomItemService>("CustomItemService", CustomItemService); con.register<RepairService>("RepairService", RepairService);
depContainer.register<BotEquipmentFilterService>("BotEquipmentFilterService", BotEquipmentFilterService); con.register<BotLootCacheService>("BotLootCacheService", BotLootCacheService, {lifecycle: Lifecycle.Singleton});
depContainer.register<ProfileSnapshotService>("ProfileSnapshotService", ProfileSnapshotService, { lifecycle: Lifecycle.Singleton }); con.register<CustomItemService>("CustomItemService", CustomItemService);
depContainer.register<ItemFilterService>("ItemFilterService", ItemFilterService, { lifecycle: Lifecycle.Singleton }); con.register<BotEquipmentFilterService>("BotEquipmentFilterService", BotEquipmentFilterService);
depContainer.register<BotGenerationCacheService>("BotGenerationCacheService", BotGenerationCacheService, { lifecycle: Lifecycle.Singleton }); con.register<ProfileSnapshotService>("ProfileSnapshotService", ProfileSnapshotService, {
depContainer.register<LocalisationService>("LocalisationService", LocalisationService, { lifecycle: Lifecycle.Singleton }); lifecycle: Lifecycle.Singleton,
depContainer.register<CustomLocationWaveService>("CustomLocationWaveService", CustomLocationWaveService, { lifecycle: Lifecycle.Singleton }); });
depContainer.register<OpenZoneService>("OpenZoneService", OpenZoneService, { lifecycle: Lifecycle.Singleton }); con.register<ItemFilterService>("ItemFilterService", ItemFilterService, {lifecycle: Lifecycle.Singleton});
depContainer.register<ItemBaseClassService>("ItemBaseClassService", ItemBaseClassService, { lifecycle: Lifecycle.Singleton }); con.register<BotGenerationCacheService>("BotGenerationCacheService", BotGenerationCacheService, {
depContainer.register<BotEquipmentModPoolService>("BotEquipmentModPoolService", BotEquipmentModPoolService, { lifecycle: Lifecycle.Singleton }); lifecycle: Lifecycle.Singleton,
depContainer.register<BotWeaponModLimitService>("BotWeaponModLimitService", BotWeaponModLimitService, { lifecycle: Lifecycle.Singleton }); });
depContainer.register<SeasonalEventService>("SeasonalEventService", SeasonalEventService, { lifecycle: Lifecycle.Singleton }); con.register<LocalisationService>("LocalisationService", LocalisationService, {
depContainer.register<MatchBotDetailsCacheService>("MatchBotDetailsCacheService", MatchBotDetailsCacheService, { lifecycle: Lifecycle.Singleton }); lifecycle: Lifecycle.Singleton,
depContainer.register<RagfairTaxService>("RagfairTaxService", RagfairTaxService, { lifecycle: Lifecycle.Singleton }); });
depContainer.register<TraderPurchasePersisterService>("TraderPurchasePersisterService", TraderPurchasePersisterService); con.register<CustomLocationWaveService>("CustomLocationWaveService", CustomLocationWaveService, {
depContainer.register<PmcChatResponseService>("PmcChatResponseService", PmcChatResponseService); lifecycle: Lifecycle.Singleton,
depContainer.register<GiftService>("GiftService", GiftService); });
depContainer.register<MailSendService>("MailSendService", MailSendService); con.register<OpenZoneService>("OpenZoneService", OpenZoneService, {lifecycle: Lifecycle.Singleton});
con.register<ItemBaseClassService>("ItemBaseClassService", ItemBaseClassService, {
lifecycle: Lifecycle.Singleton,
});
con.register<BotEquipmentModPoolService>("BotEquipmentModPoolService", BotEquipmentModPoolService, {
lifecycle: Lifecycle.Singleton,
});
con.register<BotWeaponModLimitService>("BotWeaponModLimitService", BotWeaponModLimitService, {
lifecycle: Lifecycle.Singleton,
});
con.register<SeasonalEventService>("SeasonalEventService", SeasonalEventService, {
lifecycle: Lifecycle.Singleton,
});
con.register<MatchBotDetailsCacheService>("MatchBotDetailsCacheService", MatchBotDetailsCacheService, {
lifecycle: Lifecycle.Singleton,
});
con.register<RagfairTaxService>("RagfairTaxService", RagfairTaxService, {lifecycle: Lifecycle.Singleton});
con.register<TraderPurchasePersisterService>("TraderPurchasePersisterService", TraderPurchasePersisterService);
con.register<PmcChatResponseService>("PmcChatResponseService", PmcChatResponseService);
con.register<GiftService>("GiftService", GiftService);
con.register<MailSendService>("MailSendService", MailSendService);
} }
private static registerServers(depContainer: DependencyContainer): void private static registerServers(con: DependencyContainer): void
{ {
// Servers // Servers
depContainer.register<DatabaseServer>("DatabaseServer", DatabaseServer, { lifecycle: Lifecycle.Singleton }); con.register<DatabaseServer>("DatabaseServer", DatabaseServer, {lifecycle: Lifecycle.Singleton});
depContainer.register<HttpServer>("HttpServer", HttpServer, { lifecycle: Lifecycle.Singleton }); con.register<HttpServer>("HttpServer", HttpServer, {lifecycle: Lifecycle.Singleton});
depContainer.register<WebSocketServer>("WebSocketServer", WebSocketServer, { lifecycle: Lifecycle.Singleton }); con.register<WebSocketServer>("WebSocketServer", WebSocketServer, {lifecycle: Lifecycle.Singleton});
depContainer.register<RagfairServer>("RagfairServer", RagfairServer); con.register<RagfairServer>("RagfairServer", RagfairServer);
depContainer.register<SaveServer>("SaveServer", SaveServer, { lifecycle: Lifecycle.Singleton }); con.register<SaveServer>("SaveServer", SaveServer, {lifecycle: Lifecycle.Singleton});
depContainer.register<ConfigServer>("ConfigServer", ConfigServer, { lifecycle: Lifecycle.Singleton }); con.register<ConfigServer>("ConfigServer", ConfigServer, {lifecycle: Lifecycle.Singleton});
} }
private static registerControllers(depContainer: DependencyContainer): void private static registerControllers(con: DependencyContainer): void
{ {
// Controllers // Controllers
depContainer.register<BotController>("BotController", { useClass: BotController }); con.register<BotController>("BotController", {useClass: BotController});
depContainer.register<ClientLogController>("ClientLogController", { useClass: ClientLogController }); con.register<ClientLogController>("ClientLogController", {useClass: ClientLogController});
depContainer.register<CustomizationController>("CustomizationController", { useClass: CustomizationController }); con.register<CustomizationController>("CustomizationController", {useClass: CustomizationController});
depContainer.register<DialogueController>("DialogueController", { useClass: DialogueController }); con.register<DialogueController>("DialogueController", {useClass: DialogueController});
depContainer.register<GameController>("GameController", { useClass: GameController }); con.register<GameController>("GameController", {useClass: GameController});
depContainer.register<HandbookController>("HandbookController", { useClass: HandbookController }); con.register<HandbookController>("HandbookController", {useClass: HandbookController});
depContainer.register<HealthController>("HealthController", { useClass: HealthController }); con.register<HealthController>("HealthController", {useClass: HealthController});
depContainer.register<HideoutController>("HideoutController", { useClass: HideoutController }); con.register<HideoutController>("HideoutController", {useClass: HideoutController});
depContainer.register<InraidController>("InraidController", { useClass: InraidController }); con.register<InraidController>("InraidController", {useClass: InraidController});
depContainer.register<InsuranceController>("InsuranceController", { useClass: InsuranceController }); con.register<InsuranceController>("InsuranceController", {useClass: InsuranceController});
depContainer.register<InventoryController>("InventoryController", { useClass: InventoryController }); con.register<InventoryController>("InventoryController", {useClass: InventoryController});
depContainer.register<LauncherController>("LauncherController", { useClass: LauncherController }); con.register<LauncherController>("LauncherController", {useClass: LauncherController});
depContainer.register<LocationController>("LocationController", { useClass: LocationController }); con.register<LocationController>("LocationController", {useClass: LocationController});
depContainer.register<MatchController>("MatchController", MatchController); con.register<MatchController>("MatchController", MatchController);
depContainer.register<NoteController>("NoteController", { useClass: NoteController }); con.register<NoteController>("NoteController", {useClass: NoteController});
depContainer.register<NotifierController>("NotifierController", { useClass: NotifierController }); con.register<NotifierController>("NotifierController", {useClass: NotifierController});
depContainer.register<PresetBuildController>("PresetBuildController", { useClass: PresetBuildController }); con.register<PresetBuildController>("PresetBuildController", {useClass: PresetBuildController});
depContainer.register<PresetController>("PresetController", { useClass: PresetController }); con.register<PresetController>("PresetController", {useClass: PresetController});
depContainer.register<ProfileController>("ProfileController", { useClass: ProfileController }); con.register<ProfileController>("ProfileController", {useClass: ProfileController});
depContainer.register<QuestController>("QuestController", { useClass: QuestController }); con.register<QuestController>("QuestController", {useClass: QuestController});
depContainer.register<RagfairController>("RagfairController", { useClass: RagfairController }); con.register<RagfairController>("RagfairController", {useClass: RagfairController});
depContainer.register<RepairController>("RepairController", { useClass: RepairController }); con.register<RepairController>("RepairController", {useClass: RepairController});
depContainer.register<RepeatableQuestController>("RepeatableQuestController", { useClass: RepeatableQuestController }); con.register<RepeatableQuestController>("RepeatableQuestController", {useClass: RepeatableQuestController});
depContainer.register<TradeController>("TradeController", { useClass: TradeController }); con.register<TradeController>("TradeController", {useClass: TradeController});
depContainer.register<TraderController>("TraderController", { useClass: TraderController }); con.register<TraderController>("TraderController", {useClass: TraderController});
depContainer.register<WeatherController>("WeatherController", { useClass: WeatherController }); con.register<WeatherController>("WeatherController", {useClass: WeatherController});
depContainer.register<WishlistController>("WishlistController", WishlistController); con.register<WishlistController>("WishlistController", WishlistController);
} }
} }

2
project/src/di/OnUpdate.ts
View File

@ -1,7 +1,5 @@
export interface OnUpdate export interface OnUpdate
{ {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
onUpdate(timeSinceLastRun: number): Promise<boolean>; onUpdate(timeSinceLastRun: number): Promise<boolean>;
getRoute(): string; getRoute(): string;
} }

19
project/src/di/Router.ts
View File

@ -4,7 +4,6 @@ import { IAkiProfile } from "@spt-aki/models/eft/profile/IAkiProfile";
export class Router export class Router
{ {
protected handledRoutes: HandledRoute[] = []; protected handledRoutes: HandledRoute[] = [];
public getTopLevelRoute(): string public getTopLevelRoute(): string
@ -30,11 +29,11 @@ export class Router
{ {
if (partialMatch) 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);
} }
} }
} }
@ -48,12 +47,12 @@ export class StaticRouter extends Router
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[] public override getHandledRoutes(): HandledRoute[]
{ {
return this.routes.map(route => new HandledRoute(route.url, false)); return this.routes.map((route) => new HandledRoute(route.url, false));
} }
} }
@ -66,12 +65,12 @@ export class DynamicRouter extends Router
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[] public override getHandledRoutes(): HandledRoute[]
{ {
return this.routes.map(route => new HandledRoute(route.url, true)); return this.routes.map((route) => new HandledRoute(route.url, true));
} }
} }
@ -79,7 +78,6 @@ export class DynamicRouter extends Router
// So instead I added the definition // 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 public handleItemEvent(url: string, pmcData: IPmcData, body: any, sessionID: string): IItemEventRouterResponse
{ {
throw new Error("This method needs to be overrode by the router classes"); throw new Error("This method needs to be overrode by the router classes");
@ -88,7 +86,6 @@ export class ItemEventRouterDefinition extends Router
export class SaveLoadRouter extends Router export class SaveLoadRouter extends Router
{ {
// eslint-disable-next-line @typescript-eslint/no-unused-vars
public handleLoad(profile: IAkiProfile): IAkiProfile public handleLoad(profile: IAkiProfile): IAkiProfile
{ {
throw new Error("This method needs to be overrode by the router classes"); throw new Error("This method needs to be overrode by the router classes");
@ -99,7 +96,7 @@ export class HandledRoute
{ {
constructor( constructor(
public route: string, public route: string,
public dynamic: boolean public dynamic: boolean,
) )
{} {}
} }
@ -108,7 +105,7 @@ export class RouteAction
{ {
constructor( constructor(
public url: string, 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,
) )
{} {}
} }

2
project/src/di/Serializer.ts
View File

@ -2,13 +2,11 @@ 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 public serialize(sessionID: string, req: IncomingMessage, resp: ServerResponse, body: any): void
{ {
throw new Error("Should be extended and overrode"); throw new Error("Should be extended and overrode");
} }
// eslint-disable-next-line @typescript-eslint/no-unused-vars
public canHandle(something: string): boolean public canHandle(something: string): boolean
{ {
throw new Error("Should be extended and overrode"); throw new Error("Should be extended and overrode");