@gcorevideo/player 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,467 +1,4 @@
-import { $, Log, Loader, Player as Player$1, Browser } from '@clappr/core';
-import assert from 'assert';
-import HLSJS from 'hls.js';
-import EventLite from 'event-lite';
-
-const tracer = {
-    trace: () => { },
-    reportError: () => { },
-};
-/**
- * @public
- * Sets a tracer implementation, e.g., LogTracer or SentryTracer
- */
-function setTracer(t) {
-    tracer.trace = t.trace.bind(t);
-    tracer.reportError = t.reportError.bind(t);
-}
-/**
- * @public
- * @param e
- */
-function reportError(e) {
-    tracer.reportError(e);
-}
-/**
- * @public
- * @param msg
- * @param data
- */
-function trace(msg, data = {}) {
-    tracer.trace(msg, data);
-}
-
-var PlayerEvent;
-(function (PlayerEvent) {
-    PlayerEvent["Ready"] = "ready";
-    PlayerEvent["Play"] = "play";
-    PlayerEvent["Pause"] = "pause";
-    PlayerEvent["Stop"] = "stop";
-    PlayerEvent["Ended"] = "ended";
-})(PlayerEvent || (PlayerEvent = {}));
-const T = "Player";
-const DEFAULT_OPTIONS = {
-    autoPlay: false,
-    mute: false,
-    loop: false,
-};
-/**
- * @beta
- */
-class Player {
-    emitter = new EventLite();
-    player = null;
-    pluginLoaders = [];
-    clapprReady = false;
-    timer = null;
-    tuneInEntered = false;
-    supportedMediaTransports = [];
-    config;
-    get playing() {
-        return this.player ? this.player.isPlaying() : false;
-    }
-    get ready() {
-        return this.clapprReady;
-    }
-    constructor(config) {
-        this.config = $.extend(true, {}, DEFAULT_OPTIONS, config);
-    }
-    on(event, handler) {
-        this.emitter.on(event, handler);
-    }
-    off(event, handler) {
-        this.emitter.off(event, handler);
-    }
-    async init(playerElement) {
-        assert.ok(!this.player, 'Player already initialized');
-        assert.ok(playerElement, 'Player element is required');
-        if (this.config.debug === 'all' ||
-            this.config.debug === 'clappr') {
-            Log.setLevel(0);
-        }
-        Log.debug('Config', this.config);
-        this.configurePlugins();
-        return this.loadPlugins().then(async () => {
-            const coreOpts = this.buildCoreOptions(playerElement);
-            const { core, container, } = Loader.registeredPlugins;
-            coreOpts.plugins = {
-                core: Object.values(core),
-                container: Object.values(container),
-                playback: Loader.registeredPlaybacks,
-            };
-            console.log('plugins', coreOpts.plugins);
-            return this.initPlayer(coreOpts);
-        });
-    }
-    destroy() {
-        trace(`${T} destroy`, { player: !!this.player });
-        if (this.player) {
-            this.player.destroy();
-            this.player = null;
-        }
-    }
-    pause() {
-        assert.ok(this.player, 'Player not initialized');
-        this.player.pause();
-    }
-    play() {
-        assert.ok(this.player, 'Player not initialized');
-        this.player.play();
-    }
-    seekTo(time) {
-        assert.ok(this.player, 'Player not initialized');
-        this.player.seek(time);
-    }
-    stop() {
-        assert.ok(this.player, 'Player not initialized');
-        this.player.stop();
-    }
-    static registerPlugin(plugin) {
-        Loader.registerPlugin(plugin);
-    }
-    loadPlugins() {
-        return Promise.all(this.pluginLoaders.map((loader) => loader())).then(() => { });
-    }
-    initPlayer(coreOptions) {
-        assert.ok(!this.player, 'Player already initialized');
-        const player = new Player$1(coreOptions);
-        this.player = player;
-        this.timer = globalThis.setTimeout(() => {
-            try {
-                if (!this.clapprReady &&
-                    player.core &&
-                    player.core
-                        .activePlayback) {
-                    this.tuneIn();
-                    // player.onReady = null; // TODO ?
-                }
-            }
-            catch (e) {
-                reportError(e);
-            }
-        }, 4000);
-    }
-    // TODO sort this out
-    async tuneIn() {
-        assert.ok(this.player);
-        trace(`${T} tuneIn enter`, {
-            ready: this.clapprReady,
-            tuneInEntered: this.tuneInEntered,
-        });
-        if (this.tuneInEntered) {
-            return;
-        }
-        this.tuneInEntered = true;
-        const player = this.player;
-        if (Browser.isiOS &&
-            player.core.activePlayback) {
-            player.core.activePlayback.$el.on('webkitendfullscreen', () => {
-                try {
-                    player.core.handleFullscreenChange();
-                }
-                catch (e) {
-                    reportError(e);
-                }
-            });
-        }
-    }
-    configurePlugins() {
-        if (!Browser.isiOS && this.config.multisources.some((el) => el.sourceDash)) {
-            this.scheduleLoad(async () => {
-                const module = await import('./DashPlayback-BeZz7mN9.js');
-                Loader.registerPlayback(module.default);
-            });
-        }
-        // TODO remove !isiOS?
-        // if (!Browser.isiOS && this.config.multisources.some((el) => el.hls_mpegts_url)) {
-        if (this.config.multisources.some((el) => el.hlsMpegtsUrl || el.hlsCmafUrl || el.source.endsWith('.m3u8'))) {
-            this.scheduleLoad(async () => {
-                const module = await import('./HlsPlayback-Avwy8-0O.js');
-                Loader.registerPlayback(module.default);
-            });
-        }
-    }
-    events = {
-        onReady: () => {
-            if (this.clapprReady) {
-                return;
-            }
-            this.clapprReady = true;
-            if (this.timer) {
-                clearTimeout(this.timer);
-                this.timer = null;
-            }
-            trace(`${T} onReady`);
-            setTimeout(() => this.tuneIn(), 0);
-            try {
-                this.emitter.emit(PlayerEvent.Ready);
-            }
-            catch (e) {
-                reportError(e);
-            }
-        },
-        onPlay: () => {
-            try {
-                this.emitter.emit(PlayerEvent.Play);
-            }
-            catch (e) {
-                reportError(e);
-            }
-        },
-        onPause: () => {
-            try {
-                this.emitter.emit(PlayerEvent.Pause);
-            }
-            catch (e) {
-                reportError(e);
-            }
-        },
-        onEnded: () => {
-            try {
-                this.emitter.emit(PlayerEvent.Ended);
-            }
-            catch (e) {
-                reportError(e);
-            }
-        },
-        onStop: () => {
-            try {
-                this.emitter.emit(PlayerEvent.Stop);
-            }
-            catch (e) {
-                reportError(e);
-            }
-        },
-    };
-    buildCoreOptions(playerElement) {
-        this.checkMediaTransportsSupport();
-        const multisources = this.processMultisources(this.config.priorityTransport);
-        const mediaSources = multisources.map(ms => ms.source);
-        const mainSource = this.findMainSource();
-        const mainSourceUrl = unwrapSource(mainSource ? this.selectMediaTransport(mainSource, this.config.priorityTransport) : undefined);
-        const poster = mainSource?.poster ?? this.config.poster;
-        const coreOptions = {
-            autoPlay: this.config.autoPlay,
-            debug: this.config.debug || 'none',
-            events: this.events,
-            multisources,
-            mute: this.config.mute,
-            ...this.config.pluginSettings,
-            playback: {
-                controls: false,
-                preload: Browser.isiOS ? 'metadata' : 'none',
-                playInline: true,
-                crossOrigin: 'anonymous', // TODO
-                hlsjsConfig: {
-                    debug: this.config.debug === 'all' || this.config.debug === 'hls',
-                },
-            },
-            parent: playerElement,
-            playbackType: this.config.playbackType,
-            poster,
-            width: playerElement.clientWidth,
-            height: playerElement.clientHeight,
-            loop: this.config.loop,
-            strings: this.config.strings,
-            source: mainSourceUrl,
-            sources: mediaSources,
-        };
-        trace(`${T} buildCoreOptions`, coreOptions);
-        return coreOptions;
-    }
-    findMainSource() {
-        return this.config.multisources.find(ms => ms.live !== false);
-    }
-    scheduleLoad(cb) {
-        this.pluginLoaders.push(cb);
-    }
-    selectMediaTransport(ms, priorityTransport = ms.priorityTransport) {
-        const cmafUrl = ms.hlsCmafUrl || ms.source; // source is default url for hls
-        const mpegtsUrl = ms.hlsMpegtsUrl; // no-low-latency HLS
-        const dashUrl = ms.sourceDash;
-        const masterSource = ms.source;
-        const mts = this.getAvailableTransportsPreference(priorityTransport);
-        for (const mt of mts) {
-            switch (mt) {
-                case 'dash':
-                    if (dashUrl) {
-                        return dashUrl;
-                    }
-                    break;
-                case 'hls':
-                    if (cmafUrl) {
-                        return cmafUrl;
-                    }
-                    break;
-                default:
-                    return mpegtsUrl || masterSource;
-            }
-        }
-        // no supported transport found
-        return '';
-    }
-    getAvailableTransportsPreference(priorityTransport) {
-        const mtp = [];
-        if (priorityTransport !== 'auto' && this.supportedMediaTransports.includes(priorityTransport)) {
-            mtp.push(priorityTransport);
-        }
-        for (const mt of this.supportedMediaTransports) {
-            if (mt !== priorityTransport) {
-                mtp.push(mt);
-            }
-        }
-        return mtp;
-    }
-    checkMediaTransportsSupport() {
-        const isDashSupported = typeof (globalThis.MediaSource || globalThis.WebKitMediaSource) === 'function';
-        if (isDashSupported) {
-            this.supportedMediaTransports.push('dash');
-        }
-        if (HLSJS.isSupported()) {
-            this.supportedMediaTransports.push('hls');
-        }
-        this.supportedMediaTransports.push('mpegts');
-    }
-    processMultisources(transport) {
-        return this.config.multisources.map((ms) => ({
-            ...ms,
-            source: this.selectMediaTransport(ms, transport),
-        })).filter((el) => !!el.source);
-    }
-}
-function unwrapSource(s) {
-    if (!s) {
-        return;
-    }
-    return typeof s === "string" ? s : s.source;
-}
-
-function fromStreamMediaSourceDto(s) {
-    return ({
-        ...s,
-        hlsCmafUrl: s.hls_cmaf_url,
-        hlsMpegtsUrl: s.hls_mpegts_url,
-        priorityTransport: s.priority_transport,
-        sourceDash: s.source_dash,
-        vtt: s.vtt,
-    });
-}
-
-const APP_NAME = "gplayer";
-class DebuggerWrapper {
-    writer;
-    namespace;
-    currentWriter;
-    constructor(writer, namespace, enabled = true) {
-        this.writer = writer;
-        this.namespace = namespace;
-        this.currentWriter = enabled ? writer : nullWriter;
-    }
-    enable() {
-        this.currentWriter = this.writer;
-    }
-    disable() {
-        this.currentWriter = nullWriter;
-    }
-    write = (m, ...args) => {
-        const tokens = args.map((_) => "%s");
-        if (typeof m === "string" || args.length > 0) {
-            tokens.unshift("%s");
-        }
-        this.currentWriter(`${this.namespace}: ${tokens.join(' ')}`, m, ...args.map(a => JSON.stringify(a)));
-    };
-}
-const currentPatterns = [];
-function parsePattern(pattern) {
-    if (pattern === "*") {
-        return /.?/;
-    }
-    return new RegExp("^" + pattern.replace(/\*/g, "[@\\w-]+"), "i");
-}
-function pass(namespace) {
-    return currentPatterns.some((p) => p.test(namespace));
-}
-function nullWriter() { }
-/**
- * Logging utility with [debug](https://www.npmjs.com/package/debug)-like API
- * @beta
- */
-class Logger {
-    info;
-    warn;
-    error;
-    debug;
-    static items = [];
-    constructor(namespace, appName = APP_NAME) {
-        const ns = namespace ? `:${namespace}` : "";
-        const info = new DebuggerWrapper(console.info.bind(console), `${appName}:INFO${ns}`, pass(namespace));
-        this.info = info.write;
-        const warn = new DebuggerWrapper(console.warn.bind(console), `${appName}:WARN${ns}`, pass(namespace));
-        this.warn = warn.write;
-        const error = new DebuggerWrapper(console.error.bind(console), `${appName}:ERROR${ns}`, pass(namespace));
-        this.error = error.write;
-        const debug = new DebuggerWrapper(console.debug.bind(console), `${appName}:DEBUG${ns}`, pass(namespace));
-        this.debug = debug.write;
-        Logger.items.push(warn);
-        Logger.items.push(info);
-        Logger.items.push(error);
-        Logger.items.push(debug);
-    }
-    /**
-     * @param patterns - comma-separated list of patterns, can contain '*' as a wildcard
-     */
-    static enable(patterns) {
-        currentPatterns.splice(0, currentPatterns.length, ...patterns.split(",").filter(Boolean).map(parsePattern));
-        Logger.toggleItems();
-    }
-    static disable() {
-        currentPatterns.splice(0, currentPatterns.length);
-    }
-    static toggleItems() {
-        for (const w of Logger.items) {
-            if (pass(w.namespace)) {
-                w.enable();
-            }
-            else {
-                w.disable();
-            }
-        }
-    }
-}
-
-/**
- * A tracer that logs to the console
- * @public
- */
-class LogTracer {
-    logger;
-    constructor(ns = "") {
-        this.logger = new Logger(ns);
-    }
-    reportError(e) {
-        this.logger.error(e);
-    }
-    trace(msg, data) {
-        this.logger.debug(msg, data);
-    }
-}
-
-/**
- * @beta
- */
-class SentryTracer {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    reportError(e) {
-        this.client.captureException(e);
-    }
-    trace(msg, data) {
-        this.client.captureMessage(msg, "info", {
-            data,
-        });
-    }
-}
-
-export { LogTracer, Logger, Player, PlayerEvent, SentryTracer, fromStreamMediaSourceDto, reportError, setTracer, trace };
+export { L as LogTracer, c as Logger, b as Player, P as PlayerEvent, S as SentryTracer, f as fromStreamMediaSourceDto, r as reportError, s as setTracer, t as trace } from './index-DTOY9tbl.js';
+import '@clappr/core';
+import 'hls.js';
+import 'event-lite';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gcorevideo/player",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Gcore JavaScript video player",
   "main": "dist/index.js",
   "type": "module",
@@ -37,6 +37,7 @@
     "@types/ua-parser-js": "^0.7.39",
     "assert": "^2.1.0",
     "rollup": "^4.27.4",
+    "rollup-plugin-polyfill-node": "^0.13.0",
     "rollup-plugin-sass": "^1.14.0",
     "rollup-plugin-scss": "^4.0.1",
     "rollup-plugin-string": "^3.0.0",

package/rollup.config.js

@@ -3,6 +3,7 @@ import resolve from '@rollup/plugin-node-resolve';
 import commonjs from '@rollup/plugin-commonjs';
 import sass from 'rollup-plugin-sass';
 import { string } from 'rollup-plugin-string';
+import polyfillNode from 'rollup-plugin-polyfill-node';
 
 export default [
   {
@@ -22,6 +23,7 @@ export default [
           '**/*.svg',
         ],
       }),
+      polyfillNode(),
     ],
     output: [
       {