@etothepii/satisfactory-file-parser 0.0.24 → 0.0.26

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

@@ -1,224 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFields = void 0;
-const Property_1 = require("./Property");
-class DataFields {
-    constructor() {
-        this.properties = [];
-        this.trailingData = [];
-        this.shouldBeNulled = false;
-    }
-    static Parse(length, reader, buildVersion) {
-        const start = reader.getBufferPosition();
-        const fields = new DataFields();
-        if (length === 0) {
-            fields.shouldBeNulled = true;
-            return fields;
-        }
-        let propertyName = reader.readString();
-        while (propertyName !== 'None') {
-            const property = DataFields.ParseProperty(reader, buildVersion, propertyName);
-            fields.properties.push(property);
-            propertyName = reader.readString();
-        }
-        let int1 = reader.readInt32();
-        if (int1 !== 0) {
-        }
-        const end = reader.getBufferPosition();
-        let remainingBytes = start + length - end;
-        fields.trailingData = Array.from(reader.readBytes(remainingBytes));
-        return fields;
-    }
-    static ParseProperty(reader, buildVersion, propertyName) {
-        let currentProperty = {};
-        if (currentProperty.name === 'None') {
-            return null;
-        }
-        const propertyType = reader.readString();
-        const binarySize = reader.readInt32();
-        const index = reader.readInt32();
-        const before = reader.getBufferPosition();
-        let overhead = 0;
-        switch (propertyType) {
-            case 'BoolProperty':
-                currentProperty = Property_1.BoolProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.BoolProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ByteProperty':
-                currentProperty = Property_1.ByteProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.ByteProperty.CalcOverhead(currentProperty);
-                break;
-            case 'Int8Property':
-                currentProperty = Property_1.Int8Property.Parse(reader, propertyType, index);
-                overhead = Property_1.Int8Property.CalcOverhead(currentProperty);
-                break;
-            case 'UInt8Property':
-                currentProperty = Property_1.Uint8Property.Parse(reader, propertyType, index);
-                overhead = Property_1.Uint8Property.CalcOverhead(currentProperty);
-                break;
-            case 'IntProperty':
-            case 'Int32Property':
-                currentProperty = Property_1.Int32Property.Parse(reader, propertyType, index);
-                overhead = Property_1.Int32Property.CalcOverhead(currentProperty);
-                break;
-            case 'UInt32Property':
-                currentProperty = Property_1.Uint32Property.Parse(reader, propertyType, index);
-                overhead = Property_1.Uint32Property.CalcOverhead(currentProperty);
-                break;
-            case 'Int64Property':
-                currentProperty = Property_1.Int64Property.Parse(reader, propertyType, index);
-                overhead = Property_1.Int64Property.CalcOverhead(currentProperty);
-                break;
-            case 'SingleProperty':
-            case 'FloatProperty':
-                currentProperty = Property_1.FloatProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.FloatProperty.CalcOverhead(currentProperty);
-                break;
-            case 'DoubleProperty':
-                currentProperty = Property_1.DoubleProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.DoubleProperty.CalcOverhead(currentProperty);
-                break;
-            case 'StrProperty':
-            case 'NameProperty':
-                currentProperty = Property_1.StrProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.StrProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ObjectProperty':
-            case 'InterfaceProperty':
-                currentProperty = Property_1.ObjectProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.ObjectProperty.CalcOverhead(currentProperty);
-                break;
-            case 'EnumProperty':
-                currentProperty = Property_1.EnumProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.EnumProperty.CalcOverhead(currentProperty);
-                break;
-            case 'StructProperty':
-                currentProperty = Property_1.StructProperty.Parse(reader, propertyType, index, binarySize);
-                overhead = Property_1.StructProperty.CalcOverhead(currentProperty);
-                break;
-            case 'ArrayProperty':
-                currentProperty = Property_1.ArrayProperty.Parse(reader, propertyType, index, propertyName);
-                overhead = Property_1.ArrayProperty.CalcOverhead(currentProperty);
-                break;
-            case 'MapProperty':
-                currentProperty = Property_1.MapProperty.Parse(reader, propertyName, buildVersion, binarySize);
-                overhead = Property_1.MapProperty.CalcOverhead(currentProperty);
-                break;
-            case 'TextProperty':
-                currentProperty = Property_1.TextProperty.Parse(reader, propertyType, index);
-                overhead = Property_1.TextProperty.CalcOverhead(currentProperty);
-                break;
-            case 'SetProperty':
-                currentProperty = Property_1.SetProperty.Parse(reader, propertyType, index, propertyName);
-                overhead = Property_1.SetProperty.CalcOverhead(currentProperty);
-                break;
-            default:
-                throw new Error(`Unimplemented type ${propertyType}`);
-        }
-        currentProperty.name = propertyName;
-        const readBytes = reader.getBufferPosition() - before - overhead;
-        if (readBytes !== binarySize) {
-            throw new Error(`possibly corrupt. Read ${readBytes} for ${propertyType} ${propertyName}, but ${binarySize} were indicated.`);
-        }
-        return currentProperty;
-    }
-    static Serialize(writer, fields, buildVersion) {
-        for (const property of fields.properties) {
-            writer.writeString(property.name);
-            DataFields.SerializeProperty(writer, property, property.name, buildVersion);
-        }
-        writer.writeString('None');
-        writer.writeInt32(0);
-        writer.writeBytesArray(fields.trailingData);
-    }
-    static SerializeProperty(writer, property, propertyName, buildVersion) {
-        writer.writeString(property.ueType);
-        const lenIndicator = writer.getBufferPosition();
-        writer.writeInt32(0);
-        writer.writeInt32(property.index ?? 0);
-        const start = writer.getBufferPosition();
-        let overhead = 0;
-        switch (property.ueType) {
-            case 'BoolProperty':
-                overhead = Property_1.BoolProperty.CalcOverhead(property);
-                Property_1.BoolProperty.Serialize(writer, property);
-                break;
-            case 'ByteProperty':
-                overhead = Property_1.ByteProperty.CalcOverhead(property);
-                Property_1.ByteProperty.Serialize(writer, property);
-                break;
-            case 'Int8Property':
-                overhead = Property_1.Int8Property.CalcOverhead(property);
-                Property_1.Int8Property.Serialize(writer, property);
-                break;
-            case 'UInt8Property':
-                overhead = Property_1.Uint8Property.CalcOverhead(property);
-                Property_1.Uint8Property.Serialize(writer, property);
-                break;
-            case 'IntProperty':
-            case 'Int32Property':
-                overhead = Property_1.Int32Property.CalcOverhead(property);
-                Property_1.Int32Property.Serialize(writer, property);
-                break;
-            case 'UInt32Property':
-                overhead = Property_1.Uint32Property.CalcOverhead(property);
-                Property_1.Uint32Property.Serialize(writer, property);
-                break;
-            case 'Int64Property':
-                overhead = Property_1.Int64Property.CalcOverhead(property);
-                Property_1.Int64Property.Serialize(writer, property);
-                break;
-            case 'SingleProperty':
-            case 'FloatProperty':
-                overhead = Property_1.FloatProperty.CalcOverhead(property);
-                Property_1.FloatProperty.Serialize(writer, property);
-                break;
-            case 'DoubleProperty':
-                overhead = Property_1.DoubleProperty.CalcOverhead(property);
-                Property_1.DoubleProperty.Serialize(writer, property);
-                break;
-            case 'StrProperty':
-            case 'NameProperty':
-                overhead = Property_1.StrProperty.CalcOverhead(property);
-                Property_1.StrProperty.Serialize(writer, property);
-                break;
-            case 'ObjectProperty':
-            case 'InterfaceProperty':
-                overhead = Property_1.ObjectProperty.CalcOverhead(property);
-                Property_1.ObjectProperty.Serialize(writer, property);
-                break;
-            case 'EnumProperty':
-                overhead = Property_1.EnumProperty.CalcOverhead(property);
-                Property_1.EnumProperty.Serialize(writer, property);
-                break;
-            case 'ByteProperty':
-                overhead = Property_1.ByteProperty.CalcOverhead(property);
-                Property_1.ByteProperty.Serialize(writer, property);
-                break;
-            case 'StructProperty':
-                overhead = Property_1.StructProperty.CalcOverhead(property);
-                Property_1.StructProperty.Serialize(writer, property);
-                break;
-            case 'ArrayProperty':
-                overhead = Property_1.ArrayProperty.CalcOverhead(property);
-                Property_1.ArrayProperty.Serialize(writer, property, propertyName);
-                break;
-            case 'MapProperty':
-                overhead = Property_1.MapProperty.CalcOverhead(property);
-                Property_1.MapProperty.Serialize(writer, property);
-                break;
-            case 'TextProperty':
-                overhead = Property_1.TextProperty.CalcOverhead(property);
-                Property_1.TextProperty.Serialize(writer, property);
-                break;
-            case 'SetProperty':
-                overhead = Property_1.SetProperty.CalcOverhead(property);
-                Property_1.SetProperty.Serialize(writer, property);
-                break;
-            default:
-                throw new Error(`Unimplemented type ${property.type}`);
-        }
-        writer.writeBinarySizeFromPosition(lenIndicator, start + overhead);
-    }
-}
-exports.DataFields = DataFields;

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

@@ -1,9 +0,0 @@
-import { ByteReader } from "../../byte/byte-reader.class";
-import { ByteWriter } from "../../byte/byte-writer.class";
-export declare class ObjectReference {
-    levelName: string;
-    pathName: string;
-    constructor(levelName: string, pathName: string);
-    static Parse(reader: ByteReader): ObjectReference;
-    static Serialize(writer: ByteWriter, ref: ObjectReference): void;
-}

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ObjectReference = void 0;
-class ObjectReference {
-    constructor(levelName, pathName) {
-        this.levelName = levelName;
-        this.pathName = pathName;
-    }
-    static Parse(reader) {
-        return new ObjectReference(reader.readString(), reader.readString());
-    }
-    static Serialize(writer, ref) {
-        writer.writeString(ref.levelName);
-        writer.writeString(ref.pathName);
-    }
-}
-exports.ObjectReference = ObjectReference;

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

@@ -1,270 +0,0 @@
-import { ByteReader } from "../../byte/byte-reader.class";
-import { SaveWriter } from "../save/save-writer";
-import { col4, vec3, vec4 } from "../structs/util.types";
-import { ObjectReference } from "./ObjectReference";
-export type Properties = {
-    [key: string]: string | number | boolean | any;
-};
-export declare abstract class AbstractProperty {
-    type: string;
-    index?: number | undefined;
-    constructor(type: string, index?: number | undefined);
-}
-export declare abstract class AbstractBaseProperty extends AbstractProperty {
-    ueType: string;
-    name: string;
-    constructor(type: string, ueType: string, index: number);
-}
-export declare abstract class BasicProperty extends AbstractBaseProperty {
-    guidInfo: GUID;
-    constructor(type: string, ueType: string, guidInfo: GUID, index?: number);
-}
-export type GUID = undefined | Uint8Array;
-export declare const ParseGUID: (reader: ByteReader) => GUID;
-export declare const SerializeGUID: (writer: SaveWriter, guid: GUID) => void;
-export type OverheadResult = {
-    overhead: number;
-};
-export declare class BoolProperty extends BasicProperty {
-    value: boolean;
-    constructor(value: boolean, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): BoolProperty;
-    static ReadValue(reader: ByteReader): boolean;
-    static CalcOverhead(property: BoolProperty): number;
-    static Serialize(writer: SaveWriter, property: BoolProperty): void;
-    static SerializeValue(writer: SaveWriter, value: boolean): void;
-}
-export type BytePropertyValue = {
-    type: string;
-    value: string | number;
-};
-export declare class ByteProperty extends BasicProperty {
-    value: BytePropertyValue;
-    constructor(value: BytePropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ByteProperty;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: ByteProperty): number;
-    static Serialize(writer: SaveWriter, property: ByteProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class Int8Property extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int8Property;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: Int8Property): number;
-    static Serialize(writer: SaveWriter, property: Int8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class Uint8Property extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint8Property;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: Uint8Property): number;
-    static Serialize(writer: SaveWriter, property: Uint8Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class Int32Property extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int32Property;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: Int32Property): number;
-    static Serialize(writer: SaveWriter, property: Int32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class Uint32Property extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Uint32Property;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: Uint32Property): number;
-    static Serialize(writer: SaveWriter, property: Uint32Property): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class Int64Property extends BasicProperty {
-    value: string;
-    constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): Int64Property;
-    static ReadValue(reader: ByteReader): string;
-    static CalcOverhead(property: Int64Property): number;
-    static Serialize(writer: SaveWriter, property: Int64Property): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
-}
-export declare class FloatProperty extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): FloatProperty;
-    static CalcOverhead(property: FloatProperty): number;
-    static ReadValue(reader: ByteReader): number;
-    static Serialize(writer: SaveWriter, property: FloatProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class DoubleProperty extends BasicProperty {
-    value: number;
-    constructor(value: number, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): DoubleProperty;
-    static ReadValue(reader: ByteReader): number;
-    static CalcOverhead(property: DoubleProperty): number;
-    static Serialize(writer: SaveWriter, property: DoubleProperty): void;
-    static SerializeValue(writer: SaveWriter, value: number): void;
-}
-export declare class StrProperty extends BasicProperty {
-    value: string;
-    constructor(value: string, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): StrProperty;
-    static ReadValue(reader: ByteReader): string;
-    static CalcOverhead(property: StrProperty): number;
-    static Serialize(writer: SaveWriter, property: StrProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
-}
-export declare class ObjectProperty extends BasicProperty {
-    value: ObjectReference;
-    constructor(value: ObjectReference, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): ObjectProperty;
-    static ReadValue(reader: ByteReader): ObjectReference;
-    static CalcOverhead(property: ObjectProperty): number;
-    static Serialize(writer: SaveWriter, property: ObjectProperty): void;
-    static SerializeValue(writer: SaveWriter, value: {
-        levelName: string;
-        pathName: string;
-    }): void;
-}
-export declare class EnumProperty extends BasicProperty {
-    value: {
-        name: string;
-        value: string;
-    };
-    constructor(value: {
-        name: string;
-        value: string;
-    }, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): EnumProperty;
-    static ReadValue(reader: ByteReader): string;
-    static CalcOverhead(property: EnumProperty): number;
-    static Serialize(writer: SaveWriter, property: EnumProperty): void;
-    static SerializeValue(writer: SaveWriter, value: string): void;
-}
-export type TextPropertyValue = {
-    flags: number;
-    historyType: number;
-    namespace?: string;
-    key?: string;
-    value?: string;
-    sourceFmt?: TextPropertyValue;
-    arguments?: {
-        name: string;
-        valueType: number;
-        argumentValue: TextPropertyValue;
-    }[];
-    sourceText?: TextPropertyValue;
-    transformType?: number;
-    hasCultureInvariantString?: boolean;
-};
-export declare class TextProperty extends BasicProperty {
-    value: TextPropertyValue;
-    constructor(value: TextPropertyValue, ueType?: string, guidInfo?: GUID, index?: number);
-    static Parse(reader: ByteReader, ueType: string, index?: number): TextProperty;
-    static ParseValue(reader: ByteReader): TextPropertyValue;
-    static CalcOverhead(property: TextProperty): number;
-    static Serialize(writer: SaveWriter, property: TextProperty): void;
-    static SerializeValue(writer: SaveWriter, value: TextPropertyValue): void;
-}
-export type BasicMultipleStructPropertyValue = {
-    values: any;
-};
-export type BasicStructPropertyValue = {
-    value: any;
-};
-export type BoxStructPropertyValue = {
-    min: vec3;
-    max: vec3;
-    isValid: boolean;
-};
-export type RailroadTrackPositionStructPropertyValue = {
-    root: string;
-    instanceName: string;
-    offset: number;
-    forward: number;
-};
-export type InventoryItemStructPropertyValue = {
-    unk1: number;
-    itemName: string;
-    unk2: string;
-    unk3: string;
-    properties: any[];
-};
-export type FICFrameRangeStructPropertyValue = {
-    begin: string;
-    end: string;
-};
-export type DynamicStructPropertyValue = {
-    type: string;
-    properties: Properties;
-};
-export type GENERIC_STRUCT_PROPERTY_VALUE = BasicMultipleStructPropertyValue | BasicStructPropertyValue | BoxStructPropertyValue | RailroadTrackPositionStructPropertyValue | InventoryItemStructPropertyValue | FICFrameRangeStructPropertyValue | DynamicStructPropertyValue | col4 | vec3 | vec4 | string;
-export declare class StructProperty extends AbstractBaseProperty {
-    subtype: string;
-    guid: number;
-    value: GENERIC_STRUCT_PROPERTY_VALUE;
-    unk1?: number;
-    unk2?: number;
-    unk3?: number;
-    unk4?: number;
-    constructor(subtype: string, ueType?: string, index?: number, guid?: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, size: number): StructProperty;
-    static ParseValue(reader: ByteReader, subtype: string, size: number): GENERIC_STRUCT_PROPERTY_VALUE;
-    static CalcOverhead(property: StructProperty): number;
-    static Serialize(writer: SaveWriter, property: StructProperty): void;
-    static SerializeValue(writer: SaveWriter, subtype: string, value: GENERIC_STRUCT_PROPERTY_VALUE): void;
-}
-export type ArrayPropertyStructValueFields = {
-    allStructType: string;
-    allIndex: number;
-    allGuid: number;
-    allUnk1?: number;
-    allUnk2?: number;
-    allUnk3?: number;
-    allUnk4?: number;
-};
-export declare class ArrayProperty<T> extends BasicProperty {
-    subtype: string;
-    values: T[];
-    structValueFields?: ArrayPropertyStructValueFields | undefined;
-    constructor(subtype: string, values: T[], ueType?: string, index?: number, structValueFields?: ArrayPropertyStructValueFields | undefined);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): ArrayProperty<any>;
-    static CalcOverhead(property: ArrayProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: ArrayProperty<any>, propertyName: string): void;
-}
-export declare class SetProperty<T> extends BasicProperty {
-    subtype: string;
-    values: T[];
-    constructor(subtype: string, values: T[], ueType: string, index: number);
-    static Parse(reader: ByteReader, ueType: string, index: number, propertyName: string): SetProperty<any>;
-    static CalcOverhead(property: SetProperty<any>): number;
-    static Serialize(writer: SaveWriter, property: SetProperty<any>): void;
-}
-export declare class MapProperty extends BasicProperty {
-    keyType: string;
-    valueType: string;
-    modeType: number;
-    modeUnk1: string | undefined;
-    modeUnk2: string;
-    modeUnk3: string;
-    remainingData: number[];
-    values: {
-        key: any;
-        value: any;
-    }[];
-    constructor(keyType: string, valueType: string, ueType: string, index: number);
-    static Parse(reader: ByteReader, propertyName: string, buildVersion: number, size: number, ueType?: string, index?: number): MapProperty;
-    static CalcOverhead(property: MapProperty): number;
-    static Serialize(writer: SaveWriter, property: MapProperty): void;
-}
-export declare const ParseDynamicStructData: (reader: ByteReader, buildVersion: number, type: string) => DynamicStructPropertyValue;
-export declare const SerializeDynamicStructData: (writer: SaveWriter, buildVersion: number, data: DynamicStructPropertyValue) => void;
-export declare const ReadFINNetworkTrace: (reader: ByteReader) => any;
-export declare const SerializeFINNetworkTrace: (writer: SaveWriter, obj: any) => void;
-export declare const ReadFINLuaProcessorStateStorage: (reader: ByteReader, size: number) => any;
-export declare const SerializeFINLuaProcessorStateStorage: (writer: SaveWriter, stateStorage: any) => void;