Always Spawn Containers 1.0.2

//import { DependencyContainer } from "tsyringe";
import { DependencyContainer } from "@spt/models/external/tsyringe";
import { ILogger } from "@spt/models/spt/utils/ILogger";
import { IPostDBLoadMod } from "@spt/models/external/IPostDBLoadMod";
import { DatabaseServer } from "@spt/servers/DatabaseServer";
import { ConfigServer } from "@spt/servers/ConfigServer";
import { IDatabaseTables } from "@spt/models/spt/server/IDatabaseTables";

//jsonc thing - 1/2
import path from "node:path";
import { jsonc } from "jsonc";
import { FileSystemSync } from "@spt/utils/FileSystemSync";

class alwaysSpawnContainers implements IPostDBLoadMod {
    public postDBLoad(container: DependencyContainer): void {
        const databaseServer = container.resolve<DatabaseServer>("DatabaseServer");
        const configServer = container.resolve<ConfigServer>("ConfigServer");
        const logger = container.resolve<ILogger>("WinstonLogger");

        //jsonc thing - 2/2
        const fileSystem = container.resolve<FileSystemSync>("FileSystemSync");
        const modConfigJsonC = jsonc.parse(fileSystem.read(path.resolve(__dirname, "../config/config.jsonc")));

        const tables: IDatabaseTables = databaseServer.getTables();
        const locationsData = tables.locations;

        let changeCount_containers = 0;
        let changeCount_containersAS = 0;
        let changeCount_looseLootItems = 0;
        let changeCount_looseLootItemsAS = 0;

        if (modConfigJsonC.enableMod) {

            for (const key in locationsData) {
                const location = locationsData[key];

                //containers
                if (modConfigJsonC.alwaysSpawn_containers) {
                    if (location?.staticContainers?.staticContainers) {
                        location.staticContainers.staticContainers.forEach(container => {
                            if (container.probability !== undefined && container.probability !== 1) {
                                let v1a = container.template.Id;
                                let v1b = container.probability;
                                container.probability = 1;
                                changeCount_containers++
                                /*
                                if (modConfigJsonC.logging) {
                                    logger.info(`${v1a} set from ${v1b} to ${container.probability}`);
                                }
                                */
                            }

                        });
                    }
                }

                //items
                if (modConfigJsonC.alwaysSpawn_looseLootItems) {
                    if (location?.looseLoot?.spawnpoints) {
                        location.looseLoot.spawnpoints.forEach(spawnPoint => {
                            if (spawnPoint.probability !== undefined && spawnPoint.probability !== 1) {
                                spawnPoint.probability = 1;
                                changeCount_looseLootItems++
                            }

                        });
                    }
                }

            }

            //logging
            if (modConfigJsonC.logging) {
                logger.info(`Always Spawn Containers logging:`);
                logger.info(`-Changes count for Static Containers: \t\t\t ${changeCount_containers}`);
                logger.info(`-Changes count for Static Containers IsAlwaysSpawn: \t ${changeCount_containersAS}`);
                logger.info(`-Changes count for Loose Loot Items: \t\t\t ${changeCount_looseLootItems}`);
                logger.info(`-Changes count for Loose Loot Items IsAlwaysSpawn: \t ${changeCount_looseLootItemsAS}`);
            }

        }
    }
}

export const mod = new alwaysSpawnContainers();