s2cfgtojson 3.0.5 → 3.2.0

package/Struct.mts

@@ -1,6 +1,6 @@
 export * from "./types.mts";
 export * from "./enums.mts";
-import { DefaultEntries } from "./types.mts";
+import { DefaultEntries, Internal } from "./types.mts";
 
 const TAB = "   ";
 const WILDCARD = "_wildcard";
@@ -11,6 +11,17 @@ const KEYWORDS = [
   "bpatch", // allows patching only specific keys
 ];
 const REMOVE_NODE = "removenode";
+const INTERNAL_PROPS = new Set([
+  "__internal__",
+  "fork",
+  "removeNode",
+  "addNode",
+  "clone",
+  "forEach",
+  "filter",
+  "map",
+  "toString",
+]);
 
 /**
  * This file is part of the Stalker 2 Modding Tools project.
@@ -62,31 +73,94 @@ export class Struct {
     return this;
   }
 
+  addNode(value: any, key?: string | number): this {
+    if (this.__internal__.isArray !== true) {
+      throw new Error("Cannot add node to non-array struct.");
+    }
+    if (key === undefined) {
+      const nextIndex = Object.keys(this)
+        .map((k) => parseInt(k))
+        .filter((k) => !isNaN(k))
+        .sort((a, b) => a - b)
+        .pop();
+      this[nextIndex !== undefined ? nextIndex + 1 : 0] = value;
+    } else {
+      this[key] = value;
+    }
+    return this;
+  }
+
   clone() {
     return Struct.fromString(this.toString())[0] as this;
   }
 
+  entries(): [keyof this, (typeof this)[keyof this]][] {
+    return Object.entries(this).filter(([key]) => !INTERNAL_PROPS.has(key)) as [
+      keyof this,
+      (typeof this)[keyof this],
+    ][];
+  }
+
+  forEach<K extends Exclude<keyof this, Internal>, V extends (typeof this)[K]>(
+    callback: ([key, value]: [K, V]) => void,
+  ): void {
+    this.entries().forEach(([key, value]) => callback([key as K, value as V]));
+  }
+
+  /**
+   * Filters the struct entries based on a callback function. Returns a copy.
+   * @param callback
+   */
+  filter<K extends Exclude<keyof this, Internal>, V extends (typeof this)[K]>(
+    callback: ([key, value]: [K, V]) => boolean,
+  ): Partial<this> & Struct {
+    const clone = this.clone();
+    clone.entries().forEach(([key, value]) => {
+      if (!callback([key as K, value as V])) {
+        delete clone[key];
+      }
+    });
+    return clone;
+  }
+
+  /**
+   * Maps the struct entries based on a callback function. Returns a copy.
+   * @param callback
+   */
+  map<K extends Exclude<keyof this, Internal>, V extends (typeof this)[K]>(
+    callback: ([key, value]: [K, V]) => V,
+  ): this {
+    const clone = this.clone();
+    clone.entries().forEach(([key, value]) => {
+      clone[key] = callback([key as K, value as V]);
+    });
+    return clone;
+  }
+
   toString(): string {
     if (!(this.__internal__ instanceof Refs)) {
       this.__internal__ = new Refs(this.__internal__);
     }
-    const { __internal__: internal, ...entries } = this;
 
-    let text: string = internal.rawName ? `${internal.rawName} : ` : "";
+    let text: string = this.__internal__.rawName
+      ? `${this.__internal__.rawName} : `
+      : "";
     text += "struct.begin";
 
-    const refs = internal.toString();
+    const refs = this.__internal__.toString();
     if (refs) {
       text += ` {${refs}}`;
     }
 
     text += "\n";
     // Add all keys
-    text += Object.entries(entries || {})
+    text += Object.entries(this)
+      .filter(([key]) => !INTERNAL_PROPS.has(key))
       .map(([key, value]) => {
         const nameAlreadyRendered =
           value instanceof Struct && value.__internal__.rawName;
-        const useAsterisk = internal.isArray && internal.useAsterisk;
+        const useAsterisk =
+          this.__internal__.isArray && this.__internal__.useAsterisk;
         let keyOrIndex = "";
         let equalsOrColon = "";
         let spaceOrNoSpace = "";
@@ -117,7 +191,7 @@ export class Refs implements DefaultEntries {
   isArray?: boolean;
   useAsterisk?: boolean;
 
-  constructor(ref?: string | object) {
+  constructor(ref?: string | Refs) {
     if (typeof ref === "string") {
       ref
         .split(";")
@@ -151,7 +225,7 @@ export class Refs implements DefaultEntries {
 }
 
 const structHeadRegex = new RegExp(
-  `^(.*)\\s*:\\s*struct\\.begin\\s*({\\s*((${KEYWORDS.join("|")})\\s*(=.+)?)\\s*})?`,
+  `^\s*(.*)\\s*:\\s*struct\\.begin\\s*({\\s*((${KEYWORDS.join("|")})\\s*(=.+)?)\\s*})?`,
 );
 
 function parseHead(line: string, index: number): Struct {

package/Struct.test.mts

@@ -5,6 +5,7 @@ import {
   pad,
   Struct,
   ArmorPrototype,
+  Refs,
 } from "./Struct.mjs";
 import fs from "node:fs";
 
@@ -26,15 +27,23 @@ class TradePrototype extends Struct {
   TradeGenerators = new TradeGenerators();
 }
 class TradeGenerators extends Struct {
-  "*" = new TradeGenerator();
+  __internal__ = new Refs({
+    isArray: true,
+    useAsterisk: true,
+  });
+  "0" = new TradeGenerator();
 }
 class TradeGenerator extends Struct {
   BuyLimitations = new BuyLimitations();
 }
 
 class BuyLimitations extends Struct {
-  [0] = "EItemType::Weapon";
-  [1] = "EItemType::Armor";
+  __internal__ = new Refs({
+    rawName: "BuyLimitations",
+    isArray: true,
+  });
+  "0" = "EItemType::Weapon";
+  "1" = "EItemType::Armor";
 }
 
 describe("Struct", () => {
@@ -236,6 +245,55 @@ struct.end`;
     });
   });
 
+  describe("addNode", () => {
+    test("1", () => {
+      const a = new TradePrototype().fork(true);
+      expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("EItemType::Weapon");
+      expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("EItemType::Armor");
+      a.TradeGenerators[0].BuyLimitations.addNode("EItemType::Artifact");
+      expect(a.TradeGenerators[0].BuyLimitations[2]).toBe(
+        "EItemType::Artifact",
+      );
+    });
+  });
+
+  describe("forEach", () => {
+    test("1", () => {
+      const a = new TradePrototype().fork(true);
+      expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("EItemType::Weapon");
+      expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("EItemType::Armor");
+      a.TradeGenerators[0].BuyLimitations.forEach(([k]) => {
+        a.TradeGenerators[0].BuyLimitations[k] = "forEach";
+      });
+      expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("forEach");
+      expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("forEach");
+    });
+  });
+
+  describe("filter", () => {
+    test("1", () => {
+      const a = new TradePrototype().fork(true);
+      expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("EItemType::Weapon");
+      expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("EItemType::Armor");
+      const b = a.TradeGenerators[0].BuyLimitations.filter(([k]) => k === "0");
+      expect(b[0]).toBe("EItemType::Weapon");
+      expect(b[1]).toBeUndefined();
+    });
+  });
+
+  describe("map", () => {
+    test("1", () => {
+      const a = new TradePrototype();
+      expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("EItemType::Weapon");
+      expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("EItemType::Armor");
+      const b = a.TradeGenerators[0].BuyLimitations.map(
+        ([k, v]) => `${v}-mapped-${k}`,
+      );
+      expect(b[0]).toBe("EItemType::Weapon-mapped-0");
+      expect(b[1]).toBe("EItemType::Armor-mapped-1");
+    });
+  });
+
   describe("clone", () => {
     test("1", () => {
       const a = new TradePrototype();
@@ -251,7 +309,7 @@ struct.end`;
       const a = new TradePrototype().fork(true);
       expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("EItemType::Weapon");
       expect(a.TradeGenerators[0].BuyLimitations[1]).toBe("EItemType::Armor");
-      a.TradeGenerators[0].BuyLimitations.removeNode(0);
+      a.TradeGenerators[0].BuyLimitations.removeNode("0");
       expect(a.TradeGenerators[0].BuyLimitations[0]).toBe("removenode");
     });
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "s2cfgtojson",
-  "version": "3.0.5",
+  "version": "3.2.0",
   "description": "Converts Stalker 2 Cfg file into POJOs",
   "keywords": [
     "stalker",

package/types.mts

@@ -68,7 +68,17 @@ import {
 } from "./enums.mjs";
 import { Struct } from "./Struct.mjs";
 
-export type Internal = "__internal__";
+export type Internal =
+  | "__internal__"
+  | "fork"
+  | "removeNode"
+  | "addNode"
+  | "clone"
+  | "forEach"
+  | "filter"
+  | "map"
+  | "entries"
+  | "toString";
 
 export type DeeplyPartial<T> = {
   [P in keyof T]?: T[P] extends Array<infer U>
@@ -81,7 +91,7 @@ export type DeeplyPartial<T> = {
 };
 
 export type DeeplyPartialStruct<T> = DeeplyPartial<
-  T extends Struct ? Omit<T, Internal> : T
+  T extends Struct ? Exclude<T, Internal> : T
 >;
 
 export interface DefaultEntries {