@sanity/client 6.7.1-pink-lizard.4 → 6.7.1

package/src/csm/applySourceDocuments.ts

@@ -1,87 +0,0 @@
-import {parseJsonPath} from './jsonpath'
-import {resolveMapping} from './resolveMapping'
-import type {
-  Any,
-  ApplySourceDocumentsUpdateFunction,
-  ContentSourceMap,
-  ContentSourceMapDocuments,
-  PathSegment,
-  SanityDocument,
-} from './types'
-import {walkMap} from './walkMap'
-
-const defaultUpdateFunction = <T = unknown>(changed: T): T => changed
-
-/**
- * Optimistically applies source documents to a result, using the content source map to trace fields.
- * Can be used to apply mutations to documents being edited in a Studio, or any mutation on Content Lake, to a result with extremely low latency.
- * @alpha
- */
-export function applySourceDocuments<Result = unknown>(
-  result: Result,
-  resultSourceMap: ContentSourceMap | undefined,
-  getCachedDocument: (
-    sourceDocument: ContentSourceMapDocuments[number],
-  ) => SanityDocument | undefined,
-  updateFn: ApplySourceDocumentsUpdateFunction = defaultUpdateFunction,
-): Result {
-  if (!resultSourceMap) return result
-
-  return walkMap(result, (value, path) => {
-    const resolveMappingResult = resolveMapping(path, resultSourceMap)
-    if (!resolveMappingResult) {
-      return value
-    }
-
-    const {mapping, pathSuffix} = resolveMappingResult
-    if (mapping.type !== 'value') {
-      return value
-    }
-
-    if (mapping.source.type !== 'documentValue') {
-      return value
-    }
-
-    const sourceDocument = resultSourceMap.documents[mapping.source.document]
-    const sourcePath = resultSourceMap.paths[mapping.source.path]
-
-    if (sourceDocument) {
-      const cachedDocument = getCachedDocument(sourceDocument)
-      if (!cachedDocument) {
-        return value
-      }
-
-      const parsedPath = parseJsonPath(sourcePath + pathSuffix)
-      const changedValue = cachedDocument ? getField(cachedDocument, parsedPath) ?? value : value
-      return value === changedValue
-        ? value
-        : updateFn<Result[keyof Result]>(changedValue, {
-            cachedDocument,
-            previousValue: value as Result[keyof Result],
-            sourceDocument,
-            sourcePath: parsedPath,
-          })
-    }
-
-    return value
-  }) as Result
-}
-
-function getField(obj: SanityDocument, path: PathSegment[]): Any {
-  let value = obj as SanityDocument | SanityDocument[keyof SanityDocument]
-  for (const segment of path) {
-    if (typeof segment === 'string') {
-      value = value[segment]
-    } else {
-      const match =
-        typeof segment === 'object'
-          ? value.find((item: SanityDocument[keyof SanityDocument]) => item._key === segment.key)
-          : value[segment]
-      value = match || null
-    }
-    if (value === null || value === undefined) {
-      break
-    }
-  }
-  return value
-}

package/src/csm/createEditLink.ts

@@ -1,75 +0,0 @@
-import {getPublishedId} from './getPublishedId'
-import {parseJsonPath} from './jsonpath'
-import {resolvedKeyedSourcePath} from './resolvedKeyedSourcePath'
-import {resolveMapping} from './resolveMapping'
-import {simplifyPath} from './simplifyPath'
-import type {CreateEditLinkOptions, EditIntentLink, PathSegment, StudioUrl} from './types'
-
-/** @public */
-export function createEditLink(
-  options: CreateEditLinkOptions,
-): `${StudioUrl}${EditIntentLink}` | undefined {
-  const {studioUrl: resolveStudioUrl, resultSourceMap: csm, resultPath} = options
-  const {mapping, pathSuffix} = resolveMapping(resultPath, csm) || {}
-
-  if (!mapping) {
-    // console.warn('no mapping for path', { path: resultPath, sourceMap: csm })
-    return undefined
-  }
-
-  if (mapping.source.type === 'literal') {
-    return undefined
-  }
-
-  if (mapping.source.type === 'unknown') {
-    return undefined
-  }
-
-  const sourceDoc = csm.documents[mapping.source.document]
-  const sourceBasePath = csm.paths[mapping.source.path]
-
-  if (sourceDoc && sourceBasePath) {
-    const studioUrl =
-      typeof resolveStudioUrl === 'function'
-        ? resolveStudioUrl(sourceDoc, parseJsonPath(sourceBasePath))
-        : resolveStudioUrl
-    if (!studioUrl) return undefined
-    const _studioUrl = studioUrl.replace(/\/$/, '')
-    const _path = encodeURIComponent(
-      simplifyPath(
-        resolvedKeyedSourcePath({
-          keyedResultPath: parseJsonPath(sourceBasePath),
-          pathSuffix,
-          sourceBasePath,
-        }),
-      ),
-    )
-    const {_id, _type} = sourceDoc
-    const params = new URLSearchParams()
-    if (sourceDoc._projectId) {
-      params.set('projectId', sourceDoc._projectId)
-    }
-    if (sourceDoc._dataset) {
-      params.set('dataset', sourceDoc._dataset)
-    }
-    params.set('id', sourceDoc._id)
-    params.set('type', sourceDoc._type)
-    params.set('path', decodeURIComponent(_path))
-    params.set('baseUrl', _studioUrl)
-    return `${_studioUrl}/intent/edit/id=${getPublishedId(
-      _id,
-    )};type=${_type};path=${_path}?${params}`
-  }
-
-  return undefined
-}
-
-/** @internal */
-export function encodeJsonPathToUriComponent(path: string | PathSegment[]): string {
-  const sourcePath = Array.isArray(path) ? path : parseJsonPath(path)
-  return encodeURIComponent(
-    sourcePath
-      .map((key, i) => (typeof key === 'number' ? `[${key}]` : i > 0 ? `.${key}` : key))
-      .join(''),
-  )
-}

package/src/csm/getPublishedId.ts

@@ -1,12 +0,0 @@
-const DRAFTS_PREFIX = 'drafts.'
-
-/**
- * @internal
- */
-export function getPublishedId(id: string): string {
-  if (id.startsWith(DRAFTS_PREFIX)) {
-    return id.slice(DRAFTS_PREFIX.length)
-  }
-
-  return id
-}

package/src/csm/index.ts

@@ -1,9 +0,0 @@
-export * from './applySourceDocuments'
-export {createEditLink, encodeJsonPathToUriComponent} from './createEditLink'
-export {getPublishedId} from './getPublishedId'
-export {jsonPath, parseJsonPath} from './jsonpath'
-export {resolvedKeyedSourcePath} from './resolvedKeyedSourcePath'
-export {resolveMapping} from './resolveMapping'
-export {simplifyPath} from './simplifyPath'
-export type * from './types'
-export {walkMap} from './walkMap'

package/src/csm/isArray.ts

@@ -1,3 +0,0 @@
-export function isArray(value: unknown): value is Array<unknown> {
-  return value !== null && Array.isArray(value)
-}

package/src/csm/isRecord.ts

@@ -1,3 +0,0 @@
-export function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}

package/src/csm/jsonpath.test.ts

@@ -1,33 +0,0 @@
-import {expect, test} from 'vitest'
-
-import {jsonPath, parseJsonPath} from './jsonpath'
-
-test('formats normalised JSON Paths', () => {
-  expect(jsonPath(['foo', 'bar', 0, 'baz'])).toBe("$['foo']['bar'][0]['baz']")
-})
-
-test('formats normalised JSON Paths with escaped characters', () => {
-  expect(jsonPath(['foo', 'bar', 0, 'baz', "it's a 'test'"])).toBe(
-    "$['foo']['bar'][0]['baz']['it\\'s a \\'test\\'']",
-  )
-})
-
-test('parses normalised JSON Paths', () => {
-  expect(parseJsonPath("$['foo']['bar'][0]['baz']")).toEqual(['foo', 'bar', 0, 'baz'])
-})
-
-test('parses normalised JSON Paths with escaped characters', () => {
-  expect(parseJsonPath("$['foo']['bar'][0]['baz']['it\\'s a \\'test\\'']")).toEqual([
-    'foo',
-    'bar',
-    0,
-    'baz',
-    "it's a 'test'",
-  ])
-})
-
-test('parses normalised JSON Paths with key array filter selectors', () => {
-  expect(
-    parseJsonPath("$['foo'][?(@._key=='section-1')][0]['baz'][?(@._key=='section-2')]"),
-  ).toEqual(['foo', {key: 'section-1', index: -1}, 0, 'baz', {key: 'section-2', index: -1}])
-})

package/src/csm/jsonpath.ts

@@ -1,93 +0,0 @@
-import type {PathSegment} from './types'
-
-const ESCAPE: Record<string, string> = {
-  '\f': '\\f',
-  '\n': '\\n',
-  '\r': '\\r',
-  '\t': '\\t',
-  "'": "\\'",
-  '\\': '\\\\',
-}
-
-const UNESCAPE: Record<string, string> = {
-  '\\f': '\f',
-  '\\n': '\n',
-  '\\r': '\r',
-  '\\t': '\t',
-  "\\'": "'",
-  '\\\\': '\\',
-}
-
-/**
- * @internal
- */
-export function jsonPath(
-  path: PathSegment[],
-  opts?: {
-    keyArraySelectors: boolean
-  },
-): string {
-  return `$${path
-    .map((segment) => {
-      if (typeof segment === 'string') {
-        const escapedKey = segment.replace(/[\f\n\r\t'\\]/g, (match) => {
-          return ESCAPE[match]
-        })
-        return `['${escapedKey}']`
-      }
-
-      if (typeof segment === 'number') {
-        return `[${segment}]`
-      }
-
-      if (opts?.keyArraySelectors && segment.key !== '') {
-        const escapedKey = segment.key.replace(/['\\]/g, (match) => {
-          return ESCAPE[match]
-        })
-        return `[?(@._key=='${escapedKey}')]`
-      }
-
-      return `[${segment.index}]`
-    })
-    .join('')}`
-}
-
-/**
- * @internal
- */
-export function parseJsonPath(path: string): PathSegment[] {
-  const parsed: PathSegment[] = []
-
-  const parseRe = /\['(.*?)'\]|\[(\d+)\]|\[\?\(@\._key=='(.*?)'\)\]/g
-  let match: RegExpExecArray | null
-
-  while ((match = parseRe.exec(path)) !== null) {
-    if (match[1] !== undefined) {
-      const key = match[1].replace(/\\(\\|f|n|r|t|')/g, (m) => {
-        return UNESCAPE[m]
-      })
-
-      parsed.push(key)
-      continue
-    }
-
-    if (match[2] !== undefined) {
-      parsed.push(parseInt(match[2], 10))
-      continue
-    }
-
-    if (match[3] !== undefined) {
-      const key = match[3].replace(/\\(\\')/g, (m) => {
-        return UNESCAPE[m]
-      })
-
-      parsed.push({
-        key,
-        index: -1,
-      })
-      continue
-    }
-  }
-
-  return parsed
-}

package/src/csm/resolveMapping.ts

@@ -1,41 +0,0 @@
-import {jsonPath} from './jsonpath'
-import type {ContentSourceMap, ContentSourceMapMapping, PathSegment} from './types'
-
-/**
- * @internal
- */
-export function resolveMapping(
-  resultPath: PathSegment[],
-  csm?: ContentSourceMap,
-):
-  | {
-      mapping: ContentSourceMapMapping
-      matchedPath: string
-      pathSuffix: string
-    }
-  | undefined {
-  if (!csm?.mappings) {
-    return undefined
-  }
-  const resultJsonPath = jsonPath(resultPath)
-
-  if (csm.mappings[resultJsonPath] !== undefined) {
-    return {
-      mapping: csm.mappings[resultJsonPath],
-      matchedPath: resultJsonPath,
-      pathSuffix: '',
-    }
-  }
-
-  const mappings = Object.entries(csm.mappings)
-    .filter(([key]) => resultJsonPath.startsWith(key))
-    .sort(([key1], [key2]) => key2.length - key1.length)
-
-  if (mappings.length == 0) {
-    return undefined
-  }
-
-  const [matchedPath, mapping] = mappings[0]
-  const pathSuffix = resultJsonPath.substring(matchedPath.length)
-  return {mapping, matchedPath, pathSuffix}
-}

package/src/csm/resolvedKeyedSourcePath.ts

@@ -1,23 +0,0 @@
-import {jsonPath, parseJsonPath} from './jsonpath'
-import type {PathSegment} from './types'
-
-/**
- * @internal
- */
-export function resolvedKeyedSourcePath(options: {
-  keyedResultPath: PathSegment[]
-  pathSuffix?: string
-  sourceBasePath: string
-}): PathSegment[] {
-  const {keyedResultPath, pathSuffix, sourceBasePath} = options
-
-  const inferredResultPath = pathSuffix === undefined ? [] : parseJsonPath(pathSuffix)
-
-  const inferredPath = keyedResultPath.slice(keyedResultPath.length - inferredResultPath.length)
-
-  const inferredPathSuffix = inferredPath.length
-    ? jsonPath(inferredPath, {keyArraySelectors: true}).slice(1)
-    : ''
-
-  return parseJsonPath(sourceBasePath + inferredPathSuffix)
-}

package/src/csm/simplifyPath.ts

@@ -1,20 +0,0 @@
-import type {PathSegment} from './types'
-
-/**
- * @internal
- */
-export function simplifyPath(path: PathSegment[]): string {
-  return path
-    .map((segment, index) => {
-      if (typeof segment === 'number') {
-        return `[${segment}]`
-      }
-
-      if (typeof segment === 'string') {
-        return index === 0 ? segment : `.${segment}`
-      }
-
-      return `[_key=="${segment.key}"]`
-    })
-    .join('')
-}

package/src/csm/types.ts

@@ -1,72 +0,0 @@
-import type {ContentSourceMap, ContentSourceMapDocuments, SanityDocument} from '../types'
-
-export type {
-  Any,
-  ContentSourceMap,
-  ContentSourceMapDocument,
-  ContentSourceMapDocumentBase,
-  ContentSourceMapDocuments,
-  ContentSourceMapDocumentValueSource,
-  ContentSourceMapLiteralSource,
-  ContentSourceMapMapping,
-  ContentSourceMapMappings,
-  ContentSourceMapPaths,
-  ContentSourceMapRemoteDocument,
-  ContentSourceMapSource,
-  ContentSourceMapUnknownSource,
-  ContentSourceMapValueMapping,
-  SanityDocument,
-} from '../types'
-
-/** @public */
-export type Path = PathSegment[]
-
-/** @public */
-export type PathSegment = string | number | KeyedSegment
-
-/** @public */
-export type KeyedSegment = {key: string; index: number}
-
-/** @public */
-export type StudioUrl = `/${string}` | `${string}.sanity.studio` | `https://${string}` | string
-
-/** @public */
-export type ResolveStudioUrl = (
-  sourceDocument: ContentSourceMapDocuments[number],
-  sourcePath: Path,
-) => StudioUrl
-
-/**
- * Equivalent to `import type {Exclude<Path, IndexTuple>} from 'sanity'`
- * The `IndexTuple` piece is omitted since it's irrelavent to CSM source links.
- * @public
- */
-export type StudioPathLike = (string | number | {_key: string})[]
-
-/** @public */
-export type EditIntentLink = `/intent/edit/id=${string};type=${string};path=${string}`
-
-/** @public */
-export interface CreateEditLinkOptions {
-  studioUrl: StudioUrl | ResolveStudioUrl
-  resultSourceMap: ContentSourceMap
-  resultPath: Path
-}
-
-/**
- * @alpha
- */
-export type ApplySourceDocumentsUpdateFunction = <T = unknown>(
-  changedValue: T,
-  context: {
-    cachedDocument: SanityDocument
-    previousValue: T
-    sourceDocument: ContentSourceMapDocuments[number]
-    sourcePath: PathSegment[]
-  },
-) => T
-
-/**
- * @internal
- */
-export type WalkMapFn = (value: unknown, path: PathSegment[]) => unknown

package/src/csm/walkMap.ts

@@ -1,30 +0,0 @@
-import {isArray} from './isArray'
-import {isRecord} from './isRecord'
-import type {PathSegment, WalkMapFn} from './types'
-
-/**
- * generic way to walk a nested object or array and apply a mapping function to each value
- * @internal
- */
-export function walkMap(value: unknown, mappingFn: WalkMapFn, path: PathSegment[] = []): unknown {
-  if (isArray(value)) {
-    return value.map((v, idx) => {
-      if (isRecord(v)) {
-        const key = v['_key']
-        if (typeof key === 'string') {
-          return walkMap(v, mappingFn, path.concat({key, index: idx}))
-        }
-      }
-
-      return walkMap(v, mappingFn, path.concat(idx))
-    })
-  }
-
-  if (isRecord(value)) {
-    return Object.fromEntries(
-      Object.entries(value).map(([k, v]) => [k, walkMap(v, mappingFn, path.concat(k))]),
-    )
-  }
-
-  return mappingFn(value, path)
-}