s2cfgtojson 1.0.0

package/Struct.mts

@@ -0,0 +1,222 @@
+export type Value = Omit<Struct, "toTs"> | string | boolean | number;
+type DefaultEntries = { _isArray?: boolean; _useAsterisk?: boolean };
+export type Entries = Record<string | number, Value> & DefaultEntries;
+
+/**
+ * This file is part of the Stalker 2 Modding Tools project.
+ * This is a base class for all structs.
+ */
+export abstract class Struct<T extends Entries = {}> {
+  isRoot?: boolean;
+  refurl?: string;
+  refkey?: string | number;
+  bskipref?: boolean;
+  abstract _id: string;
+  entries: T;
+
+  static TAB = "   ";
+  static pad(text: string): string {
+    return `${Struct.TAB}${text.replace(/\n+/g, `\n${Struct.TAB}`)}`;
+  }
+  static WILDCARD = "_wildcard";
+  static isNumber(ref: string): boolean {
+    return Number.isInteger(parseInt(ref)) || typeof ref === "number";
+  }
+  static isArrayKey(key: string) {
+    return key.includes("[") && key.includes("]");
+  }
+  static renderKeyName(ref: string, useAsterisk?: boolean): string {
+    if (`${ref}`.startsWith("_")) {
+      return Struct.renderKeyName(ref.slice(1), useAsterisk); // Special case for indexed structs
+    }
+    if (`${ref}`.includes("*") || useAsterisk) {
+      return "[*]"; // Special case for wildcard structs
+    }
+    if (`${ref}`.includes("_dupe_")) {
+      return Struct.renderKeyName(ref.slice(0, ref.indexOf("_dupe_")));
+    }
+    if (Struct.isNumber(ref)) {
+      return `[${parseInt(ref)}]`;
+    }
+    return ref;
+  }
+
+  static renderStructName(name: string): string {
+    if (name === Struct.WILDCARD) {
+      return "[*]"; // Special case for wildcard structs
+    }
+    if (`${name}`.startsWith("_")) {
+      return Struct.renderStructName(name.slice(1)); // Special case for indexed structs
+    }
+    if (Struct.isNumber(name)) {
+      return `[${parseInt(name)}]`;
+    }
+    return name;
+  }
+
+  static extractKeyFromBrackets(key: string) {
+    if (/\[(.+)]/.test(key)) {
+      return key.match(/\[(.+)]/)[1];
+    }
+    return "";
+  }
+
+  static parseStructName(name: string): string {
+    if (Struct.extractKeyFromBrackets(name) === "*") {
+      return Struct.WILDCARD; // Special case for wildcard structs
+    }
+    if (Struct.isNumber(Struct.extractKeyFromBrackets(name))) {
+      return `_${name.match(/\[(\d+)]/)[1]}`; // Special case for indexed structs
+    }
+    return name;
+  }
+
+  static createDynamicClass = (name: string): new () => Struct =>
+    new Function("parent", `return class ${name} extends parent {}`)(Struct);
+
+  toString(): string {
+    let text: string;
+    text = this.isRoot ? `${Struct.renderStructName(this._id)} : ` : "";
+    text += "struct.begin";
+    const refs = ["refurl", "refkey", "bskipref"]
+      .map((k) => [k, this[k]])
+      .filter(([_, v]) => v !== "" && v !== undefined && v !== false)
+      .map(([k, v]) => {
+        if (v === true) return k;
+        return `${k}=${Struct.renderKeyName(v)}`;
+      })
+      .join(";");
+    if (refs) {
+      text += ` {${refs}}`;
+    }
+    text += "\n";
+    // Add all keys
+    text += Object.entries(this.entries || {})
+      .filter(([key]) => key !== "_useAsterisk" && key !== "_isArray")
+      .map(([key, value]) => {
+        const keyOrIndex = Struct.renderKeyName(key, this.entries._useAsterisk);
+        const equalsOrColon = value instanceof Struct ? ":" : "=";
+        const spaceOrNoSpace = value === "" ? "" : " ";
+        return Struct.pad(
+          `${keyOrIndex} ${equalsOrColon}${spaceOrNoSpace}${value}`,
+        );
+      })
+      .join("\n");
+    text += "\nstruct.end";
+    return text;
+  }
+
+  toTs(): string {
+    return JSON.stringify(this, null, 2);
+  }
+
+  static addEntry(
+    parent: Struct<DefaultEntries>,
+    key: string,
+    value: Value,
+    index: number,
+  ) {
+    parent.entries ||= {};
+
+    const getKey = () => {
+      let normKey: string | number = key;
+      if (Struct.isArrayKey(key)) {
+        parent.entries._isArray = true;
+        normKey = Struct.extractKeyFromBrackets(key);
+
+        if (normKey === "*") {
+          parent.entries._useAsterisk = true;
+          return Object.keys(parent.entries).length;
+        }
+
+        if (parent.entries[normKey] !== undefined) {
+          return `${normKey}_dupe_${index}`;
+        }
+        return normKey;
+      }
+      if (parent.entries[normKey] !== undefined) {
+        return `${normKey}_dupe_${index}`;
+      }
+      return normKey;
+    };
+
+    parent.entries[getKey()] = value;
+  }
+
+  static fromString<IntendedType extends Partial<Struct> = Struct>(
+    text: string,
+  ): IntendedType[] {
+    const lines = text.trim().split("\n");
+
+    const parseHead = (line: string): Struct => {
+      const match = line.match(
+        /^(.*)\s*:\s*struct\.begin\s*({\s*((refurl|refkey|bskipref)\s*(=.+)?)\s*})?/,
+      );
+      if (!match) {
+        throw new Error(`Invalid struct head: ${line}`);
+      }
+      let name = Struct.parseStructName(match[1].trim());
+
+      const dummy = new (Struct.createDynamicClass(name))();
+      if (name === match[1].trim()) {
+        dummy._id = name;
+      }
+      if (match[3]) {
+        const refs = match[3]
+          .split(";")
+          .map((ref) => ref.trim())
+          .filter(Boolean)
+          .reduce(
+            (acc, ref) => {
+              const [key, value] = ref.split("=");
+              acc[key.trim()] = value ? value.trim() : true;
+              return acc;
+            },
+            {} as { refurl?: string; refkey?: string; bskipref?: boolean },
+          );
+        if (refs.refurl) dummy.refurl = refs.refurl;
+        if (refs.refkey) dummy.refkey = refs.refkey;
+        if (refs.bskipref) dummy.bskipref = refs.bskipref;
+      }
+      return dummy as Struct;
+    };
+
+    const parseKeyValue = (line: string, parent: Struct): void => {
+      const match = line.match(/^(.*?)(\s*:\s*|\s*=\s*)(.*)$/);
+      if (!match) {
+        throw new Error(`Invalid key-value pair: ${line}`);
+      }
+      const key = match[1].trim();
+      const value = match[3].trim();
+      Struct.addEntry(parent, key, value, index);
+    };
+    let index = 0;
+
+    const walk = () => {
+      const roots: Struct[] = [];
+      const stack = [];
+      while (index < lines.length) {
+        const line = lines[index++].trim();
+        const current = stack[stack.length - 1];
+        if (line.includes("struct.begin")) {
+          const newStruct = parseHead(line);
+          if (current) {
+            const key = Struct.renderStructName(newStruct.constructor.name);
+            Struct.addEntry(current, key, newStruct, index);
+          } else {
+            newStruct.isRoot = true;
+            roots.push(newStruct);
+          }
+          stack.push(newStruct);
+        } else if (line.includes("struct.end")) {
+          stack.pop();
+        } else if (line.includes("=") && current) {
+          parseKeyValue(line, current);
+        }
+      }
+      return roots;
+    };
+
+    return walk() as IntendedType[];
+  }
+}

package/Struct.test.mts

@@ -0,0 +1,174 @@
+import { describe, test, expect } from "vitest";
+import { Struct } from "./Struct.mjs";
+
+class ChimeraHPFix extends Struct {
+  _id = "ChimeraHPFix";
+  bskipref = true;
+  entries = { MaxHP: 750 };
+  isRoot = true;
+}
+class TradersDontBuyWeaponsArmor extends Struct {
+  _id = "TradersDontBuyWeaponsArmor";
+  refurl = "../TradePrototypes.cfg";
+  refkey = 0;
+  isRoot = true;
+  entries = { TradeGenerators: new TradeGenerators() };
+}
+class TradeGenerators extends Struct {
+  _id = "TradeGenerators";
+  entries = { "*": new TradeGenerator() };
+}
+class TradeGenerator extends Struct {
+  _id = "TradeGenerator";
+  entries = { BuyLimitations: new BuyLimitations() };
+}
+class BuyLimitations extends Struct {
+  _id = "BuyLimitations";
+  entries = { [0]: "EItemType::Weapon", [1]: "EItemType::Armor" };
+}
+
+describe("Struct", () => {
+  test("toString()", () => {
+    expect(new ChimeraHPFix().toString()).toBe(
+      `ChimeraHPFix : struct.begin {bskipref}
+   MaxHP = 750
+struct.end`,
+    );
+
+    expect(new TradersDontBuyWeaponsArmor().toString()).toBe(
+      `TradersDontBuyWeaponsArmor : struct.begin {refurl=../TradePrototypes.cfg;refkey=[0]}
+   TradeGenerators : struct.begin
+      [*] : struct.begin
+         BuyLimitations : struct.begin
+            [0] = EItemType::Weapon
+            [1] = EItemType::Armor
+         struct.end
+      struct.end
+   struct.end
+struct.end`,
+    );
+  });
+
+  test("pad()", () => {
+    expect(Struct.pad("test")).toBe("   test");
+    expect(Struct.pad(Struct.pad("test"))).toBe("      test");
+  });
+
+  describe("fromString()", () => {
+    test("1", () => {
+      const chimeraText = new ChimeraHPFix().toString();
+
+      expect(Struct.fromString(chimeraText)[0].toString()).toBe(chimeraText);
+    });
+
+    test("2", () => {
+      const complexStructText = `BasePhantomAttack : struct.begin {refkey=BaseAttackAbility}
+   TriggeredCooldowns : struct.begin
+      [0] : struct.begin
+         CooldownTag = Ability.Cooldown.RunAttack
+         Duration = 50.f
+      struct.end
+   struct.end
+   Effects : struct.begin
+      [0] : struct.begin
+         EffectPrototypeSID = MutantMediumAttackCameraShake
+         Chance = 1.f
+      struct.end
+   struct.end
+struct.end`;
+      expect(Struct.fromString(complexStructText)[0].toString()).toBe(
+        complexStructText,
+      );
+    });
+
+    test("3", () => {
+      const dynamicItemGeneratorText = `DynamicTraderItemGenerator : struct.begin {refurl=../ItemGeneratorPrototypes.cfg;refkey=[0]}
+   SID = DynamicTraderItemGenerator
+   ItemGenerator : struct.begin
+      [0] : struct.begin
+         Category = EItemGenerationCategory::WeaponPrimary
+         PlayerRank = ERank::Newbie
+         bAllowSameCategoryGeneration = true
+         ReputationThreshold = -500
+         RefreshTime = 1h
+         PossibleItems : struct.begin
+            [0] : struct.begin
+               ItemPrototypeSID = GunMark_SP
+               Weight = 1
+               MinDurability = 0.3
+               MaxDurability = 0.6
+               AmmoMinCount = 600
+               AmmoMaxCount = 900
+            struct.end
+         struct.end
+      struct.end
+      [1] : struct.begin
+         Category = EItemGenerationCategory::BodyArmor
+         PlayerRank = ERank::Newbie
+         bAllowSameCategoryGeneration = true
+         ReputationThreshold = -500
+         RefreshTime = 1h
+         PossibleItems : struct.begin
+            [0] : struct.begin
+               ItemPrototypeSID = DutyArmor_3_U1
+               Weight = 1
+               MinDurability = 1.
+               MaxDurability = 1.
+            struct.end
+         struct.end
+      struct.end
+      [2] : struct.begin
+         Category = EItemGenerationCategory::WeaponPistol
+         ReputationThreshold = -500
+         bAllowSameCategoryGeneration = true
+         RefreshTime = 1h
+         PossibleItems : struct.begin
+            [0] : struct.begin
+               ItemPrototypeSID = GunAPB_HG
+               Weight = 1
+               MinDurability = 0.25
+               MaxDurability = 0.5
+               AmmoMinCount = 60
+               AmmoMaxCount = 100
+            struct.end
+         struct.end
+      struct.end
+      [3] : struct.begin
+         Category = EItemGenerationCategory::WeaponSecondary
+         PlayerRank = ERank::Veteran
+         bAllowSameCategoryGeneration = true
+         RefreshTime = 1h
+         PossibleItems : struct.begin
+            [0] : struct.begin
+               ItemPrototypeSID = GunTOZ_SG
+               Weight = 1
+               MinDurability = 0.3
+               MaxDurability = 0.6
+               AmmoMinCount = 60
+               AmmoMaxCount = 90
+            struct.end
+         struct.end
+      struct.end
+      [4] : struct.begin
+         Category = EItemGenerationCategory::Head
+         PlayerRank = ERank::Veteran
+         bAllowSameCategoryGeneration = true
+         ReputationThreshold = -500
+         RefreshTime = 1h
+         PossibleItems : struct.begin
+            [0] : struct.begin
+               ItemPrototypeSID = DutyMask_1
+               Weight = 2
+               MinDurability = 1.
+               MaxDurability = 1.
+            struct.end
+         struct.end
+      struct.end
+   struct.end
+struct.end`;
+      expect(Struct.fromString(dynamicItemGeneratorText)[0].toString()).toBe(
+        dynamicItemGeneratorText,
+      );
+    });
+  });
+});

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "s2cfgtojson",
+  "version": "1.0.0",
+  "description": "Converts Stalker 2 Cfg file into a POJO",
+  "keywords": [
+    "stalker",
+    "unrealengine",
+    "typescript",
+    "javascript",
+    "modding",
+    "mod",
+    "utility"
+  ],
+  "homepage": "https://github.com/sdwvit/s2cfgtojson#readme",
+  "bugs": {
+    "url": "https://github.com/sdwvit/s2cfgtojson/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sdwvit/s2cfgtojson.git"
+  },
+  "license": "ISC",
+  "author": "sdwvit",
+  "type": "module",
+  "main": "Struct.mts",
+  "scripts": {
+    "test": "vitest"
+  },
+  "devDependencies": {
+    "vitest": "^3.2.4",
+    "typescript": "^5.8.3",
+    "prettier": "^3.6.2"
+  },
+  "engines": {
+    "node": ">=24"
+  }
+}

package/readme.md

@@ -0,0 +1,78 @@
+# Stalker 2 CFG to JSON Converter
+
+A utility to convert Stalker 2 `.cfg` configuration files into structured JavaScript objects (POJOs), enabling easier mod development and analysis.
+
+---
+
+## Key Features
+
+- **Struct Class**: A flexible base class for parsing and generating Stalker 2 config structures, handling nested data, wildcards, and indexed entries.
+- **TypeScript Support**: Built with TypeScript for type safety and clarity.
+
+---
+
+## Getting Started
+
+### Prerequisites
+- Node.js ≥24
+- npm (or pnpm/yarn)
+
+### Installation
+```bash
+npm install
+```
+
+### Usage
+Import the `Struct` class from `Struct.mts` to parse or generate Stalker 2 config data. For example:
+```ts
+import { Struct } from './Struct.mts';
+
+const config = new Struct();
+// Use methods like `toString()` or `fromString()` to process configs
+```
+
+---
+
+## Example
+Convert a `.cfg` file to a structured object:
+```ts
+const configText = `
+BasePhantomAttack : struct.begin {refkey=BaseAttackAbility}
+   TriggeredCooldowns : struct.begin
+      [0] : struct.begin
+         CooldownTag = Ability.Cooldown.RunAttack
+         Duration = 50.f
+      struct.end
+   struct.end
+struct.end
+`;
+const parsed = Struct.fromString(configText)[0];
+console.log(parsed.toString());
+```
+
+---
+
+## Development
+
+### Tests
+Run tests using:
+```bash
+npm test
+```
+
+---
+
+## Contributing
+
+Feel free to contribute by submitting issues or pull requests. Ensure your code adheres to the project's coding standards and includes tests for new features.
+
+---
+
+## License
+Free to use in non-commercial projects.
+
+---
+
+## Notes
+
+Thanks, GSC and modders for providing the community with tools to enhance the modding experience.

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "lib": ["es2024"],
+    "module": "nodenext",
+    "allowImportingTsExtensions": true
+  }
+}