sanity-plugin-mux-input 3.0.5 → 4.0.0

package/src/util/convertWatermarkToMux.ts

@@ -1,160 +0,0 @@
-import {roundPxString} from './roundPxString'
-import type {MuxOverlaySettings, WatermarkConfig} from './types'
-
-/**
- * Converts a draggable watermark position (x, y percentages) to Mux's overlay_settings format.
- *
- * @param watermark - The watermark configuration with position, size, and opacity
- * @returns Mux overlay_settings object
- * @see {@link https://www.mux.com/docs/guides/add-watermarks-to-your-videos}
- */
-export function convertWatermarkToMuxOverlay(
-  watermark: WatermarkConfig,
-  options?: {
-    /**
-     * Video aspect ratio (width / height). Needed for correct vertical positioning,
-     * especially on vertical videos.
-     */
-    videoAspectRatio?: number
-    /**
-     * Unit to emit for margins/width when generating overlay_settings from Canvas mode.
-     * - 'px' will generate pixel strings according to Mux's scaling rules:
-     *   values are applied as if the video were scaled to 1920x1080 (horizontal)
-     *   or 1080x1920 (vertical).
-     * - '%' preserves existing behavior.
-     */
-    units?: '%' | 'px'
-  },
-): MuxOverlaySettings | null {
-  if (!watermark.enabled || !watermark.imageUrl) {
-    return null
-  }
-
-  const size = watermark.size || 20
-  const opacity = watermark.opacity ?? 0.7
-
-  /**
-   * Convert a percentage to whole-pixel string, using Mux's base dimensions:
-   * - Horizontal video: 1920x1080
-   * - Vertical video:   1080x1920
-   */
-  const toPxString = (valuePercent: number, axis: 'x' | 'y') => {
-    const videoAspectRatio = options?.videoAspectRatio ?? 16 / 9
-    const isVertical = videoAspectRatio > 0 && videoAspectRatio < 1
-    const baseW = isVertical ? 1080 : 1920
-    const baseH = isVertical ? 1920 : 1080
-    const base = axis === 'x' ? baseW : baseH
-    const px = (valuePercent / 100) * base
-    let rounded = Math.round(px)
-    // Avoid sending 0px (and JS -0); keep sign for negative margins.
-    if (rounded === 0) rounded = px < 0 ? -1 : 1
-    return `${rounded}px`
-  }
-
-  const normalizeToPixels = (value: string | undefined, axis: 'x' | 'y'): string | undefined => {
-    if (!value) return value
-    const trimmed = value.trim()
-    if (trimmed.endsWith('px')) {
-      return roundPxString(trimmed)
-    }
-    if (trimmed.endsWith('%')) {
-      const n = Number(trimmed.slice(0, -1))
-      if (!Number.isFinite(n)) return value
-      return toPxString(n, axis)
-    }
-    return value
-  }
-
-  // If user provided explicit overlay settings, use them (Mux-documented format).
-  // When `options.units === 'px'`, we normalize both % and px to whole-pixel strings,
-  // honoring vertical vs horizontal video bases.
-  if (watermark.overlay_settings) {
-    const widthValue = watermark.overlay_settings.width
-    const widthNormalized =
-      options?.units === 'px' ? normalizeToPixels(widthValue, 'x') : widthValue
-    return {
-      ...watermark.overlay_settings,
-      horizontal_margin:
-        options?.units === 'px'
-          ? (normalizeToPixels(watermark.overlay_settings.horizontal_margin, 'x') ??
-            watermark.overlay_settings.horizontal_margin)
-          : watermark.overlay_settings.horizontal_margin,
-      vertical_margin:
-        options?.units === 'px'
-          ? (normalizeToPixels(watermark.overlay_settings.vertical_margin, 'y') ??
-            watermark.overlay_settings.vertical_margin)
-          : watermark.overlay_settings.vertical_margin,
-      width: widthNormalized ?? `${size}%`,
-      opacity: watermark.overlay_settings.opacity ?? `${Math.round(opacity * 100)}%`,
-    }
-  }
-
-  const position = watermark.position || {x: 50, y: 50}
-
-  /**
-   * Our UI stores watermark position as the *center point* in percentages.
-   * Mux margins are interpreted relative to an *edge* (based on align).
-   *
-   * To make "corner" placements match what the user dragged, we convert from
-   * center-position to top-left margins by subtracting half the watermark size.
-   *
-   * Note: `size` is a percentage of video width. Mux `width` is also expressed
-   * as a percentage of the video width, so we can reuse it for horizontal math.
-   * For vertical math, we approximate using the same percentage to keep behavior
-   * consistent with the current draggable UI (which also uses `size` in both axes
-   * for bounds).
-   */
-  // Allow negative margins to compensate for rounding / letterboxing edge-cases.
-  // We still clamp to a sane range so values don't explode.
-  const clampPercent = (value: number) => Math.max(-100, Math.min(100, value))
-
-  // Mux accepts percentage strings; avoid sending an exact "0%" by nudging to 0.01%.
-  // This also handles the JS -0 edge case and tiny floating point remnants.
-  const toPercentString = (value: number) => {
-    const epsilon = 1e-9
-    const isZeroish = value === 0 || Object.is(value, -0) || Math.abs(value) < epsilon
-    return `${isZeroish ? 0.01 : value}%`
-  }
-
-  const watermarkWidthPercentOfVideoWidth = size
-
-  /**
-   * Convert watermark height into % of video height.
-   * height% = (watermarkWidthPx / imageAspectRatio) / videoHeightPx
-   *         = (size% * videoWidthPx / imageAspectRatio) / videoHeightPx
-   *         = size% * (videoWidthPx/videoHeightPx) / imageAspectRatio
-   *         = size% * videoAspectRatio / imageAspectRatio
-   */
-  const videoAspectRatio = options?.videoAspectRatio ?? 16 / 9
-  const imageAspectRatio = watermark.imageAspectRatio ?? 1
-  const watermarkHeightPercentOfVideoHeight = Math.max(
-    0,
-    Math.min(100, (size * videoAspectRatio) / imageAspectRatio),
-  )
-
-  const halfWidth = watermarkWidthPercentOfVideoWidth / 2
-  const halfHeight = watermarkHeightPercentOfVideoHeight / 2
-
-  const leftMargin = clampPercent(
-    Math.min(position.x - halfWidth, 100 - watermarkWidthPercentOfVideoWidth),
-  )
-  const topMargin = clampPercent(
-    Math.min(position.y - halfHeight, 100 - watermarkHeightPercentOfVideoHeight),
-  )
-
-  const units = options?.units ?? '%'
-  const marginX = units === 'px' ? toPxString(leftMargin, 'x') : toPercentString(leftMargin)
-  const marginY = units === 'px' ? toPxString(topMargin, 'y') : toPercentString(topMargin)
-  const width = units === 'px' ? toPxString(size, 'x') : `${size}%`
-
-  const overlaySettings: MuxOverlaySettings = {
-    vertical_align: 'top',
-    vertical_margin: marginY,
-    horizontal_align: 'left',
-    horizontal_margin: marginX,
-    width,
-    opacity: `${Math.round(opacity * 100)}%`,
-  }
-
-  return overlaySettings
-}

package/src/util/createSearchFilter.ts

@@ -1,76 +0,0 @@
-// Adaptation of Sanity's createSearchQuery for our limited use case:
-// https://github.com/sanity-io/sanity/blob/next/packages/sanity/src/core/search/weighted/createSearchQuery.ts
-import {compact, toLower, trim, uniq, words} from 'lodash'
-
-const SPECIAL_CHARS = /([^!@#$%^&*(),\\/?";:{}|[\]+<>\s-])+/g
-const STRIP_EDGE_CHARS = /(^[.]+)|([.]+$)/
-
-function tokenize(string: string): string[] {
-  return (string.match(SPECIAL_CHARS) || []).map((token) => token.replace(STRIP_EDGE_CHARS, ''))
-}
-
-function toGroqParams(terms: string[]): Record<string, string> {
-  const params: Record<string, string> = {}
-  return terms.reduce((acc, term, i) => {
-    acc[`t${i}`] = `*${term}*` // "t" is short for term
-    return acc
-  }, params)
-}
-
-/**
- * Convert a string into an array of tokenized terms.
- *
- * Any (multi word) text wrapped in double quotes will be treated as "phrases", or separate tokens that
- * will not have its special characters removed.
- * E.g.`"the" "fantastic mr" fox fox book` =\> ["the", `"fantastic mr"`, "fox", "book"]
- *
- * Phrases wrapped in quotes are assigned relevance scoring differently from regular words.
- *
- * @internal
- */
-function extractTermsFromQuery(query: string): string[] {
-  const quotedQueries = [] as string[]
-  const unquotedQuery = query.replace(/("[^"]*")/g, (match) => {
-    if (words(match).length > 1) {
-      quotedQueries.push(match)
-      return ''
-    }
-    return match
-  })
-
-  // Lowercase and trim quoted queries
-  const quotedTerms = quotedQueries.map((str) => trim(toLower(str)))
-
-  /**
-   * Convert (remaining) search query into an array of deduped, sanitized tokens.
-   * All white space and special characters are removed.
-   * e.g. "The saint of Saint-Germain-des-Prés" =\> ['the', 'saint', 'of', 'germain', 'des', 'pres']
-   */
-  const remainingTerms = uniq(compact(tokenize(toLower(unquotedQuery))))
-
-  return [...quotedTerms, ...remainingTerms]
-}
-
-/**
- * Create GROQ constraints, given search terms and the full spec of available document types and fields.
- * Essentially a large list of all possible fields (joined by logical OR) to match our search terms against.
- */
-function createConstraints(terms: string[], includeAssetId: boolean) {
-  const searchPaths = includeAssetId ? ['filename', 'assetId'] : ['filename']
-  const constraints = terms
-    .map((_term, i) => searchPaths.map((joinedPath) => `${joinedPath} match $t${i}`))
-    .filter((constraint) => constraint.length > 0)
-
-  return constraints.map((constraint) => `(${constraint.join(' || ')})`)
-}
-
-export function createSearchFilter(query: string) {
-  const terms = extractTermsFromQuery(query)
-
-  return {
-    filter: createConstraints(terms, query.length >= 8), // if the search is big enough, include the assetId (mux id) in the results
-    params: {
-      ...toGroqParams(terms),
-    },
-  }
-}

package/src/util/createUrlParamsObject.ts

@@ -1,29 +0,0 @@
-import type {SanityClient} from 'sanity'
-
-import {getPlaybackId} from '../util/getPlaybackPolicy'
-import {type Audience, generateJwt} from './generateJwt'
-import {getPlaybackPolicyById} from './getPlaybackPolicy'
-import type {AssetThumbnailOptions} from './types'
-
-/**
- * May throw a Promise. Call this with {@link tryWithSuspend} or rethrow the Promise
- */
-export function createUrlParamsObject(
-  client: SanityClient,
-  asset: AssetThumbnailOptions['asset'],
-  params: object,
-  audience: Audience,
-) {
-  const playbackId = getPlaybackId(asset)
-
-  let searchParams = new URLSearchParams(
-    JSON.parse(JSON.stringify(params, (_, v) => v ?? undefined)),
-  )
-  const playbackPolicy = getPlaybackPolicyById(asset, playbackId)?.policy
-  if (playbackPolicy === 'signed' || playbackPolicy === 'drm') {
-    const token = generateJwt(client, playbackId, audience, params)
-    searchParams = new URLSearchParams({token})
-  }
-
-  return {playbackId, searchParams}
-}

package/src/util/extractFiles.ts

@@ -1,67 +0,0 @@
-/**
- * Utilities for extracting files from dataTransfer in a predictable cross-browser fashion.
- * Also recursively extracts files from a directory
- * Inspired by https://github.com/component/normalized-upload
- */
-
-export function extractDroppedFiles(dataTransfer: DataTransfer) {
-  const files = Array.from(dataTransfer.files || [])
-  const items = Array.from(dataTransfer.items || [])
-  if (files && files.length > 0) {
-    return Promise.resolve(files)
-  }
-  return normalizeItems(items).then((arr) => arr.flat())
-}
-
-function normalizeItems(items: DataTransferItem[]) {
-  return Promise.all(
-    items.map((item) => {
-      // directory
-      if (item.kind === 'file' && item.webkitGetAsEntry) {
-        let entry: FileSystemEntry | File[] | null
-        // Edge throws
-        try {
-          entry = item.webkitGetAsEntry()
-        } catch {
-          return [item.getAsFile()]
-        }
-        if (!entry) {
-          return []
-        }
-        return entry.isDirectory ? walk(entry) : [item.getAsFile()]
-      }
-
-      // file
-      if (item.kind === 'file') {
-        const file = item.getAsFile()
-        return Promise.resolve(file ? [file] : [])
-      }
-
-      // others
-      return new Promise((resolve) => item.getAsString(resolve)).then((str?: any) =>
-        str ? [new File([str], 'unknown.txt', {type: item.type})] : [],
-      )
-    }),
-  )
-}
-
-function isFile(entry: FileSystemEntry): entry is FileSystemFileEntry {
-  return entry.isFile
-}
-function isDirectory(entry: FileSystemEntry): entry is FileSystemDirectoryEntry {
-  return entry.isDirectory
-}
-
-function walk(entry: FileSystemEntry): any {
-  if (isFile(entry)) {
-    return new Promise((resolve) => entry.file(resolve)).then((file) => [file])
-  }
-
-  if (isDirectory(entry)) {
-    const dir = entry.createReader()
-    return new Promise<any>((resolve) => dir.readEntries(resolve))
-      .then((entries: FileSystemEntry[]) => entries.filter((entr) => !entr.name.startsWith('.')))
-      .then((entries) => Promise.all(entries.map(walk)).then((arr) => arr.flat()))
-  }
-  return Promise.resolve([])
-}

package/src/util/formatBytes.ts

@@ -1,31 +0,0 @@
-// From: https://stackoverflow.com/questions/10420352/converting-file-size-in-bytes-to-human-readable-string
-/**
- * Format bytes as human-readable text.
- *
- * @param bytes Number of bytes.
- * @param si True to use metric (SI) units, aka powers of 1000. False to use
- *           binary (IEC), aka powers of 1024.
- * @param dp Number of decimal places to display.
- *
- * @return Formatted string.
- */
-export default function formatBytes(bytes: number, si = false, dp = 1) {
-  const thresh = si ? 1000 : 1024
-
-  if (Math.abs(bytes) < thresh) {
-    return bytes + ' B'
-  }
-
-  const units = si
-    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB']
-  let u = -1
-  const r = 10 ** dp
-
-  do {
-    bytes /= thresh
-    ++u
-  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1)
-
-  return bytes.toFixed(dp) + ' ' + units[u]
-}

package/src/util/formatDriveShareLink.ts

@@ -1,64 +0,0 @@
-/**
- * Format Google Drive share links as Google Drive export links.
- * Supported formats:
- *  - https://drive.google.com/uc?id=<ID>...
- *  - https://drive.google.com/open?id=<ID>...
- *  - https://drive.google.com/file/d/<ID>...
- *  - https://drive.google.com/folder/<ID>...
- *
- * @param url Google Drive share link to format.
- * @returns Google Drive export link (URL passthrough if not share link).
- */
-export function formatDriveShareLink(url: string): string {
-  // Export link formatter.
-  const formatExportLink = (id: string) => {
-    return `https://drive.google.com/uc?export=download&id=${id}`
-  }
-
-  // URL formatting.
-  try {
-    // Parse URL.
-    const trimmed = url.trim()
-    const parsed = new URL(trimmed)
-
-    // Enforce strict host name.
-    if (parsed.hostname !== 'drive.google.com') {
-      throw new Error('URL is not from Google Drive.')
-    }
-
-    // Look for ID in search parameters.
-    const id = parsed.searchParams.get('id') || ''
-    if (id.length) {
-      return formatExportLink(id)
-    }
-
-    // Look for ID in path name.
-    const path = parsed.pathname.split('/') || []
-
-    // Path is /file/d/<ID>...
-    if (path.includes('file') && path.includes('d')) {
-      const index =
-        path.findIndex((value: string) => {
-          return value === 'd'
-        }) + 1
-      const fileId = path.at(index) || ''
-      return formatExportLink(fileId)
-    }
-
-    // Path is /folder/<ID>...
-    if (path.includes('folders')) {
-      const index =
-        path.findIndex((value: string) => {
-          return value === 'folders'
-        }) + 1
-      const folderId = path.at(index) || ''
-      return formatExportLink(folderId)
-    }
-
-    // URL not recognized.
-    throw new Error('URL was not recognized.')
-  } catch {
-    // URL passthrough by default.
-    return url
-  }
-}

package/src/util/formatSeconds.ts

@@ -1,48 +0,0 @@
-// From: https://stackoverflow.com/a/11486026/10433647
-export function formatSeconds(seconds: number): string {
-  if (typeof seconds !== 'number' || Number.isNaN(seconds)) {
-    return ''
-  }
-  // Hours, minutes and seconds
-  const hrs = ~~(seconds / 3600)
-  const mins = ~~((seconds % 3600) / 60)
-  const secs = ~~seconds % 60
-
-  // Output like "1:01" or "4:03:59" or "123:03:59"
-  let ret = ''
-
-  if (hrs > 0) {
-    ret += '' + hrs + ':' + (mins < 10 ? '0' : '')
-  }
-
-  ret += '' + mins + ':' + (secs < 10 ? '0' : '')
-  ret += '' + secs
-  return ret
-}
-
-// Output like "05:14:01"
-export function formatSecondsToHHMMSS(seconds: number): string {
-  const hrs = Math.floor(seconds / 3600)
-    .toString()
-    .padStart(2, '0')
-  const mins = Math.floor((seconds % 3600) / 60)
-    .toString()
-    .padStart(2, '0')
-  const secs = Math.floor(seconds % 60)
-    .toString()
-    .padStart(2, '0')
-
-  return `${hrs}:${mins}:${secs}`
-}
-
-// Checks if time has a HH:MM:SS format like "05:14:01"
-export function isValidTimeFormat(time: string) {
-  const regex = /^([0-1]?[0-9]|2[0-3]):([0-5]?[0-9]):([0-5]?[0-9])$/
-  return regex.test(time) || time === ''
-}
-
-// Converts a time like "05:14:01" to seconds
-export function getSecondsFromTimeFormat(time: string): number {
-  const [hh = 0, mm = 0, ss = 0] = time.split(':').map(Number)
-  return hh * 3600 + mm * 60 + ss
-}

package/src/util/generateJwt.ts

@@ -1,57 +0,0 @@
-import type {SanityClient} from 'sanity'
-import {suspend} from 'suspend-react'
-
-import {readSecrets} from './readSecrets'
-import type {AnimatedThumbnailOptions, ThumbnailOptions} from './types'
-
-export type Audience = 'g' | 's' | 't' | 'v' | 'd'
-
-export type Payload<T extends Audience> = T extends 'g'
-  ? AnimatedThumbnailOptions
-  : T extends 's'
-    ? never
-    : T extends 't'
-      ? ThumbnailOptions
-      : T extends 'v'
-        ? never
-        : T extends 'd'
-          ? never
-          : never
-
-/**
- * Uses suspend. Call this with {@link tryWithSuspend} or rethrow the Promise
- */
-export function generateJwt<T extends Audience>(
-  client: SanityClient,
-  playbackId: string,
-  aud: T,
-  payload?: Payload<T>,
-): string {
-  const {signingKeyId, signingKeyPrivate} = readSecrets(client)
-  if (!signingKeyId) {
-    throw new TypeError("Missing `signingKeyId`.\n Check your plugin's configuration")
-  }
-  if (!signingKeyPrivate) {
-    throw new TypeError("Missing `signingKeyPrivate`.\n Check your plugin's configuration")
-  }
-
-  /* Using suspend means we need to use Suspense on parent components.
-  Also, this will throw a Promise under the hood (apparently common in React), 
-  so if we want to catch errors we have to take this into account in catch blocks
-  and rethrow promises. */
-  // @ts-expect-error - handle missing typings for this package
-  const {default: sign} = suspend(() => import('jsonwebtoken-esm/sign'), ['jsonwebtoken-esm/sign'])
-
-  return sign(
-    payload ? JSON.parse(JSON.stringify(payload, (_, v) => v ?? undefined)) : {},
-    atob(signingKeyPrivate),
-    {
-      algorithm: 'RS256',
-      keyid: signingKeyId,
-      audience: aud,
-      subject: playbackId,
-      noTimestamp: true,
-      expiresIn: '12h',
-    },
-  )
-}

package/src/util/getAnimatedPosterSrc.ts

@@ -1,26 +0,0 @@
-import type {SanityClient} from 'sanity'
-
-import {createUrlParamsObject} from './createUrlParamsObject'
-import type {AnimatedThumbnailOptions, MuxAnimatedThumbnailUrl} from './types'
-import {type AssetThumbnailOptions} from './types'
-
-export interface AnimatedPosterSrcOptions extends AnimatedThumbnailOptions {
-  asset: AssetThumbnailOptions['asset']
-  client: SanityClient
-}
-
-export function getAnimatedPosterSrc({
-  asset,
-  client,
-  height,
-  width,
-  start = asset.thumbTime ? Math.max(0, asset.thumbTime - 2.5) : 0,
-  end = start + 5,
-  fps = 15,
-}: AnimatedPosterSrcOptions): MuxAnimatedThumbnailUrl {
-  const params = {height, width, start, end, fps}
-
-  const {playbackId, searchParams} = createUrlParamsObject(client, asset, params, 'g')
-
-  return `https://image.mux.com/${playbackId}/animated.gif?${searchParams}`
-}

package/src/util/getPlaybackPolicy.ts

@@ -1,69 +0,0 @@
-import type {
-  AdvancedPlaybackPolicy,
-  MuxPlaybackId,
-  PlaybackPolicy,
-  VideoAssetDocument,
-} from './types'
-
-/* - Returns the playback id of the asset based on the specified priority.
-  By default chooses the "strongest" policy
-   - Otherwise, returns the first playback id in the array.
-   */
-export function getPlaybackId(
-  asset: Pick<VideoAssetDocument, 'data'>,
-  priority: string[] = ['drm', 'signed', 'public'],
-): string {
-  try {
-    if (!asset) {
-      throw new TypeError('Tried to get playback Id with no asset')
-    }
-
-    const playbackIds = asset.data?.playback_ids
-    if (playbackIds && playbackIds.length > 0) {
-      for (const policy of priority) {
-        const match = playbackIds.find((entry) => entry.policy === policy)
-        if (match) {
-          return match.id
-        }
-      }
-
-      return playbackIds[0]!.id
-    }
-
-    throw new TypeError('Missing playbackId')
-  } catch (e) {
-    console.error('Asset is missing a playbackId', {asset}, e)
-    throw e
-  }
-}
-
-export function getPlaybackPolicy(
-  asset: Pick<VideoAssetDocument, 'data' | 'playbackId'>,
-): MuxPlaybackId | undefined {
-  return (
-    asset.data?.playback_ids?.find(
-      (playbackId) => getPlaybackId(asset, ['drm', 'signed', 'public']) === playbackId.id,
-    ) ?? {id: '', policy: 'public'}
-  )
-}
-
-export function getPlaybackPolicyById(
-  asset: Pick<VideoAssetDocument, 'data'>,
-  playbackId: string,
-): MuxPlaybackId | undefined {
-  return asset.data?.playback_ids?.find((entry) => playbackId === entry.id)
-}
-
-export function hasPlaybackPolicy(
-  data: Partial<{
-    playback_policy?: PlaybackPolicy[]
-    advanced_playback_policies: AdvancedPlaybackPolicy[]
-  }>,
-  policy: PlaybackPolicy,
-) {
-  return (
-    (data.advanced_playback_policies &&
-      data.advanced_playback_policies.find((p) => p.policy === policy)) ||
-    data.playback_policy?.find((p) => p === policy)
-  )
-}

package/src/util/getPosterSrc.ts

@@ -1,28 +0,0 @@
-import type {SanityClient} from 'sanity'
-
-import {createUrlParamsObject} from './createUrlParamsObject'
-import type {MuxThumbnailUrl, ThumbnailOptions} from './types'
-import {type AssetThumbnailOptions} from './types'
-
-export interface PosterSrcOptions extends ThumbnailOptions {
-  asset: AssetThumbnailOptions['asset']
-  client: SanityClient
-}
-
-export function getPosterSrc({
-  asset,
-  client,
-  fit_mode,
-  height,
-  time = asset.thumbTime ?? undefined,
-  width,
-}: PosterSrcOptions): MuxThumbnailUrl {
-  const params = {fit_mode, height, width}
-  if (time !== undefined) {
-    ;(params as any).time = time
-  }
-
-  const {playbackId, searchParams} = createUrlParamsObject(client, asset, params, 't')
-
-  return `https://image.mux.com/${playbackId}/thumbnail.png?${searchParams}`
-}

package/src/util/getVideoMetadata.ts

@@ -1,23 +0,0 @@
-import {formatSeconds} from './formatSeconds'
-import type {MuxTextTrack, VideoAssetDocument} from './types'
-
-export default function getVideoMetadata(doc: VideoAssetDocument) {
-  const id = doc.assetId || doc._id || ''
-  const date = doc.data?.created_at
-    ? new Date(Number(doc.data.created_at) * 1000)
-    : new Date(doc._createdAt || doc._updatedAt || Date.now())
-
-  return {
-    title: doc.filename || id.slice(0, 12),
-    id: id,
-    playbackId: doc.playbackId,
-    createdAt: date,
-    duration: doc.data?.duration ? formatSeconds(doc.data?.duration) : undefined,
-    playback_ids: doc.data?.playback_ids,
-    aspect_ratio: doc.data?.aspect_ratio,
-    max_stored_resolution: doc.data?.max_stored_resolution,
-    max_stored_frame_rate: doc.data?.max_stored_frame_rate,
-    text_tracks:
-      doc.data?.tracks?.filter((track): track is MuxTextTrack => track.type === 'text') || [],
-  }
-}