@butr/vortexextensionnative 2.0.195 → 2.0.197

package/dist/module/types/BannerlordModuleManager.d.ts

@@ -0,0 +1,118 @@
+export interface ModuleInfoExtended {
+    id: string;
+    name: string;
+    isOfficial: boolean;
+    version: ApplicationVersion;
+    isSingleplayerModule: boolean;
+    isMultiplayerModule: boolean;
+    subModules: Array<SubModuleInfoExtended>;
+    dependentModules: Array<DependentModule>;
+    modulesToLoadAfterThis: Array<DependentModule>;
+    incompatibleModules: Array<DependentModule>;
+    url: string;
+    dependentModuleMetadatas: Array<DependentModuleMetadata>;
+}
+export interface ModuleInfoExtendedWithPath extends ModuleInfoExtended {
+    path: string;
+}
+export interface ModuleInfoExtendedWithMetadata extends ModuleInfoExtended {
+    moduleProviderType: ModuleProviderType;
+    path: string;
+}
+export declare enum ModuleProviderType {
+    Default = "Default",
+    Steam = "Steam"
+}
+export interface ApplicationVersion {
+    applicationVersionType: ApplicationVersionType;
+    major: number;
+    minor: number;
+    revision: number;
+    changeSet: number;
+}
+export declare enum ApplicationVersionType {
+    Alpha = "Alpha",
+    Beta = "Beta",
+    EarlyAccess = "EarlyAccess",
+    Release = "Release",
+    Development = "Development",
+    Invalid = "Invalid"
+}
+export interface SubModuleInfoExtended {
+    name: string;
+    dLLName: string;
+    assemblies: Array<string>;
+    subModuleClassType: string;
+    tags: Map<string, Array<string>>;
+}
+export interface DependentModule {
+    id: string;
+    version: ApplicationVersion;
+    isOptional: boolean;
+}
+export interface DependentModuleMetadata {
+    id: string;
+    loadType: LoadType;
+    isOptional: boolean;
+    isIncompatible: boolean;
+    version: ApplicationVersion;
+    versionRange: ApplicationVersionRange;
+}
+export declare enum LoadType {
+    None = "None",
+    LoadAfterThis = "LoadAfterThis",
+    LoadBeforeThis = "LoadBeforeThis"
+}
+export interface ApplicationVersionRange {
+    min: ApplicationVersion;
+    max: ApplicationVersion;
+}
+export interface ModuleSorterOptions {
+    skipOptionals: boolean;
+    skipExternalDependencies: boolean;
+}
+export interface ModuleIssue {
+    target: ModuleInfoExtended;
+    sourceId: string;
+    type: ModuleIssueType;
+    reason: string;
+    sourceVersion: ApplicationVersionRange;
+}
+export declare enum ModuleIssueType {
+    MissingDependencies = "MissingDependencies",
+    DependencyMissingDependencies = "DependencyMissingDependencies",
+    DependencyValidationError = "DependencyValidationError",
+    VersionMismatch = "VersionMismatch",
+    Incompatible = "Incompatible",
+    DependencyConflict = "DependencyConflict"
+}
+export interface IValidationManager {
+    isSelected(moduleId: string): boolean;
+}
+export interface IEnableDisableManager {
+    getSelected(moduleId: string): boolean;
+    setSelected(moduleId: string, value: boolean): void;
+    getDisabled(moduleId: string): boolean;
+    setDisabled(moduleId: string, value: boolean): void;
+}
+export interface IBannerlordModuleManager {
+    sort(unsorted: Array<ModuleInfoExtended>): Array<ModuleInfoExtended>;
+    sortWithOptions(unsorted: Array<ModuleInfoExtended>, options: ModuleSorterOptions): Array<ModuleInfoExtended>;
+    areAllDependenciesOfModulePresent(unsorted: Array<ModuleInfoExtended>, module: ModuleInfoExtended): boolean;
+    getDependentModulesOf(source: Array<ModuleInfoExtended>, module: ModuleInfoExtended): Array<ModuleInfoExtended>;
+    getDependentModulesOfWithOptions(source: Array<ModuleInfoExtended>, module: ModuleInfoExtended, options: ModuleSorterOptions): Array<ModuleInfoExtended>;
+    validateLoadOrder(source: Array<ModuleInfoExtended>, targetModule: ModuleInfoExtended): Array<ModuleIssue>;
+    validateModule(modules: Array<ModuleInfoExtended>, targetModule: ModuleInfoExtended, manager: IValidationManager): Array<ModuleIssue>;
+    enableModule(modules: Array<ModuleInfoExtended>, targetModule: ModuleInfoExtended, manager: IEnableDisableManager): Array<ModuleIssue>;
+    disableModule(modules: Array<ModuleInfoExtended>, targetModule: ModuleInfoExtended, manager: IEnableDisableManager): Array<ModuleIssue>;
+    getModuleInfo(xml: string): ModuleInfoExtended | undefined;
+    getModuleInfoWithPath(xml: string, path: string): ModuleInfoExtendedWithPath | undefined;
+    getModuleInfoWithMetadata(xml: string, type: ModuleProviderType, path: string): ModuleInfoExtendedWithMetadata | undefined;
+    getSubModuleInfo(xml: string): SubModuleInfoExtended | undefined;
+    parseApplicationVersion(content: string): ApplicationVersion;
+    compareVersions(x: ApplicationVersion, y: ApplicationVersion): number;
+    getDependenciesAll(module: ModuleInfoExtended): DependentModuleMetadata[];
+    getDependenciesToLoadBeforeThis(module: ModuleInfoExtended): DependentModuleMetadata[];
+    getDependenciesToLoadAfterThis(module: ModuleInfoExtended): DependentModuleMetadata[];
+    getDependenciesIncompatibles(module: ModuleInfoExtended): DependentModuleMetadata[];
+}

package/dist/module/types/BannerlordModuleManager.js

@@ -0,0 +1,30 @@
+export var ModuleProviderType;
+(function (ModuleProviderType) {
+    ModuleProviderType["Default"] = "Default";
+    ModuleProviderType["Steam"] = "Steam";
+})(ModuleProviderType || (ModuleProviderType = {}));
+export var ApplicationVersionType;
+(function (ApplicationVersionType) {
+    ApplicationVersionType["Alpha"] = "Alpha";
+    ApplicationVersionType["Beta"] = "Beta";
+    ApplicationVersionType["EarlyAccess"] = "EarlyAccess";
+    ApplicationVersionType["Release"] = "Release";
+    ApplicationVersionType["Development"] = "Development";
+    ApplicationVersionType["Invalid"] = "Invalid";
+})(ApplicationVersionType || (ApplicationVersionType = {}));
+export var LoadType;
+(function (LoadType) {
+    LoadType["None"] = "None";
+    LoadType["LoadAfterThis"] = "LoadAfterThis";
+    LoadType["LoadBeforeThis"] = "LoadBeforeThis";
+})(LoadType || (LoadType = {}));
+export var ModuleIssueType;
+(function (ModuleIssueType) {
+    ModuleIssueType["MissingDependencies"] = "MissingDependencies";
+    ModuleIssueType["DependencyMissingDependencies"] = "DependencyMissingDependencies";
+    ModuleIssueType["DependencyValidationError"] = "DependencyValidationError";
+    ModuleIssueType["VersionMismatch"] = "VersionMismatch";
+    ModuleIssueType["Incompatible"] = "Incompatible";
+    ModuleIssueType["DependencyConflict"] = "DependencyConflict";
+})(ModuleIssueType || (ModuleIssueType = {}));
+//# sourceMappingURL=BannerlordModuleManager.js.map

package/dist/module/types/BannerlordModuleManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BannerlordModuleManager.js","sourceRoot":"","sources":["../../../src/types/BannerlordModuleManager.ts"],"names":[],"mappings":"AAqBA,MAAM,CAAN,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC1B,yCAAmB,CAAA;IACnB,qCAAe,CAAA;AACnB,CAAC,EAHW,kBAAkB,KAAlB,kBAAkB,QAG7B;AAQD,MAAM,CAAN,IAAY,sBAOX;AAPD,WAAY,sBAAsB;IAC9B,yCAAe,CAAA;IACf,uCAAa,CAAA;IACb,qDAA2B,CAAA;IAC3B,6CAAmB,CAAA;IACnB,qDAA2B,CAAA;IAC3B,6CAAmB,CAAA;AACvB,CAAC,EAPW,sBAAsB,KAAtB,sBAAsB,QAOjC;AAqBD,MAAM,CAAN,IAAY,QAIX;AAJD,WAAY,QAAQ;IAChB,yBAAa,CAAA;IACb,2CAA+B,CAAA;IAC/B,6CAAiC,CAAA;AACrC,CAAC,EAJW,QAAQ,KAAR,QAAQ,QAInB;AAgBD,MAAM,CAAN,IAAY,eAOX;AAPD,WAAY,eAAe;IACvB,8DAA2C,CAAA;IAC3C,kFAA+D,CAAA;IAC/D,0EAAuD,CAAA;IACvD,sDAAmC,CAAA;IACnC,gDAA6B,CAAA;IAC7B,4DAAyC,CAAA;AAC7C,CAAC,EAPW,eAAe,KAAf,eAAe,QAO1B"}

package/dist/module/types/FetchBannerlordVersion.d.ts

@@ -0,0 +1,5 @@
+export interface IFetchBannerlordVersion {
+    getChangeSet(gameFolderPath: string, libAssembly: string): number;
+    getVersion(gameFolderPath: string, libAssembly: string): string;
+    getVersionType(gameFolderPath: string, libAssembly: string): number;
+}

package/dist/module/types/FetchBannerlordVersion.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=FetchBannerlordVersion.js.map

package/dist/module/types/FetchBannerlordVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FetchBannerlordVersion.js","sourceRoot":"","sources":["../../../src/types/FetchBannerlordVersion.ts"],"names":[],"mappings":""}

package/dist/module/types/LauncherManager.d.ts

@@ -0,0 +1,92 @@
+import { ModuleInfoExtended, ModuleInfoExtendedWithMetadata } from "./BannerlordModuleManager";
+export interface INativeExtension {
+    LauncherManager: new (setGameParametersAsync: (executable: string, gameParameters: string[]) => Promise<void>, sendNotificationAsync: (id: string, type: NotificationType, message: string, delayMS: number) => Promise<void>, sendDialogAsync: (type: DialogType, title: string, message: string, filters: FileFilter[]) => Promise<string>, getInstallPathAsync: () => Promise<string>, readFileContentAsync: (filePath: string, offset: number, length: number) => Promise<Uint8Array | null>, writeFileContentAsync: (filePath: string, data: Uint8Array) => Promise<void>, readDirectoryFileListAsync: (directoryPath: string) => Promise<string[] | null>, readDirectoryListAsync: (directoryPath: string) => Promise<string[] | null>, getAllModuleViewModelsAsync: () => Promise<ModuleViewModel[] | null>, getModuleViewModelsAsync: () => Promise<ModuleViewModel[] | null>, setModuleViewModelsAsync: (moduleViewModels: ModuleViewModel[]) => Promise<void>, getOptionsAsync: () => Promise<LauncherOptions>, getStateAsync: () => Promise<LauncherState>) => LauncherManager;
+}
+export interface LoadOrderEntry {
+    id: string;
+    name: string;
+    isSelected: boolean;
+    isDisabled: boolean;
+    index: number;
+}
+export interface LoadOrder {
+    [id: string]: LoadOrderEntry;
+}
+export interface ModuleViewModel {
+    moduleInfoExtended: ModuleInfoExtendedWithMetadata;
+    isValid: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+    index: number;
+}
+export interface LauncherOptions {
+    betaSorting: boolean;
+}
+export interface LauncherState {
+    isSingleplayer: boolean;
+}
+export interface SaveMetadata {
+    [key: string]: string;
+    Name: string;
+}
+export type GameStore = 'Steam' | 'GOG' | 'Epic' | 'Xbox' | 'Unknown';
+export type GamePlatform = 'Win64' | 'Xbox' | 'Unknown';
+export type NotificationType = 'hint' | 'info' | 'warning' | 'error';
+export type DialogType = 'warning' | 'fileOpen' | 'fileSave';
+export type InstructionType = 'Copy' | 'ModuleInfo' | 'CopyStore';
+export interface InstallInstruction {
+    type: InstructionType;
+    store?: GameStore;
+    moduleInfo?: ModuleInfoExtended;
+    source?: string;
+    destination?: string;
+}
+export interface InstallResult {
+    instructions: InstallInstruction[];
+}
+export interface SupportedResult {
+    supported: boolean;
+    requiredFiles: string[];
+}
+export interface OrderByLoadOrderResult {
+    result: boolean;
+    issues?: string[];
+    orderedModuleViewModels?: ModuleViewModel[];
+}
+export interface FileFilter {
+    name: string;
+    extensions: string[];
+}
+export type LauncherManager = {
+    constructor(): LauncherManager;
+    checkForRootHarmonyAsync(): Promise<void>;
+    getGamePlatformAsync(): Promise<GamePlatform>;
+    getGameVersionAsync(): Promise<string>;
+    getModulesAsync(): Promise<ModuleInfoExtendedWithMetadata[]>;
+    getAllModulesAsync(): Promise<ModuleInfoExtendedWithMetadata[]>;
+    getSaveFilePathAsync(saveFile: string): Promise<string>;
+    getSaveFilesAsync(): Promise<SaveMetadata[]>;
+    getSaveMetadataAsync(saveFile: string, data: Uint8Array): Promise<SaveMetadata>;
+    installModule(files: string[], moduleInfos: ModuleInfoExtendedWithMetadata[]): InstallResult;
+    isObfuscatedAsync(module: ModuleInfoExtendedWithMetadata): Promise<boolean>;
+    isSorting(): boolean;
+    moduleListHandlerExportAsync(): Promise<void>;
+    moduleListHandlerExportSaveFileAsync(saveFile: string): Promise<void>;
+    moduleListHandlerImportAsync(): Promise<boolean>;
+    moduleListHandlerImportSaveFileAsync(saveFile: string): Promise<boolean>;
+    orderByLoadOrderAsync(loadOrder: LoadOrder): Promise<OrderByLoadOrderResult>;
+    refreshModulesAsync(): Promise<void>;
+    refreshGameParametersAsync(): Promise<void>;
+    setGameParameterExecutableAsync(executable: string): Promise<void>;
+    setGameParameterSaveFileAsync(saveName: string): Promise<void>;
+    setGameParameterContinueLastSaveFileAsync(value: boolean): Promise<void>;
+    setGameStore(gameStore: GameStore): void;
+    sortAsync(): Promise<void>;
+    sortHelperChangeModulePositionAsync(moduleViewModel: ModuleViewModel, insertIndex: number): Promise<boolean>;
+    sortHelperToggleModuleSelectionAsync(moduleViewModel: ModuleViewModel): Promise<ModuleViewModel>;
+    sortHelperValidateModuleAsync(moduleViewModel: ModuleViewModel): Promise<string[]>;
+    testModule(files: string[]): SupportedResult;
+    dialogTestWarningAsync(): Promise<string>;
+    dialogTestFileOpenAsync(): Promise<string>;
+    setGameParameterLoadOrderAsync(loadOrder: LoadOrder): Promise<void>;
+};

package/dist/module/types/LauncherManager.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LauncherManager.js.map

package/dist/module/types/LauncherManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LauncherManager.js","sourceRoot":"","sources":["../../../src/types/LauncherManager.ts"],"names":[],"mappings":""}

package/dist/module/types/Utils.d.ts

@@ -0,0 +1,11 @@
+import { ModuleInfoExtended, ModuleIssue } from "./BannerlordModuleManager";
+export interface IUtils {
+    isLoadOrderCorrect(modules: Array<ModuleInfoExtended>): Array<string>;
+    getDependencyHint(module: ModuleInfoExtended): string;
+    renderModuleIssue(moduleIssue: ModuleIssue): string;
+    loadLocalization(xml: string): void;
+    setLanguage(language: string): void;
+    localizeString(template: string, values: {
+        [value: string]: string;
+    }): string;
+}

package/dist/module/types/Utils.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Utils.js.map

package/dist/module/types/Utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.js","sourceRoot":"","sources":["../../../src/types/Utils.ts"],"names":[],"mappings":""}

package/dist/module/types/index.d.ts

@@ -0,0 +1,13 @@
+export * from './BannerlordModuleManager';
+export * from './FetchBannerlordVersion';
+export * from './LauncherManager';
+export * from './Utils';
+import { IBannerlordModuleManager } from './BannerlordModuleManager';
+import { IFetchBannerlordVersion } from './FetchBannerlordVersion';
+import { INativeExtension } from './LauncherManager';
+import { IUtils } from './Utils';
+export interface IExtension extends IBannerlordModuleManager, IFetchBannerlordVersion, IUtils, INativeExtension {
+    allocWithOwnership(length: number): Buffer | null;
+    allocWithoutOwnership(length: number): Buffer | null;
+    allocAliveCount(): number;
+}

package/dist/module/types/index.js

@@ -0,0 +1,5 @@
+export * from './BannerlordModuleManager';
+export * from './FetchBannerlordVersion';
+export * from './LauncherManager';
+export * from './Utils';
+//# sourceMappingURL=index.js.map

package/dist/module/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@butr/vortexextensionnative",
-  "version": "2.0.195",
+  "version": "2.0.197",
   "description": "Package of native bindings bundled with TS declarations",
   "main": "dist/main/index.js",
   "typings": "dist/main/index.d.ts",
@@ -53,10 +53,8 @@
     "typescript": "^5.7.3"
   },
   "files": [
-    "dist/main/index.*",
-    "dist/main/lib",
-    "dist/module/index.*",
-    "dist/module/lib",
+    "dist/main",
+    "dist/module",
     "dist/Bannerlord.LauncherManager.Native.dll",
     "dist/launchermanager.node",
     "CHANGELOG.md",