@hopecloud/jetstream-player 1.3.0 → 1.4.0-rc.6

package/README.md

@@ -1,10 +1,10 @@
 # @hopecloud/jetstream-player
 
-Control an embedded [Jetstream](https://jetstream-player.docs.hope.cloud/) player
+Control an embedded [Jetstream](https://docs.hope.cloud/libs/jetstream-player/) player
 from your page — play, pause, seek, mute, read playback state, and subscribe to
 events — across the iframe boundary, with no server glue.
 
-**[Full documentation →](https://jetstream-player.docs.hope.cloud/)**
+**[Full documentation →](https://docs.hope.cloud/libs/jetstream-player/)**
 
 ## Install
 
@@ -36,26 +36,25 @@ at the given selector.
 
 - **Commands** — `play()`, `pause()`, `mute()`, `unmute()`, `seekTo(seconds)`,
   `playNext()`, `playPrev()`.
-- **Getters** (Promise-based) — `isMuted()`, `isPaused()`,
-  `getVideoCurrentTime()`, `getDuration()`. They reject after 5s if the player
-  doesn't reply.
+- **Getters** (Promise-based) — `isMuted()`, `isPaused()`, `getCurrentTime()`,
+  `getDuration()`. They reject after 5s if the player doesn't reply.
 - **Events** — subscribe via `options.events`: `ready`, `timeupdate`, `play`,
   `pause`, `loadedmetadata`, `ended`, `volumechange`, `error`.
 - **Teardown** — `dispose()` removes listeners and tears down Picture-in-Picture.
 
-See the [options](https://jetstream-player.docs.hope.cloud/api/player-options)
-and [methods](https://jetstream-player.docs.hope.cloud/api/player-methods)
+See the [options](https://docs.hope.cloud/libs/jetstream-player/player-options)
+and [methods](https://docs.hope.cloud/libs/jetstream-player/player-methods)
 reference for the full list.
 
 ## Targeting a non-prod embed
 
 By default the player loads the production embed. Point it at another host
-(staging/dev) with `origin`:
+(staging/dev) with `embedOrigin`:
 
 ```ts
 new JetstreamPlayer('#player', {
   mediaId: 'jsv:xxxxxxxxxx',
-  origin: 'https://embed-stage.jetstream.studio',
+  embedOrigin: 'https://embed-stage.jetstream.studio',
 });
 ```
 
@@ -69,8 +68,10 @@ pnpm install
 pnpm build       # rolldown + .d.ts
 pnpm test        # vitest
 pnpm lint
-pnpm typecheck
-pnpm docs:dev    # vitepress docs
+pnpm type-check
 ```
 
+Documentation lives in the monorepo's public docs site at
+`docs/cloud/libs/jetstream-player/`, published to docs.hope.cloud.
+
 Architecture decisions are recorded in [`adr/`](./adr).

package/dist/{player-bridge.d.ts → bridge/player-bridge.d.ts}

@@ -1,4 +1,4 @@
-import type { PlayerCommand, PlayerEvent } from './player.type';
+import type { PlayerCommand, PlayerEvent } from './protocol.types';
 import type { PlayerTransport } from './player-transport';
 export declare class PlayerBridge {
     private readonly transport;

package/dist/{protocol.d.ts → bridge/protocol.d.ts}

@@ -1,3 +1,3 @@
-import type { PlayerCommand, PlayerEvent } from './player.type';
+import type { PlayerCommand, PlayerEvent } from './protocol.types';
 export declare const encode: (command: PlayerCommand) => string;
 export declare const decode: (raw: string) => PlayerEvent | null;

package/dist/{player.type.d.ts → bridge/protocol.types.d.ts}

@@ -1,27 +1,22 @@
+export interface PlayerEventMap {
+    ready: unknown;
+    timeupdate: number;
+    play: unknown;
+    pause: unknown;
+    loadedmetadata: undefined;
+    ended: boolean;
+    volumechange: number;
+    error: unknown;
+}
 export declare const playerListenEvents: readonly ["ready", "timeupdate", "play", "pause", "loadedmetadata", "ended", "volumechange", "error"];
-export type PlayerEvents = 'ready' | 'timeupdate' | 'play' | 'pause' | 'loadedmetadata' | 'ended' | 'volumechange' | 'error';
+export type PlayerEvents = (typeof playerListenEvents)[number];
 export type PlayerGetterEvents = 'is-muted' | 'get-video-current-time' | 'get-duration' | 'is-paused';
 export interface PlayerEvent {
     type: PlayerEvents | PlayerGetterEvents;
     value?: unknown;
 }
-export type PlayerEventHandler = (value?: unknown) => void;
 export type PlayerCommandEvent = 'play' | 'pause' | 'mute' | 'unmute' | 'seekTo' | 'play-next' | 'play-prev';
 export interface PlayerCommand {
     name: PlayerCommandEvent | PlayerGetterEvents;
     params?: unknown;
 }
-export interface EmbedFrameOptions {
-    mediaId: string;
-    playerId?: string;
-    region?: 'eu';
-    audioLang?: string;
-    subtitleLang?: string;
-    origin?: string;
-    width?: string;
-    height?: string;
-}
-export type JetstreamPlayerOptions = {
-    sticky?: boolean;
-    events?: Partial<Record<PlayerEvents, PlayerEventHandler>>;
-} & EmbedFrameOptions;

package/dist/{embed-frame.d.ts → embed/embed-frame.d.ts}

@@ -1,4 +1,4 @@
-import type { EmbedFrameOptions } from './player.type';
+import type { EmbedFrameOptions } from './embed-frame.types';
 export declare const buildEmbedSrc: (options: EmbedFrameOptions) => string;
 export interface MountedFrame {
     iframe: HTMLIFrameElement;

package/dist/embed/embed-frame.types.d.ts

@@ -0,0 +1,12 @@
+export interface EmbedFrameOptions {
+    mediaId: string;
+    playerId?: string;
+    region?: 'eu';
+    audioLang?: string;
+    subtitleLang?: string;
+    embedOrigin?: string;
+    /** @deprecated Use {@link embedOrigin} instead. */
+    origin?: string;
+    width?: string;
+    height?: string;
+}

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 export { JetstreamPlayer } from './player';
-export * from './player.type';
+export type { JetstreamPlayerOptions, PlayerEventHandler, PlayerEventHandlers, } from './player.types';
+export type { EmbedFrameOptions } from './embed/embed-frame.types';
+export { playerListenEvents } from './bridge/protocol.types';
+export type { PlayerCommand, PlayerCommandEvent, PlayerEvent, PlayerEventMap, PlayerEvents, PlayerGetterEvents, } from './bridge/protocol.types';

package/dist/index.js

@@ -1,5 +1,84 @@
-//#region src/embed-frame.ts
-const DEFAULT_ORIGIN = "https://jstre.am";
+//#region src/bridge/protocol.ts
+const encode = (command) => JSON.stringify(command);
+const decode = (raw) => {
+	if (typeof raw !== "string") return null;
+	try {
+		const parsed = JSON.parse(raw);
+		if (typeof parsed === "object" && parsed !== null && typeof parsed.type === "string") return parsed;
+		return null;
+	} catch {
+		return null;
+	}
+};
+//#endregion
+//#region src/bridge/player-bridge.ts
+const REQUEST_TIMEOUT_MS = 5e3;
+var PlayerBridge = class {
+	transport;
+	targetOrigin;
+	listeners = /* @__PURE__ */ new Set();
+	detach;
+	constructor(transport, initialTargetOrigin) {
+		this.transport = transport;
+		this.targetOrigin = initialTargetOrigin;
+		this.detach = this.transport.subscribe((message, origin) => {
+			const event = decode(message);
+			if (!event) return;
+			this.targetOrigin = origin;
+			this.listeners.forEach((listener) => listener(event));
+		});
+	}
+	send(command) {
+		this.transport.send(encode(command), this.targetOrigin);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	request(command, timeoutMs = REQUEST_TIMEOUT_MS) {
+		return new Promise((resolve, reject) => {
+			let off = () => void 0;
+			const timer = setTimeout(() => {
+				off();
+				reject(/* @__PURE__ */ new Error(`Timed out waiting for "${command.name}" response`));
+			}, timeoutMs);
+			off = this.subscribe((event) => {
+				if (event.type === command.name) {
+					clearTimeout(timer);
+					off();
+					resolve(event.value);
+				}
+			});
+			this.send(command);
+		});
+	}
+	dispose() {
+		this.detach();
+		this.listeners.clear();
+	}
+};
+//#endregion
+//#region src/bridge/player-transport.ts
+const windowTransport = (iframe) => ({
+	send: (message, targetOrigin) => {
+		iframe.contentWindow?.postMessage(message, targetOrigin);
+	},
+	subscribe: (handler) => {
+		const listener = (event) => {
+			if (event.source !== iframe.contentWindow) return;
+			handler(event.data, event.origin);
+		};
+		window.addEventListener("message", listener);
+		return () => {
+			window.removeEventListener("message", listener);
+		};
+	}
+});
+//#endregion
+//#region src/embed/embed-frame.ts
+const DEFAULT_EMBED_ORIGIN = "https://jstre.am";
 const regionOrigin = (origin, region) => {
 	const url = new URL(origin);
 	if (region === "eu") {
@@ -11,9 +90,9 @@ const regionOrigin = (origin, region) => {
 };
 const buildEmbedSrc = (options) => {
 	if (options.mediaId === "") throw new Error("mediaId not provided!");
-	const origin = regionOrigin(options.origin ?? DEFAULT_ORIGIN, options.region);
+	const embedOrigin = regionOrigin(options.embedOrigin ?? options.origin ?? DEFAULT_EMBED_ORIGIN, options.region);
 	const path = options.playerId ? `/embed/${options.mediaId}/${options.playerId}` : `/embed/${options.mediaId}`;
-	const url = new URL(`${origin}${path}`);
+	const url = new URL(`${embedOrigin}${path}`);
 	if (options.region === "eu") url.searchParams.append("region", "eu");
 	if (options.audioLang) url.searchParams.append("audioLang", options.audioLang.toLowerCase());
 	if (options.subtitleLang) url.searchParams.append("subtitleLang", options.subtitleLang.toLowerCase());
@@ -25,11 +104,11 @@ const mountEmbedFrame = (selector, options) => {
 	iframe.allow = "accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture";
 	iframe.allowFullscreen = true;
 	iframe.frameBorder = "0";
-	iframe.title = "Jetstream player";
+	iframe.title = "Jetstream Player";
 	iframe.src = src;
 	iframe.width = options.width || "480px";
 	iframe.height = options.height || "270px";
-	iframe.classList.add("jet-stream-iframe-player");
+	iframe.classList.add("jetstream-player-iframe");
 	const parent = document.querySelector(selector);
 	if (parent) parent.appendChild(iframe);
 	else console.error(`Element matching selector "${selector}" not found.`);
@@ -39,7 +118,7 @@ const mountEmbedFrame = (selector, options) => {
 	};
 };
 //#endregion
-//#region src/iframe-pip-plugin.ts
+//#region src/pip/iframe-pip-plugin.ts
 const PiP_STYLES = {
 	position: "fixed",
 	bottom: "20px",
@@ -98,90 +177,8 @@ var IFramePiPPlugin = class {
 		if (this.iframe) if (this.originalIframeStyle) this.iframe.setAttribute("style", this.originalIframeStyle);
 		else this.iframe.removeAttribute("style");
 	}
-	destory() {
-		this.destroy();
-	}
-};
-//#endregion
-//#region src/protocol.ts
-const encode = (command) => JSON.stringify(command);
-const decode = (raw) => {
-	if (typeof raw !== "string") return null;
-	try {
-		const parsed = JSON.parse(raw);
-		if (typeof parsed === "object" && parsed !== null && typeof parsed.type === "string") return parsed;
-		return null;
-	} catch {
-		return null;
-	}
-};
-//#endregion
-//#region src/player-bridge.ts
-const REQUEST_TIMEOUT_MS = 5e3;
-var PlayerBridge = class {
-	transport;
-	targetOrigin;
-	listeners = /* @__PURE__ */ new Set();
-	detach;
-	constructor(transport, initialTargetOrigin) {
-		this.transport = transport;
-		this.targetOrigin = initialTargetOrigin;
-		this.detach = this.transport.subscribe((message, origin) => {
-			const event = decode(message);
-			if (!event) return;
-			this.targetOrigin = origin;
-			this.listeners.forEach((listener) => listener(event));
-		});
-	}
-	send(command) {
-		this.transport.send(encode(command), this.targetOrigin);
-	}
-	subscribe(listener) {
-		this.listeners.add(listener);
-		return () => {
-			this.listeners.delete(listener);
-		};
-	}
-	request(command, timeoutMs = REQUEST_TIMEOUT_MS) {
-		return new Promise((resolve, reject) => {
-			let off = () => void 0;
-			const timer = setTimeout(() => {
-				off();
-				reject(/* @__PURE__ */ new Error(`Timed out waiting for "${command.name}" response`));
-			}, timeoutMs);
-			off = this.subscribe((event) => {
-				if (event.type === command.name) {
-					clearTimeout(timer);
-					off();
-					resolve(event.value);
-				}
-			});
-			this.send(command);
-		});
-	}
-	dispose() {
-		this.detach();
-		this.listeners.clear();
-	}
 };
 //#endregion
-//#region src/player-transport.ts
-const windowTransport = (iframe) => ({
-	send: (message, targetOrigin) => {
-		iframe.contentWindow?.postMessage(message, targetOrigin);
-	},
-	subscribe: (handler) => {
-		const listener = (event) => {
-			if (event.source !== iframe.contentWindow) return;
-			handler(event.data, event.origin);
-		};
-		window.addEventListener("message", listener);
-		return () => {
-			window.removeEventListener("message", listener);
-		};
-	}
-});
-//#endregion
 //#region src/player.ts
 var JetstreamPlayer = class {
 	options;
@@ -272,9 +269,13 @@ var JetstreamPlayer = class {
 	isPaused() {
 		return this.request({ name: "is-paused" });
 	}
-	getVideoCurrentTime() {
+	getCurrentTime() {
 		return this.request({ name: "get-video-current-time" });
 	}
+	/** @deprecated Use {@link getCurrentTime} instead. */
+	getVideoCurrentTime() {
+		return this.getCurrentTime();
+	}
 	getDuration() {
 		return this.request({ name: "get-duration" });
 	}
@@ -285,7 +286,7 @@ var JetstreamPlayer = class {
 	}
 };
 //#endregion
-//#region src/player.type.ts
+//#region src/bridge/protocol.types.ts
 const playerListenEvents = [
 	"ready",
 	"timeupdate",

package/dist/{iframe-pip-plugin.d.ts → pip/iframe-pip-plugin.d.ts}

@@ -8,5 +8,4 @@ export declare class IFramePiPPlugin {
     constructor(containerSelector: string, iframe: HTMLIFrameElement);
     init(): void;
     destroy(): void;
-    destory(): void;
 }

package/dist/player.d.ts

@@ -1,4 +1,5 @@
-import type { PlayerEvents, JetstreamPlayerOptions, PlayerEventHandler } from './player.type';
+import type { PlayerEvents } from './bridge/protocol.types';
+import type { JetstreamPlayerOptions, PlayerEventHandler } from './player.types';
 export declare class JetstreamPlayer {
     private options;
     private readonly listeners;
@@ -7,8 +8,8 @@ export declare class JetstreamPlayer {
     constructor(el: string, options: JetstreamPlayerOptions);
     private registerEvents;
     private emit;
-    on(event: PlayerEvents, handler: PlayerEventHandler): () => void;
-    off(event: PlayerEvents, handler?: PlayerEventHandler): void;
+    on<E extends PlayerEvents>(event: E, handler: PlayerEventHandler<E>): () => void;
+    off<E extends PlayerEvents>(event: E, handler?: PlayerEventHandler<E>): void;
     private request;
     play(): void;
     pause(): void;
@@ -19,6 +20,8 @@ export declare class JetstreamPlayer {
     playPrev(): void;
     isMuted(): Promise<boolean>;
     isPaused(): Promise<boolean>;
+    getCurrentTime(): Promise<number>;
+    /** @deprecated Use {@link getCurrentTime} instead. */
     getVideoCurrentTime(): Promise<number>;
     getDuration(): Promise<number>;
     dispose(): void;

package/dist/player.types.d.ts

@@ -0,0 +1,10 @@
+import type { PlayerEventMap, PlayerEvents } from './bridge/protocol.types';
+import type { EmbedFrameOptions } from './embed/embed-frame.types';
+export type PlayerEventHandler<E extends PlayerEvents = PlayerEvents> = (value: PlayerEventMap[E]) => void;
+export type PlayerEventHandlers = {
+    [E in PlayerEvents]?: PlayerEventHandler<E>;
+};
+export type JetstreamPlayerOptions = {
+    sticky?: boolean;
+    events?: PlayerEventHandlers;
+} & EmbedFrameOptions;

package/package.json

@@ -1,15 +1,10 @@
 {
   "name": "@hopecloud/jetstream-player",
-  "version": "1.3.0",
+  "version": "1.4.0-rc.6",
   "description": "Jetstream Embed Player SDK",
   "type": "module",
   "sideEffects": false,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hopechannel/hopecloud.git",
-    "directory": "libs/jetstream-player"
-  },
-  "homepage": "https://jetstream-player.docs.hope.cloud/",
+  "homepage": "https://docs.hope.cloud/libs/jetstream-player/",
   "engines": {
     "node": "24"
   },
@@ -37,14 +32,10 @@
     "happy-dom": "^20.4.0",
     "rolldown": "^1.1.4",
     "typescript": "6.0.3",
-    "vitepress": "^1.6.4",
     "vitest": "^4.0.18"
   },
   "scripts": {
     "build": "rolldown --config && tsc --emitDeclarationOnly",
-    "docs:dev": "vitepress dev docs",
-    "docs:build": "vitepress build docs",
-    "docs:preview": "vitepress preview docs",
     "lint": "eslint",
     "lint:fix": "eslint --fix",
     "type-check": "tsc --noEmit",