sanity-plugin-media 4.1.0 → 4.2.0

package/src/utils/getDocumentAssetIds.test.ts

@@ -0,0 +1,49 @@
+// @vitest-environment node
+
+import {describe, expect, it} from 'vitest'
+import getDocumentAssetIds from './getDocumentAssetIds'
+
+describe('getDocumentAssetIds', () => {
+  it('returns empty array for document without asset refs', () => {
+    expect(getDocumentAssetIds({_id: 'doc1', _type: 'post'} as any)).toEqual([])
+  })
+
+  it('collects asset _ref from nested portable text–like structures', () => {
+    const doc = {
+      _id: 'doc1',
+      _type: 'post',
+      body: [
+        {
+          _type: 'block',
+          asset: {_type: 'reference', _ref: 'image-asset-1'}
+        }
+      ]
+    } as any
+
+    expect(getDocumentAssetIds(doc)).toEqual(['image-asset-1'])
+  })
+
+  it('dedupes and sorts refs', () => {
+    const doc = {
+      _id: 'doc1',
+      _type: 'post',
+      modules: [
+        {image: {asset: {_type: 'reference', _ref: 'b'}}},
+        {image: {asset: {_type: 'reference', _ref: 'a'}}},
+        {image: {asset: {_type: 'reference', _ref: 'b'}}}
+      ]
+    } as any
+
+    expect(getDocumentAssetIds(doc)).toEqual(['a', 'b'])
+  })
+
+  it('ignores reference nodes that are not asset references', () => {
+    const doc = {
+      _id: 'doc1',
+      _type: 'post',
+      author: {_type: 'reference', _ref: 'person-1'}
+    } as any
+
+    expect(getDocumentAssetIds(doc)).toEqual([])
+  })
+})

package/src/utils/getSchemeColor.test.ts

@@ -0,0 +1,11 @@
+import {describe, expect, it} from 'vitest'
+import {getSchemeColor} from './getSchemeColor'
+
+describe('getSchemeColor', () => {
+  it('returns a hex or theme string for light and dark schemes', () => {
+    expect(getSchemeColor('light', 'bg')).toMatch(/^#/)
+    expect(getSchemeColor('dark', 'bg')).toMatch(/^#/)
+    expect(getSchemeColor('light', 'spotBlue')).toBeTruthy()
+    expect(getSchemeColor('dark', 'inputEnabledBorder')).toBeTruthy()
+  })
+})

package/src/utils/getTagSelectOptions.test.ts

@@ -0,0 +1,43 @@
+import {describe, expect, it} from 'vitest'
+import getTagSelectOptions from './getTagSelectOptions'
+import type {Tag, TagItem} from '../types'
+
+function tagItem(partial: Partial<TagItem> & Pick<TagItem, 'tag'>): TagItem {
+  return {
+    _type: 'tag',
+    picked: false,
+    updating: false,
+    ...partial
+  }
+}
+
+const makeTag = (id: string, name: string): Tag => ({
+  _id: id,
+  _type: 'media.tag',
+  _createdAt: '',
+  _updatedAt: '',
+  _rev: 'r1',
+  name: {_type: 'slug', current: name}
+})
+
+describe('getTagSelectOptions', () => {
+  it('maps tag items to label/value options', () => {
+    const tags = [tagItem({tag: makeTag('t1', 'alpha')}), tagItem({tag: makeTag('t2', 'beta')})]
+    expect(getTagSelectOptions(tags)).toEqual([
+      {label: 'alpha', value: 't1'},
+      {label: 'beta', value: 't2'}
+    ])
+  })
+
+  it('returns an empty array for an empty list', () => {
+    expect(getTagSelectOptions([])).toEqual([])
+  })
+
+  it('skips items without a tag', () => {
+    const tags = [
+      tagItem({tag: makeTag('t1', 'ok')}),
+      {_type: 'tag', tag: undefined, picked: false, updating: false} as unknown as TagItem
+    ]
+    expect(getTagSelectOptions(tags)).toEqual([{label: 'ok', value: 't1'}])
+  })
+})

package/src/utils/getUniqueDocuments.test.ts

@@ -0,0 +1,25 @@
+import {describe, expect, it} from 'vitest'
+import type {SanityDocument} from '@sanity/client'
+import {getUniqueDocuments} from './getUniqueDocuments'
+
+describe('getUniqueDocuments', () => {
+  it('drops published documents when a drafts.* sibling exists', () => {
+    const docs: SanityDocument[] = [
+      {_id: 'drafts.post1', _type: 'post'} as SanityDocument,
+      {_id: 'post1', _type: 'post'} as SanityDocument
+    ]
+    expect(getUniqueDocuments(docs)).toEqual([{_id: 'drafts.post1', _type: 'post'}])
+  })
+
+  it('keeps published-only and draft-only ids', () => {
+    const docs: SanityDocument[] = [
+      {_id: 'onlyPub', _type: 'x'} as SanityDocument,
+      {_id: 'drafts.onlyDraft', _type: 'x'} as SanityDocument
+    ]
+    expect(getUniqueDocuments(docs)).toEqual(docs)
+  })
+
+  it('returns an empty array for an empty list', () => {
+    expect(getUniqueDocuments([])).toEqual([])
+  })
+})

package/src/utils/imageDprUrl.test.ts

@@ -0,0 +1,45 @@
+import {afterEach, describe, expect, it} from 'vitest'
+import imageDprUrl from './imageDprUrl'
+import type {ImageAsset} from '../types'
+
+const asset = {
+  _id: 'a1',
+  _type: 'sanity.imageAsset',
+  _createdAt: '',
+  _updatedAt: '',
+  _rev: 'r1',
+  originalFilename: 'x.png',
+  size: 1,
+  mimeType: 'image/png',
+  url: 'https://cdn.test/image.png',
+  metadata: {dimensions: {width: 100, height: 100}, isOpaque: true}
+} as ImageAsset
+
+describe('imageDprUrl', () => {
+  const dpr = window.devicePixelRatio
+
+  afterEach(() => {
+    Object.defineProperty(window, 'devicePixelRatio', {value: dpr, configurable: true})
+  })
+
+  it('scales width by devicePixelRatio and sets fit=max', () => {
+    Object.defineProperty(window, 'devicePixelRatio', {value: 2, configurable: true})
+    const url = imageDprUrl(asset, {width: 400})
+    expect(url).toBe('https://cdn.test/image.png?fit=max&w=800')
+  })
+
+  it('includes height when provided, scaled by dpr', () => {
+    Object.defineProperty(window, 'devicePixelRatio', {value: 2, configurable: true})
+    const url = imageDprUrl(asset, {width: 300, height: 200})
+    expect(url).toBe('https://cdn.test/image.png?fit=max&w=600&h=400')
+  })
+
+  it('uses multiplier 1 when devicePixelRatio is missing', () => {
+    Object.defineProperty(window, 'devicePixelRatio', {
+      value: undefined as unknown as number,
+      configurable: true
+    })
+    const url = imageDprUrl(asset, {width: 100})
+    expect(url).toBe('https://cdn.test/image.png?fit=max&w=100')
+  })
+})

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/isSupportedAssetType.ts

@@ -0,0 +1,15 @@
+import {SUPPORTED_ASSET_TYPES} from '../constants'
+import type {AssetType} from '../types'
+
+/**
+ * Determines whether or not the provided asset type (eg 'image', 'file', 'arbitrary')
+ * is a supported asset type for this plugin.
+ *
+ * @param assetType - The asset type to check.
+ * @returns True if the asset type is supported, false otherwise.
+ * @internal
+ */
+export function isSupportedAssetType(assetType?: string): assetType is AssetType {
+  const supported: string[] = SUPPORTED_ASSET_TYPES
+  return assetType ? supported.includes(assetType) : 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)
+  })
+})