@sanity/sdk-react 3.1.0 → 3.3.0-rc.0

package/src/hooks/dashboard/useRemoteClient.test.tsx

@@ -0,0 +1,88 @@
+import {createSanityInstance, type SanityInstance} from '@sanity/sdk'
+import {type ReactNode, StrictMode} from 'react'
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest'
+
+import {renderHook} from '../../../test/test-utils'
+import {SanityInstanceContext} from '../../context/SanityInstanceContext'
+import {useRemoteClient} from './useRemoteClient'
+
+const {createMFInstance} = vi.hoisted(() => ({
+  createMFInstance: vi.fn(() => ({
+    registerRemotes: vi.fn(),
+    loadRemote: vi.fn(),
+    preloadRemote: vi.fn(),
+  })),
+}))
+
+vi.mock('@module-federation/runtime', () => ({createInstance: createMFInstance}))
+
+function wrapper(instance: SanityInstance) {
+  return function TestProvider({children}: {children: ReactNode}) {
+    return (
+      <StrictMode>
+        <SanityInstanceContext.Provider value={instance}>{children}</SanityInstanceContext.Provider>
+      </StrictMode>
+    )
+  }
+}
+
+describe('useRemoteClient', () => {
+  const instances: SanityInstance[] = []
+  function createTestInstance() {
+    const instance = createSanityInstance()
+    instances.push(instance)
+    return instance
+  }
+
+  beforeEach(() => vi.clearAllMocks())
+  afterEach(() => {
+    instances.splice(0).forEach((instance) => instance.dispose())
+  })
+
+  it("creates a client for the hook's Sanity instance", () => {
+    const instance = createTestInstance()
+    renderHook(() => useRemoteClient(), {wrapper: wrapper(instance)})
+
+    expect(createMFInstance).toHaveBeenCalledTimes(1)
+    expect(createMFInstance).toHaveBeenCalledWith(
+      expect.objectContaining({
+        name: `sanity-remote-${instance.instanceId}`,
+        remotes: [],
+      }),
+    )
+  })
+
+  it('does not create a client for a disposed Sanity instance', () => {
+    const instance = createTestInstance()
+    instance.dispose()
+
+    expect(() => renderHook(() => useRemoteClient(), {wrapper: wrapper(instance)})).toThrow(
+      'Cannot create a remote client for a disposed Sanity instance',
+    )
+    expect(createMFInstance).not.toHaveBeenCalled()
+  })
+
+  it('shares a client across consumers and remounts using the same instance', () => {
+    const instance = createTestInstance()
+    const first = renderHook(() => useRemoteClient(), {wrapper: wrapper(instance)})
+    const second = renderHook(() => useRemoteClient(), {wrapper: wrapper(instance)})
+    expect(second.result.current).toBe(first.result.current)
+    const client = first.result.current
+    first.unmount()
+    second.unmount()
+
+    const remounted = renderHook(() => useRemoteClient(), {wrapper: wrapper(instance)})
+    expect(remounted.result.current).toBe(client)
+    expect(createMFInstance).toHaveBeenCalledTimes(1)
+  })
+
+  it('isolates clients between Sanity instances', () => {
+    const firstInstance = createTestInstance()
+    const secondInstance = createTestInstance()
+    const first = renderHook(() => useRemoteClient(), {wrapper: wrapper(firstInstance)})
+    const second = renderHook(() => useRemoteClient(), {wrapper: wrapper(secondInstance)})
+
+    expect(first.result.current).not.toBe(second.result.current)
+    expect(createMFInstance).toHaveBeenCalledTimes(2)
+  })
+})

package/src/hooks/dashboard/useRemoteClient.ts

@@ -0,0 +1,10 @@
+import {type RemoteInstance} from '../../dashboard/createRemoteInstance'
+import {getRemoteClientState} from '../../dashboard/remoteClientState'
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+/**
+ * Returns a remote client shared by hooks using the same Sanity instance.
+ * The first call creates the client; later calls reuse it.
+ * @public
+ */
+export const useRemoteClient: () => RemoteInstance = createStateSourceHook(getRemoteClientState)

package/src/hooks/dashboard/useTopic.test.tsx

@@ -0,0 +1,200 @@
+import {installMessageBus, resetMessageBus} from '@sanity/sdk/_internal'
+import {
+  MessageBusError,
+  type MessageBusHost,
+  type TopicData,
+  TopicError,
+  type ValueOf,
+} from '@sanity/sdk/dashboard'
+import {Suspense} from 'react'
+import {ErrorBoundary} from 'react-error-boundary'
+import {afterEach, beforeEach, describe, expect, expectTypeOf, it, vi} from 'vitest'
+
+import {act, fireEvent, render, renderHook, screen} from '../../../test/test-utils'
+import {useTopic} from './useTopic'
+
+type Applications = Extract<NonNullable<ValueOf<'applications.list'>>, {ok: true}>['value']
+
+const MESSAGE_BUS_KEY = Symbol.for('sanity.os.bus')
+
+let host: MessageBusHost
+
+function Token() {
+  return <span>{useTopic('auth.token')}</span>
+}
+
+function ApplicationCount() {
+  const applications = useTopic('applications.list')
+  return <span>{applications?.length ?? 0} applications</span>
+}
+
+function renderInBoundary(ui: React.ReactNode, onError = vi.fn()) {
+  render(
+    <ErrorBoundary
+      fallbackRender={({resetErrorBoundary}) => <button onClick={resetErrorBoundary}>Retry</button>}
+      onError={onError}
+    >
+      <Suspense fallback="Loading">{ui}</Suspense>
+    </ErrorBoundary>,
+  )
+  return onError
+}
+
+describe('useTopic', () => {
+  beforeEach(() => {
+    // The SDK resolves its own app ID from the CLI-embedded global.
+    vi.stubGlobal('__SANITY_APP_ID__', 'app')
+    host = installMessageBus({appId: 'dashboard'})
+  })
+
+  afterEach(() => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.unstubAllGlobals()
+    vi.useRealTimers()
+    vi.restoreAllMocks()
+  })
+
+  it('reads a published value and follows topic updates', () => {
+    host.connections.subscribe((client) => client.emit('applications.foreground', null))
+    const {result} = renderHook(() => useTopic('applications.foreground'))
+
+    expectTypeOf(result.current).toEqualTypeOf<string | null>()
+    expect(result.current).toBeNull()
+
+    act(() =>
+      host.connections.subscribe((client) =>
+        client.emit('applications.foreground', 'application-2'),
+      ),
+    )
+
+    expect(result.current).toBe('application-2')
+  })
+
+  it('suspends an unseeded topic until its first value', async () => {
+    renderInBoundary(<Token />)
+
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      host.connections.subscribe((client) => client.emit('auth.token', 'token'))
+    })
+
+    expect(await screen.findByText('token')).toBeInTheDocument()
+  })
+
+  it('unwraps a successful topic result to its value', () => {
+    const applications = [{id: 'application-1'}] as Applications
+    host.connections.subscribe((client) =>
+      client.emit('applications.list', {ok: true, value: applications}),
+    )
+
+    const {result} = renderHook(() => useTopic('applications.list'))
+
+    expectTypeOf(result.current).toEqualTypeOf<TopicData<'applications.list'>>()
+    expectTypeOf(result.current).toEqualTypeOf<Applications | null>()
+    expect(result.current).toBe(applications)
+  })
+
+  it('throws a TopicError to the error boundary when a topic result fails', () => {
+    host.connections.subscribe((client) => client.emit('applications.list', {ok: false}))
+
+    const onError = renderInBoundary(<ApplicationCount />)
+
+    expect(screen.getByText('Retry')).toBeInTheDocument()
+    const error = onError.mock.calls[0][0] as TopicError
+    expect(error).toBeInstanceOf(TopicError)
+    expect(error.topic).toBe('applications.list')
+  })
+
+  it('throws a TopicError when the first published result fails', async () => {
+    const onError = renderInBoundary(<ApplicationCount />)
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      host.connections.subscribe((client) => client.emit('applications.list', {ok: false}))
+    })
+
+    expect(await screen.findByText('Retry')).toBeInTheDocument()
+    expect(onError.mock.calls[0][0]).toBeInstanceOf(TopicError)
+  })
+
+  it('throws a TopicError when a later result fails', () => {
+    host.connections.subscribe((client) =>
+      client.emit('applications.list', {ok: true, value: [] as Applications}),
+    )
+    const onError = renderInBoundary(<ApplicationCount />)
+    expect(screen.getByText('0 applications')).toBeInTheDocument()
+
+    act(() => host.connections.subscribe((client) => client.emit('applications.list', {ok: false})))
+
+    expect(screen.getByText('Retry')).toBeInTheDocument()
+    expect(onError.mock.calls[0][0]).toBeInstanceOf(TopicError)
+  })
+
+  it('throws to the error boundary when the query deadline passes', async () => {
+    // Only the query deadline is faked; React's scheduler keeps real timers so the retry renders.
+    vi.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']})
+
+    const onError = renderInBoundary(<Token />)
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5000)
+    })
+
+    expect(screen.getByText('Retry')).toBeInTheDocument()
+    const error = onError.mock.calls[0][0] as MessageBusError
+    expect(error).toBeInstanceOf(MessageBusError)
+    expect(error.code).toBe('TIMEOUT')
+  })
+
+  it('retries with a fresh deadline when the boundary resets after the failure is released', async () => {
+    vi.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']})
+
+    const onError = renderInBoundary(<Token />)
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(5000)
+    })
+    expect(onError).toHaveBeenCalledTimes(1)
+
+    // The failure is held for a short grace period, then dropped with its last reader.
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(1000)
+    })
+    fireEvent.click(screen.getByText('Retry'))
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+
+    await act(async () => {
+      host.connections.subscribe((client) => client.emit('auth.token', 'token'))
+    })
+
+    expect(screen.getByText('token')).toBeInTheDocument()
+    expect(onError).toHaveBeenCalledTimes(1)
+  })
+
+  it('does not throw a failure recorded after the reader unmounted at the next mount', async () => {
+    vi.useFakeTimers({toFake: ['setTimeout', 'clearTimeout']})
+
+    const {unmount} = render(<Suspense fallback="Loading">{<Token />}</Suspense>)
+    unmount()
+    await act(async () => {
+      await vi.advanceTimersByTimeAsync(6000)
+    })
+
+    const onError = renderInBoundary(<Token />)
+
+    expect(screen.getByText('Loading')).toBeInTheDocument()
+    expect(onError).not.toHaveBeenCalled()
+  })
+
+  it('throws when used outside a dashboard application', () => {
+    resetMessageBus()
+    delete (globalThis as {[MESSAGE_BUS_KEY]?: unknown})[MESSAGE_BUS_KEY]
+    vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    expect(() => renderHook(() => useTopic('applications.foreground'))).toThrow(
+      'Cannot read topic "applications.foreground" without an installed dashboard message bus',
+    )
+  })
+})

package/src/hooks/dashboard/useTopic.ts

@@ -0,0 +1,29 @@
+import {getTopicState, resolveTopic} from '@sanity/sdk/_internal'
+import {type StateTopic, type TopicData} from '@sanity/sdk/dashboard'
+
+import {createStateSourceHook} from '../helpers/createStateSourceHook'
+
+/**
+ * Returns the current value of a dashboard state topic and follows later updates.
+ *
+ * The hook suspends until the topic publishes its first value, using the message bus query
+ * deadline. A topic declared with `TopicResult` resolves to its successful value; a
+ * failed result throws a `TopicError` to the nearest error boundary.
+ *
+ * @example
+ * ```tsx
+ * function ForegroundApplication() {
+ *   const foregroundId = useTopic('applications.foreground')
+ *   return <span>{foregroundId ?? 'No application in the foreground'}</span>
+ * }
+ * ```
+ *
+ * @public
+ */
+export const useTopic = createStateSourceHook({
+  getState: getTopicState,
+  // `getCurrent` throws a recorded read failure, which surfaces it from render like a thrown value.
+  shouldSuspend: (instance, topic: StateTopic) =>
+    getTopicState(instance, topic).getCurrent() === undefined,
+  suspender: resolveTopic,
+}) as <K extends StateTopic>(topic: K) => TopicData<K>

package/src/hooks/dashboard/useUpdateFavorite.test.tsx

@@ -121,11 +121,18 @@ describe('useUpdateFavorite', () => {
     mockSetFavorite.mockRejectedValue(new Error('mutate failed'))
 
     const {result} = renderHook(() => useUpdateFavorite(handle), {wrapper})
+    let error: unknown
 
     await act(async () => {
-      await expect(result.current.favorite()).rejects.toThrow('mutate failed')
+      try {
+        await result.current.favorite()
+      } catch (caughtError) {
+        error = caughtError
+      }
     })
 
+    expect(error).toBeInstanceOf(Error)
+    expect((error as Error).message).toBe('mutate failed')
     await waitFor(() => expect(result.current.error).toBeInstanceOf(Error))
   })
 

package/src/hooks/document/useApplyDocumentActions.ts

@@ -1,5 +1,4 @@
-import {type ActionsResult, type DocumentAction} from '@sanity/sdk'
-import {type SanityDocument} from 'groq'
+import {type ActionsResult, type DocumentAction, type ResolveDocument} from '@sanity/sdk'
 
 import {type ResourceHandle} from '../../config/handles'
 import {useApplyActions} from '../helpers/useApplyActions'
@@ -20,7 +19,7 @@ interface UseApplyDocumentActions {
       | DocumentAction<TDocumentType, TDataset, TProjectId>
       | DocumentAction<TDocumentType, TDataset, TProjectId>[],
     options?: ResourceHandle,
-  ) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
+  ) => Promise<ActionsResult<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 }
 
 /**
@@ -199,7 +198,7 @@ interface UseApplyDocumentActions {
  *       perspective: {releaseName: 'summer-drop'},
  *     })
  *
- *     apply(editDocument(docHandle, {title: 'Updated for release'}))
+ *     apply(editDocument(docHandle, {set: {title: 'Updated for release'}}))
  *   }
  *
  *   return <button onClick={handleEdit}>Edit in Release</button>

package/src/hooks/document/useCreateDocument.ts

@@ -1,6 +1,5 @@
-import {createDocument} from '@sanity/sdk'
+import {createDocument, type ResolveDocument} from '@sanity/sdk'
 import {randomUuid} from '@sanity/sdk/_internal'
-import {type SanityDocument} from 'groq'
 
 import {type DocumentHandle, type DocumentTypeHandle} from '../../config/handles'
 import {useSanityInstance} from '../context/useSanityInstance'
@@ -38,7 +37,7 @@ export function useCreateDocument<
   options: DocumentTypeHandle<TDocumentType, TDataset, TProjectId>,
 ): (
   initialValue?: Partial<
-    Omit<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, IgnoredKey>
+    Omit<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>, IgnoredKey>
   >,
   overrides?: CreateDocumentOverrides,
 ) => Promise<DocumentHandle<TDocumentType, TDataset, TProjectId>>

package/src/hooks/document/useDocument.ts

@@ -1,5 +1,10 @@
-import {type DocumentOptions, getDocumentState, type JsonMatch, resolveDocument} from '@sanity/sdk'
-import {type SanityDocument} from 'groq'
+import {
+  type DocumentOptions,
+  getDocumentState,
+  type JsonMatch,
+  type ResolveDocument,
+  resolveDocument,
+} from '@sanity/sdk'
 import {identity} from 'rxjs'
 
 import {type DocumentHandle} from '../../config/handles'
@@ -47,7 +52,7 @@ interface UseDocument {
   /** @internal */
   <TDocumentType extends string, TDataset extends string, TProjectId extends string = string>(
     options: UseDocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
-  ): {data: SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
+  ): {data: ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
 
   /** @internal */
   <
@@ -58,7 +63,7 @@ interface UseDocument {
   >(
     options: UseDocumentOptions<TPath, TDocumentType>,
   ): {
-    data: JsonMatch<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath> | undefined
+    data: JsonMatch<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath> | undefined
   }
 
   /** @internal */
@@ -138,10 +143,10 @@ interface UseDocument {
   ): TPath extends string
     ? {
         data:
-          | JsonMatch<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath>
+          | JsonMatch<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath>
           | undefined
       }
-    : {data: SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
+    : {data: ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`> | null}
 
   /**
    * @public

package/src/hooks/document/useEditDocument.ts

@@ -4,9 +4,9 @@ import {
   editDocument,
   getDocumentState,
   type JsonMatch,
+  type ResolveDocument,
   resolveDocument,
 } from '@sanity/sdk'
-import {type SanityDocument} from 'groq'
 import {useCallback} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
@@ -34,8 +34,8 @@ export function useEditDocument<
 >(
   options: DocumentOptions<undefined, TDocumentType, TDataset, TProjectId>,
 ): (
-  nextValue: Updater<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>,
-) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
+  nextValue: Updater<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>>,
+) => Promise<ActionsResult<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 
 // Overload 2: Path provided, relies on Typegen
 /**
@@ -54,8 +54,8 @@ export function useEditDocument<
 >(
   options: DocumentOptions<TPath, TDocumentType, TDataset, TProjectId>,
 ): (
-  nextValue: Updater<JsonMatch<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath>>,
-) => Promise<ActionsResult<SanityDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
+  nextValue: Updater<JsonMatch<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>, TPath>>,
+) => Promise<ActionsResult<ResolveDocument<TDocumentType, `${TProjectId}.${TDataset}`>>>
 
 // Overload 3: Explicit type, no path
 /**

package/src/hooks/projection/useDocumentProjection.ts

@@ -1,5 +1,4 @@
-import {getProjectionState, resolveProjection} from '@sanity/sdk'
-import {type SanityProjectionResult} from 'groq'
+import {getProjectionState, resolveProjection, type ResolveProjectionResult} from '@sanity/sdk'
 import {useCallback, useMemo, useSyncExternalStore} from 'react'
 import {distinctUntilChanged, EMPTY, Observable, startWith, switchMap} from 'rxjs'
 
@@ -64,19 +63,19 @@ export interface useDocumentProjectionResults<TData> {
  * @param options - Options including the document handle properties (`documentId`, `documentType`, etc.) and the `projection`.
  * @returns The projected data, typed based on Typegen.
  *
- * @example Using Typegen for a book preview
+ * @example Using an existing experimental Typegen file for a book preview
  * ```tsx
  * // ProjectionComponent.tsx
- * import {useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
+ * import {defineProjection, useDocumentProjection, type DocumentHandle} from '@sanity/sdk-react'
  * import {useRef} from 'react'
- * import {defineProjection} from 'groq'
  *
  * // Define props using DocumentHandle with the specific document type
  * type ProjectionComponentProps = {
  *   doc: DocumentHandle<'book'> // Typegen knows 'book'
  * }
  *
- * // This is required for typegen to generate the correct return type
+ * // Keep the projection string identical to its entry in the existing generated file.
+ * // Current Typegen does not scan defineProjection imported from the SDK.
  * const myProjection = defineProjection(`{
  *   title,
  *   'coverImage': cover.asset->url,
@@ -120,7 +119,7 @@ export function useDocumentProjection<
 >(
   options: useDocumentProjectionOptions<TProjection, TDocumentType, TDataset, TProjectId>,
 ): useDocumentProjectionResults<
-  SanityProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>
+  ResolveProjectionResult<TProjection, TDocumentType, `${TProjectId}.${TDataset}`>
 >
 
 // Overload 2: Explicit type provided

package/src/hooks/query/useQuery.ts

@@ -1,6 +1,5 @@
-import {getQueryState, type QueryOptions, resolveQuery} from '@sanity/sdk'
+import {getQueryState, type QueryOptions, resolveQuery, type ResolveQueryResult} from '@sanity/sdk'
 import {getQueryKey, parseQueryKey} from '@sanity/sdk/_internal'
-import {type SanityQueryResult} from 'groq'
 import {useEffect, useMemo, useRef, useState, useSyncExternalStore, useTransition} from 'react'
 
 import {useSanityInstance} from '../context/useSanityInstance'
@@ -83,7 +82,7 @@ export function useQuery<
   options: UseQueryOptions<TQuery, TDataset, TProjectId>,
 ): {
   /** The query result, typed based on the GROQ query string */
-  data: SanityQueryResult<TQuery, `${TProjectId}.${TDataset}`>
+  data: ResolveQueryResult<TQuery, `${TProjectId}.${TDataset}`>
   /** True if a query transition is in progress */
   isPending: boolean
 }
@@ -205,6 +204,6 @@ export function useQuery(options: WithResourceNameSupport<QueryOptions>): {
 
   // Subscribe to updates and get the current data
   // useSyncExternalStore ensures the component re-renders when the data changes
-  const data = useSyncExternalStore(subscribe, getCurrent) as SanityQueryResult
+  const data = useSyncExternalStore(subscribe, getCurrent) as ResolveQueryResult
   return useMemo(() => ({data, isPending}), [data, isPending])
 }

package/dist/useStudioWorkspacesByProjectIdDataset-DxUlukmF.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"useStudioWorkspacesByProjectIdDataset-DxUlukmF.js","names":["SanityInstance","createContext","SanityInstanceContext","SanityInstance","useContext","SanityInstanceContext","useSanityInstance","instance","Error","SanityConfig","SanityInstance","StateSource","useSyncExternalStore","useSanityInstance","StateSourceFactory","instance","params","TParams","TState","CreateStateSourceHookOptions","getState","shouldSuspend","suspender","Promise","getConfig","createStateSourceHook","options","suspense","undefined","useHook","t0","$","_c","t1","state","subscribe","getCurrent","AuthState","getAuthState","createStateSourceHook","useAuthState","MessageData","NodeInput","SanityInstance","StateSource","FrameMessage","getNodeState","NodeState","WindowMessage","useCallback","useEffect","useRef","filter","firstValueFrom","useSanityInstance","createStateSourceHook","WindowMessageHandler","event","TFrameMessage","UseWindowConnectionOptions","name","connectTo","onMessage","Record","TMessage","WindowConnection","sendMessage","type","TType","data","Extract","fetch","options","signal","AbortSignal","suppressWarnings","responseTimeout","Promise","TResponse","useNodeState","getState","instance","nodeInput","shouldSuspend","getCurrent","undefined","suspender","observable","pipe","Boolean","useWindowConnection","t0","$","_c","t1","node","t2","Symbol","for","messageUnsubscribers","t3","Object","entries","forEach","t4","handler","messageUnsubscribe","on","current","push","_temp","t5","type_0","post","t6","type_1","data_0","fetchOptions","t7","unsubscribe","from","Observable","of","catchError","switchMap","OS_BUS_KEY","Symbol","for","isDashboardEnvironment","globalThis","observeDashboardToken","undefined","pipe","os","subscribe","refreshDashboardToken","then","emit","ClientError","AuthStateType","setAuthToken","React","PropsWithChildren","useEffect","useRef","useAuthState","useSanityInstance","isDashboardEnvironment","observeDashboardToken","refreshDashboardToken","DashboardTokenRefresh","t0","$","_c","children","instance","authState","processed401ErrorRef","t1","t2","token$","subscription","subscribe","token","unsubscribe","t3","error","type","has401Error","ERROR","statusCode","current","t4","DashboardTokenRefreshProvider","FC","getDashboardOrganizationId","useMemo","useSyncExternalStore","useSanityInstance","useOrganizationId","$","_c","instance","t0","subscribe","getCurrent","SDK_CHANNEL_NAME","SDK_NODE_NAME","useEffect","useState","useWindowConnection","DashboardResource","id","name","title","basePath","projectId","dataset","type","userApplicationId","url","WorkspacesByProjectIdDataset","key","StudioWorkspacesResult","workspacesByProjectIdAndDataset","error","useStudioWorkspacesByProjectIdDataset","$","_c","t0","Symbol","for","setWorkspacesByProjectIdAndDataset","setError","t1","connectTo","fetch","t2","t3","fetchWorkspaces","signal","data","undefined","workspaceMap","noProjectIdAndDataset","context","availableResources","forEach","resource","push","const","length","t4","err","Error","controller","AbortController","abort"],"sources":["../src/context/SanityInstanceContext.ts","../src/hooks/context/useSanityInstance.ts","../src/hooks/helpers/createStateSourceHook.tsx","../src/hooks/auth/useAuthState.tsx","../src/hooks/comlink/useWindowConnection.ts","../src/context/dashboardToken.ts","../src/context/DashboardTokenRefresh.tsx","../src/hooks/dashboard/useOrganizationId.tsx","../src/hooks/dashboard/useStudioWorkspacesByProjectIdDataset.ts"],"sourcesContent":["import {type SanityInstance} from '@sanity/sdk'\nimport {createContext} from 'react'\n\nexport const SanityInstanceContext = createContext<SanityInstance | null>(null)\n","import {type SanityInstance} from '@sanity/sdk'\nimport {useContext} from 'react'\n\nimport {SanityInstanceContext} from '../../context/SanityInstanceContext'\n\n/**\n * Retrieves the current Sanity instance from context\n *\n * @public\n *\n * @category Platform\n * @returns The current Sanity instance\n *\n * @remarks\n * This hook accesses the nearest Sanity instance from the React context.\n * The hook must be used within a component wrapped by a `ResourceProvider` or `SanityApp`.\n *\n * @example Get the current instance\n * ```tsx\n * const instance = useSanityInstance()\n * console.log(instance.config.projectId)\n * ```\n *\n * @throws Error if no SanityInstance is found in context\n */\nexport const useSanityInstance = (): SanityInstance => {\n  const instance = useContext(SanityInstanceContext)\n\n  if (!instance) {\n    throw new Error(\n      `SanityInstance context not found. Please ensure that your component is wrapped in a ResourceProvider or a SanityApp component.`,\n    )\n  }\n\n  return instance\n}\n","import {type SanityConfig, type SanityInstance, type StateSource} from '@sanity/sdk'\nimport {useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\ntype StateSourceFactory<TParams extends unknown[], TState> = (\n  instance: SanityInstance,\n  ...params: TParams\n) => StateSource<TState>\n\ninterface CreateStateSourceHookOptions<TParams extends unknown[], TState> {\n  getState: StateSourceFactory<TParams, TState>\n  shouldSuspend?: (instance: SanityInstance, ...params: TParams) => boolean\n  suspender?: (instance: SanityInstance, ...params: TParams) => Promise<unknown>\n  getConfig?: (...params: TParams) => SanityConfig | undefined\n}\n\nexport function createStateSourceHook<TParams extends unknown[], TState>(\n  options: StateSourceFactory<TParams, TState> | CreateStateSourceHookOptions<TParams, TState>,\n): (...params: TParams) => TState {\n  const getState = typeof options === 'function' ? options : options.getState\n  const suspense = 'shouldSuspend' in options && 'suspender' in options ? options : undefined\n\n  function useHook(...params: TParams) {\n    const instance = useSanityInstance()\n\n    if (suspense?.suspender && suspense?.shouldSuspend?.(instance, ...params)) {\n      throw suspense.suspender(instance, ...params)\n    }\n\n    const state = getState(instance, ...params)\n    return useSyncExternalStore(state.subscribe, state.getCurrent)\n  }\n\n  return useHook\n}\n","import {type AuthState, getAuthState} from '@sanity/sdk'\n\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/**\n * @internal\n * A React hook that subscribes to authentication state changes.\n *\n * This hook provides access to the current authentication state type from the Sanity auth store.\n * It automatically re-renders when the authentication state changes.\n *\n * @remarks\n * The hook uses `useSyncExternalStore` to safely subscribe to auth state changes\n * and ensure consistency between server and client rendering.\n *\n * @returns The current authentication state type\n *\n * @example\n * ```tsx\n * function AuthStatus() {\n *   const authState = useAuthState()\n *   return <div>Current auth state: {authState}</div>\n * }\n * ```\n */\nexport const useAuthState: () => AuthState = createStateSourceHook(getAuthState)\n","import {type MessageData, type NodeInput} from '@sanity/comlink'\nimport {type SanityInstance, type StateSource} from '@sanity/sdk'\nimport {\n  type FrameMessage,\n  getNodeState,\n  type NodeState,\n  type WindowMessage,\n} from '@sanity/sdk/comlink'\nimport {useCallback, useEffect, useRef} from 'react'\nimport {filter, firstValueFrom} from 'rxjs'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\nimport {createStateSourceHook} from '../helpers/createStateSourceHook'\n\n/**\n * @internal\n */\nexport type WindowMessageHandler<TFrameMessage extends FrameMessage> = (\n  event: TFrameMessage['data'],\n) => TFrameMessage['response']\n\n/**\n * @internal\n */\nexport interface UseWindowConnectionOptions<TMessage extends FrameMessage> {\n  name: string\n  connectTo: string\n  onMessage?: Record<TMessage['type'], WindowMessageHandler<TMessage>>\n}\n\n/**\n * @internal\n */\nexport interface WindowConnection<TMessage extends WindowMessage> {\n  sendMessage: <TType extends TMessage['type']>(\n    type: TType,\n    data?: Extract<TMessage, {type: TType}>['data'],\n  ) => void\n  fetch: <TResponse>(\n    type: string,\n    data?: MessageData,\n    options?: {\n      signal?: AbortSignal\n      suppressWarnings?: boolean\n      responseTimeout?: number\n    },\n  ) => Promise<TResponse>\n}\n\nconst useNodeState = createStateSourceHook({\n  getState: getNodeState as (\n    instance: SanityInstance,\n    nodeInput: NodeInput,\n  ) => StateSource<NodeState>,\n  shouldSuspend: (instance: SanityInstance, nodeInput: NodeInput) =>\n    getNodeState(instance, nodeInput).getCurrent() === undefined,\n  suspender: (instance: SanityInstance, nodeInput: NodeInput) => {\n    return firstValueFrom(getNodeState(instance, nodeInput).observable.pipe(filter(Boolean)))\n  },\n})\n\n/**\n * @internal\n * Hook to wrap a Comlink node in a React hook.\n * Our store functionality takes care of the lifecycle of the node,\n * as well as sharing a single node between invocations if they share the same name.\n *\n * Generally not to be used directly, but to be used as a dependency of\n * Comlink-powered hooks like `useStudioWorkspacesByProjectIdDataset`.\n */\nexport function useWindowConnection<\n  TWindowMessage extends WindowMessage,\n  TFrameMessage extends FrameMessage,\n>({\n  name,\n  connectTo,\n  onMessage,\n}: UseWindowConnectionOptions<TFrameMessage>): WindowConnection<TWindowMessage> {\n  const {node} = useNodeState({name, connectTo})\n  const messageUnsubscribers = useRef<(() => void)[]>([])\n  const instance = useSanityInstance()\n\n  useEffect(() => {\n    if (onMessage) {\n      Object.entries(onMessage).forEach(([type, handler]) => {\n        const messageUnsubscribe = node.on(type, handler as WindowMessageHandler<TFrameMessage>)\n        if (messageUnsubscribe) {\n          messageUnsubscribers.current.push(messageUnsubscribe)\n        }\n      })\n    }\n\n    return () => {\n      messageUnsubscribers.current.forEach((unsubscribe) => unsubscribe())\n      messageUnsubscribers.current = []\n    }\n  }, [instance, name, onMessage, node])\n\n  const sendMessage = useCallback(\n    (type: TWindowMessage['type'], data?: Extract<TWindowMessage, {type: typeof type}>['data']) => {\n      node.post(type, data)\n    },\n    [node],\n  )\n\n  const fetch = useCallback(\n    <TResponse>(\n      type: string,\n      data?: MessageData,\n      fetchOptions?: {\n        responseTimeout?: number\n        signal?: AbortSignal\n        suppressWarnings?: boolean\n      },\n    ): Promise<TResponse> => {\n      return node.fetch(type, data, fetchOptions ?? {}) as Promise<TResponse>\n    },\n    [node],\n  )\n  return {\n    sendMessage,\n    fetch,\n  }\n}\n","import {from, type Observable, of} from 'rxjs'\nimport {catchError, switchMap} from 'rxjs/operators'\n\n// The dashboard host installs its shared message bus on this well-known global\n// symbol before it loads the apps it embeds in its own window. It must match\n// the key used by `@sanity/workbench` (`Symbol.for('sanity.os.bus')`).\nconst OS_BUS_KEY = Symbol.for('sanity.os.bus')\n\n/**\n * Whether this app is running inside the dashboard, embedded in its window.\n *\n * Apps embedded this way share the dashboard's realm, so the bus it installs\n * is visible on `globalThis`. This is `false` in a standalone app, where we\n * must never import `@sanity/workbench` (it would install a bus and add bundle\n * weight for no reason). Note: this is a different embedding model to the Core\n * UI iframe, which is detected separately via the dashboard context — that\n * signal is not set for apps sharing the dashboard's window.\n *\n * @internal\n */\nexport function isDashboardEnvironment(): boolean {\n  return typeof globalThis === 'object' && OS_BUS_KEY in globalThis\n}\n\n/**\n * Observes the session token issued by the dashboard \"OS\", tracking the OS auth\n * state over time.\n *\n * Returns `undefined` when the app is not embedded in the dashboard, so the\n * caller uses its normal auth flow. Inside the dashboard, subscribes to the\n * `auth.token` state topic, emitting the current token — or `null` when the OS\n * is signed out — and re-emitting as the OS auth state changes, so sign-in/out\n * propagates instead of being captured once. Any bus error is treated as \"no\n * token\" (`null`). The token is used in-memory only and never persisted.\n *\n * @internal\n */\nexport function observeDashboardToken(): Observable<string | null> | undefined {\n  if (!isDashboardEnvironment()) return undefined\n\n  return from(import('@sanity/workbench')).pipe(\n    switchMap(({os}) => os.subscribe('auth.token')),\n    // Any failure (importing the host bundle, or the subscription) means \"no OS token\".\n    catchError(() => of(null)),\n  )\n}\n\n/**\n * Asks the dashboard \"OS\" to reissue the session token, e.g. after its current\n * one was rejected with a 401. Fire-and-forget: the reissued token arrives via\n * the `auth.token` subscription in {@link observeDashboardToken}. No-op outside\n * the dashboard.\n *\n * @internal\n */\nexport function refreshDashboardToken(): void {\n  if (!isDashboardEnvironment()) return\n\n  void import('@sanity/workbench').then(\n    ({os}) => os.emit('auth.token.refresh', undefined),\n    () => {},\n  )\n}\n","import {type ClientError} from '@sanity/client'\nimport {AuthStateType, setAuthToken} from '@sanity/sdk'\nimport React, {type PropsWithChildren, useEffect, useRef} from 'react'\n\nimport {useAuthState} from '../hooks/auth/useAuthState'\nimport {useSanityInstance} from '../hooks/context/useSanityInstance'\nimport {\n  isDashboardEnvironment,\n  observeDashboardToken,\n  refreshDashboardToken,\n} from './dashboardToken'\n\n/**\n * Keeps the SDK auth token in sync with the dashboard \"OS\".\n *\n * When running inside the dashboard the OS owns the session, so we subscribe\n * to its `auth.token` stream and mirror each value into\n * the auth store — a token logs us in, `null` logs us out, and later OS\n * sign-in/out propagates automatically. When a request is rejected with a 401\n * (the token expired), we ask the OS to reissue rather than tearing the session\n * down; the new token arrives back through the same subscription.\n */\nfunction DashboardTokenRefresh({children}: PropsWithChildren) {\n  const instance = useSanityInstance()\n  const authState = useAuthState()\n  const processed401ErrorRef = useRef<unknown | null>(null)\n\n  useEffect(() => {\n    const token$ = observeDashboardToken()\n    if (!token$) return undefined\n    const subscription = token$.subscribe((token) => setAuthToken(instance, token))\n    return () => subscription.unsubscribe()\n  }, [instance])\n\n  useEffect(() => {\n    const has401Error =\n      authState.type === AuthStateType.ERROR && (authState.error as ClientError)?.statusCode === 401\n\n    if (has401Error && processed401ErrorRef.current !== authState.error) {\n      processed401ErrorRef.current = authState.error\n      refreshDashboardToken()\n    } else if (!has401Error) {\n      processed401ErrorRef.current = null\n    }\n  }, [authState])\n\n  return children\n}\n\n/**\n * Authenticates the SDK with the Sanity Dashboard's session when the app runs\n * inside the dashboard.\n *\n * The dashboard owns the session there: this provider subscribes to the token\n * the dashboard issues, writes each new value into the SDK's auth store (where\n * SDK hooks read it from), and asks the dashboard for a fresh token when a\n * request fails with a 401. Outside the dashboard it renders children\n * unchanged and the app's normal auth flow applies.\n *\n * @remarks\n * `AuthBoundary` mounts this automatically, so most apps never need it\n * directly. Mount it yourself only when your app runs inside the dashboard\n * without `AuthBoundary` — that is, the app renders its own loading and error\n * UI instead of the SDK's login flow — but still uses SDK hooks such as\n * `useQuery`, which need the dashboard's token in the auth store to\n * authenticate their requests.\n *\n * Mount it once, inside the provider that creates the Sanity instance whose\n * store should receive the token.\n *\n * @example\n * ```tsx\n * import {ResourceProvider} from '@sanity/sdk-react'\n * import {TokenRefreshProvider} from '@sanity/sdk-react/dashboard'\n *\n * function EmbeddedApp() {\n *   return (\n *     <ResourceProvider fallback={<Loading />}>\n *       <TokenRefreshProvider>\n *         <App />\n *       </TokenRefreshProvider>\n *     </ResourceProvider>\n *   )\n * }\n * ```\n *\n * @public\n */\nexport const DashboardTokenRefreshProvider: React.FC<PropsWithChildren> = ({children}) => {\n  if (isDashboardEnvironment()) {\n    return <DashboardTokenRefresh>{children}</DashboardTokenRefresh>\n  }\n\n  return children\n}\n","import {getDashboardOrganizationId} from '@sanity/sdk'\nimport {useMemo, useSyncExternalStore} from 'react'\n\nimport {useSanityInstance} from '../context/useSanityInstance'\n\n/**\n * @public\n *\n * A React hook that retrieves the dashboard organization ID that is currently selected in the Sanity Dashboard.\n *\n * @example\n * ```tsx\n * function DashboardComponent() {\n *   const orgId = useOrganizationId()\n *\n *   if (!orgId) return null\n *\n *   return <div>Organization ID: {String(orgId)}</div>\n * }\n * ```\n *\n * @category Dashboard\n * @returns The dashboard organization ID (string | undefined)\n */\nexport function useOrganizationId(): string | undefined {\n  const instance = useSanityInstance()\n  const {subscribe, getCurrent} = useMemo(() => getDashboardOrganizationId(instance), [instance])\n\n  return useSyncExternalStore(subscribe, getCurrent)\n}\n","import {SDK_CHANNEL_NAME, SDK_NODE_NAME} from '@sanity/message-protocol'\nimport {useEffect, useState} from 'react'\n\nimport {useWindowConnection} from '../comlink/useWindowConnection'\n\nexport interface DashboardResource {\n  id: string\n  name: string\n  title: string\n  basePath: string\n  projectId: string\n  dataset: string\n  type: string\n  userApplicationId: string\n  url: string\n}\n\ninterface WorkspacesByProjectIdDataset {\n  [key: `${string}:${string}`]: DashboardResource[] // key format: `${projectId}:${dataset}`\n}\n\ninterface StudioWorkspacesResult {\n  workspacesByProjectIdAndDataset: WorkspacesByProjectIdDataset\n  error: string | null\n}\n\n/**\n * Hook that fetches studio workspaces and organizes them by projectId:dataset\n * @internal\n *\n * @example\n * ```tsx\n * import {useStudioWorkspacesByProjectIdDataset} from '@sanity/sdk-react'\n * import {Card, Code, Button} from '@sanity/ui'\n * import {Suspense} from 'react'\n *\n * function WorkspacesCard() {\n *   const {workspacesByProjectIdAndDataset, error} = useStudioWorkspacesByProjectIdDataset()\n *   if (error) {\n *     return <div>Error: {error}</div>\n *   }\n *   return (\n *     <Card padding={4} radius={2} shadow={1}>\n *       <Code language=\"json\">\n *         {JSON.stringify(workspacesByProjectIdAndDataset, null, 2)}\n *       </Code>\n *     </Card>\n *   )\n * }\n *\n * // Wrap the component with Suspense since the hook may suspend\n * function DashboardWorkspaces() {\n *   return (\n *     <Suspense fallback={<Button text=\"Loading...\" disabled />}>\n *       <WorkspacesCard />\n *     </Suspense>\n *   )\n * }\n * ```\n */\nexport function useStudioWorkspacesByProjectIdDataset(): StudioWorkspacesResult {\n  const [workspacesByProjectIdAndDataset, setWorkspacesByProjectIdAndDataset] =\n    useState<WorkspacesByProjectIdDataset>({})\n  const [error, setError] = useState<string | null>(null)\n\n  const {fetch} = useWindowConnection({\n    name: SDK_NODE_NAME,\n    connectTo: SDK_CHANNEL_NAME,\n  })\n\n  // Once computed, this should probably be in a store and poll for changes\n  // However, our stores are currently being refactored\n  useEffect(() => {\n    if (!fetch) return\n\n    async function fetchWorkspaces(signal: AbortSignal) {\n      try {\n        const data = await fetch<{\n          context: {availableResources: Array<DashboardResource>}\n        }>('dashboard/v1/context', undefined, {signal})\n\n        const workspaceMap: WorkspacesByProjectIdDataset = {}\n        const noProjectIdAndDataset: DashboardResource[] = []\n\n        data.context.availableResources.forEach((resource) => {\n          if (resource.type !== 'studio') return\n          if (!resource.projectId || !resource.dataset) {\n            noProjectIdAndDataset.push(resource)\n            return\n          }\n          const key = `${resource.projectId}:${resource.dataset}` as const\n          if (!workspaceMap[key]) {\n            workspaceMap[key] = []\n          }\n          workspaceMap[key].push(resource)\n        })\n\n        if (noProjectIdAndDataset.length > 0) {\n          workspaceMap['NO_PROJECT_ID:NO_DATASET'] = noProjectIdAndDataset\n        }\n\n        setWorkspacesByProjectIdAndDataset(workspaceMap)\n        setError(null)\n      } catch (err: unknown) {\n        if (err instanceof Error) {\n          if (err.name === 'AbortError') {\n            return\n          }\n          setError('Failed to fetch workspaces')\n        }\n      }\n    }\n\n    const controller = new AbortController()\n    fetchWorkspaces(controller.signal)\n\n    return () => {\n      controller.abort()\n    }\n  }, [fetch])\n\n  return {\n    workspacesByProjectIdAndDataset,\n    error,\n  }\n}\n"],"mappings":";;;;;;;;;AAGA,MAAaE,wBAAwBD,cAAqC,IAAI,GCsBjEK,0BAAoB;CAC/B,IAAAC,WAAiBH,WAAWC,qBAAqB;CAEjD,IAAI,CAACE,UACH,MAAUC,MACR,gIACF;CACD,OAEMD;AAAQ;ACjBjB,SAAgBkB,sBACdC,SACgC;CAChC,IAAMN,WAAW,OAAOM,WAAY,aAAaA,UAAUA,QAAQN,UAC7DO,WAAW,mBAAmBD,WAAW,eAAeA,UAAUA,UAAUE,KAAAA;CAElF,SAAAC,QAAA,GAAAC,IAAA;EAAA,IAAAC,IAAAC,EAAA,CAAA,GAAiBhB,SAAAc,IACff,WAAiBF,kBAAkB;EAEnC,IAAIc,UAAQL,aAAeK,UAAQN,gBAAkBN,UAAQ,GAAKC,MAAM,GACtE,MAAMW,SAAQL,UAAWP,UAAQ,GAAKC,MAAM;EAC7C,IAAAiB;EAAA,AAAAF,EAAA,OAAAhB,YAAAgB,EAAA,OAAAf,UAEaiB,KAAAb,SAASL,UAAQ,GAAKC,MAAM,GAACe,EAAA,KAAAhB,UAAAgB,EAAA,KAAAf,QAAAe,EAAA,KAAAE,MAAAA,KAAAF,EAAA;EAA3C,IAAAG,QAAcD;EAA6B,OACpCrB,qBAAqBsB,MAAKC,WAAYD,MAAKE,UAAW;CAAC;CAGhE,OAAOP;AACT;;;;;;;;;;;;;;;;;;;;;;ACVA,MAAaW,eAAgCD,sBAAsBD,YAAY,GCwBzEyC,eAAexB,sBAAsB;CACzCyB,UAAUlC;CAIVqC,gBAAgBF,UAA0BC,cACxCpC,aAAamC,UAAUC,SAAS,CAAC,CAACE,WAAW,MAAMC,KAAAA;CACrDC,YAAYL,UAA0BC,cAC7B7B,eAAeP,aAAamC,UAAUC,SAAS,CAAC,CAACK,WAAWC,KAAKpC,OAAOqC,OAAO,CAAC,CAAC;AAE5F,CAAC;;;;;;;;;;AAWD,SAAOC,oBAAAC,IAAA;CAAA,IAAAC,IAAAC,EAAA,EAAA,GAGL,EAAAjC,MAAAC,WAAAC,cAAA6B,IAI0CG;CAAA,AAAAF,EAAA,OAAA/B,aAAA+B,EAAA,OAAAhC,QACdkC,KAAA;EAAAlC;EAAAC;CAAgB,GAAC+B,EAAA,KAAA/B,WAAA+B,EAAA,KAAAhC,MAAAgC,EAAA,KAAAE,MAAAA,KAAAF,EAAA;CAA7C,IAAA,EAAAG,SAAehB,aAAae,EAAiB,GAACE;CAAA,AAAAJ,EAAA,OAAAK,OAAAC,IAAA,2BAAA,KACMF,KAAA,CAAA,GAAEJ,EAAA,KAAAI,MAAAA,KAAAJ,EAAA;CAAtD,IAAAO,uBAA6BhD,OAAuB6C,EAAE,GACtDf,WAAiB3B,kBAAkB,GAAC8C;CAAA,AAAAR,EAAA,OAAAG,QAAAH,EAAA,OAAA9B,aAE1BsC,YACJtC,aACFuC,OAAMC,QAASxC,SAAS,CAAC,CAAAyC,SAASC,OAAA;EAAC,IAAA,CAAArC,MAAAsC,WAAAD,IACjCE,qBAA2BX,KAAIY,GAAIxC,MAAMsC,OAA8C;EACvF,AAAIC,sBACFP,qBAAoBS,QAAQC,KAAMH,kBAAkB;CACrD,CACF,SAGI;EAELP,AADAA,qBAAoBS,QAAQL,QAASO,KAA8B,GACnEX,qBAAoBS,UAAW,CAAA;CAAH,IAE/BhB,EAAA,KAAAG,MAAAH,EAAA,KAAA9B,WAAA8B,EAAA,KAAAQ,MAAAA,KAAAR,EAAA;CAAA,IAAAY;CAdDtD,AAcC0C,EAAA,OAAAX,YAAAW,EAAA,OAAAhC,QAAAgC,EAAA,OAAAG,QAAAH,EAAA,QAAA9B,aAAE0C,KAAA;EAACvB;EAAUrB;EAAME;EAAWiC;CAAI,GAACH,EAAA,KAAAX,UAAAW,EAAA,KAAAhC,MAAAgC,EAAA,KAAAG,MAAAH,EAAA,MAAA9B,WAAA8B,EAAA,MAAAY,MAAAA,KAAAZ,EAAA,KAdpC1C,UAAUkD,IAcPI,EAAiC;CAAC,IAAAO;CAAA,AAAAnB,EAAA,QAAAG,OAKlCgB,KAAAnB,EAAA,OAFDmB,MAAAC,QAAA3C,SAAA;EACE0B,KAAIkB,KAAM9C,QAAME,IAAI;CAAC,GACtBuB,EAAA,MAAAG,MAAAH,EAAA,MAAAmB;CAHH,IAAA7C,cAAoB6C,IAKnBG;CAAA,AAAAtB,EAAA,QAAAG,OAaEmB,KAAAtB,EAAA,OAVDsB,MAAAC,QAAAC,QAAAC,iBASStB,KAAIxB,MAAOJ,QAAME,QAAMgD,gBAAA,CAAiB,CAAC,GACjDzB,EAAA,MAAAG,MAAAH,EAAA,MAAAsB;CAXH,IAAA3C,QAAc2C,IAabI;CAIA,OAJA1B,EAAA,QAAArB,SAAAqB,EAAA,QAAA1B,eACMoD,KAAA;EAAApD;EAAAK;CAGP,GAACqB,EAAA,MAAArB,OAAAqB,EAAA,MAAA1B,aAAA0B,EAAA,MAAA0B,MAAAA,KAAA1B,EAAA,KAHM0B;AAGN;AApDI,SAAAR,MAAAS,aAAA;CAAA,OAuBqDA,YAAY;AAAC;ACvFzE,MAAMM,aAAaC,OAAOC,IAAI,eAAe;;;;;;;;;;;;;AAc7C,SAAgBC,yBAAkC;CAChD,OAAO,OAAOC,cAAe,YAAYJ,cAAcI;AACzD;;;;;;;;;;;;;;AAeA,SAAgBC,wBAA+D;CACxEF,2BAAuB,GAE5B,OAAOR,KAAK,OAAO,oBAAoB,CAAC,CAACY,KACvCR,aAAW,EAACS,SAAQA,GAAGC,UAAU,YAAY,CAAC,GAE9CX,iBAAiBD,GAAG,IAAI,CAAC,CAC3B;AACF;;;;;;;;;AAUA,SAAgBa,wBAA8B;CACvCP,uBAAuB,KAE5B,OAAY,oBAAoB,CAACQ,MAC9B,EAACH,SAAQA,GAAGI,KAAK,sBAAsBN,KAAAA,CAAS,SAC3C,CAAC,CACT;AACF;;;;;;;;;;;ACxCA,SAAAmB,sBAAAC,IAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GAA+B,EAAAC,aAAAH,IAC7BI,WAAiBT,kBAAkB,GACnCU,YAAkBX,aAAa,GAC/BY,uBAA6Bb,OAAuB,IAAI,GAACc,IAAAC;CAEzDhB,AAFyDS,EAAA,OAAAG,YAO5CG,KAAAN,EAAA,IAAAO,KAAAP,EAAA,OALHM,WAAA;EACR,IAAAE,SAAeZ,sBAAsB;EACrC,IAAI,CAACY,QAAM;EACX,IAAAC,eAAqBD,OAAME,WAAWC,UAAWvB,aAAae,UAAUQ,KAAK,CAAC;EAAC,aAClEF,aAAYG,YAAa;CAAC,GACtCL,KAAA,CAACJ,QAAQ,GAACH,EAAA,KAAAG,UAAAH,EAAA,KAAAM,IAAAN,EAAA,KAAAO,KALbhB,UAAUe,IAKPC,EAAU;CAAC,IAAAM;CAAA,AAAAb,EAAA,OAAAI,UAAAU,SAAAd,EAAA,OAAAI,UAAAW,QAEJF,WAAA;EACR,IAAAG,cACEZ,UAASW,SAAU5B,cAAa8B,SAAWb,UAASU,OAAkCI,eAAK;EAE7F,AAAIF,eAAeX,qBAAoBc,YAAaf,UAASU,SAC3DT,qBAAoBc,UAAWf,UAASU,OACxCjB,sBAAsB,KACZmB,gBACVX,qBAAoBc,UAAW;CAChC,GACFnB,EAAA,KAAAI,UAAAU,OAAAd,EAAA,KAAAI,UAAAW,MAAAf,EAAA,KAAAa,MAAAA,KAAAb,EAAA;CAAA,IAAAoB;CAAc,OAAdpB,EAAA,OAAAI,YAAagB,KAAApB,EAAA,MAAXoB,KAAA,CAAChB,SAAS,GAACJ,EAAA,KAAAI,WAAAJ,EAAA,KAAAoB,KAVd7B,UAAUsB,IAUPO,EAAW,GAEPlB;AAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CjB,MAAamB,iCAA6DtB,OAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GAAC,EAAAC,aAAAH;CACzE,IAAIJ,uBAAuB,GAAC;EAAA,IAAAW;EACsC,OADtCN,EAAA,OAAAE,WACsCI,KAAAN,EAAA,MAAzDM,KAAA,oBAAC,uBAAD,EAAwBJ,SAAF,CAAA,GAAmCF,EAAA,KAAAE,UAAAF,EAAA,KAAAM,KAAzDA;CAAyD;CACjE,OAEMJ;AAAQ;;;;;;;;;;;;;;;;;;;;ACrEjB,SAAOyB,oBAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GACLC,WAAiBJ,kBAAkB,GAACK;CAAA,AAAAH,EAAA,OAAAE,WAC8CC,KAAAH,EAAA,MAApCG,KAAAR,2BAA2BO,QAAQ,GAACF,EAAA,KAAAE,UAAAF,EAAA,KAAAG;CAAlF,IAAA,EAAAC,WAAAC,eAA8CF;CAAiD,OAExFN,qBAAqBO,WAAWC,UAAU;AAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;ACgCpD,SAAOqB,wCAAA;CAAA,IAAAC,IAAAC,EAAA,CAAA,GAAAC;CAAA,AAAAF,EAAA,OAAAG,OAAAC,IAAA,2BAAA,KAEoCF,KAAA,CAAC,GAACF,EAAA,KAAAE,MAAAA,KAAAF,EAAA;CAD3C,IAAA,CAAAH,iCAAAQ,sCACEvB,SAAuCoB,EAAE,GAC3C,CAAAJ,OAAAQ,YAA0BxB,SAAwB,IAAI,GAACyB;CAAA,AAAAP,EAAA,OAAAG,OAAAC,IAAA,2BAAA,KAEnBG,KAAA;EAAArB,MAC5BN;EAAa4B,WACR7B;CACb,GAACqB,EAAA,KAAAO,MAAAA,KAAAP,EAAA;CAHD,IAAA,EAAAS,UAAgB1B,oBAAoBwB,EAGnC,GAACG,IAAAC;CAIF9B,AAJEmB,EAAA,OAAAS,SAmDQC,KAAAV,EAAA,IAAAW,KAAAX,EAAA,OA/CAU,WAAA;EACR,IAAI,CAACD,OAAK;EAEV,IAAAG,kBAAA,eAAAA,gBAAAC,QAAA;GACE,IAAA;IACE,IAAAC,OAAa,MAAML,MAEhB,wBAAwBM,KAAAA,GAAW,EAAAF,OAAO,CAAC,GAE9CG,eAAmD,CAAC,GACpDC,wBAAmD,CAAA;IAoBnDX,AAlBAQ,KAAII,QAAQC,mBAAmBC,SAASC,aAAA;KACtC,IAAIA,SAAQ9B,SAAU,UAAQ;KAC9B,IAAI,CAAC8B,SAAQhC,aAAT,CAAwBgC,SAAQ/B,SAAQ;MAC1C2B,sBAAqBK,KAAMD,QAAQ;MAAC;KAAA;KAGtC,IAAA1B,MAAY,GAAG0B,SAAQhC,UAAU,GAAIgC,SAAQ/B;KAI7C0B,AAHKA,aAAarB,SAChBqB,aAAarB,OAAO,CAAA,IAEtBqB,aAAarB,IAAI,CAAA2B,KAAMD,QAAQ;IAAC,CACjC,GAEGJ,sBAAqBO,SAAU,MACjCR,aAAa,8BAA8BC,wBAG7CZ,mCAAmCW,YAAY,GAC/CV,SAAS,IAAI;GAAC,SAAAmB,IAAA;IACPC,IAAAA,MAAAA;IACP,IAAIA,eAAeC,OAAK;KACtB,IAAID,IAAGxC,SAAU,cAAY;KAG7BoB,SAAS,4BAA4B;IAAC;GACvC;EACF,GAGHsB,aAAmB,IAAIC,gBAAgB;EACL,OAAlCjB,gBAAgBgB,WAAUf,MAAO,SAE1B;GACLe,WAAUE,MAAO;EAAC;CACnB,GACAnB,KAAA,CAACF,KAAK,GAACT,EAAA,KAAAS,OAAAT,EAAA,KAAAU,IAAAV,EAAA,KAAAW,KA/CV9B,UAAU6B,IA+CPC,EAAO;CAAC,IAAAc;CAKV,OALUzB,EAAA,OAAAF,SAAAE,EAAA,OAAAH,mCAEJ4B,KAAA;EAAA5B;EAAAC;CAGP,GAACE,EAAA,KAAAF,OAAAE,EAAA,KAAAH,iCAAAG,EAAA,KAAAyB,MAAAA,KAAAzB,EAAA,IAHMyB;AAGN"}