mega-stream-proxy 0.1.9

package/src/Player/playerweb/SubtitleDisplay.tsx

@@ -0,0 +1,48 @@
+import { StyleSheet, Text, View } from "react-native";
+
+export type SubCueShapeWeb = { start: number; end: number; text: string };
+
+/**
+ * Renders the active subtitle cue over the video surface. Positioned
+ * absolutely with zIndex 1 (below the controls at zIndex 2, above the
+ * video background at zIndex 0).
+ */
+export function SubtitleDisplayWeb({
+  cue,
+  enabled,
+  fontSize,
+}: {
+  cue: SubCueShapeWeb | null;
+  enabled: boolean;
+  fontSize: number;
+}) {
+  if (!enabled || !cue?.text) return null;
+  return (
+    <View pointerEvents="none" style={styles.wrap}>
+      <Text style={[styles.text, { fontSize, lineHeight: fontSize * 1.35 }]}>
+        {cue.text}
+      </Text>
+    </View>
+  );
+}
+
+const styles = StyleSheet.create({
+  wrap: {
+    position: "absolute",
+    left: 0,
+    right: 0,
+    bottom: 56,
+    alignItems: "center",
+    paddingHorizontal: 24,
+    zIndex: 1,
+  },
+  text: {
+    backgroundColor: "rgba(0,0,0,0.65)",
+    color: "#fff",
+    textAlign: "center",
+    paddingHorizontal: 8,
+    paddingVertical: 3,
+    borderRadius: 4,
+    overflow: "hidden",
+  },
+});

package/src/Player/playerweb/index.ts

@@ -0,0 +1,3 @@
+export { MegaVideoPlayerWeb, type MegaVideoPlayerWebProps } from "./MegaVideoPlayer.js";
+export { PlayerControlsWeb, type PlayerControlsWebProps } from "./PlayerControls.js";
+export { SubtitleDisplayWeb, type SubCueShapeWeb } from "./SubtitleDisplay.js";

package/src/accounts/async-storage.ts

@@ -0,0 +1,55 @@
+import AsyncStorage from "@react-native-async-storage/async-storage";
+import type { MegaAccount, MegaAccountStore } from "./types.js";
+
+const STORAGE_KEY = "mega-stream-proxy.accounts";
+
+/** Structural subset of AsyncStorage (decoupled from its type surface). */
+type AsyncStoreLike = {
+  getItem: (key: string) => Promise<string | null>;
+  setItem: (key: string, value: string) => Promise<void>;
+  removeItem: (key: string) => Promise<void>;
+};
+
+/** React Native account store backed by @react-native-async-storage/async-storage. */
+export function createAsyncStorageStore(
+  storage?: AsyncStoreLike,
+): MegaAccountStore {
+  const s: AsyncStoreLike = (storage ?? AsyncStorage) as unknown as AsyncStoreLike;
+
+  const parseStored = (raw: string | null): MegaAccount[] => {
+    if (!raw) return [];
+    try {
+      const arr = JSON.parse(raw) as unknown[];
+      if (!Array.isArray(arr)) return [];
+      return arr
+        .filter((v): v is Record<string, unknown> => typeof v === "object" && v !== null)
+        .map((v) => ({
+          id: String(v.id ?? ""),
+          email: String(v.email ?? ""),
+          password: String(v.password ?? ""),
+          label: String(v.label ?? ""),
+          createdAt: Number(v.createdAt ?? 0),
+        }))
+        .sort((a, b) => b.createdAt - a.createdAt);
+    } catch {
+      return [];
+    }
+  };
+
+  return {
+    async list() {
+      return parseStored(await s.getItem(STORAGE_KEY));
+    },
+    async save(account) {
+      const accounts = parseStored(await s.getItem(STORAGE_KEY));
+      const idx = accounts.findIndex((a) => a.id === account.id);
+      if (idx >= 0) accounts[idx] = account;
+      else accounts.push(account);
+      await s.setItem(STORAGE_KEY, JSON.stringify(accounts));
+    },
+    async remove(id) {
+      const accounts = parseStored(await s.getItem(STORAGE_KEY));
+      await s.setItem(STORAGE_KEY, JSON.stringify(accounts.filter((a) => a.id !== id)));
+    },
+  };
+}

package/src/accounts/index.ts

@@ -0,0 +1,9 @@
+export type {
+  MegaAccount,
+  MegaAccountStore,
+  MegaTreeNode,
+  AccountTestResult,
+} from "./types.js";
+export { MegaAccountManager } from "./manager.js";
+export { createLocalStorageStore } from "./local-storage.js";
+export { createAsyncStorageStore } from "./async-storage.js";

package/src/accounts/local-storage.ts

@@ -0,0 +1,66 @@
+import type { MegaAccount, MegaAccountStore } from "./types.js";
+
+const STORAGE_KEY = "mega-stream-proxy.accounts";
+
+function parseStored(raw: string | null): MegaAccount[] {
+  if (!raw) return [];
+  try {
+    const arr = JSON.parse(raw) as unknown[];
+    if (!Array.isArray(arr)) return [];
+    return arr
+      .filter((v): v is Record<string, unknown> => typeof v === "object" && v !== null)
+      .map((v) => ({
+        id: String(v.id ?? ""),
+        email: String(v.email ?? ""),
+        password: String(v.password ?? ""),
+        label: String(v.label ?? ""),
+        createdAt: Number(v.createdAt ?? 0),
+      }));
+  } catch {
+    return [];
+  }
+}
+
+function sortByNewest(a: MegaAccount, b: MegaAccount): number {
+  return b.createdAt - a.createdAt;
+}
+
+/** Persists accounts in `localStorage` (web). Subscribe listens to cross-tab `storage` events. */
+export function createLocalStorageStore(
+  storage: Pick<Storage, "getItem" | "setItem" | "removeItem"> | null = null,
+): MegaAccountStore {
+  const ls = storage ?? (typeof localStorage !== "undefined" ? localStorage : null);
+  const key = (): string => (ls ? STORAGE_KEY : "__noop__");
+
+  const readAll = async (): Promise<MegaAccount[]> =>
+    ls ? parseStored(ls.getItem(key())).sort(sortByNewest) : [];
+
+  const writeAll = async (accounts: MegaAccount[]): Promise<void> => {
+    if (!ls) return;
+    ls.setItem(key(), JSON.stringify(accounts));
+  };
+
+  return {
+    list: readAll,
+    async save(account) {
+      const accounts = await readAll();
+      const idx = accounts.findIndex((a) => a.id === account.id);
+      if (idx >= 0) accounts[idx] = account;
+      else accounts.push(account);
+      await writeAll(accounts);
+    },
+    async remove(id) {
+      const accounts = await readAll();
+      await writeAll(accounts.filter((a) => a.id !== id));
+    },
+    subscribe(cb, subscriptionKey = STORAGE_KEY) {
+      if (typeof window === "undefined" || !ls) return () => {};
+      const onStorage = (e: StorageEvent) => {
+        if (e.key !== subscriptionKey && e.key !== null) return;
+        void readAll().then(cb);
+      };
+      window.addEventListener("storage", onStorage);
+      return () => window.removeEventListener("storage", onStorage);
+    },
+  };
+}

package/src/accounts/manager.ts

@@ -0,0 +1,174 @@
+import type { AccountTestResult, MegaAccount, MegaAccountStore, MegaTreeNode } from "./types.js";
+
+const VIDEO_EXT = /\.(mp4|mkv|avi|mov|webm|m4v|ts|flv|wmv|mpg|mpeg|3gp)$/i;
+const SUBTITLE_EXT = /\.(srt|ass|ssa|vtt)$/i;
+
+type MegaStorageLike = {
+  ready: Promise<unknown>;
+  name?: string | null;
+  root?: unknown;
+  files?: Record<string, FileNodeLike>;
+  close: () => void;
+};
+
+type FileNodeLike = {
+  nodeId?: string;
+  name?: string;
+  size?: number;
+  directory?: boolean;
+  children?: FileNodeLike[];
+  link?: (cb: (err: Error | null, link?: string) => void) => void;
+};
+
+function nextId(): string {
+  try {
+    return globalThis.crypto?.randomUUID?.() ?? fallbackId();
+  } catch {
+    return fallbackId();
+  }
+}
+
+function fallbackId(): string {
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/**
+ * Owns the MEGA accounts list (via a pluggable store) plus the live megajs
+ * `Storage` sessions used while browsing a saved account's cloud drive.
+ */
+export class MegaAccountManager {
+  private readonly store: MegaAccountStore;
+  private sessions = new Map<string, Promise<MegaStorageLike>>();
+
+  constructor(store: MegaAccountStore) {
+    this.store = store;
+  }
+
+  /* ------------------------- account CRUD ------------------------- */
+
+  async listAccounts(): Promise<MegaAccount[]> {
+    return this.store.list();
+  }
+
+  subscribe(cb: (accounts: MegaAccount[]) => void): () => void {
+    return this.store.subscribe?.(cb) ?? (() => {});
+  }
+
+  async addAccount(input: { email: string; password: string; label?: string }): Promise<MegaAccount> {
+    const account: MegaAccount = {
+      id: nextId(),
+      email: input.email.trim(),
+      password: input.password,
+      label: (input.label ?? "").trim(),
+      createdAt: Date.now(),
+    };
+    await this.store.save(account);
+    return account;
+  }
+
+  async deleteAccount(id: string): Promise<void> {
+    this.closeSession(id);
+    await this.store.remove(id);
+  }
+
+  /* ------------------------- sessions ------------------------- */
+
+  private async openStorage(account: { id: string; email: string; password: string }): Promise<MegaStorageLike> {
+    const existing = this.sessions.get(account.id);
+    if (existing) return existing;
+    const p = (async () => {
+      const { Storage } = (await import("megajs")) as unknown as {
+        Storage: new (opts: Record<string, unknown>) => MegaStorageLike;
+      };
+      const storage = new Storage({
+        email: account.email.trim(),
+        password: account.password,
+        userAgent: "mega-stream-proxy",
+      });
+      await storage.ready;
+      return storage;
+    })();
+    this.sessions.set(account.id, p);
+    p.catch(() => this.sessions.delete(account.id));
+    return p;
+  }
+
+  closeSession(accountId: string): void {
+    const p = this.sessions.get(accountId);
+    this.sessions.delete(accountId);
+    p?.then((s) => {
+      try {
+        s.close();
+      } catch {}
+    });
+  }
+
+  closeAll(): void {
+    for (const id of [...this.sessions.keys()]) this.closeSession(id);
+  }
+
+  /** login only — verifies credentials and counts the cloud drive. */
+  async testAccount(account: { id?: string; email: string; password: string }): Promise<AccountTestResult> {
+    const { Storage } = (await import("megajs")) as unknown as {
+      Storage: new (opts: Record<string, unknown>) => MegaStorageLike;
+    };
+    const storage = new Storage({
+      email: account.email.trim(),
+      password: account.password,
+      userAgent: "mega-stream-proxy",
+    });
+    await storage.ready;
+    let folders = 0;
+    let files = 0;
+    for (const node of Object.values(storage.files ?? {})) {
+      if (node.directory) folders += 1;
+      else files += 1;
+    }
+    const result = { name: storage.name ?? account.email, folders, files };
+    try {
+      storage.close();
+    } catch {}
+    return result;
+  }
+
+  /** Full Cloud-Drive tree of a saved account, root first. */
+  async loadTree(account: { id: string; email: string; password: string }): Promise<MegaTreeNode[]> {
+    const storage = await this.openStorage(account);
+    const out: MegaTreeNode[] = [];
+    const walk = (node: FileNodeLike, parentPath: string) => {
+      const isFolder = Boolean(node.directory);
+      const name = String(node.name ?? "");
+      const path = parentPath ? `${parentPath}/${name}` : name;
+      out.push({
+        handle: String(node.nodeId ?? name),
+        name,
+        isFolder,
+        isVideo: !isFolder && VIDEO_EXT.test(name),
+        isSubtitle: !isFolder && SUBTITLE_EXT.test(name),
+        size: Number(node.size ?? 0),
+        path,
+      });
+      if (!isFolder || !Array.isArray(node.children)) return;
+      for (const child of node.children) walk(child, path);
+    };
+    const root = storage.root as FileNodeLike | undefined;
+    if (root && Array.isArray(root.children)) {
+      for (const child of root.children) walk(child, "");
+    }
+    return out.filter((n) => n.isFolder || n.isVideo || n.isSubtitle);
+  }
+
+  /** Export a shareable link (with key) for a file inside the logged-in account. */
+  async exportLink(account: { id: string; email: string; password: string }, handle: string): Promise<string> {
+    const storage = await this.openStorage(account);
+    const node = storage.files?.[handle];
+    if (!node) throw new Error("File not found in this MEGA account.");
+    if (typeof node.link !== "function") throw new Error("Node has no link method.");
+    return new Promise<string>((resolve, reject) => {
+      node.link?.((err, link) => {
+        if (err || !link) reject(err ?? new Error("Failed to generate link"));
+        else resolve(link);
+      });
+    });
+  }
+}

package/src/accounts/types.ts

@@ -0,0 +1,38 @@
+/** A saved MEGA account (credentials + label). Passwords are handled by the store. */
+export type MegaAccount = {
+  id: string;
+  email: string;
+  password: string;
+  label: string;
+  createdAt: number;
+};
+
+/**
+ * Pluggable persistence for MEGA accounts. Bring your own backend (Firestore,
+ * AsyncStorage, localStorage, …) by implementing this interface.
+ */
+export type MegaAccountStore = {
+  list: () => Promise<MegaAccount[]>;
+  /** Upsert by id. */
+  save: (account: MegaAccount) => Promise<void>;
+  remove: (id: string) => Promise<void>;
+  /** Optional live updates; return an unsubscribe function. */
+  subscribe?: (cb: (accounts: MegaAccount[]) => void, key?: string) => () => void;
+};
+
+export type MegaTreeNode = {
+  /** MEGA node handle */
+  handle: string;
+  name: string;
+  isFolder: boolean;
+  isVideo: boolean;
+  isSubtitle: boolean;
+  size: number;
+  path: string;
+};
+
+export type AccountTestResult = {
+  name: string;
+  folders: number;
+  files: number;
+};

package/src/index.ts

@@ -0,0 +1,10 @@
+export { loadMegaFile, fileSizeOf, withTimeout } from "./megaFile.js";
+export { collectMegaFileStream } from "./stream.js";
+export {
+  parseRange,
+  toMegaRange,
+  rangeHeaders,
+  type RangeResult,
+} from "./ranges.js";
+export { SW_MARKER } from "./swDefine.js";
+export type { MegaFileLike, StreamLike } from "./proxy/types.js";

package/src/megaFile.ts

@@ -0,0 +1,48 @@
+import type { MegaFileLike } from "./proxy/types.js";
+
+const ATTRS_TIMEOUT_MS = 30_000;
+
+/** Lazily resolves megajs `File.fromURL` + attributes (incl. folder-link child). */
+export async function loadMegaFile(url: string): Promise<MegaFileLike> {
+  const { File } = (await import("megajs")) as {
+    File: { fromURL: (u: string) => MegaFileLike };
+  };
+  const file = File.fromURL(url.trim());
+  await withTimeout<unknown>(
+    file.loadAttributes(),
+    ATTRS_TIMEOUT_MS,
+    "MEGA did not respond. Check your connection and try again.",
+  );
+
+  // Folder links: loadAttributes resolves to the folder itself — pick the
+  // first non-directory child instead (mirrors the megajs docs sample).
+  const group = file as unknown as {
+    children?: unknown[];
+    find?: (fn: (n: any) => boolean, recursive: boolean) => MegaFileLike | undefined;
+  };
+  if (group.children?.length) {
+    const child = group.find?.((n: any) => !n.children, true);
+    if (child) return child;
+  }
+  return file;
+}
+
+export function fileSizeOf(file: { size?: number }): number {
+  return Number(file.size ?? 0);
+}
+
+export async function withTimeout<T>(p: Promise<T>, ms: number, msg: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const t = setTimeout(() => reject(new Error(msg)), ms);
+    p.then(
+      (v) => {
+        clearTimeout(t);
+        resolve(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      },
+    );
+  });
+}