@rel-packages/osu-beatmap-parser 0.1.7 → 0.1.9

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export declare function get_property(location: string, key: OsuKey): string;
 export declare function get_properties(input: string | OsuInput, keys: OsuKey[]): Record<OsuKey, string> & {
     id?: string;
 };
-export declare function process_beatmaps(inputs: (string | OsuInput)[], keys: OsuKey[]): Promise<(Record<OsuKey, string> & {
+export declare function process_beatmaps(inputs: (string | OsuInput)[], keys: OsuKey[], update_fn?: (index: number) => void): Promise<(Record<OsuKey, string> & {
     id?: string;
 })[]>;
 export declare function get_duration(location: string): number;

package/dist/index.js

@@ -8,8 +8,9 @@ exports.get_properties = get_properties;
 exports.process_beatmaps = process_beatmaps;
 exports.get_duration = get_duration;
 exports.get_audio_duration = get_audio_duration;
-const bindings_1 = __importDefault(require("bindings"));
-const native = (0, bindings_1.default)("osu-beatmap-parser");
+const node_gyp_build_1 = __importDefault(require("node-gyp-build"));
+const path_1 = __importDefault(require("path"));
+const native = (0, node_gyp_build_1.default)(path_1.default.join(__dirname, ".."));
 function get_property(location, key) {
     return native.get_property(location, key);
 }
@@ -23,9 +24,9 @@ function get_properties(input, keys) {
     return result;
 }
 ;
-async function process_beatmaps(inputs, keys) {
+async function process_beatmaps(inputs, keys, update_fn) {
     const locations = inputs.map(i => typeof i === "string" ? i : i.path);
-    const results = await native.process_beatmaps(locations, keys);
+    const results = await native.process_beatmaps(locations, keys, update_fn);
     return results.map((res, i) => {
         const input = inputs[i];
         if (typeof input !== "string" && input.id) {

package/dist/types.d.ts

@@ -6,7 +6,7 @@ export interface OsuInput {
 export interface INativeExporter {
     get_property(location: string, key: string): string;
     get_properties(location: string, keys: string[]): Record<string, string>;
-    process_beatmaps(locations: string[], keys: string[]): Promise<Record<string, string>[]>;
+    process_beatmaps(locations: string[], keys: string[], callback?: (index: number) => void): Promise<Record<string, string>[]>;
     get_duration(location: string): number;
     get_audio_duration(location: string): number;
 }

package/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@rel-packages/osu-beatmap-parser",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": ".osu parser for nodejs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/mezleca/osu-beatmap-parser",
   "scripts": {
-    "install": "prebuild-install || npm run compile",
     "dev": "npm run compile:native && tsx scripts/verify.ts",
     "compile": "npm run compile:native && npm run compile:tsc",
     "compile:tsc": "tsc",
@@ -19,24 +18,16 @@
   "repository": {
     "url": "https://github.com/mezleca/osu-beatmap-parser.git"
   },
-  "binary": {
-    "module_name": "osu-beatmap-parser",
-    "module_path": "./build/Release/",
-    "host": "https://github.com/mezleca/osu-beatmap-parser/releases/download/",
-    "remote_path": "{version}"
-  },
   "type": "commonjs",
-  "dependencies": {
-    "bindings": "^1.5.0",
-    "prebuild-install": "^7.1.2"
-  },
   "devDependencies": {
     "@types/bindings": "^1.5.5",
     "@types/node": "^24.10.1",
     "cmake-js": "^7.4.0",
     "node-addon-api": "^8.5.0",
-    "prebuild": "^13.0.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "node-gyp-build": "^4.8.4"
   }
 }

package/src/native/addon.cpp

@@ -92,7 +92,14 @@ Napi::Value ParserAddon::get_properties(const Napi::CallbackInfo& info) {
     }
     
     return obj;
-}
+};
+
+struct CallbackContext {
+    Napi::ThreadSafeFunction tsfn;
+    std::atomic<size_t> current_index = 0;
+
+    CallbackContext() {}
+};
 
 struct BatchContext {
     std::vector<std::string> paths;
@@ -100,6 +107,7 @@ struct BatchContext {
     std::vector<std::unordered_map<std::string, std::string>> results;
     std::atomic<size_t> completed_count{0};
     Napi::ThreadSafeFunction tsfn;
+    CallbackContext *callback_ctx;
     Napi::Promise::Deferred deferred;
     bool needs_duration = false;
     
@@ -107,6 +115,8 @@ struct BatchContext {
 };
 
 void process_chunk(BatchContext* context, size_t start, size_t end) {
+    auto callback_ctx = context->callback_ctx;
+
     for (size_t i = start; i < end; i++) {
         std::string content = read_file(context->paths[i]);
         if (!content.empty()) {
@@ -120,13 +130,30 @@ void process_chunk(BatchContext* context, size_t start, size_t end) {
                     context->results[i]["Duration"] = std::to_string(duration);
                 }
             }
+
+            // only increment and call if file was actually processed
+            if (callback_ctx != nullptr) {
+                size_t current = callback_ctx->current_index.fetch_add(1) + 1;
+                callback_ctx->tsfn.NonBlockingCall([current](Napi::Env env, Napi::Function js_callback) {
+                    js_callback.Call({
+                        Napi::Number::New(env, static_cast<double>(current))
+                    });
+                });
+            }
         }
     }
     
     size_t completed = context->completed_count.fetch_add(end - start) + (end - start);
     
+    // last thread to finish resolves
     if (completed == context->paths.size()) {
-        auto callback = [context](Napi::Env env, Napi::Function jsCallback) {
+        // release callback
+        if (context->callback_ctx != nullptr) {
+            context->callback_ctx->tsfn.Release();
+        }
+
+        // then resolve the promise
+        context->tsfn.BlockingCall([context](Napi::Env env, Napi::Function) {
             Napi::Array result_array = Napi::Array::New(env, context->results.size());
             
             for (size_t i = 0; i < context->results.size(); i++) {
@@ -138,9 +165,8 @@ void process_chunk(BatchContext* context, size_t start, size_t end) {
             }
             
             context->deferred.Resolve(result_array);
-        };
+        });
         
-        context->tsfn.BlockingCall(callback);
         context->tsfn.Release();
     }
 }
@@ -171,8 +197,27 @@ Napi::Value ParserAddon::process_beatmaps(const Napi::CallbackInfo& info) {
         }
     }
     
+    if (info[2].IsFunction()) {
+        Napi::Function callback_fn = info[2].As<Napi::Function>();
+        auto callback_ctx = new CallbackContext();
+
+        callback_ctx = new CallbackContext();
+        callback_ctx->tsfn = Napi::ThreadSafeFunction::New(
+            callback_fn.Env(),
+            callback_fn,
+            "ProcessBeatmapsUpdate",
+            0,
+            1,
+            [callback_ctx](Napi::Env) {
+                delete callback_ctx;
+            }
+        );
+
+        context->callback_ctx = callback_ctx;
+    }
+
     context->results.resize(context->paths.size());
-    
+
     context->tsfn = Napi::ThreadSafeFunction::New(
         env,
         NOOP_FUNC(env),

package/src/types.ts

@@ -42,7 +42,7 @@ export interface OsuInput {
 export interface INativeExporter {
     get_property(location: string, key: string): string;
     get_properties(location: string, keys: string[]): Record<string, string>;
-    process_beatmaps(locations: string[], keys: string[]): Promise<Record<string, string>[]>;
+    process_beatmaps(locations: string[], keys: string[], callback?: (index: number) => void): Promise<Record<string, string>[]>;
     get_duration(location: string): number;
     get_audio_duration(location: string): number;
 }