@sanity/sdk 2.7.0 → 2.9.0

package/src/preview/previewProjectionUtils.test.ts

@@ -0,0 +1,179 @@
+import {type SanityClient} from '@sanity/client'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {createSanityInstance} from '../store/createSanityInstance'
+import {normalizeMedia, transformProjectionToPreview} from './previewProjectionUtils'
+import {type PreviewQueryResult} from './types'
+
+// Mock the getClient function
+vi.mock('../client/clientStore', () => ({
+  getClient: vi.fn(),
+}))
+
+const mockClient = {
+  config: () => ({projectId: 'test-project', dataset: 'test-dataset'}),
+} as unknown as SanityClient
+
+describe('normalizeMedia', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks()
+  })
+
+  it('returns null if media is null or undefined', () => {
+    expect(normalizeMedia(null, mockClient)).toBeNull()
+    expect(normalizeMedia(undefined, mockClient)).toBeNull()
+  })
+
+  it('returns null if media does not have a valid asset', () => {
+    const invalidMedia1 = {media: {_ref: 'image-abc123-200x200-png'}} // Missing `asset` property
+    const invalidMedia2 = {asset: {ref: 'image-abc123-200x200-png'}} // Incorrect property name `ref`
+    expect(normalizeMedia(invalidMedia1, mockClient)).toBeNull()
+    expect(normalizeMedia(invalidMedia2, mockClient)).toBeNull()
+  })
+
+  it('returns null if media is not an object', () => {
+    expect(normalizeMedia(123, mockClient)).toBeNull()
+    expect(normalizeMedia('invalid', mockClient)).toBeNull()
+  })
+
+  it('returns a normalized URL for valid image asset objects', () => {
+    const validMedia = {type: 'image-asset', _ref: 'image-abc123-200x200-png'}
+    const result = normalizeMedia(validMedia, mockClient)
+    expect(result).toEqual({
+      type: 'image-asset',
+      _ref: 'image-abc123-200x200-png',
+      url: 'https://cdn.sanity.io/images/test-project/test-dataset/abc123-200x200.png',
+    })
+  })
+
+  it('handles image assets with expected URL format', () => {
+    const media = {type: 'image-asset', _ref: 'image-xyz456-400x400-jpg'}
+    const result = normalizeMedia(media, mockClient)
+    expect(result).toEqual({
+      type: 'image-asset',
+      _ref: 'image-xyz456-400x400-jpg',
+      url: 'https://cdn.sanity.io/images/test-project/test-dataset/xyz456-400x400.jpg',
+    })
+  })
+})
+
+describe('transformProjectionToPreview', () => {
+  const instance = createSanityInstance({
+    projectId: 'test-project',
+    dataset: 'test-dataset',
+  })
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+
+    // Mock getClient to return our mock client
+    const {getClient} = await import('../client/clientStore')
+    vi.mocked(getClient).mockReturnValue(mockClient)
+  })
+
+  it('transforms projection result with title and subtitle', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {description: 'My Description'},
+      media: null,
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: 'My Description',
+      media: null,
+    })
+  })
+
+  it('uses fallback title when no title candidates exist', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {},
+      subtitleCandidates: {},
+      media: null,
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result.title).toBe('article: doc1')
+    expect(result.subtitle).toBeUndefined()
+  })
+
+  it('transforms projection result with media', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: {type: 'image-asset', _ref: 'image-abc123-200x200-png', url: ''},
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: undefined,
+      media: {
+        type: 'image-asset',
+        _ref: 'image-abc123-200x200-png',
+        url: 'https://cdn.sanity.io/images/test-project/test-dataset/abc123-200x200.png',
+      },
+    })
+  })
+
+  it('includes status when provided', () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: null,
+      _status: {
+        lastEditedPublishedAt: '2026-01-01',
+        lastEditedDraftAt: '2026-01-02',
+      },
+    }
+
+    const result = transformProjectionToPreview(instance, projectionResult)
+
+    expect(result).toEqual({
+      title: 'My Title',
+      subtitle: undefined,
+      media: null,
+      _status: {
+        lastEditedPublishedAt: '2026-01-01',
+        lastEditedDraftAt: '2026-01-02',
+      },
+    })
+  })
+
+  it('calls getClient with the provided source', async () => {
+    const projectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2026-01-01',
+      titleCandidates: {title: 'My Title'},
+      subtitleCandidates: {},
+      media: null,
+    }
+
+    const source = {mediaLibraryId: 'test-library'}
+
+    transformProjectionToPreview(instance, projectionResult, source)
+
+    const {getClient} = await import('../client/clientStore')
+    expect(getClient).toHaveBeenCalledWith(instance, {
+      apiVersion: 'v2025-05-06',
+      source,
+    })
+  })
+})

package/src/preview/previewProjectionUtils.ts

@@ -0,0 +1,93 @@
+import {type SanityClient} from '@sanity/client'
+import {createImageUrlBuilder} from '@sanity/image-url'
+import {isObject} from 'lodash-es'
+
+import {getClient} from '../client/clientStore'
+import {type DocumentSource, isDatasetSource} from '../config/sanityConfig'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {SUBTITLE_CANDIDATES, TITLE_CANDIDATES} from './previewConstants'
+import {type PreviewQueryResult, type PreviewValue} from './types'
+
+const API_VERSION = 'v2025-05-06'
+
+/**
+ * Checks if the provided value has `_ref` property that is a string and starts with `image-`
+ */
+function hasImageRef<T>(value: unknown): value is T & {_ref: string} {
+  return isObject(value) && '_ref' in value && typeof (value as {_ref: unknown})._ref === 'string'
+}
+
+/**
+ * Normalizes a media asset to a preview value.
+ * Adds a url to a media asset reference using `@sanity/image-url`.
+ *
+ * @internal
+ */
+export function normalizeMedia(media: unknown, client: SanityClient): PreviewValue['media'] {
+  if (!media) return null
+  if (!hasImageRef(media)) return null
+
+  const builder = createImageUrlBuilder(client)
+  const url = builder.image({_ref: media._ref}).url()
+
+  return {
+    type: 'image-asset',
+    _ref: media._ref,
+    url,
+  }
+}
+
+/**
+ * Finds a single field value from a set of candidates based on a priority list of field names.
+ * Returns the first non-empty string value found from the candidates matching the priority list order.
+ *
+ * @internal
+ */
+function findFirstDefined(
+  fieldsToSearch: string[],
+  candidates: Record<string, unknown>,
+  exclude?: unknown,
+): string | undefined {
+  if (!candidates) return undefined
+
+  for (const field of fieldsToSearch) {
+    const value = candidates[field]
+    if (typeof value === 'string' && value.trim() !== '' && value !== exclude) {
+      return value
+    }
+  }
+
+  return undefined
+}
+
+/**
+ * Transforms a projection result (with titleCandidates, subtitleCandidates, media)
+ * into a PreviewValue (with title, subtitle, media).
+ *
+ * @param projectionResult - The raw projection result from GROQ
+ * @param instance - The Sanity instance to use for client configuration
+ * @param source - Data source for the preview
+ * @internal
+ */
+export function transformProjectionToPreview(
+  instance: SanityInstance,
+  projectionResult: PreviewQueryResult,
+  source?: DocumentSource,
+): PreviewValue {
+  const title = findFirstDefined(TITLE_CANDIDATES, projectionResult.titleCandidates)
+  const subtitle = findFirstDefined(SUBTITLE_CANDIDATES, projectionResult.subtitleCandidates, title)
+
+  // Get a client for the source (if provided) or use the instance config
+  const client = getClient(instance, {
+    apiVersion: API_VERSION,
+    // TODO: remove in v3 when we're ready for everything to be queried via source
+    source: source && !isDatasetSource(source) ? source : undefined,
+  })
+
+  return {
+    title: String(title || `${projectionResult._type}: ${projectionResult._id}`),
+    subtitle: subtitle || undefined,
+    media: normalizeMedia(projectionResult.media, client),
+    ...(projectionResult._status && {_status: projectionResult._status}),
+  }
+}

package/src/preview/resolvePreview.test.ts

@@ -1,28 +1,17 @@
-import {of} from 'rxjs'
-import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+import {beforeEach, describe, expect, it, vi} from 'vitest'
 
-import {createDocumentHandle} from '../config/handles'
+import {resolveProjection} from '../projection/resolveProjection'
+import {type ProjectionValuePending} from '../projection/types'
 import {createSanityInstance, type SanityInstance} from '../store/createSanityInstance'
-import {type StateSource} from '../store/createStateSourceAction'
-import {getPreviewState} from './getPreviewState'
-import {type PreviewValue, type ValuePending} from './previewStore'
 import {resolvePreview} from './resolvePreview'
+import {type PreviewQueryResult} from './types'
 
-vi.mock('./getPreviewState')
+vi.mock('../projection/resolveProjection')
 
 describe('resolvePreview', () => {
   let instance: SanityInstance
-
   beforeEach(() => {
-    vi.resetAllMocks()
-    // Create a mock that returns the correct ValuePending type
-    vi.mocked(getPreviewState).mockReturnValue({
-      observable: of({
-        data: {title: 'test'},
-        isPending: false,
-      } as ValuePending<PreviewValue>),
-    } as StateSource<ValuePending<PreviewValue>>)
-
+    vi.clearAllMocks()
     instance = createSanityInstance({projectId: 'p', dataset: 'd'})
   })
 
@@ -30,18 +19,46 @@ describe('resolvePreview', () => {
     instance.dispose()
   })
 
-  it('resolves a preview and returns the first emitted value with results', async () => {
-    const docHandle = createDocumentHandle({
-      documentId: 'doc123',
-      documentType: 'movie',
+  it('resolves and transforms projection result to preview format', async () => {
+    const mockProjectionResult: PreviewQueryResult = {
+      _id: 'doc1',
+      _type: 'article',
+      _updatedAt: '2024-01-01',
+      titleCandidates: {title: 'Resolved Title'},
+      subtitleCandidates: {description: 'Resolved Description'},
+      media: null,
+    }
+
+    vi.mocked(resolveProjection).mockResolvedValue({
+      data: mockProjectionResult,
+      isPending: false,
+    } as ProjectionValuePending<PreviewQueryResult>)
+
+    const result = await resolvePreview(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
     })
 
-    const result = await resolvePreview(instance, docHandle)
+    expect(result.data).toEqual({
+      title: 'Resolved Title',
+      subtitle: 'Resolved Description',
+      media: null,
+    })
+    expect(result.isPending).toBe(false)
+  })
 
-    expect(getPreviewState).toHaveBeenCalledWith(instance, docHandle)
-    expect(result).toEqual({
-      data: {title: 'test'},
+  it('returns null data when projection resolves with null', async () => {
+    vi.mocked(resolveProjection).mockResolvedValue({
+      data: null,
       isPending: false,
     })
+
+    const result = await resolvePreview(instance, {
+      documentId: 'doc1',
+      documentType: 'article',
+    })
+
+    expect(result.data).toBeNull()
+    expect(result.isPending).toBe(false)
   })
 })

package/src/preview/resolvePreview.ts

@@ -1,20 +1,39 @@
-import {filter, firstValueFrom} from 'rxjs'
-
 import {type DocumentHandle} from '../config/sanityConfig'
-import {bindActionByDataset} from '../store/createActionBinder'
-import {getPreviewState} from './getPreviewState'
-import {previewStore} from './previewStore'
+import {resolveProjection} from '../projection/resolveProjection'
+import {type SanityInstance} from '../store/createSanityInstance'
+import {PREVIEW_PROJECTION} from './previewConstants'
+import {transformProjectionToPreview} from './previewProjectionUtils'
+import {type PreviewQueryResult, type PreviewValue, type ValuePending} from './types'
 
 /**
  * @beta
+ * @deprecated This type is deprecated and will be removed in a future release.
  */
 export type ResolvePreviewOptions = DocumentHandle
 
 /**
  * @beta
+ * @deprecated This function is deprecated and will be removed in a future release.
  */
-export const resolvePreview = bindActionByDataset(
-  previewStore,
-  ({instance}, docHandle: ResolvePreviewOptions) =>
-    firstValueFrom(getPreviewState(instance, docHandle).observable.pipe(filter((i) => !!i.data))),
-)
+export async function resolvePreview(
+  instance: SanityInstance,
+  options: ResolvePreviewOptions,
+): Promise<ValuePending<PreviewValue>> {
+  // Resolve the projection
+  const projectionResult = await resolveProjection<PreviewQueryResult>(instance, {
+    ...options,
+    projection: PREVIEW_PROJECTION,
+  })
+
+  if (!projectionResult.data) {
+    return {data: null, isPending: projectionResult.isPending}
+  }
+
+  // Transform to preview format
+  const previewValue = transformProjectionToPreview(instance, projectionResult.data, options.source)
+
+  return {
+    data: previewValue,
+    isPending: projectionResult.isPending,
+  }
+}

package/src/preview/{previewStore.ts → types.ts}

@@ -1,7 +1,9 @@
-import {type BoundDatasetKey} from '../store/createActionBinder'
-import {defineStore} from '../store/defineStore'
-import {subscribeToStateAndFetchBatches} from './subscribeToStateAndFetchBatches'
+import {type DocumentStatus} from '../projection/types'
 
+/**
+ *
+ * @internal
+ */
 export interface PreviewQueryResult {
   _id: string
   _type: string
@@ -9,6 +11,7 @@ export interface PreviewQueryResult {
   titleCandidates: Record<string, unknown>
   subtitleCandidates: Record<string, unknown>
   media?: PreviewMedia | null
+  _status?: DocumentStatus
 }
 
 /**
@@ -74,22 +77,10 @@ export type ValuePending<T> = {
 
 /**
  * @public
+ * @deprecated This interface is kept for backwards compatibility but is no longer used internally.
+ * Preview state is now stored in the projection store.
  */
 export interface PreviewStoreState {
   values: {[TDocumentId in string]?: ValuePending<PreviewValue>}
   subscriptions: {[TDocumentId in string]?: {[TSubscriptionId in string]?: true}}
 }
-
-export const previewStore = defineStore<PreviewStoreState, BoundDatasetKey>({
-  name: 'Preview',
-  getInitialState() {
-    return {
-      subscriptions: {},
-      values: {},
-    }
-  },
-  initialize: (context) => {
-    const subscription = subscribeToStateAndFetchBatches(context)
-    return () => subscription.unsubscribe
-  },
-})

package/src/projection/getProjectionState.test.ts

@@ -126,7 +126,7 @@ describe('getProjectionState', () => {
     expect(state.get().subscriptions).toEqual({})
     expect(state.get().documentProjections).toEqual({})
 
-    const unsubscribe1 = projectionState1.subscribe(vi.fn()) // Should use ID 3
+    const unsubscribe1 = projectionState1.subscribe(vi.fn()) // Should use ID 2
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {[hash1]: {testSubId_2: true}},
     })
@@ -134,7 +134,7 @@ describe('getProjectionState', () => {
       [docHandle.documentId]: {[hash1]: projection1},
     })
 
-    const unsubscribe2 = projectionState2.subscribe(vi.fn()) // Should use ID 4
+    const unsubscribe2 = projectionState2.subscribe(vi.fn()) // Should use ID 3
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {
         [hash1]: {testSubId_2: true},
@@ -148,10 +148,12 @@ describe('getProjectionState', () => {
       },
     })
 
-    const unsubscribe3 = projectionState1.subscribe(vi.fn()) // Should use ID 5
+    // should share ID 2 from the first subscription -- we only care if ANY subscription exists
+    // so we can include the document / projection in a bulk fetch
+    const unsubscribe3 = projectionState1.subscribe(vi.fn())
     expect(state.get().subscriptions).toEqual({
       [docHandle.documentId]: {
-        [hash1]: {testSubId_2: true, testSubId_4: true},
+        [hash1]: {testSubId_2: true},
         [hash2]: {testSubId_3: true},
       },
     })
@@ -165,23 +167,20 @@ describe('getProjectionState', () => {
     })
 
     // --- Test Unsubscribe ---
-    unsubscribe1() // Unsubscribes ID 3
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({
-      testSubId_2: true,
-      testSubId_4: true,
-    })
+    unsubscribe1() // Unsubscribes first subscription consumer
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_2: true})
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_4: true})
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toEqual({testSubId_2: true})
     expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toEqual(projection1)
 
-    unsubscribe3() // Unsubscribes ID 5
+    unsubscribe3() // Also unsubscibes first projection subscription, should be removed
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().subscriptions[docHandle.documentId]?.[hash1]).toBeUndefined()
     expect(state.get().documentProjections[docHandle.documentId]?.[hash1]).toBeUndefined()
     expect(state.get().subscriptions[docHandle.documentId]?.[hash2]).toEqual({testSubId_3: true})
     expect(state.get().documentProjections[docHandle.documentId]?.[hash2]).toEqual(projection2)
 
-    unsubscribe2() // Unsubscribes ID 4
+    unsubscribe2() // Unsubscribes second projection subscription, should be removed
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().subscriptions[docHandle.documentId]).toBeUndefined()
     expect(state.get().documentProjections[docHandle.documentId]).toBeUndefined()
@@ -203,14 +202,14 @@ describe('getProjectionState', () => {
     }))
 
     const unsubscribe1 = projectionState.subscribe(vi.fn()) // Should use ID 2
-    const unsubscribe2 = projectionState.subscribe(vi.fn()) // Should use ID 3
+    const unsubscribe2 = projectionState.subscribe(vi.fn()) // Should reuse ID 2
 
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
       isPending: true,
     })
 
-    unsubscribe1() // Unsubscribes ID 2
+    unsubscribe1() // Unsubscribes first subscription consumer
     vi.advanceTimersByTime(PROJECTION_STATE_CLEAR_DELAY)
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
@@ -219,9 +218,10 @@ describe('getProjectionState', () => {
     expect(Object.keys(state.get().subscriptions[docHandle.documentId]?.[hash] ?? {}).length).toBe(
       1,
     )
-    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toEqual({testSubId_3: true})
+    // should still have the same subscription ID since we're not unsubscribing the second consumer
+    expect(state.get().subscriptions[docHandle.documentId]?.[hash]).toEqual({testSubId_2: true})
 
-    unsubscribe2() // Unsubscribes ID 3
+    unsubscribe2() // Unsubscribes second subscription consumer
     expect(state.get().values[docHandle.documentId]?.[hash]).toEqual({
       data: initialData,
       isPending: true,

package/src/projection/getProjectionState.ts

@@ -12,6 +12,7 @@ import {
 } from '../store/createStateSourceAction'
 import {hashString} from '../utils/hashString'
 import {insecureRandomId} from '../utils/ids'
+import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {projectionStore} from './projectionStore'
 import {type ProjectionStoreState, type ProjectionValuePending} from './types'
 import {PROJECTION_STATE_CLEAR_DELAY, STABLE_EMPTY_PROJECTION, validateProjection} from './util'
@@ -110,7 +111,7 @@ export const _getProjectionState = bindActionBySourceAndPerspective(
       }))
 
       return () => {
-        setTimeout(() => {
+        setCleanupTimeout(() => {
           state.set('removeSubscription', (prev): Partial<ProjectionStoreState> => {
             const documentSubscriptionsForHash = omit(
               prev.subscriptions[documentId]?.[projectionHash],

package/src/projection/projectionQuery.ts

@@ -1,8 +1,7 @@
 import {type ClientPerspective} from '@sanity/client'
-import {DocumentId} from '@sanity/id-utils'
+import {DocumentId, getPublishedId} from '@sanity/id-utils'
 
 import {type ReleasePerspective} from '../config/sanityConfig'
-import {getPublishedId} from '../utils/ids'
 import {
   type DocumentProjections,
   type DocumentProjectionValues,
@@ -85,7 +84,7 @@ export function processProjectionQuery({
   } = {}
 
   for (const result of results) {
-    const originalId = getPublishedId(result._id)
+    const originalId = getPublishedId(DocumentId(result._id))
     const hash = result.__projectionHash
 
     if (!ids.has(originalId)) continue

package/src/projection/types.ts

@@ -29,7 +29,7 @@ interface DocumentProjectionSubscriptions {
   }
 }
 
-interface DocumentStatus {
+export interface DocumentStatus {
   lastEditedDraftAt?: string
   lastEditedPublishedAt?: string
   lastEditedVersionAt?: string

package/src/query/queryStore.ts

@@ -45,6 +45,7 @@ import {
 import {type StoreState} from '../store/createStoreState'
 import {defineStore, type StoreContext} from '../store/defineStore'
 import {insecureRandomId} from '../utils/ids'
+import {setCleanupTimeout} from '../utils/setCleanupTimeout'
 import {
   QUERY_STATE_CLEAR_DELAY,
   QUERY_STORE_API_VERSION,
@@ -333,7 +334,7 @@ const _getQueryState = bindActionBySource(
 
       return () => {
         // this runs on unsubscribe
-        setTimeout(
+        setCleanupTimeout(
           () => state.set('removeSubscriber', removeSubscriber(key, subscriptionId)),
           QUERY_STATE_CLEAR_DELAY,
         )

package/src/releases/getPerspectiveState.ts

@@ -1,7 +1,7 @@
 import {createSelector} from 'reselect'
 
-import {type PerspectiveHandle} from '../config/sanityConfig'
-import {bindActionByDataset, type BoundStoreAction} from '../store/createActionBinder'
+import {type DocumentSource, type PerspectiveHandle} from '../config/sanityConfig'
+import {bindActionBySource, type BoundStoreAction} from '../store/createActionBinder'
 import {createStateSourceAction, type SelectorContext} from '../store/createStateSourceAction'
 /*
  * Although this is an import dependency cycle, it is not a logical cycle:
@@ -26,7 +26,7 @@ const selectActiveReleases = (context: SelectorContext<ReleasesStoreState>) =>
   context.state.activeReleases
 const selectOptions = (
   _context: SelectorContext<ReleasesStoreState>,
-  options: PerspectiveHandle & {projectId?: string; dataset?: string},
+  options: PerspectiveHandle & {projectId?: string; dataset?: string; source?: DocumentSource},
 ) => options
 
 const memoizedOptionsSelector = createSelector(
@@ -103,12 +103,13 @@ let _boundGetPerspectiveState: BoundGetPerspectiveState | undefined
  *
  * @public
  */
-export const getPerspectiveState: BoundGetPerspectiveState = (...args) => {
+export const getPerspectiveState: BoundGetPerspectiveState = (instance, ...rest) => {
   if (!_boundGetPerspectiveState) {
-    _boundGetPerspectiveState = bindActionByDataset(
+    _boundGetPerspectiveState = bindActionBySource(
       releasesStore,
       _getPerspectiveStateSelector,
     ) as BoundGetPerspectiveState
   }
-  return _boundGetPerspectiveState(...args)
+  // bindActionBySource keyFn destructures { source } from the first param, so pass {} when no options
+  return _boundGetPerspectiveState(instance, ...(rest.length ? rest : [{}]))
 }