sanity-plugin-media 4.1.1 → 4.2.0

package/src/utils/isSupportedAssetType.test.ts

@@ -0,0 +1,15 @@
+import {describe, expect, it} from 'vitest'
+import {isSupportedAssetType} from './isSupportedAssetType'
+
+describe('isSupportedAssetType', () => {
+  it('returns true for file and image', () => {
+    expect(isSupportedAssetType('file')).toBe(true)
+    expect(isSupportedAssetType('image')).toBe(true)
+  })
+
+  it('returns false for unsupported or missing types', () => {
+    expect(isSupportedAssetType('video')).toBe(false)
+    expect(isSupportedAssetType('')).toBe(false)
+    expect(isSupportedAssetType(undefined)).toBe(false)
+  })
+})

package/src/utils/sanitizeFormData.test.ts

@@ -0,0 +1,58 @@
+// @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/typeGuards.test.ts

@@ -0,0 +1,17 @@
+import {describe, expect, it} from 'vitest'
+import {isFileAsset, isImageAsset} from './typeGuards'
+import type {Asset} from '../types'
+
+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/uploadSanityAsset.test.ts

@@ -0,0 +1,28 @@
+import {afterEach, describe, expect, it} from 'vitest'
+import {firstValueFrom} from 'rxjs'
+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/withMaxConcurrency.test.ts

@@ -0,0 +1,42 @@
+import {describe, expect, it} from 'vitest'
+import {Observable, firstValueFrom} from 'rxjs'
+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)
+  })
+})