@rel-packages/osu-beatmap-parser 0.1.8 → 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

@@ -24,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,6 +1,6 @@
 {
   "name": "@rel-packages/osu-beatmap-parser",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": ".osu parser for nodejs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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;
 }