@etothepii/satisfactory-file-parser 0.0.31 → 0.0.32

package/build/parser/satisfactory/objects/Property.js

@@ -233,7 +233,7 @@
             return new Int64Property(value, ueType, guidInfo, index);
         }
         static ReadValue(reader) {
-            return reader.readLong().toString();
+            return reader.readInt64().toString();
         }
         static CalcOverhead(property) {
             return 1;
@@ -261,7 +261,7 @@
             return 1;
         }
         static ReadValue(reader) {
-            return reader.readFloat();
+            return reader.readFloat32();
         }
         static Serialize(writer, property) {
             (0, exports.SerializeGUID)(writer, property.guidInfo);
@@ -547,8 +547,8 @@
                     value = {
                         root: reader.readString(),
                         instanceName: reader.readString(),
-                        offset: reader.readFloat(),
-                        forward: reader.readFloat()
+                        offset: reader.readFloat32(),
+                        forward: reader.readFloat32()
                     };
                     break;
                 case 'TimerHandle':
@@ -568,14 +568,14 @@
                     break;
                 case 'FluidBox':
                     value = {
-                        value: reader.readFloat()
+                        value: reader.readFloat32()
                     };
                     break;
                 case 'SlateBrush':
                     value = reader.readString();
                     break;
                 case 'DateTime':
-                    value = reader.readLong().toString();
+                    value = reader.readInt64().toString();
                     break;
                 case 'FINNetworkTrace':
                     value = (0, exports.ReadFINNetworkTrace)(reader);
@@ -587,8 +587,8 @@
                     break;
                 case 'FICFrameRange':
                     value = {
-                        begin: reader.readLong().toString(),
-                        end: reader.readLong().toString(),
+                        begin: reader.readInt64().toString(),
+                        end: reader.readInt64().toString(),
                     };
                     break;
                 default:
@@ -704,35 +704,35 @@
             const elementCount = reader.readInt32();
             switch (subtype) {
                 case "FloatProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => FloatProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => FloatProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "BoolProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => BoolProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => BoolProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "IntProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
                     break;
                 case "Int64Property":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => Int64Property.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => Int64Property.ReadValue(reader)), ueType, index);
                     break;
                 case "DoubleProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => DoubleProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => DoubleProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "ByteProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ByteProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ByteProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StrProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "EnumProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => EnumProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => EnumProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "TextProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => TextProperty.ParseValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => TextProperty.ParseValue(reader)), ueType, index);
                     break;
                 case "InterfaceProperty":
                 case "ObjectProperty":
-                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
+                    property = new ArrayProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StructProperty":
                     const name = reader.readString();
@@ -759,7 +759,7 @@
                         innerStructValueFields.allUnk4 = allUnk4;
                     }
                     const before = reader.getBufferPosition();
-                    const maArr = new Array(elementCount).fill(0).map(e => {
+                    const maArr = new Array(elementCount).fill(0).map(() => {
                         const struct = new StructProperty(allStructType, type, allIndex, allGuid);
                         struct.value = StructProperty.ParseValue(reader, allStructType, binarySize);
                         return struct;
@@ -852,17 +852,17 @@
             let property;
             switch (subtype) {
                 case "IntProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => Int32Property.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => Int32Property.ReadValue(reader)), ueType, index);
                     break;
                 case "ObjectProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => ObjectProperty.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => ObjectProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "NameProperty":
-                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => StrProperty.ReadValue(reader)), ueType, index);
+                    property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => StrProperty.ReadValue(reader)), ueType, index);
                     break;
                 case "StructProperty":
                     if (propertyName === 'mRemovalLocations') {
-                        property = new SetProperty(subtype, new Array(elementCount).fill(0).map(e => (0, util_types_1.ParseVec3)(reader)), ueType, index);
+                        property = new SetProperty(subtype, new Array(elementCount).fill(0).map(() => (0, util_types_1.ParseVec3)(reader)), ueType, index);
                     }
                     break;
                 default:
@@ -932,6 +932,7 @@
         const data = {
             type, properties: {}
         };
+        const pos = reader.getBufferPosition();
         let propertyName = reader.readString();
         while (propertyName !== 'None') {
             const property = DataFields_1.DataFields.ParseProperty(reader, buildVersion, propertyName);

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

@@ -1,8 +1,11 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
-import { SaveObject } from "./SaveObject";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
 export declare const isSaveComponent: (obj: any) => obj is SaveComponent;
-export declare class SaveComponent extends SaveObject {
+export interface SaveComponentHeader extends SaveObjectHeader {
+    parentEntityName: string;
+}
+export declare class SaveComponent extends SaveObject implements SaveComponentHeader {
     typePath: string;
     rootObject: string;
     instanceName: string;
@@ -10,7 +13,7 @@ export declare class SaveComponent extends SaveObject {
     static readonly TypeID = 0;
     readonly type = "SaveComponent";
     constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string);
-    static ParseHeader(reader: ByteReader, obj: SaveComponent): void;
+    static ParseHeader(reader: BinaryReadable, obj: SaveComponent): void;
     static SerializeHeader(writer: ByteWriter, component: SaveComponent): void;
-    static ParseData(component: SaveComponent, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseData(component: SaveComponent, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
 }

package/build/parser/satisfactory/objects/SaveComponent.js

@@ -32,8 +32,8 @@
             SaveObject_1.SaveObject.SerializeHeader(writer, component);
             writer.writeString(component.parentEntityName);
         }
-        static ParseData(component, length, reader, buildVersion) {
-            SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion);
+        static ParseData(component, length, reader, buildVersion, typePath) {
+            SaveObject_1.SaveObject.ParseData(component, length, reader, buildVersion, typePath);
         }
     }
     SaveComponent.TypeID = 0;

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

@@ -1,9 +1,14 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { Transform } from "../structs/util.types";
 import { ObjectReference } from "./ObjectReference";
-import { SaveObject } from "./SaveObject";
+import { SaveObject, SaveObjectHeader } from "./SaveObject";
 export declare const isSaveEntity: (obj: any) => obj is SaveEntity;
+export interface SaveEntityHeader extends SaveObjectHeader {
+    needTransform: boolean;
+    transform: Transform;
+    wasPlacedInLevel: boolean;
+}
 export declare class SaveEntity extends SaveObject {
     typePath: string;
     rootObject: string;
@@ -18,8 +23,8 @@ export declare class SaveEntity extends SaveObject {
     parentObjectName: string;
     components: ObjectReference[];
     constructor(typePath: string, rootObject: string, instanceName: string, parentEntityName?: string, needsTransform?: boolean);
-    static ParseHeader(reader: ByteReader, obj: SaveEntity): void;
-    static ParseData(entity: SaveEntity, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseHeader(reader: BinaryReadable, obj: SaveEntity): void;
+    static ParseData(entity: SaveEntity, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
     static SerializeHeader(writer: ByteWriter, entity: SaveEntity): void;
     static SerializeData(writer: ByteWriter, entity: SaveEntity, buildVersion: number): void;
 }

package/build/parser/satisfactory/objects/SaveEntity.js

@@ -42,7 +42,7 @@
             obj.transform = (0, util_types_1.ParseTransform)(reader);
             obj.wasPlacedInLevel = reader.readInt32() == 1;
         }
-        static ParseData(entity, length, reader, buildVersion) {
+        static ParseData(entity, length, reader, buildVersion, typePath) {
             var newLen = length - 12;
             entity.parentObjectRoot = reader.readString();
             if (entity.parentObjectRoot.length > 0)
@@ -56,7 +56,7 @@
                 entity.components.push(componentRef);
                 newLen -= 10 + componentRef.levelName.length + componentRef.pathName.length;
             }
-            SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion);
+            return SaveObject_1.SaveObject.ParseData(entity, newLen, reader, buildVersion, typePath);
         }
         static SerializeHeader(writer, entity) {
             SaveObject_1.SaveObject.SerializeHeader(writer, entity);

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

@@ -1,14 +1,19 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { DataFields } from "./DataFields";
-export declare abstract class SaveObject {
+export interface SaveObjectHeader {
+    typePath: string;
+    rootObject: string;
+    instanceName: string;
+}
+export declare abstract class SaveObject implements SaveObjectHeader {
     typePath: string;
     rootObject: string;
     instanceName: string;
     dataFields: DataFields;
     constructor(typePath: string, rootObject: string, instanceName: string);
-    protected static ParseHeader(reader: ByteReader, obj: SaveObject): void;
+    protected static ParseHeader(reader: BinaryReadable, obj: SaveObject): void;
     protected static SerializeHeader(writer: ByteWriter, obj: SaveObject): void;
-    static ParseData(obj: SaveObject, length: number, reader: ByteReader, buildVersion: number): void;
+    static ParseData(obj: SaveObject, length: number, reader: BinaryReadable, buildVersion: number, typePath: string): void;
     static SerializeData(writer: any, obj: SaveObject, buildVersion: number): void;
 }

package/build/parser/satisfactory/objects/SaveObject.js

@@ -28,11 +28,11 @@
             writer.writeString(obj.rootObject);
             writer.writeString(obj.instanceName);
         }
-        static ParseData(obj, length, reader, buildVersion) {
-            obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion);
+        static ParseData(obj, length, reader, buildVersion, typePath) {
+            obj.dataFields = DataFields_1.DataFields.Parse(length, reader, buildVersion, typePath);
         }
         static SerializeData(writer, obj, buildVersion) {
-            DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion);
+            DataFields_1.DataFields.Serialize(writer, obj.dataFields, buildVersion, obj.typePath);
         }
     }
     exports.SaveObject = SaveObject;

package/build/parser/satisfactory/save/asynchronous-level.class.d.ts

@@ -0,0 +1,9 @@
+import { ByteReader } from "../../byte/byte-reader.class";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
+import { SaveObject } from "../objects/SaveObject";
+import { Level } from "./level.class";
+import { SaveReader } from "./save-reader";
+export declare class AsynchronousLevel {
+    static StreamReadObjectContents(reader: ByteReader, objectsList: SaveObject[], buildVersion: number, writer: SaveStreamWriter, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
+    static StreamReadLevel(reader: SaveReader, levelName: string, buildVersion: number, writer: SaveStreamWriter): Promise<Level>;
+}

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

@@ -0,0 +1,76 @@
+(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", "../objects/SaveComponent", "../objects/SaveEntity", "./level.class"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.AsynchronousLevel = void 0;
+    const SaveComponent_1 = require("../objects/SaveComponent");
+    const SaveEntity_1 = require("../objects/SaveEntity");
+    const level_class_1 = require("./level.class");
+    class AsynchronousLevel {
+        static async StreamReadObjectContents(reader, objectsList, buildVersion, writer, onProgressCallback) {
+            const binarySize = reader.readInt32();
+            const posBefore = reader.getBufferPosition();
+            await reader.allocate(binarySize);
+            const countEntities = reader.readInt32();
+            if (countEntities !== objectsList.length) {
+                throw new Error(`possibly corrupt. entity content count ${countEntities} does not equal object count of ${objectsList.length}`);
+            }
+            let dynamicObjectBatch = [];
+            for (let i = 0; i < countEntities; i++) {
+                if (i % 1000 === 0) {
+                    console.log(`having some objects, writing ${i + 1}/${countEntities}.`);
+                    onProgressCallback(reader.getBufferProgress());
+                    await writer.writeObjects(...dynamicObjectBatch);
+                    dynamicObjectBatch = [];
+                }
+                const len = reader.readInt32();
+                const before = reader.getBufferPosition();
+                if (len < reader.getAmountAllocatedLeft()) {
+                    await reader.allocate(Math.max(before - binarySize, 300 * 1000 * 1000));
+                }
+                const obj = objectsList[i];
+                if ((0, SaveEntity_1.isSaveEntity)(obj)) {
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
+                }
+                dynamicObjectBatch.push(obj);
+                const after = reader.getBufferPosition();
+                if (after - before !== len) {
+                    console.warn('entity may be corrupt', this.name, i);
+                }
+            }
+            await writer.writeObjects(...dynamicObjectBatch);
+            const posAfter = reader.getBufferPosition();
+            if (posAfter - posBefore !== binarySize) {
+                console.warn('save seems corrupt.', this.name);
+            }
+        }
+        static async StreamReadLevel(reader, levelName, buildVersion, writer) {
+            const level = new level_class_1.Level(levelName);
+            const binaryLength = reader.readInt32();
+            await reader.allocate(binaryLength);
+            await writer.openLevel(levelName);
+            level_class_1.Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level.collectables = level_class_1.Level.ReadCollectablesList(reader);
+            console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
+            await AsynchronousLevel.StreamReadObjectContents(reader, level.objects, buildVersion, writer, reader.onProgressCallback);
+            await writer.switchInLevelToCollectables();
+            await writer.writeCollectables(...level.collectables);
+            reader.onProgressCallback(reader.getBufferProgress());
+            level_class_1.Level.ReadCollectablesList(reader);
+            await writer.endLevel();
+            return level;
+        }
+    }
+    exports.AsynchronousLevel = AsynchronousLevel;
+});

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

@@ -1,4 +1,4 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 import { ObjectReference } from "../objects/ObjectReference";
 import { SaveComponent } from "../objects/SaveComponent";
@@ -12,10 +12,10 @@ export declare class Level {
     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 SerializeObjectContents(writer: ByteWriter, objects: (SaveEntity | SaveComponent)[], buildVersion: number, levelName: string): void;
+    static ReadObjectHeaders(reader: BinaryReadable, objectsList: SaveObject[], onProgressCallback: (progress: number, msg?: string) => void): void;
+    static ReadObjectContents(reader: BinaryReadable, objectsList: SaveObject[], buildVersion: number, onProgressCallback: (progress: number, msg?: string) => void): Promise<void>;
     static ReadLevel(reader: SaveReader, levelName: string, buildVersion: number): Level;
     static SerializeCollectablesList(writer: ByteWriter, collectables: ObjectReference[]): void;
-    static ReadCollectablesList(reader: SaveReader): ObjectReference[];
+    static ReadCollectablesList(reader: BinaryReadable): ObjectReference[];
 }

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

@@ -43,10 +43,10 @@
             Level.SerializeObjectHeaders(writer, level.objects);
             Level.SerializeCollectablesList(writer, level.collectables);
             writer.writeBinarySizeFromPosition(lenIndicatorHeaderAndCollectableSize, lenIndicatorHeaderAndCollectableSize + 4);
-            Level.SerializeObjectContents(writer, level.objects, buildVersion);
+            Level.SerializeObjectContents(writer, level.objects, buildVersion, level.name);
             Level.SerializeCollectablesList(writer, level.collectables);
         }
-        static SerializeObjectContents(writer, objects, buildVersion) {
+        static SerializeObjectContents(writer, objects, buildVersion, levelName) {
             const lenIndicatorEntities = writer.getBufferPosition();
             writer.writeInt32(0);
             writer.writeInt32(objects.length);
@@ -87,12 +87,12 @@
                 }
             }
         }
-        static ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
+        static async ReadObjectContents(reader, objectsList, buildVersion, onProgressCallback) {
             const binarySize = reader.readInt32();
             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}`);
+                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) {
@@ -102,10 +102,10 @@
                 const before = reader.getBufferPosition();
                 const obj = objectsList[i];
                 if ((0, SaveEntity_1.isSaveEntity)(obj)) {
-                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion);
+                    SaveEntity_1.SaveEntity.ParseData(obj, len, reader, buildVersion, obj.typePath);
                 }
                 else if ((0, SaveComponent_1.isSaveComponent)(obj)) {
-                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion);
+                    SaveComponent_1.SaveComponent.ParseData(obj, len, reader, buildVersion, obj.typePath);
                 }
                 const after = reader.getBufferPosition();
                 if (after - before !== len) {
@@ -123,6 +123,7 @@
             Level.ReadObjectHeaders(reader, level.objects, reader.onProgressCallback);
             reader.onProgressCallback(reader.getBufferProgress());
             level.collectables = Level.ReadCollectablesList(reader);
+            console.log(`before object contents buffer pos ${reader.getBufferPosition()}`);
             Level.ReadObjectContents(reader, level.objects, buildVersion, reader.onProgressCallback);
             reader.onProgressCallback(reader.getBufferProgress());
             Level.ReadCollectablesList(reader);

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

@@ -1,9 +1,9 @@
 import { ByteReader } from "../../byte/byte-reader.class";
 import { ChunkCompressionInfo } from "../../file.types";
+import { SaveStreamWriter } from "../../stream/save-stream-writer.class";
 import { ObjectReference } from "../objects/ObjectReference";
 import { SaveComponent } from "../objects/SaveComponent";
 import { SaveEntity } from "../objects/SaveEntity";
-import { SaveObject } from "../objects/SaveObject";
 import { Level } from "./level.class";
 import { SatisfactorySaveHeader } from "./save.types";
 export type EntityPathFilter = {
@@ -15,6 +15,8 @@ export type SaveProjectionConfig = {
     includeComponents: boolean;
 };
 export declare const projectionFilterApplies: (config: SaveProjectionConfig, object: SaveComponent | SaveEntity) => boolean;
+export type ReadMode = 'stream' | 'whole';
+export declare const DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
 export declare class SaveReader extends ByteReader {
     onProgressCallback: (progress: number, msg?: string) => void;
     header: SatisfactorySaveHeader | undefined;
@@ -29,16 +31,5 @@ export declare class SaveReader extends ByteReader {
         numChunks: number;
     };
     readLevels(): Level[];
-}
-export declare class Conveyor {
-    static getConveyorBeltRegex(): RegExp;
-    static getConveyorLiftRegex(): RegExp;
-    static isAConveyorBelt(obj: SaveObject): boolean;
-    static isAConveyorLift(obj: SaveObject): boolean;
-    static get availableConnections(): string[];
-    static get availableConveyorBelts(): string[];
-    static get availableConveyorLifts(): string[];
-    static isConveyor(currentObject: any): boolean;
-    static isConveyorBelt(currentObject: any): boolean;
-    static isConveyorLift(currentObject: any): boolean;
+    readLevelsAsynchronously(writer: SaveStreamWriter): Promise<Level[]>;
 }

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

@@ -7,18 +7,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "pako", "../../byte/alignment.enum", "../../byte/byte-reader.class", "../../error/parser.error", "../objects/SaveComponent", "../objects/SaveEntity", "./level.class"], factory);
+        define(["require", "exports", "pako", "../../byte/alignment.enum", "../../byte/byte-reader.class", "../../error/parser.error", "../objects/SaveComponent", "../objects/SaveEntity", "./asynchronous-level.class", "./level.class"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.Conveyor = exports.SaveReader = exports.projectionFilterApplies = void 0;
+    exports.SaveReader = exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = exports.projectionFilterApplies = void 0;
     const pako_1 = __importDefault(require("pako"));
     const alignment_enum_1 = require("../../byte/alignment.enum");
     const byte_reader_class_1 = require("../../byte/byte-reader.class");
     const parser_error_1 = require("../../error/parser.error");
     const SaveComponent_1 = require("../objects/SaveComponent");
     const SaveEntity_1 = require("../objects/SaveEntity");
+    const asynchronous_level_class_1 = require("./asynchronous-level.class");
     const level_class_1 = require("./level.class");
     const projectionFilterApplies = (config, object) => {
         let cond1 = false;
@@ -38,6 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
         return cond1 && cond2;
     };
     exports.projectionFilterApplies = projectionFilterApplies;
+    exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE = 48;
     class SaveReader extends byte_reader_class_1.ByteReader {
         constructor(fileBuffer, onProgressCallback = () => { }) {
             super(fileBuffer, alignment_enum_1.Alignment.LITTLE_ENDIAN);
@@ -47,7 +49,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
             this.compressionInfo = {
                 packageFileTag: 0,
                 maxChunkContentSize: 0,
-                chunkHeaderSize: 48
+                chunkHeaderSize: exports.DEFAULT_SATISFACTORY_CHUNK_HEADER_SIZE
             };
         }
         readHeader() {
@@ -168,76 +170,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
             }
             return this.levels;
         }
-    }
-    SaveReader.EPOCH_TICKS = 621355968000000000n;
-    exports.SaveReader = SaveReader;
-    class Conveyor {
-        static getConveyorBeltRegex() {
-            return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorBeltMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
-        }
-        ;
-        static getConveyorLiftRegex() {
-            return /\/Game\/FactoryGame\/Buildable\/Factory\/(ConveyorLiftMk[0-9]+)\/Build_(\1)\.Build_(\1)_C/g;
-        }
-        ;
-        static isAConveyorBelt(obj) {
-            return obj.typePath.match(this.getConveyorBeltRegex()) !== null;
-        }
-        static isAConveyorLift(obj) {
-            return obj.typePath.match(this.getConveyorLiftRegex()) !== null;
-        }
-        static get availableConnections() { return ['.ConveyorAny0', '.ConveyorAny1', '.Input0', '.Input1', '.Input2', '.Input3', '.InPut3', '.Input4', '.Input5', '.Input6', '.Output0', '.Output1', '.Output2', '.Output3']; }
-        static get availableConveyorBelts() {
-            return [
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk1/Build_ConveyorBeltMk1.Build_ConveyorBeltMk1_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk2/Build_ConveyorBeltMk2.Build_ConveyorBeltMk2_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk3/Build_ConveyorBeltMk3.Build_ConveyorBeltMk3_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk4/Build_ConveyorBeltMk4.Build_ConveyorBeltMk4_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorBeltMk5/Build_ConveyorBeltMk5.Build_ConveyorBeltMk5_C'
-            ];
-        }
-        static get availableConveyorLifts() {
-            return [
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk1/Build_ConveyorLiftMk1.Build_ConveyorLiftMk1_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk2/Build_ConveyorLiftMk2.Build_ConveyorLiftMk2_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk3/Build_ConveyorLiftMk3.Build_ConveyorLiftMk3_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk4/Build_ConveyorLiftMk4.Build_ConveyorLiftMk4_C',
-                '/Game/FactoryGame/Buildable/Factory/ConveyorLiftMk5/Build_ConveyorLiftMk5.Build_ConveyorLiftMk5_C'
-            ];
-        }
-        static isConveyor(currentObject) {
-            return Conveyor.isConveyorBelt(currentObject) || Conveyor.isConveyorLift(currentObject);
-        }
-        static isConveyorBelt(currentObject) {
-            if (Conveyor.availableConveyorBelts.includes(currentObject.className)) {
-                return true;
-            }
-            if (currentObject.className.startsWith('/Conveyors_Mod/Build_BeltMk')
-                || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_BeltMk')
-                || currentObject.className.startsWith('/UltraFastLogistics/Buildable/build_conveyorbeltMK')
-                || currentObject.className.startsWith('/FlexSplines/Conveyor/Build_Belt')
-                || currentObject.className.startsWith('/conveyorbeltmod/Belt/mk')
-                || currentObject.className.startsWith('/minerplus/content/buildable/Factory/belt_')
-                || currentObject.className.startsWith('/bamfp/content/buildable/Factory/belt_')) {
-                return true;
-            }
-            return false;
-        }
-        static isConveyorLift(currentObject) {
-            if (Conveyor.availableConveyorLifts.includes(currentObject.className)) {
-                return true;
-            }
-            if (currentObject.className.startsWith('/minerplus/content/buildable/Factory/lift')
-                || currentObject.className.startsWith('/bamfp/content/buildable/Factory/lift')
-                || currentObject.className.startsWith('/Game/Conveyors_Mod/Build_LiftMk')
-                || currentObject.className.startsWith('/Conveyors_Mod/Build_LiftMk')
-                || currentObject.className.startsWith('/Game/CoveredConveyor')
-                || currentObject.className.startsWith('/CoveredConveyor')
-                || currentObject.className.startsWith('/conveyorbeltmod/lift/')) {
-                return true;
+        async readLevelsAsynchronously(writer) {
+            const numSubLevels = this.readInt32();
+            this.levels = new Array(numSubLevels + 1);
+            await writer.openLevels();
+            for (let j = 0; j <= numSubLevels; j++) {
+                let levelName = (j === numSubLevels) ? '' + this.header.mapName : this.readString();
+                this.onProgressCallback(this.getBufferProgress(), `reading level [${(j + 1)}/${(numSubLevels + 1)}] ${levelName}`);
+                this.levels[j] = await asynchronous_level_class_1.AsynchronousLevel.StreamReadLevel(this, levelName, this.header.buildVersion, writer);
             }
-            return false;
+            await writer.endLevels();
+            return this.levels;
         }
     }
-    exports.Conveyor = Conveyor;
+    SaveReader.EPOCH_TICKS = 621355968000000000n;
+    exports.SaveReader = SaveReader;
 });

package/build/parser/satisfactory/structs/util.types.d.ts

@@ -1,4 +1,4 @@
-import { ByteReader } from "../../byte/byte-reader.class";
+import { BinaryReadable } from "../../byte/binary-readable.interface";
 import { ByteWriter } from "../../byte/byte-writer.class";
 export type col4 = {
     r: number;
@@ -7,13 +7,13 @@ export type col4 = {
     a: number;
 };
 export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4RGBA: (reader: ByteReader) => col4;
+export declare const ParseCol4RGBA: (reader: BinaryReadable) => col4;
 export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4BGRA: (reader: ByteReader) => col4;
+export declare const ParseCol4BGRA: (reader: BinaryReadable) => col4;
 export type vec4 = vec3 & {
     w: number;
 };
-export declare const ParseVec4: (reader: ByteReader) => vec4;
+export declare const ParseVec4: (reader: BinaryReadable) => vec4;
 export declare const SerializeVec4: (writer: ByteWriter, vec: vec4) => void;
 export declare const sub: (other: vec3, vec: vec3) => vec3;
 export declare const add: (vec: vec3, other: vec3) => vec3;
@@ -23,18 +23,18 @@ export declare const norm: (vec: vec3) => vec3;
 export type vec3 = vec2 & {
     z: number;
 };
-export declare const ParseVec3: (reader: ByteReader) => vec3;
+export declare const ParseVec3: (reader: BinaryReadable) => vec3;
 export declare const SerializeVec3: (writer: ByteWriter, vec: vec3) => void;
 export type vec2 = {
     x: number;
     y: number;
 };
-export declare const ParseVec2: (reader: ByteReader) => vec2;
+export declare const ParseVec2: (reader: BinaryReadable) => vec2;
 export declare const SerializeVec2: (writer: ByteWriter, vec: vec2) => void;
 export type Transform = {
     rotation: vec4;
     translation: vec3;
     scale3d: vec3;
 };
-export declare const ParseTransform: (reader: ByteReader) => Transform;
+export declare const ParseTransform: (reader: BinaryReadable) => Transform;
 export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;