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

package/README.md

@@ -13,4 +13,9 @@ npm install osu-beatmap-parser
 ```bash
 npm install
 npm run compile
-```
+```
+
+## TODO
+- [ ] native: handle "Storyboard" key
+- [ ] native: handle beatmap file version
+- [ ] native: handle lazer files (like, if we're trying to get AudioLocation from a lazer file, we will need to follow the hashed lazer path)

package/dist/index.d.ts

@@ -1,11 +1,5 @@
 import { OsuKey, OsuInput } from "./types";
-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[], update_fn?: (index: number) => void): Promise<(Record<OsuKey, string> & {
-    id?: string;
-})[]>;
-export declare function get_duration(location: string): number;
-export declare function get_audio_duration(location: string): number;
-export { OsuKey, OsuInput };
+import { init_wasm } from "./lib/bindings";
+export declare const get_property: (data: Uint8Array, key: OsuKey) => any;
+export declare const get_properties: (input: Uint8Array | OsuInput, keys: OsuKey[]) => any;
+export { OsuKey, OsuInput, init_wasm };

package/dist/index.js

@@ -1,46 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.init_wasm = exports.get_properties = exports.get_property = void 0;
+const bindings_1 = require("./lib/bindings");
+Object.defineProperty(exports, "init_wasm", { enumerable: true, get: function () { return bindings_1.init_wasm; } });
+const get_property = (data, key) => {
+    return bindings_1.native.get_property(data, key);
+};
 exports.get_property = get_property;
-exports.get_properties = get_properties;
-exports.process_beatmaps = process_beatmaps;
-exports.get_duration = get_duration;
-exports.get_audio_duration = get_audio_duration;
-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);
-}
-;
-function get_properties(input, keys) {
-    const location = typeof input === "string" ? input : input.path;
-    const result = native.get_properties(location, keys);
-    if (typeof input !== "string" && input.id) {
+const get_properties = (input, keys) => {
+    const data = input instanceof Uint8Array ? input : input.data;
+    const result = bindings_1.native.get_properties(data, keys);
+    if (!(input instanceof Uint8Array) && input.id) {
         return { ...result, id: input.id };
     }
     return result;
-}
-;
-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, update_fn);
-    return results.map((res, i) => {
-        const input = inputs[i];
-        if (typeof input !== "string" && input.id) {
-            return { ...res, id: input.id };
-        }
-        return res;
-    });
-}
-;
-function get_duration(location) {
-    return native.get_duration(location);
-}
-;
-function get_audio_duration(location) {
-    return native.get_audio_duration(location);
-}
-;
+};
+exports.get_properties = get_properties;

package/dist/lib/bindings.d.ts

@@ -0,0 +1,2 @@
+export declare const init_wasm: () => Promise<void>;
+export declare let native: any;

package/dist/lib/bindings.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.native = exports.init_wasm = void 0;
+const IS_BROWSER = globalThis.window != undefined;
+const wasm_proxy = {
+    instance: null,
+    init_promise: null,
+    get_property: (data, key) => {
+        if (wasm_proxy.instance == null)
+            throw Error("WASM not loaded yet...");
+        const wasm_inst = wasm_proxy.instance;
+        const buffer_ptr = wasm_inst._malloc(data.length);
+        wasm_inst.HEAPU8.set(data, buffer_ptr);
+        const result = wasm_inst.get_property(buffer_ptr, data.length, key);
+        wasm_inst._free(buffer_ptr);
+        return result;
+    },
+    get_properties: (data, keys) => {
+        if (wasm_proxy.instance == null)
+            throw Error("WASM not loaded yet...");
+        const wasm_inst = wasm_proxy.instance;
+        const buffer_ptr = wasm_inst._malloc(data.length);
+        wasm_inst.HEAPU8.set(data, buffer_ptr);
+        const result = wasm_inst.get_properties(buffer_ptr, data.length, keys);
+        wasm_inst._free(buffer_ptr);
+        return result;
+    },
+};
+const init_wasm = async () => {
+    if (!IS_BROWSER)
+        return;
+    if (wasm_proxy.instance)
+        return;
+    if (wasm_proxy.init_promise)
+        return wasm_proxy.init_promise;
+    wasm_proxy.init_promise = (async () => {
+        // try dynamic import first, fallback to globalThis
+        let create_func;
+        try {
+            // @ts-ignore
+            const mod = await Promise.resolve().then(() => __importStar(require("../../build/osu-beatmap-parser.js")));
+            create_func = mod.default || mod.create_osu_parser;
+        }
+        catch (e) {
+            create_func = globalThis.create_osu_parser;
+        }
+        if (!create_func) {
+            throw Error("create_osu_parser not found");
+        }
+        wasm_proxy.instance = await create_func();
+    })();
+    return wasm_proxy.init_promise;
+};
+exports.init_wasm = init_wasm;
+const load_native_module = () => {
+    if (IS_BROWSER) {
+        return wasm_proxy;
+    }
+    try {
+        const fs = require("fs");
+        const path = require("path");
+        const platform = process.platform;
+        const arch = process.arch;
+        const paths = [
+            // prebuilt binaries
+            path.join(__dirname, "..", "..", "prebuilds", `${platform}-${arch}`, "osu-beatmap-parser.node"),
+            path.join(__dirname, "..", "prebuilds", `${platform}-${arch}`, "osu-beatmap-parser.node"),
+            // local builds
+            path.join(__dirname, "..", "..", "build", "osu-beatmap-parser.node"),
+            path.join(__dirname, "..", "..", "build", "Release", "osu-beatmap-parser.node"),
+            path.join(__dirname, "..", "build", "osu-beatmap-parser.node"),
+            path.join(__dirname, "build", "osu-beatmap-parser.node"),
+        ];
+        for (const p of paths) {
+            if (fs.existsSync(p)) {
+                return require(p);
+            }
+        }
+    }
+    catch (e) { }
+    return false;
+};
+exports.native = load_native_module();
+if (exports.native == false && !IS_BROWSER) {
+    throw new Error("failed to load native module...");
+}

package/dist/types.d.ts

@@ -1,12 +1,9 @@
 export type OsuKey = "AudioFilename" | "AudioLeadIn" | "PreviewTime" | "Countdown" | "SampleSet" | "StackLeniency" | "Mode" | "LetterboxInBreaks" | "WidescreenStoryboard" | "Bookmarks" | "DistanceSpacing" | "BeatDivisor" | "GridSize" | "TimelineZoom" | "Title" | "TitleUnicode" | "Artist" | "ArtistUnicode" | "Creator" | "Version" | "Source" | "Tags" | "BeatmapID" | "BeatmapSetID" | "HPDrainRate" | "CircleSize" | "OverallDifficulty" | "ApproachRate" | "SliderMultiplier" | "SliderTickRate" | "Background" | "Video" | "Storyboard" | "Duration";
 export interface OsuInput {
-    path: string;
+    data: Uint8Array;
     id?: string;
 }
 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[], callback?: (index: number) => void): Promise<Record<string, string>[]>;
-    get_duration(location: string): number;
-    get_audio_duration(location: string): number;
+    get_property(data: Uint8Array, key: string): string;
+    get_properties(data: Uint8Array, keys: string[]): Record<string, string>;
 }

package/package.json

@@ -1,24 +1,43 @@
 {
   "name": "@rel-packages/osu-beatmap-parser",
-  "version": "0.1.9",
+  "version": "1.0.4",
   "description": ".osu parser for nodejs",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "homepage": "https://github.com/mezleca/osu-beatmap-parser",
   "scripts": {
-    "dev": "npm run compile:native && tsx scripts/verify.ts",
-    "compile": "npm run compile:native && npm run compile:tsc",
+    "update:patch": "npm version patch && git push --follow-tags",
+    "update:minor": "npm version minor && git push --follow-tags",
+    "update:major": "npm version major && git push --follow-tags",
+    "prepublishOnly": "npm run compile:tsc && mkdir -p lib",
+    "compile:native": "tsx scripts/build.ts native",
+    "compile:wasm": "tsx scripts/build.ts wasm",
     "compile:tsc": "tsc",
-    "compile:native": "cmake-js build",
-    "prebuild": "prebuild --backend cmake-js --strip --verbose"
+    "build": "tsx scripts/build.ts all && npm run compile:tsc",
+    "example:wasm": "bun run compile:wasm && bun run examples/wasm/server.ts",
+    "example:node": "bun run compile:native && tsx examples/node/index.ts"
   },
-  "keywords": [],
+  "keywords": [
+    "osu",
+    "beatmap",
+    "parser",
+    "native"
+  ],
   "author": "",
   "license": "ISC",
   "repository": {
     "url": "https://github.com/mezleca/osu-beatmap-parser.git"
   },
   "type": "commonjs",
+  "files": [
+    "dist/",
+    "prebuilds/",
+    "build/*.node",
+    "build/*.wasm",
+    "build/*.js",
+    "lib/bindings.ts",
+    "README.md"
+  ],
   "devDependencies": {
     "@types/bindings": "^1.5.5",
     "@types/node": "^24.10.1",
@@ -27,7 +46,6 @@
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   },
-  "dependencies": {
-    "node-gyp-build": "^4.8.4"
-  }
-}
+  "dependencies": {},
+  "optionalDependencies": {}
+}

package/.prebuildrc

@@ -1,6 +0,0 @@
-{
-  "upload": "gh release upload {tag_name} {file_path} --repo={owner}/{repo} --clobber",
-  "download": "https://github.com/{owner}/{repo}/releases/download/{tag}/{file_name}",
-  "tag-prefix": "v",
-  "backend": "cmake-js"
-}

package/CMakeLists.txt

@@ -1,68 +0,0 @@
-cmake_minimum_required(VERSION 3.16)
-
-if(WIN32)
-    if(NOT DEFINED CMAKE_TOOLCHAIN_FILE)
-        if(EXISTS "${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
-            set(CMAKE_TOOLCHAIN_FILE "${CMAKE_SOURCE_DIR}/vcpkg/scripts/buildsystems/vcpkg.cmake")
-        elseif(EXISTS "C:/vcpkg/scripts/buildsystems/vcpkg.cmake")
-            set(CMAKE_TOOLCHAIN_FILE "C:/vcpkg/scripts/buildsystems/vcpkg.cmake")
-        endif()
-    endif()
-    set(VCPKG_TARGET_TRIPLET "x64-windows-static")
-endif()
-
-project(osu-beatmap-parser VERSION 0.0.1)
-
-set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(BUILD_TESTING OFF CACHE BOOL "Build tests" FORCE)
-set(BUILD_SHARED_LIBS ON CACHE BOOL "Build shared libraries")
-
-file(GLOB_RECURSE SOURCES CONFIGURE_DEPENDS "src/native/*.cpp")
-file(GLOB_RECURSE HEADERS CONFIGURE_DEPENDS "src/native/*.hpp")
-
-if(WIN32)
-    find_package(SndFile CONFIG REQUIRED)
-    set(SNDFILE_LIBRARIES SndFile::sndfile)
-else()
-    find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SNDFILE REQUIRED sndfile)
-endif()
-
-execute_process(
-  COMMAND node -p "require('node-addon-api').include"
-  WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-  OUTPUT_VARIABLE NODE_ADDON_API_DIR
-  OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-string(REPLACE "\"" "" NODE_ADDON_API_DIR ${NODE_ADDON_API_DIR})
-
-add_library(${PROJECT_NAME} SHARED ${SOURCES} ${HEADERS} ${CMAKE_JS_SRC})
-
-set_target_properties(${PROJECT_NAME} PROPERTIES 
-    PREFIX "" 
-    SUFFIX ".node"
-    CXX_STANDARD 17
-    CXX_STANDARD_REQUIRED ON
-)
-
-if (MSVC)
-    set(MSVC_RUNTIME_LIBRARY OFF)
-    add_compile_definitions(_SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING)
-    execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF} /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})
-    target_compile_options(${PROJECT_NAME} PRIVATE /Zc:__cplusplus)
-endif()
-
-target_include_directories(${PROJECT_NAME} PRIVATE
-    ${NODE_ADDON_API_DIR}
-    ${CMAKE_JS_INC}
-    ${SNDFILE_INCLUDE_DIRS}
-)
-
-target_link_libraries(
-    ${PROJECT_NAME} 
-    ${CMAKE_JS_LIB}
-    ${SNDFILE_LIBRARIES}
-)

package/src/native/addon.cpp

@@ -1,310 +0,0 @@
-#include <filesystem>
-#include <napi.h>
-#include <iostream>
-#include <sndfile.h>
-#include <string>
-#include <thread>
-#include <fstream>
-#include <vector>
-#include <atomic>
-#include "osu/parser.hpp"
-#include "osu/audio.hpp"
-#include "addon.hpp"
-#include "pool.hpp"
-
-#define NOOP_FUNC(env) Napi::Function::New(env, [](const Napi::CallbackInfo& info){})
-
-AudioAnalyzer audio_analizer;
-
-std::filesystem::path dirname(const std::string &path) {
-    std::filesystem::path p(path);
-    return p.parent_path();
-}
-
-std::string read_file(const std::string& path) {
-    std::ifstream file(path, std::ios::binary | std::ios::ate);
-
-    if (!file.is_open()) {
-        return "";
-    }
-
-    std::streamsize size = file.tellg();
-    file.seekg(0, std::ios::beg);
-
-    std::string buffer(size, ' ');
-
-    if (file.read(buffer.data(), size)) {
-        return buffer;
-    }
-
-    return "";
-}
-
-Napi::Value ParserAddon::get_property(const Napi::CallbackInfo& info) {
-    if (info.Length() < 2) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    if (!info[0].IsString() || !info[1].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::string key = info[1].As<Napi::String>().Utf8Value();
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    return Napi::String::From(info.Env(), osu_parser::get_property(content, key));
-}
-
-Napi::Value ParserAddon::get_properties(const Napi::CallbackInfo& info) {
-    if (info.Length() < 2) {
-        return Napi::Object::New(info.Env());
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    Napi::Array keys_array = info[1].As<Napi::Array>();
-    
-    std::vector<std::string> keys;
-
-    for (uint32_t i = 0; i < keys_array.Length(); i++) {
-        Napi::Value val = keys_array[i];
-        if (val.IsString()) {
-            keys.push_back(val.As<Napi::String>().Utf8Value());
-        }
-    }
-
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::Object::New(info.Env());
-    }
-
-    auto results = osu_parser::get_properties(content, keys);
-
-    Napi::Object obj = Napi::Object::New(info.Env());
-
-    for (const auto& [k, v] : results) {
-        obj.Set(k, v);
-    }
-    
-    return obj;
-};
-
-struct CallbackContext {
-    Napi::ThreadSafeFunction tsfn;
-    std::atomic<size_t> current_index = 0;
-
-    CallbackContext() {}
-};
-
-struct BatchContext {
-    std::vector<std::string> paths;
-    std::vector<std::string> keys;
-    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;
-    
-    BatchContext(Napi::Env env) : deferred(Napi::Promise::Deferred::New(env)) {}
-};
-
-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()) {
-            context->results[i] = osu_parser::get_properties(content, context->keys);
-            
-            if (context->needs_duration) {
-                std::string audio_file_name = osu_parser::get_property(content, "AudioFilename");
-                if (!audio_file_name.empty()) {
-                    std::filesystem::path audio_path = dirname(context->paths[i]) / audio_file_name;
-                    double duration = audio_analizer.get_audio_duration(audio_path.string());
-                    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()) {
-        // 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++) {
-                Napi::Object obj = Napi::Object::New(env);
-                for (const auto& [k, v] : context->results[i]) {
-                    obj.Set(k, v);
-                }
-                result_array[i] = obj;
-            }
-            
-            context->deferred.Resolve(result_array);
-        });
-        
-        context->tsfn.Release();
-    }
-}
-
-Napi::Value ParserAddon::process_beatmaps(const Napi::CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    
-    if (info.Length() < 2) {
-        auto deferred = Napi::Promise::Deferred::New(env);
-        deferred.Reject(Napi::String::New(env, "Invalid arguments"));
-        return deferred.Promise();
-    }
-
-    Napi::Array paths_array = info[0].As<Napi::Array>();
-    Napi::Array keys_array = info[1].As<Napi::Array>();
-
-    auto context = new BatchContext(env);
-    
-    for (uint32_t i = 0; i < paths_array.Length(); i++) {
-        context->paths.push_back(Napi::Value(paths_array[i]).As<Napi::String>().Utf8Value());
-    }
-    
-    for (uint32_t i = 0; i < keys_array.Length(); i++) {
-        std::string key = Napi::Value(keys_array[i]).As<Napi::String>().Utf8Value();
-        context->keys.push_back(key);
-        if (key == "Duration") {
-            context->needs_duration = true;
-        }
-    }
-    
-    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),
-        "ProcessBeatmaps",
-        0,
-        1,
-        [context](Napi::Env) {
-            delete context;
-        }
-    );
-
-    size_t total_files = context->paths.size();
-    size_t thread_count = std::thread::hardware_concurrency();
-
-    if (thread_count == 0) {
-        thread_count = 1;
-    }
-    
-    size_t chunk_size = (total_files + thread_count - 1) / thread_count;
-    
-    for (size_t t = 0; t < thread_count; t++) {
-        size_t start = t * chunk_size;
-        size_t end = std::min(start + chunk_size, total_files);
-        
-        if (start >= end) {
-            break;
-        }
-
-        pool.enqueue([context, start, end]() {
-            process_chunk(context, start, end);
-        });
-    }
-
-    return context->deferred.Promise();
-}
-
-Napi::Value ParserAddon::get_duration(const Napi::CallbackInfo& info) {
-    if (info.Length() < 1) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    if (!info[0].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::string content = read_file(location);
-
-    if (content.empty()) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    std::string audio_file_name = osu_parser::get_property(content, "AudioFilename");
-    std::filesystem::path audio_path = dirname(location) / audio_file_name;
-
-    return Napi::Number::From(info.Env(), audio_analizer.get_audio_duration(audio_path.string()));
-}
-
-Napi::Value ParserAddon::get_audio_duration(const Napi::CallbackInfo& info) {
-    if (info.Length() < 1) {
-        return Napi::Number::New(info.Env(), 0.0);
-    }
-
-    if (!info[0].IsString()) {
-        return Napi::String::New(info.Env(), "");
-    }
-
-    std::string location = info[0].As<Napi::String>().Utf8Value();
-    std::filesystem::path audio_path(location);
-
-    return Napi::Number::From(info.Env(), audio_analizer.get_audio_duration(audio_path.string()));
-}
-
-Napi::Value ParserAddon::test_promise(const Napi::CallbackInfo& info) {
-    auto deffered = Napi::Promise::Deferred::New(info.Env());
-    auto tsfn = Napi::ThreadSafeFunction::New(info.Env(), NOOP_FUNC(info.Env()), "tsfn", 0, 1);
-
-    std::thread([tsfn, deffered]() {
-        tsfn.NonBlockingCall([deffered](Napi::Env env, Napi::Function) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(2000));
-            deffered.Resolve(Napi::Boolean::New(env, true));
-        });
-
-        tsfn.Release();
-    }).detach();
-
-    return deffered.Promise();
-}
-
-NODE_API_ADDON(ParserAddon)

package/src/native/addon.hpp

@@ -1,26 +0,0 @@
-#pragma once
-
-#include <napi.h>
-#include "pool.hpp"
-
-class ParserAddon : public Napi::Addon<ParserAddon> {
-public:
-    ParserAddon(Napi::Env env, Napi::Object exports) {
-        pool.initialize(std::thread::hardware_concurrency());
-        DefineAddon(exports, {
-            InstanceMethod("get_property", &ParserAddon::get_property),
-            InstanceMethod("get_properties", &ParserAddon::get_properties),
-            InstanceMethod("process_beatmaps", &ParserAddon::process_beatmaps),
-            InstanceMethod("get_duration", &ParserAddon::get_duration),
-            InstanceMethod("get_audio_duration", &ParserAddon::get_audio_duration),
-            InstanceMethod("test_promise", &ParserAddon::test_promise)
-        });
-    }
-
-    Napi::Value get_property(const Napi::CallbackInfo& info);
-    Napi::Value get_properties(const Napi::CallbackInfo& info);
-    Napi::Value process_beatmaps(const Napi::CallbackInfo& info);
-    Napi::Value get_duration(const Napi::CallbackInfo& info);
-    Napi::Value get_audio_duration(const Napi::CallbackInfo& info);
-    Napi::Value test_promise(const Napi::CallbackInfo& info);
-};

package/src/native/definitions.hpp

@@ -1,56 +0,0 @@
-#pragma once
-#include <string>
-#include <unordered_set>
-#include <unordered_map>
-
-enum OSU_SECTIONS {
-    General = 0,
-    Editor,
-    Metadata,
-    Difficulty,
-    Events,
-    TimingPoints,
-    Colours,
-    HitObjects
-};
-
-const std::unordered_map<std::string_view, std::string_view> KEY_TO_SECTION = {
-    {"AudioFilename", "[General]"},
-    {"AudioLeadIn", "[General]"},
-    {"PreviewTime", "[General]"},
-    {"Countdown", "[General]"},
-    {"SampleSet", "[General]"},
-    {"StackLeniency", "[General]"},
-    {"Mode", "[General]"},
-    {"LetterboxInBreaks", "[General]"},
-    {"WidescreenStoryboard", "[General]"},
-    {"Bookmarks", "[Editor]"},
-    {"DistanceSpacing", "[Editor]"},
-    {"BeatDivisor", "[Editor]"},
-    {"GridSize", "[Editor]"},
-    {"TimelineZoom", "[Editor]"},
-    {"Title", "[Metadata]"},
-    {"TitleUnicode", "[Metadata]"},
-    {"Artist", "[Metadata]"},
-    {"ArtistUnicode", "[Metadata]"},
-    {"Creator", "[Metadata]"},
-    {"Version", "[Metadata]"},
-    {"Source", "[Metadata]"},
-    {"Tags", "[Metadata]"},
-    {"BeatmapID", "[Metadata]"},
-    {"BeatmapSetID", "[Metadata]"},
-    {"HPDrainRate", "[Difficulty]"},
-    {"CircleSize", "[Difficulty]"},
-    {"OverallDifficulty", "[Difficulty]"},
-    {"ApproachRate", "[Difficulty]"},
-    {"SliderMultiplier", "[Difficulty]"},
-    {"SliderTickRate", "[Difficulty]"},
-    // special ones (doenst have keys)
-    {"Background", "[Events]"},
-    {"Video", "[Events]"},
-    {"Storyboard", "[Events]"},
-    // extra special ones (why not)
-    {"Duration", "[General]"}
-};
-
-const std::unordered_set<std::string_view> SPECIAL_KEYS {"Background", "Video", "Storyboard"};

package/src/native/osu/audio.cpp

@@ -1,30 +0,0 @@
-#include <iostream>
-#include <filesystem>
-#include <sndfile.h>
-#include "audio.hpp"
-
-double AudioAnalyzer::get_audio_duration(std::string location) {
-    double duration = 0.0;
-    
-    if (get_cache(location, duration)) {
-        return duration;
-    }
-
-    if (!std::filesystem::exists(location)) {
-        std::cout << location << " does not exists\n";
-        return 0.0;
-    }
-
-    SF_INFO sfinfo{};
-    SNDFILE *file = sf_open(location.c_str(), SFM_READ, &sfinfo);
-
-    if (!file) {
-        return 0.0;
-    }
-
-    duration = static_cast<double>(sfinfo.frames) / sfinfo.samplerate;
-    
-    sf_close(file);
-    set_cache(location, duration);
-    return duration;
-}

package/src/native/osu/audio.hpp

@@ -1,34 +0,0 @@
-#pragma once
-#include <mutex>
-#include <string>
-#include <unordered_map>
-
-class AudioAnalyzer
-{
-private:
-    std::unordered_map<std::string, double> cache;
-    mutable std::mutex cache_mutex;
-    
-    bool get_cache(const std::string &key, double &duration) const {
-        std::lock_guard<std::mutex> lock(cache_mutex);
-        auto it = cache.find(key);
-        if (it != cache.end())
-        {
-            duration = it->second;
-            return true;
-        }
-        return false;
-    }
-
-    void set_cache(const std::string &key, double duration) {
-        std::lock_guard<std::mutex> lock(cache_mutex);
-        cache[key] = duration;
-    }
-
-    void clear_cache() {
-        std::lock_guard<std::mutex> lock(cache_mutex);
-        cache.clear();
-    }
-public:
-    double get_audio_duration(std::string location);
-};

package/src/native/osu/parser.cpp

@@ -1,294 +0,0 @@
-#include <algorithm>
-#include <cstdio>
-#include <iostream>
-#include <optional>
-#include <string>
-#include <string_view>
-#include <unordered_set>
-#include <unordered_map>
-#include "./parser.hpp"
-#include "../definitions.hpp"
-
-const std::unordered_set<std::string_view> VIDEO_EXTENSIONS = {
-    ".mp4", ".avi", ".flv", ".mov", ".wmv", ".m4v", ".mpg", ".mpeg"
-};
-
-const std::unordered_set<std::string_view> IMAGE_EXTENSIONS = {
-    ".jpg", ".jpeg", ".png", ".bmp", ".gif"
-};
-
-std::string_view trim_view(std::string_view s) {
-    size_t start = s.find_first_not_of(" \t\r\n");
-
-    if (start == std::string_view::npos) {
-        return "";
-    }
-
-    size_t end = s.find_last_not_of(" \t\r\n");
-    return s.substr(start, end - start + 1);
-}
-
-std::string trim(const std::string &s) {
-    std::string_view result = trim_view(s);
-    return std::string(result);
-}
-
-std::vector<std::string_view> split_view(std::string_view s, char delim) {
-    std::vector<std::string_view> result;
-
-    size_t start = 0;
-    size_t end = s.find(delim);
-    
-    while (end != std::string_view::npos) {
-        result.push_back(s.substr(start, end - start));
-        start = end + 1;
-        end = s.find(delim, start);
-    }
-
-    result.push_back(s.substr(start));
-    return result;
-}
-
-std::string normalize_path(const std::string &path) {
-#ifdef _WIN32
-    std::string normalized = path;
-    std::replace(normalized.begin(), normalized.end(), '/', '\\');
-    return normalized;
-#else
-    return path;
-#endif
-}
-
-std::string_view get_extension(std::string_view filename) {
-    size_t dot_pos = filename.find_last_of('.');
-
-    if (dot_pos == std::string_view::npos) {
-        return "";
-    }
-
-    return filename.substr(dot_pos);
-}
-
-std::optional<std::string> get_special_key(std::string_view key, std::string_view line) {
-    if (key == "Background" || key == "Video") {
-        std::vector<std::string_view> parts = split_view(line, ',');
-
-        if (parts.size() < 3) {
-            return std::nullopt;
-        }
-        
-        std::string_view event_type = trim_view(parts[0]);
-        std::string_view start_time = trim_view(parts[1]);
-
-        if (event_type != "0" || start_time != "0") {
-            return std::nullopt;
-        }
-        
-        std::string_view filename = trim_view(parts[2]);
-        
-        // remove quotes if present
-        if (filename.size() >= 2 && filename.front() == '"' && filename.back() == '"') {
-            filename = filename.substr(1, filename.size() - 2);
-        }
-        
-        std::string_view ext = get_extension(filename);
-        std::string ext_lower(ext);
-        std::transform(ext_lower.begin(), ext_lower.end(), ext_lower.begin(), ::tolower);
-        
-        if (key == "Video") {
-            if (VIDEO_EXTENSIONS.count(ext_lower) == 0) {
-                return std::nullopt;
-            }
-        } else {
-            if (IMAGE_EXTENSIONS.count(ext_lower) == 0) {
-                return std::nullopt;
-            }
-        }
-        
-        return normalize_path(std::string(filename));
-    } else if (key == "Storyboard") {
-        // TODO:
-        return std::nullopt;
-    }
-    
-    return std::nullopt;
-}
-
-std::string osu_parser::get_property(std::string_view content, std::string_view key) {
-    bool is_special_key = SPECIAL_KEYS.count(key) > 0;
-    std::string current_section;
-    std::string special_section;
-    
-    if (is_special_key) {
-        if (KEY_TO_SECTION.find(key) == KEY_TO_SECTION.end()) {
-            std::cout << "failed to find special key: " << key << "\n";
-            return "";
-        }
-        special_section = KEY_TO_SECTION.at(key);
-    }
-
-    size_t start = 0;
-    size_t end = content.find('\n');
-
-    while (end != std::string_view::npos) {
-        std::string_view line_view = trim_view(content.substr(start, end - start));
-        start = end + 1;
-        end = content.find('\n', start);
-
-        if (line_view.empty() || line_view[0] == '/') {
-            continue;
-        }
-        
-        if (line_view[0] == '[') {
-            current_section = std::string(line_view);
-            continue;
-        }
-        
-        if (is_special_key) {
-            if (special_section != current_section) {
-                continue;
-            }
-            
-            auto result = get_special_key(key, line_view);
-
-            if (result.has_value()) {
-                return result.value();
-            }
-
-            continue;
-        }
-        
-        size_t delimiter_i = line_view.find(':');
-
-        if (delimiter_i == std::string_view::npos) {
-            continue;
-        }
-        
-        std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
-
-        if (current_key == key) {
-            std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
-            return std::string(value);
-        }
-    }
-    
-    // check last line if no newline at end
-    if (start < content.size()) {
-        std::string_view line_view = trim_view(content.substr(start));
-        if (line_view.empty() || line_view[0] == '/') {
-            return "";
-        }
-
-         // section change at end
-        if (line_view[0] == '[') {
-            return ""; 
-        }
-
-        if (is_special_key) {
-            if (special_section == current_section) {
-                auto result = get_special_key(key, line_view);
-                if (result.has_value()) {
-                    return result.value();
-                }
-            }
-            return "";
-        } 
-        
-        size_t delimiter_i = line_view.find(':');
-        
-        if (delimiter_i != std::string_view::npos) {
-            std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
-            if (current_key == key) {
-                std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
-                return std::string(value);
-            }
-        }
-    }
-
-    return "";
-}
-
-std::unordered_map<std::string, std::string> osu_parser::get_properties(std::string_view content, const std::vector<std::string>& keys) {
-    std::unordered_map<std::string, std::string> results;
-    std::unordered_map<std::string_view, std::string_view> key_to_section_map;
-    std::unordered_set<std::string_view> keys_to_find;
-    
-    for (const auto& key : keys) {
-        keys_to_find.insert(key);
-        if (KEY_TO_SECTION.count(key)) {
-            key_to_section_map[key] = KEY_TO_SECTION.at(key);
-        }
-    }
-
-    std::string current_section;
-    size_t start = 0;
-    size_t end = content.find('\n');
-
-    auto process_line = [&](std::string_view line_view) {
-        if (line_view.empty() || line_view[0] == '/') {
-            return;
-        }
-        
-        if (line_view[0] == '[') {
-            current_section = std::string(line_view);
-            return;
-        }
-        
-        size_t delimiter_i = line_view.find(':');
-        if (delimiter_i != std::string_view::npos) {
-            std::string_view current_key = trim_view(line_view.substr(0, delimiter_i));
-            
-            if (keys_to_find.count(current_key)) {
-                bool correct_section = !key_to_section_map.count(current_key) || 
-                                       key_to_section_map.at(current_key) == current_section;
-
-                bool not_found_yet = results.find(std::string(current_key)) == results.end();
-                
-                if (correct_section && not_found_yet) {
-                     std::string_view value = trim_view(line_view.substr(delimiter_i + 1));
-                     results[std::string(current_key)] = std::string(value);
-                }
-            }
-        }
-
-        for (const auto& key : keys) {
-            if (!SPECIAL_KEYS.count(key)) {
-                continue;
-            }
-            
-            if (results.find(key) != results.end()) {
-                continue;
-            }
-            
-            if (key_to_section_map.count(key) && key_to_section_map.at(key) == current_section) {
-                auto result = get_special_key(key, line_view);
-                if (result.has_value()) {
-                    results[key] = result.value();
-                }
-            }
-        }
-    };
-
-    while (end != std::string_view::npos) {
-        std::string_view line_view = trim_view(content.substr(start, end - start));
-        process_line(line_view);
-        start = end + 1;
-        end = content.find('\n', start);
-    }
-    
-    if (start < content.size()) {
-        std::string_view line_view = trim_view(content.substr(start));
-        process_line(line_view);
-    }
-
-    return results;
-}
-
-std::vector<std::string> osu_parser::get_section() {
-    std::vector<std::string> result;
-    return result;
-}
-
-std::map<std::string, std::string> osu_parser::parse(std::string_view content) {
-    return {};
-}

package/src/native/osu/parser.hpp

@@ -1,14 +0,0 @@
-#pragma once
-#include <map>
-#include <string>
-#include <vector>
-#include <unordered_map>
-
-namespace osu_parser {
-    std::string get_property(std::string_view content, std::string_view key);
-    std::unordered_map<std::string, std::string> get_properties(std::string_view content, const std::vector<std::string>& keys);
-
-    // TODO:
-    std::vector<std::string> get_section();
-    std::map<std::string, std::string> parse(std::string_view content); 
-};

package/src/native/pool.hpp

@@ -1,80 +0,0 @@
-#pragma once 
-
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <queue>
-#include <thread>
-#include <vector>
-#include <atomic>
-
-class ThreadPool {
-public:
-    void initialize(int count) {
-        for (int i = 0; i < count; i++) {
-            // add new worker
-            workers.emplace_back([this]() {
-                // initialize task loop
-                while (true) {
-                    std::function<void()> task;
-                    // wait for new task
-                    {
-                        std::unique_lock<std::mutex> lock(queue_mutex);
-
-                        // use condition variable to make threads go zzz until we actually have a task to do
-                        cv.wait(lock, [this] { 
-                            return stop || !tasks.empty();
-                        });
-
-                        // ensure we have a task
-                        if (stop && tasks.empty()) {
-                            break;
-                        }
-
-                        // move task from queue to var
-                        task = std::move(tasks.front());
-
-                        // if i recall correctly "move" moves the pointer data from the queue
-                        // but the pointer is still there pointing to nothing
-                        // so remove it anyway
-                        tasks.pop();
-                    }
-
-                    // execute it :)
-                    task();
-                }
-            });
-        }
-    }
-
-    ~ThreadPool() {
-        stop = true;
-
-        // wake up all lazy ass threads
-        cv.notify_all();
-
-        // free them
-        for (std::thread& t : workers) {
-            if (t.joinable()) {
-                t.join();
-            }
-        }
-    }
-
-    template<class T>
-    void enqueue(T&& f) {
-        {
-            std::unique_lock<std::mutex> lock(queue_mutex);
-            tasks.emplace(std::forward<T>(f));
-        }
-        cv.notify_one();
-    }
-private:
-    std::atomic<bool> stop{false};
-    std::vector<std::thread> workers;
-    std::queue<std::function<void()>> tasks;
-    std::mutex queue_mutex;
-    std::condition_variable cv;
-};
-
-inline ThreadPool pool;

package/src/types.ts

@@ -1,48 +0,0 @@
-export type OsuKey =
-    | "AudioFilename"
-    | "AudioLeadIn"
-    | "PreviewTime"
-    | "Countdown"
-    | "SampleSet"
-    | "StackLeniency"
-    | "Mode"
-    | "LetterboxInBreaks"
-    | "WidescreenStoryboard"
-    | "Bookmarks"
-    | "DistanceSpacing"
-    | "BeatDivisor"
-    | "GridSize"
-    | "TimelineZoom"
-    | "Title"
-    | "TitleUnicode"
-    | "Artist"
-    | "ArtistUnicode"
-    | "Creator"
-    | "Version"
-    | "Source"
-    | "Tags"
-    | "BeatmapID"
-    | "BeatmapSetID"
-    | "HPDrainRate"
-    | "CircleSize"
-    | "OverallDifficulty"
-    | "ApproachRate"
-    | "SliderMultiplier"
-    | "SliderTickRate"
-    | "Background"
-    | "Video"
-    | "Storyboard"
-    | "Duration";
-
-export interface OsuInput {
-    path: string;
-    id?: string;
-}
-
-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[], callback?: (index: number) => void): Promise<Record<string, string>[]>;
-    get_duration(location: string): number;
-    get_audio_duration(location: string): number;
-}