sanity-plugin-media 4.3.5 → 5.0.0

package/src/utils/sanitizeFormData.test.ts

@@ -1,59 +0,0 @@
-// @vitest-environment node
-
-import {describe, expect, it} from 'vitest'
-
-import sanitizeFormData from './sanitizeFormData'
-
-describe('sanitizeFormData', () => {
-  it('maps empty string, undefined, and empty array to null', () => {
-    expect(
-      sanitizeFormData({
-        a: '',
-        b: undefined,
-        c: [],
-      }),
-    ).toEqual({
-      a: null,
-      b: null,
-      c: null,
-    })
-  })
-
-  it('trims non-empty strings', () => {
-    expect(sanitizeFormData({title: '  hello  '})).toEqual({title: 'hello'})
-  })
-
-  it('recurses into plain objects', () => {
-    expect(
-      sanitizeFormData({
-        opt: {
-          media: {
-            tags: [],
-          },
-        },
-      }),
-    ).toEqual({
-      opt: {
-        media: {
-          tags: null,
-        },
-      },
-    })
-  })
-
-  it('preserves null and non-empty arrays', () => {
-    expect(
-      sanitizeFormData({
-        kept: null,
-        tags: [{_ref: 't1'}],
-      }),
-    ).toEqual({
-      kept: null,
-      tags: [{_ref: 't1'}],
-    })
-  })
-
-  it('preserves numbers and booleans', () => {
-    expect(sanitizeFormData({n: 0, ok: false})).toEqual({n: 0, ok: false})
-  })
-})

package/src/utils/sanitizeFormData.ts

@@ -1,26 +0,0 @@
-// Recursively sanitize form data:
-// - convert empty strings, undefined values and empty arrays to null (to correctly unset / delete fields)
-// - trim whitespace on string fleids
-
-type FormData = Record<string, any>
-
-const sanitizeFormData = (formData: FormData): FormData => {
-  return Object.keys(formData).reduce((acc: FormData, key) => {
-    const val = formData[key]
-
-    // TODO: refactor
-    if (typeof val === 'object' && val !== null && val.constructor !== Array) {
-      acc[key] = sanitizeFormData(val)
-    } else if (val === '' || typeof val === 'undefined' || val?.length === 0) {
-      acc[key] = null
-    } else if (typeof val === 'string' && val) {
-      acc[key] = formData[key].trim()
-    } else {
-      acc[key] = formData[key]
-    }
-
-    return acc
-  }, {})
-}
-
-export default sanitizeFormData

package/src/utils/typeGuards.test.ts

@@ -1,18 +0,0 @@
-import {describe, expect, it} from 'vitest'
-
-import type {Asset} from '../types'
-import {isFileAsset, isImageAsset} from './typeGuards'
-
-describe('typeGuards', () => {
-  it('isFileAsset narrows sanity.fileAsset', () => {
-    const file = {_type: 'sanity.fileAsset'} as Asset
-    expect(isFileAsset(file)).toBe(true)
-    expect(isImageAsset(file)).toBe(false)
-  })
-
-  it('isImageAsset narrows sanity.imageAsset', () => {
-    const image = {_type: 'sanity.imageAsset'} as Asset
-    expect(isImageAsset(image)).toBe(true)
-    expect(isFileAsset(image)).toBe(false)
-  })
-})

package/src/utils/typeGuards.ts

@@ -1,9 +0,0 @@
-import type {Asset, FileAsset, ImageAsset} from '../types'
-
-export const isFileAsset = (asset: Asset): asset is FileAsset => {
-  return (asset as FileAsset)._type === 'sanity.fileAsset'
-}
-
-export const isImageAsset = (asset: Asset): asset is ImageAsset => {
-  return (asset as ImageAsset)._type === 'sanity.imageAsset'
-}

package/src/utils/uploadSanityAsset.test.ts

@@ -1,29 +0,0 @@
-import {firstValueFrom} from 'rxjs'
-import {afterEach, describe, expect, it} from 'vitest'
-
-import {hashFile$} from './uploadSanityAsset'
-
-describe('hashFile$', () => {
-  const cryptoRef = globalThis.crypto
-
-  afterEach(() => {
-    Object.defineProperty(globalThis, 'crypto', {
-      value: cryptoRef,
-      configurable: true,
-      writable: true,
-    })
-  })
-
-  it('errors when Web Crypto is unavailable', async () => {
-    Object.defineProperty(globalThis, 'crypto', {
-      value: undefined,
-      configurable: true,
-      writable: true,
-    })
-
-    await expect(firstValueFrom(hashFile$(new File(['x'], 'blob.bin')))).rejects.toMatchObject({
-      message: expect.stringMatching(/secure contexts/i),
-      statusCode: 500,
-    })
-  })
-})

package/src/utils/uploadSanityAsset.ts

@@ -1,97 +0,0 @@
-// Sourced from:
-// https://github.com/sanity-io/sanity/blob/ccb777e115a8cdf20d81a9a2bc9d8c228568faff/packages/%40sanity/form-builder/src/sanity/inputs/client-adapters/assets.ts
-
-import type {SanityAssetDocument, SanityClient, SanityImageAssetDocument} from '@sanity/client'
-import {Observable, of, throwError} from 'rxjs'
-import {map, mergeMap} from 'rxjs/operators'
-
-import type {HttpError} from '../types'
-import {withMaxConcurrency} from './withMaxConcurrency'
-
-const fetchExisting$ = (client: SanityClient, type: string, hash: string) => {
-  return client.observable.fetch('*[_type == $documentType && sha1hash == $hash][0]', {
-    documentType: type,
-    hash,
-  })
-}
-
-const readFile$ = (file: File): Observable<ArrayBuffer> => {
-  return new Observable((subscriber) => {
-    const reader = new FileReader()
-    reader.onload = () => {
-      subscriber.next(reader.result as ArrayBuffer)
-      subscriber.complete()
-    }
-    reader.onerror = (err) => {
-      subscriber.error(err)
-    }
-    reader.readAsArrayBuffer(file)
-    return () => {
-      reader.abort()
-    }
-  })
-}
-
-const hexFromBuffer = (buffer: ArrayBuffer): string => {
-  return Array.prototype.map
-    .call(new Uint8Array(buffer), (x) => `00${x.toString(16)}`.slice(-2))
-    .join('')
-}
-
-export const hashFile$ = (file: File): Observable<string> => {
-  if (!window.crypto || !window.crypto.subtle || !window.FileReader) {
-    return throwError({
-      message: 'Unable to generate hash: uploads are only allowed in secure contexts',
-      statusCode: 500,
-    })
-  }
-  return readFile$(file).pipe(
-    mergeMap((arrayBuffer) => window.crypto.subtle.digest('SHA-1', arrayBuffer)),
-    map(hexFromBuffer),
-  )
-}
-
-const uploadSanityAsset$ = (
-  client: SanityClient,
-  assetType: 'file' | 'image',
-  file: File,
-  hash: string,
-) => {
-  return of(null).pipe(
-    // NOTE: the sanity api will still dedupe unique files, but this saves us from uploading the asset file entirely
-    mergeMap(() => fetchExisting$(client, `sanity.${assetType}Asset`, hash)),
-    // Cancel if the asset already exists
-    mergeMap((existingAsset: SanityAssetDocument | SanityImageAssetDocument | null) => {
-      if (existingAsset) {
-        return throwError({
-          message: 'Asset already exists',
-          statusCode: 409,
-        } as HttpError)
-      }
-
-      return of(null)
-    }),
-    mergeMap(() => {
-      // Begin upload if no existing asset found
-      return client.observable.assets
-        .upload(assetType, file, {
-          extract: ['blurhash', 'exif', 'location', 'lqip', 'palette'],
-          preserveFilename: true,
-        })
-        .pipe(
-          map((event) =>
-            event.type === 'response'
-              ? {
-                  // rewrite to a 'complete' event
-                  asset: event.body.document,
-                  id: event.body.document._id,
-                  type: 'complete',
-                }
-              : event,
-          ),
-        )
-    }),
-  )
-}
-
-export const uploadAsset$ = withMaxConcurrency(uploadSanityAsset$)

package/src/utils/withMaxConcurrency.test.ts

@@ -1,43 +0,0 @@
-import {Observable, firstValueFrom} from 'rxjs'
-import {describe, expect, it} from 'vitest'
-
-import {createThrottler, withMaxConcurrency} from './withMaxConcurrency'
-
-describe('createThrottler', () => {
-  it('never runs more observables concurrently than the limit', async () => {
-    let active = 0
-    let maxActive = 0
-    const request = createThrottler(2)
-
-    const mk = () =>
-      new Observable<number>((sub) => {
-        active++
-        maxActive = Math.max(maxActive, active)
-        queueMicrotask(() => {
-          active--
-          sub.next(1)
-          sub.complete()
-        })
-      })
-
-    await Promise.all([
-      firstValueFrom(request(mk())),
-      firstValueFrom(request(mk())),
-      firstValueFrom(request(mk())),
-    ])
-
-    expect(maxActive).toBe(2)
-  })
-})
-
-describe('withMaxConcurrency', () => {
-  it('wraps a function so each call returns a single-value observable', async () => {
-    const fn = (n: number) =>
-      new Observable<number>((sub) => {
-        sub.next(n)
-        sub.complete()
-      })
-    const wrapped = withMaxConcurrency(fn, 4)
-    await expect(firstValueFrom(wrapped(7))).resolves.toBe(7)
-  })
-})

package/src/utils/withMaxConcurrency.ts

@@ -1,55 +0,0 @@
-import {Subject, Subscription, Observable, from} from 'rxjs'
-// Takes a observable-returning function and returns a new function that limits on the number of
-// concurrent observables.
-import {first, mergeMap} from 'rxjs/operators'
-
-const DEFAULT_CONCURRENCY = 4
-
-function remove<T>(array: Array<T>, item: T): Array<T> {
-  const index = array.indexOf(item)
-  if (index > -1) {
-    array.splice(index, 1)
-  }
-  return array
-}
-
-export const createThrottler = (concurrency: number = DEFAULT_CONCURRENCY) => {
-  const currentSubscriptions: Array<Subscription> = []
-  const pendingObservables: Array<Observable<any>> = []
-  const ready$ = new Subject()
-
-  function request(observable: Observable<any>): Observable<any> {
-    return new Observable((observer) => {
-      if (currentSubscriptions.length >= concurrency) {
-        return scheduleAndWait$(observable)
-          .pipe(mergeMap(request)) //
-          .subscribe(observer)
-      }
-      const subscription = observable.subscribe(observer)
-      currentSubscriptions.push(subscription)
-      return () => {
-        remove(currentSubscriptions, subscription)
-        remove(pendingObservables, observable)
-        subscription.unsubscribe()
-        while (pendingObservables.length > 0 && currentSubscriptions.length < concurrency) {
-          ready$.next(pendingObservables.shift())
-        }
-      }
-    })
-  }
-
-  function scheduleAndWait$(observable: Observable<any>): Observable<any> {
-    pendingObservables.push(observable)
-    return ready$.asObservable().pipe(first((obs) => obs === observable))
-  }
-
-  return request
-}
-
-export const withMaxConcurrency = (
-  func: (...args: any[]) => Observable<any>,
-  concurrency: number = DEFAULT_CONCURRENCY,
-) => {
-  const throttler = createThrottler(concurrency)
-  return (...args: Array<any>) => from(throttler(func(...args)))
-}

package/src/utils/zodFormResolver.ts

@@ -1,17 +0,0 @@
-import {zodResolver} from '@hookform/resolvers/zod'
-import type {FieldValues, Resolver} from 'react-hook-form'
-
-/**
- * `@hookform/resolvers/zod` resolves its own `zod` typings through dependency
- * hoisting, which in this monorepo lands on zod v4, while this plugin authors its
- * form schemas with zod v3. The resolver accepts v3 schema instances correctly at
- * runtime, so this thin wrapper only bridges the type-only v3/v4 mismatch. The
- * react-hook-form field types stay fully checked at the call sites.
- */
-export default function zodFormResolver<TFieldValues extends FieldValues>(
-  schema: unknown,
-): Resolver<TFieldValues> {
-  return zodResolver(
-    schema as Parameters<typeof zodResolver>[0],
-  ) as unknown as Resolver<TFieldValues>
-}

package/v2-incompatible.js

@@ -1,11 +0,0 @@
-const {showIncompatiblePluginDialog} = require('@sanity/incompatible-plugin')
-const {name, version} = require('./package.json')
-
-export default showIncompatiblePluginDialog({
-  name: name,
-  versions: {
-    v3: version,
-    v2: '^1.4.13',
-  },
-  sanityExchangeUrl: 'https://www.sanity.io/plugins/sanity-plugin-media',
-})