@jamiephan/casclib 0.0.0-dev.0 → 0.0.0-dev.2

package/dist/index.js

@@ -14,107 +14,108 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.File = exports.Storage = exports.CascFile = exports.CascStorage = void 0;
+exports.File = exports.Storage = void 0;
 const bindings_1 = require("./bindings");
-Object.defineProperty(exports, "Storage", { enumerable: true, get: function () { return bindings_1.Storage; } });
-Object.defineProperty(exports, "File", { enumerable: true, get: function () { return bindings_1.File; } });
-class CascStorage {
+class Storage {
     constructor() {
-        this.storage = new bindings_1.Storage();
+        this.storage = new bindings_1.CascStorageBinding();
     }
     open(path, options) {
-        this.storage.open(path, options?.flags || 0);
+        this.storage.CascOpenStorage(path, options?.flags || 0);
     }
     openOnline(path, options) {
-        this.storage.openOnline(path, options?.flags || 0);
+        this.storage.CascOpenOnlineStorage(path, options?.flags || 0);
+    }
+    openEx(params, options) {
+        this.storage.CascOpenStorageEx(params, options);
     }
     close() {
-        return this.storage.close();
+        return this.storage.CascCloseStorage();
     }
     openFile(filename, options) {
-        const file = this.storage.openFile(filename, options?.flags || 0);
-        return new CascFile(file);
+        const file = this.storage.CascOpenFile(filename, options?.flags || 0);
+        return new File(file);
     }
     getFileInfo(filename) {
-        return this.storage.getFileInfo(filename);
+        return this.storage.CascGetFileInfo(filename);
     }
     fileExists(filename) {
         return this.storage.fileExists(filename);
     }
     getStorageInfo(infoClass) {
-        return this.storage.getStorageInfo(infoClass);
+        return this.storage.CascGetStorageInfo(infoClass);
     }
     findFirstFile(mask, listFile) {
-        return this.storage.findFirstFile(mask, listFile);
+        return this.storage.CascFindFirstFile(mask, listFile);
     }
     findNextFile() {
-        return this.storage.findNextFile();
+        return this.storage.CascFindNextFile();
     }
     findClose() {
-        return this.storage.findClose();
+        return this.storage.CascFindClose();
     }
     addEncryptionKey(keyName, key) {
-        return this.storage.addEncryptionKey(keyName, key);
+        return this.storage.CascAddEncryptionKey(keyName, key);
     }
     addStringEncryptionKey(keyName, keyStr) {
-        return this.storage.addStringEncryptionKey(keyName, keyStr);
+        return this.storage.CascAddStringEncryptionKey(keyName, keyStr);
     }
     importKeysFromString(keyList) {
-        return this.storage.importKeysFromString(keyList);
+        return this.storage.CascImportKeysFromString(keyList);
     }
     importKeysFromFile(filePath) {
-        return this.storage.importKeysFromFile(filePath);
+        return this.storage.CascImportKeysFromFile(filePath);
     }
     findEncryptionKey(keyName) {
-        return this.storage.findEncryptionKey(keyName);
+        return this.storage.CascFindEncryptionKey(keyName);
     }
     getNotFoundEncryptionKey() {
-        return this.storage.getNotFoundEncryptionKey();
+        return this.storage.CascGetNotFoundEncryptionKey();
     }
 }
-exports.CascStorage = CascStorage;
-class CascFile {
+exports.Storage = Storage;
+class File {
     constructor(file) {
         this.file = file;
     }
     read(bytesToRead) {
-        return this.file.read(bytesToRead || 4096);
+        return this.file.CascReadFile(bytesToRead || 4096);
     }
     readAll() {
-        return this.file.readAll();
+        return this.file.readFileAll();
     }
     getSize() {
-        return this.file.getSize();
+        return this.file.CascGetFileSize();
     }
     getSize64() {
-        return this.file.getSize64();
+        return this.file.CascGetFileSize64();
     }
     getPosition() {
-        return this.file.getPosition();
+        return this.file.CascGetFilePointer();
     }
     getPosition64() {
-        return this.file.getPosition64();
+        return this.file.CascGetFilePointer64();
     }
     setPosition(position) {
-        return this.file.setPosition(position);
+        return this.file.CascSetFilePointer(position);
     }
     setPosition64(position, moveMethod) {
-        return this.file.setPosition64(position, moveMethod);
+        return this.file.CascSetFilePointer64(position, moveMethod);
     }
     getFileInfo(infoClass) {
-        return this.file.getFileInfo(infoClass);
+        return this.file.CascGetFileInfo(infoClass);
     }
     setFileFlags(flags) {
-        return this.file.setFileFlags(flags);
+        return this.file.CascSetFileFlags(flags);
     }
     close() {
-        return this.file.close();
+        return this.file.CascCloseFile();
     }
 }
-exports.CascFile = CascFile;
+exports.File = File;
 __exportStar(require("./bindings"), exports);
 exports.default = {
-    CascStorage,
-    CascFile
+    Storage,
+    File
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jamiephan/casclib",
-  "version": "0.0.0-dev.0",
+  "version": "0.0.0-dev.2",
   "description": "Node.js native bindings for CascLib - A library to read CASC storage from Blizzard games",
   "repository": {
     "type": "git",

package/src/addon.cpp

@@ -62,6 +62,52 @@ Napi::Value SetError(const Napi::CallbackInfo& info) {
   return env.Undefined();
 }
 
+// Wrapper for CascCdnGetDefault
+Napi::Value CdnGetDefault(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  LPCTSTR cdnUrl = CascCdnGetDefault();
+  
+  if (cdnUrl == nullptr) {
+    return env.Null();
+  }
+  
+  return Napi::String::New(env, cdnUrl);
+}
+
+// Wrapper for CascCdnDownload
+Napi::Value CdnDownload(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 3) {
+    Napi::TypeError::New(env, "Expected cdnHostUrl, product, and fileName as arguments")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsString() || !info[1].IsString() || !info[2].IsString()) {
+    Napi::TypeError::New(env, "All arguments must be strings")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string cdnHostUrl = info[0].As<Napi::String>().Utf8Value();
+  std::string product = info[1].As<Napi::String>().Utf8Value();
+  std::string fileName = info[2].As<Napi::String>().Utf8Value();
+  DWORD dwSize = 0;
+
+  LPBYTE data = CascCdnDownload(cdnHostUrl.c_str(), product.c_str(), fileName.c_str(), &dwSize);
+  
+  if (data == nullptr || dwSize == 0) {
+    return env.Null();
+  }
+
+  // Copy the data to a Node.js Buffer and free the original
+  Napi::Buffer<uint8_t> buffer = Napi::Buffer<uint8_t>::Copy(env, data, dwSize);
+  CascCdnFree(data);
+  
+  return buffer;
+}
+
 Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   // Initialize Storage class
   CascStorage::Init(env, exports);
@@ -70,29 +116,71 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   CascFile::Init(env, exports);
 
   // Export utility functions
-  exports.Set("openLocalFile", Napi::Function::New(env, OpenLocalFile));
-  exports.Set("getError", Napi::Function::New(env, GetError));
-  exports.Set("setError", Napi::Function::New(env, SetError));
+  exports.Set("CascOpenLocalFile", Napi::Function::New(env, OpenLocalFile));
+  exports.Set("GetCascError", Napi::Function::New(env, GetError));
+  exports.Set("SetCascError", Napi::Function::New(env, SetError));
+  
+  // Export CDN functions
+  exports.Set("CascCdnGetDefault", Napi::Function::New(env, CdnGetDefault));
+  exports.Set("CascCdnDownload", Napi::Function::New(env, CdnDownload));
+
+  // Export version constants
+  exports.Set("CASCLIB_VERSION", Napi::Number::New(env, CASCLIB_VERSION));
+
+  // Export file positioning constants
+  #ifdef _WIN32
+    exports.Set("FILE_BEGIN", Napi::Number::New(env, FILE_BEGIN));
+    exports.Set("FILE_CURRENT", Napi::Number::New(env, FILE_CURRENT));
+    exports.Set("FILE_END", Napi::Number::New(env, FILE_END));
+  #else
+    exports.Set("FILE_BEGIN", Napi::Number::New(env, SEEK_SET));
+    exports.Set("FILE_CURRENT", Napi::Number::New(env, SEEK_CUR));
+    exports.Set("FILE_END", Napi::Number::New(env, SEEK_END));
+  #endif
+
+  // Export other useful constants
+  exports.Set("CASC_FILEID_FORMAT", Napi::String::New(env, CASC_FILEID_FORMAT));
+  exports.Set("CASC_PARAM_SEPARATOR", Napi::String::New(env, std::string(1, CASC_PARAM_SEPARATOR)));
+
+  // Export progress message constants
+  exports.Set("CascProgressLoadingFile", Napi::Number::New(env, CascProgressLoadingFile));
+  exports.Set("CascProgressLoadingManifest", Napi::Number::New(env, CascProgressLoadingManifest));
+  exports.Set("CascProgressDownloadingFile", Napi::Number::New(env, CascProgressDownloadingFile));
+  exports.Set("CascProgressLoadingIndexes", Napi::Number::New(env, CascProgressLoadingIndexes));
+  exports.Set("CascProgressDownloadingArchiveIndexes", Napi::Number::New(env, CascProgressDownloadingArchiveIndexes));
 
   // Export constants - Open flags
   exports.Set("CASC_OPEN_BY_NAME", Napi::Number::New(env, CASC_OPEN_BY_NAME));
   exports.Set("CASC_OPEN_BY_CKEY", Napi::Number::New(env, CASC_OPEN_BY_CKEY));
   exports.Set("CASC_OPEN_BY_EKEY", Napi::Number::New(env, CASC_OPEN_BY_EKEY));
   exports.Set("CASC_OPEN_BY_FILEID", Napi::Number::New(env, CASC_OPEN_BY_FILEID));
+  exports.Set("CASC_OPEN_TYPE_MASK", Napi::Number::New(env, CASC_OPEN_TYPE_MASK));
+  exports.Set("CASC_OPEN_FLAGS_MASK", Napi::Number::New(env, CASC_OPEN_FLAGS_MASK));
   exports.Set("CASC_STRICT_DATA_CHECK", Napi::Number::New(env, CASC_STRICT_DATA_CHECK));
   exports.Set("CASC_OVERCOME_ENCRYPTED", Napi::Number::New(env, CASC_OVERCOME_ENCRYPTED));
+  exports.Set("CASC_OPEN_CKEY_ONCE", Napi::Number::New(env, CASC_OPEN_CKEY_ONCE));
 
   // Export constants - Locale flags
   exports.Set("CASC_LOCALE_ALL", Napi::Number::New(env, CASC_LOCALE_ALL));
+  exports.Set("CASC_LOCALE_ALL_WOW", Napi::Number::New(env, CASC_LOCALE_ALL_WOW));
   exports.Set("CASC_LOCALE_NONE", Napi::Number::New(env, CASC_LOCALE_NONE));
+  exports.Set("CASC_LOCALE_UNKNOWN1", Napi::Number::New(env, CASC_LOCALE_UNKNOWN1));
   exports.Set("CASC_LOCALE_ENUS", Napi::Number::New(env, CASC_LOCALE_ENUS));
   exports.Set("CASC_LOCALE_KOKR", Napi::Number::New(env, CASC_LOCALE_KOKR));
+  exports.Set("CASC_LOCALE_RESERVED", Napi::Number::New(env, CASC_LOCALE_RESERVED));
   exports.Set("CASC_LOCALE_FRFR", Napi::Number::New(env, CASC_LOCALE_FRFR));
   exports.Set("CASC_LOCALE_DEDE", Napi::Number::New(env, CASC_LOCALE_DEDE));
   exports.Set("CASC_LOCALE_ZHCN", Napi::Number::New(env, CASC_LOCALE_ZHCN));
   exports.Set("CASC_LOCALE_ESES", Napi::Number::New(env, CASC_LOCALE_ESES));
   exports.Set("CASC_LOCALE_ZHTW", Napi::Number::New(env, CASC_LOCALE_ZHTW));
   exports.Set("CASC_LOCALE_ENGB", Napi::Number::New(env, CASC_LOCALE_ENGB));
+  exports.Set("CASC_LOCALE_ENCN", Napi::Number::New(env, CASC_LOCALE_ENCN));
+  exports.Set("CASC_LOCALE_ENTW", Napi::Number::New(env, CASC_LOCALE_ENTW));
+  exports.Set("CASC_LOCALE_ESMX", Napi::Number::New(env, CASC_LOCALE_ESMX));
+  exports.Set("CASC_LOCALE_RURU", Napi::Number::New(env, CASC_LOCALE_RURU));
+  exports.Set("CASC_LOCALE_PTBR", Napi::Number::New(env, CASC_LOCALE_PTBR));
+  exports.Set("CASC_LOCALE_ITIT", Napi::Number::New(env, CASC_LOCALE_ITIT));
+  exports.Set("CASC_LOCALE_PTPT", Napi::Number::New(env, CASC_LOCALE_PTPT));
 
   // Export constants - Content flags
   exports.Set("CASC_CFLAG_INSTALL", Napi::Number::New(env, CASC_CFLAG_INSTALL));
@@ -100,27 +188,62 @@ Napi::Object InitAll(Napi::Env env, Napi::Object exports) {
   exports.Set("CASC_CFLAG_LOAD_ON_MAC", Napi::Number::New(env, CASC_CFLAG_LOAD_ON_MAC));
   exports.Set("CASC_CFLAG_X86_32", Napi::Number::New(env, CASC_CFLAG_X86_32));
   exports.Set("CASC_CFLAG_X86_64", Napi::Number::New(env, CASC_CFLAG_X86_64));
+  exports.Set("CASC_CFLAG_LOW_VIOLENCE", Napi::Number::New(env, CASC_CFLAG_LOW_VIOLENCE));
+  exports.Set("CASC_CFLAG_DONT_LOAD", Napi::Number::New(env, CASC_CFLAG_DONT_LOAD));
+  exports.Set("CASC_CFLAG_UPDATE_PLUGIN", Napi::Number::New(env, CASC_CFLAG_UPDATE_PLUGIN));
+  exports.Set("CASC_CFLAG_ARM64", Napi::Number::New(env, CASC_CFLAG_ARM64));
   exports.Set("CASC_CFLAG_ENCRYPTED", Napi::Number::New(env, CASC_CFLAG_ENCRYPTED));
+  exports.Set("CASC_CFLAG_NO_NAME_HASH", Napi::Number::New(env, CASC_CFLAG_NO_NAME_HASH));
+  exports.Set("CASC_CFLAG_UNCMN_RESOLUTION", Napi::Number::New(env, CASC_CFLAG_UNCMN_RESOLUTION));
+  exports.Set("CASC_CFLAG_BUNDLE", Napi::Number::New(env, CASC_CFLAG_BUNDLE));
+  exports.Set("CASC_CFLAG_NO_COMPRESSION", Napi::Number::New(env, CASC_CFLAG_NO_COMPRESSION));
+
+  // Export constants - Hash sizes
+  exports.Set("MD5_HASH_SIZE", Napi::Number::New(env, MD5_HASH_SIZE));
+  exports.Set("MD5_STRING_SIZE", Napi::Number::New(env, MD5_STRING_SIZE));
+  exports.Set("SHA1_HASH_SIZE", Napi::Number::New(env, SHA1_HASH_SIZE));
+  exports.Set("SHA1_STRING_SIZE", Napi::Number::New(env, SHA1_STRING_SIZE));
+
+  // Export constants - Invalid values
+  exports.Set("CASC_INVALID_INDEX", Napi::Number::New(env, CASC_INVALID_INDEX));
+  exports.Set("CASC_INVALID_SIZE", Napi::Number::New(env, CASC_INVALID_SIZE));
+  exports.Set("CASC_INVALID_POS", Napi::Number::New(env, CASC_INVALID_POS));
+  exports.Set("CASC_INVALID_ID", Napi::Number::New(env, CASC_INVALID_ID));
+  exports.Set("CASC_INVALID_OFFS64", Napi::Number::New(env, (double)CASC_INVALID_OFFS64));
+  exports.Set("CASC_INVALID_SIZE64", Napi::Number::New(env, (double)CASC_INVALID_SIZE64));
+  // Note: CASC_INVALID_SIZE_T is (size_t)(-1), which may not be accurately representable in JS
 
   // Export constants - Storage info classes
   exports.Set("CascStorageLocalFileCount", Napi::Number::New(env, CascStorageLocalFileCount));
   exports.Set("CascStorageTotalFileCount", Napi::Number::New(env, CascStorageTotalFileCount));
   exports.Set("CascStorageFeatures", Napi::Number::New(env, CascStorageFeatures));
+  exports.Set("CascStorageInstalledLocales", Napi::Number::New(env, CascStorageInstalledLocales));
   exports.Set("CascStorageProduct", Napi::Number::New(env, CascStorageProduct));
+  exports.Set("CascStorageTags", Napi::Number::New(env, CascStorageTags));
+  exports.Set("CascStoragePathProduct", Napi::Number::New(env, CascStoragePathProduct));
 
   // Export constants - File info classes
   exports.Set("CascFileContentKey", Napi::Number::New(env, CascFileContentKey));
   exports.Set("CascFileEncodedKey", Napi::Number::New(env, CascFileEncodedKey));
   exports.Set("CascFileFullInfo", Napi::Number::New(env, CascFileFullInfo));
+  exports.Set("CascFileSpanInfo", Napi::Number::New(env, CascFileSpanInfo));
 
   // Export constants - Feature flags
   exports.Set("CASC_FEATURE_FILE_NAMES", Napi::Number::New(env, CASC_FEATURE_FILE_NAMES));
   exports.Set("CASC_FEATURE_ROOT_CKEY", Napi::Number::New(env, CASC_FEATURE_ROOT_CKEY));
   exports.Set("CASC_FEATURE_TAGS", Napi::Number::New(env, CASC_FEATURE_TAGS));
+  exports.Set("CASC_FEATURE_FNAME_HASHES", Napi::Number::New(env, CASC_FEATURE_FNAME_HASHES));
+  exports.Set("CASC_FEATURE_FNAME_HASHES_OPTIONAL", Napi::Number::New(env, CASC_FEATURE_FNAME_HASHES_OPTIONAL));
   exports.Set("CASC_FEATURE_FILE_DATA_IDS", Napi::Number::New(env, CASC_FEATURE_FILE_DATA_IDS));
   exports.Set("CASC_FEATURE_LOCALE_FLAGS", Napi::Number::New(env, CASC_FEATURE_LOCALE_FLAGS));
   exports.Set("CASC_FEATURE_CONTENT_FLAGS", Napi::Number::New(env, CASC_FEATURE_CONTENT_FLAGS));
+  exports.Set("CASC_FEATURE_DATA_ARCHIVES", Napi::Number::New(env, CASC_FEATURE_DATA_ARCHIVES));
+  exports.Set("CASC_FEATURE_DATA_FILES", Napi::Number::New(env, CASC_FEATURE_DATA_FILES));
   exports.Set("CASC_FEATURE_ONLINE", Napi::Number::New(env, CASC_FEATURE_ONLINE));
+  exports.Set("CASC_FEATURE_FORCE_DOWNLOAD", Napi::Number::New(env, CASC_FEATURE_FORCE_DOWNLOAD));
+
+  // Export constants - Key length
+  exports.Set("CASC_KEY_LENGTH", Napi::Number::New(env, CASC_KEY_LENGTH));
 
   return exports;
 }

package/src/file.cpp

@@ -7,17 +7,17 @@ Napi::Object CascFile::Init(Napi::Env env, Napi::Object exports) {
   Napi::HandleScope scope(env);
 
   Napi::Function func = DefineClass(env, "File", {
-    InstanceMethod("read", &CascFile::Read),
-    InstanceMethod("readAll", &CascFile::ReadAll),
-    InstanceMethod("getSize", &CascFile::GetSize),
-    InstanceMethod("getSize64", &CascFile::GetSize64),
-    InstanceMethod("getPosition", &CascFile::GetPosition),
-    InstanceMethod("getPosition64", &CascFile::GetPosition64),
-    InstanceMethod("setPosition", &CascFile::SetPosition),
-    InstanceMethod("setPosition64", &CascFile::SetPosition64),
-    InstanceMethod("getFileInfo", &CascFile::GetFileInfo),
-    InstanceMethod("setFileFlags", &CascFile::SetFileFlags),
-    InstanceMethod("close", &CascFile::Close)
+    InstanceMethod("CascReadFile", &CascFile::Read),
+    InstanceMethod("readFileAll", &CascFile::ReadAll),
+    InstanceMethod("CascGetFileSize", &CascFile::GetSize),
+    InstanceMethod("CascGetFileSize64", &CascFile::GetSize64),
+    InstanceMethod("CascGetFilePointer", &CascFile::GetPosition),
+    InstanceMethod("CascGetFilePointer64", &CascFile::GetPosition64),
+    InstanceMethod("CascSetFilePointer", &CascFile::SetPosition),
+    InstanceMethod("CascSetFilePointer64", &CascFile::SetPosition64),
+    InstanceMethod("CascGetFileInfo", &CascFile::GetFileInfo),
+    InstanceMethod("CascSetFileFlags", &CascFile::SetFileFlags),
+    InstanceMethod("CascCloseFile", &CascFile::Close)
   });
 
   constructor = Napi::Persistent(func);

package/src/storage.cpp

@@ -8,22 +8,23 @@ Napi::Object CascStorage::Init(Napi::Env env, Napi::Object exports) {
   Napi::HandleScope scope(env);
 
   Napi::Function func = DefineClass(env, "Storage", {
-    InstanceMethod("open", &CascStorage::Open),
-    InstanceMethod("openOnline", &CascStorage::OpenOnline),
-    InstanceMethod("close", &CascStorage::Close),
-    InstanceMethod("openFile", &CascStorage::OpenFile),
-    InstanceMethod("getFileInfo", &CascStorage::GetFileInfo),
+    InstanceMethod("CascOpenStorage", &CascStorage::Open),
+    InstanceMethod("CascOpenOnlineStorage", &CascStorage::OpenOnline),
+    InstanceMethod("CascOpenStorageEx", &CascStorage::OpenEx),
+    InstanceMethod("CascCloseStorage", &CascStorage::Close),
+    InstanceMethod("CascOpenFile", &CascStorage::OpenFile),
+    InstanceMethod("CascGetFileInfo", &CascStorage::GetFileInfo),
     InstanceMethod("fileExists", &CascStorage::FileExists),
-    InstanceMethod("getStorageInfo", &CascStorage::GetStorageInfo),
-    InstanceMethod("findFirstFile", &CascStorage::FindFirstFile),
-    InstanceMethod("findNextFile", &CascStorage::FindNextFile),
-    InstanceMethod("findClose", &CascStorage::FindClose),
-    InstanceMethod("addEncryptionKey", &CascStorage::AddEncryptionKey),
-    InstanceMethod("addStringEncryptionKey", &CascStorage::AddStringEncryptionKey),
-    InstanceMethod("importKeysFromString", &CascStorage::ImportKeysFromString),
-    InstanceMethod("importKeysFromFile", &CascStorage::ImportKeysFromFile),
-    InstanceMethod("findEncryptionKey", &CascStorage::FindEncryptionKey),
-    InstanceMethod("getNotFoundEncryptionKey", &CascStorage::GetNotFoundEncryptionKey)
+    InstanceMethod("CascGetStorageInfo", &CascStorage::GetStorageInfo),
+    InstanceMethod("CascFindFirstFile", &CascStorage::FindFirstFile),
+    InstanceMethod("CascFindNextFile", &CascStorage::FindNextFile),
+    InstanceMethod("CascFindClose", &CascStorage::FindClose),
+    InstanceMethod("CascAddEncryptionKey", &CascStorage::AddEncryptionKey),
+    InstanceMethod("CascAddStringEncryptionKey", &CascStorage::AddStringEncryptionKey),
+    InstanceMethod("CascImportKeysFromString", &CascStorage::ImportKeysFromString),
+    InstanceMethod("CascImportKeysFromFile", &CascStorage::ImportKeysFromFile),
+    InstanceMethod("CascFindEncryptionKey", &CascStorage::FindEncryptionKey),
+    InstanceMethod("CascGetNotFoundEncryptionKey", &CascStorage::GetNotFoundEncryptionKey)
   });
 
   constructor = Napi::Persistent(func);
@@ -243,6 +244,94 @@ Napi::Value CascStorage::OpenOnline(const Napi::CallbackInfo& info) {
   return Napi::Boolean::New(env, true);
 }
 
+Napi::Value CascStorage::OpenEx(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() < 1) {
+    Napi::TypeError::New(env, "Expected at least params string as first argument")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsString()) {
+    Napi::TypeError::New(env, "First argument must be a string")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (isOpen) {
+    Napi::Error::New(env, "Storage is already open")
+      .ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  std::string params = info[0].As<Napi::String>().Utf8Value();
+  
+  // Initialize CASC_OPEN_STORAGE_ARGS structure
+  CASC_OPEN_STORAGE_ARGS args = {0};
+  args.Size = sizeof(CASC_OPEN_STORAGE_ARGS);
+  args.dwLocaleMask = CASC_LOCALE_ALL;
+  args.dwFlags = 0;
+
+  bool bOnlineStorage = false;
+
+  // If second argument is an options object
+  if (info.Length() > 1 && info[1].IsObject()) {
+    Napi::Object options = info[1].As<Napi::Object>();
+
+    // Extract optional parameters
+    if (options.Has("localPath") && options.Get("localPath").IsString()) {
+      // LocalPath is stored temporarily - we'll use params for szLocalPath instead
+    }
+
+    if (options.Has("codeName") && options.Get("codeName").IsString()) {
+      static std::string codeName;
+      codeName = options.Get("codeName").As<Napi::String>().Utf8Value();
+      args.szCodeName = codeName.c_str();
+    }
+
+    if (options.Has("region") && options.Get("region").IsString()) {
+      static std::string region;
+      region = options.Get("region").As<Napi::String>().Utf8Value();
+      args.szRegion = region.c_str();
+    }
+
+    if (options.Has("localeMask") && options.Get("localeMask").IsNumber()) {
+      args.dwLocaleMask = options.Get("localeMask").As<Napi::Number>().Uint32Value();
+    }
+
+    if (options.Has("flags") && options.Get("flags").IsNumber()) {
+      args.dwFlags = options.Get("flags").As<Napi::Number>().Uint32Value();
+    }
+
+    if (options.Has("buildKey") && options.Get("buildKey").IsString()) {
+      static std::string buildKey;
+      buildKey = options.Get("buildKey").As<Napi::String>().Utf8Value();
+      args.szBuildKey = buildKey.c_str();
+    }
+
+    if (options.Has("cdnHostUrl") && options.Get("cdnHostUrl").IsString()) {
+      static std::string cdnHostUrl;
+      cdnHostUrl = options.Get("cdnHostUrl").As<Napi::String>().Utf8Value();
+      args.szCdnHostUrl = cdnHostUrl.c_str();
+    }
+
+    if (options.Has("online") && options.Get("online").IsBoolean()) {
+      bOnlineStorage = options.Get("online").As<Napi::Boolean>().Value();
+    }
+  }
+
+  // Call CascOpenStorageEx
+  if (!CascOpenStorageEx(params.c_str(), &args, bOnlineStorage, &hStorage)) {
+    std::string error = "Failed to open CASC storage with extended parameters: " + params;
+    Napi::Error::New(env, error).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  isOpen = true;
+  return Napi::Boolean::New(env, true);
+}
+
 Napi::Value CascStorage::GetStorageInfo(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -332,11 +421,17 @@ Napi::Value CascStorage::FindFirstFile(const Napi::CallbackInfo& info) {
 
   Napi::Object result = Napi::Object::New(env);
   result.Set("fileName", Napi::String::New(env, findData.szFileName));
+  result.Set("ckey", Napi::Buffer<BYTE>::Copy(env, findData.CKey, MD5_HASH_SIZE));
+  result.Set("ekey", Napi::Buffer<BYTE>::Copy(env, findData.EKey, MD5_HASH_SIZE));
+  result.Set("tagBitMask", Napi::Number::New(env, (double)findData.TagBitMask));
   result.Set("fileSize", Napi::Number::New(env, (double)findData.FileSize));
+  result.Set("plainName", findData.szPlainName ? Napi::String::New(env, findData.szPlainName) : env.Null());
   result.Set("fileDataId", Napi::Number::New(env, findData.dwFileDataId));
   result.Set("localeFlags", Napi::Number::New(env, findData.dwLocaleFlags));
   result.Set("contentFlags", Napi::Number::New(env, findData.dwContentFlags));
+  result.Set("spanCount", Napi::Number::New(env, findData.dwSpanCount));
   result.Set("available", Napi::Boolean::New(env, findData.bFileAvailable));
+  result.Set("nameType", Napi::Number::New(env, findData.NameType));
 
   return result;
 }
@@ -357,11 +452,17 @@ Napi::Value CascStorage::FindNextFile(const Napi::CallbackInfo& info) {
 
   Napi::Object result = Napi::Object::New(env);
   result.Set("fileName", Napi::String::New(env, findData.szFileName));
+  result.Set("ckey", Napi::Buffer<BYTE>::Copy(env, findData.CKey, MD5_HASH_SIZE));
+  result.Set("ekey", Napi::Buffer<BYTE>::Copy(env, findData.EKey, MD5_HASH_SIZE));
+  result.Set("tagBitMask", Napi::Number::New(env, (double)findData.TagBitMask));
   result.Set("fileSize", Napi::Number::New(env, (double)findData.FileSize));
+  result.Set("plainName", findData.szPlainName ? Napi::String::New(env, findData.szPlainName) : env.Null());
   result.Set("fileDataId", Napi::Number::New(env, findData.dwFileDataId));
   result.Set("localeFlags", Napi::Number::New(env, findData.dwLocaleFlags));
   result.Set("contentFlags", Napi::Number::New(env, findData.dwContentFlags));
+  result.Set("spanCount", Napi::Number::New(env, findData.dwSpanCount));
   result.Set("available", Napi::Boolean::New(env, findData.bFileAvailable));
+  result.Set("nameType", Napi::Number::New(env, findData.NameType));
 
   return result;
 }

package/src/storage.h

@@ -16,6 +16,7 @@ private:
   // Methods
   Napi::Value Open(const Napi::CallbackInfo& info);
   Napi::Value OpenOnline(const Napi::CallbackInfo& info);
+  Napi::Value OpenEx(const Napi::CallbackInfo& info);
   Napi::Value Close(const Napi::CallbackInfo& info);
   Napi::Value OpenFile(const Napi::CallbackInfo& info);
   Napi::Value GetFileInfo(const Napi::CallbackInfo& info);