@kimjansheden/payload-video-processor 0.1.2 → 0.1.3

package/dist/index.js

@@ -637,6 +637,166 @@ var createReplaceOriginalHandler = ({ access }) => async (req) => {
   }
 };
 
+// src/utils/playback.ts
+var isAbsoluteUrl = (value) => value.startsWith("http://") || value.startsWith("https://") || value.startsWith("data:") || value.startsWith("blob:") || value.startsWith("//");
+var readHeader = (headers, name) => {
+  if (!headers) {
+    return "";
+  }
+  if (typeof headers.get === "function") {
+    return headers.get(name) ?? headers.get(name.toLowerCase()) ?? "";
+  }
+  const record = headers;
+  const value = record[name] ?? record[name.toLowerCase()];
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return typeof value[0] === "string" ? value[0] : "";
+  }
+  return "";
+};
+var getServerUrlFromReq = (req) => {
+  const serverURL = req?.payload?.config?.serverURL;
+  return typeof serverURL === "string" ? serverURL.trim() : "";
+};
+var getRequestOrigin = (req) => {
+  const serverURL = getServerUrlFromReq(req);
+  if (serverURL) {
+    try {
+      return new URL(serverURL).origin;
+    } catch {
+    }
+  }
+  const requestUrl = typeof req?.url === "string" ? req.url : "";
+  if (requestUrl && isAbsoluteUrl(requestUrl)) {
+    try {
+      return new URL(requestUrl).origin;
+    } catch {
+    }
+  }
+  const headers = req?.headers;
+  const forwardedProto = readHeader(headers, "x-forwarded-proto");
+  const forwardedHost = readHeader(headers, "x-forwarded-host");
+  const host = forwardedHost || readHeader(headers, "host");
+  const proto = forwardedProto || "http";
+  return host ? `${proto}://${host}` : "";
+};
+var resolvePlaybackUrl = (input, bases) => {
+  if (typeof input !== "string") {
+    return "";
+  }
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return "";
+  }
+  if (isAbsoluteUrl(trimmed)) {
+    try {
+      return new URL(trimmed).toString();
+    } catch {
+      return "";
+    }
+  }
+  for (const base of bases) {
+    if (!base) {
+      continue;
+    }
+    try {
+      return new URL(trimmed, base).toString();
+    } catch {
+    }
+  }
+  return trimmed;
+};
+var inferVideoMimeTypeFromUrl = (url) => {
+  const cleanUrl = url.split("#")[0]?.split("?")[0] ?? "";
+  const lower = cleanUrl.toLowerCase();
+  if (lower.endsWith(".mp4") || lower.endsWith(".m4v") || lower.endsWith(".mov")) {
+    return "video/mp4";
+  }
+  if (lower.endsWith(".webm")) {
+    return "video/webm";
+  }
+  if (lower.endsWith(".ogv") || lower.endsWith(".ogg")) {
+    return "video/ogg";
+  }
+  return void 0;
+};
+var normaliseVideoSourceType = (mimeType, resolvedUrl) => {
+  const normalised = typeof mimeType === "string" ? mimeType.trim().toLowerCase() : "";
+  if (normalised === "video/quicktime") {
+    return "video/mp4";
+  }
+  if (normalised) {
+    return normalised;
+  }
+  return inferVideoMimeTypeFromUrl(resolvedUrl);
+};
+var getThumbnailCandidate = (doc) => {
+  const sizes = doc.sizes;
+  if (sizes && typeof sizes === "object") {
+    const sizeCandidates = ["medium", "large", "square", "thumbnail"];
+    for (const key of sizeCandidates) {
+      const entry = sizes[key];
+      const url = entry?.url;
+      if (typeof url === "string" && url.trim()) {
+        return url;
+      }
+    }
+  }
+  if (typeof doc.thumbnailURL === "string" && doc.thumbnailURL.trim()) {
+    return doc.thumbnailURL;
+  }
+  return void 0;
+};
+var buildPlaybackSources = ({
+  doc,
+  req
+}) => {
+  const sources = [];
+  const seen = /* @__PURE__ */ new Set();
+  const docUrl = typeof doc.url === "string" ? doc.url.trim() : "";
+  const requestOrigin = getRequestOrigin(req);
+  const bases = [docUrl, requestOrigin].filter(Boolean);
+  const variants = Array.isArray(doc.variants) ? doc.variants : [];
+  const sortedVariants = [...variants].sort((a, b) => {
+    const aSize = typeof a?.size === "number" ? a.size : Number.NEGATIVE_INFINITY;
+    const bSize = typeof b?.size === "number" ? b.size : Number.NEGATIVE_INFINITY;
+    return bSize - aSize;
+  });
+  for (const variant of sortedVariants) {
+    const resolvedUrl = resolvePlaybackUrl(variant?.url, bases);
+    if (!resolvedUrl || seen.has(resolvedUrl)) {
+      continue;
+    }
+    seen.add(resolvedUrl);
+    sources.push({
+      preset: typeof variant?.preset === "string" ? variant.preset : void 0,
+      src: resolvedUrl,
+      type: normaliseVideoSourceType(void 0, resolvedUrl)
+    });
+  }
+  const resolvedOriginalUrl = resolvePlaybackUrl(doc.url, bases);
+  if (resolvedOriginalUrl && !seen.has(resolvedOriginalUrl)) {
+    sources.push({
+      src: resolvedOriginalUrl,
+      type: normaliseVideoSourceType(doc.mimeType, resolvedOriginalUrl)
+    });
+  }
+  return sources;
+};
+var buildPlaybackPosterUrl = ({
+  doc,
+  req
+}) => {
+  const docUrl = typeof doc.url === "string" ? doc.url.trim() : "";
+  const requestOrigin = getRequestOrigin(req);
+  const bases = [docUrl, requestOrigin].filter(Boolean);
+  const candidate = getThumbnailCandidate(doc);
+  const resolved = resolvePlaybackUrl(candidate, bases);
+  return resolved || void 0;
+};
+
 // src/ffmpeg/args.ts
 var FASTSTART_FLAGS = ["-movflags", "+faststart"];
 var CRF_FLAG = "-crf";
@@ -1077,9 +1237,39 @@ var pluginFactory = (rawOptions) => {
           };
           fields.push(controlField);
         }
+        const existingHooks = collection.hooks ?? {};
+        const existingAfterRead = Array.isArray(existingHooks.afterRead) ? existingHooks.afterRead : [];
+        const hooks = {
+          ...existingHooks,
+          afterRead: [
+            ...existingAfterRead,
+            ({ doc, req }) => {
+              if (!doc || typeof doc !== "object") {
+                return doc;
+              }
+              const mimeType = typeof doc.mimeType === "string" ? doc.mimeType : "";
+              if (!mimeType.startsWith("video/")) {
+                return doc;
+              }
+              doc.playbackSources = buildPlaybackSources({
+                doc,
+                req
+              });
+              const posterUrl = buildPlaybackPosterUrl({
+                doc,
+                req
+              });
+              if (posterUrl) {
+                doc.playbackPosterUrl = posterUrl;
+              }
+              return doc;
+            }
+          ]
+        };
         return {
           ...collection,
-          fields
+          fields,
+          hooks
         };
       }
     );