cloudinary-video-player/lib/index.js

Cloudinary Video Player

import { s as setupCloudinaryGlobal, b as createAsyncPlayer, a as createMultiplePlayers, c as createMultipleSync } from './player-api.js';

/**
 * Deferred Player Proxy
 *
 * Returns a synchronous object from videoPlayer() that buffers all method calls
 * while the real VideoPlayer loads asynchronously, then replays them in order.
 *
 * This allows the default entry point to be lightweight (lazy) while preserving
 * the synchronous API contract:
 *
 *   const player = cloudinary.videoPlayer('el', { ... });
 *   player.source('elephants');       // buffered, replayed after load
 *   player.on('error', handler);      // buffered, replayed after load
 */

/**
 * Creates a deferred player proxy that buffers calls until the real player loads.
 *
 * @param {Promise<Object>} playerPromise - Promise that resolves to a VideoPlayer instance.
 * @returns {Object} A proxy that looks like a VideoPlayer synchronously.
 */
const createDeferredPlayer = playerPromise => {
  let realPlayer = null;
  let failed = false;
  const queue = [];
  const resolvedPromise = playerPromise.then(p => {
    realPlayer = p;
    queue.forEach(_ref => {
      let {
        method,
        args,
        resolve,
        reject
      } = _ref;
      try {
        resolve(realPlayer[method](...args));
      } catch (e) {
        reject(e);
      }
    });
    queue.length = 0;
    return p;
  }).catch(err => {
    failed = true;
    queue.forEach(_ref2 => {
      let {
        reject
      } = _ref2;
      return reject(err);
    });
    queue.length = 0;
    throw err;
  });
  const proxy = new Proxy({}, {
    get(_target, prop) {
      if (prop === 'then' || prop === 'catch' || prop === 'finally') {
        return resolvedPromise[prop].bind(resolvedPromise);
      }
      if (prop === Symbol.toPrimitive || prop === Symbol.toStringTag) {
        return undefined;
      }
      if (realPlayer) {
        const val = realPlayer[prop];
        return typeof val === 'function' ? val.bind(realPlayer) : val;
      }
      if (failed) {
        return undefined;
      }
      return function () {
        const deferred = {};
        const promise = new Promise((resolve, reject) => {
          deferred.resolve = resolve;
          deferred.reject = reject;
        });
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }
        queue.push({
          method: prop,
          args,
          ...deferred
        });
        promise.catch(e => console.error('[Cloudinary] Deferred player call failed:', e));
        return proxy;
      };
    },
    has(_target, prop) {
      if (realPlayer) {
        return prop in realPlayer;
      }
      return true;
    }
  });
  return proxy;
};

const importCore = () => import(/* webpackChunkName: "cld-player-core" */'./video-player.js').then(function (n) { return n.v; });
const mergeOpts = function () {
  for (var _len = arguments.length, opts = new Array(_len), _key = 0; _key < _len; _key++) {
    opts[_key] = arguments[_key];
  }
  return Object.assign({}, ...opts, {
    _internalAnalyticsMetadata: Object.assign({}, ...opts.map(opt => opt?._internalAnalyticsMetadata || {}), {
      playerBundle: 'lazy'
    })
  });
};
const videoPlayer = function (id) {
  let playerOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  let ready = arguments.length > 2 ? arguments[2] : undefined;
  return createDeferredPlayer(importCore().then(m => m.createVideoPlayer(id, mergeOpts(playerOptions), ready)));
};
const videoPlayers = (selector, playerOptions, ready) => createMultipleSync(selector, playerOptions, ready, videoPlayer);
const player = function (id) {
  let playerOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  let ready = arguments.length > 2 ? arguments[2] : undefined;
  return createAsyncPlayer(id, playerOptions, ready, async (videoElement, opts, r) => {
    const {
      createPlayerWithConfig
    } = await importCore();
    return createPlayerWithConfig(videoElement, mergeOpts(opts), r);
  });
};
const players = (selector, playerOptions, ready) => createMultiplePlayers(selector, playerOptions, ready, player);
const cloudinaryVideoPlayerLegacyConfig = function () {
  let instanceConfig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
  console.warn('Cloudinary.new() is deprecated and will be removed. Please use cloudinary.videoPlayer() instead.');
  return {
    videoPlayer: function (id) {
      let playerOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      let ready = arguments.length > 2 ? arguments[2] : undefined;
      return createDeferredPlayer(importCore().then(m => m.createVideoPlayer(id, mergeOpts(instanceConfig, playerOptions), ready)));
    },
    videoPlayers: function (selector) {
      let playerOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      let ready = arguments.length > 2 ? arguments[2] : undefined;
      return createMultipleSync(selector, mergeOpts(instanceConfig, playerOptions), ready, videoPlayer);
    }
  };
};
var cloudinary = setupCloudinaryGlobal({
  videoPlayer,
  videoPlayers,
  player,
  players,
  Cloudinary: {
    new: cloudinaryVideoPlayerLegacyConfig
  }
});

export { cloudinary as default, player, players, videoPlayer, videoPlayers };