@r2o3/rgskin-nodejs 0.0.2 → 0.0.4

package/README.md

@@ -1,8 +1,18 @@
 # rgskin
-A library for loading and creating skins for various rhythm games. It supports cross-platform usage including Web and Node.js environments via WebAssembly (WASM).
+
+[![crates.io](https://img.shields.io/crates/v/rgskin?style=flat-square&logo=rust&logoColor=white&color=e05d2c)](https://crates.io/crates/rgskin)
+[![npm (browser)](https://img.shields.io/npm/v/%40r2o3%2Frgskin-browser?style=flat-square&logo=npm&logoColor=white&label=npm%20(browser)&color=CB3837)](https://www.npmjs.com/package/@r2o3/rgskin-browser)
+[![npm (node)](https://img.shields.io/npm/v/%40r2o3%2Frgskin-nodejs?style=flat-square&logo=npm&logoColor=white&label=npm%20(node)&color=CB3837)](https://www.npmjs.com/package/@r2o3/rgskin-nodejs)
+
+[![license](https://img.shields.io/badge/license-MIT-4A80D4?style=flat-square)](LICENSE)
+[![rust](https://img.shields.io/badge/rust-nightly%201.98%2B-534eb5?style=flat-square&logo=rust&logoColor=white)](https://www.rust-lang.org/tools/install)
+
+A library for loading and creating skins for various rhythm games. It supports multi-threading and cross-platform usage including Web and Node.js environments via WebAssembly (WASM).
 
 ## Table of Contents
 
+- [Features](#features)
+    - [Supported Games](#supported-games) 
 - [Rust Usage](#rust-usage)
     - [Installation](#installation)
     - [API Reference](#api-reference)
@@ -21,13 +31,20 @@ A library for loading and creating skins for various rhythm games. It supports c
     - [WASM Bindings](#wasm-bindings)
 - [License](#license)
 
+## Features
+
+### Supported Games:
+- Osu!
+- Quaver
+- fluXis
+
 ## Rust Usage
 
 ### Installation
 Add this to your `Cargo.toml`:
 ```toml
 [dependencies]
-rgskin = "0.0.2"
+rgskin = "0.0.4"
 ```
 
 Or run:
@@ -47,6 +64,7 @@ use rgskin::prelude::*;
 // importing a skin from a directory
 let osu_skin = import::osu::skin_from_dir("path/to/skin").expect("Failed to import skin!", false);
 let fluxis_skin = import::fluxis::skin_from_dir("path/to/skin").expect("Failed to import skin!", false);
+let quaver_skin = import::quaver::skin_from_dir("path/to/skin").expect("Failed to import skin!", false);
 ```
 
 The second argument is for if you want to import ALL assets for a skin, it will import all textures but leave the unrequired unloaded, usually recommended when merging skins of the same type as you might need all assets; otherwise if false it will only import and load the required assets.
@@ -90,7 +108,7 @@ OsuSkin.to_generic_mania(()); // yes, the extra parethesis is required.
 ```
 ```rust
 FluXisSkin::from_generic_mania(&generic); 
-FluXisSkin.to_generic_mania(fluxis_layout); // if you don't have a layout you can just pass None or ().
+FluXisSkin.to_generic_mania(fluxis_layout); // if you don't have a layout you can just pass None.
 ```
 
 ---
@@ -134,20 +152,58 @@ then use as an ES module
 ### API Reference
 
 #### Initialization
+
+
+As of now you can't parse/write using the original structures in JS/TS, will be supported in the *near* future.
+
+> [!IMPORTANT]
+> `wasm-bindgen-rayon` uses `SharedArrayBuffer` for thread communication, which requires your page to be cross-origin isolated. Your server must send these headers:
+> ```
+> Cross-Origin-Opener-Policy: same-origin
+> Cross-Origin-Embedder-Policy: require-corp
+> ```
+> You can verify isolation is active with `self.crossOriginIsolated` in the browser console.
+
+---
+
+**ES Modules (bundler or Node.js)**
+
 ```javascript
-// For ES modules
-import * as rgskin from '@r2o3/rgskin'; // or if not in node modules use the path to rgskin.js
+import init, { initThreadPool } from '@r2o3/rgskin';
+// or if not installed via npm:
+// import init, { initThreadPool } from './path/to/rgskin.js';
 
-// or alternatively
-const rgskin = await import('path/to/rgskin.js')
+await init();
+await initThreadPool(navigator.hardwareConcurrency);
+```
 
-// For CommonJS
-const rgskin = require('rgskin');
+---
+
+**Browser (`<script type="module">`)**
+
+```javascript
+import rgskin from './path/to/rgskin.js';
+
+await rgskin.default();
+await rgskin.initThreadPool(navigator.hardwareConcurrency);
 ```
 
-you may need to do ``await rgskin.default()`` after importing if you've imported it in a script tag (with type="module") or you get an error like ``Uncaught TypeError: Cannot read properties of undefined (reading '__wbindgen_malloc')``
+---
 
-As of now you can't parse/write using the original structures in JS/TS, will be supported in the *near* future.
+**CommonJS (Node.js or Legacy Environments)**
+
+CommonJS (`require`) is not natively supported because `wasm-bindgen-rayon` relies on ES Modules and top-level async initialization. However, you can load it using `import()`:
+
+```javascript
+async function loadWasm() {
+    const wasm = await import('@r2o3/rgskin');
+    
+    await wasm.default();
+    await wasm.initThreadPool(navigator.hardwareConcurrency);
+    
+    return wasm;
+}
+```
 
 #### Importing/Loading Skins
 

package/package.json

@@ -3,8 +3,8 @@
   "collaborators": [
     "menvae"
   ],
-  "description": "A library for converting rhythm game skins.",
-  "version": "0.0.2",
+  "description": "A library for converting, loading and creating skins for various rhythm games.",
+  "version": "0.0.4",
   "license": "MIT",
   "repository": {
     "type": "git",

package/rgskin.d.ts

@@ -4,27 +4,33 @@
 export class BinaryStore {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
-  insertBinary(binary: RawBytes): void;
-  makeUnique(new_path: string, binary: RawBytes): string;
-  loadFromArrayBuffer(path: string, buffer: ArrayBuffer): void;
-  loadFromUint8Array(path: string, array: Uint8Array): void;
   allLoaded(): boolean;
+  hasBinary(path: string): boolean;
+  makeUnique(new_path: string, binary: RawBytes): string;
   loadedCount(): number;
+  insertBinary(binary: RawBytes): void;
   unloadedPaths(): Array<any>;
-  hasBinary(path: string): boolean;
-  getBinaryPath(path: string): string | undefined;
   binaryHasData(path: string): boolean;
   getBinaryData(path: string): Uint8Array | undefined;
-  contains(path: string): boolean;
-  remove(path: string): boolean;
+  getBinaryPath(path: string): string | undefined;
+  loadFromUint8Array(path: string, array: Uint8Array): void;
+  loadFromArrayBuffer(path: string, buffer: ArrayBuffer): void;
+  constructor();
+  clear(): void;
   getLength(): number;
+  extend(other: BinaryStore): void;
+  remove(path: string): boolean;
+  contains(path: string): boolean;
   isEmpty(): boolean;
   getPaths(): Array<any>;
-  clear(): void;
-  copy(original_path: string, new_path: string): string | undefined;
   makeUniqueCopy(original_path: string, new_base_path: string): string | undefined;
-  extend(other: BinaryStore): void;
+  copy(original_path: string, new_path: string): string | undefined;
+}
+
+export enum DefaultSkin {
+  Arrow = 0,
+  Bar = 1,
+  Circle = 2,
 }
 
 export class FluXisKeymode {
@@ -54,12 +60,12 @@ export class FluXisSkin {
   free(): void;
   [Symbol.dispose](): void;
   constructor(skin_json: SkinJson, textures?: TextureStore | null, samples?: BinaryStore | null);
+  getKeymode(keymode: number): FluXisKeymode | undefined;
   toGenericMania(): GenericManiaSkin;
-  toGenericManiaWithLayout(layout: FluXisLayout): GenericManiaSkin;
   static fromGenericMania(skin: GenericManiaSkin): FluXisSkinWithLayout;
-  getKeymode(keymode: number): FluXisKeymode | undefined;
-  getRequiredTexturePaths(): string[];
   getRequiredSamplePaths(): string[];
+  getRequiredTexturePaths(): string[];
+  toGenericManiaWithLayout(layout: FluXisLayout): GenericManiaSkin;
   skin_json: SkinJson;
   textures: TextureStore;
   samples: BinaryStore;
@@ -102,15 +108,39 @@ export class GenericManiaSkin {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
+  getKeymode(keymode: number): Keymode | undefined;
   toGenericMania(): GenericManiaSkin;
   static fromGenericMania(skin: GenericManiaSkin): GenericManiaSkin;
-  getKeymode(keymode: number): Keymode | undefined;
-  getRequiredTexturePaths(): string[];
   getRequiredSamplePaths(): string[];
+  getRequiredTexturePaths(): string[];
   textures: TextureStore;
   samples: BinaryStore;
 }
 
+export enum HealthBarKeysAlignment {
+  LeftStage = 0,
+  RightStage = 1,
+  TopLeft = 2,
+}
+
+export enum HealthBarType {
+  Horizontal = 0,
+  Vertical = 1,
+}
+
+export enum HitBubblesAlignment {
+  LeftStage = 0,
+  RightStage = 1,
+  BelowStage = 2,
+}
+
+export enum HitBubblesType {
+  FallDown = 0,
+  FallUp = 1,
+  FallLeft = 2,
+  FallRight = 3,
+}
+
 export class Info {
   private constructor();
   free(): void;
@@ -124,12 +154,31 @@ export class Keymode {
   private constructor();
   free(): void;
   [Symbol.dispose](): void;
-  static fromStr(content: string): OsuKeymode;
   toStr(): string;
+  static fromStr(content: string): OsuKeymode;
   getTexturePaths(): string[];
   keymode: number;
 }
 
+export class MainMenu {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(content: string): MainMenu;
+  toString(): string;
+  navigation_button_hovered_alpha: number;
+  audio_visualizer_opacity: number;
+  note_visualizer_opacity: number;
+}
+
+export class MenuBorder {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(content: string): MenuBorder;
+  toString(): string;
+}
+
 export class OsuKeymode {
   private constructor();
   free(): void;
@@ -190,11 +239,11 @@ export class OsuSkin {
   free(): void;
   [Symbol.dispose](): void;
   constructor(skin_ini: OsuSkinIni, textures?: TextureStore | null, samples?: BinaryStore | null);
+  getKeymode(keymode: number): OsuKeymode | undefined;
   toGenericMania(): GenericManiaSkin;
   static fromGenericMania(skin: GenericManiaSkin): OsuSkin;
-  getKeymode(keymode: number): OsuKeymode | undefined;
-  getRequiredTexturePaths(): string[];
   getRequiredSamplePaths(): string[];
+  getRequiredTexturePaths(): string[];
   skin_ini: OsuSkinIni;
   textures: TextureStore;
   samples: BinaryStore;
@@ -203,112 +252,291 @@ export class OsuSkin {
 export class OsuSkinIni {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
   static fromStr(json_str: string): OsuSkinIni;
   toString(): string;
-  getRequiredTexturePaths(): string[];
-  getRequiredSamplePaths(): string[];
   getKeymode(keymode: number): OsuKeymode | undefined;
+  getRequiredSamplePaths(): string[];
+  getRequiredTexturePaths(): string[];
+  constructor();
   general: General;
   keymodes: OsuKeymode[];
 }
 
+export class QuaGeneral {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(content: string): QuaGeneral;
+  toString(): string;
+  name: string;
+  author: string;
+  version: string;
+  center_cursor: boolean;
+  use_skin_backgrounds: boolean;
+}
+
+export class QuaKeymode {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  toStr(): string;
+  static fromStr(content: string): QuaKeymode;
+  keymode: number;
+  default_skin: DefaultSkin;
+  color_objects_by_snap_distance: boolean;
+  use_hit_object_sheet: boolean;
+  rotate_hit_objects_by_column: boolean;
+  flip_note_images_on_upscroll: boolean;
+  flip_note_end_images_on_upscroll: boolean;
+  draw_long_note_end: boolean;
+  note_padding: number;
+  width_for_note_height_scale: number;
+  bg_mask_alpha: number;
+  bg_mask_padding: number;
+  column_alignment: number;
+  column_size: number;
+  column_lighting_offset_y: number;
+  column_lighting_scale: number;
+  hit_pos_offset_y: number;
+  receptor_pos_offset_y: number;
+  receptors_over_hit_objects: boolean;
+  stage_receptor_padding: number;
+  coop_playfield_padding: number;
+  hit_error_chevron_size: number;
+  hit_error_height: number;
+  hit_error_pos_x: number;
+  hit_error_pos_y: number;
+  hit_error_alpha: number;
+  judgement_hit_burst_fps: number;
+  judgement_burst_pos_y: number;
+  judgement_hit_burst_bump_y: number;
+  judgement_hit_burst_bump_time: number;
+  judgement_hit_burst_scale: number;
+  hit_lighting_x: number;
+  hit_lighting_y: number;
+  hit_lighting_fps: number;
+  hit_lighting_scale: number;
+  hit_lighting_column_rotation: boolean;
+  hold_lighting_fps: number;
+  hold_lighting_scale: number;
+  hold_lighting_column_rotation: boolean;
+  health_bar_keys_alignment: HealthBarKeysAlignment;
+  health_bar_type: HealthBarType;
+  health_bar_pos_offset_x: number;
+  health_bar_pos_offset_y: number;
+  health_bar_scale: number;
+  hit_bubbles_alignment: HitBubblesAlignment;
+  hit_bubbles_type: HitBubblesType;
+  hit_bubbles_pos_x: number;
+  hit_bubbles_pos_y: number;
+  hit_bubbles_scale: number;
+  hit_bubble_scale: number;
+  hit_bubble_border_padding: number;
+  hit_bubble_padding: number;
+  combo_display_scale: number;
+  combo_pos_x: number;
+  combo_pos_y: number;
+  combo_display_bump_y: number;
+  combo_display_bump_time: number;
+  rating_display_scale: number;
+  rating_display_pos_x: number;
+  rating_display_pos_y: number;
+  accuracy_display_scale: number;
+  accuracy_display_pos_x: number;
+  accuracy_display_pos_y: number;
+  kps_display_scale: number;
+  kps_display_pos_x: number;
+  kps_display_pos_y: number;
+  score_display_scale: number;
+  score_display_pos_x: number;
+  score_display_pos_y: number;
+  battle_royale_alert_pos_x: number;
+  battle_royale_alert_pos_y: number;
+  battle_royale_alert_scale: number;
+  battle_royale_eliminated_pos_x: number;
+  battle_royale_eliminated_pos_y: number;
+  judgement_counter_alpha: number;
+  judgement_counter_size: number;
+  judgement_counter_pos_x: number;
+  judgement_counter_pos_y: number;
+  judgement_counter_padding: number;
+  judgement_counter_horizontal: boolean;
+  judgement_counter_fade_to_alpha: boolean;
+  use_judgement_color_for_numbers: boolean;
+  song_time_progress_scale: number;
+  song_time_progress_position_at_top: boolean;
+  show_mini_song_bar: boolean;
+  mini_song_bar_display_pos_x: number;
+  mini_song_bar_display_pos_y: number;
+  mini_song_bar_display_width_factor: number;
+  mini_song_bar_display_height: number;
+  use_fallback: boolean;
+}
+
+export class QuaSkin {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(skin_ini: QuaSkinIni, textures?: TextureStore | null, samples?: BinaryStore | null);
+  getKeymode(keymode: number): QuaKeymode | undefined;
+  toGenericMania(): GenericManiaSkin;
+  static fromGenericMania(skin: GenericManiaSkin): QuaSkin;
+  getRequiredSamplePaths(): string[];
+  getRequiredTexturePaths(): string[];
+  skin_ini: QuaSkinIni;
+  textures: TextureStore;
+  samples: BinaryStore;
+}
+
+export class QuaSkinIni {
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(ini_str: string): QuaSkinIni;
+  toString(): string;
+  getKeymode(keymode: number): QuaKeymode | undefined;
+  constructor();
+  general: QuaGeneral;
+  main_menu: MainMenu;
+  menu_border: MenuBorder;
+  song_select: SongSelect;
+  results: Results;
+  keymodes: QuaKeymode[];
+  get shared_keymode(): QuaKeymode | undefined;
+  set shared_keymode(value: QuaKeymode | null | undefined);
+}
+
 export class RawBytes {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(path: string);
-  static fromBytes(path: string, bytes: Uint8Array): RawBytes;
   getData(): Uint8Array | undefined;
-  static fromArrayBuffer(path: string, buffer: ArrayBuffer): RawBytes;
-  static fromArrayBufferUnloaded(path: string, buffer: ArrayBuffer): RawBytes;
-  static fromUint8Array(path: string, array: Uint8Array): RawBytes;
-  static fromUint8ArrayUnloaded(path: string, array: Uint8Array): RawBytes;
+  getHash(): bigint | undefined;
+  static fromBytes(path: string, bytes: Uint8Array): RawBytes;
+  constructor(path: string);
+  unload(): void;
   getPath(): string;
   hasData(): boolean;
+  isEmpty(): boolean;
   isLoaded(): boolean;
   isUnloaded(): boolean;
-  isEmpty(): boolean;
+  static fromUint8Array(path: string, array: Uint8Array): RawBytes;
+  static fromArrayBuffer(path: string, buffer: ArrayBuffer): RawBytes;
+  static fromUint8ArrayUnloaded(path: string, array: Uint8Array): RawBytes;
+  static fromArrayBufferUnloaded(path: string, buffer: ArrayBuffer): RawBytes;
   load(): void;
-  unload(): void;
   path: string;
 }
 
+export class Results {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(content: string): Results;
+  toString(): string;
+  results_background_type: ResultsBackgroundType;
+  results_background_filter_alpha: number;
+}
+
+export enum ResultsBackgroundType {
+  Header = 0,
+  Background = 1,
+  None = 2,
+}
+
 export class SkinJson {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
   static fromStr(json_str: string): SkinJson;
   toString(): string;
+  constructor();
   info: Info;
   keymodes: FluXisKeymode[];
 }
 
+export class SongSelect {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromStr(content: string): SongSelect;
+  toString(): string;
+  mapset_panel_hovering_alpha: number;
+  map_background_brightness: number;
+  display_map_background: boolean;
+}
+
 export class Texture {
   free(): void;
   [Symbol.dispose](): void;
-  constructor(path: string);
   static fromBlank(path: string): Texture;
-  static fromArrayBuffer(path: string, buffer: ArrayBuffer): Texture;
-  static fromArrayBufferUnloaded(path: string, buffer: ArrayBuffer): Texture;
-  static fromUint8Array(path: string, array: Uint8Array): Texture;
-  static fromUint8ArrayUnloaded(path: string, array: Uint8Array): Texture;
+  getHash(): bigint | undefined;
+  constructor(path: string);
+  unload(): void;
   getPath(): string;
   hasData(): boolean;
+  isEmpty(): boolean;
   isLoaded(): boolean;
   isUnloaded(): boolean;
-  isEmpty(): boolean;
+  static fromUint8Array(path: string, array: Uint8Array): Texture;
+  static fromArrayBuffer(path: string, buffer: ArrayBuffer): Texture;
+  static fromUint8ArrayUnloaded(path: string, array: Uint8Array): Texture;
+  static fromArrayBufferUnloaded(path: string, buffer: ArrayBuffer): Texture;
   load(): void;
-  unload(): void;
   path: string;
 }
 
 export class TextureStore {
   free(): void;
   [Symbol.dispose](): void;
-  constructor();
-  insertTexture(texture: Texture): void;
-  makeUnique(new_path: string, texture: Texture): string;
-  loadFromArrayBuffer(path: string, buffer: ArrayBuffer): void;
-  loadFromUint8Array(path: string, array: Uint8Array): void;
   allLoaded(): boolean;
+  hasTexture(path: string): boolean;
+  makeUnique(new_path: string, texture: Texture): string;
   loadedCount(): number;
+  insertTexture(texture: Texture): void;
   unloadedPaths(): Array<any>;
-  hasTexture(path: string): boolean;
   getTexturePath(path: string): string | undefined;
   textureHasData(path: string): boolean;
-  contains(path: string): boolean;
-  remove(path: string): boolean;
+  loadFromUint8Array(path: string, array: Uint8Array): void;
+  loadFromArrayBuffer(path: string, buffer: ArrayBuffer): void;
+  constructor();
+  clear(): void;
   getLength(): number;
+  extend(other: TextureStore): void;
+  remove(path: string): boolean;
+  contains(path: string): boolean;
   isEmpty(): boolean;
   getPaths(): Array<any>;
-  clear(): void;
-  copy(original_path: string, new_path: string): string | undefined;
   makeUniqueCopy(original_path: string, new_base_path: string): string | undefined;
-  extend(other: TextureStore): void;
+  copy(original_path: string, new_path: string): string | undefined;
 }
 
 export function allSamplesFromDir(path: string): BinaryStore;
 
-export function allTexturesFromDir(path: string): TextureStore;
+export function allTexturesFromDir(path: string, load_only?: string[] | null): TextureStore;
 
-export function fluXisSkinFromDir(path: string): FluXisSkin;
+export function fluXisSkinFromDir(path: string, import_all?: boolean | null): FluXisSkin;
 
 export function fluXisSkinToDir(skin: FluXisSkin, path: string): void;
 
-export function iniStrFromDir(path: string): string;
+export function fluxisJsonStrFromDir(path: string): string;
 
-export function iniToDir(skin_ini: OsuSkinIni, path: string): void;
+export function fluxisJsonToDir(skin_json: SkinJson, path: string): void;
 
-export function jsonStrFromDir(path: string): string;
+export function fluxisLayoutToDir(layout_json: FluXisLayout, path: string): void;
 
-export function jsonToDir(skin_json: SkinJson, path: string): void;
+export function osuIniStrFromDir(path: string): string;
 
-export function layoutToDir(layout_json: FluXisLayout, path: string): void;
+export function osuIniToDir(skin_ini: OsuSkinIni, path: string): void;
 
-export function osuSkinFromDir(path: string): OsuSkin;
+export function osuSkinFromDir(path: string, import_all?: boolean | null): OsuSkin;
 
 export function osuSkinToDir(skin: OsuSkin, path: string): void;
 
+export function quaverIniStrFromDir(path: string): string;
+
+export function quaverIniToDir(skin_ini: QuaSkinIni, path: string): void;
+
+export function quaverSkinFromDir(path: string, import_all?: boolean | null): QuaSkin;
+
+export function quaverSkinToDir(skin: QuaSkin, path: string): void;
+
 export function samplesFromDir(path: string, relative_sample_paths: Array<any>): BinaryStore;
 
 export function samplesToDir(samples: BinaryStore, path: string): void;