@sanity/client 8.2.0 → 8.4.0

package/src/context/types.ts

@@ -0,0 +1,228 @@
+import type {
+  ListenOptions,
+  RequestOptions as MainRequestOptions,
+  ResumableListenOptions,
+  UploadBody,
+} from '../types'
+import type {components, paths} from './types.gen'
+
+/** Options accepted by every Context method. @beta */
+export type RequestOptions = {signal?: AbortSignal; tag?: string}
+
+/** @internal */
+export const possibleStoreRequestOptions = ['headers', 'signal', 'tag', 'timeout', 'token'] as const
+
+/**
+ * Request options honored by `context.fetch`.
+ *
+ * @beta
+ */
+export type ContextRequestOptions = Pick<
+  MainRequestOptions,
+  (typeof possibleStoreRequestOptions)[number]
+>
+
+/**
+ * Listener options for `context.listen`.
+ *
+ * `includeAllVersions` is left out: Context documents are written by the
+ * Context API with no drafts or versions, so it would never make a
+ * difference.
+ *
+ * @beta
+ */
+export type ContextListenOptions =
+  | Omit<ListenOptions, 'includeAllVersions'>
+  | Omit<ResumableListenOptions, 'includeAllVersions'>
+
+/**
+ * A file import. The client stages the upload, PUTs the bytes straight to
+ * storage with a signed URL, and confirms. The Context API never holds the
+ * file content.
+ * @beta
+ */
+export type CreateFileImportParams = {
+  type: 'file'
+  /** Same shapes `assets.upload` accepts, minus node streams: the bytes go
+   * out through `fetch`, which has no portable stream support. */
+  file: Exclude<UploadBody, NodeJS.ReadableStream>
+  filename: string
+  contentType?: string
+}
+
+type KnowledgeBasesPath = '/{apiVersion}/context/knowledge-bases'
+type ConversationPath =
+  '/{apiVersion}/context/organizations/{organizationId}/conversations/{threadId}'
+type KnowledgeBasePath = '/{apiVersion}/context/knowledge-bases/{knowledgeBaseId}'
+type ImportsPath = `${KnowledgeBasePath}/imports`
+type ImportPath = `${KnowledgeBasePath}/imports/{importId}`
+type UploadsPath = `${KnowledgeBasePath}/imports/uploads`
+type EntryRebuildPath = `${KnowledgeBasePath}/entries/{entryPath}/rebuild`
+type SourcesPath = `${KnowledgeBasePath}/sources`
+type SourcePath = `${KnowledgeBasePath}/sources/{sourceId}`
+type SourceContentPath = `${KnowledgeBasePath}/sources/{sourceId}/content`
+type IssuesApplyPath = `${KnowledgeBasePath}/issues/apply`
+type InstructionPath = `${KnowledgeBasePath}/instructions/{instructionId}`
+type JobPath = `${KnowledgeBasePath}/jobs/{jobId}`
+type IssueResolvePath = `${KnowledgeBasePath}/issues/{issueId}/resolve`
+type IssueDismissPath = `${KnowledgeBasePath}/issues/{issueId}/dismiss`
+type IssueReopenPath = `${KnowledgeBasePath}/issues/{issueId}/reopen`
+type InstructionsPath = `${KnowledgeBasePath}/instructions`
+
+type JsonResponse<T> = T extends {content: {'application/json': infer R}} ? R : never
+type JsonBody<T> = T extends {
+  requestBody: {content: {'application/json': infer R}}
+}
+  ? R
+  : never
+
+/**
+ * A knowledge base: one buildable body of knowledge inside Context.
+ * @beta
+ */
+export type KnowledgeBase = JsonResponse<paths[KnowledgeBasePath]['get']['responses']['200']>
+
+/**
+ * Parameters for creating a knowledge base.
+ * @beta
+ */
+export type CreateKnowledgeBaseParams = JsonBody<paths[KnowledgeBasesPath]['post']>
+/** @beta */
+export type EditKnowledgeBaseParams = JsonBody<paths[KnowledgeBasePath]['patch']>
+
+/**
+ * Parameters for importing content. Discriminated on `type`:
+ * inline text, a website crawl, or a Sanity dataset bind.
+ * @beta
+ */
+export type CreateImportParams = JsonBody<paths[ImportsPath]['post']>
+
+/**
+ * Accepted async work. Poll the job with `jobs.get` until it reaches a
+ * terminal state.
+ * @beta
+ */
+export type JobAccepted = JsonResponse<
+  paths[`${KnowledgeBasePath}/build`]['post']['responses']['202']
+>
+
+/** @beta */
+export type Job = JsonResponse<paths[JobPath]['get']['responses']['200']>
+
+/**
+ * Accepted entry rebuild: the job to poll plus every entry the rebuild
+ * touches.
+ * @beta
+ */
+export type RebuildEntryResponse = JsonResponse<paths[EntryRebuildPath]['post']['responses']['202']>
+
+/** @beta */
+export type ApplyIssuesParams = JsonBody<paths[IssuesApplyPath]['post']>
+/** @beta */
+export type ApplyIssuesResponse = JsonResponse<paths[IssuesApplyPath]['post']['responses']['202']>
+/** @beta */
+export type ResolveIssueParams = JsonBody<paths[IssueResolvePath]['post']>
+/** @beta */
+export type ResolveIssueResponse = JsonResponse<paths[IssueResolvePath]['post']['responses']['200']>
+/** @beta */
+export type DismissIssueResponse = JsonResponse<paths[IssueDismissPath]['post']['responses']['200']>
+/** @beta */
+export type ReopenIssueResponse = JsonResponse<paths[IssueReopenPath]['post']['responses']['200']>
+
+/** @beta */
+export type CreateInstructionParams = JsonBody<paths[InstructionsPath]['post']>
+/**
+ * A standing instruction, as the instruction endpoints return it.
+ * @beta
+ */
+export type Instruction = JsonResponse<paths[InstructionPath]['patch']['responses']['200']>
+/** The created instruction, wrapped the way the create endpoint returns it. @beta */
+export type CreateInstructionResponse = JsonResponse<
+  paths[InstructionsPath]['post']['responses']['201']
+>
+/** @beta */
+export type EditInstructionParams = JsonBody<paths[InstructionPath]['patch']>
+
+/** @beta */
+export type KnowledgeBasesResponse = JsonResponse<
+  paths[KnowledgeBasesPath]['get']['responses']['200']
+>
+
+/** @beta */
+export type ImportsResponse = JsonResponse<paths[ImportsPath]['get']['responses']['200']>
+/** @beta */
+export type Import = ImportsResponse['data'][number]
+/** @beta */
+export type ImportDetail = JsonResponse<paths[ImportPath]['get']['responses']['200']>
+/** @beta */
+export type ImportDownloadResponse = JsonResponse<
+  paths[`${ImportPath}/download`]['get']['responses']['200']
+>
+
+/**
+ * The staged half of a file upload: PUT the bytes to `uploadUrl`, then
+ * confirm with the complete endpoint. `imports.create({type: 'file'})` does
+ * all of this in one call.
+ * @beta
+ */
+export type StagedUpload = JsonResponse<paths[UploadsPath]['post']['responses']['201']>
+
+/** @beta */
+export type SourcesResponse = JsonResponse<paths[SourcesPath]['get']['responses']['200']>
+/** @beta */
+export type Source = SourcesResponse['data'][number]
+/** @beta */
+export type SourceDetail = JsonResponse<paths[SourcePath]['get']['responses']['200']>
+/** @beta */
+export type SourceContentResponse = JsonResponse<
+  paths[SourceContentPath]['get']['responses']['200']
+>
+
+/**
+ * A recorded conversation: one agent thread's transcript plus the
+ * classification recorded on it. Standalone org-level telemetry — dimensions
+ * (MCP endpoints, app, the customer's own keys) live in the `metadata` bag.
+ * @beta
+ */
+export type Conversation = JsonResponse<paths[ConversationPath]['put']['responses']['200']>
+/**
+ * Body for the conversation ingest upsert. Messages replace the stored
+ * transcript wholesale; `metadata` and model fields only overwrite when
+ * present.
+ * @beta
+ */
+export type SaveConversationParams = JsonBody<paths[ConversationPath]['put']>
+/** Exactly one of a verdict (`coreMetrics`) or a failure (`classificationError`). @beta */
+export type ClassifyConversationParams = JsonBody<paths[ConversationPath]['patch']>
+
+/**
+ * The raw `sanity.context.entry` document shape, as stored in the
+ * organization's document store. For typing GROQ reads.
+ * @beta
+ */
+export type EntryDoc = components['schemas']['EntryDoc']
+/** @beta */
+export type IssueDoc = components['schemas']['IssueDoc']
+/** @beta */
+export type InstructionDoc = components['schemas']['InstructionDoc']
+/**
+ * The raw `sanity.context.mcp` document shape (an MCP endpoint
+ * configuration), as stored in the organization's document store. For
+ * typing GROQ reads.
+ * @beta
+ */
+export type McpDoc = components['schemas']['McpDoc']
+
+/**
+ * The metadata view of an entry, as `entries.list` projects it. Bodies stay
+ * behind `entries.get` (or a GROQ read through `context.fetch`).
+ * @beta
+ */
+export type Entry = Pick<EntryDoc, '_id' | 'path' | 'title' | 'tldr' | 'status'>
+
+/**
+ * The raw `sanity.context.conversation` document shape, as stored in the
+ * organization's document store. For typing GROQ reads.
+ * @beta
+ */
+export type ConversationDoc = components['schemas']['ConversationDoc']

package/src/data/dataMethods.ts

@@ -1128,7 +1128,7 @@ export function _prepareRequest(client: Client, options: RequestObservableOption
  *
  * @internal
  */
-function _observe<R>(
+export function _observe<R>(
   userSignal: AbortSignal | undefined,
   run: (signal: AbortSignal) => Promise<R>,
 ): Observable<R> {
@@ -1291,6 +1291,9 @@ const resourceDataBase = (config: InitializedClientConfig): string => {
     case 'canvas': {
       return `/canvases/${id}`
     }
+    case 'knowledge-base': {
+      return `/knowledge-bases/${id}`
+    }
     case 'media-library': {
       return `/media-libraries/${id}`
     }

package/src/defineCreateClient.ts

@@ -26,6 +26,7 @@ export {
   isQueryParseError,
   ServerError,
 } from './http/errors'
+export * as Context from './context/types'
 export * from './SanityClient'
 export * from './types'
 

package/src/functions/FunctionsClient.ts

@@ -2,7 +2,7 @@ import {lastValueFrom, type Observable} from 'rxjs'
 
 import type {ObservableSanityClient, SanityClient} from '../SanityClient'
 import type {HttpRequest} from '../types'
-import {_invoke, type InvokeFunctionRequest} from './invoke'
+import {_invoke, type InvokeFunctionOptions, type InvokeFunctionRequest} from './invoke'
 
 /** @public */
 export class ObservableFunctionsClient {
@@ -17,16 +17,36 @@ export class ObservableFunctionsClient {
    * Invoke a deployed function by its blueprint name.
    *
    * The name is resolved within the stack given by `stackId` on the request or
-   * the client config. Passes the function's return value once it finishes.
+   * the client config. Starts the invocation and emits `undefined` as soon as
+   * it is accepted; pass `{sync: true}` to wait for the function's return value
+   * instead.
    *
    * @param functionName - name of the function, as declared in the blueprint
    * @param request - payload and request options
+   * @param options - invocation options
    */
+  invoke(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions & {sync?: false},
+  ): Observable<undefined>
+  invoke<R = unknown>(
+    functionName: string,
+    request: InvokeFunctionRequest | undefined,
+    options: InvokeFunctionOptions & {sync: true},
+  ): Observable<R>
+  invoke<R = unknown>(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions,
+  ): Observable<R | undefined>
+  // Implementation signature — not part of the public API.
   invoke<R = unknown>(
     functionName: string,
     request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions,
   ): Observable<R | undefined> {
-    return _invoke<R>(this.#client, this.#httpRequest, functionName, request)
+    return _invoke<R>(this.#client, this.#httpRequest, functionName, request, options)
   }
 }
 
@@ -44,23 +64,46 @@ export class FunctionsClient {
    *
    * The name is resolved within the stack given by `stackId` on the request or
    * the client config, which costs one extra request per call. Rejects if the
-   * stack has no function by that name, or if the name resolves to anything
-   * other than a `sanity.function.pubsub` function.
+   * stack has no function by that name, or if the name resolves to a function
+   * type that cannot be invoked the way it was asked for.
    *
    * The lookup is scoped to `projectId`, or to `organizationId` when one is set
    * for a stack deployed at organization scope.
    *
-   * The request stays open until the function finishes, and resolves with its
-   * return value, or `undefined` if it returns nothing. Long-running functions
-   * may need an explicit `timeout`.
+   * The invocation is started by default: the promise resolves with `undefined`
+   * as soon as the call is accepted, without waiting for the function to run.
+   * Pass `{sync: true}` to keep the request open until the function finishes
+   * and resolve with its return value — long-running functions may then need an
+   * explicit `timeout`. Only `sanity.function.pubsub` functions can be invoked
+   * synchronously.
    *
    * @param functionName - name of the function, as declared in the blueprint
    * @param request - payload and request options
+   * @param options - invocation options
    */
+  invoke(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions & {sync?: false},
+  ): Promise<undefined>
+  invoke<R = unknown>(
+    functionName: string,
+    request: InvokeFunctionRequest | undefined,
+    options: InvokeFunctionOptions & {sync: true},
+  ): Promise<R>
+  invoke<R = unknown>(
+    functionName: string,
+    request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions,
+  ): Promise<R | undefined>
+  // Implementation signature — not part of the public API.
   invoke<R = unknown>(
     functionName: string,
     request?: InvokeFunctionRequest,
+    options?: InvokeFunctionOptions,
   ): Promise<R | undefined> {
-    return lastValueFrom(_invoke<R>(this.#client, this.#httpRequest, functionName, request))
+    return lastValueFrom(
+      _invoke<R>(this.#client, this.#httpRequest, functionName, request, options),
+    )
   }
 }

package/src/functions/invoke.ts

@@ -6,7 +6,15 @@ import type {HttpRequest, InitializedClientConfig} from '../types'
 
 /** Function resource types in a blueprint are namespaced under this prefix. */
 const FUNCTION_RESOURCE_PREFIX = 'sanity.function.'
-const INVOKABLE_FUNCTION_TYPE = 'sanity.function.pubsub'
+const SYNC_INVOCABLE_FUNCTION_TYPES = ['sanity.function.pubsub']
+const ASYNC_INVOCABLE_FUNCTION_TYPES = [
+  'sanity.function.durable',
+  'sanity.function.pubsub',
+  'sanity.function.queue',
+]
+const INVOCABLE_FUNCTION_TYPES = [
+  ...new Set([...SYNC_INVOCABLE_FUNCTION_TYPES, ...ASYNC_INVOCABLE_FUNCTION_TYPES]),
+]
 
 /** @public */
 export interface InvokeFunctionEvent {
@@ -37,6 +45,18 @@ export interface InvokeFunctionRequest {
   signal?: AbortSignal
 }
 
+/** @public */
+export interface InvokeFunctionOptions {
+  /**
+   * Wait for the function to finish and resolve with its return value.
+   *
+   * Defaults to `false`: the invocation is started, the request resolves as soon
+   * as it is accepted, and the value is always `undefined`. Only function types
+   * that support running inline can be invoked synchronously.
+   */
+  sync?: boolean
+}
+
 /**
  * Subset of a stack resource the client needs in order to resolve a name.
  *
@@ -109,6 +129,7 @@ function _resolveFunctionId(
   stackId: string,
   headers: Record<string, string>,
   request: InvokeFunctionRequest | undefined,
+  sync: boolean,
 ): Observable<string> {
   return _requestObservable<{resources?: StackResource[]}>(client, httpRequest, {
     method: 'GET',
@@ -132,9 +153,15 @@ function _resolveFunctionId(
         )
       }
 
-      if (match.type !== INVOKABLE_FUNCTION_TYPE) {
+      if (!INVOCABLE_FUNCTION_TYPES.includes(match.type)) {
         throw new Error(`Function invocation is not supported for ${match.type}`)
       }
+      if (sync && !SYNC_INVOCABLE_FUNCTION_TYPES.includes(match.type)) {
+        throw new Error(`Synchronous function invocation is not supported for ${match.type}`)
+      }
+      if (!sync && !ASYNC_INVOCABLE_FUNCTION_TYPES.includes(match.type)) {
+        throw new Error(`Asynchronous function invocation is not supported for ${match.type}`)
+      }
 
       return match.externalId
     }),
@@ -147,6 +174,7 @@ export function _invoke<R = unknown>(
   httpRequest: HttpRequest,
   functionName: string,
   request?: InvokeFunctionRequest,
+  options?: InvokeFunctionOptions,
 ): Observable<R | undefined> {
   // Deferred so a bad config surfaces as an error on the returned observable
   // (and so a rejected promise) rather than throwing at the call site.
@@ -154,17 +182,30 @@ export function _invoke<R = unknown>(
     const config = client.config()
     const headers = scopeHeaders(config, request)
     const stackId = resolveStackId(config, request)
-
-    return _resolveFunctionId(client, httpRequest, functionName, stackId, headers, request).pipe(
-      // A function that returns nothing answers 204, which the transport parses
+    const sync = options?.sync ?? false
+
+    return _resolveFunctionId(
+      client,
+      httpRequest,
+      functionName,
+      stackId,
+      headers,
+      request,
+      sync,
+    ).pipe(
+      // An async invocation is only acknowledged (202, no body), and a sync
+      // function that returns nothing answers 204, which the transport parses
       // to an `undefined` body. The status code is not observable from here —
       // the `HttpRequest` boundary resolves to the body alone — so an empty
       // response and a function that returned nothing both surface as
       // `undefined`.
+      //
+      // The route is async by default, so `sync=false` is left off the wire
+      // rather than spelled out.
       mergeMap((functionId) =>
         _requestObservable<R | undefined>(client, httpRequest, {
           method: 'POST',
-          url: `/functions/${functionId}/invoke`,
+          url: `/functions/${functionId}/invoke${sync ? '?sync=true' : ''}`,
           headers,
           body: {event: {data: request?.event?.data ?? {}}},
           timeout: request?.timeout,

package/src/http/browserUpload.ts

@@ -1,14 +1,9 @@
-import {createDebug} from 'obug'
 import {Observable} from 'rxjs'
 
 import type {UploadEvent} from '../types'
 import {ClientError, httpResponseFromFetch, ServerError} from './errors'
 import {parseJsonText} from './request'
 
-const log = createDebug('sanity:client')
-
-let nextRequestId = 1
-
 /**
  * Options for a browser-side asset upload that needs progress events.
  *
@@ -36,11 +31,8 @@ export interface BrowserUploadOptions {
 export function uploadWithProgress<T>(options: BrowserUploadOptions): Observable<UploadEvent<T>> {
   return new Observable<UploadEvent<T>>((subscriber) => {
     const xhr = new XMLHttpRequest()
-    const requestId = nextRequestId++
     const {url, method, headers, body, withCredentials, timeout, signal} = options
 
-    log('[%d] %s %s (XHR upload with progress)', requestId, method, url)
-
     xhr.open(method, url)
     xhr.withCredentials = withCredentials
     if (typeof timeout === 'number' && timeout > 0) {
@@ -63,8 +55,6 @@ export function uploadWithProgress<T>(options: BrowserUploadOptions): Observable
     }
 
     xhr.onload = () => {
-      log('[%d] %s %s — %d', requestId, method, url, xhr.status)
-
       if (xhr.status >= 400) {
         // Same typed errors as the fetch transport, so consumers can keep
         // detecting `ClientError`/`ServerError` and reading `statusCode`,
@@ -100,12 +90,10 @@ export function uploadWithProgress<T>(options: BrowserUploadOptions): Observable
     }
 
     xhr.onerror = () => {
-      log('[%d] %s %s — network error', requestId, method, url)
       subscriber.error(new Error('XHR upload network error'))
     }
 
     xhr.ontimeout = () => {
-      log('[%d] %s %s — timed out after %dms', requestId, method, url, timeout)
       // Same error shape as the fetch transport's timeout rejection.
       subscriber.error(
         new DOMException(

package/src/types.ts

@@ -109,6 +109,10 @@ type ClientConfigResource =
       type: 'canvas'
       id: string
     }
+  | {
+      type: 'knowledge-base'
+      id: string
+    }
   | {
       type: 'media-library'
       id: string
@@ -314,6 +318,17 @@ export interface ClientConfig {
   collaboration?: {
     organizationId?: string
   }
+
+  /**
+   * Organization-scoped configuration for Context APIs.
+   *
+   * Currently this is used by `context.insights` methods.
+   *
+   * @beta
+   */
+  context?: {
+    organizationId?: string
+  }
 }
 
 /** @public */
@@ -620,6 +635,7 @@ export type DatasetAclMode = 'public' | 'private' | 'custom'
 /** @public */
 export type DatasetCreateOptions = {
   aclMode?: DatasetAclMode
+  description?: string
   embeddings?: {
     enabled: boolean
     projection?: string
@@ -629,6 +645,7 @@ export type DatasetCreateOptions = {
 /** @public */
 export type DatasetEditOptions = {
   aclMode?: DatasetAclMode
+  description?: string
 }
 
 /** @public */
@@ -645,17 +662,21 @@ export type EmbeddingsSettingsBody = {
 }
 
 /** @public */
-export type DatasetResponse = {datasetName: string; aclMode: DatasetAclMode}
+export type DatasetResponse = {datasetName: string; aclMode: DatasetAclMode; description: string}
 /** @public */
 export type DatasetsResponse = {
   name: string
   aclMode: DatasetAclMode
+  description: string
   createdAt: string
   createdByUserId: string
   addonFor: string | null
   datasetProfile: string
   features: string[]
-  tags: string[]
+  tags: {
+    name: string
+    title: string
+  }[]
 }[]
 
 /** @public */
@@ -2297,7 +2318,11 @@ export type {
   TranslateTarget,
   TranslateTargetInclude,
 } from './agent/actions/translate'
-export type {InvokeFunctionEvent, InvokeFunctionRequest} from './functions/invoke'
+export type {
+  InvokeFunctionEvent,
+  InvokeFunctionOptions,
+  InvokeFunctionRequest,
+} from './functions/invoke'
 export type {
   CollaborationCommentCreate,
   CollaborationCommentDocument,
@@ -2312,6 +2337,7 @@ export type {
   CollaborationCommentTarget,
   CollaborationCommentUpdate,
   CollaborationCommentRange,
+  CollaborationCommentFieldValue,
 } from './collaboration/types'
 export type {
   ContentSourceMapParsedPath,

package/src/util/createVersionId.ts

@@ -5,20 +5,30 @@ import {
   isDraftId,
   isVersionId,
 } from '@sanity/client/csm'
-import {customAlphabet} from 'nanoid'
 
 import type {IdentifiedSanityDocumentStub, SanityDocumentStub} from '../types'
 import {validateVersionIdMatch} from '../validators'
 
+const alphabet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'
+
 /**
  * @internal
  *
  * ~24 years (or 7.54e+8 seconds) needed, in order to have a 1% probability of at least one collision if 10 ID's are generated every hour.
  */
-export const generateReleaseId = customAlphabet(
-  'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789',
-  8,
-)
+export function generateReleaseId() {
+  let id = ''
+
+  while (id.length < 8) {
+    const bytes = crypto.getRandomValues(new Uint8Array(8 - id.length))
+    for (const byte of bytes) {
+      const index = byte & 63
+      if (index < alphabet.length) id += alphabet[index]
+    }
+  }
+
+  return id
+}
 
 /** @internal */
 export const getDocumentVersionId = (publishedId: string, releaseId?: string) =>

package/src/validators.ts

@@ -128,6 +128,7 @@ export const resourceConfig = (config: InitializedClientConfig): void => {
       return
     }
     case 'dashboard':
+    case 'knowledge-base':
     case 'media-library':
     case 'canvas': {
       return

package/dist/browserUpload-2tz6Sdqp.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browserUpload-2tz6Sdqp.js","names":[],"sources":["../src/http/browserUpload.ts"],"sourcesContent":["import {createDebug} from 'obug'\nimport {Observable} from 'rxjs'\n\nimport type {UploadEvent} from '../types'\nimport {ClientError, httpResponseFromFetch, ServerError} from './errors'\nimport {parseJsonText} from './request'\n\nconst log = createDebug('sanity:client')\n\nlet nextRequestId = 1\n\n/**\n * Options for a browser-side asset upload that needs progress events.\n *\n * @internal\n */\nexport interface BrowserUploadOptions {\n  url: string\n  method: string\n  headers: Record<string, string>\n  body: unknown\n  withCredentials: boolean\n  /** Milliseconds before the upload is aborted; `false` and `0` both disable the timeout. */\n  timeout?: number | false\n  signal?: AbortSignal\n}\n\n/**\n * Run an asset upload through `XMLHttpRequest` so we can surface per-chunk\n * upload progress events. get-it v9 / fetch has no equivalent hook in the\n * browser, so the observable asset-upload API falls back to this path when\n * `XMLHttpRequest` is available.\n *\n * @internal\n */\nexport function uploadWithProgress<T>(options: BrowserUploadOptions): Observable<UploadEvent<T>> {\n  return new Observable<UploadEvent<T>>((subscriber) => {\n    const xhr = new XMLHttpRequest()\n    const requestId = nextRequestId++\n    const {url, method, headers, body, withCredentials, timeout, signal} = options\n\n    log('[%d] %s %s (XHR upload with progress)', requestId, method, url)\n\n    xhr.open(method, url)\n    xhr.withCredentials = withCredentials\n    if (typeof timeout === 'number' && timeout > 0) {\n      xhr.timeout = timeout\n    }\n\n    for (const [key, value] of Object.entries(headers)) {\n      xhr.setRequestHeader(key, value)\n    }\n\n    xhr.upload.onprogress = (e) => {\n      subscriber.next({\n        type: 'progress',\n        stage: 'upload',\n        percent: e.lengthComputable ? Math.round((e.loaded / e.total) * 100) : 0,\n        total: e.total || undefined,\n        loaded: e.loaded,\n        lengthComputable: e.lengthComputable,\n      })\n    }\n\n    xhr.onload = () => {\n      log('[%d] %s %s — %d', requestId, method, url, xhr.status)\n\n      if (xhr.status >= 400) {\n        // Same typed errors as the fetch transport, so consumers can keep\n        // detecting `ClientError`/`ServerError` and reading `statusCode`,\n        // `responseBody` and the structured API `details` on failed uploads.\n        const errorHeaders = parseXhrResponseHeaders(xhr.getAllResponseHeaders())\n        const canonical = httpResponseFromFetch(\n          {\n            status: xhr.status,\n            statusText: xhr.statusText,\n            headers: errorHeaders,\n            body: parseJsonText(xhr.responseText, errorHeaders),\n            url: xhr.responseURL,\n          },\n          url,\n          method,\n        )\n        subscriber.error(\n          xhr.status >= 500 ? new ServerError(canonical) : new ClientError(canonical),\n        )\n        return\n      }\n\n      let responseBody: T\n      try {\n        responseBody = JSON.parse(xhr.responseText) as T\n      } catch {\n        subscriber.error(new Error('Failed to parse upload response as JSON'))\n        return\n      }\n\n      subscriber.next({type: 'response', body: responseBody})\n      subscriber.complete()\n    }\n\n    xhr.onerror = () => {\n      log('[%d] %s %s — network error', requestId, method, url)\n      subscriber.error(new Error('XHR upload network error'))\n    }\n\n    xhr.ontimeout = () => {\n      log('[%d] %s %s — timed out after %dms', requestId, method, url, timeout)\n      // Same error shape as the fetch transport's timeout rejection.\n      subscriber.error(\n        new DOMException(\n          `The operation timed out after ${timeout}ms while attempting to reach ${url}`,\n          'TimeoutError',\n        ),\n      )\n    }\n\n    xhr.onabort = () => {\n      subscriber.error(new DOMException('Upload aborted', 'AbortError'))\n    }\n\n    const onSignalAbort = () => xhr.abort()\n    if (signal) {\n      if (signal.aborted) {\n        // `xhr.abort()` before `send()` fires no `abort` event per spec, so\n        // error out directly instead of relying on `onabort`.\n        subscriber.error(new DOMException('Upload aborted', 'AbortError'))\n        return undefined\n      }\n      signal.addEventListener('abort', onSignalAbort, {once: true})\n    }\n\n    xhr.send(body as XMLHttpRequestBodyInit)\n\n    // Unsubscribing cancels the in-flight upload, mirroring how the fetch\n    // path aborts its request (`_observe`). After settle this is a no-op —\n    // except for detaching from the caller's signal, which may be long-lived\n    // and must not accumulate a listener per upload.\n    return () => {\n      signal?.removeEventListener('abort', onSignalAbort)\n      xhr.abort()\n    }\n  })\n}\n\n/**\n * Parse `XMLHttpRequest.getAllResponseHeaders()` output (CRLF-separated\n * `name: value` lines) into a `Headers` instance.\n */\nfunction parseXhrResponseHeaders(raw: string): Headers {\n  const headers = new Headers()\n  for (const line of raw.split('\\r\\n')) {\n    const separator = line.indexOf(':')\n    if (separator <= 0) continue\n    try {\n      headers.append(line.slice(0, separator).trim(), line.slice(separator + 1).trim())\n    } catch {\n      // Skip header lines the Headers constructor rejects — better a partial\n      // header record on the error than no error details at all.\n    }\n  }\n  return headers\n}\n"],"mappings":";;;AAOA,MAAM,MAAM,YAAY,eAAe;AAEvC,IAAI,gBAAgB;;;;;;;;;AA0BpB,SAAgB,mBAAsB,SAA2D;CAC/F,OAAO,IAAI,YAA4B,eAAe;EACpD,IAAM,MAAM,IAAI,eAAe,GACzB,YAAY,iBACZ,EAAC,KAAK,QAAQ,SAAS,MAAM,iBAAiB,SAAS,WAAU;EAMvE,AAJA,IAAI,yCAAyC,WAAW,QAAQ,GAAG,GAEnE,IAAI,KAAK,QAAQ,GAAG,GACpB,IAAI,kBAAkB,iBAClB,OAAO,WAAY,YAAY,UAAU,MAC3C,IAAI,UAAU;EAGhB,KAAK,IAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,GAC/C,IAAI,iBAAiB,KAAK,KAAK;EAmEjC,AAhEA,IAAI,OAAO,cAAc,MAAM;GAC7B,WAAW,KAAK;IACd,MAAM;IACN,OAAO;IACP,SAAS,EAAE,mBAAmB,KAAK,MAAO,EAAE,SAAS,EAAE,QAAS,GAAG,IAAI;IACvE,OAAO,EAAE,SAAS,KAAA;IAClB,QAAQ,EAAE;IACV,kBAAkB,EAAE;GACtB,CAAC;EACH,GAEA,IAAI,eAAe;GAGjB,IAFA,IAAI,mBAAmB,WAAW,QAAQ,KAAK,IAAI,MAAM,GAErD,IAAI,UAAU,KAAK;IAIrB,IAAM,eAAe,wBAAwB,IAAI,sBAAsB,CAAC,GAClE,YAAY,sBAChB;KACE,QAAQ,IAAI;KACZ,YAAY,IAAI;KAChB,SAAS;KACT,MAAM,cAAc,IAAI,cAAc,YAAY;KAClD,KAAK,IAAI;IACX,GACA,KACA,MACF;IACA,WAAW,MACT,IAAI,UAAU,MAAM,IAAI,YAAY,SAAS,IAAI,IAAI,YAAY,SAAS,CAC5E;IACA;GACF;GAEA,IAAI;GACJ,IAAI;IACF,eAAe,KAAK,MAAM,IAAI,YAAY;GAC5C,QAAQ;IACN,WAAW,MAAM,gBAAI,MAAM,yCAAyC,CAAC;IACrE;GACF;GAGA,AADA,WAAW,KAAK;IAAC,MAAM;IAAY,MAAM;GAAY,CAAC,GACtD,WAAW,SAAS;EACtB,GAEA,IAAI,gBAAgB;GAElB,AADA,IAAI,8BAA8B,WAAW,QAAQ,GAAG,GACxD,WAAW,MAAM,gBAAI,MAAM,0BAA0B,CAAC;EACxD,GAEA,IAAI,kBAAkB;GAGpB,AAFA,IAAI,qCAAqC,WAAW,QAAQ,KAAK,OAAO,GAExE,WAAW,MACT,IAAI,aACF,iCAAiC,QAAQ,+BAA+B,OACxE,cACF,CACF;EACF,GAEA,IAAI,gBAAgB;GAClB,WAAW,MAAM,IAAI,aAAa,kBAAkB,YAAY,CAAC;EACnE;EAEA,IAAM,sBAAsB,IAAI,MAAM;EACtC,IAAI,QAAQ;GACV,IAAI,OAAO,SAAS;IAGlB,WAAW,MAAM,IAAI,aAAa,kBAAkB,YAAY,CAAC;IACjE;GACF;GACA,OAAO,iBAAiB,SAAS,eAAe,EAAC,MAAM,GAAI,CAAC;EAC9D;EAQA,OANA,IAAI,KAAK,IAA8B,SAM1B;GAEX,AADA,QAAQ,oBAAoB,SAAS,aAAa,GAClD,IAAI,MAAM;EACZ;CACF,CAAC;AACH;;;;;AAMA,SAAS,wBAAwB,KAAsB;CACrD,IAAM,UAAU,IAAI,QAAQ;CAC5B,KAAK,IAAM,QAAQ,IAAI,MAAM,MAAM,GAAG;EACpC,IAAM,YAAY,KAAK,QAAQ,GAAG;EAC9B,mBAAa,IACjB,IAAI;GACF,QAAQ,OAAO,KAAK,MAAM,GAAG,SAAS,CAAC,CAAC,KAAK,GAAG,KAAK,MAAM,YAAY,CAAC,CAAC,CAAC,KAAK,CAAC;EAClF,QAAQ,CAGR;CACF;CACA,OAAO;AACT"}