@etothepii/satisfactory-file-parser 0.1.22 → 0.1.25

package/build/index.d.ts

@@ -24,3 +24,4 @@ export { SaveStreamWriter } from './parser/stream/save-stream-writer.class';
 export * from './parser/error/parser.error';
 export * from './parser/file.types';
 export { Parser } from './parser/parser';
+export { ReadableStreamParser } from './parser/stream/reworked/readable-stream-parser';

package/build/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Parser = exports.SaveStreamWriter = exports.SaveStreamJsonStringifier = exports.SaveWriter = exports.SaveReader = exports.BlueprintWriter = exports.BlueprintConfigWriter = exports.BlueprintReader = exports.BlueprintConfigReader = exports.ByteWriter = exports.ByteReader = exports.SatisfactorySave = exports.Level = exports.SaveEntity = exports.SaveComponent = exports.ObjectReference = exports.DataFields = void 0;
+exports.ReadableStreamParser = exports.Parser = exports.SaveStreamWriter = exports.SaveStreamJsonStringifier = exports.SaveWriter = exports.SaveReader = exports.BlueprintWriter = exports.BlueprintConfigWriter = exports.BlueprintReader = exports.BlueprintConfigReader = exports.ByteWriter = exports.ByteReader = exports.SatisfactorySave = exports.Level = exports.SaveEntity = exports.SaveComponent = exports.ObjectReference = exports.DataFields = void 0;
 __exportStar(require("./parser/satisfactory/blueprint/blueprint.types"), exports);
 var DataFields_1 = require("./parser/satisfactory/objects/DataFields");
 Object.defineProperty(exports, "DataFields", { enumerable: true, get: function () { return DataFields_1.DataFields; } });
@@ -56,3 +56,5 @@ __exportStar(require("./parser/error/parser.error"), exports);
 __exportStar(require("./parser/file.types"), exports);
 var parser_1 = require("./parser/parser");
 Object.defineProperty(exports, "Parser", { enumerable: true, get: function () { return parser_1.Parser; } });
+var readable_stream_parser_1 = require("./parser/stream/reworked/readable-stream-parser");
+Object.defineProperty(exports, "ReadableStreamParser", { enumerable: true, get: function () { return readable_stream_parser_1.ReadableStreamParser; } });

package/build/parser/parser.d.ts

@@ -4,7 +4,7 @@ import { Blueprint } from "./satisfactory/blueprint/blueprint.types";
 import { SatisfactorySave } from "./satisfactory/save/satisfactory-save";
 export declare class Parser {
     static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void): ChunkSummary[];
-    static ParseSaveFile(file: Buffer, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
+    static ParseSaveFile(name: string, file: Buffer, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
     static WriteBlueprintFiles(blueprint: Blueprint, onMainFileBinaryBeforeCompressing?: (binary: ArrayBuffer) => void, onMainFileHeader?: (header: Uint8Array) => void, onMainFileChunk?: (chunk: Uint8Array) => void): {
         mainFileChunkSummary: ChunkSummary[];
         configFileBinary: ArrayBuffer;

package/build/parser/parser.js

@@ -18,10 +18,10 @@ class Parser {
         const chunkSummary = writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk);
         return chunkSummary;
     }
-    static ParseSaveFile(file, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+    static ParseSaveFile(name, file, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
         const reader = new save_reader_1.SaveReader(new Uint8Array(file).buffer, onProgress);
         const header = reader.readHeader();
-        const save = new satisfactory_save_1.SatisfactorySave(header);
+        const save = new satisfactory_save_1.SatisfactorySave(name, header);
         const inflateResult = reader.inflateChunks();
         onDecompressedSaveBody(reader.getBuffer());
         const gridHash = reader.readSaveBodyHash();

package/build/parser/satisfactory/save/level.class.js

@@ -89,8 +89,8 @@ class Level {
             throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
         }
         for (let i = 0; i < countEntities; i++) {
-            if (i % 1000 === 0) {
-                onProgressCallback(reader.getBufferProgress());
+            if (countEntities >= 10000 && i % 10000 === 0) {
+                onProgressCallback(reader.getBufferProgress(), `read object count [${(i + 1)}/${(countEntities + 1)}] in level ${levelName}`);
             }
             const obj = objectsList[i];
             obj.saveOrBlueprintIndicator = reader.readInt32();

package/build/parser/satisfactory/save/satisfactory-save.d.ts

@@ -4,11 +4,12 @@ import { Level } from "./level.class";
 import { ByteArray4, Grids } from "./save-reader";
 import { SatisfactorySaveHeader } from "./save.types";
 export declare class SatisfactorySave {
+    name: string;
     header: SatisfactorySaveHeader;
     gridHash: ByteArray4;
     grids: Grids;
     levels: Level[];
     trailingCollectedObjects: ObjectReference[];
     compressionInfo?: ChunkCompressionInfo;
-    constructor(header: SatisfactorySaveHeader);
+    constructor(name: string, header: SatisfactorySaveHeader);
 }

package/build/parser/satisfactory/save/satisfactory-save.js

@@ -2,11 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SatisfactorySave = void 0;
 class SatisfactorySave {
-    constructor(header) {
+    constructor(name, header) {
         this.gridHash = [0, 0, 0, 0];
         this.grids = {};
         this.levels = [];
         this.trailingCollectedObjects = [];
+        this.name = name;
         this.header = header;
     }
 }

package/build/parser/satisfactory/save/save-reader.js

@@ -179,6 +179,9 @@ class SaveReader extends byte_reader_class_1.ByteReader {
         this.onProgressCallback(this.getBufferProgress(), `reading pack of ${levelCount} levels.`);
         for (let i = 0; i < levelCount; i++) {
             let levelSingleName = this.readString();
+            if (i % 500 === 0) {
+                this.onProgressCallback(this.getBufferProgress(), `reading level [${(i + 1)}/${(levelCount + 1)}] ${levelSingleName}`);
+            }
             levels.push(level_class_1.Level.ReadLevel(this, levelSingleName, this.header.buildVersion));
         }
         levels.push(level_class_1.Level.ReadLevel(this, this.header.mapName, this.header.buildVersion));

package/build/parser/satisfactory/save/save-writer.js

@@ -69,7 +69,7 @@ class SaveWriter extends byte_writer_class_1.ByteWriter {
     static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, alignment = alignment_enum_1.Alignment.LITTLE_ENDIAN) {
         const errors = [];
         const totalUncompressedSize = bufferArray.byteLength;
-        const saveBody = new Uint8Array(bufferArray.byteLength + 4);
+        const saveBody = new Uint8Array(bufferArray.byteLength + 8);
         saveBody.set(new Uint8Array(bufferArray), 4);
         const miniView = new DataView(saveBody.buffer);
         miniView.setInt32(0, totalUncompressedSize, alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);

package/build/parser/stream/reworked/readable-stream-parser.d.ts

@@ -0,0 +1,12 @@
+import { ReadableStream } from "stream/web";
+export declare class ReadableStreamParser {
+    private static CreateReadableStreamForParsingSave;
+    static CreateReadableStreamFromSaveToJson: (name: string, bytes: Uint8Array, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void) => {
+        stream: ReadableStream<string>;
+        startStreaming: () => Promise<void>;
+    };
+    private static WriteHeaderAndGrids;
+    private static WriteLevels;
+    private static ReadNObjectHeaders;
+    private static ReadNObjects;
+}

package/build/parser/stream/reworked/readable-stream-parser.js

@@ -0,0 +1,204 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadableStreamParser = void 0;
+const web_1 = require("stream/web");
+const satisfactory_save_1 = require("../../satisfactory/save/satisfactory-save");
+const save_reader_1 = require("../../satisfactory/save/save-reader");
+const SaveComponent_1 = require("../../satisfactory/objects/SaveComponent");
+const SaveEntity_1 = require("../../satisfactory/objects/SaveEntity");
+const level_class_1 = require("../../satisfactory/save/level.class");
+const DEFAULT_BYTE_HIGHWATERMARK = 1024 * 1024 * 200;
+const createStringLengthQueuingStrategy = (highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => ({
+    highWaterMark,
+    size: (chunk) => {
+        if (chunk === undefined) {
+            return 0;
+        }
+        return chunk.length;
+    }
+});
+class SimpleWaitForConsumerLock {
+    constructor() {
+        this.locked = false;
+        this.unlockWasCalledInTheMeantime = false;
+        this.executionFn = undefined;
+    }
+    lock(executionFn) {
+        this.executionFn = executionFn;
+        this.locked = true;
+        if (this.unlockWasCalledInTheMeantime) {
+            this.unlock();
+        }
+    }
+    unlock() {
+        this.locked = false;
+        if (this.executionFn) {
+            this.executionFn();
+            this.executionFn = undefined;
+        }
+        else {
+            this.unlockWasCalledInTheMeantime = true;
+        }
+    }
+}
+;
+class ReadableStreamParser {
+    static async WriteLevels(write, reader, mapName, buildVersion) {
+        const batchingSizeOfObjects = 1000;
+        const thresholdOfWrittenObjectsUntilWaitingForConsumerAgain = 3 * batchingSizeOfObjects;
+        const levelCount = reader.readInt32();
+        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount + 1} levels.`);
+        let writtenTotalObjectsSinceConsumerSync = 0;
+        for (let j = 0; j <= levelCount; j++) {
+            let levelName = (j === levelCount) ? '' + mapName : reader.readString();
+            if (j % 500 === 0) {
+                reader.onProgressCallback(reader.getBufferProgress(), `reading level [${(j + 1)}/${(levelCount + 1)}] ${levelName}`);
+            }
+            await write(`${j > 0 ? ', ' : ''}{"name": "${levelName}", "objects": [`, false);
+            const headersBinLen = reader.readInt32();
+            const unk = reader.readInt32();
+            const posBeforeHeaders = reader.getBufferPosition();
+            const afterAllHeaders = posBeforeHeaders + headersBinLen;
+            let countObjectHeaders = reader.readInt32();
+            let totalReadObjectsInLevel = 0;
+            let writtenObjectsInLevel = 0;
+            let afterHeadersOfBatch = reader.getBufferPosition();
+            let afterObjectsOfBatch = -1;
+            do {
+                reader.skipBytes(afterHeadersOfBatch - reader.getBufferPosition());
+                const objectCountToRead = Math.min(countObjectHeaders - totalReadObjectsInLevel, batchingSizeOfObjects);
+                const objects = ReadableStreamParser.ReadNObjectHeaders(reader, objectCountToRead);
+                afterHeadersOfBatch = reader.getBufferPosition();
+                if (totalReadObjectsInLevel === 0) {
+                    reader.skipBytes(afterAllHeaders - reader.getBufferPosition());
+                    const objectContentsBinLen = reader.readInt32();
+                    const unk2 = reader.readInt32();
+                    const posBeforeContents = reader.getBufferPosition();
+                    const countEntities = reader.readInt32();
+                    afterObjectsOfBatch = reader.getBufferPosition();
+                }
+                else {
+                    reader.skipBytes(afterObjectsOfBatch - reader.getBufferPosition());
+                }
+                ReadableStreamParser.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
+                afterObjectsOfBatch = reader.getBufferPosition();
+                totalReadObjectsInLevel += objectCountToRead;
+                if (countObjectHeaders > 10000 && totalReadObjectsInLevel % 10000 === 0) {
+                    reader.onProgressCallback(reader.getBufferProgress(), `read object count [${(totalReadObjectsInLevel + 1)}/${(countObjectHeaders + 1)}] in level ${levelName}`);
+                }
+                let shouldWait = false;
+                if (writtenTotalObjectsSinceConsumerSync >= thresholdOfWrittenObjectsUntilWaitingForConsumerAgain) {
+                    shouldWait = true;
+                    writtenTotalObjectsSinceConsumerSync = 0;
+                }
+                await write(`${writtenObjectsInLevel > 0 ? ', ' : ''}${objects.map(obj => JSON.stringify(obj)).join(', ')}`, shouldWait);
+                writtenTotalObjectsSinceConsumerSync += objectCountToRead;
+                writtenObjectsInLevel += objectCountToRead;
+            } while (totalReadObjectsInLevel < countObjectHeaders);
+            await write('], "collectables": [', false);
+            const collectables = level_class_1.Level.ReadCollectablesList(reader);
+            await write(`${collectables.map(obj => JSON.stringify(obj)).join(', ')}`, true);
+            await write(']', false);
+            await write('}', false);
+        }
+    }
+}
+_a = ReadableStreamParser;
+ReadableStreamParser.CreateReadableStreamForParsingSave = (onStart, onCancel, onPullRequest, highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => {
+    let ourController = null;
+    const stream = new web_1.ReadableStream({
+        start: (controller) => {
+            ourController = controller;
+            onStart(ourController);
+        },
+        pull: (controller) => {
+            onPullRequest(ourController.desiredSize ?? 1);
+        },
+        cancel: (reason) => {
+            console.warn('parsing stream was canceled!', reason);
+            if (ourController !== null) {
+                ourController.close();
+            }
+            onCancel(reason);
+        }
+    }, createStringLengthQueuingStrategy(highWaterMark));
+    const finish = () => {
+        if (ourController !== null) {
+            ourController?.close();
+        }
+    };
+    return { stream, controller: ourController, finish };
+};
+ReadableStreamParser.CreateReadableStreamFromSaveToJson = (name, bytes, onDecompressedSaveBody = () => { }, onProgress = () => { }) => {
+    const waitForConsumerLock = new SimpleWaitForConsumerLock();
+    const waitForConsumer = async () => {
+        return new Promise((resolve, reject) => {
+            waitForConsumerLock.lock(resolve);
+        });
+    };
+    const { stream, controller, finish } = ReadableStreamParser.CreateReadableStreamForParsingSave((controller) => {
+    }, (reason) => { }, (desiredSize) => {
+        waitForConsumerLock.unlock();
+    });
+    const write = async (value, waitForConsumerToBeReady = true) => {
+        if (waitForConsumerToBeReady) {
+            await waitForConsumer();
+        }
+        controller.enqueue(value);
+    };
+    const startStreaming = async () => {
+        const reader = new save_reader_1.SaveReader(bytes.buffer, onProgress);
+        const header = reader.readHeader();
+        const save = new satisfactory_save_1.SatisfactorySave(name, header);
+        const inflateResult = reader.inflateChunks();
+        onDecompressedSaveBody(reader.getBuffer());
+        const gridHash = reader.readSaveBodyHash();
+        const grids = reader.readGrids();
+        await ReadableStreamParser.WriteHeaderAndGrids(write, reader.compressionInfo, header, grids, gridHash);
+        await ReadableStreamParser.WriteLevels(write, reader, save.header.mapName, save.header.buildVersion);
+        await write(`]}`);
+        finish();
+    };
+    return { stream, startStreaming };
+};
+ReadableStreamParser.WriteHeaderAndGrids = async (write, compressionInfo, header, grids, gridHash) => {
+    return write(`{"header": ${JSON.stringify(header)}, "compressionInfo": ${JSON.stringify(compressionInfo)}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, "levels": [`, false);
+};
+ReadableStreamParser.ReadNObjectHeaders = (reader, count) => {
+    let objects = [];
+    let objectsRead = 0;
+    for (; objectsRead < count; objectsRead++) {
+        let obj;
+        let objectType = reader.readInt32();
+        switch (objectType) {
+            case SaveEntity_1.SaveEntity.TypeID:
+                obj = new SaveEntity_1.SaveEntity('', '', '', '');
+                SaveEntity_1.SaveEntity.ParseHeader(reader, obj);
+                break;
+            case SaveComponent_1.SaveComponent.TypeID:
+                obj = new SaveComponent_1.SaveComponent('', '', '', '');
+                SaveComponent_1.SaveComponent.ParseHeader(reader, obj);
+                break;
+            default:
+                throw new Error('Unknown object type' + objectType);
+        }
+        objects.push(obj);
+    }
+    return objects;
+};
+ReadableStreamParser.ReadNObjects = (reader, count, objects, buildVersion) => {
+    for (let i = 0; i < count; i++) {
+        objects[i].saveOrBlueprintIndicator = reader.readInt32();
+        objects[i].unknownType2 = reader.readInt32();
+        const binarySize = reader.readInt32();
+        const before = reader.getBufferPosition();
+        if ((0, SaveEntity_1.isSaveEntity)(objects[i])) {
+            SaveEntity_1.SaveEntity.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+        else if ((0, SaveComponent_1.isSaveComponent)(objects[i])) {
+            SaveComponent_1.SaveComponent.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+    }
+};
+exports.ReadableStreamParser = ReadableStreamParser;

package/build/parser/stream/reworked/stream-parser.d.ts

@@ -1,6 +1,8 @@
 /// <reference types="node" />
 import { WritableStream } from 'stream/web';
 export declare class StreamParser {
-    static ParseSaveFileAsynchronousToOutput(bytes: Uint8Array, outputJson: WritableStream<string>, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): Promise<void>;
+    static ParseSaveFileToJsonStream(name: string, bytes: Uint8Array, outputJson: WritableStream<string>, onDecompressedSaveBody?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): Promise<void>;
     private static readLevelsAsync;
+    private static ReadNObjectHeaders;
+    private static ReadNObjects;
 }

package/build/parser/stream/reworked/stream-parser.js

@@ -2,30 +2,108 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamParser = void 0;
 const __1 = require("../../..");
+const SaveComponent_1 = require("../../satisfactory/objects/SaveComponent");
+const SaveEntity_1 = require("../../satisfactory/objects/SaveEntity");
 class StreamParser {
-    static async ParseSaveFileAsynchronousToOutput(bytes, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
+    static async ParseSaveFileToJsonStream(name, bytes, outputJson, onDecompressedSaveBody = () => { }, onProgress = () => { }) {
         const reader = new __1.SaveReader(bytes.buffer, onProgress);
         const writer = outputJson.getWriter();
         const header = reader.readHeader();
-        const save = new __1.SatisfactorySave(header);
+        const save = new __1.SatisfactorySave(name, header);
         const inflateResult = reader.inflateChunks();
         onDecompressedSaveBody(reader.getBuffer());
         const gridHash = reader.readSaveBodyHash();
         const grids = reader.readGrids();
-        await writer.write(`{"header:" ${JSON.stringify(header)}, "compressionInfo": {}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, levels: [`);
+        await writer.write(`{"header": ${JSON.stringify(header)}, "compressionInfo": ${JSON.stringify(reader.compressionInfo)}, "gridHash": ${JSON.stringify(gridHash)}, "grids": ${JSON.stringify(grids)}, "levels": [`);
         await StreamParser.readLevelsAsync(reader, writer, save.header.mapName, save.header.buildVersion);
         await writer.write(`]}`);
+        await writer.ready;
         await writer.close();
     }
     static async readLevelsAsync(reader, writer, mapName, buildVersion) {
         const levelCount = reader.readInt32();
-        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount} levels.`);
+        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount + 1} levels.`);
+        const batchingSizeOfObjects = 1000;
         for (let j = 0; j <= levelCount; j++) {
             let levelName = (j === levelCount) ? '' + mapName : reader.readString();
-            if (j % 300 === 0) {
+            if (j % 500 === 0) {
                 reader.onProgressCallback(reader.getBufferProgress(), `reading level [${(j + 1)}/${(levelCount + 1)}] ${levelName}`);
             }
+            await writer.write(`${j > 0 ? ', ' : ''}{"name": "${levelName}", "objects": [`);
+            const headersBinLen = reader.readInt32();
+            const unk = reader.readInt32();
+            const posBeforeHeaders = reader.getBufferPosition();
+            const afterAllHeaders = posBeforeHeaders + headersBinLen;
+            let countObjectHeaders = reader.readInt32();
+            let totalReadObjects = 0;
+            let afterHeadersOfBatch = reader.getBufferPosition();
+            let afterObjectsOfBatch = -1;
+            do {
+                reader.skipBytes(afterHeadersOfBatch - reader.getBufferPosition());
+                const objectCountToRead = Math.min(countObjectHeaders - totalReadObjects, batchingSizeOfObjects);
+                const objects = StreamParser.ReadNObjectHeaders(reader, objectCountToRead);
+                afterHeadersOfBatch = reader.getBufferPosition();
+                if (totalReadObjects === 0) {
+                    reader.skipBytes(afterAllHeaders - reader.getBufferPosition());
+                    const objectContentsBinLen = reader.readInt32();
+                    const unk2 = reader.readInt32();
+                    const posBeforeContents = reader.getBufferPosition();
+                    const countEntities = reader.readInt32();
+                    afterObjectsOfBatch = reader.getBufferPosition();
+                }
+                else {
+                    reader.skipBytes(afterObjectsOfBatch - reader.getBufferPosition());
+                }
+                StreamParser.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
+                afterObjectsOfBatch = reader.getBufferPosition();
+                totalReadObjects += objectCountToRead;
+                if (countObjectHeaders > 10000 && totalReadObjects % 10000 === 0) {
+                    reader.onProgressCallback(reader.getBufferProgress(), `read object count [${(totalReadObjects + 1)}/${(countObjectHeaders + 1)}] in level ${levelName}`);
+                }
+                await writer.write(`${objects.map(obj => JSON.stringify(obj)).join(', ')}`);
+            } while (totalReadObjects < countObjectHeaders);
+            await writer.write('], "collectables": [');
+            const collectables = __1.Level.ReadCollectablesList(reader);
+            await writer.write(`${collectables.map(obj => JSON.stringify(obj)).join(', ')}`);
+            await writer.write(']');
+            await writer.write('}');
         }
     }
 }
+StreamParser.ReadNObjectHeaders = (reader, count) => {
+    let objects = [];
+    let objectsRead = 0;
+    for (; objectsRead < count; objectsRead++) {
+        let obj;
+        let objectType = reader.readInt32();
+        switch (objectType) {
+            case __1.SaveEntity.TypeID:
+                obj = new __1.SaveEntity('', '', '', '');
+                __1.SaveEntity.ParseHeader(reader, obj);
+                break;
+            case __1.SaveComponent.TypeID:
+                obj = new __1.SaveComponent('', '', '', '');
+                __1.SaveComponent.ParseHeader(reader, obj);
+                break;
+            default:
+                throw new Error('Unknown object type' + objectType);
+        }
+        objects.push(obj);
+    }
+    return objects;
+};
+StreamParser.ReadNObjects = (reader, count, objects, buildVersion) => {
+    for (let i = 0; i < count; i++) {
+        objects[i].saveOrBlueprintIndicator = reader.readInt32();
+        objects[i].unknownType2 = reader.readInt32();
+        const binarySize = reader.readInt32();
+        const before = reader.getBufferPosition();
+        if ((0, SaveEntity_1.isSaveEntity)(objects[i])) {
+            __1.SaveEntity.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+        else if ((0, SaveComponent_1.isSaveComponent)(objects[i])) {
+            __1.SaveComponent.ParseData(objects[i], binarySize, reader, buildVersion, objects[i].typePath);
+        }
+    }
+};
 exports.StreamParser = StreamParser;

package/build/parser/stream/save-stream-writer.class.d.ts

@@ -6,20 +6,22 @@ import { ByteArray4, Grids } from '../satisfactory/save/save-reader';
 export declare class SaveStreamWriter {
     private writer;
     private mode;
+    private tracker;
     private formatTracker;
     constructor(writer: WritableStreamDefaultWriter<string>);
-    beginSave(): Promise<void>;
-    writeHeader(header: SatisfactorySaveHeader): Promise<void>;
-    writeCompressionInfo(compressionInfo: ChunkCompressionInfo): Promise<void>;
-    writeGridHash(gridHash: ByteArray4): Promise<void>;
-    writeGrids(grids: Grids): Promise<void>;
-    openLevels(): Promise<void>;
-    openLevel(levelName: string): Promise<void>;
-    writeObjects(...objects: SaveObject[]): Promise<void>;
-    switchInLevelToCollectables(): Promise<void>;
-    writeCollectables(...collectables: ObjectReference[]): Promise<void>;
-    endLevel(): Promise<void>;
-    endLevels(): Promise<void>;
-    endSave(): Promise<void>;
+    private createExecutionFunction;
+    beginSave: () => Promise<void>;
+    writeHeader: (header: SatisfactorySaveHeader) => Promise<void>;
+    writeCompressionInfo: (compressionInfo: ChunkCompressionInfo) => Promise<void>;
+    writeGridHash: (gridHash: ByteArray4) => Promise<void>;
+    writeGrids: (grids: Grids) => Promise<void>;
+    openLevels: () => Promise<void>;
+    openLevel: (levelName: string) => Promise<void>;
+    writeObjects: (...objects: SaveObject[]) => Promise<void>;
+    switchInLevelToCollectables: (...objects: SaveObject[]) => Promise<void>;
+    writeCollectables: (...collectables: ObjectReference[]) => Promise<void>;
+    endLevel: () => Promise<void>;
+    endLevels: () => Promise<void>;
+    endSave: () => Promise<void>;
     close(): Promise<void>;
 }

package/build/parser/stream/save-stream-writer.class.js

@@ -1,117 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SaveStreamWriter = void 0;
+class ModeStateTracker {
+    constructor(mode) {
+        this.mode = mode;
+    }
+    checkIsComingFrom(...allowedPredecessors) {
+        if (!allowedPredecessors.includes(this.mode)) {
+            throw new Error(`Wrong order of commands. mode is ${this.mode}. but only ${allowedPredecessors.join(', ')} is/are allowed.`);
+        }
+    }
+    advance(newMode) {
+        this.mode = newMode;
+    }
+}
 class SaveStreamWriter {
     constructor(writer) {
         this.writer = writer;
+        this.createExecutionFunction = async (allowedInputModes, fn, targetMode) => {
+            this.tracker.checkIsComingFrom(...allowedInputModes);
+            await fn();
+            this.tracker.advance(targetMode);
+        };
+        this.beginSave = () => this.createExecutionFunction(['BEFORE_START'], async () => {
+            await this.writer.write('{');
+        }, 'OPENED_SAVE');
+        this.writeHeader = (header) => this.createExecutionFunction(['OPENED_SAVE'], async () => {
+            await this.writer.write(`"header": ${JSON.stringify(header)}`);
+        }, 'FINISHED_HEADER');
+        this.writeCompressionInfo = (compressionInfo) => this.createExecutionFunction(['FINISHED_HEADER'], async () => {
+            await this.writer.write(`, "compressionInfo": ${JSON.stringify(compressionInfo)}`);
+        }, 'WROTE_COMPRESSION_INFO');
+        this.writeGridHash = (gridHash) => this.createExecutionFunction(['WROTE_COMPRESSION_INFO'], async () => {
+            await this.writer.write(`, "gridHash": ${JSON.stringify(gridHash)}`);
+        }, 'WROTE_GRID_HASH');
+        this.writeGrids = (grids) => this.createExecutionFunction(['WROTE_GRID_HASH'], async () => {
+            await this.writer.write(`, "grids": ${JSON.stringify(grids)}`);
+        }, 'WROTE_GRIDS');
+        this.openLevels = () => this.createExecutionFunction(['WROTE_GRIDS'], async () => {
+            await this.writer.write(`, "levels": [`);
+        }, 'OPENED_LEVELS');
+        this.openLevel = (levelName) => this.createExecutionFunction(['OPENED_LEVELS', 'FINISHED_LEVEL'], async () => {
+            this.formatTracker.levels.push({
+                objectCount: 0, collectablesCount: 0
+            });
+            const prefix = this.formatTracker.levels.length > 1 ? ', ' : '';
+            await this.writer.write(`${prefix}{"name": "${levelName}", "objects": [`);
+        }, 'OPENED_LEVEL');
+        this.writeObjects = (...objects) => this.createExecutionFunction(['OPENED_LEVEL', 'WROTE_OBJECT'], async () => {
+            const stringified = objects.map(saveObj => JSON.stringify(saveObj));
+            for (const obj of stringified) {
+                await this.writer.write(`${this.formatTracker.levels.at(-1).objectCount >= 1 ? ', ' : ''}${obj}`);
+                this.formatTracker.levels.at(-1).objectCount++;
+            }
+        }, 'WROTE_OBJECT');
+        this.switchInLevelToCollectables = (...objects) => this.createExecutionFunction(['OPENED_LEVEL', 'WROTE_OBJECT'], async () => {
+            await this.writer.write(`], "collectables": [`);
+        }, 'SWITCH_TO_COLLECTABLES');
+        this.writeCollectables = (...collectables) => this.createExecutionFunction(['SWITCH_TO_COLLECTABLES', 'WROTE_COLLECTABLE'], async () => {
+            const stringified = collectables.map(coll => JSON.stringify(coll));
+            for (const obj of stringified) {
+                await this.writer.write(`${this.formatTracker.levels.at(-1).collectablesCount >= 1 ? ', ' : ''}${obj}`);
+                this.formatTracker.levels.at(-1).collectablesCount++;
+            }
+        }, 'WROTE_COLLECTABLE');
+        this.endLevel = () => this.createExecutionFunction(['SWITCH_TO_COLLECTABLES', 'WROTE_COLLECTABLE'], async () => {
+            await this.writer.write(`]}`);
+        }, 'FINISHED_LEVEL');
+        this.endLevels = () => this.createExecutionFunction(['OPENED_LEVELS', 'FINISHED_LEVEL'], async () => {
+            await this.writer.write(`]`);
+        }, 'FINISHED_LEVELS');
+        this.endSave = () => this.createExecutionFunction(['FINISHED_LEVELS'], async () => {
+            await this.writer.write('}');
+        }, 'FINISHED_SAVE');
         this.mode = 'BEFORE_START';
+        this.tracker = new ModeStateTracker(this.mode);
         this.formatTracker = {
             levels: []
         };
     }
-    async beginSave() {
-        if (this.mode !== 'BEFORE_START') {
-            throw new Error(`Wrong order of commands. Already opened save. mode is ${this.mode}.`);
-        }
-        await this.writer.write('{');
-        this.mode = 'OPENED_SAVE';
-    }
-    async writeHeader(header) {
-        if (this.mode !== 'OPENED_SAVE') {
-            throw new Error(`Wrong order of commands. Header has to come after save open. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`"header": ${JSON.stringify(header)}`);
-        this.mode = 'FINISHED_HEADER';
-    }
-    async writeCompressionInfo(compressionInfo) {
-        if (this.mode !== 'FINISHED_HEADER') {
-            throw new Error(`Wrong order of commands. Compression info has to come after header. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`, "compressionInfo": ${JSON.stringify(compressionInfo)}`);
-        this.mode = 'WROTE_COMPRESSION_INFO';
-    }
-    async writeGridHash(gridHash) {
-        if (this.mode !== 'WROTE_COMPRESSION_INFO') {
-            throw new Error(`Wrong order of commands. Save hbody hash has to come after compression info. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`, "gridHash": ${JSON.stringify(gridHash)}`);
-        this.mode = 'WROTE_GRID_HASH';
-    }
-    async writeGrids(grids) {
-        if (this.mode !== 'WROTE_GRID_HASH') {
-            throw new Error(`Wrong order of commands. Grids have to come after save body hash info. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`, "grids": ${JSON.stringify(grids)}`);
-        this.mode = 'WROTE_GRIDS';
-    }
-    async openLevels() {
-        if (this.mode !== 'WROTE_GRIDS') {
-            throw new Error(`Wrong order of commands. Levels have to come after grids info. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`, "levels": [`);
-        this.mode = 'OPENED_LEVELS';
-    }
-    async openLevel(levelName) {
-        if (this.mode !== 'OPENED_LEVELS' && this.mode !== 'FINISHED_LEVEL') {
-            throw new Error(`Wrong order of commands. Single level can only come after opening levels array or after finishing single level. mode is ${this.mode}.`);
-        }
-        this.formatTracker.levels.push({
-            objectCount: 0, collectablesCount: 0
-        });
-        const prefix = this.formatTracker.levels.length > 1 ? ', ' : '';
-        await this.writer.write(`${prefix}{"name": "${levelName}", "objects": [`);
-        this.mode = 'OPENED_LEVEL';
-    }
-    async writeObjects(...objects) {
-        if (this.mode !== 'OPENED_LEVEL' && this.mode !== 'WROTE_OBJECT') {
-            throw new Error(`Wrong order of commands. An object can not be written into the level if it was not opened or other objects were not written. mode is ${this.mode}.`);
-        }
-        const stringified = objects.map(saveObj => JSON.stringify(saveObj));
-        for (const obj of stringified) {
-            await this.writer.write(`${this.formatTracker.levels.at(-1).objectCount >= 1 ? ', ' : ''}${obj}`);
-            this.formatTracker.levels.at(-1).objectCount++;
-        }
-        this.mode = 'WROTE_OBJECT';
-    }
-    async switchInLevelToCollectables() {
-        if (this.mode !== 'OPENED_LEVEL' && this.mode !== 'WROTE_OBJECT') {
-            throw new Error(`Wrong order of commands. The level structure can not be switched to collectables if the level was not opened recently or has not written objects. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`], "collectables": [`);
-        this.mode = 'SWITCH_TO_COLLECTABLES';
-    }
-    async writeCollectables(...collectables) {
-        if (this.mode !== 'SWITCH_TO_COLLECTABLES' && this.mode !== 'WROTE_COLLECTABLE') {
-            throw new Error(`Wrong order of commands. A  collectable can not be written into the level if we did not switch to collectables or other collectables were not written. mode is ${this.mode}.`);
-        }
-        const stringified = collectables.map(coll => JSON.stringify(coll));
-        for (const obj of stringified) {
-            await this.writer.write(`${this.formatTracker.levels.at(-1).collectablesCount >= 1 ? ', ' : ''}${obj}`);
-            this.formatTracker.levels.at(-1).collectablesCount++;
-        }
-        this.mode = 'WROTE_COLLECTABLE';
-    }
-    async endLevel() {
-        if (this.mode !== 'SWITCH_TO_COLLECTABLES' && this.mode !== 'WROTE_COLLECTABLE') {
-            throw new Error(`Wrong order of commands. Single level can not be closed if a switch to collectibles or writing of collectible did not happen. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`]}`);
-        this.mode = 'FINISHED_LEVEL';
-    }
-    async endLevels() {
-        if (this.mode !== 'OPENED_LEVELS' && this.mode !== 'FINISHED_LEVEL') {
-            throw new Error(`Wrong order of commands. Levels can only be closed after opening levels array or after finishing single level. mode is ${this.mode}.`);
-        }
-        await this.writer.write(`]`);
-        this.mode = 'FINISHED_LEVELS';
-    }
-    async endSave() {
-        if (this.mode !== 'FINISHED_LEVELS') {
-            throw new Error(`Wrong order of commands. Save has to end after levels. mode is ${this.mode}.`);
-        }
-        await this.writer.write('}');
-        this.mode = 'FINISHED_SAVE';
-    }
     async close() {
         return this.writer.close();
     }

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.1.22",
+	"version": "0.1.25",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
 	"types": "./build/index.d.ts",
 	"main": "./build/index.js",

package/build/parser/satisfactory/objects/ue/FMD5Hash.d.ts

@@ -1,7 +0,0 @@
-import { ByteReader, ByteWriter } from '../../../..';
-export type MD5Hash = {
-    isValid: boolean;
-    hash?: number[];
-};
-export declare const readMD5Hash: (reader: ByteReader) => MD5Hash;
-export declare const writeMD5Hash: (writer: ByteWriter, md5Hash: MD5Hash) => void;

package/build/parser/satisfactory/objects/ue/FMD5Hash.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeMD5Hash = exports.readMD5Hash = void 0;
-const readMD5Hash = (reader) => {
-    const md5Hash = { isValid: false };
-    md5Hash.isValid = reader.readInt32() === 1;
-    if (md5Hash.isValid) {
-        md5Hash.hash = Array.from(reader.readBytes(16));
-    }
-    return md5Hash;
-};
-exports.readMD5Hash = readMD5Hash;
-const writeMD5Hash = (writer, md5Hash) => {
-    writer.writeInt32(md5Hash.isValid ? 1 : 0);
-    if (md5Hash.isValid) {
-        writer.writeBytesArray(md5Hash.hash);
-    }
-};
-exports.writeMD5Hash = writeMD5Hash;