unreal.js/dist/ue4/asyncloading2/FPackageStore.d.ts

A pak reader for games like VALORANT & Fortnite written in Node.JS

import { FOnContainerMountedListener } from "../io/IoDispatcher";
import { FileProvider } from "../../fileprovider/FileProvider";
import { FNameMap } from "./FNameMap";
import { FPackageObjectIndex } from "./AsyncLoading2";
import { UnrealMap } from "../../util/UnrealMap";
import Collection from "@discordjs/collection";
import { FFilePackageStoreEntry } from "../io/IoContainerHeader";
import { FName } from "../objects/uobject/FName";
import { Pair } from "../../util/Pair";
import { FMinimalName } from "../objects/uobject/NameTypes";
import { FArchive } from "../reader/FArchive";
import { FIoStoreReader } from "../io/IoStore";
/**
 * FScriptObjectEntry
 */
export declare class FScriptObjectEntry {
    /**
     * objectName
     * @type {FMinimalName}
     * @public
     */
    objectName: FMinimalName;
    /**
     * globalIndex
     * @type {FPackageObjectIndex}
     * @public
     */
    globalIndex: FPackageObjectIndex;
    /**
     * outerIndex
     * @type {FPackageObjectIndex}
     * @public
     */
    outerIndex: FPackageObjectIndex;
    /**
     * cdoClassIndex
     * @type {FPackageObjectIndex}
     * @public
     */
    cdoClassIndex: FPackageObjectIndex;
    /**
     * Creates an instance using an UE4 Reader
     * @param {FArchive} Ar UE4 Reader to use
     * @param {Array<string>} nameMap Name map
     * @constructor
     * @public
     */
    constructor(Ar: FArchive, nameMap: string[]);
}
/**
 * FPackageStore (I/O)
 * @extends {FOnContainerMountedListener}
 */
export declare class FPackageStore extends FOnContainerMountedListener {
    /**
     * Provider
     * @type {FileProvider}
     * @public
     */
    provider: FileProvider;
    /**
     * Creates instance using values
     * @param {FileProvider} provider File provider to use
     */
    constructor(provider: FileProvider);
    /**
     * Loaded containers
     * @type {Collection<bigint, FLoadedContainer>}
     * @public
     */
    loadedContainers: Collection<bigint, FLoadedContainer>;
    /**
     * Package Name Maps Critical
     * @type {{}}
     * @public
     */
    packageNameMapsCritical: {};
    /**
     * Current culture names
     * @type {Array<string>}
     * @public
     currentCultureNames: string[] = []*/
    /**
     * Store entries
     * @type {Collection<bigint, FFilePackageStoreEntry>}
     * @public
     */
    storeEntries: Collection<bigint, FFilePackageStoreEntry>;
    /**
     * Redirected packages
     * @type {Collection<bigint, Pair<FName, bigint>>}
     * @public
     */
    redirectedPackages: Collection<bigint, Pair<FName, bigint>>;
    /**
     * Script object entries
     * @type {Array<FScriptObjectEntry>}
     * @public
     scriptObjectEntries: FScriptObjectEntry[]*/
    /**
     * Script object entries map
     * @type {UnrealMap<FPackageObjectIndex, FScriptObjectEntry>}
     * @public
     */
    scriptObjectEntries: UnrealMap<FPackageObjectIndex, FScriptObjectEntry>;
    /**
     * Sets up culture
     * @returns {void}
     * @public
     setupCulture() {
        this.currentCultureNames = [osLocale.sync().toString().replace("_", "-")]
    }*/
    /**
     * Sets up initial load data
     * @returns {void}
     * @public
     setupInitialLoadData() {
        const initialLoadIoBuffer = this.provider.saveChunk(createIoChunkId(0n, 0, EIoChunkType.LoaderInitialLoadMeta))
        const initialLoadArchive = new FByteArchive(initialLoadIoBuffer)
        const numScriptObjects = initialLoadArchive.readInt32()
        this.scriptObjectEntries = new Array(numScriptObjects)
        for (let i = 0; i < numScriptObjects; ++i) {
            const obj = new FScriptObjectEntry(initialLoadArchive, this.globalNameMap.nameEntries)
            const mappedName = FMappedName.fromMinimalName(obj.objectName)
            if (!mappedName.isGlobal())
                throw new ParserException("FMappedName must be global", initialLoadArchive)
            obj.objectName = this.globalNameMap.getMinimalName(mappedName)
            this.scriptObjectEntriesMap.set(obj.globalIndex, obj)
            this.scriptObjectEntries[i] = obj
        }
    }*/
    /**
     * Loads containers
     * @param {Array<FIoStoreReader>} containers Containers to load
     * @returns {void}
     * @public
     */
    loadContainers(containers: FIoStoreReader[]): void;
    /**
     * On container mounted 'event'
     * @param {FIoStoreReader} container Container to call
     * @returns {void}
     * @public
     */
    onContainerMounted(container: FIoStoreReader): void;
    /**
     * Applies store redirects
     * @param {UnrealMap<bigint, bigint>} redirects Redirects to apply
     * @returns {void}
     * @public
     */
    applyRedirects(redirects: UnrealMap<bigint, bigint>): void;
    /**
     * Gets an store entry
     * @param {bigint} packageId ID of store entry to get
     * @returns {FFilePackageStoreEntry}
     * @public
     */
    findStoreEntry(packageId: bigint): FFilePackageStoreEntry;
    /**
     * Gets redirected package id
     * @param {bigint} packageId ID of redirect to get
     * @returns {Collection<bigint, bigint>}
     * @public
     */
    getRedirectedPackageId(packageId: bigint): Pair<FName, bigint>;
}
/**
 * FLoadedContainer
 */
export declare class FLoadedContainer {
    /**
     * Container name map
     * @type {FNameMap}
     * @public
     */
    containerNameMap: FNameMap;
    /**
     * Store entries
     * @type {Array<FFilePackageStoreEntry>}
     * @public
     */
    storeEntries: FFilePackageStoreEntry[];
    /**
     * Package count
     * @type {number}
     * @public
     */
    packageCount: number;
    /**
     * Order
     * @type {number}
     * @public
     */
    order: number;
    /**
     * bValid
     * @type {boolean}
     * @public
     */
    bValid: boolean;
}