@etothepii/satisfactory-file-parser 0.3.7 → 0.4.3

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

@@ -6,43 +6,53 @@ export type col4 = {
     b: number;
     a: number;
 };
-export declare const SerializeCol4RGBA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4RGBA: (reader: BinaryReadable) => col4;
-export declare const SerializeCol4BGRA: (writer: ByteWriter, value: col4) => void;
-export declare const ParseCol4BGRA: (reader: BinaryReadable) => col4;
+export declare namespace col4 {
+    const SerializeRGBA: (writer: ByteWriter, value: col4) => void;
+    const ParseRGBA: (reader: BinaryReadable) => col4;
+    const SerializeBGRA: (writer: ByteWriter, value: col4) => void;
+    const ParseBGRA: (reader: BinaryReadable) => col4;
+}
 export type vec4 = vec3 & {
     w: number;
 };
-export declare const ParseVec4: (reader: BinaryReadable) => vec4;
-export declare const SerializeVec4: (writer: ByteWriter, vec: vec4) => void;
-export declare const ParseVec4f: (reader: BinaryReadable) => vec4;
-export declare const SerializeVec4f: (writer: ByteWriter, vec: vec4) => void;
-export declare const sub: (other: vec3, vec: vec3) => vec3;
-export declare const add: (vec: vec3, other: vec3) => vec3;
-export declare const length: (vec: vec3) => number;
-export declare const mult: (vec: vec3, scale: number) => vec3;
-export declare const norm: (vec: vec3) => vec3;
+export declare namespace vec4 {
+    const Parse: (reader: BinaryReadable) => vec4;
+    const Serialize: (writer: ByteWriter, vec: vec4) => void;
+    const ParseF: (reader: BinaryReadable) => vec4;
+    const SerializeF: (writer: ByteWriter, vec: vec4) => void;
+}
 export type vec3 = vec2 & {
     z: number;
 };
-export declare const ParseVec3: (reader: BinaryReadable) => vec3;
-export declare const SerializeVec3: (writer: ByteWriter, vec: vec3) => void;
-export declare const ParseVec3Int: (reader: BinaryReadable) => vec3;
-export declare const SerializeVec3Int: (writer: ByteWriter, vec: vec3) => void;
-export declare const ParseVec3f: (reader: BinaryReadable) => vec3;
-export declare const SerializeVec3f: (writer: ByteWriter, vec: vec3) => void;
+export declare namespace vec3 {
+    const Parse: (reader: BinaryReadable) => vec3;
+    const Serialize: (writer: ByteWriter, vec: vec3) => void;
+    const ParseInt: (reader: BinaryReadable) => vec3;
+    const SerializeInt: (writer: ByteWriter, vec: vec3) => void;
+    const ParseF: (reader: BinaryReadable) => vec3;
+    const SerializeF: (writer: ByteWriter, vec: vec3) => void;
+    const sub: (other: vec3, vec: vec3) => vec3;
+    const add: (vec: vec3, other: vec3) => vec3;
+    const length: (vec: vec3) => number;
+    const mult: (vec: vec3, scale: number) => vec3;
+    const norm: (vec: vec3) => vec3;
+}
 export type vec2 = {
     x: number;
     y: number;
 };
-export declare const ParseVec2: (reader: BinaryReadable) => vec2;
-export declare const SerializeVec2: (writer: ByteWriter, vec: vec2) => void;
-export declare const ParseVec2f: (reader: BinaryReadable) => vec2;
-export declare const SerializeVec2f: (writer: ByteWriter, vec: vec2) => void;
+export declare namespace vec2 {
+    const Parse: (reader: BinaryReadable) => vec2;
+    const Serialize: (writer: ByteWriter, vec: vec2) => void;
+    const ParseF: (reader: BinaryReadable) => vec2;
+    const SerializeF: (writer: ByteWriter, vec: vec2) => void;
+}
 export type Transform = {
     rotation: vec4;
     translation: vec3;
     scale3d: vec3;
 };
-export declare const ParseTransform: (reader: BinaryReadable) => Transform;
-export declare const SerializeTransform: (writer: ByteWriter, transform: Transform) => void;
+export declare namespace Transform {
+    const Parse: (reader: BinaryReadable) => Transform;
+    const Serialize: (writer: ByteWriter, transform: Transform) => void;
+}

package/build/parser/satisfactory/structs/util.types.js

@@ -1,145 +1,135 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SerializeTransform = exports.ParseTransform = exports.SerializeVec2f = exports.ParseVec2f = exports.SerializeVec2 = exports.ParseVec2 = exports.SerializeVec3f = exports.ParseVec3f = exports.SerializeVec3Int = exports.ParseVec3Int = exports.SerializeVec3 = exports.ParseVec3 = exports.norm = exports.mult = exports.length = exports.add = exports.sub = exports.SerializeVec4f = exports.ParseVec4f = exports.SerializeVec4 = exports.ParseVec4 = exports.ParseCol4BGRA = exports.SerializeCol4BGRA = exports.ParseCol4RGBA = exports.SerializeCol4RGBA = void 0;
-const SerializeCol4RGBA = (writer, value) => {
-    writer.writeFloat(value.r);
-    writer.writeFloat(value.g);
-    writer.writeFloat(value.b);
-    writer.writeFloat(value.a);
-};
-exports.SerializeCol4RGBA = SerializeCol4RGBA;
-const ParseCol4RGBA = (reader) => {
-    return {
-        r: reader.readFloat32(),
-        g: reader.readFloat32(),
-        b: reader.readFloat32(),
-        a: reader.readFloat32(),
-    };
-};
-exports.ParseCol4RGBA = ParseCol4RGBA;
-const SerializeCol4BGRA = (writer, value) => {
-    writer.writeByte(value.b);
-    writer.writeByte(value.g);
-    writer.writeByte(value.r);
-    writer.writeByte(value.a);
-};
-exports.SerializeCol4BGRA = SerializeCol4BGRA;
-const ParseCol4BGRA = (reader) => {
-    return {
-        b: reader.readByte(),
-        g: reader.readByte(),
-        r: reader.readByte(),
-        a: reader.readByte(),
-    };
-};
-exports.ParseCol4BGRA = ParseCol4BGRA;
-const ParseVec4 = (reader) => {
-    return {
-        ...((0, exports.ParseVec3)(reader)),
-        w: reader.readDouble()
-    };
-};
-exports.ParseVec4 = ParseVec4;
-const SerializeVec4 = (writer, vec) => {
-    (0, exports.SerializeVec3)(writer, vec);
-    writer.writeDouble(vec.w);
-};
-exports.SerializeVec4 = SerializeVec4;
-const ParseVec4f = (reader) => {
-    return {
-        ...((0, exports.ParseVec3f)(reader)),
-        w: reader.readFloat32()
-    };
-};
-exports.ParseVec4f = ParseVec4f;
-const SerializeVec4f = (writer, vec) => {
-    (0, exports.SerializeVec3f)(writer, vec);
-    writer.writeFloat(vec.w);
-};
-exports.SerializeVec4f = SerializeVec4f;
-const sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
-exports.sub = sub;
-const add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
-exports.add = add;
-const length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
-exports.length = length;
-const mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
-exports.mult = mult;
-const norm = (vec) => (0, exports.mult)(vec, 1. / (0, exports.length)(vec));
-exports.norm = norm;
-const ParseVec3 = (reader) => {
-    return {
-        ...((0, exports.ParseVec2)(reader)),
-        z: reader.readDouble()
-    };
-};
-exports.ParseVec3 = ParseVec3;
-const SerializeVec3 = (writer, vec) => {
-    (0, exports.SerializeVec2)(writer, vec);
-    writer.writeDouble(vec.z);
-};
-exports.SerializeVec3 = SerializeVec3;
-const ParseVec3Int = (reader) => {
-    return {
-        x: reader.readInt32(),
-        y: reader.readInt32(),
-        z: reader.readInt32()
-    };
-};
-exports.ParseVec3Int = ParseVec3Int;
-const SerializeVec3Int = (writer, vec) => {
-    writer.writeInt32(vec.x);
-    writer.writeInt32(vec.y);
-    writer.writeInt32(vec.z);
-};
-exports.SerializeVec3Int = SerializeVec3Int;
-const ParseVec3f = (reader) => {
-    return {
-        ...((0, exports.ParseVec2f)(reader)),
-        z: reader.readFloat32()
-    };
-};
-exports.ParseVec3f = ParseVec3f;
-const SerializeVec3f = (writer, vec) => {
-    (0, exports.SerializeVec2f)(writer, vec);
-    writer.writeFloat(vec.z);
-};
-exports.SerializeVec3f = SerializeVec3f;
-const ParseVec2 = (reader) => {
-    return {
-        x: reader.readDouble(),
-        y: reader.readDouble(),
-    };
-};
-exports.ParseVec2 = ParseVec2;
-const SerializeVec2 = (writer, vec) => {
-    writer.writeDouble(vec.x);
-    writer.writeDouble(vec.y);
-};
-exports.SerializeVec2 = SerializeVec2;
-const ParseVec2f = (reader) => {
-    return {
-        x: reader.readFloat32(),
-        y: reader.readFloat32(),
-    };
-};
-exports.ParseVec2f = ParseVec2f;
-const SerializeVec2f = (writer, vec) => {
-    writer.writeFloat(vec.x);
-    writer.writeFloat(vec.y);
-};
-exports.SerializeVec2f = SerializeVec2f;
-const ParseTransform = (reader) => {
-    return {
-        rotation: (0, exports.ParseVec4f)(reader),
-        translation: (0, exports.ParseVec3f)(reader),
-        scale3d: (0, exports.ParseVec3f)(reader),
-    };
-};
-exports.ParseTransform = ParseTransform;
-const SerializeTransform = (writer, transform) => {
-    (0, exports.SerializeVec4f)(writer, transform.rotation);
-    (0, exports.SerializeVec3f)(writer, transform.translation);
-    (0, exports.SerializeVec3f)(writer, transform.scale3d);
-};
-exports.SerializeTransform = SerializeTransform;
+exports.Transform = exports.vec2 = exports.vec3 = exports.vec4 = exports.col4 = void 0;
+var col4;
+(function (col4) {
+    col4.SerializeRGBA = (writer, value) => {
+        writer.writeFloat(value.r);
+        writer.writeFloat(value.g);
+        writer.writeFloat(value.b);
+        writer.writeFloat(value.a);
+    };
+    col4.ParseRGBA = (reader) => {
+        return {
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32(),
+            a: reader.readFloat32(),
+        };
+    };
+    col4.SerializeBGRA = (writer, value) => {
+        writer.writeByte(value.b);
+        writer.writeByte(value.g);
+        writer.writeByte(value.r);
+        writer.writeByte(value.a);
+    };
+    col4.ParseBGRA = (reader) => {
+        return {
+            b: reader.readByte(),
+            g: reader.readByte(),
+            r: reader.readByte(),
+            a: reader.readByte(),
+        };
+    };
+})(col4 || (exports.col4 = col4 = {}));
+var vec4;
+(function (vec4) {
+    vec4.Parse = (reader) => {
+        return {
+            ...(vec3.Parse(reader)),
+            w: reader.readDouble()
+        };
+    };
+    vec4.Serialize = (writer, vec) => {
+        vec3.Serialize(writer, vec);
+        writer.writeDouble(vec.w);
+    };
+    vec4.ParseF = (reader) => {
+        return {
+            ...(vec3.ParseF(reader)),
+            w: reader.readFloat32()
+        };
+    };
+    vec4.SerializeF = (writer, vec) => {
+        vec3.SerializeF(writer, vec);
+        writer.writeFloat(vec.w);
+    };
+})(vec4 || (exports.vec4 = vec4 = {}));
+var vec3;
+(function (vec3) {
+    vec3.Parse = (reader) => {
+        return {
+            ...(vec2.Parse(reader)),
+            z: reader.readDouble()
+        };
+    };
+    vec3.Serialize = (writer, vec) => {
+        vec2.Serialize(writer, vec);
+        writer.writeDouble(vec.z);
+    };
+    vec3.ParseInt = (reader) => {
+        return {
+            x: reader.readInt32(),
+            y: reader.readInt32(),
+            z: reader.readInt32()
+        };
+    };
+    vec3.SerializeInt = (writer, vec) => {
+        writer.writeInt32(vec.x);
+        writer.writeInt32(vec.y);
+        writer.writeInt32(vec.z);
+    };
+    vec3.ParseF = (reader) => {
+        return {
+            ...(vec2.ParseF(reader)),
+            z: reader.readFloat32()
+        };
+    };
+    vec3.SerializeF = (writer, vec) => {
+        vec2.SerializeF(writer, vec);
+        writer.writeFloat(vec.z);
+    };
+    vec3.sub = (other, vec) => ({ x: other.x - vec.x, y: other.y - vec.y, z: other.z - vec.z });
+    vec3.add = (vec, other) => ({ x: vec.x + other.x, y: vec.y + other.y, z: vec.z + other.z });
+    vec3.length = (vec) => Math.sqrt(vec.x ** 2 + vec.y ** 2 + vec.z ** 2);
+    vec3.mult = (vec, scale) => ({ x: vec.x * scale, y: vec.y * scale, z: vec.z * scale });
+    vec3.norm = (vec) => vec3.mult(vec, 1. / vec3.length(vec));
+})(vec3 || (exports.vec3 = vec3 = {}));
+var vec2;
+(function (vec2) {
+    vec2.Parse = (reader) => {
+        return {
+            x: reader.readDouble(),
+            y: reader.readDouble(),
+        };
+    };
+    vec2.Serialize = (writer, vec) => {
+        writer.writeDouble(vec.x);
+        writer.writeDouble(vec.y);
+    };
+    vec2.ParseF = (reader) => {
+        return {
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
+        };
+    };
+    vec2.SerializeF = (writer, vec) => {
+        writer.writeFloat(vec.x);
+        writer.writeFloat(vec.y);
+    };
+})(vec2 || (exports.vec2 = vec2 = {}));
+var Transform;
+(function (Transform) {
+    Transform.Parse = (reader) => {
+        return {
+            rotation: vec4.ParseF(reader),
+            translation: vec3.ParseF(reader),
+            scale3d: vec3.ParseF(reader),
+        };
+    };
+    Transform.Serialize = (writer, transform) => {
+        vec4.SerializeF(writer, transform.rotation);
+        vec3.SerializeF(writer, transform.translation);
+        vec3.SerializeF(writer, transform.scale3d);
+    };
+})(Transform || (exports.Transform = Transform = {}));

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

@@ -68,7 +68,7 @@ class ReadableStreamParser {
             do {
                 reader.skipBytes(afterHeadersOfBatch - reader.getBufferPosition());
                 const objectCountToRead = Math.min(countObjectHeaders - totalReadObjectsInLevel, batchingSizeOfObjects);
-                const objects = ReadableStreamParser.ReadNObjectHeaders(reader, objectCountToRead);
+                const objects = _a.ReadNObjectHeaders(reader, objectCountToRead);
                 afterHeadersOfBatch = reader.getBufferPosition();
                 if (totalReadObjectsInLevel === 0) {
                     reader.skipBytes(afterAllHeaders - reader.getBufferPosition());
@@ -81,7 +81,7 @@ class ReadableStreamParser {
                 else {
                     reader.skipBytes(afterObjectsOfBatch - reader.getBufferPosition());
                 }
-                ReadableStreamParser.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
+                _a.ReadNObjects(reader, objectCountToRead, objects, buildVersion);
                 afterObjectsOfBatch = reader.getBufferPosition();
                 totalReadObjectsInLevel += objectCountToRead;
                 if (countObjectHeaders > 10000 && totalReadObjectsInLevel % 10000 === 0) {
@@ -104,6 +104,7 @@ class ReadableStreamParser {
         }
     }
 }
+exports.ReadableStreamParser = ReadableStreamParser;
 _a = ReadableStreamParser;
 ReadableStreamParser.CreateReadableStreamForParsingSave = (onStart, onCancel, onPullRequest, highWaterMark = DEFAULT_BYTE_HIGHWATERMARK / 4) => {
     let ourController = null;
@@ -137,7 +138,7 @@ ReadableStreamParser.CreateReadableStreamFromSaveToJson = (name, bytes, onDecomp
             waitForConsumerLock.lock(resolve);
         });
     };
-    const { stream, controller, finish } = ReadableStreamParser.CreateReadableStreamForParsingSave((controller) => {
+    const { stream, controller, finish } = _a.CreateReadableStreamForParsingSave((controller) => {
     }, (reason) => { }, (desiredSize) => {
         waitForConsumerLock.unlock();
     });
@@ -155,8 +156,8 @@ ReadableStreamParser.CreateReadableStreamFromSaveToJson = (name, bytes, onDecomp
         onDecompressedSaveBody(reader.getBuffer());
         const gridHash = reader.readSaveBodyHash();
         const grids = reader.readGrids();
-        await ReadableStreamParser.WriteHeaderAndGrids(write, reader.compressionInfo, header, grids, gridHash);
-        await ReadableStreamParser.WriteLevels(write, reader, save.header.mapName, save.header.buildVersion);
+        await _a.WriteHeaderAndGrids(write, reader.compressionInfo, header, grids, gridHash);
+        await _a.WriteLevels(write, reader, save.header.mapName, save.header.buildVersion);
         await write(`]}`);
         finish();
     };
@@ -201,4 +202,3 @@ ReadableStreamParser.ReadNObjects = (reader, count, objects, buildVersion) => {
         }
     }
 };
-exports.ReadableStreamParser = ReadableStreamParser;

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

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

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

@@ -1,8 +1,9 @@
-/// <reference types="node" />
 import { WritableStreamDefaultWriter } from "stream/web";
-import { ChunkCompressionInfo, ObjectReference, SatisfactorySaveHeader } from "../../..";
+import { ChunkCompressionInfo } from '../../file.types';
 import { SaveObject } from "../../satisfactory/objects/SaveObject";
+import { ObjectReference } from '../../satisfactory/objects/values/ObjectReference';
 import { ByteArray4, Grids } from '../../satisfactory/save/save-reader';
+import { SatisfactorySaveHeader } from '../../satisfactory/save/save.types';
 export declare class SaveStreamWriter {
     private writer;
     private mode;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@etothepii/satisfactory-file-parser",
 	"author": "etothepii",
-	"version": "0.3.7",
+	"version": "0.4.3",
 	"description": "A file parser for satisfactory files. Includes save files and blueprint files.",
 	"types": "./build/index.d.ts",
 	"main": "./build/index.js",