@videojs/soundcloud-audio 0.0.0-stage → 10.3.0

package/dist/default/index.js

@@ -0,0 +1,3 @@
+import { buildSoundCloudIframeSrc, buildSoundCloudWidgetUrl, parseSoundCloudSource, wantsSoundCloudAutoplay } from "./source.js";
+import { SoundCloudAdapter } from "./adapter.js";
+export { SoundCloudAdapter, buildSoundCloudIframeSrc, buildSoundCloudWidgetUrl, parseSoundCloudSource, wantsSoundCloudAutoplay };

package/dist/default/source.js

@@ -0,0 +1,53 @@
+import { WIDGET_ORIGIN } from "./widget-api.js";
+import { parseSoundCloudSource, parseSoundCloudSource as parseSoundCloudSource$1 } from "@videojs/media";
+//#region src/source.ts
+/**
+* Build the widget iframe URL for a source. Empty when `src` is not a SoundCloud URL.
+*
+* @internal
+*/
+function buildSoundCloudIframeSrc(src, props = {}) {
+	const parsed = parseSoundCloudSource(src);
+	if (!parsed) return "";
+	return buildSoundCloudWidgetUrl(parsed.url, parsed, props);
+}
+/**
+* Build the widget iframe URL for a resource URL the widget plays, carrying the parameters of the source it came from.
+*
+* @internal
+*/
+function buildSoundCloudWidgetUrl(resourceUrl, parsed, props = {}) {
+	const { referrerPolicy: _referrerPolicy, ...engine } = props.source?.engine?.soundcloud ?? {};
+	const params = {
+		...DEFAULT_PARAMS,
+		...parsed.params,
+		...engine
+	};
+	const query = new URLSearchParams({ url: resourceUrl });
+	for (const [key, value] of Object.entries(params)) {
+		if (key === "url" || key === "auto_play" || value === null || value === void 0) continue;
+		query.set(key, String(value));
+	}
+	return `${WIDGET_ORIGIN}/player/?${query}`;
+}
+/**
+* Whether the source asks to autoplay through the widget's own `auto_play` parameter.
+*
+* @internal
+*/
+function wantsSoundCloudAutoplay(parsed, source) {
+	const value = source?.engine?.soundcloud?.auto_play ?? parsed?.params.auto_play;
+	return value === true || value === "true";
+}
+const DEFAULT_PARAMS = {
+	visual: false,
+	hide_related: true,
+	show_comments: false,
+	show_reposts: false,
+	show_teaser: false,
+	buying: false,
+	sharing: false,
+	download: false
+};
+//#endregion
+export { buildSoundCloudIframeSrc, buildSoundCloudWidgetUrl, parseSoundCloudSource$1 as parseSoundCloudSource, wantsSoundCloudAutoplay };

package/dist/default/widget-api.js

@@ -0,0 +1,33 @@
+import { isNumber, isObject, isString } from "@videojs/utils/predicate";
+//#region src/widget-api.ts
+/** Where the widget is served from: commands are posted to it, and only its messages are read. */
+const WIDGET_ORIGIN = "https://w.soundcloud.com";
+/** Read a `message` event's data as a widget message; anything else another frame posts comes back null. */
+function parseSoundCloudMessage(data) {
+	if (!isString(data) || !data.includes("\"method\"")) return null;
+	let message;
+	try {
+		message = JSON.parse(data);
+	} catch {
+		return null;
+	}
+	return isObject(message) && isString(message.method) ? message : null;
+}
+function createSoundCloudCommand(method, value) {
+	return JSON.stringify(value === void 0 ? { method } : {
+		method,
+		value
+	});
+}
+function isSoundCloudProgress(value) {
+	if (!isObject(value)) return false;
+	const { currentPosition } = value;
+	return isNumber(currentPosition);
+}
+/** The share of the sound the widget has loaded, under either spelling. */
+function loadedShareOf(progress) {
+	const share = progress.loadedProgress ?? progress.loadProgress;
+	return isNumber(share) ? share : void 0;
+}
+//#endregion
+export { WIDGET_ORIGIN, createSoundCloudCommand, isSoundCloudProgress, loadedShareOf, parseSoundCloudMessage };

package/dist/dev/adapter.d.ts

@@ -0,0 +1,82 @@
+import { SoundCloudSource } from "./source.js";
+import { SoundCloudAdapterProps } from "./props.js";
+import { MediaContentData, MediaError, Video } from "@videojs/media";
+//#region src/adapter.d.ts
+declare const SoundCloudAdapter_base: import("@videojs/utils/types").MixinReturn<{
+  new (): EventTarget;
+  prototype: EventTarget;
+}, import("@videojs/media/dom").MediaPlayedRangesAPI>;
+/**
+ * Plays SoundCloud tracks and sets through the SoundCloud Widget. A set plays as one source: moving to another track
+ * reports a new `duration` and restarts `currentTime`, and `ended` fires once the last track ends. The widget stays
+ * visible and takes input, since it is what credits the uploader and SoundCloud; what it does is reported like anything
+ * the host asked for.
+ *
+ * @fires sourcechange - Fired when `source` changes, either directly or by resolving a new `src`. Read `source` for the
+ *   new value.
+ * @fires contentdatachange - Fired when the widget reports the title and artwork of a track, and when they are cleared.
+ *   Read `contentData` for them.
+ */
+export declare class SoundCloudAdapter extends SoundCloudAdapter_base implements Partial<Video> {
+  #private;
+  static readonly defaultProps: SoundCloudAdapterProps;
+  static PLAYER_SOFTWARE_NAME: string;
+  /** The widget's window, which commands are posted to. Null until rendered. */
+  get engine(): Window | null;
+  get target(): HTMLIFrameElement | null;
+  /** Bind the iframe hosting the widget. The widget follows once a `src` resolves, which may be after attach. */
+  attach(target: HTMLIFrameElement | null): void;
+  detach(): void;
+  destroy(): void;
+  get src(): string;
+  /** SoundCloud URL. Setting it re-derives `source`, carrying its engine options over. */
+  set src(value: string);
+  get currentSrc(): string;
+  get readyState(): number;
+  /** Point the widget at the current source; rewriting the iframe URL is the only load the widget takes parameters on. */
+  load(): Promise<void>;
+  get paused(): boolean;
+  get ended(): boolean;
+  get seeking(): boolean;
+  play(): Promise<void>;
+  pause(): void;
+  get currentTime(): number;
+  set currentTime(value: number);
+  get duration(): number;
+  get volume(): number;
+  set volume(value: number);
+  get muted(): boolean;
+  set muted(value: boolean);
+  /** Starts playback once the widget is ready, after the volume and start position apply. Browsers may refuse it. */
+  get autoplay(): boolean;
+  set autoplay(value: boolean);
+  get defaultMuted(): boolean;
+  set defaultMuted(value: boolean);
+  /** Replays the track, or a set from its first track, when the last one ends. */
+  get loop(): boolean;
+  set loop(value: boolean);
+  get controls(): boolean;
+  set controls(value: boolean);
+  get playsInline(): boolean;
+  set playsInline(value: boolean);
+  get preload(): import("@videojs/media").MediaPreloadType;
+  set preload(value: import("@videojs/media").MediaPreloadType);
+  get poster(): string;
+  set poster(value: string);
+  /** SoundCloud URL in `src`, widget parameters under `engine.soundcloud`. Replacing it re-derives `src`. */
+  get source(): SoundCloudSource | null;
+  set source(value: SoundCloudSource | null);
+  /** The stretch the widget reports loaded, from where playback last started or landed. */
+  get buffered(): import("@videojs/media").TimeRangeLike;
+  get seekable(): import("@videojs/media").TimeRangeLike;
+  get error(): MediaError | null;
+  /**
+   * The `title` and `poster` of the track playing, which change with each track of a set. Empty until the widget
+   * reports them, and again across a source change. `contentdatachange` announces both.
+   */
+  get contentData(): MediaContentData;
+  /** Always empty: SoundCloud has no captions or other text tracks. */
+  get textTracks(): import("@videojs/media").TextTrackListLike;
+}
+//#endregion
+//# sourceMappingURL=adapter.d.ts.map