@vindral/web-sdk 3.4.4 → 4.0.0-101-g094c7a1b

package/cast-sender.d.ts

@@ -0,0 +1,424 @@
+type VideoCodec = "h264" | "av1";
+type MatchingKeys<TRecord, TMatch, K extends keyof TRecord = keyof TRecord> = K extends (TRecord[K] extends TMatch ? K : never) ? K : never;
+type VoidKeys<Record> = MatchingKeys<Record, void>;
+type EventListenerReturnType = (() => void) | void;
+declare class Emitter<TEvents, TEmits = TEvents, ArgLessEvents extends VoidKeys<TEvents> = VoidKeys<TEvents>, ArgEvents extends Exclude<keyof TEvents, ArgLessEvents> = Exclude<keyof TEvents, ArgLessEvents>, ArgLessEmits extends VoidKeys<TEmits> = VoidKeys<TEmits>, ArgEmits extends Exclude<keyof TEmits, ArgLessEmits> = Exclude<keyof TEmits, ArgLessEmits>> {
+	private listeners;
+	emit<T extends ArgLessEmits>(eventName: T): void;
+	emit<T extends ArgEmits>(eventName: T, args: TEmits[T]): void;
+	/**
+	 * Remove an event listener from `eventName`
+	 */
+	off<T extends ArgLessEvents>(eventName: T, fn: () => EventListenerReturnType): void;
+	off<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => EventListenerReturnType): void;
+	/**
+	 * Add an event listener to `eventName`
+	 *
+	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
+	 * This is useful when one listener may want everone to have reacted to an event before calling something.
+	 */
+	on<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
+	on<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
+	/**
+	 * Add an event listener to `eventName` that will be called once only
+	 *
+	 * Event listeners may optionally return a "defer function" that will be called once all other listeners have been called.
+	 * This is useful when one listener may want everone to have reacted to an event before calling something.
+	 */
+	once<T extends ArgLessEvents>(eventName: T, fn: () => void): void;
+	once<T extends ArgEvents>(eventName: T, fn: (args: TEvents[T]) => void): void;
+	/**
+	 * Reset the event emitter
+	 */
+	reset(): void;
+	private add;
+}
+declare const LogLevels: readonly [
+	"off",
+	"error",
+	"warn",
+	"info",
+	"debug",
+	"trace"
+];
+type LogLevel = (typeof LogLevels)[number];
+declare const LogLevel: {
+	ERROR: "error";
+	WARN: "warn";
+	INFO: "info";
+	DEBUG: "debug";
+	TRACE: "trace";
+	OFF: "off";
+};
+interface Metadata {
+	/**
+	 * The raw string content as it was ingested (if using JSON, it needs to be parsed on your end)
+	 */
+	content: string;
+	/**
+	 * Timestamp in ms
+	 */
+	timestamp: number;
+}
+interface ReconnectState {
+	/**
+	 * The number or retry attempts so far.
+	 * This gets reset on every successful connect, so it will start from zero every
+	 * time the client instance gets disconnected and will increment until the
+	 * client instance makes a connection attempt is successful.
+	 */
+	reconnectRetries: number;
+}
+interface Size {
+	/** */
+	width: number;
+	/** */
+	height: number;
+}
+interface VideoConstraint {
+	/** */
+	width: number;
+	/** */
+	height: number;
+	/** */
+	bitRate: number;
+	/** */
+	codec?: VideoCodec;
+	/** */
+	codecString?: string;
+}
+interface AdvancedOptions {
+	/**
+	 * Constrains wasm decoding to this resolution.
+	 * By default it is set to 1280 in width and height.
+	 * This guarantees better performance on older devices and reduces battery drain in general.
+	 */
+	wasmDecodingConstraint: Partial<VideoConstraint>;
+}
+interface DrmOptions {
+	/**
+	 * Headers to be added to requests to license servers
+	 */
+	headers?: Record<string, string>;
+	/**
+	 * Query parameters to be added to requests to license servers
+	 */
+	queryParams?: Record<string, string>;
+}
+type Media = "audio" | "video" | "audio+video";
+interface Options {
+	/**
+	 * URL to use when connecting to the stream
+	 */
+	url: string;
+	/**
+	 * Channel ID to connect to initially - can be changed later mid-stream when connected to a channel group.
+	 */
+	channelId: string;
+	/**
+	 * Channel group to connect to
+	 * Note: Only needed for fast channel switching
+	 */
+	channelGroupId?: string;
+	/**
+	 * A container to attach the video view in - can be provided later with .attach() on the vindral core instance
+	 */
+	container?: HTMLElement;
+	/**
+	 * An authentication token to provide to the server when connecting - only needed for channels with authentication enabled
+	 * Note: If not supplied when needed, an "Authentication Failed" error will be raised.
+	 */
+	authenticationToken?: string;
+	/**
+	 * Language to use initially - can be changed during during runtime on the vindral instance
+	 * Note: Only needed when multiple languages are provided - if no language is specified, one will be automatically selected.
+	 */
+	language?: string;
+	/**
+	 * TextTrack to use initially - can be changed during during runtime on the vindral instance
+	 */
+	textTrack?: string;
+	/**
+	 * Sets the log level - defaults to info
+	 */
+	logLevel?: LogLevel;
+	/**
+	 * Sets the minimum and initial buffer time
+	 */
+	minBufferTime?: number;
+	/**
+	 * Sets the maximum buffer time allowed. The vindral instance will automatically slowly increase
+	 * the buffer time if the use experiences to much buffering with the initial buffer time.
+	 */
+	maxBufferTime?: number;
+	/**
+	 * Enables or disables user bandwidth savings by capping the video resolution to the size of the video element.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note: This is automatically set to false when abrEnabled is set to false.
+	 */
+	sizeBasedResolutionCapEnabled?: boolean;
+	/**
+	 * Enables or disables picture in picture support.
+	 */
+	pictureInPictureEnabled?: boolean;
+	/**
+	 * Enable bursting for initial connection and channel switches. This makes time to first frame faster at the
+	 * cost of stability (more demanding due to the sudden burst of live content)
+	 *
+	 * Is disabled by default.
+	 *
+	 */
+	burstEnabled?: boolean;
+	/**
+	 * Enable usage of the MediaSource API on supported browsers.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note: We recommend to keep this at the default value unless you have very specific needs.
+	 */
+	mseEnabled?: boolean;
+	/**
+	 * Enable Opus with the MediaSource API on supported browsers.
+	 *
+	 * Is enabled by default.
+	 *
+	 */
+	mseOpusEnabled?: boolean;
+	/**
+	 * Enable or disable support for playing audio in the background for iOS devices.
+	 *
+	 * Is false (disabled) by default.
+	 *
+	 * Note:  This may be enabled by default in a future (major) release
+	 */
+	iosBackgroundPlayEnabled?: boolean;
+	/**
+	 * Enable or disable Adaptive Bit Rate. This allows for automatically adapting the incoming bit rate based on
+	 * the viewers bandwidth and thus avoiding buffering events. This also disables the
+	 * sizeBasedResolutionCapEnabled option.
+	 *
+	 * Is enabled by default.
+	 *
+	 * Note:  It is strongly recommended to keep this enabled as user experience can greatly suffer without ABR.
+	 */
+	abrEnabled?: boolean;
+	/**
+	 * Enable or disable telemetry. This allows for telemetry and errors being collected.
+	 *
+	 * Is enabled by default.
+	 *
+	 * We appreciate you turning it off during development/staging to not bloat real telemetry data.
+	 *
+	 * Note: It is strongly recommended to keep this enabled in production as it is required for insights and KPIs.
+	 */
+	telemetryEnabled?: boolean;
+	/**
+	 * Set a cap on the maximum video size.
+	 * This can be used to provide user options to limit the video bandwidth usage.
+	 *
+	 * Note: This takes presedence over any size based resolution caps.
+	 */
+	maxSize?: Size;
+	/**
+	 * Maximum audio bit rate allowed.
+	 * This can be used to provide user options to limit the audio bandwidth usage.
+	 */
+	maxAudioBitRate?: number;
+	/**
+	 * Maximum video bit rate allowed.
+	 * This can be used to provide user options to limit the video bandwidth usage.
+	 */
+	maxVideoBitRate?: number;
+	/**
+	 * Controls video element background behaviour while loading.
+	 * - If `false`, a black background will be shown.
+	 * - If undefined or `true`, a live thumbnail will be shown.
+	 * - If set to a string containing a URL (https://urltoimage), use that.
+	 * Default `true` - meaning a live thumbnail is shown
+	 */
+	poster?: boolean | string;
+	/**
+	 * Whether to start the player muted or to try to start playing audio automatically.
+	 */
+	muted?: boolean;
+	/**
+	 * Provide a custom reconnect handler to control when the instance should stop trying to
+	 * reconnect. The reconnect handler should either return true to allow the reconnect or
+	 * false to stop reconnecting. It can also return a promise with true or false if it needs
+	 * to make any async calls before determining wether to reconnect.
+	 *
+	 * The default reconnect handler allows 30 reconnects before stopping.
+	 *
+	 * Note: the ReconnectState gets reset every time the client instance makes a successful connection.
+	 * This means the default reconnect handler will only stop reconnecting after 30 _consecutive_ failed connections.
+	 *
+	 * ```typescript
+	 * // An example reconnect handler that will reconnect forever
+	 * const reconnectHandler = (state: ReconnectState) => true
+	 *
+	 * // An example reconnect handler that will fetch an url and determine whether to reconnect
+	 * const reconnectHandler = async (state: ReconnectState) => {
+	 *   const result = await fetch("https://should-i-reconnect-now.com")
+	 *   return result.ok
+	 * },
+	 * ```
+	 */
+	reconnectHandler?: (state: ReconnectState) => Promise<boolean> | boolean;
+	tags?: string[];
+	ownerSessionId?: string;
+	edgeUrl?: string;
+	logShippingEnabled?: boolean;
+	statsShippingEnabled?: boolean;
+	webtransportEnabled?: boolean;
+	/**
+	 * Enable wake lock for iOS devices.
+	 * The wake lock requires that the audio has been activated at least once for the instance, othwerwise it will not work.
+	 * Other devices already provide wake lock by default.
+	 *
+	 * This option is redundant and has no effect if iosMediaElementEnabled is enabled since that automatically enables wake lock.
+	 *
+	 * Disabled by default.
+	 */
+	iosWakeLockEnabled?: boolean;
+	/**
+	 * Disabling this will revert to legacy behaviour where Vindral will try to always keep the video element playing.
+	 */
+	pauseSupportEnabled?: boolean;
+	/**
+	 * Enables iOS devices to use a media element for playback. This enables fullscreen and picture in picture support on iOS.
+	 */
+	iosMediaElementEnabled?: boolean;
+	/**
+	 * Advanced options to override default behaviour.
+	 */
+	advanced?: AdvancedOptions;
+	media?: Media;
+	videoCodecs?: VideoCodec[];
+	/**
+	 * DRM options to provide to the Vindral instance
+	 */
+	drm?: DrmOptions;
+}
+/**
+ * Available events to listen to
+ */
+export interface CastSenderEvents {
+	/**
+	 * When a connection has been established with a CastReceiver
+	 */
+	["connected"]: void;
+	/**
+	 * When a previous session has been resumed
+	 */
+	["resumed"]: void;
+	/**
+	 * When a CastReceiver has lost or stopped a connection
+	 */
+	["disconnected"]: void;
+	/**
+	 * When a connection attempt was initiated unsuccessfully
+	 */
+	["failed"]: void;
+	/**
+	 * When the remote connection emits a metadata event
+	 */
+	["metadata"]: Metadata;
+	/**
+	 * When the remote connection receives a server wallclock time event
+	 */
+	["server wallclock time"]: number;
+}
+/**
+ * Used for initializing the CastSender
+ */
+export interface CastConfig {
+	/**
+	 * The Vindral Options to use for the Cast Receiver
+	 */
+	options: Options;
+	/**
+	 * URL to a background image.
+	 * Example: "https://via.placeholder.com/256x144"
+	 */
+	background?: string;
+	/**
+	 * Override this if you have your own custom receiver
+	 */
+	receiverApplicationId?: string;
+}
+/**
+ * CastSender handles initiation of and communication with the Google Cast Receiver
+ */
+export declare class CastSender extends Emitter<CastSenderEvents> {
+	private state;
+	private config;
+	private unloaded;
+	constructor(config: CastConfig);
+	/**
+	 * True if the instance is casting right now
+	 */
+	get casting(): boolean;
+	/**
+	 * The current volume
+	 */
+	get volume(): number;
+	/**
+	 * Set the current volume. Setting this to zero is equivalent to muting the video
+	 */
+	set volume(volume: number);
+	/**
+	 * The current language
+	 */
+	get language(): string | undefined;
+	/**
+	 * Set the current language
+	 */
+	set language(language: string | undefined);
+	/**
+	 * The current channelId
+	 */
+	get channelId(): string;
+	/**
+	 * Set the current channelId
+	 */
+	set channelId(channelId: string);
+	/**
+	 * Update authentication token on an already established and authenticated connection
+	 */
+	updateAuthenticationToken: (token: string) => void;
+	/**
+	 * Fully unloads the instance. This disconnects the current listener but lets the
+	 * cast session continue on the receiving device
+	 */
+	unload: () => void;
+	/**
+	 * Initiates the CastSender.
+	 * Will reject if Cast is not available on the device or the network.
+	 */
+	init: () => Promise<void>;
+	/**
+	 * Requests a session. It will open the native cast receiver chooser dialog
+	 */
+	start: () => Promise<void>;
+	/**
+	 * Stops a session. It will stop playback on device as well.
+	 */
+	stop: () => void;
+	/**
+	 * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
+	 */
+	getReceiverName: () => string | undefined;
+	private onGCastApiAvailable;
+	private send;
+	private onMessage;
+	private onSessionStarted;
+	private onSessionStateChanged;
+	private getInstance;
+	private getSession;
+	private castLibrariesAdded;
+	private verifyCastLibraries;
+}
+
+export {};

package/cast-sender.js

@@ -0,0 +1,230 @@
+var u = Object.defineProperty;
+var l = (n, i, e) => i in n ? u(n, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[i] = e;
+var s = (n, i, e) => l(n, typeof i != "symbol" ? i + "" : i, e);
+var h = (n, i, e) => new Promise((t, a) => {
+  var o = (r) => {
+    try {
+      c(e.next(r));
+    } catch (S) {
+      a(S);
+    }
+  }, d = (r) => {
+    try {
+      c(e.throw(r));
+    } catch (S) {
+      a(S);
+    }
+  }, c = (r) => r.done ? t(r.value) : Promise.resolve(r.value).then(o, d);
+  c((e = e.apply(n, i)).next());
+});
+import { E as g } from "./Bx7s5QdT.js";
+class p extends g {
+  constructor(e) {
+    super();
+    s(this, "state", "not casting");
+    s(this, "config");
+    s(this, "unloaded", !1);
+    /**
+     * Update authentication token on an already established and authenticated connection
+     */
+    s(this, "updateAuthenticationToken", (e) => {
+      this.config && (this.config.options.authenticationToken = e, this.send({
+        type: "updateAuthToken",
+        token: e
+      }));
+    });
+    /**
+     * Fully unloads the instance. This disconnects the current listener but lets the
+     * cast session continue on the receiving device
+     */
+    s(this, "unload", () => {
+      var e;
+      this.unloaded = !0, (e = this.getSession()) == null || e.removeMessageListener("urn:x-cast:com.vindral.castdata", this.onMessage);
+    });
+    /**
+     * Initiates the CastSender.
+     * Will reject if Cast is not available on the device or the network.
+     */
+    s(this, "init", () => h(this, null, function* () {
+      return new Promise((e, t) => {
+        let a = !1;
+        const o = setTimeout(() => {
+          a = !0, t();
+        }, 1e4);
+        window.__onGCastApiAvailable = (d) => {
+          if (a) {
+            a = !1;
+            return;
+          }
+          if (clearTimeout(o), !d)
+            return t();
+          setTimeout(() => {
+            try {
+              this.onGCastApiAvailable(), e();
+            } catch (c) {
+              t();
+            }
+          }, 1e3);
+        }, this.castLibrariesAdded() && window.cast ? window.__onGCastApiAvailable(!0) : this.verifyCastLibraries();
+      });
+    }));
+    /**
+     * Requests a session. It will open the native cast receiver chooser dialog
+     */
+    s(this, "start", () => h(this, null, function* () {
+      var e;
+      yield (e = this.getInstance()) == null ? void 0 : e.requestSession();
+    }));
+    /**
+     * Stops a session. It will stop playback on device as well.
+     */
+    s(this, "stop", () => {
+      var e;
+      (e = this.getSession()) == null || e.endSession(!0);
+    });
+    /**
+     * Returns a string representing the name of the Cast receiver device or undefined if no receiver exists
+     */
+    s(this, "getReceiverName", () => {
+      var e, t;
+      return ((t = (e = this.getSession()) == null ? void 0 : e.getCastDevice()) == null ? void 0 : t.friendlyName) || void 0;
+    });
+    s(this, "onGCastApiAvailable", () => {
+      var o;
+      const e = this.getInstance();
+      if (!e)
+        throw "cast context should exist";
+      const t = e.getSessionState(), a = ((o = this.config) == null ? void 0 : o.receiverApplicationId) || "A5452297";
+      e.setOptions({
+        receiverApplicationId: a,
+        autoJoinPolicy: chrome.cast.AutoJoinPolicy.TAB_AND_ORIGIN_SCOPED,
+        resumeSavedSession: !0
+      }), e.addEventListener(cast.framework.CastContextEventType.SESSION_STATE_CHANGED, this.onSessionStateChanged), t === cast.framework.SessionState.SESSION_STARTED && setTimeout(() => {
+        this.state = "casting", this.emit("resumed");
+      });
+    });
+    s(this, "send", (e) => {
+      var t;
+      (t = this.getSession()) == null || t.sendMessage("urn:x-cast:com.vindral.castdata", e);
+    });
+    s(this, "onMessage", (e, t) => {
+      if (e === "urn:x-cast:com.vindral.castdata")
+        try {
+          const a = JSON.parse(t);
+          switch (a.type) {
+            case "metadata":
+              this.emit("metadata", a.metadata);
+              break;
+            case "serverWallclockTime":
+              this.emit("server wallclock time", a.serverWallclockTime);
+              break;
+            default:
+              break;
+          }
+        } catch (a) {
+        }
+    });
+    s(this, "onSessionStarted", () => {
+      var e;
+      (e = this.getSession()) == null || e.addMessageListener("urn:x-cast:com.vindral.castdata", this.onMessage), this.send({
+        type: "start",
+        config: this.config
+      });
+    });
+    s(this, "onSessionStateChanged", (e) => {
+      if (!this.unloaded)
+        switch (e.sessionState) {
+          case cast.framework.SessionState.SESSION_START_FAILED:
+            this.state = "not casting", this.emit("failed");
+            break;
+          case cast.framework.SessionState.SESSION_ENDED:
+            this.state = "not casting", this.emit("disconnected");
+            break;
+          case cast.framework.SessionState.SESSION_ENDING:
+            break;
+          case cast.framework.SessionState.SESSION_RESUMED:
+            this.onSessionStarted(), this.state = "casting", this.emit("resumed");
+            break;
+          case cast.framework.SessionState.SESSION_STARTED:
+            this.onSessionStarted(), this.state = "casting", this.emit("connected");
+            break;
+          case cast.framework.SessionState.SESSION_STARTING:
+            break;
+        }
+    });
+    s(this, "getInstance", () => {
+      var e;
+      return (e = window.cast) == null ? void 0 : e.framework.CastContext.getInstance();
+    });
+    s(this, "getSession", () => {
+      var e;
+      return (e = this.getInstance()) == null ? void 0 : e.getCurrentSession();
+    });
+    // check if cast libraries are already added
+    s(this, "castLibrariesAdded", () => !!(document.querySelector("#vindralCastFrameworkLib") && document.querySelector("#vindralCastSenderLib")));
+    s(this, "verifyCastLibraries", () => {
+      if (this.castLibrariesAdded())
+        return;
+      const e = document.createElement("script");
+      e.type = "text/javascript", e.id = "vindralCastFrameworkLib", e.src = "//www.gstatic.com/cast/sdk/libs/sender/1.0/cast_framework.js", document.head.appendChild(e);
+      const t = document.createElement("script");
+      t.type = "text/javascript", t.id = "vindralCastSenderLib", t.src = "//www.gstatic.com/cv/js/sender/v1/cast_sender.js", document.head.appendChild(t);
+    });
+    this.config = e;
+  }
+  /**
+   * True if the instance is casting right now
+   */
+  get casting() {
+    return this.state === "casting";
+  }
+  /**
+   * The current volume
+   */
+  get volume() {
+    var e, t;
+    return (t = (e = this.getSession()) == null ? void 0 : e.getVolume()) != null ? t : 0;
+  }
+  /**
+   * Set the current volume. Setting this to zero is equivalent to muting the video
+   */
+  set volume(e) {
+    var t;
+    (t = this.getSession()) == null || t.setVolume(e);
+  }
+  /**
+   * The current language
+   */
+  get language() {
+    var e, t;
+    return (t = (e = this.config) == null ? void 0 : e.options) == null ? void 0 : t.language;
+  }
+  /**
+   * Set the current language
+   */
+  set language(e) {
+    this.config && (this.config.options.language = e, this.send({
+      type: "setLanguage",
+      language: e
+    }));
+  }
+  /**
+   * The current channelId
+   */
+  get channelId() {
+    var e;
+    return ((e = this.config) == null ? void 0 : e.options.channelId) || "";
+  }
+  /**
+   * Set the current channelId
+   */
+  set channelId(e) {
+    this.config && (this.config.options.channelId = e, this.send({
+      type: "setChannelId",
+      channelId: e
+    }));
+  }
+}
+export {
+  p as CastSender
+};