@etothepii/satisfactory-file-parser 0.4.13 → 0.4.15

package/build/parser/stream/json-stream-writer.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsonStreamWriter = void 0;
-const json_stream_state_writer_1 = require("./json-stream-state-writer");
-class JsonStreamWriter extends json_stream_state_writer_1.JsonStreamStateWriter {
-    constructor(writer) {
-        super(async (value) => await writer.write(value), 'BEFORE_START');
-        this.writer = writer;
-        this.stateMachine = {
-            openSave: {
-                name: 'Open Save',
-                requiresOneOfThemToBeBefore: ['BEFORE_START'],
-                do: async () => await this.startObject(),
-                assignOnFinish: 'OPENED_SAVE',
-            },
-            writeHeader: {
-                name: 'Write Header',
-                requiresOneOfThemToBeBefore: ['OPENED_SAVE'],
-                do: async (param) => await this.writeProperty('header', Promise.resolve(JSON.stringify(param))),
-                assignOnFinish: 'FINISHED_HEADER',
-            },
-            writeCompressionInfo: {
-                name: 'Write Compression Info',
-                requiresOneOfThemToBeBefore: ['FINISHED_HEADER'],
-                do: async (param) => await this.writeProperty('compressionInfo', Promise.resolve(JSON.stringify(param))),
-                assignOnFinish: 'WROTE_COMPRESSION_INFO',
-            },
-            openLevels: {
-                name: 'Open Levels',
-                requiresOneOfThemToBeBefore: ['WROTE_COMPRESSION_INFO'],
-                do: async () => await this.startArray(),
-                assignOnFinish: 'OPENED_LEVELS',
-            },
-            openLevel: {
-                name: 'Open Level',
-                requiresOneOfThemToBeBefore: ['OPENED_LEVELS', 'FINISHED_LEVEL'],
-                do: async (param) => {
-                    await this.writePropertyName(param);
-                    await this.startObject();
-                    await this.writeProperty('name', Promise.resolve(param));
-                    await this.writePropertyName('objects');
-                    await this.startArray();
-                },
-                assignOnFinish: 'OPENED_LEVEL',
-            },
-            writeObject: {
-                name: 'Write Object',
-                requiresOneOfThemToBeBefore: ['OPENED_LEVEL', 'WROTE_OBJECT'],
-                do: async (param) => await this.writeValue(Promise.resolve(JSON.stringify(param))),
-                assignOnFinish: 'WROTE_OBJECT',
-            },
-            switchToCollectables: {
-                name: 'Switch To collectables',
-                requiresOneOfThemToBeBefore: ['OPENED_LEVEL', 'WROTE_OBJECT'],
-                do: async () => {
-                    await this.endArray();
-                    await this.writePropertyName('collectables');
-                    await this.startArray();
-                },
-                assignOnFinish: 'SWITCH_TO_COLLECTABLES',
-            },
-            writeCollectable: {
-                name: 'Write Collectables',
-                requiresOneOfThemToBeBefore: ['SWITCH_TO_COLLECTABLES'],
-                do: async (param) => {
-                    await this.writeValue(Promise.resolve(JSON.stringify(param)));
-                },
-                assignOnFinish: 'WROTE_COLLECTABLE',
-            },
-            closeLevel: {
-                name: 'Close Level',
-                requiresOneOfThemToBeBefore: ['SWITCH_TO_COLLECTABLES', 'WROTE_COLLECTABLE'],
-                do: async () => {
-                    await this.endArray();
-                    await this.endObject();
-                },
-                assignOnFinish: 'FINISHED_LEVEL',
-            },
-            closeLevels: {
-                name: 'Close Levels',
-                requiresOneOfThemToBeBefore: [],
-                do: async () => await this.endArray(),
-                assignOnFinish: "FINISHED_LEVELS",
-            },
-            closeSave: {
-                name: 'Close Save',
-                requiresOneOfThemToBeBefore: ['FINISHED_LEVELS'],
-                do: async () => await this.startObject(),
-                assignOnFinish: 'FINISHED_SAVE',
-            }
-        };
-    }
-    async beginSave() {
-        await this.useTransition(this.stateMachine.openSave);
-    }
-    async writeHeader(header) {
-        await this.useTransition(this.stateMachine.writeHeader, header);
-    }
-    async writeCompressionInfo(compressionInfo) {
-        await this.useTransition(this.stateMachine.writeCompressionInfo, compressionInfo);
-    }
-    async openLevels() {
-        await this.useTransition(this.stateMachine.openLevels);
-    }
-    async openLevel() {
-        await this.useTransition(this.stateMachine.openLevel);
-    }
-    async writeObject(object) {
-        await this.useTransition(this.stateMachine.writeObject, object);
-    }
-    async switchToCollectables() {
-        await this.useTransition(this.stateMachine.switchToCollectables);
-    }
-    async writeCollectable(object) {
-        await this.useTransition(this.stateMachine.writeCollectable, object);
-    }
-    async closeLevel() {
-        await this.useTransition(this.stateMachine.closeLevel);
-    }
-    async closeLevels() {
-        await this.useTransition(this.stateMachine.closeLevels);
-    }
-    async endSave() {
-        await this.useTransition(this.stateMachine.closeSave);
-    }
-}
-exports.JsonStreamWriter = JsonStreamWriter;

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

@@ -1,6 +0,0 @@
-/// <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>;
-    private static readLevelsAsync;
-}

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

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamParser = void 0;
-const __1 = require("../../..");
-class StreamParser {
-    static async ParseSaveFileAsynchronousToOutput(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 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 StreamParser.readLevelsAsync(reader, writer, save.header.mapName, save.header.buildVersion);
-        await writer.write(`]}`);
-        await writer.close();
-    }
-    static async readLevelsAsync(reader, writer, mapName, buildVersion) {
-        const levelCount = reader.readInt32();
-        reader.onProgressCallback(reader.getBufferProgress(), `reading pack of ${levelCount} levels.`);
-        for (let j = 0; j <= levelCount; j++) {
-            let levelName = (j === levelCount) ? '' + mapName : reader.readString();
-            if (j % 300 === 0) {
-                reader.onProgressCallback(reader.getBufferProgress(), `reading level [${(j + 1)}/${(levelCount + 1)}] ${levelName}`);
-            }
-        }
-    }
-}
-exports.StreamParser = StreamParser;

package/build/parser/stream/save-stream-json-stringifier.d.ts

@@ -1,6 +0,0 @@
-/// <reference types="node" />
-import { WritableStream } from "stream/web";
-import { SatisfactorySave } from "../..";
-export declare class SaveStreamJsonStringifier {
-    static StreamStringifySave(save: SatisfactorySave, output: WritableStream<string>): Promise<void>;
-}

package/build/parser/stream/save-stream-json-stringifier.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SaveStreamJsonStringifier = void 0;
-const save_stream_writer_class_1 = require("./save-stream-writer.class");
-class SaveStreamJsonStringifier {
-    static async StreamStringifySave(save, output) {
-        const writer = new save_stream_writer_class_1.SaveStreamWriter(output.getWriter());
-        await writer.beginSave();
-        await writer.writeHeader(save.header);
-        if (save.compressionInfo) {
-            await writer.writeCompressionInfo(save.compressionInfo);
-        }
-        await writer.writeGridHash(save.gridHash);
-        await writer.writeGrids(save.grids);
-        await writer.openLevels();
-        const objectBatchSize = 10000;
-        for (const level of save.levels) {
-            await writer.openLevel(level.name);
-            let i = 0;
-            for (i; i < level.objects.length; i += objectBatchSize) {
-                await writer.writeObjects(...level.objects.slice(i, Math.min(i + objectBatchSize, level.objects.length)));
-            }
-            await writer.switchInLevelToCollectables();
-            i = 0;
-            for (i; i < level.collectables.length; i += objectBatchSize) {
-                await writer.writeCollectables(...level.collectables.slice(i, Math.min(i + objectBatchSize, level.collectables.length)));
-            }
-            await writer.endLevel();
-        }
-        await writer.endLevels();
-        await writer.endSave();
-        await writer.close();
-    }
-}
-exports.SaveStreamJsonStringifier = SaveStreamJsonStringifier;

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

@@ -1,15 +0,0 @@
-/// <reference types="node" />
-import { ReadableStreamDefaultReader } from "stream/web";
-import { ChunkCompressionInfo, SatisfactorySaveHeader } from "../..";
-import { ByteStreamReader } from "./byte-stream-reader.class";
-import { SaveStreamWriter } from "./save-stream-writer.class";
-export declare class SaveStreamReader extends ByteStreamReader {
-    static readonly EPOCH_TICKS = 621355968000000000n;
-    static readonly DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
-    compressionInfo: ChunkCompressionInfo;
-    constructor(reader: ReadableStreamDefaultReader<Uint8Array>, maxBufferThreshold: number, onCloseCallback?: () => Promise<void>);
-    readHeader(): Promise<SatisfactorySaveHeader>;
-    readBodyChunk(): Promise<Uint8Array>;
-    debugInfo(): string;
-    streamLevelsToOutput(writer: SaveStreamWriter, header: SatisfactorySaveHeader): Promise<void>;
-}

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

@@ -1,121 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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,
-            maxUncompressedChunkContentSize: 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.maxUncompressedChunkContentSize <= 0) {
-            this.compressionInfo.maxUncompressedChunkContentSize = 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

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import { WritableStreamDefaultWriter } from "stream/web";
-import { ChunkCompressionInfo, ObjectReference, SatisfactorySaveHeader } from "../..";
-import { SaveObject } from "../satisfactory/objects/SaveObject";
-import { ByteArray4, Grids } from '../satisfactory/save/save-reader';
-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>;
-    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>;
-    close(): Promise<void>;
-}

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

@@ -1,119 +0,0 @@
-"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 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();
-    }
-}
-exports.SaveStreamWriter = SaveStreamWriter;

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

@@ -1,12 +0,0 @@
-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

@@ -1,103 +0,0 @@
-"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/build/parser/stream/stream-parser.d.ts

@@ -1,40 +0,0 @@
-/// <reference types="node" />
-import { Readable } from "stream";
-import { Alignment } from "../byte/alignment.enum";
-export declare class StreamParserReader {
-    minBufferSize: number;
-    private buffer;
-    view: DataView;
-    private hasInputStreamEnded;
-    currentByte: number;
-    alignment: Alignment;
-    private inputBuffer;
-    private input;
-    hasDataToRead: boolean;
-    private onInputDataAvailableCallback;
-    constructor(minBufferSize: number);
-    getAmountLeftToRead: () => number;
-    parseLogic: () => Promise<void>;
-    private allocate;
-    private waitForAmountLeftToRead;
-    private wait;
-    private shiftBufferIntoOperatingDataView;
-    private readTilBufferFullOrInputEmpty;
-    startReading(input: Readable): void;
-    skipBytes(byteLength?: number): void;
-    readByte(): number;
-    readBytes(count: number): Uint8Array;
-    readHex(hexLength: number): string;
-    readInt8(): number;
-    readUint8(): number;
-    readInt16(): number;
-    readUint16(): number;
-    readInt32(): number;
-    readUint32(): number;
-    readLong(): bigint;
-    readInt64(): bigint;
-    readUint64(): bigint;
-    readFloat32(): number;
-    readDouble(): number;
-    readString(): string;
-}