@sanity/assist 5.0.4 → 6.0.0

package/sanity.json

@@ -1,8 +0,0 @@
-{
-  "parts": [
-    {
-      "implements": "part:@sanity/base/sanity-root",
-      "path": "./v2-incompatible.js"
-    }
-  ]
-}

package/src/_lib/connector/ConnectFromRegion.tsx

@@ -1,25 +0,0 @@
-import {HTMLProps, useEffect, useState} from 'react'
-
-import {ConnectorRegion} from './ConnectorRegion'
-import {ConnectorRegionRects} from './types'
-import {useConnectorsStore} from './useConnectorsStore'
-
-export function ConnectFromRegion(
-  props: {_key: string; zIndex: number} & HTMLProps<HTMLDivElement>,
-) {
-  const {children, _key: key, zIndex, ...restProps} = props
-  const store = useConnectorsStore()
-  const [rects, setRects] = useState<ConnectorRegionRects | null>(null)
-
-  useEffect(() => store.from.subscribe(key, {zIndex}), [key, store, zIndex])
-
-  useEffect(() => {
-    if (rects) store.from.next(key, rects)
-  }, [key, rects, store])
-
-  return (
-    <ConnectorRegion {...restProps} onRectsChange={setRects}>
-      {children}
-    </ConnectorRegion>
-  )
-}

package/src/_lib/connector/ConnectToRegion.tsx

@@ -1,23 +0,0 @@
-import {HTMLProps, useEffect, useState} from 'react'
-
-import {ConnectorRegion} from './ConnectorRegion'
-import {ConnectorRegionRects} from './types'
-import {useConnectorsStore} from './useConnectorsStore'
-
-export function ConnectToRegion(props: {_key: string} & HTMLProps<HTMLDivElement>) {
-  const {children, _key: key, ...restProps} = props
-  const aiConnectors = useConnectorsStore()
-  const [rects, setRects] = useState<ConnectorRegionRects | null>(null)
-
-  useEffect(() => aiConnectors.to.subscribe(key), [aiConnectors, key])
-
-  useEffect(() => {
-    if (rects) aiConnectors.to.next(key, rects)
-  }, [aiConnectors, key, rects])
-
-  return (
-    <ConnectorRegion {...restProps} onRectsChange={setRects}>
-      {children}
-    </ConnectorRegion>
-  )
-}

package/src/_lib/connector/ConnectorRegion.tsx

@@ -1,24 +0,0 @@
-import {HTMLProps, useEffect} from 'react'
-
-import {ConnectorRegionRects} from './types'
-import {useRegionRects} from './useRegionRects'
-
-export function ConnectorRegion(
-  props: {
-    onRectsChange?: (rects: ConnectorRegionRects | null) => void
-  } & HTMLProps<HTMLDivElement>,
-) {
-  const {children, onRectsChange, ...restProps} = props
-
-  const {bounds, element, ref} = useRegionRects()
-
-  useEffect(() => {
-    onRectsChange?.(bounds && element ? {bounds, element} : null)
-  }, [bounds, element, onRectsChange])
-
-  return (
-    <div {...restProps} ref={ref}>
-      {children}
-    </div>
-  )
-}

package/src/_lib/connector/ConnectorsProvider.tsx

@@ -1,20 +0,0 @@
-import {ReactNode, useEffect, useMemo} from 'react'
-
-import {ConnectorsStore, createConnectorsStore} from './ConnectorsStore'
-import {ConnectorsStoreContext} from './ConnectorsStoreContext'
-import {Connector} from './types'
-
-export function ConnectorsProvider(props: {
-  children?: ReactNode
-  onConnectorsChange?: (connectors: Connector[]) => void
-}) {
-  const {children, onConnectorsChange} = props
-  const store: ConnectorsStore = useMemo(() => createConnectorsStore(), [])
-
-  useEffect(
-    () => onConnectorsChange && store.connectors.subscribe(onConnectorsChange),
-    [onConnectorsChange, store],
-  )
-
-  return <ConnectorsStoreContext.Provider value={store}>{children}</ConnectorsStoreContext.Provider>
-}

package/src/_lib/connector/ConnectorsStore.ts

@@ -1,122 +0,0 @@
-import {Connector, ConnectorRegionRects} from './types'
-
-export interface ConnectorsStore {
-  connectors: {
-    subscribe: (observer: (connectors: Connector[]) => void) => () => void
-  }
-
-  from: {
-    subscribe: (key: string, payload?: Record<string, unknown>) => () => void
-    next: (key: string, rects: ConnectorRegionRects) => void
-  }
-
-  to: {
-    subscribe: (key: string, payload?: Record<string, unknown>) => () => void
-    next: (key: string, rects: ConnectorRegionRects) => void
-  }
-}
-
-export function createConnectorsStore(): ConnectorsStore {
-  const configKeys: string[] = []
-  const fieldKeys: string[] = []
-
-  const channels = {
-    from: new Map<string, ConnectorRegionRects | null>(),
-    to: new Map<string, ConnectorRegionRects | null>(),
-  }
-
-  const payloads = {
-    from: new Map<string, Record<string, unknown> | undefined>(),
-    to: new Map<string, Record<string, unknown> | undefined>(),
-  }
-
-  const observers: ((connectors: Connector[]) => void)[] = []
-
-  function notifyObservers() {
-    const connectors: Connector[] = []
-
-    for (const key of configKeys) {
-      const toRects = channels.to.get(key)
-      const toPayload = payloads.from.get(key)
-
-      const fromRects = channels.from.get(key)
-      const fromPayload = payloads.from.get(key)
-
-      if (toRects && fromRects) {
-        connectors.push({
-          key,
-          from: {...fromRects, payload: fromPayload},
-          to: {...toRects, payload: toPayload},
-        })
-      }
-    }
-
-    for (const observer of observers) {
-      observer(connectors)
-    }
-  }
-
-  return {
-    to: {
-      subscribe(key, payload) {
-        channels.to.set(key, null)
-        payloads.to.set(key, payload)
-
-        configKeys.push(key)
-
-        return () => {
-          channels.to.delete(key)
-          payloads.to.delete(key)
-
-          const idx = configKeys.indexOf(key)
-
-          if (idx > -1) configKeys.splice(idx, 1)
-
-          notifyObservers()
-        }
-      },
-      next(key, rects) {
-        channels.to.set(key, rects)
-
-        if (fieldKeys.includes(key)) notifyObservers()
-      },
-    },
-
-    connectors: {
-      subscribe(observer) {
-        observers.push(observer)
-
-        return () => {
-          const idx = observers.indexOf(observer)
-
-          if (idx > -1) observers.splice(idx, 1)
-        }
-      },
-    },
-
-    from: {
-      subscribe(key, payload) {
-        channels.from.set(key, null)
-        payloads.from.set(key, payload)
-
-        fieldKeys.push(key)
-
-        return () => {
-          channels.from.delete(key)
-          payloads.from.delete(key)
-
-          const idx = fieldKeys.indexOf(key)
-
-          if (idx > -1) fieldKeys.splice(idx, 1)
-
-          notifyObservers()
-        }
-      },
-      next(key, rects) {
-        channels.from.set(key, rects)
-
-        if (configKeys.includes(key)) notifyObservers()
-      },
-    },
-  }
-}

package/src/_lib/connector/ConnectorsStoreContext.ts

@@ -1,5 +0,0 @@
-import {createContext} from 'react'
-
-import {ConnectorsStore} from './ConnectorsStore'
-
-export const ConnectorsStoreContext = createContext<ConnectorsStore | null>(null)

package/src/_lib/connector/helpers.ts

@@ -1,5 +0,0 @@
-export function hasOverflowScroll(el: HTMLElement): boolean {
-  const overflow = getComputedStyle(el).overflow
-
-  return overflow.includes('auto') || overflow.includes('hidden') || overflow.includes('scroll')
-}

package/src/_lib/connector/index.ts

@@ -1,9 +0,0 @@
-export * from './ConnectFromRegion'
-export * from './ConnectorRegion'
-export * from './ConnectorsProvider'
-export * from './ConnectorsStore'
-export * from './ConnectorsStoreContext'
-export * from './ConnectToRegion'
-export * from './mapConnectorToLine'
-export * from './types'
-export * from './useConnectorsStore'

package/src/_lib/connector/mapConnectorToLine.ts

@@ -1,83 +0,0 @@
-import {
-  ConnectorLine,
-  ConnectorLinePoint,
-  ConnectorOptions,
-  ConnectorRegionRects,
-  Rect,
-} from './types'
-
-function getConnectorLinePoint(
-  options: ConnectorOptions,
-  rect: Rect,
-  bounds: Rect,
-): ConnectorLinePoint {
-  const centerY = rect.y + rect.h / 2
-  const isAbove = rect.y + rect.h < bounds.y + options.arrow.marginY
-  const isBelow = rect.y > bounds.y + bounds.h - options.arrow.marginY
-
-  return {
-    bounds,
-    x: rect.x,
-    y: centerY,
-    centerY,
-    startY: rect.y + options.path.marginY,
-    endY: rect.y + rect.h - options.path.marginY,
-    isAbove,
-    isBelow,
-    outOfBounds: isAbove || isBelow,
-  }
-}
-
-export function mapConnectorToLine(
-  options: ConnectorOptions,
-  connector: {from: ConnectorRegionRects; to: ConnectorRegionRects},
-): ConnectorLine {
-  const fromBounds: Rect = {
-    y: connector.from.bounds.y + options.arrow.threshold,
-    // bottom: connector.from.bounds.y + connector.from.bounds.h - options.arrow.threshold,
-    x: connector.from.bounds.x,
-    // right: connector.from.bounds.x + connector.from.bounds.w,
-    w: connector.from.bounds.w,
-    h: connector.from.bounds.h - options.arrow.threshold * 2,
-  }
-
-  const from = getConnectorLinePoint(options, connector.from.element, fromBounds)
-  from.x = connector.from.element.x + connector.from.element.w // + 1
-
-  const fromBottom = fromBounds.y + fromBounds.h
-
-  const toBounds: Rect = {
-    y: connector.to.bounds.y + options.arrow.threshold,
-    // bottom: connector.to.bounds.y + connector.to.bounds.h - options.arrow.threshold,
-    x: connector.to.bounds.x,
-    // right: connector.to.bounds.x + connector.to.bounds.w,
-    w: connector.to.bounds.w,
-    h: connector.to.bounds.h - options.arrow.threshold * 2,
-  }
-
-  const toBottom = toBounds.y + toBounds.h
-
-  const to = getConnectorLinePoint(options, connector.to.element, toBounds)
-
-  const maxStartY = Math.max(to.startY, from.startY)
-
-  // Align from <-> to vertically
-  from.y = Math.min(maxStartY, from.endY)
-  if (from.y < toBounds.y) {
-    from.y = Math.min(toBounds.y, from.endY)
-  } else if (from.y > toBottom) {
-    from.y = Math.max(toBottom, from.startY)
-  }
-  to.y = Math.min(maxStartY, to.endY)
-  if (to.y < fromBounds.y) {
-    to.y = Math.min(fromBounds.y, to.endY)
-  } else if (to.y > fromBottom) {
-    to.y = Math.max(fromBottom, to.startY)
-  }
-
-  // Keep within bounds
-  from.y = Math.min(Math.max(from.y, fromBounds.y), fromBottom)
-  to.y = Math.min(Math.max(to.y, toBounds.y), toBottom)
-
-  return {from, to}
-}

package/src/_lib/connector/types.ts

@@ -1,56 +0,0 @@
-export interface Rect {
-  x: number
-  y: number
-  w: number
-  h: number
-}
-
-export interface Scroll {
-  x: number
-  y: number
-}
-
-export interface ConnectorLinePoint {
-  bounds: Rect
-  x: number
-  y: number
-  startY: number
-  centerY: number
-  endY: number
-  isAbove: boolean
-  isBelow: boolean
-  outOfBounds: boolean
-}
-
-export interface ConnectorLine {
-  from: ConnectorLinePoint
-  to: ConnectorLinePoint
-}
-
-export interface ConnectorOptions {
-  arrow: {
-    marginX: number
-    marginY: number
-    size: number
-    threshold: number
-  }
-  divider: {
-    offsetX: number
-  }
-  path: {
-    cornerRadius: number
-    marginY: number
-    strokeWidth: number
-  }
-}
-
-export interface ConnectorRegionRects {
-  bounds: Rect
-  element: Rect
-}
-
-export interface Connector {
-  key: string
-  from: ConnectorRegionRects & {payload?: Record<string, unknown>}
-  to: ConnectorRegionRects & {payload?: Record<string, unknown>}
-}

package/src/_lib/connector/useConnectorsStore.ts

@@ -1,14 +0,0 @@
-import {useContext} from 'react'
-
-import {ConnectorsStore} from './ConnectorsStore'
-import {ConnectorsStoreContext} from './ConnectorsStoreContext'
-
-export function useConnectorsStore(): ConnectorsStore {
-  const store = useContext(ConnectorsStoreContext)
-
-  if (!store) {
-    throw new Error('Missing connectors store context')
-  }
-
-  return store
-}

package/src/_lib/connector/useRegionRects.ts

@@ -1,142 +0,0 @@
-import {useEffect, useMemo, useRef, useState} from 'react'
-
-import {hasOverflowScroll} from './helpers'
-import {Rect, Scroll} from './types'
-
-export function useRegionRects() {
-  const ref = useRef<HTMLDivElement>(null)
-
-  const [relativeBoundsRect, setRelativeBoundsRect] = useState<Rect | null>(null)
-  const [relativeElementRect, setRelativeElementRect] = useState<Rect | null>(null)
-  const [boundsScroll, setBoundsScroll] = useState<Scroll>({x: 0, y: 0})
-  const [scroll, setScroll] = useState<Scroll>({x: 0, y: 0})
-
-  const boundsScrollXRef = useRef(0)
-  const boundsScrollYRef = useRef(0)
-
-  const elementScrollXRef = useRef(0)
-  const elementScrollYRef = useRef(0)
-
-  useEffect(() => {
-    const el = ref.current
-
-    if (!el) return undefined
-
-    const scrollParents: HTMLElement[] = []
-    let parent = el.parentElement
-
-    while (parent && parent !== document.body) {
-      if (
-        hasOverflowScroll(parent)
-        // || parent.scrollHeight > parent.clientHeight
-      ) {
-        scrollParents.push(parent)
-      }
-
-      parent = parent.parentElement
-    }
-
-    function handleResize() {
-      const scrollParent = scrollParents[0]
-
-      const boundsRect = scrollParent?.getBoundingClientRect() || {
-        x: 0,
-        y: 0,
-        width: window.innerWidth,
-        height: window.innerHeight,
-      }
-
-      const domRect = el!.getBoundingClientRect()
-
-      setRelativeBoundsRect({
-        x: boundsRect.x + boundsScrollXRef.current,
-        y: boundsRect.y + boundsScrollYRef.current,
-        w: boundsRect.width,
-        h: boundsRect.height,
-      })
-
-      setRelativeElementRect({
-        x: domRect.x + elementScrollXRef.current,
-        y: domRect.y + elementScrollYRef.current,
-        w: domRect.width,
-        h: domRect.height,
-      })
-    }
-
-    function handleScroll() {
-      let scrollX = window.scrollX
-      let scrollY = window.scrollY
-
-      for (const scrollParent of scrollParents) {
-        scrollX += scrollParent.scrollLeft
-        scrollY += scrollParent.scrollTop
-      }
-
-      const scrollParent = scrollParents[0]
-
-      boundsScrollXRef.current = scrollX - (scrollParent?.scrollLeft || window.scrollX)
-
-      boundsScrollYRef.current = scrollY - (scrollParent?.scrollTop || window.scrollY)
-
-      setBoundsScroll({
-        x: boundsScrollXRef.current,
-        y: boundsScrollYRef.current,
-      })
-
-      elementScrollXRef.current = scrollX
-      elementScrollYRef.current = scrollY
-
-      setScroll({x: scrollX, y: scrollY})
-    }
-
-    window.addEventListener('scroll', handleScroll, {passive: true})
-
-    const ro = new ResizeObserver(handleResize)
-
-    ro.observe(el)
-
-    for (const scrollParent of scrollParents) {
-      scrollParent.addEventListener('scroll', handleScroll, {passive: true})
-      ro.observe(scrollParent)
-    }
-
-    handleScroll()
-
-    return () => {
-      ro.unobserve(el)
-
-      for (const scrollParent of scrollParents) {
-        ro.unobserve(scrollParent)
-        scrollParent.removeEventListener('scroll', handleScroll)
-      }
-
-      ro.disconnect()
-
-      window.removeEventListener('scroll', handleScroll)
-    }
-  }, [])
-
-  const bounds: Rect | null = useMemo(
-    () =>
-      relativeBoundsRect && {
-        x: relativeBoundsRect.x - boundsScroll.x,
-        y: relativeBoundsRect.y - boundsScroll.y,
-        w: relativeBoundsRect.w,
-        h: relativeBoundsRect.h,
-      },
-    [relativeBoundsRect, boundsScroll],
-  )
-
-  const element: Rect | null = useMemo(
-    () =>
-      relativeElementRect && {
-        x: relativeElementRect.x - scroll.x,
-        y: relativeElementRect.y - scroll.y,
-        w: relativeElementRect.w,
-        h: relativeElementRect.h,
-      },
-    [relativeElementRect, scroll],
-  )
-
-  return {bounds, element, ref}
-}

package/src/_lib/fixedListenQuery.ts

@@ -1,101 +0,0 @@
-import type {SanityClient} from '@sanity/client'
-import {defer, delay, merge, Observable, of, partition, switchMap, throwError} from 'rxjs'
-import {filter, mergeMap, share, take} from 'rxjs/operators'
-import {exhaustMapToWithTrailing} from 'rxjs-exhaustmap-with-trailing'
-import {MutationEvent, ReconnectEvent, WelcomeEvent} from 'sanity'
-
-/** @internal */
-export type ListenQueryParams = Record<string, string | number | boolean | string[]>
-
-/** @beta */
-export interface ListenQueryOptions {
-  tag?: string
-  apiVersion?: string
-  throttleTime?: number
-  transitions?: ('update' | 'appear' | 'disappear')[]
-}
-
-const fetch = (
-  client: SanityClient,
-  query: string,
-  params: ListenQueryParams,
-  options: ListenQueryOptions,
-) =>
-  defer(() =>
-    // getVersionedClient(options.apiVersion)
-    client.observable.fetch(query, params, {
-      tag: options.tag,
-      filterResponse: true,
-    }),
-  )
-
-const listen = (
-  client: SanityClient,
-  query: string,
-  params: ListenQueryParams,
-  options: ListenQueryOptions,
-) =>
-  defer(() =>
-    // getVersionedClient(options.apiVersion)
-    client.listen(query, params, {
-      events: ['welcome', 'mutation', 'reconnect'],
-      includeResult: false,
-      visibility: 'query',
-      tag: options.tag,
-    }),
-  ) as Observable<ReconnectEvent | WelcomeEvent | MutationEvent>
-
-function isWelcomeEvent(
-  event: MutationEvent | ReconnectEvent | WelcomeEvent,
-): event is WelcomeEvent {
-  return event.type === 'welcome'
-}
-
-/** @internal */
-export const listenQuery = (
-  client: SanityClient,
-  query: string | {fetch: string; listen: string},
-  params: ListenQueryParams = {},
-  options: ListenQueryOptions = {},
-) => {
-  const fetchQuery = typeof query === 'string' ? query : query.fetch
-  const listenerQuery = typeof query === 'string' ? query : query.listen
-
-  const fetchOnce$ = fetch(client, fetchQuery, params, options)
-
-  const events$ = listen(client, listenerQuery, params, options).pipe(
-    mergeMap((ev, i) => {
-      const isFirst = i === 0
-      if (isFirst && !isWelcomeEvent(ev)) {
-        // if the first event is not welcome, it is most likely a reconnect and
-        // if it's not a reconnect something is very wrong
-        return throwError(
-          new Error(
-            ev.type === 'reconnect'
-              ? 'Could not establish EventSource connection'
-              : `Received unexpected type of first event "${ev.type}"`,
-          ),
-        )
-      }
-      return of(ev)
-    }),
-    share(),
-  )
-
-  const [welcome$, mutationAndReconnect$] = partition(events$, isWelcomeEvent)
-  const isRelevantEvent = (event: MutationEvent | ReconnectEvent | WelcomeEvent): boolean => {
-    if (!options.transitions || event.type !== 'mutation') {
-      return true
-    }
-
-    return options.transitions.includes(event.transition)
-  }
-
-  return merge(
-    welcome$.pipe(take(1)),
-    mutationAndReconnect$.pipe(
-      filter(isRelevantEvent),
-      switchMap((event) => merge(of(event), of(event).pipe(delay(options.throttleTime || 1000)))),
-    ),
-  ).pipe(exhaustMapToWithTrailing(fetchOnce$))
-}