@etothepii/satisfactory-file-parser 0.0.10 → 0.0.11

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

@@ -0,0 +1,22 @@
+import { Alignment } from "./byte/alignment.enum";
+import { ByteWriter } from "./byte/byte-writer.class";
+import { ChunkCompressionInfo, SatisfactorySave, SatisfactorySaveHeader } from "./satisfactory/satisfactory-save";
+export declare class SaveWriter extends ByteWriter {
+    constructor();
+    static WriteHeader(writer: ByteWriter, header: SatisfactorySaveHeader): void;
+    static WriteLevels(writer: ByteWriter, save: SatisfactorySave, buildVersion: number): void;
+    static GenerateCompressedChunksFromData(bufferArray: ArrayBuffer, compressionInfo: ChunkCompressionInfo, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void, alignment?: Alignment): void;
+    generateChunks(compressionInfo: ChunkCompressionInfo, posAfterHeader: number, onBinaryBeforeCompressing: (binary: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void): void;
+}

package/build/parser/save-writer.js

@@ -0,0 +1,114 @@
+import Pako from "pako";
+import { Alignment } from "./byte/alignment.enum";
+import { ByteWriter } from "./byte/byte-writer.class";
+import { ParserError, UnsupportedVersionError } from "./error/parser.error";
+import { Level } from "./satisfactory/level.class";
+export class SaveWriter extends ByteWriter {
+    constructor() {
+        super(Alignment.LITTLE_ENDIAN);
+    }
+    static WriteHeader(writer, header) {
+        writer.writeInt32(header.saveHeaderType);
+        writer.writeInt32(header.saveVersion);
+        writer.writeInt32(header.buildVersion);
+        writer.writeString(header.mapName);
+        writer.writeString(header.mapOptions);
+        writer.writeString(header.sessionName);
+        writer.writeInt32(header.playDurationSeconds);
+        writer.writeInt64(BigInt(header.saveDateTime));
+        writer.writeByte(header.sessionVisibility);
+        if (header.saveHeaderType >= 7) {
+            writer.writeInt32(header.fEditorObjectVersion);
+        }
+        if (header.saveHeaderType >= 8) {
+            if (header.modMetadata) {
+                writer.writeString(JSON.stringify(header.modMetadata));
+            }
+            else {
+                writer.writeString(header.rawModMetadataString);
+            }
+            writer.writeInt32(header.isModdedSave);
+        }
+        if (header.saveHeaderType >= 10) {
+            writer.writeString(header.saveIdentifier);
+        }
+        if (header.saveVersion >= 21) {
+            // ready to write levels now.
+        }
+        else {
+            throw new UnsupportedVersionError("The save version is too old to be supported currently.");
+        }
+    }
+    static WriteLevels(writer, save, buildVersion) {
+        writer.writeInt32(save.levels.length - 1);
+        for (const level of save.levels) {
+            if (level.name !== save.header.mapName) {
+                writer.writeString(level.name);
+            }
+            Level.WriteLevel(writer, level, buildVersion);
+        }
+        Level.SerializeCollectablesList(writer, save.trailingCollectedObjects);
+    }
+    static GenerateCompressedChunksFromData(bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, alignment = Alignment.LITTLE_ENDIAN) {
+        const errors = [];
+        const totalUncompressedSize = bufferArray.byteLength;
+        const saveBody = new Uint8Array(bufferArray.byteLength + 4);
+        saveBody.set(new Uint8Array(bufferArray), 4);
+        const miniView = new DataView(saveBody.buffer);
+        miniView.setInt32(0, totalUncompressedSize, alignment === Alignment.LITTLE_ENDIAN);
+        onBinaryBeforeCompressing(saveBody.buffer);
+        // collect slices of chunks with help of compression info for max chunk size
+        let handledByte = 0;
+        const chunkSummary = [];
+        while (handledByte < saveBody.byteLength) {
+            // create uncompressed chunk.
+            const uncompressedContentSize = Math.min(compressionInfo.maxChunkContentSize, saveBody.byteLength - handledByte);
+            const uncompressedChunk = saveBody.buffer.slice(handledByte, handledByte + uncompressedContentSize);
+            // deflate chunk while we're at it.
+            let compressedChunk = new Uint8Array(0);
+            try {
+                compressedChunk = Pako.deflate(uncompressedChunk);
+            }
+            catch (err) {
+                errors.push("An error occurred while calling pako deflate. -> " + err);
+            }
+            const chunk = new Uint8Array(compressionInfo.chunkHeaderSize + compressedChunk.byteLength);
+            chunk.set(compressedChunk, compressionInfo.chunkHeaderSize);
+            // write header
+            const view = new DataView(chunk.buffer);
+            view.setInt32(0, compressionInfo.packageFileTag, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(4, 0, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(8, compressionInfo.maxChunkContentSize, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(12, 0, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(16, compressedChunk.byteLength, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(20, 0, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(24, uncompressedContentSize, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(28, 0, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(32, compressedChunk.byteLength, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(36, 0, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(40, uncompressedContentSize, alignment === Alignment.LITTLE_ENDIAN);
+            view.setInt32(44, 0, alignment === Alignment.LITTLE_ENDIAN);
+            onChunk(chunk);
+            chunkSummary.push({
+                uncompressedSize: uncompressedContentSize + compressionInfo.chunkHeaderSize,
+                compressedSize: compressedChunk.byteLength + compressionInfo.chunkHeaderSize
+            });
+            handledByte += uncompressedContentSize;
+        }
+        onFinish({
+            errors,
+            chunkSummary
+        });
+    }
+    generateChunks(compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
+        if (posAfterHeader <= 0) {
+            throw new ParserError('ParserError', 'Seems like this buffer has no header. Please write the header first before you can generate chunks.');
+        }
+        // send plain header first.
+        const header = new Uint8Array(this.bufferArray.slice(0, posAfterHeader));
+        onHeader(header);
+        // create save body
+        this.bufferArray = this.bufferArray.slice(posAfterHeader);
+        SaveWriter.GenerateCompressedChunksFromData(this.bufferArray, compressionInfo, onBinaryBeforeCompressing, onChunk, onFinish, this.alignment);
+    }
+}

package/package.json

@@ -1,9 +1,10 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.0.10",
+	"version": "0.0.11",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
-	"main": "index.js",
+	"main": "build/index.js",
+	"type": "module",
 	"keywords": [
 		"satisfactory",
 		"save",
@@ -15,7 +16,7 @@
 	"scripts": {
 		"test": "jest --config=jest.config.json",
 		"build": "tsc",
-		"prepublish": "rollup -c && npm version patch"
+		"prepublish": "npm version patch"
 	},
 	"repository": {
 		"type": "git",