@etothepii/satisfactory-file-parser 0.0.31 → 0.0.33

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

@@ -0,0 +1,131 @@
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "pako", "../..", "../byte/alignment.enum", "./byte-stream-reader.class", "./stream-level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveStreamReader = void 0;
+    const pako_1 = __importDefault(require("pako"));
+    const __1 = require("../..");
+    const alignment_enum_1 = require("../byte/alignment.enum");
+    const byte_stream_reader_class_1 = require("./byte-stream-reader.class");
+    const stream_level_class_1 = require("./stream-level.class");
+    class SaveStreamReader extends byte_stream_reader_class_1.ByteStreamReader {
+        constructor(reader, maxBufferThreshold, onCloseCallback = async () => { }) {
+            super(reader, onCloseCallback, 30000, maxBufferThreshold, alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.compressionInfo = {
+                packageFileTag: 0,
+                maxChunkContentSize: 0,
+                chunkHeaderSize: SaveStreamReader.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
+            };
+        }
+        async readHeader() {
+            const header = {
+                saveHeaderType: 0,
+                saveVersion: 0,
+                buildVersion: 0,
+                mapName: "DEFAULT",
+                mapOptions: "",
+                sessionName: "",
+                playDurationSeconds: 0,
+                saveDateTime: "0",
+                sessionVisibility: 0
+            };
+            await this.allocate(400);
+            console.log(`safely reading header stuff now. ${this.currentByte} ${this.operatingDataView.byteLength} ${this.operatingStreamBuffer.byteLength}`);
+            header.saveHeaderType = this.readInt32();
+            header.saveVersion = this.readInt32();
+            header.buildVersion = this.readInt32();
+            header.mapName = this.readString();
+            header.mapOptions = this.readString();
+            header.sessionName = this.readString();
+            header.playDurationSeconds = this.readInt32();
+            const rawSaveDateTimeInTicks = this.readLong();
+            const unixMilliseconds = (rawSaveDateTimeInTicks - SaveStreamReader.EPOCH_TICKS) / 10000n;
+            header.saveDateTime = unixMilliseconds.toString();
+            header.sessionVisibility = this.readByte();
+            if (header.saveHeaderType >= 7) {
+                header.fEditorObjectVersion = this.readInt32();
+            }
+            if (header.saveHeaderType >= 8) {
+                header.rawModMetadataString = this.readString();
+                try {
+                    header.modMetadata = JSON.parse(header.rawModMetadataString);
+                }
+                catch (error) {
+                }
+                header.isModdedSave = this.readInt32();
+            }
+            if (header.saveHeaderType >= 10) {
+                header.saveIdentifier = this.readString();
+            }
+            if (header.saveVersion >= 21) {
+            }
+            else {
+                throw new __1.UnsupportedVersionError("The save version is too old to support encoding currently. Save in newer game version.");
+            }
+            return header;
+        }
+        async readBodyChunk() {
+            await this.allocate(this.compressionInfo.chunkHeaderSize);
+            this.operatingStreamBuffer = this.operatingStreamBuffer.slice(this.currentByte);
+            this.operatingDataView = new DataView(this.operatingStreamBuffer.buffer);
+            this.currentByte = 0;
+            if (this.compressionInfo.packageFileTag <= 0) {
+                this.compressionInfo.packageFileTag = this.operatingDataView.getInt32(0, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            if (this.compressionInfo.maxChunkContentSize <= 0) {
+                this.compressionInfo.maxChunkContentSize = this.operatingDataView.getInt32(8, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            }
+            const chunkCompressedLength = this.operatingDataView.getInt32(32, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            const chunkUncompressedLength = this.operatingDataView.getInt32(40, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+            this.currentByte = this.compressionInfo.chunkHeaderSize;
+            await this.allocate(chunkCompressedLength);
+            let currentChunk = this.operatingStreamBuffer.slice(this.currentByte, this.currentByte + chunkCompressedLength);
+            this.currentByte += chunkCompressedLength;
+            this.totalNumberOfBytesRead += chunkUncompressedLength;
+            try {
+                const uncompressedChunk = pako_1.default.inflate(currentChunk);
+                if (uncompressedChunk.byteLength !== chunkUncompressedLength) {
+                    throw new __1.CorruptSaveError('indicated save body chunk size does not match the inflated result. Save is possibly corrupt.');
+                }
+                if (this.debug) {
+                    console.log(`${new Date().toString()}: decompressed a chunk from ${currentChunk.byteLength} to ${uncompressedChunk.byteLength} bytes.`);
+                }
+                return uncompressedChunk;
+            }
+            catch (err) {
+                throw new __1.CompressionLibraryError("Failed to inflate compressed save data. " + err);
+            }
+        }
+        debugInfo() {
+            return `operating buffer size is ${this.operatingStreamBuffer.byteLength}/${this.operatingDataView.byteLength}, at ${this.currentByte} means ${this.getBufferPosition()} pos, with ${this.operatingStreamBuffer.byteLength - this.currentByte} left until end of operating buffer.`;
+        }
+        async streamLevelsToOutput(writer, header) {
+            if (header.saveVersion < 29) {
+                throw new __1.UnsupportedVersionError('Support for < U6 is not yet implemented.');
+            }
+            await this.allocate(100);
+            const numSubLevels = this.readInt32();
+            for (let j = 0; j <= numSubLevels; j++) {
+                let levelName = (j === numSubLevels) ? '' + header.mapName : this.readString();
+                if (this.debug) {
+                    console.log(`${new Date().toString()}: reading level [${(j)}/${numSubLevels}] ${levelName}`);
+                }
+                await stream_level_class_1.StreamLevel.ReadLevelAsync(this, writer, levelName, header.buildVersion);
+            }
+            return;
+        }
+    }
+    SaveStreamReader.EPOCH_TICKS = 621355968000000000n;
+    SaveStreamReader.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
+    exports.SaveStreamReader = SaveStreamReader;
+});

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

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { WritableStreamDefaultWriter } from "stream/web";
+import { ChunkCompressionInfo, ObjectReference, SatisfactorySaveHeader } from "../..";
+import { SaveObject } from "../satisfactory/objects/SaveObject";
+export declare class SaveStreamWriter {
+    private writer;
+    private mode;
+    private formatTracker;
+    constructor(writer: WritableStreamDefaultWriter<string>);
+    beginSave(): Promise<void>;
+    writeHeader(header: SatisfactorySaveHeader): Promise<void>;
+    writeCompressionInfo(compressionInfo: ChunkCompressionInfo): 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>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,115 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaveStreamWriter = void 0;
+    class SaveStreamWriter {
+        constructor(writer) {
+            this.writer = writer;
+            this.mode = 'BEFORE_START';
+            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 openLevels() {
+            if (this.mode !== 'WROTE_COMPRESSION_INFO') {
+                throw new Error(`Wrong order of commands. Levels have to come after compression 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();
+        }
+    }
+    exports.SaveStreamWriter = SaveStreamWriter;
+});

package/build/parser/stream/stream-level.class.d.ts

@@ -0,0 +1,12 @@
+import { BinaryReadable } from "../byte/binary-readable.interface";
+import { SaveComponentHeader } from "../satisfactory/objects/SaveComponent";
+import { SaveEntityHeader } from "../satisfactory/objects/SaveEntity";
+import { SaveStreamReader } from "./save-stream-reader.class";
+import { SaveStreamWriter } from "./save-stream-writer.class";
+export declare class StreamLevel {
+    name: string;
+    constructor(name: string);
+    static ReadLevelAsync(reader: SaveStreamReader, writer: SaveStreamWriter, levelName: string, buildVersion: number): Promise<void>;
+    static ReadObjectHeaders(reader: BinaryReadable): (SaveEntityHeader | SaveComponentHeader)[];
+    static StreamObjectContentsAsync(reader: SaveStreamReader, writer: SaveStreamWriter, headerList: (SaveEntityHeader | SaveComponentHeader)[], buildVersion: number): Promise<void>;
+}

package/build/parser/stream/stream-level.class.js

@@ -0,0 +1,113 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "../..", "../satisfactory/objects/SaveComponent", "../satisfactory/objects/SaveEntity"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.StreamLevel = void 0;
+    const __1 = require("../..");
+    const SaveComponent_1 = require("../satisfactory/objects/SaveComponent");
+    const SaveEntity_1 = require("../satisfactory/objects/SaveEntity");
+    class StreamLevel {
+        constructor(name) {
+            this.name = name;
+        }
+        static async ReadLevelAsync(reader, writer, levelName, buildVersion) {
+            const binaryLength = reader.readInt32();
+            await reader.allocate(binaryLength);
+            const objectHeaders = StreamLevel.ReadObjectHeaders(reader);
+            const collectables = __1.Level.ReadCollectablesList(reader);
+            await writer.openLevel(levelName);
+            await StreamLevel.StreamObjectContentsAsync(reader, writer, objectHeaders, buildVersion);
+            await writer.switchInLevelToCollectables();
+            await writer.writeCollectables(...collectables);
+            await writer.endLevel();
+            __1.Level.ReadCollectablesList(reader);
+            return;
+        }
+        static ReadObjectHeaders(reader) {
+            let countObjectHeaders = reader.readInt32();
+            const headers = [];
+            for (let i = 0; i < countObjectHeaders; i++) {
+                let objectType = reader.readInt32();
+                switch (objectType) {
+                    case 1:
+                        headers.push({
+                            typePath: reader.readString(),
+                            rootObject: reader.readString(),
+                            instanceName: reader.readString(),
+                            needTransform: reader.readInt32() == 1,
+                            transform: (0, __1.ParseTransform)(reader),
+                            wasPlacedInLevel: reader.readInt32() == 1
+                        });
+                        break;
+                    case 0:
+                        headers.push({
+                            typePath: reader.readString(),
+                            rootObject: reader.readString(),
+                            instanceName: reader.readString(),
+                            parentEntityName: reader.readString()
+                        });
+                        break;
+                    default:
+                        console.log('Unknown object type', objectType);
+                        break;
+                }
+            }
+            return headers;
+        }
+        static async StreamObjectContentsAsync(reader, writer, headerList, buildVersion) {
+            const binarySize = reader.readInt32();
+            const posBefore = reader.getBufferPosition();
+            await reader.allocate(Math.min(binarySize, 300 * 1000 * 1000));
+            const countEntities = reader.readInt32();
+            if (countEntities !== headerList.length) {
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not object count of ${headerList.length}`);
+            }
+            let bufferedObjects = [];
+            for (let i = 0; i < countEntities; i++) {
+                if ((i + 1) % 10000 === 0) {
+                    await writer.writeObjects(...bufferedObjects);
+                    bufferedObjects = [];
+                }
+                const len = reader.readInt32();
+                if (reader.getAmountAllocatedLeft() <= len) {
+                    const allocateAmount = Math.min(binarySize - (reader.getBufferPosition() - posBefore) + 4, 300 * 1000 * 1000);
+                    await reader.allocate(allocateAmount);
+                }
+                const before = reader.getBufferPosition();
+                const obj = headerList.shift();
+                if (!obj) {
+                    throw new Error();
+                }
+                const isComponent = obj.parentEntityName !== undefined;
+                if (!isComponent) {
+                    const entity = new SaveEntity_1.SaveEntity(obj.typePath, obj.rootObject, obj.instanceName, '', obj.needTransform);
+                    SaveEntity_1.SaveEntity.ParseData(entity, len, reader, buildVersion, obj.typePath);
+                    bufferedObjects.push(entity);
+                }
+                else if (isComponent) {
+                    const component = new SaveComponent_1.SaveComponent(obj.typePath, obj.rootObject, obj.instanceName, obj.parentEntityName);
+                    SaveComponent_1.SaveComponent.ParseData(component, len, reader, buildVersion, obj.typePath);
+                    bufferedObjects.push(component);
+                }
+                const after = reader.getBufferPosition();
+                if (after - before !== len) {
+                    console.warn('entity may be corrupt.', i);
+                }
+            }
+            await writer.writeObjects(...bufferedObjects);
+            bufferedObjects = [];
+            const posAfter = reader.getBufferPosition();
+            if (posAfter - posBefore !== binarySize) {
+                console.warn('save seems corrupt.', this.name);
+            }
+        }
+    }
+    exports.StreamLevel = StreamLevel;
+});

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.0.31",
+	"version": "0.0.33",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
 	"types": "./build/index.d.ts",
 	"main": "./build/index.js",
@@ -34,6 +34,8 @@
 		"@types/pako": "^2.0.0",
 		"dts-bundle-generator": "^8.0.0",
 		"jest": "^29.5.0",
+		"json-stream-stringify": "^3.0.1",
+		"JSONStream": "^1.3.5",
 		"npm-dts": "^1.3.12",
 		"ts-jest": "^29.0.5",
 		"ts-loader": "^9.4.2",