sanity-plugin-mux-input 3.0.5 → 4.0.0

package/src/util/getVideoSrc.ts

@@ -1,23 +0,0 @@
-import type {SanityClient} from 'sanity'
-
-import {generateJwt} from './generateJwt'
-import type {MuxPlaybackId, MuxVideoUrl} from './types'
-
-interface VideoSrcOptions {
-  muxPlaybackId: MuxPlaybackId
-  client: SanityClient
-}
-
-/**
- * May throw a Promise. Call this with {@link tryWithSuspend} or rethrow the Promise
- */
-export function getVideoSrc({client, muxPlaybackId}: VideoSrcOptions): MuxVideoUrl {
-  const searchParams = new URLSearchParams()
-
-  if (muxPlaybackId.policy === 'signed' || muxPlaybackId.policy === 'drm') {
-    const token = generateJwt(client, muxPlaybackId.id, 'v')
-    searchParams.set('token', token)
-  }
-
-  return `https://stream.mux.com/${muxPlaybackId.id}.m3u8?${searchParams}`
-}

package/src/util/parsers.ts

@@ -1,5 +0,0 @@
-import type {MuxAsset} from './types'
-
-export function parseMuxDate(date: MuxAsset['created_at']): Date {
-  return new Date(Number(date) * 1000)
-}

package/src/util/pluginVersion.ts

@@ -1,5 +0,0 @@
-export const PLUGIN_VERSION_QUERY = {
-  sanityVersion:
-    // @ts-expect-error - this constant is search/replaced so must be exact, not accessed with an index signature
-    process.env.PKG_VERSION!,
-}

package/src/util/readSecrets.ts

@@ -1,38 +0,0 @@
-// Utils with a readName prefix are suspendable and should only be called in the render body
-// Not inside event callbacks or a useEffect.
-// They may be called dynamically, unlike useEffect
-
-// @TODO rename to readSigningPair
-
-import type {SanityClient} from 'sanity'
-import {suspend} from 'suspend-react'
-
-import {cacheNs} from '../util/constants'
-import {type Secrets} from '../util/types'
-
-export const _id = 'secrets.mux' as const
-
-export function readSecrets(client: SanityClient): Secrets {
-  const {projectId, dataset} = client.config()
-  return suspend(async () => {
-    const data = await client.fetch(
-      /* groq */ `*[_id == $_id][0]{
-        token,
-        secretKey,
-        enableSignedUrls,
-        signingKeyId,
-        signingKeyPrivate,
-        drmConfigId
-      }`,
-      {_id},
-    )
-    return {
-      token: data?.token || null,
-      secretKey: data?.secretKey || null,
-      enableSignedUrls: Boolean(data?.enableSignedUrls) || false,
-      signingKeyId: data?.signingKeyId || null,
-      signingKeyPrivate: data?.signingKeyPrivate || null,
-      drmConfigId: data?.drmConfigId || null,
-    }
-  }, [cacheNs, _id, projectId, dataset])
-}

package/src/util/roundPxString.ts

@@ -1,16 +0,0 @@
-/**
- * Rounds the numeric part of a px string to the nearest integer.
- * Returns undefined if the value is not a valid px string or not a finite number.
- * Avoids sending 0px (and JS -0); snaps to ±1 instead.
- */
-export function roundPxString(value: unknown): string | undefined {
-  if (typeof value !== 'string') return undefined
-  const trimmed = value.trim()
-  if (!trimmed.endsWith('px')) return undefined
-  const n = Number(trimmed.slice(0, -2))
-  if (!Number.isFinite(n)) return undefined
-  let rounded = Math.round(n)
-  // Avoid sending 0px (and JS -0); keep sign when negative.
-  if (rounded === 0) rounded = n < 0 ? -1 : 1
-  return `${rounded}px`
-}

package/src/util/textTracks.ts

@@ -1,222 +0,0 @@
-import type {SanityClient} from '@sanity/client'
-
-import {getAsset} from '../actions/assets'
-import {generateJwt} from './generateJwt'
-import {getPlaybackId} from './getPlaybackPolicy'
-import {getPlaybackPolicy} from './getPlaybackPolicy'
-import type {MuxTextTrack, VideoAssetDocument} from './types'
-
-export function extractErrorMessage(
-  error: unknown,
-  defaultMessage = 'Failed to process request',
-): string {
-  let message = ''
-
-  if (error && typeof error === 'object') {
-    const err = error as {response?: {body?: {message?: string}}; message?: string}
-    message = err.response?.body?.message || err.message || ''
-  } else if (typeof error === 'string') {
-    message = error
-  }
-
-  if (!message) {
-    return defaultMessage
-  }
-
-  const match = message.match(/\(([^)]+)\)/)
-  if (match && match[1]) {
-    return match[1]
-  }
-
-  if (message.includes('responded with')) {
-    const parts = message.split('(')
-    if (parts.length > 1) {
-      return parts[parts.length - 1]!.replace(')', '').trim()
-    }
-  }
-
-  return message
-}
-
-export interface PollTrackStatusOptions {
-  client: SanityClient
-  assetId: string
-  trackName: string
-  trackLanguageCode: string
-  maxAttempts?: number
-  onTrackFound?: (track: MuxTextTrack) => void
-  onTrackErrored?: (track: MuxTextTrack) => void
-  onTrackReady?: (track: MuxTextTrack) => void
-}
-
-export interface PollTrackStatusResult {
-  track: MuxTextTrack | undefined
-  found: boolean
-  status: 'ready' | 'preparing' | 'errored' | 'not-found'
-}
-
-/**
- * Polls Mux API to find and track the status of a newly added text track.
- * The track may be in "preparing" state initially, then become "ready" or "errored".
- *
- * @param options - Configuration options for polling
- * @returns Promise resolving to the poll result
- */
-export async function pollTrackStatus(
-  options: PollTrackStatusOptions,
-): Promise<PollTrackStatusResult> {
-  const {
-    client,
-    assetId,
-    trackName,
-    trackLanguageCode,
-    maxAttempts = 10,
-    onTrackFound,
-    onTrackErrored,
-    onTrackReady,
-  } = options
-
-  const trimmedName = trackName.trim()
-  const trimmedLanguageCode = trackLanguageCode.trim()
-  let newTrack: MuxTextTrack | undefined
-  let attempts = 0
-  let trackFound = false
-
-  const findTrack = (textTracks: MuxTextTrack[]): MuxTextTrack | undefined => {
-    let foundTrack = textTracks.find(
-      (track) => track.name === trimmedName && track.language_code === trimmedLanguageCode,
-    )
-
-    if (!foundTrack) {
-      foundTrack = textTracks.find((track) => track.language_code === trimmedLanguageCode)
-    }
-
-    if (!foundTrack && textTracks.length > 0) {
-      foundTrack = textTracks[textTracks.length - 1]
-    }
-
-    return foundTrack
-  }
-
-  while (attempts < maxAttempts) {
-    try {
-      if (attempts > 0) {
-        await new Promise((resolve) => setTimeout(resolve, 1000))
-      }
-
-      const assetData = await getAsset(client, assetId)
-      const textTracks =
-        assetData.data.tracks?.filter((track): track is MuxTextTrack => track.type === 'text') || []
-
-      const foundTrack = findTrack(textTracks)
-
-      if (!foundTrack) {
-        attempts++
-        continue
-      }
-
-      trackFound = true
-      newTrack = foundTrack
-
-      if (onTrackFound) {
-        onTrackFound(foundTrack)
-      }
-
-      if (foundTrack.status === 'ready') {
-        if (onTrackReady) {
-          onTrackReady(foundTrack)
-        }
-        break
-      }
-
-      if (foundTrack.status === 'errored') {
-        if (onTrackErrored) {
-          onTrackErrored(foundTrack)
-        }
-        return {
-          track: foundTrack,
-          found: true,
-          status: 'errored',
-        }
-      }
-    } catch (error) {
-      console.error('Failed to fetch updated asset:', error)
-    }
-
-    attempts++
-  }
-
-  if (!newTrack || !trackFound) {
-    return {
-      track: undefined,
-      found: false,
-      status: 'not-found',
-    }
-  }
-
-  if (newTrack.status === 'preparing') {
-    return {
-      track: newTrack,
-      found: true,
-      status: 'preparing',
-    }
-  }
-
-  return {
-    track: newTrack,
-    found: true,
-    status: 'ready',
-  }
-}
-
-/**
- * May throw a Promise. Call this with {@link tryWithSuspend} or rethrow the Promise
- */
-export async function downloadVttFile(
-  client: SanityClient,
-  asset: VideoAssetDocument,
-  track: MuxTextTrack,
-): Promise<void> {
-  if (!track.id) {
-    throw new Error('Track ID is missing')
-  }
-
-  if (track.status !== 'ready') {
-    throw new Error(`Track is not ready yet. Status: ${track.status}`)
-  }
-
-  if (!asset.assetId) {
-    throw new Error('Asset ID is required')
-  }
-
-  const playbackId = getPlaybackId(asset)
-  if (!playbackId) {
-    throw new Error('Playback ID is required')
-  }
-
-  const playbackPolicy = getPlaybackPolicy(asset)?.policy
-
-  let downloadUrl = `https://stream.mux.com/${playbackId}/text/${track.id}.vtt`
-
-  if (playbackPolicy === 'signed' || playbackPolicy === 'drm') {
-    const token = generateJwt(client, playbackId, 'v')
-    downloadUrl += `?token=${token}`
-  }
-
-  const response = await fetch(downloadUrl)
-  if (!response.ok) {
-    throw new Error(`Failed to download file: ${response.statusText}`)
-  }
-
-  const blob = await response.blob()
-  const blobUrl = URL.createObjectURL(blob)
-
-  const link = document.createElement('a')
-  link.href = blobUrl
-  link.download = `${asset.filename || 'captions'}-${track.language_code || 'en'}.vtt`
-  document.body.appendChild(link)
-  link.click()
-  document.body.removeChild(link)
-
-  URL.revokeObjectURL(blobUrl)
-}

package/src/util/tryWithSuspend.ts

@@ -1,22 +0,0 @@
-/**
- * When running `suspend()` from react-suspend a function may throw a Promise
- * causing unexpected behavior when catching.
- * @param block Your block of code that uses suspend
- * @param onError (optional) How to handle a regular Error
- * @returns Whatever is returned by the block if it succeeds, otherwise whatever is resolved by onError if defined
- * @throws rethrows the caught Promise to comply with Suspense logic
- */
-export function tryWithSuspend<T, E>(
-  block: () => T,
-  onError?: (error: Error) => E,
-): T | E | undefined {
-  try {
-    return block()
-  } catch (errorOrPromise) {
-    if (errorOrPromise instanceof Promise) {
-      // react-suspend will throw a Promise
-      throw errorOrPromise
-    }
-    return onError ? onError(errorOrPromise as Error) : undefined
-  }
-}