osu-play 1.0.2 → 1.0.4

package/src/realm/mod.ts

@@ -0,0 +1,54 @@
+import Realm from "realm";
+import path from "node:path";
+import { getDataDir } from "../utils/mod.js";
+import {
+  Beatmap,
+  BeatmapMetadata,
+  BeatmapSet,
+  RealmFile,
+  RealmNamedFileUsage,
+  RealmUser,
+} from "./schema/mod.js";
+
+export const getLazerDB = async (realmDBPath: string) => {
+  const realm = await Realm.open({
+    schema: [
+      BeatmapSet,
+      RealmFile,
+      RealmNamedFileUsage,
+      Beatmap,
+      BeatmapMetadata,
+      RealmUser,
+    ],
+    path: realmDBPath,
+    schemaVersion: 36,
+    onMigration: (oldRealm, newRealm) => {
+      console.log(
+        `[onMigration]: Migrating ${oldRealm.path} - ${oldRealm.schemaVersion} -> ${newRealm.path} - ${newRealm.schemaVersion}`,
+      );
+    },
+  });
+
+  return realm;
+};
+
+export const hashedFilePath = (hash: string) => {
+  const dataDir = getDataDir();
+  if (!dataDir) return null;
+  return path.join(
+    dataDir,
+    "osu",
+    "files",
+    hash.slice(0, 1),
+    hash.slice(0, 2),
+    hash,
+  );
+};
+
+export const getNamedFileHash = (fileName: string, beatmapSet: BeatmapSet) => {
+  const files = beatmapSet.Files;
+  for (const file of files) {
+    if (file.Filename == fileName) return file.File.Hash;
+  }
+  return undefined;
+};

package/src/realm/schema/beatmap.ts

@@ -0,0 +1,85 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+import { BeatmapMetadata } from "./beatmapMetadata.js";
+
+export class Beatmap extends Realm.Object<Beatmap> {
+  ID!: string;
+  DifficultyName?: string;
+  Ruleset!: any;
+  Difficulty!: any;
+  Metadata!: BeatmapMetadata;
+  UserSettings!: any;
+  BeatmapSet!: any;
+  Status!: number;
+  OnlineID!: number;
+  Length!: number;
+  BPM!: number;
+  Hash?: string;
+  StarRating!: number;
+  MD5Hash?: string;
+  OnlineMD5Hash?: string;
+  LastLocalUpdate?: Date;
+  LastOnlineUpdate?: Date;
+  Hidden!: boolean;
+  AudioLeadIn!: number;
+  StackLeniency!: number;
+  SpecialStyle!: boolean;
+  LetterboxInBreaks!: boolean;
+  WidescreenStoryboard!: boolean;
+  EpilepsyWarning!: boolean;
+  SamplesMatchPlaybackRate!: boolean;
+  LastPlayed?: Date;
+  DistanceSpacing!: number;
+  BeatDivisor!: number;
+  GridSize!: number;
+  TimelineZoom!: number;
+  EditorTimestamp?: number;
+  CountdownOffset!: number;
+
+  static schema: ObjectSchema = {
+    name: "Beatmap",
+    primaryKey: "ID",
+    properties: {
+      ID: { type: "uuid", default: "" },
+      DifficultyName: { type: "string", default: "", optional: true },
+      // Ruleset: { type: "object", objectType: "Ruleset", default: null },
+      // Difficulty: { type: "object", objectType: "BeatmapDifficulty", default: null },
+      Metadata: {
+        type: "object",
+        objectType: "BeatmapMetadata",
+        default: null,
+      },
+      // UserSettings: { type: "object", objectType: "BeatmapUserSettings", default: null },
+      BeatmapSet: { type: "object", objectType: "BeatmapSet", default: null },
+      Status: { type: "int", default: -3 },
+      OnlineID: { type: "int", default: -1 },
+      Length: { type: "double", default: 0 },
+      BPM: { type: "double", default: 0 },
+      Hash: { type: "string", default: "", optional: true },
+      StarRating: { type: "double", default: -1 },
+      MD5Hash: { type: "string", default: "", optional: true },
+      OnlineMD5Hash: {
+        type: "string",
+        default: "",
+        optional: true,
+      },
+      LastLocalUpdate: { type: "date", optional: true },
+      LastOnlineUpdate: { type: "date", optional: true },
+      Hidden: { type: "bool", default: false },
+      AudioLeadIn: { type: "double", default: 0 },
+      StackLeniency: { type: "float", default: 0.7 },
+      SpecialStyle: { type: "bool", default: false },
+      LetterboxInBreaks: { type: "bool", default: false },
+      WidescreenStoryboard: { type: "bool", default: false },
+      EpilepsyWarning: { type: "bool", default: false },
+      SamplesMatchPlaybackRate: { type: "bool", default: false },
+      LastPlayed: { type: "date", optional: true },
+      DistanceSpacing: { type: "double", default: 0 },
+      BeatDivisor: { type: "int", default: 0 },
+      GridSize: { type: "int", default: 0 },
+      TimelineZoom: { type: "double", default: 0 },
+      EditorTimestamp: { type: "double", optional: true },
+      CountdownOffset: { type: "int", default: 0 },
+    },
+  };
+}

package/src/realm/schema/beatmapMetadata.ts

@@ -0,0 +1,33 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+import { RealmUser } from "./realmUser.js";
+
+export class BeatmapMetadata extends Realm.Object<BeatmapMetadata> {
+  Title?: string;
+  TitleUnicode?: string;
+  Artist?: string;
+  ArtistUnicode?: string;
+  Author?: RealmUser;
+  Source?: string;
+  Tags?: string;
+  PreviewTime?: number;
+  AudioFile?: string;
+  BackgroundFile?: string;
+
+  static schema: ObjectSchema = {
+    name: "BeatmapMetadata",
+    properties: {
+      Title: { type: "string", default: "", optional: true },
+      TitleUnicode: { type: "string", default: "", optional: true },
+      Artist: { type: "string", default: "", optional: true },
+      ArtistUnicode: { type: "string", default: "", optional: true },
+      Author: { type: "object", objectType: "RealmUser", default: null },
+      Source: { type: "string", default: "", optional: true },
+      Tags: { type: "string", default: "", optional: true },
+      PreviewTime: { type: "int", default: 0 },
+      AudioFile: { type: "string", default: "", optional: true },
+      BackgroundFile: { type: "string", default: "", optional: true },
+    },
+  };
+}
+

package/src/realm/schema/beatmapSet.ts

@@ -0,0 +1,36 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+import { Beatmap } from "./beatmap.js";
+import { RealmNamedFileUsage } from "./realmNamedFileUsage.js";
+
+export class BeatmapSet extends Realm.Object<BeatmapSet> {
+  ID!: string;
+  OnlineID!: number;
+  DateAdded!: Date;
+  DateSubmitted?: Date;
+  DateRanked?: Date;
+  Beatmaps!: Array<Beatmap>;
+  Files!: Array<RealmNamedFileUsage>;
+  Status!: number;
+  DeletePending!: boolean;
+  Hash?: string;
+  Protected!: boolean;
+
+  static schema: ObjectSchema = {
+    name: "BeatmapSet",
+    primaryKey: "ID",
+    properties: {
+      ID: { type: "uuid", default: "" },
+      OnlineID: { type: "int", default: -1 },
+      DateAdded: { type: "date" },
+      DateSubmitted: { type: "date", optional: true },
+      DateRanked: { type: "date", optional: true },
+      Beatmaps: { type: "list", objectType: "Beatmap", default: [] },
+      Files: { type: "list", objectType: "RealmNamedFileUsage", default: [] },
+      Status: { type: "int", default: -3 },
+      DeletePending: { type: "bool", default: false },
+      Hash: { type: "string", default: "", optional: true },
+      Protected: { type: "bool", default: false },
+    },
+  };
+}

package/src/realm/schema/mod.ts

@@ -0,0 +1,7 @@
+export { Beatmap } from "./beatmap.js";
+export { BeatmapMetadata } from "./beatmapMetadata.js";
+export { BeatmapSet } from "./beatmapSet.js";
+export { RealmFile } from "./realmFile.js";
+export { RealmUser } from "./realmUser.js";
+export { RealmNamedFileUsage } from "./realmNamedFileUsage.js";
+

package/src/realm/schema/realmFile.ts

@@ -0,0 +1,15 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+
+export class RealmFile extends Realm.Object<RealmFile> {
+  Hash?: string;
+
+  static schema: ObjectSchema = {
+    name: "File",
+    primaryKey: "Hash",
+    properties: {
+      Hash: { type: "string", default: "", optional: true },
+    },
+  };
+}
+

package/src/realm/schema/realmNamedFileUsage.ts

@@ -0,0 +1,19 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+import { RealmFile } from "./realmFile.js";
+
+export class RealmNamedFileUsage extends Realm.Object<RealmNamedFileUsage> {
+  File!: RealmFile;
+  Filename?: string;
+
+  static embedded = true;
+
+  static schema: ObjectSchema = {
+    name: "RealmNamedFileUsage",
+    embedded: true,
+    properties: {
+      File: "File",
+      Filename: { type: "string", optional: true },
+    },
+  };
+}

package/src/realm/schema/realmUser.ts

@@ -0,0 +1,21 @@
+import Realm from "realm";
+import type { ObjectSchema } from "realm";
+
+export class RealmUser extends Realm.Object<RealmUser> {
+  OnlineID!: number;
+  Username?: string;
+  CountryCode?: string;
+
+  static embedded = true;
+
+  static schema: ObjectSchema = {
+    name: "RealmUser",
+    embedded: true,
+    properties: {
+      OnlineID: { type: "int", default: 1 },
+      Username: { type: "string", default: "", optional: true },
+      CountryCode: { type: "string", optional: true },
+    },
+  };
+}
+

package/src/utils/mod.ts

@@ -0,0 +1,77 @@
+import path from "node:path";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+
+export function getDataDir(): string | undefined {
+  switch (process.platform) {
+    case "linux":
+    case "openbsd":
+    case "freebsd": {
+      const xdg = process.env["XDG_DATA_HOME"];
+      if (xdg) return xdg;
+      const home = process.env["HOME"];
+      if (home) return path.join(home, ".local", "share");
+      break;
+    }
+
+    case "darwin": {
+      const home = process.env["HOME"];
+      if (home) return path.join(home, "Library", "Application Support");
+      break;
+    }
+
+    case "win32":
+      return process.env["LOCALAPPDATA"] ?? undefined;
+  }
+
+  return undefined;
+}
+
+export function getConfigDir(): string | undefined {
+  switch (process.platform) {
+    case "openbsd":
+    case "freebsd":
+    case "linux": {
+      const xdg = process.env["XDG_CONFIG_HOME"];
+      if (xdg) return xdg;
+      const home = process.env["HOME"];
+      if (home) return path.join(home, ".config");
+      break;
+    }
+
+    case "darwin": {
+      const home = process.env["HOME"];
+      if (home) return path.join(home, "Library", "Preferences");
+      break;
+    }
+
+    case "win32":
+      return process.env["APPDATA"] ?? undefined;
+  }
+
+  return undefined;
+}
+
+/**
+ * Get Realm for the app, import to the config if it doesn't exist
+ */
+export function getRealmDBPath(
+  appConfigDir: string,
+  options: {
+    osuDataDir: string;
+    reload: boolean;
+  } = { reload: false, osuDataDir: getDataDir() || "." },
+) {
+  const localDBPath = path.join(appConfigDir, "client.realm");
+  if (!options.reload && existsSync(localDBPath)) return localDBPath;
+
+  const osuDBPath = path.join(options.osuDataDir, "client.realm");
+  if (existsSync(osuDBPath)) {
+    console.log( `[getRealmDBPath]: ${osuDBPath} is being imported from osu!lazer to ${localDBPath}`);
+    mkdirSync(appConfigDir, { recursive: true });
+    copyFileSync(osuDBPath, localDBPath );
+    return localDBPath;
+  } else {
+    console.log(`[getRealmDBPath]: ${osuDBPath} not found`);
+    return null;
+  }
+}