romm/frontend/src/v2/composables/usePlatformPlayable/index.ts

// usePlatformPlayable: reactive "can any ROM on this platform run
// in-browser?" check. Companion to useCanPlay (which takes a rom);
// platform-level surfaces (PlatformTile, PlatformListRow) only know the
// slug, so they read this instead. Reuses the same engine-support utils
// so the marker on the tile and the Play button on the ROM agree.
//
// `usePlatformPlayableChecker` is the batch sibling: returns a plain
// function (no per-call computed) for surfaces that need to test many
// slugs at once (sort comparators, group-by buckets in PlatformsIndex).
//
// `emulator` resolves to the in-browser engine that actually drives the
// platform: "ruffle" for Flash, "jsdos" for Windows 3.x/9x, "dosbox" when
// the EJS catalogue picks the dosbox_pure core (DOS is wrapped by EJS but
// distinctive enough to surface by name in the UI), "emulatorjs" for
// everything else playable, and `null` when nothing on the server can run it
// or the user lacks the in-browser play grant.
//
// `mode` folds the in-browser answer together with streaming: a platform
// served by a configured streaming container is playable too, just not in
// this tab. Streaming comes from the same `containerForPlatform` the Play
// button reads, so the badge can never disagree with the button.
import { storeToRefs } from "pinia";
import { computed, type ComputedRef } from "vue";
import i18n from "@/locales";
import storeConfig, { type Config } from "@/stores/config";
import storeHeartbeat, { type Heartbeat } from "@/stores/heartbeat";
import { useNativeStore } from "@/stores/native";
import { useStreamingStore } from "@/stores/streaming";
import {
  getSupportedEJSCores,
  isEasyRpgEmulationSupported,
  isEJSEmulationSupported,
  isJsDosEmulationSupported,
  isPico8EmulationSupported,
  isRuffleEmulationSupported,
  resolvePlatformSlug,
} from "@/utils";
import { useCan } from "@/v2/composables/useCan";

export type PlatformEmulator =
  "emulatorjs" | "ruffle" | "jsdos" | "pico8" | "easyrpg" | "dosbox" | null;

export type PlatformPlayMode = "browser" | "stream" | "both" | null;

function resolveMode(playable: boolean, streamable: boolean): PlatformPlayMode {
  if (playable && streamable) return "both";
  if (playable) return "browser";
  if (streamable) return "stream";
  return null;
}

/** Pure helper: picks the engine that would actually run a platform.
 * Shared between the reactive and the batch composables so both surface
 * the same label for the same slug. */
function resolveEmulator(
  slug: string | null | undefined,
  heartbeat: Heartbeat,
  config: Config | undefined,
): PlatformEmulator {
  if (!slug) return null;
  if (isRuffleEmulationSupported(slug, heartbeat, config)) return "ruffle";
  if (isJsDosEmulationSupported(slug, heartbeat, config)) return "jsdos";
  if (isPico8EmulationSupported(slug, heartbeat, config)) return "pico8";
  if (isEasyRpgEmulationSupported(slug, heartbeat, config)) return "easyrpg";
  if (!isEJSEmulationSupported(slug, heartbeat, config)) return null;
  const cores = getSupportedEJSCores(resolvePlatformSlug(slug, config));
  if (cores.includes("dosbox_pure")) return "dosbox";
  return "emulatorjs";
}

export function usePlatformPlayable(getSlug: () => string | null | undefined): {
  playable: ComputedRef<boolean>;
  emulator: ComputedRef<PlatformEmulator>;
  streamLabel: ComputedRef<string | null>;
  mode: ComputedRef<PlatformPlayMode>;
} {
  const heartbeatStore = storeHeartbeat();
  const configStore = storeConfig();
  const streamingStore = useStreamingStore();
  const { value: heartbeat } = storeToRefs(heartbeatStore);

  const canPlayInBrowser = useCan("rom.play");
  const emulator = computed<PlatformEmulator>(() =>
    canPlayInBrowser.value
      ? resolveEmulator(getSlug(), heartbeat.value, configStore.config)
      : null,
  );

  const playable = computed(() => emulator.value !== null);

  const streamContainer = computed(() =>
    streamingStore.containerForPlatform(getSlug()),
  );

  const streamable = computed(() => streamContainer.value !== null);

  // The container's label is what the Play button says, so the tooltip says
  // the same.
  const streamLabel = computed(() =>
    streamingStore.containerLabelForPlatform(getSlug()),
  );

  const mode = computed<PlatformPlayMode>(() =>
    resolveMode(playable.value, streamable.value),
  );

  return { playable, emulator, streamLabel, mode };
}

export function usePlatformPlayableChecker(): {
  isPlayable: ComputedRef<(slug: string | null | undefined) => boolean>;
  getEmulator: ComputedRef<
    (slug: string | null | undefined) => PlatformEmulator
  >;
  isStreamable: ComputedRef<(slug: string | null | undefined) => boolean>;
  isNativeSupported: ComputedRef<(slug: string | null | undefined) => boolean>;
} {
  const heartbeatStore = storeHeartbeat();
  const configStore = storeConfig();
  const streamingStore = useStreamingStore();
  const nativeStore = useNativeStore();
  const { value: heartbeat } = storeToRefs(heartbeatStore);

  // Expose computed functions so callers that consume them inside another
  // computed (sort comparator, bucket discriminator) re-run when the
  // heartbeat or admin-toggle state changes.
  const canPlayInBrowser = useCan("rom.play");
  const getEmulator = computed(() => {
    const hb = heartbeat.value;
    const cfg = configStore.config;
    const allowed = canPlayInBrowser.value;
    return (slug: string | null | undefined): PlatformEmulator =>
      allowed ? resolveEmulator(slug, hb, cfg) : null;
  });

  const isPlayable = computed(() => {
    const resolve = getEmulator.value;
    return (slug: string | null | undefined) => resolve(slug) !== null;
  });

  const isStreamable = computed(() => {
    // Read the config object so the returned function is rebuilt when
    // /config lands or an admin changes it.
    const cfg = streamingStore.config;
    return (slug: string | null | undefined): boolean =>
      cfg.enabled && streamingStore.containerForPlatform(slug) !== null;
  });

  // Whether the desktop shell can launch this platform locally. Deliberately
  // not folded into `mode`: the badge answers a question about the server, and
  // this one is about the machine the page is open on.
  const isNativeSupported = computed(() => {
    const probed = nativeStore.support;
    return (slug: string | null | undefined): boolean =>
      Boolean(probed) && nativeStore.isSupportedPlatform(slug);
  });

  return { isPlayable, getEmulator, isStreamable, isNativeSupported };
}

/** Human-readable tooltip for the play badge / column. Shared by every
 * surface so the wording stays in lock-step. */
export function playTooltip(
  mode: PlatformPlayMode,
  emulator: PlatformEmulator,
  streamLabel: string | null,
): string {
  const t = i18n.global.t;
  switch (mode) {
    case "both":
      return t("platform.playable-both", { label: streamLabel ?? "" });
    case "stream":
      return t("platform.playable-stream", { label: streamLabel ?? "" });
    case "browser":
      switch (emulator) {
        case "ruffle":
          return t("platform.playable-browser-ruffle");
        case "jsdos":
          return t("platform.playable-browser-jsdos");
        case "pico8":
          return t("platform.playable-browser-pico8");
        case "easyrpg":
          return t("platform.playable-browser-easyrpg");
        case "dosbox":
          return t("platform.playable-browser-dosbox");
        default:
          return t("platform.playable-browser-emulatorjs");
      }
    case null:
      return t("platform.playable-none");
  }
}