cloudinary-video-player 3.12.1 → 3.12.2-edge.0

package/lib/player-api.js

@@ -0,0 +1,469 @@
+import { c as commonjsGlobal, g as getDefaultExportFromCjs } from './_commonjsHelpers.js';
+
+const LEGACY_CONDITIONAL_OPERATORS = {
+    "=": 'eq',
+    "!=": 'ne',
+    "<": 'lt',
+    ">": 'gt',
+    "<=": 'lte',
+    ">=": 'gte',
+    "&&": 'and',
+    "||": 'or',
+    "*": "mul",
+    "/": "div",
+    "+": "add",
+    "-": "sub",
+    "^": "pow"
+};
+const OLD_AKAMAI_SHARED_CDN = "cloudinary-a.akamaihd.net";
+const AKAMAI_SHARED_CDN = "res.cloudinary.com";
+const SHARED_CDN = AKAMAI_SHARED_CDN;
+const LEGACY_PREDEFINED_VARS = {
+    "aspect_ratio": "ar",
+    "aspectRatio": "ar",
+    "current_page": "cp",
+    "currentPage": "cp",
+    "duration": "du",
+    "face_count": "fc",
+    "faceCount": "fc",
+    "height": "h",
+    "initial_aspect_ratio": "iar",
+    "initial_height": "ih",
+    "initial_width": "iw",
+    "initialAspectRatio": "iar",
+    "initialHeight": "ih",
+    "initialWidth": "iw",
+    "initial_duration": "idu",
+    "initialDuration": "idu",
+    "page_count": "pc",
+    "page_x": "px",
+    "page_y": "py",
+    "pageCount": "pc",
+    "pageX": "px",
+    "pageY": "py",
+    "tags": "tags",
+    "width": "w"
+};
+const NUMBER_PATTERN = "([0-9]*)\\.([0-9]+)|([0-9]+)";
+const OFFSET_ANY_PATTERN = `(${NUMBER_PATTERN})([%pP])?`;
+const RANGE_VALUE_RE = RegExp(`^${OFFSET_ANY_PATTERN}$`);
+const OFFSET_ANY_PATTERN_RE = RegExp(`(${OFFSET_ANY_PATTERN})\\.\\.(${OFFSET_ANY_PATTERN})`);
+const LAYER_KEYWORD_PARAMS = {
+    font_weight: "normal",
+    font_style: "normal",
+    text_decoration: "none",
+    text_align: '',
+    stroke: "none"
+};
+
+function unsigned_url_prefix(source, cloud_name, private_cdn, cdn_subdomain, secure_cdn_subdomain, cname, secure, secure_distribution) {
+    let prefix;
+    if (cloud_name.indexOf("/") === 0) {
+        return '/res' + cloud_name;
+    }
+    let shared_domain = !private_cdn;
+    if (secure) {
+        if ((secure_distribution == null) || secure_distribution === OLD_AKAMAI_SHARED_CDN) {
+            secure_distribution = private_cdn ? cloud_name + "-res.cloudinary.com" : SHARED_CDN;
+        }
+        if (shared_domain == null) {
+            shared_domain = secure_distribution === SHARED_CDN;
+        }
+        prefix = 'https://' + secure_distribution;
+    }
+    else if (cname) {
+        // let subdomain = cdn_subdomain ? 'a' + ((crc32(source) % 5) + 1) + '.' : '';
+        prefix = 'http://' + cname;
+    }
+    else {
+        let cdn_part = private_cdn ? cloud_name + '-' : '';
+        let host = [cdn_part, 'res', '.cloudinary.com'].join('');
+        prefix = 'http://' + host;
+    }
+    if (shared_domain) {
+        prefix += '/' + cloud_name;
+    }
+    return prefix;
+}
+
+const getCloudinaryUrlPrefix = cloudinaryConfig => {
+  return unsigned_url_prefix(null, cloudinaryConfig.cloud_name, cloudinaryConfig.private_cdn, cloudinaryConfig.cdn_subdomain, cloudinaryConfig.secure_cdn_subdomain, cloudinaryConfig.cname, cloudinaryConfig.secure ?? true, cloudinaryConfig.secure_distribution);
+};
+
+var css_escape$1 = {exports: {}};
+
+/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
+var css_escape = css_escape$1.exports;
+
+var hasRequiredCss_escape;
+
+function requireCss_escape () {
+	if (hasRequiredCss_escape) return css_escape$1.exports;
+	hasRequiredCss_escape = 1;
+	(function (module, exports$1) {
+(function(root, factory) {
+			// https://github.com/umdjs/umd/blob/master/returnExports.js
+			{
+				// For Node.js.
+				module.exports = factory(root);
+			}
+		}(typeof commonjsGlobal != 'undefined' ? commonjsGlobal : css_escape, function(root) {
+
+			if (root.CSS && root.CSS.escape) {
+				return root.CSS.escape;
+			}
+
+			// https://drafts.csswg.org/cssom/#serialize-an-identifier
+			var cssEscape = function(value) {
+				if (arguments.length == 0) {
+					throw new TypeError('`CSS.escape` requires an argument.');
+				}
+				var string = String(value);
+				var length = string.length;
+				var index = -1;
+				var codeUnit;
+				var result = '';
+				var firstCodeUnit = string.charCodeAt(0);
+				while (++index < length) {
+					codeUnit = string.charCodeAt(index);
+					// Note: there’s no need to special-case astral symbols, surrogate
+					// pairs, or lone surrogates.
+
+					// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+					// (U+FFFD).
+					if (codeUnit == 0x0000) {
+						result += '\uFFFD';
+						continue;
+					}
+
+					if (
+						// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+						// U+007F, […]
+						(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+						// If the character is the first character and is in the range [0-9]
+						// (U+0030 to U+0039), […]
+						(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+						// If the character is the second character and is in the range [0-9]
+						// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+						(
+							index == 1 &&
+							codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+							firstCodeUnit == 0x002D
+						)
+					) {
+						// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+						result += '\\' + codeUnit.toString(16) + ' ';
+						continue;
+					}
+
+					if (
+						// If the character is the first character and is a `-` (U+002D), and
+						// there is no second character, […]
+						index == 0 &&
+						length == 1 &&
+						codeUnit == 0x002D
+					) {
+						result += '\\' + string.charAt(index);
+						continue;
+					}
+
+					// If the character is not handled by one of the above rules and is
+					// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+					// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+					// U+005A), or [a-z] (U+0061 to U+007A), […]
+					if (
+						codeUnit >= 0x0080 ||
+						codeUnit == 0x002D ||
+						codeUnit == 0x005F ||
+						codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+						codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+						codeUnit >= 0x0061 && codeUnit <= 0x007A
+					) {
+						// the character itself
+						result += string.charAt(index);
+						continue;
+					}
+
+					// Otherwise, the escaped character.
+					// https://drafts.csswg.org/cssom/#escape-a-character
+					result += '\\' + string.charAt(index);
+
+				}
+				return result;
+			};
+
+			if (!root.CSS) {
+				root.CSS = {};
+			}
+
+			root.CSS.escape = cssEscape;
+			return cssEscape;
+
+		})); 
+	} (css_escape$1));
+	return css_escape$1.exports;
+}
+
+var css_escapeExports = requireCss_escape();
+var cssEscape = /*@__PURE__*/getDefaultExportFromCjs(css_escapeExports);
+
+/**
+ * Minimal Cloudinary poster URL builder for video first frame.
+ * Used by schedule bootstrap when outside schedule (no full player loaded).
+ */
+const POSTER_TRANSFORMATION = 'so_0,f_auto,q_auto';
+
+/**
+ * Build Cloudinary video poster (first frame) URL.
+ * @param {string} cloudName - Cloudinary cloud name
+ * @param {string} publicId - Video public ID
+ * @param {object} [cloudinaryConfig] - Optional: secure, private_cdn, cdn_subdomain, cname, secure_distribution
+ * @returns {string} Poster image URL
+ */
+const buildPosterUrl = function (cloudName, publicId) {
+  let cloudinaryConfig = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const config = {
+    cloud_name: cloudName || cloudinaryConfig.cloud_name,
+    ...cloudinaryConfig,
+    secure: cloudinaryConfig.secure ?? true
+  };
+  const prefix = getCloudinaryUrlPrefix(config);
+  return `${prefix}/video/upload/${POSTER_TRANSFORMATION}/${publicId}`;
+};
+
+/**
+ * Schedule utilities: weekly time-range parsing and bootstrap (poster rendering).
+ * Uses browser local time. No videojs dependency for the bootstrap path.
+ */
+const INTERNAL_ANALYTICS_URL = 'https://analytics-api-s.cloudinary.com';
+const sendScheduleImageAnalytics = options => {
+  const allowReport = options?.sourceOptions?.allowUsageReport ?? options?.allowUsageReport;
+  if (allowReport === false) return;
+  try {
+    const params = new URLSearchParams({
+      scheduleImageRendered: 'true',
+      cloudName: options?.cloudName || options?.cloudinaryConfig?.cloud_name || ''
+    }).toString();
+    fetch(`${INTERNAL_ANALYTICS_URL}/video_player_source?${params}`);
+  } catch {
+    // noop
+  }
+};
+const getCloudNameFromOptions = options => options?.cloudName || options?.cloud_name || options?.cloudinaryConfig?.cloud_name;
+const getPublicIdFromOptions = options => options?.publicId || options?.sourceOptions?.publicId;
+
+/**
+ * Returns true when schedule.weekly is configured and current time is outside the schedule.
+ * @param {object} options - player options
+ * @returns {boolean}
+ */
+const shouldUseScheduleBootstrap = options => {
+  const schedule = options?.schedule;
+  const weekly = schedule?.weekly;
+  return Array.isArray(weekly) && weekly.length > 0 && !isWithinSchedule(schedule, new Date());
+};
+
+/**
+ * Bootstrap path when outside schedule: render poster, return stub with loadPlayer().
+ * @param {string|HTMLElement} elem - Element id or video element
+ * @param {object} options - player options
+ * @returns {object} Stub with source() and loadPlayer()
+ */
+const scheduleBootstrap = (elem, options) => {
+  const videoElement = getElementForSchedule(elem);
+  const cloudName = getCloudNameFromOptions(options);
+  const publicId = getPublicIdFromOptions(options);
+  if (!cloudName || !publicId) {
+    throw new Error('schedule.weekly requires cloudName and publicId when outside schedule');
+  }
+  const cloudinaryConfig = options?.cloudinaryConfig || {
+    cloud_name: cloudName
+  };
+  const posterUrl = buildPosterUrl(cloudName, publicId, cloudinaryConfig);
+  const fluid = options?.fluid !== false;
+  const {
+    container,
+    videoElement: vEl
+  } = renderScheduleImage(videoElement, posterUrl, {
+    fluid,
+    width: options?.width,
+    height: options?.height,
+    cropMode: options?.sourceOptions?.cropMode
+  });
+  sendScheduleImageAnalytics(options);
+  const stub = {
+    source: () => stub,
+    loadPlayer: () => {
+      if (container && container.parentNode) {
+        container.parentNode.removeChild(container);
+      }
+      vEl.style.display = '';
+      return import('./video-player.js').then(function (n) { return n.v; }).then(m => m.createVideoPlayer(vEl, options));
+    }
+  };
+  return stub;
+};
+const DAY_MAP = {
+  sunday: 0,
+  sun: 0,
+  monday: 1,
+  mon: 1,
+  tuesday: 2,
+  tue: 2,
+  tues: 2,
+  wednesday: 3,
+  wed: 3,
+  thursday: 4,
+  thu: 4,
+  thur: 4,
+  thurs: 4,
+  friday: 5,
+  fri: 5,
+  saturday: 6,
+  sat: 6
+};
+const FLUID_CLASS = 'cld-fluid';
+
+/**
+ * Parse readable day-of-week string to JS Date.getDay() value (0=Sun .. 6=Sat).
+ * @param {string} day - Full or abbreviated day name (case-insensitive)
+ * @returns {number|null} 0-6, or null if invalid
+ */
+const parseDay = day => {
+  if (typeof day !== 'string') return null;
+  const key = day.toLowerCase().trim();
+  return DAY_MAP[key] ?? null;
+};
+
+/**
+ * Parse "HH:mm" string to minutes since midnight.
+ * @param {string} timeStr - "09:00" or "17:30"
+ * @returns {number|null} minutes, or null if invalid
+ */
+const parseTime = timeStr => {
+  if (typeof timeStr !== 'string') return null;
+  const match = timeStr.trim().match(/^(\d{1,2}):(\d{2})$/);
+  if (!match) return null;
+  const h = parseInt(match[1], 10);
+  const m = parseInt(match[2], 10);
+  if (h < 0 || h > 23 || m < 0 || m > 59) return null;
+  return h * 60 + m;
+};
+
+/**
+ * Check if a date falls within any configured weekly slot (local time).
+ * @param {{ weekly?: Array<{ day: string, start: string, duration: number }> }} schedule - schedule config
+ * @param {Date} date - date to check (uses local time)
+ * @returns {boolean} true if within a slot
+ */
+const isWithinSchedule = (schedule, date) => {
+  const weekly = schedule?.weekly;
+  if (!Array.isArray(weekly) || weekly.length === 0) return true;
+  const WEEK = 7 * 1440;
+  const nowInWeek = date.getDay() * 1440 + date.getHours() * 60 + date.getMinutes();
+  for (const slot of weekly) {
+    const slotDay = parseDay(slot.day);
+    if (slotDay === null) continue;
+    const startMin = parseTime(slot.start);
+    if (startMin === null || typeof slot.duration !== 'number' || slot.duration <= 0) continue;
+    const slotStart = slotDay * 1440 + startMin;
+    const durationMin = slot.duration * 60;
+    const elapsed = (nowInWeek - slotStart + WEEK) % WEEK;
+    if (elapsed < durationMin) return true;
+  }
+  return false;
+};
+
+/**
+ * Resolve video element by id or return element. No videojs.
+ * @param {string|HTMLElement} elem - Element id (with or without #) or video element
+ * @returns {HTMLVideoElement}
+ */
+const getElementForSchedule = elem => {
+  if (typeof elem === 'string') {
+    let id = elem;
+    if (id.indexOf('#') === 0) id = id.slice(1);
+    try {
+      elem = document.querySelector(`#${cssEscape(id)}`);
+    } catch {
+      elem = null;
+    }
+    if (!elem) throw new Error(`Could not find element with id ${id}`);
+  }
+  if (!elem?.tagName) throw new Error('Must specify either an element or an element id.');
+  if (elem.tagName !== 'VIDEO') throw new Error('Element is not a video tag.');
+  return elem;
+};
+
+/**
+ * Hide video, show poster image overlay. Keeps video in DOM for load().
+ * @param {HTMLVideoElement} videoElement
+ * @param {string} posterUrl
+ * @param {object} options - fluid, width, height, etc.
+ * @returns {{ img: HTMLImageElement, container: HTMLElement, videoElement: HTMLVideoElement }}
+ */
+const renderScheduleImage = function (videoElement, posterUrl) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const fluid = options.fluid !== false;
+  const parent = videoElement.parentNode;
+  const container = document.createElement('div');
+  container.className = 'cld-schedule-poster-container';
+  container.style.cssText = 'position:relative;width:100%;height:100%;';
+  const img = document.createElement('img');
+  img.src = posterUrl;
+  img.alt = '';
+  img.setAttribute('data-cld-schedule-poster', 'true');
+  img.style.cssText = 'display:block;width:100%;height:100%;object-fit:contain;';
+  if (fluid) {
+    container.classList.add(FLUID_CLASS);
+    img.style.objectFit = options.cropMode === 'fill' ? 'cover' : 'contain';
+  }
+  if (options.width) container.style.width = `${options.width}px`;
+  if (options.height) container.style.height = `${options.height}px`;
+  videoElement.style.display = 'none';
+  container.appendChild(img);
+  parent.insertBefore(container, videoElement);
+  return {
+    img,
+    container,
+    videoElement
+  };
+};
+
+const createAsyncPlayer = async (id, playerOptions, ready, createFn) => {
+  const mergedOptions = Object.assign({}, playerOptions);
+  const videoElement = getElementForSchedule(id);
+  const opts = await (async () => {
+    try {
+      const {
+        fetchAndMergeConfig
+      } = await import('./fetch-config.js');
+      const fetched = await fetchAndMergeConfig(mergedOptions);
+      return Object.assign({}, fetched, mergedOptions);
+    } catch {
+      return mergedOptions;
+    }
+  })();
+  if (shouldUseScheduleBootstrap(opts)) {
+    return scheduleBootstrap(id, opts);
+  }
+  return createFn(videoElement, opts, ready);
+};
+const createMultiplePlayers = async (selector, playerOptions, ready, playerFn) => {
+  const nodeList = document.querySelectorAll(selector);
+  return Promise.all([...nodeList].map(node => playerFn(node, playerOptions, ready)));
+};
+const createMultipleSync = (selector, playerOptions, ready, playerFn) => {
+  const nodeList = document.querySelectorAll(selector);
+  return [...nodeList].map(node => playerFn(node, playerOptions, ready));
+};
+const setupCloudinaryGlobal = methods => {
+  const cloudinary = {
+    ...(window.cloudinary || {}),
+    ...methods
+  };
+  window.cloudinary = cloudinary;
+  return cloudinary;
+};
+
+export { LAYER_KEYWORD_PARAMS as L, OFFSET_ANY_PATTERN_RE as O, RANGE_VALUE_RE as R, createAsyncPlayer as a, LEGACY_CONDITIONAL_OPERATORS as b, createMultiplePlayers as c, LEGACY_PREDEFINED_VARS as d, cssEscape as e, createMultipleSync as f, getCloudinaryUrlPrefix as g, setupCloudinaryGlobal as s, unsigned_url_prefix as u };