rhythia-api 243.0.0 → 244.0.0

package/utils/beatmapHash.ts

@@ -1,336 +1,239 @@
-import { createHash } from "node:crypto";
-import { SSPMParser, type SSPMParsedMap } from "./star-calc/sspmParser.ts";
-import { V1SSPMParser, type SSPMMap } from "./star-calc/sspmv1Parser.ts";
-
-const IntrosortSizeThreshold = 16;
-const GeneralScientificLowerExponentDotNet = -5;
-const DecimalTieTolerance = Number.EPSILON * 4;
-
-type Marker = SSPMParsedMap["markers"][number];
-
-function formatSingle(value: number) {
-  value = Math.fround(value);
-
-  for (let precision = 1; precision <= 9; precision++) {
-    const rounded = Number(value.toPrecision(precision));
-    const formatted = formatGeneralDotNet(
-      breakDecimalTieDotNet(value, rounded, precision)
-    );
-
-    if (Math.fround(Number(formatted)) === value) {
-      return formatted;
-    }
-  }
-
-  return formatGeneralDotNet(value);
-}
-
-function formatGeneralDotNet(value: number) {
-  if (value === 0) {
-    return "0";
-  }
-
-  const formatted = value.toString();
-  const exponent = getDecimalExponent(value);
-
-  if (
-    formatted.includes("e") ||
-    exponent <= GeneralScientificLowerExponentDotNet
-  ) {
-    return formatExponential(value, getSignificantDigitCount(formatted));
-  }
-
-  return formatted;
-}
-
-function getDecimalExponent(value: number) {
-  return Math.floor(Math.log10(Math.abs(value)));
-}
-
-function getSignificantDigitCount(value: string) {
-  const [mantissa] = value.toLowerCase().split("e");
-  const digits = mantissa!.replace("-", "").replace(".", "").replace(/^0+/, "");
-  return Math.max(digits.length, 1);
-}
-
-function formatExponential(value: number, significantDigitCount: number) {
-  const [mantissa, exponent] = value
-    .toExponential(significantDigitCount - 1)
-    .split("e");
-  const exponentValue = Number(exponent);
-  const exponentSign = exponentValue < 0 ? "-" : "+";
-  const exponentDigits = Math.abs(exponentValue).toString().padStart(2, "0");
-  const normalizedMantissa = mantissa!
-    .replace(/(\.\d*?)0+$/, "$1")
-    .replace(/\.$/, "");
-
-  return `${normalizedMantissa}E${exponentSign}${exponentDigits}`;
-}
-
-function breakDecimalTieDotNet(
-  value: number,
-  rounded: number,
-  precision: number
-) {
-  if (rounded === value || Math.fround(rounded) !== value) {
-    return rounded;
-  }
-
-  const exponent = getDecimalExponent(rounded);
-  const step = 10 ** (exponent - precision + 1);
-  const alternate = Number(
-    (rounded > value ? rounded - step : rounded + step).toPrecision(precision)
-  );
-
-  if (alternate === rounded || Math.fround(alternate) !== value) {
-    return rounded;
-  }
-
-  const roundedDistance = Math.abs(value - rounded);
-  const alternateDistance = Math.abs(value - alternate);
-  const tolerance =
-    DecimalTieTolerance *
-    Math.max(1, Math.abs(value), Math.abs(rounded), Math.abs(alternate));
-
-  if (alternateDistance + tolerance < roundedDistance) {
-    return alternate;
-  }
-
-  if (roundedDistance + tolerance < alternateDistance) {
-    return rounded;
-  }
-
-  return hasEvenLastSignificantDigit(alternate, precision)
-    ? alternate
-    : rounded;
-}
-
-function hasEvenLastSignificantDigit(value: number, precision: number) {
-  const [mantissa] = Math.abs(value).toPrecision(precision).split("e");
-  const digits = mantissa!.replace(".", "").replace(/^0+/, "");
-  const lastDigit = Number(digits.at(-1));
-
-  return lastDigit % 2 === 0;
-}
-
-function compareMarkerPosition(a: Marker, b: Marker) {
-  return a.position - b.position;
-}
-
-function swap(items: Marker[], left: number, right: number) {
-  const temp = items[left]!;
-  items[left] = items[right]!;
-  items[right] = temp;
-}
-
-function swapIfGreater(items: Marker[], left: number, right: number) {
-  if (
-    left !== right &&
-    compareMarkerPosition(items[left]!, items[right]!) > 0
-  ) {
-    swap(items, left, right);
-  }
-}
-
-function insertionSort(items: Marker[], start: number, length: number) {
-  for (let i = start; i < start + length - 1; i++) {
-    const value = items[i + 1]!;
-    let j = i;
-
-    while (j >= start && compareMarkerPosition(value, items[j]!) < 0) {
-      items[j + 1] = items[j]!;
-      j--;
-    }
-
-    items[j + 1] = value;
-  }
-}
-
-function downHeap(
-  items: Marker[],
-  start: number,
-  index: number,
-  heapSize: number
-) {
-  const value = items[start + index - 1]!;
-  let child: number;
-
-  while ((child = 2 * index) <= heapSize) {
-    if (
-      child < heapSize &&
-      compareMarkerPosition(items[start + child - 1]!, items[start + child]!) <
-        0
-    ) {
-      child++;
-    }
-
-    if (compareMarkerPosition(value, items[start + child - 1]!) >= 0) {
-      break;
-    }
-
-    items[start + index - 1] = items[start + child - 1]!;
-    index = child;
-  }
-
-  items[start + index - 1] = value;
-}
-
-function heapSort(items: Marker[], start: number, length: number) {
-  for (let i = Math.floor(length / 2); i >= 1; i--) {
-    downHeap(items, start, i, length);
-  }
-
-  for (let i = length; i > 1; i--) {
-    swap(items, start, start + i - 1);
-    downHeap(items, start, 1, i - 1);
-  }
-}
-
-function pickPivotAndPartition(items: Marker[], start: number, length: number) {
-  const high = start + length - 1;
-  const middle = start + ((high - start) >> 1);
-
-  swapIfGreater(items, start, middle);
-  swapIfGreater(items, start, high);
-  swapIfGreater(items, middle, high);
-
-  const pivot = items[middle]!;
-  swap(items, middle, high - 1);
-
-  let left = start;
-  let right = high - 1;
-
-  while (left < right) {
-    while (compareMarkerPosition(items[++left]!, pivot) < 0) {}
-    while (compareMarkerPosition(pivot, items[--right]!) < 0) {}
-
-    if (left >= right) {
-      break;
-    }
-
-    swap(items, left, right);
-  }
-
-  if (left !== high - 1) {
-    swap(items, left, high - 1);
-  }
-
-  return left;
-}
-
-function introSort(
-  items: Marker[],
-  start: number,
-  length: number,
-  depthLimit: number
-) {
-  let partitionSize = length;
-
-  while (partitionSize > 1) {
-    if (partitionSize <= IntrosortSizeThreshold) {
-      if (partitionSize === 2) {
-        swapIfGreater(items, start, start + 1);
-        return;
-      }
-
-      if (partitionSize === 3) {
-        swapIfGreater(items, start, start + 1);
-        swapIfGreater(items, start, start + 2);
-        swapIfGreater(items, start + 1, start + 2);
-        return;
-      }
-
-      insertionSort(items, start, partitionSize);
-      return;
-    }
-
-    if (depthLimit === 0) {
-      heapSort(items, start, partitionSize);
-      return;
-    }
-
-    depthLimit--;
-    const pivot = pickPivotAndPartition(items, start, partitionSize);
-    introSort(
-      items,
-      pivot + 1,
-      start + partitionSize - (pivot + 1),
-      depthLimit
-    );
-    partitionSize = pivot - start;
-  }
-}
-
-function sortByPositionDotNet(markers: Marker[]) {
-  const result = [...markers];
-
-  if (result.length > 1) {
-    const depthLimit = 2 * (Math.floor(Math.log2(result.length)) + 1);
-    introSort(result, 0, result.length, depthLimit);
-  }
-
-  return result;
-}
-
-export function computeBeatmapHash(map: SSPMParsedMap) {
-  const noteType = Math.max(
-    map.markerDefinitions.findIndex((x) => x.id === "ssp_note"),
-    0
-  );
-  const customDifficultyName =
-    map.customData.fields.find((x) => x.id === "difficulty_name")?.value ?? "";
-
-  const hashString =
-    map.strings.mapName +
-    map.strings.mapName +
-    map.strings.mappers.join(",") +
-    map.metadata.lastMarkerPos +
-    sortByPositionDotNet(map.markers.filter((x) => x.type === noteType))
-      .map(
-        (x) =>
-          x.position +
-          formatSingle(x.data.position.x) +
-          formatSingle(x.data.position.y)
-      )
-      .join(",") +
-    map.metadata.difficulty +
-    customDifficultyName;
-
-  return createHash("sha256").update(hashString, "utf16le").digest("hex");
-}
-
-export function computeV1BeatmapHash(map: SSPMMap) {
-  const hashString =
-    map.name +
-    map.name +
-    map.creator
-      .split(/[&,]/)
-      .map((x) => x.trim())
-      .join(",") +
-    map.lastNotePosition +
-    map.notes
-      .map(
-        (x) =>
-          x.position +
-          formatSingle(x.x) +
-          formatSingle(x.y)
-      )
-      .join(",") +
-    map.difficulty;
-
-  return createHash("sha256").update(hashString, "utf16le").digest("hex");
-}
-
-export function computeBeatmapHashFromBytes(bytes: Buffer) {
-  const version = bytes.readUInt16LE(4);
-
-  if (version === 1) {
-    return computeV1BeatmapHash(new V1SSPMParser(bytes).parse());
-  }
-
-  if (version === 2) {
-    return computeBeatmapHash(new SSPMParser(bytes).parse());
-  }
-
-  throw new Error(`Invalid SSPM version: ${version}`);
-}
+import { createHash } from "node:crypto";
+import { SSPMParser, type SSPMParsedMap } from "./star-calc/sspmParser.ts";
+import { V1SSPMParser, type SSPMMap } from "./star-calc/sspmv1Parser.ts";
+import { formatSingle } from "./star-calc/formatSingle.ts";
+import {
+  computeRhythiaMapHash,
+  isRHM,
+  parseRHM,
+} from "./star-calc/rhmParser.ts";
+
+const IntrosortSizeThreshold = 16;
+
+type Marker = SSPMParsedMap["markers"][number];
+
+function compareMarkerPosition(a: Marker, b: Marker) {
+  return a.position - b.position;
+}
+
+function swap(items: Marker[], left: number, right: number) {
+  const temp = items[left]!;
+  items[left] = items[right]!;
+  items[right] = temp;
+}
+
+function swapIfGreater(items: Marker[], left: number, right: number) {
+  if (
+    left !== right &&
+    compareMarkerPosition(items[left]!, items[right]!) > 0
+  ) {
+    swap(items, left, right);
+  }
+}
+
+function insertionSort(items: Marker[], start: number, length: number) {
+  for (let i = start; i < start + length - 1; i++) {
+    const value = items[i + 1]!;
+    let j = i;
+
+    while (j >= start && compareMarkerPosition(value, items[j]!) < 0) {
+      items[j + 1] = items[j]!;
+      j--;
+    }
+
+    items[j + 1] = value;
+  }
+}
+
+function downHeap(
+  items: Marker[],
+  start: number,
+  index: number,
+  heapSize: number
+) {
+  const value = items[start + index - 1]!;
+  let child: number;
+
+  while ((child = 2 * index) <= heapSize) {
+    if (
+      child < heapSize &&
+      compareMarkerPosition(items[start + child - 1]!, items[start + child]!) <
+        0
+    ) {
+      child++;
+    }
+
+    if (compareMarkerPosition(value, items[start + child - 1]!) >= 0) {
+      break;
+    }
+
+    items[start + index - 1] = items[start + child - 1]!;
+    index = child;
+  }
+
+  items[start + index - 1] = value;
+}
+
+function heapSort(items: Marker[], start: number, length: number) {
+  for (let i = Math.floor(length / 2); i >= 1; i--) {
+    downHeap(items, start, i, length);
+  }
+
+  for (let i = length; i > 1; i--) {
+    swap(items, start, start + i - 1);
+    downHeap(items, start, 1, i - 1);
+  }
+}
+
+function pickPivotAndPartition(items: Marker[], start: number, length: number) {
+  const high = start + length - 1;
+  const middle = start + ((high - start) >> 1);
+
+  swapIfGreater(items, start, middle);
+  swapIfGreater(items, start, high);
+  swapIfGreater(items, middle, high);
+
+  const pivot = items[middle]!;
+  swap(items, middle, high - 1);
+
+  let left = start;
+  let right = high - 1;
+
+  while (left < right) {
+    while (compareMarkerPosition(items[++left]!, pivot) < 0) {}
+    while (compareMarkerPosition(pivot, items[--right]!) < 0) {}
+
+    if (left >= right) {
+      break;
+    }
+
+    swap(items, left, right);
+  }
+
+  if (left !== high - 1) {
+    swap(items, left, high - 1);
+  }
+
+  return left;
+}
+
+function introSort(
+  items: Marker[],
+  start: number,
+  length: number,
+  depthLimit: number
+) {
+  let partitionSize = length;
+
+  while (partitionSize > 1) {
+    if (partitionSize <= IntrosortSizeThreshold) {
+      if (partitionSize === 2) {
+        swapIfGreater(items, start, start + 1);
+        return;
+      }
+
+      if (partitionSize === 3) {
+        swapIfGreater(items, start, start + 1);
+        swapIfGreater(items, start, start + 2);
+        swapIfGreater(items, start + 1, start + 2);
+        return;
+      }
+
+      insertionSort(items, start, partitionSize);
+      return;
+    }
+
+    if (depthLimit === 0) {
+      heapSort(items, start, partitionSize);
+      return;
+    }
+
+    depthLimit--;
+    const pivot = pickPivotAndPartition(items, start, partitionSize);
+    introSort(
+      items,
+      pivot + 1,
+      start + partitionSize - (pivot + 1),
+      depthLimit
+    );
+    partitionSize = pivot - start;
+  }
+}
+
+function sortByPositionDotNet(markers: Marker[]) {
+  const result = [...markers];
+
+  if (result.length > 1) {
+    const depthLimit = 2 * (Math.floor(Math.log2(result.length)) + 1);
+    introSort(result, 0, result.length, depthLimit);
+  }
+
+  return result;
+}
+
+export function computeBeatmapHash(map: SSPMParsedMap) {
+  const noteType = Math.max(
+    map.markerDefinitions.findIndex((x) => x.id === "ssp_note"),
+    0
+  );
+  const customDifficultyName =
+    map.customData.fields.find((x) => x.id === "difficulty_name")?.value ?? "";
+
+  const hashString =
+    map.strings.mapName +
+    map.strings.mapName +
+    map.strings.mappers.join(",") +
+    map.metadata.lastMarkerPos +
+    sortByPositionDotNet(map.markers.filter((x) => x.type === noteType))
+      .map(
+        (x) =>
+          x.position +
+          formatSingle(x.data.position.x) +
+          formatSingle(x.data.position.y)
+      )
+      .join(",") +
+    map.metadata.difficulty +
+    customDifficultyName;
+
+  return createHash("sha256").update(hashString, "utf16le").digest("hex");
+}
+
+export function computeV1BeatmapHash(map: SSPMMap) {
+  const hashString =
+    map.name +
+    map.name +
+    map.creator
+      .split(/[&,]/)
+      .map((x) => x.trim())
+      .join(",") +
+    map.lastNotePosition +
+    map.notes
+      .map(
+        (x) =>
+          x.position +
+          formatSingle(x.x) +
+          formatSingle(x.y)
+      )
+      .join(",") +
+    map.difficulty;
+
+  return createHash("sha256").update(hashString, "utf16le").digest("hex");
+}
+
+export function computeBeatmapHashFromBytes(bytes: Buffer) {
+  if (isRHM(bytes)) {
+    return computeRhythiaMapHash(parseRHM(bytes).map);
+  }
+
+  const version = bytes.readUInt16LE(4);
+
+  if (version === 1) {
+    return computeV1BeatmapHash(new V1SSPMParser(bytes).parse());
+  }
+
+  if (version === 2) {
+    return computeBeatmapHash(new SSPMParser(bytes).parse());
+  }
+
+  throw new Error(`Invalid SSPM version: ${version}`);
+}

package/utils/moderation.ts

@@ -0,0 +1,101 @@
+import type { Json } from "../types/database";
+import { supabase } from "./supabase";
+
+export type ViolationType = "excluded" | "silenced" | "restricted";
+
+export type AddViolationInput = {
+  profileId: number;
+  type: ViolationType;
+  reason: string;
+  expiresAt?: string | null;
+  moderatedBy: number;
+  metadata?: Record<string, unknown>;
+};
+
+export type RevokeViolationInput = {
+  profileId: number;
+  type: ViolationType;
+  revokedBy: number;
+  reason?: string;
+};
+
+export type ModerationState = {
+  excluded: boolean;
+  silenced: boolean;
+  restricted: boolean;
+  activeViolations: Array<{
+    id: number;
+    type: ViolationType;
+    reason: string;
+    createdAt: string;
+    expiresAt: string | null;
+    moderatedBy: number | null;
+  }>;
+};
+
+type RpcActiveViolation = ModerationState["activeViolations"][number] & {
+  violation_type?: ViolationType;
+  created_at?: string;
+  expires_at?: string | null;
+  moderated_by?: number | null;
+};
+
+export async function addViolation(input: AddViolationInput) {
+  return supabase.rpc("add_user_violation", {
+    _profile_id: input.profileId,
+    _violation_type: input.type,
+    _reason: input.reason,
+    _expires_at: input.expiresAt ?? undefined,
+    _moderated_by: input.moderatedBy,
+    _metadata: (input.metadata ?? {}) as Json,
+  });
+}
+
+export async function revokeViolation(input: RevokeViolationInput) {
+  return supabase.rpc("revoke_user_violation", {
+    _profile_id: input.profileId,
+    _violation_type: input.type,
+    _revoked_by: input.revokedBy,
+    _revoke_reason: input.reason,
+  });
+}
+
+export async function getUserViolationState(profileId: number) {
+  return supabase.rpc("get_user_violation_state", {
+    _profile_id: profileId,
+  });
+}
+
+export async function getModerationState(profileId: number) {
+  const { data, error } = await getUserViolationState(profileId);
+
+  if (error) {
+    return { data: null, error };
+  }
+
+  const state = data?.[0];
+
+  if (!state) {
+    return { data: null, error: { message: "Moderation state not found" } };
+  }
+
+  const activeViolations = (state.active_violations ??
+    []) as RpcActiveViolation[];
+
+  return {
+    data: {
+      excluded: state.excluded,
+      silenced: state.silenced,
+      restricted: state.restricted,
+      activeViolations: activeViolations.map((violation) => ({
+        id: violation.id,
+        type: violation.type ?? violation.violation_type!,
+        reason: violation.reason,
+        createdAt: violation.createdAt ?? violation.created_at!,
+        expiresAt: violation.expiresAt ?? violation.expires_at ?? null,
+        moderatedBy: violation.moderatedBy ?? violation.moderated_by ?? null,
+      })),
+    } satisfies ModerationState,
+    error: null,
+  };
+}