@etothepii/satisfactory-file-parser 0.0.10 → 0.0.12

package/build/parser/byte/byte-writer.class.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ByteWriter = void 0;
+const alignment_enum_1 = require("./alignment.enum");
+class ByteWriter {
+    constructor(alignment, bufferSize = 500) {
+        this.getBufferPosition = () => this.currentByte;
+        this.getBufferSlice = (start, end) => this.bufferArray.slice(start, end);
+        this.alignment = alignment;
+        this.bufferArray = new ArrayBuffer(bufferSize);
+        this.bufferView = new DataView(this.bufferArray);
+        this.currentByte = 0;
+    }
+    /*
+     * Byte Manipulation
+     */
+    skipBytes(count = 1) {
+        this.extendBufferIfNeeded(count);
+        this.currentByte += count;
+    }
+    jumpTo(pos) {
+        const count = pos - this.getBufferPosition();
+        this.skipBytes(count);
+    }
+    writeByte(value) {
+        this.extendBufferIfNeeded(1);
+        this.bufferView.setUint8(this.currentByte, value);
+        this.currentByte += 1;
+    }
+    writeBytesArray(bytes) {
+        this.writeBytes(new Uint8Array(bytes));
+    }
+    writeBytes(bytes) {
+        this.extendBufferIfNeeded(bytes.length);
+        bytes.forEach(byte => this.bufferView.setUint8(this.currentByte++, byte));
+    }
+    writeInt8(value) {
+        this.extendBufferIfNeeded(1);
+        this.bufferView.setInt8(this.currentByte, value);
+        this.currentByte += 1;
+    }
+    writeUint8(value) {
+        this.writeByte(value);
+    }
+    writeInt16(value) {
+        this.extendBufferIfNeeded(2);
+        this.bufferView.setInt16(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+    }
+    writeUint16(value) {
+        this.extendBufferIfNeeded(2);
+        this.bufferView.setUint16(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 2;
+    }
+    writeInt32(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setInt32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeUint32(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setUint32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeInt64(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setBigInt64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeUint64(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setBigUint64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeFloat(value) {
+        this.extendBufferIfNeeded(4);
+        this.bufferView.setFloat32(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 4;
+    }
+    writeDouble(value) {
+        this.extendBufferIfNeeded(8);
+        this.bufferView.setFloat64(this.currentByte, value, this.alignment === alignment_enum_1.Alignment.LITTLE_ENDIAN);
+        this.currentByte += 8;
+    }
+    writeString(value) {
+        if (value.length === 0) {
+            this.writeInt32(0);
+            return;
+        }
+        // if it's safe to use ASCII, use UTF8.
+        if (ByteWriter.IsASCIICompatible(value)) {
+            this.writeInt32(value.length + 1);
+            for (let i = 0; i < value.length; i++) {
+                this.writeByte(value.charCodeAt(i));
+            }
+            this.writeUint8(0);
+        }
+        // write UTF16
+        else {
+            this.writeInt32(-value.length - 1);
+            for (let i = 0; i < value.length; i++) {
+                this.writeUint16(value.charCodeAt(i));
+            }
+            this.writeUint16(0);
+        }
+    }
+    writeBinarySizeFromPosition(lenIndicatorPos, start) {
+        const after = this.getBufferPosition();
+        const writtenBytes = after - start;
+        this.jumpTo(lenIndicatorPos);
+        this.writeInt32(writtenBytes);
+        this.jumpTo(after);
+    }
+    /**
+     * automatically extends the current buffer if the given space exceeds the available rest capacity of the current buffer.
+     * @param countNeededBytes the needed space
+     * @param factor how big the appended buffer should be in comparison to the current one. Values >= 1 make sense.
+     */
+    extendBufferIfNeeded(countNeededBytes, factor = 1.5) {
+        if (this.currentByte + countNeededBytes > this.bufferView.byteLength) {
+            this.bufferArray = ByteWriter.AppendBuffer(this.bufferArray, new ArrayBuffer(factor * this.bufferArray.byteLength));
+            this.bufferView = new DataView(this.bufferArray);
+        }
+    }
+    truncateBuffer() {
+        this.bufferArray = this.bufferArray.slice(0, this.currentByte);
+    }
+    endWriting() {
+        this.truncateBuffer();
+        return this.bufferArray;
+    }
+    static ToInt32(num) {
+        return new Uint8Array([
+            (num & 0xff000000) >> 24,
+            (num & 0x00ff0000) >> 16,
+            (num & 0x0000ff00) >> 8,
+            (num & 0x000000ff)
+        ]);
+    }
+    static AppendBuffer(buffer1, buffer2) {
+        var tmp = new Uint8Array(buffer1.byteLength + buffer2.byteLength);
+        tmp.set(new Uint8Array(buffer1), 0);
+        tmp.set(new Uint8Array(buffer2), buffer1.byteLength);
+        return tmp.buffer;
+    }
+    ;
+}
+ByteWriter.IsASCIICompatible = (value) => /^[\x00-\x7F]*$/.test(value);
+exports.ByteWriter = ByteWriter;

package/build/parser/error/parser.error.d.ts

@@ -0,0 +1,12 @@
+export declare class ParserError extends Error {
+    constructor(name: string, message: string);
+}
+export declare class UnsupportedVersionError extends ParserError {
+    constructor(message?: string);
+}
+export declare class CorruptSaveError extends ParserError {
+    constructor(message?: string);
+}
+export declare class CompressionLibraryError extends ParserError {
+    constructor(message?: string);
+}

package/build/parser/error/parser.error.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompressionLibraryError = exports.CorruptSaveError = exports.UnsupportedVersionError = exports.ParserError = void 0;
+class ParserError extends Error {
+    constructor(name, message) {
+        super(message);
+        this.name = name;
+    }
+}
+exports.ParserError = ParserError;
+class UnsupportedVersionError extends ParserError {
+    constructor(message) {
+        super('UnsupportedVersionError', message ?? 'This save version is not supported.');
+    }
+}
+exports.UnsupportedVersionError = UnsupportedVersionError;
+class CorruptSaveError extends ParserError {
+    constructor(message) {
+        super('CorruptSaveError', message ?? 'This save data is most likely corrupt.');
+    }
+}
+exports.CorruptSaveError = CorruptSaveError;
+class CompressionLibraryError extends ParserError {
+    constructor(message) {
+        super('CompressionLibraryError', message ?? 'Failed to compress/decompress save data.');
+    }
+}
+exports.CompressionLibraryError = CompressionLibraryError;

package/build/parser/parser.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+import { SatisfactorySave } from "./satisfactory/satisfactory-save";
+import { SaveProjectionConfig } from "./save-reader";
+export declare class SaveParser {
+    /**
+     * serializes a save file into binary and reports back on individual callbacks.
+     * @param save the save file to serialize into binary.
+     * @param onBinaryBeforeCompressing gets called on the binary save body before it is compressed.
+     * @param onHeader gets called on the binary save header, which is always uncompressed.
+     * @param onChunk gets called when a chunk of the compressed save body was generated. Often, files' save bodies consist of multiple chunks.
+     * @param onFinish gets called when all chunks have been generated. A summary of the chunk sizes and count is reported.
+     */
+    static WriteSave(save: SatisfactorySave, onBinaryBeforeCompressing: (buffer: ArrayBuffer) => void, onHeader: (header: Uint8Array) => void, onChunk: (chunk: Uint8Array) => void, onFinish: (summary: {
+        errors: string[];
+        chunkSummary: {
+            uncompressedSize: number;
+            compressedSize: number;
+        }[];
+    }) => void): void;
+    /**
+     * parses a save object from a binary buffer and reports back on decompressing the save body in a callback.
+     * @param file the binary content to be parsed.
+     * @param additionalData additional static data that is not contained in save files. For example, power slugs and resource nodes.
+     * @param onSaveDecompressed gets called when the entire binary save body has been decompressed.
+     * @returns a brief summary
+     */
+    static ParseSaveFile(file: Buffer, onSaveDecompressed?: (buffer: ArrayBuffer) => void, onProgress?: (progress: number, message?: string) => void): SatisfactorySave;
+    /**
+     * Does Projection on a Save Object in order to reduce it's complexity.
+     * @param save the save object in question.
+     * @param config the projection config to apply.
+     * @returns a save object that has been projected / modified. Do not try to serialize it into an actual save tho! Since information has been transformed.
+     */
+    static ProjectSave(save: SatisfactorySave, config: SaveProjectionConfig): SatisfactorySave;
+    /**
+     * It JSON.stringifies any parsed content safely. The original JSON.stringify() has some flaws that get in the way, so it is custom wrapped. The original has some problems:
+     * 1. it cannot stringify bigints. So we help out by converting it into a string.
+     * 2. It cannot distinguish between 0 and -0. But a float32 is encoded in a uint8Array for 0 to be [0,0,0,0] (0x00000000) and -0 to be [0,0,0,128] (0x00000080) in little endian.
+     * @param obj
+     * @param indent
+     * @returns a string that is safely stringified.
+     */
+    static JSONStringifyModified: (obj: any, indent?: number) => string;
+}

package/build/parser/parser.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveParser = void 0;
+const level_class_1 = require("./satisfactory/level.class");
+const satisfactory_save_1 = require("./satisfactory/satisfactory-save");
+const save_reader_1 = require("./save-reader");
+const save_writer_1 = require("./save-writer");
+class SaveParser {
+    /**
+     * serializes a save file into binary and reports back on individual callbacks.
+     * @param save the save file to serialize into binary.
+     * @param onBinaryBeforeCompressing gets called on the binary save body before it is compressed.
+     * @param onHeader gets called on the binary save header, which is always uncompressed.
+     * @param onChunk gets called when a chunk of the compressed save body was generated. Often, files' save bodies consist of multiple chunks.
+     * @param onFinish gets called when all chunks have been generated. A summary of the chunk sizes and count is reported.
+     */
+    static WriteSave(save, onBinaryBeforeCompressing, onHeader, onChunk, onFinish) {
+        const writer = new save_writer_1.SaveWriter();
+        save_writer_1.SaveWriter.WriteHeader(writer, save.header);
+        const posAfterHeader = writer.getBufferPosition();
+        save_writer_1.SaveWriter.WriteLevels(writer, save, save.header.buildVersion);
+        writer.endWriting();
+        writer.generateChunks(save.compressionInfo, posAfterHeader, onBinaryBeforeCompressing, onHeader, onChunk, onFinish);
+    }
+    /**
+     * parses a save object from a binary buffer and reports back on decompressing the save body in a callback.
+     * @param file the binary content to be parsed.
+     * @param additionalData additional static data that is not contained in save files. For example, power slugs and resource nodes.
+     * @param onSaveDecompressed gets called when the entire binary save body has been decompressed.
+     * @returns a brief summary
+     */
+    static ParseSaveFile(file, onSaveDecompressed = () => { }, onProgress = () => { }) {
+        const reader = new save_reader_1.SaveReader(file.buffer, onProgress);
+        // read header
+        const header = reader.readHeader();
+        const save = new satisfactory_save_1.SatisfactorySave(header);
+        // inflate chunks
+        const inflateResult = reader.inflateChunks();
+        // call callback on decompressed save body
+        onSaveDecompressed(reader.getBuffer());
+        // parse levels
+        const levelParseResult = reader.readLevels();
+        save.levels = reader.levels;
+        save.compressionInfo = reader.compressionInfo;
+        save.trailingCollectedObjects = reader.trailingCollectedObjects;
+        return save;
+    }
+    /**
+     * Does Projection on a Save Object in order to reduce it's complexity.
+     * @param save the save object in question.
+     * @param config the projection config to apply.
+     * @returns a save object that has been projected / modified. Do not try to serialize it into an actual save tho! Since information has been transformed.
+     */
+    static ProjectSave(save, config) {
+        return {
+            header: save.header,
+            trailingCollectedObjects: save.trailingCollectedObjects,
+            levels: save.levels.map(level => {
+                const lvl = new level_class_1.Level(level.name);
+                lvl.collectables = level.collectables;
+                lvl.objects = level.objects.filter(obj => (0, save_reader_1.projectionFilterApplies)(config, obj));
+                return lvl;
+            })
+        };
+    }
+}
+/**
+ * It JSON.stringifies any parsed content safely. The original JSON.stringify() has some flaws that get in the way, so it is custom wrapped. The original has some problems:
+ * 1. it cannot stringify bigints. So we help out by converting it into a string.
+ * 2. It cannot distinguish between 0 and -0. But a float32 is encoded in a uint8Array for 0 to be [0,0,0,0] (0x00000000) and -0 to be [0,0,0,128] (0x00000080) in little endian.
+ * @param obj
+ * @param indent
+ * @returns a string that is safely stringified.
+ */
+SaveParser.JSONStringifyModified = (obj, indent = 0) => JSON.stringify(obj, (key, value) => {
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    else if (value === 0 && 1 / value < 0) { // -0
+        return '-0';
+    }
+    return value;
+}, indent);
+exports.SaveParser = SaveParser;

package/build/parser/satisfactory/blueprint/blueprint.d.ts

@@ -0,0 +1,20 @@
+import { SaveComponent } from "../objects/SaveComponent";
+import { SaveEntity } from "../objects/SaveEntity";
+import { ChunkCompressionInfo } from "../satisfactory-save";
+import { col4 } from "../structs/util.types";
+export interface BlueprintConfig {
+    description: string;
+    color: col4;
+    iconID: number;
+}
+export type BlueprintHeader = {
+    itemCosts: [string, number][];
+    recipeReferences: string[];
+};
+export interface Blueprint {
+    name: string;
+    compressionInfo: ChunkCompressionInfo;
+    header: BlueprintHeader;
+    config: BlueprintConfig;
+    objects: (SaveEntity | SaveComponent)[];
+}

package/build/parser/satisfactory/blueprint/blueprint.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/parser/satisfactory/level.class.d.ts

@@ -0,0 +1,21 @@
+import { ByteReader } from "../byte/byte-reader.class";
+import { ByteWriter } from "../byte/byte-writer.class";
+import { SaveReader } from "../save-reader";
+import { ObjectReference } from "./objects/ObjectReference";
+import { SaveComponent } from "./objects/SaveComponent";
+import { SaveEntity } from "./objects/SaveEntity";
+import { SaveObject } from "./objects/SaveObject";
+export declare class Level {
+    name: string;
+    objects: (SaveEntity | SaveComponent)[];
+    collectables: ObjectReference[];
+    constructor(name: string);
+    static SerializeObjectHeaders(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[]): void;
+    static WriteLevel(writer: ByteWriter, level: Level, buildVersion: number): void;
+    static SerializeObjectContents(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[], buildVersion: number): void;
+    static ReadObjectHeaders(reader: ByteReader, objectsList: SaveObject[], onProgressCallback: (progress: number, msg?: string) => void): void;
+    static ReadObjectContents(reader: ByteReader, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): void;
+    static ReadLevel(reader: SaveReader, levelName: string, buildVersion: number): Level;
+    static SerializeCollectablesList(writer: ByteWriter, collectables: ObjectReference[]): void;
+    static ReadCollectablesList(reader: SaveReader): ObjectReference[];
+}

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Level = void 0;
+const ObjectReference_1 = require("./objects/ObjectReference");
+const SaveComponent_1 = require("./objects/SaveComponent");
+const SaveEntity_1 = require("./objects/SaveEntity");
+class Level {
+    constructor(name) {
+        this.name = name;
+        this.objects = [];
+        this.collectables = [];
+    }
+    static SerializeObjectHeaders(writer, objects) {
+        writer.writeInt32(objects.length);
+        for (const obj of objects) {
+            switch (obj.type) {
+                case 'SaveEntity':
+                    writer.writeInt32(SaveEntity_1.SaveEntity.TypeID);
+                    SaveEntity_1.SaveEntity.SerializeHeader(writer, obj);
+                    break;
+                case 'SaveComponent':
+                    writer.writeInt32(SaveComponent_1.SaveComponent.TypeID);
+                    SaveComponent_1.SaveComponent.SerializeHeader(writer, obj);
+                    break;
+                default:
+                    console.log('Unknown object type', obj);
+                    break;
+            }
+        }
+    }
+    static WriteLevel(writer, level, buildVersion) {
+        const lenIndicatorHeaderAndCollectableSize = writer.getBufferPosition();
+        writer.writeInt32(0);
+        Level.SerializeObjectHeaders(writer, level.objects);
+        Level.SerializeCollectablesList(writer, level.collectables);
+        // replace binary size from earlier for - object headers + collectables
+        writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
+        // write entities
+        Level.SerializeObjectContents(writer, level.objects, buildVersion);
+        Level.SerializeCollectablesList(writer, level.collectables);
+    }
+    static SerializeObjectContents(writer, objects, buildVersion) {
+        const lenIndicatorEntities = writer.getBufferPosition();
+        writer.writeInt32(0);
+        writer.writeInt32(objects.length);
+        for (const obj of objects) {
+            const lenReplacementPosition = writer.getBufferPosition();
+            writer.writeInt32(0);
+            if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                SaveEntity_1.SaveEntity.SerializeData(writer, obj, buildVersion);
+            }
+            else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                SaveComponent_1.SaveComponent.SerializeData(writer, obj, buildVersion);
+            }
+            writer.writeBinarySizeFromPosition(lenReplacementPosition, lenReplacementPosition + 4);
+        }
+        writer.writeBinarySizeFromPosition(lenIndicatorEntities, lenIndicatorEntities + 4);
+    }
+    static ReadObjectHeaders(reader, objectsList, onProgressCallback) {
+        let countObjectHeaders = reader.readInt32();
+        for (let i = 0; i < countObjectHeaders; i++) {
+            if (i % 1000 === 0) {
+                onProgressCallback(reader.getBufferProgress());
+            }
+            let objectType = reader.readInt32();
+            switch (objectType) {
+                case SaveEntity_1.SaveEntity.TypeID:
+                    let object = new SaveEntity_1.SaveEntity('', '', '', '');
+                    SaveEntity_1.SaveEntity.ParseHeader(reader, object);
+                    objectsList.push(object);
+                    break;
+                case SaveComponent_1.SaveComponent.TypeID:
+                    let component = new SaveComponent_1.SaveComponent('', '', '', '');
+                    SaveComponent_1.SaveComponent.ParseHeader(reader, component);
+                    objectsList.push(component);
+                    break;
+                default:
+                    console.log('Unknown object type', objectType);
+                    break;
+            }
+        }
+    }
+    static ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
+        const binarySize = reader.readInt32(); // entities binary length
+        const posBefore = reader.getBufferPosition();
+        const countEntities = reader.readInt32();
+        if (countEntities !== objectsList.length) {
+            throw new Error(`possibly corrupt. entity content count ${countEntities} does not object count of ${objectsList.length}`);
+        }
+        // definitely after i=25467
+        for (let i = 0; i < countEntities; i++) {
+            if (i % 1000 === 0) {
+                onProgressCallback(reader.getBufferProgress());
+            }
+            const len = reader.readInt32();
+            const before = reader.getBufferPosition();
+            const obj = objectsList[i];
+            if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion);
+            }
+            else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion);
+            }
+            const after = reader.getBufferPosition();
+            if (after - before !== len) {
+                console.warn('entity may be corrupt', this.name, i);
+            }
+        }
+        const posAfter = reader.getBufferPosition();
+        if (posAfter - posBefore !== binarySize) {
+            //WARNING
+            console.warn('save seems corrupt.', this.name);
+        }
+    }
+    static ReadLevel(reader, levelName, buildVersion) {
+        const level = new Level(levelName);
+        reader.readInt32(); // object headers + collectables binary length
+        // object headers
+        Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
+        // collectables
+        reader.onProgressCallback(reader.getBufferProgress());
+        level.collectables = Level.ReadCollectablesList(reader);
+        // objects contents
+        Level.ReadObjectContents(reader, level.objects, buildVersion, reader.onProgressCallback);
+        // collectables 2nd time.
+        reader.onProgressCallback(reader.getBufferProgress());
+        Level.ReadCollectablesList(reader);
+        return level;
+    }
+    // collected stuff
+    static SerializeCollectablesList(writer, collectables) {
+        writer.writeInt32(collectables.length);
+        for (const collectable of collectables) {
+            ObjectReference_1.ObjectReference.Serialize(writer, collectable);
+        }
+    }
+    // collected stuff
+    static ReadCollectablesList(reader) {
+        let countCollected = reader.readInt32();
+        const collected = [];
+        for (let i = 0; i < countCollected; i++) {
+            const collectable = ObjectReference_1.ObjectReference.Parse(reader);
+            collected.push(collectable);
+        }
+        return collected;
+    }
+}
+exports.Level = Level;

package/build/parser/satisfactory/objects/DataFields.d.ts

@@ -0,0 +1,13 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveWriter } from "../../save-writer";
+import { AbstractBaseProperty } from "./Property";
+export declare class DataFields {
+    properties: any[];
+    trailingData: number[];
+    shouldBeNulled: boolean;
+    constructor();
+    static Parse(length: number, reader: ByteReader, buildVersion: number): DataFields;
+    static ParseProperty(reader: ByteReader, buildVersion: number, propertyName: string): AbstractBaseProperty | null;
+    static Serialize(writer: SaveWriter, fields: DataFields, buildVersion: number): void;
+    static SerializeProperty(writer: SaveWriter, property: AbstractBaseProperty, propertyName: string, buildVersion: number): void;
+}