@liiift-studio/deploy-vercel-from-sanity 1.1.1 → 1.2.1

package/src/lib/api.ts

@@ -1,96 +0,0 @@
-// Vercel REST API helpers — all calls require a bearer token
-import type { VercelDeployment, DeploymentEvent } from '../types'
-
-const BASE = 'https://api.vercel.com'
-
-/** Only allow genuine Vercel deploy hook URLs through triggerDeploy */
-const VERCEL_HOOK_RE = /^https:\/\/api\.vercel\.com\/v1\/integrations\/deploy\//
-
-async function vercelFetch<T>(path: string, token: string, init?: RequestInit): Promise<T> {
-	const res = await fetch(`${BASE}${path}`, {
-		...init,
-		headers: {
-			Authorization: `Bearer ${token}`,
-			'Content-Type': 'application/json',
-			...init?.headers,
-		},
-	})
-	if (!res.ok) {
-		const hint =
-			res.status === 401 ? ' — token is invalid or expired. Reconnect your API token.' :
-			res.status === 403 ? ' — token lacks the required permissions. Ensure it has Full Account scope.' :
-			res.status === 404 ? ' — resource not found. Check the deploy hook URL and team ID.' :
-			res.status === 429 ? ' — rate limit reached. Wait a moment and try again.' :
-			res.status >= 500  ? ' — Vercel is experiencing issues. Try again shortly.' :
-			''
-		throw new Error(`Vercel API ${res.status}${hint}`)
-	}
-	return res.json() as Promise<T>
-}
-
-/** Fetch the last N deployments triggered by a specific deploy hook */
-export async function listDeployments(opts: {
-	projectId: string
-	hookId: string
-	token: string
-	teamId?: string
-	limit?: number
-}): Promise<VercelDeployment[]> {
-	const params = new URLSearchParams({
-		projectId: opts.projectId,
-		'meta-deployHookId': opts.hookId,
-		limit: String(opts.limit ?? 10),
-	})
-	if (opts.teamId) params.set('teamId', opts.teamId)
-	const data = await vercelFetch<{ deployments: VercelDeployment[] }>(
-		`/v6/deployments?${params}`,
-		opts.token,
-	)
-	return data.deployments ?? []
-}
-
-/** Cancel an in-progress deployment */
-export async function cancelDeployment(opts: {
-	deploymentId: string
-	token: string
-	teamId?: string
-}): Promise<void> {
-	const params = opts.teamId ? `?teamId=${opts.teamId}` : ''
-	await vercelFetch(`/v12/deployments/${opts.deploymentId}/cancel${params}`, opts.token, {
-		method: 'PATCH',
-	})
-}
-
-/**
- * Trigger a deploy by POSTing to the hook URL.
- * Validates the URL is a genuine Vercel hook before calling to prevent
- * SSRF if a document is tampered with outside the Studio schema.
- */
-export async function triggerDeploy(hookUrl: string): Promise<void> {
-	if (!VERCEL_HOOK_RE.test(hookUrl)) {
-		throw new Error('Invalid deploy hook URL — must be a Vercel hook (api.vercel.com/v1/integrations/deploy/…)')
-	}
-	const res = await fetch(hookUrl, { method: 'POST' })
-	if (!res.ok) throw new Error(`Deploy hook returned ${res.status}`)
-}
-
-/**
- * Fetch build events for a deployment.
- * Returns up to 100 events in reverse chronological order,
- * filtered to lines with actual text content.
- */
-export async function getDeploymentEvents(opts: {
-	deploymentId: string
-	token: string
-	teamId?: string
-}): Promise<DeploymentEvent[]> {
-	const params = new URLSearchParams({ limit: '100', direction: 'backward' })
-	if (opts.teamId) params.set('teamId', opts.teamId)
-	// API returns either a plain array or a wrapped object depending on version
-	const raw = await vercelFetch<DeploymentEvent[] | { events?: DeploymentEvent[] }>(
-		`/v2/deployments/${opts.deploymentId}/events?${params}`,
-		opts.token,
-	)
-	const events: DeploymentEvent[] = Array.isArray(raw) ? raw : (raw.events ?? [])
-	return events.filter(e => e.text?.trim())
-}

package/src/lib/helpers.ts

@@ -1,114 +0,0 @@
-// URL parsing and time formatting utilities
-import type { VercelDeployment, VercelDeployState } from '../types'
-
-/**
- * Extracts projectId and hookId from a Vercel deploy hook URL.
- * Format: https://api.vercel.com/v1/integrations/deploy/{projectId}/{hookId}
- */
-export function parseHookUrl(url: string): { projectId: string; hookId: string } {
-	try {
-		const path = new URL(url).pathname
-		const parts = path.split('/').filter(Boolean)
-		// parts: ['v1', 'integrations', 'deploy', '{projectId}', '{hookId}']
-		return {
-			projectId: parts[3] ?? '',
-			hookId: parts[4] ?? '',
-		}
-	} catch {
-		return { projectId: '', hookId: '' }
-	}
-}
-
-/** Active states — deployment is in progress and should be polled */
-const ACTIVE_STATES: ReadonlySet<VercelDeployState> = new Set([
-	'QUEUED',
-	'INITIALIZING',
-	'BUILDING',
-])
-
-export function isActiveState(state: VercelDeployState | undefined): boolean {
-	return !!state && ACTIVE_STATES.has(state)
-}
-
-/** Human-readable elapsed duration from a number of seconds */
-export function formatDuration(seconds: number): string {
-	if (seconds < 60) return `${seconds}s`
-	const m = Math.floor(seconds / 60)
-	const s = seconds % 60
-	return `${m}m ${s}s`
-}
-
-/** Human-readable relative time from a Unix ms timestamp */
-export function timeAgo(ms: number): string {
-	const diff = Math.floor((Date.now() - ms) / 1000)
-	if (diff < 60) return `${diff}s ago`
-	if (diff < 3600) return `${Math.floor(diff / 60)}m ago`
-	if (diff < 86400) return `${Math.floor(diff / 3600)}h ago`
-	return `${Math.floor(diff / 86400)}d ago`
-}
-
-/**
- * Validates a URL is safe to use as an href.
- * Rejects anything that isn't http/https to block javascript: injection
- * from a compromised API response.
- */
-export function safeHref(url: string | undefined): string | undefined {
-	if (!url) return undefined
-	try {
-		const parsed = new URL(url)
-		if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') return undefined
-		return url
-	} catch {
-		return undefined
-	}
-}
-
-/** Truncates a commit SHA to 7 chars */
-export function shortSha(sha: string | undefined): string {
-	return sha ? sha.slice(0, 7) : ''
-}
-
-/** Returns a label and tone for a Vercel deployment state */
-export function stateLabel(state: VercelDeployState | undefined): {
-	label: string
-	tone: 'positive' | 'caution' | 'critical' | 'default'
-} {
-	switch (state) {
-		case 'READY':        return { label: 'Ready',        tone: 'positive' }
-		case 'BUILDING':     return { label: 'Building',     tone: 'caution' }
-		case 'QUEUED':       return { label: 'Queued',       tone: 'caution' }
-		case 'INITIALIZING': return { label: 'Initializing', tone: 'caution' }
-		case 'ERROR':        return { label: 'Error',        tone: 'critical' }
-		case 'CANCELED':     return { label: 'Canceled',     tone: 'default' }
-		case 'LOADING':      return { label: 'Loading…',     tone: 'default' }
-		default:             return { label: 'Unknown',      tone: 'default' }
-	}
-}
-
-/**
- * Constructs a GitHub commit URL from deployment meta fields.
- * Returns null if the required repo or SHA info is not present.
- */
-export function githubCommitHref(meta: VercelDeployment['meta']): string | null {
-	if (!meta?.githubCommitSha) return null
-	const repo = meta.githubRepo ?? null
-	if (!repo) return null
-	return `https://github.com/${repo}/commit/${meta.githubCommitSha}`
-}
-
-/**
- * Extracts the Vercel project dashboard URL from a deployment's inspectorUrl.
- * inspectorUrl format: https://vercel.com/{team}/{project}/{deploymentId}
- * Returns https://vercel.com/{team}/{project} or null if unparseable.
- */
-export function projectHref(inspectorUrl: string | undefined): string | null {
-	if (!inspectorUrl) return null
-	try {
-		const { origin, pathname } = new URL(inspectorUrl)
-		const parts = pathname.split('/').filter(Boolean)
-		if (parts.length < 2) return null
-		return `${origin}/${parts[0]}/${parts[1]}`
-	} catch {
-		return null
-	}
-}

package/src/schema/vercelDeploy.ts

@@ -1,49 +0,0 @@
-// Sanity schema for vercel_deploy documents — stores deploy hook targets
-import { defineField, defineType } from 'sanity'
-import { RocketIcon } from '../icons'
-
-export const vercelDeploySchema = defineType({
-	name: 'vercel_deploy',
-	title: 'Deploy Target',
-	type: 'document',
-	icon: RocketIcon,
-	fields: [
-		defineField({
-			name: 'name',
-			title: 'Name',
-			type: 'string',
-			description: 'Display label shown in the Deploy tool (e.g. "Production", "Staging")',
-			validation: Rule => Rule.required(),
-		}),
-		defineField({
-			name: 'url',
-			title: 'Deploy Hook URL',
-			type: 'url',
-			description: 'From Vercel → Project Settings → Git → Deploy Hooks',
-			validation: Rule =>
-				Rule.required().uri({ scheme: ['https'] }).custom(url => {
-					if (typeof url !== 'string') return true
-					if (!url.includes('api.vercel.com/v1/integrations/deploy/')) {
-						return 'Must be a Vercel deploy hook URL (api.vercel.com/v1/integrations/deploy/…)'
-					}
-					return true
-				}),
-		}),
-		defineField({
-			name: 'teamId',
-			title: 'Vercel Team ID',
-			type: 'string',
-			description: 'Required for team-owned projects — find it in Vercel Team Settings',
-		}),
-		defineField({
-			name: 'disableDeleteAction',
-			title: 'Prevent deletion',
-			type: 'boolean',
-			description: 'Lock this target so it cannot be deleted from the Studio',
-			initialValue: false,
-		}),
-	],
-	preview: {
-		select: { title: 'name', subtitle: 'url' },
-	},
-})

package/src/types.ts

@@ -1,77 +0,0 @@
-// TypeScript types for deploy-vercel-from-sanity
-
-export type VercelDeployState =
-	| 'QUEUED'
-	| 'INITIALIZING'
-	| 'BUILDING'
-	| 'READY'
-	| 'ERROR'
-	| 'CANCELED'
-	| 'LOADING' // internal — before first API response
-
-/** A vercel_deploy document stored in the Sanity dataset */
-export interface DeployTarget {
-	_id: string
-	_type: 'vercel_deploy'
-	name: string
-	/** Full Vercel deploy hook URL */
-	url: string
-	/** Vercel team ID — optional, only needed for team projects */
-	teamId?: string
-	/** Prevent editors from deleting this target */
-	disableDeleteAction?: boolean
-}
-
-/** A single deployment returned by GET /v6/deployments */
-export interface VercelDeployment {
-	uid: string
-	/** Preview hostname, e.g. my-project-abc123.vercel.app */
-	url: string
-	state: VercelDeployState
-	/** Unix ms timestamp — when the deployment was created */
-	created: number
-	/** Unix ms timestamp — when the deployment became ready */
-	ready?: number
-	/** Link to the Vercel dashboard page for this deployment */
-	inspectorUrl?: string
-	creator?: {
-		uid: string
-		username: string
-		avatar?: string
-	}
-	meta?: {
-		githubCommitMessage?: string
-		githubCommitRef?: string
-		githubCommitSha?: string
-		githubCommitAuthorName?: string
-		/** GitHub repo in "org/repo" format — used to construct commit links */
-		githubRepo?: string
-		/** GitHub org slug — fallback when githubRepo is absent */
-		githubCommitOrg?: string
-	}
-}
-
-/** A single build event returned by GET /v2/deployments/{id}/events */
-export interface DeploymentEvent {
-	type: 'command' | 'stdout' | 'stderr' | 'exit' | 'deployment-state'
-	text?: string
-	created: number
-	payload?: Record<string, unknown>
-}
-
-/** Vercel config document stored at _id: 'config.vercelDeploy' — readable by all authenticated users */
-export interface VercelConfig {
-	_id: 'config.vercelDeploy'
-	_type: 'vercelDeploy.config'
-	accessToken: string
-}
-
-/** Plugin configuration options */
-export interface VercelDeployPluginConfig {
-	/** Tool name slug shown in Studio sidebar (default: 'vercel-deploy') */
-	name?: string
-	/** Tool label shown in Studio sidebar (default: 'Deploy') */
-	title?: string
-	/** Custom icon component */
-	icon?: React.ComponentType
-}

package/src/ui.tsx

@@ -1,337 +0,0 @@
-// Version-agnostic access to the @sanity/ui components that v4 moved out of the barrel, with local fallbacks
-import { useCallback, useEffect, useRef, useState } from 'react'
-import type { CSSProperties, ReactNode } from 'react'
-import * as sanityUi from '@sanity/ui'
-import { Box, Button, Card, Flex, Stack as SanityStack, Text } from '@sanity/ui'
-
-/**
- * The installed @sanity/ui namespace, read through an index signature.
- *
- * @sanity/ui v4 relocated Tooltip, Menu, MenuButton, MenuItem, Code, Popover and
- * useToast into subpath entry points (`@sanity/ui/tooltip`, `/menu`, …) and dropped
- * them from the root barrel. Those subpaths do not exist on v2 or v3, so a static
- * import of either shape breaks half the supported Studio range. Reading the barrel
- * dynamically lets one build prefer the real components wherever they are still
- * exported and fall back to the local equivalents below when they are not.
- */
-const INSTALLED = sanityUi as unknown as Record<string, unknown>
-
-/* ------------------------------------------------------------------ stack -- */
-
-/**
- * Whether the installed @sanity/ui is v4 or newer.
- *
- * v4 both emptied the barrel of Tooltip/Menu/Code/useToast and renamed Stack's
- * `space` prop to `gap` (the old name is typed `never` and ignored at runtime, so
- * passing it silently collapses all vertical spacing). Those landed in the same
- * major, so the absence of `useToast` from the barrel identifies v4+ reliably.
- */
-const IS_UI_V4_PLUS = !('useToast' in INSTALLED)
-
-/** Props for the compat Stack — keeps the pre-v4 `space` name at every call site. */
-export type StackProps = {
-	space?: number
-	children: ReactNode
-	[key: string]: unknown
-}
-
-/**
- * Vertical stack. Forwards `space` on @sanity/ui v2 and v3 and `gap` on v4+, so one
- * call site spells spacing correctly on either major.
- *
- * @param space Spacing step on Sanity's scale, forwarded under whichever name applies.
- */
-export function Stack({ space, children, ...rest }: StackProps): React.JSX.Element {
-	const spacing = space === undefined ? {} : IS_UI_V4_PLUS ? { gap: space } : { space }
-	const Component = SanityStack as unknown as React.ComponentType<Record<string, unknown>>
-	return <Component {...rest} {...spacing}>{children}</Component>
-}
-
-/* ------------------------------------------------------------------ toast -- */
-
-/** A toast request, matching the subset of @sanity/ui's ToastParams this plugin uses. */
-export type ToastParams = {
-	status?: 'success' | 'error' | 'warning' | 'info'
-	title?: ReactNode
-	description?: ReactNode
-}
-
-/** The object returned by useToast — only `push` is used here. */
-export type Toaster = { push: (params: ToastParams) => void }
-
-/** A queued fallback toast. `id` is a monotonic counter, unique for the session. */
-type LocalToast = ToastParams & { id: number }
-
-/** How long a fallback toast stays on screen, in milliseconds. */
-const LOCAL_TOAST_MS = 5000
-
-/** Border tone per toast status, used only by the fallback viewport. */
-const LOCAL_TOAST_TONE: Record<string, 'positive' | 'critical' | 'caution' | 'primary'> = {
-	success: 'positive',
-	error: 'critical',
-	warning: 'caution',
-	info: 'primary',
-}
-
-let nextToastId = 0
-let localToasts: LocalToast[] = []
-const toastListeners = new Set<(toasts: LocalToast[]) => void>()
-
-/** Publish the current fallback queue to every mounted viewport. */
-function emitToasts(): void {
-	for (const listener of toastListeners) listener(localToasts)
-}
-
-/** Queue a fallback toast and schedule its removal. */
-function pushLocalToast(params: ToastParams): void {
-	const toast: LocalToast = { ...params, id: nextToastId++ }
-	localToasts = [...localToasts, toast]
-	emitToasts()
-	setTimeout(() => {
-		localToasts = localToasts.filter(t => t.id !== toast.id)
-		emitToasts()
-	}, LOCAL_TOAST_MS)
-}
-
-/** The real hook when the installed @sanity/ui still exports it, otherwise undefined. */
-const installedUseToast = INSTALLED.useToast as (() => Toaster) | undefined
-
-/** Stable fallback toaster — identity never changes, so it is safe in dependency arrays. */
-const localToaster: Toaster = { push: pushLocalToast }
-
-/**
- * Push toasts through Studio's toast system where available, or through the local
- * viewport below on @sanity/ui v4+. Mount `<ToastViewport />` once for the fallback
- * to be visible; it renders nothing when the real hook is present.
- */
-export function useToast(): Toaster {
-	const real = installedUseToast
-	// Hook order is stable across renders because `installedUseToast` is module-level.
-	if (real) return real()
-	return localToaster
-}
-
-/**
- * Renders queued fallback toasts. No-op when the installed @sanity/ui exports its
- * own useToast, because Studio's ToastProvider is already handling them.
- */
-export function ToastViewport(): React.JSX.Element | null {
-	const [toasts, setToasts] = useState<LocalToast[]>(localToasts)
-
-	useEffect(() => {
-		if (installedUseToast) return
-		toastListeners.add(setToasts)
-		return () => { toastListeners.delete(setToasts) }
-	}, [])
-
-	if (installedUseToast || toasts.length === 0) return null
-
-	return (
-		<Box style={{ position: 'fixed', bottom: 16, right: 16, zIndex: 1000000, maxWidth: 360 }}>
-			<Stack space={2}>
-				{toasts.map(toast => (
-					<Card
-						key={toast.id}
-						padding={3}
-						radius={2}
-						shadow={3}
-						tone={LOCAL_TOAST_TONE[toast.status ?? 'info'] ?? 'primary'}
-					>
-						<Stack space={2}>
-							{toast.title && <Text size={1} weight="semibold">{toast.title}</Text>}
-							{toast.description && <Text size={1} muted>{toast.description}</Text>}
-						</Stack>
-					</Card>
-				))}
-			</Stack>
-		</Box>
-	)
-}
-
-/* ---------------------------------------------------------------- tooltip -- */
-
-/** Props for the compat Tooltip — plain text rather than @sanity/ui's ReactNode `content`. */
-export type TooltipProps = { text: string; children: ReactNode }
-
-/** The real Tooltip when the installed @sanity/ui still exports it, otherwise undefined. */
-const InstalledTooltip = INSTALLED.Tooltip as
-	| React.ComponentType<{ content: ReactNode; portal?: boolean; children: ReactNode }>
-	| undefined
-
-/**
- * Hover hint over `children`. Uses Studio's Tooltip where available and degrades to
- * the native `title` attribute on @sanity/ui v4+.
- */
-export function Tooltip({ text, children }: TooltipProps): React.JSX.Element {
-	if (InstalledTooltip) {
-		return (
-			<InstalledTooltip content={<Box padding={2}><Text size={1}>{text}</Text></Box>} portal>
-				{children}
-			</InstalledTooltip>
-		)
-	}
-	return <span title={text} style={{ display: 'inline-flex' }}>{children}</span>
-}
-
-/* ------------------------------------------------------------------- menu -- */
-
-/** One entry in an ActionMenu. Either `onClick` or `href` drives the behaviour. */
-export type MenuAction = {
-	text: string
-	icon: React.ComponentType<React.SVGProps<SVGSVGElement>>
-	onClick?: () => void
-	href?: string
-	tone?: 'critical' | 'default'
-}
-
-/** Props for the compat ActionMenu — a declarative item list rather than nested JSX. */
-export type ActionMenuProps = { id: string; items: MenuAction[]; buttonIcon: MenuAction['icon'] }
-
-const InstalledMenuButton = INSTALLED.MenuButton as React.ComponentType<Record<string, unknown>> | undefined
-const InstalledMenu = INSTALLED.Menu as React.ComponentType<Record<string, unknown>> | undefined
-const InstalledMenuItem = INSTALLED.MenuItem as React.ComponentType<Record<string, unknown>> | undefined
-
-/** Whether the installed @sanity/ui still exports the full menu trio. */
-const HAS_INSTALLED_MENU = Boolean(InstalledMenuButton && InstalledMenu && InstalledMenuItem)
-
-/**
- * Overflow menu for a deploy target. Uses Studio's MenuButton where available and
- * falls back to a locally positioned card on @sanity/ui v4+.
- *
- * @param id        Stable DOM id, required by @sanity/ui's MenuButton.
- * @param items     Actions in display order.
- * @param buttonIcon Icon for the trigger button.
- */
-export function ActionMenu({ id, items, buttonIcon }: ActionMenuProps): React.JSX.Element {
-	const [open, setOpen] = useState(false)
-	const wrapRef = useRef<HTMLDivElement>(null)
-
-	// Fallback only — dismiss on outside click or Escape.
-	useEffect(() => {
-		if (HAS_INSTALLED_MENU || !open) return
-		const onPointerDown = (e: MouseEvent) => {
-			if (!wrapRef.current?.contains(e.target as Node)) setOpen(false)
-		}
-		const onKeyDown = (e: KeyboardEvent) => { if (e.key === 'Escape') setOpen(false) }
-		document.addEventListener('mousedown', onPointerDown)
-		document.addEventListener('keydown', onKeyDown)
-		return () => {
-			document.removeEventListener('mousedown', onPointerDown)
-			document.removeEventListener('keydown', onKeyDown)
-		}
-	}, [open])
-
-	const runAction = useCallback((item: MenuAction) => {
-		setOpen(false)
-		item.onClick?.()
-	}, [])
-
-	if (HAS_INSTALLED_MENU && InstalledMenuButton && InstalledMenu && InstalledMenuItem) {
-		const MenuButton = InstalledMenuButton
-		const Menu = InstalledMenu
-		const MenuItem = InstalledMenuItem
-		return (
-			<MenuButton
-				id={id}
-				button={<Button mode="ghost" icon={buttonIcon} padding={2} />}
-				popover={{ placement: 'bottom-end' }}
-				menu={
-					<Menu>
-						{items.map(item => (
-							<MenuItem
-								key={item.text}
-								text={item.text}
-								icon={item.icon}
-								tone={item.tone}
-								{...(item.href
-									? { as: 'a', href: item.href, target: '_blank', rel: 'noreferrer' }
-									: { onClick: () => item.onClick?.() })}
-							/>
-						))}
-					</Menu>
-				}
-			/>
-		)
-	}
-
-	return (
-		<div ref={wrapRef} style={{ position: 'relative' }}>
-			<Button
-				mode="ghost"
-				icon={buttonIcon}
-				padding={2}
-				id={id}
-				aria-haspopup="menu"
-				aria-expanded={open}
-				onClick={() => setOpen(o => !o)}
-			/>
-			{open && (
-				<Card
-					radius={2}
-					shadow={3}
-					padding={1}
-					role="menu"
-					style={{ position: 'absolute', top: '100%', right: 0, marginTop: 4, zIndex: 1000, minWidth: 180 }}
-				>
-					<Stack space={1}>
-						{items.map(item => {
-							const Icon = item.icon
-							const label = (
-								<Flex align="center" gap={2} paddingX={2} paddingY={2}>
-									<Icon width="1em" height="1em" />
-									<Text size={1}>{item.text}</Text>
-								</Flex>
-							)
-							return item.href ? (
-								<a
-									key={item.text}
-									role="menuitem"
-									href={item.href}
-									target="_blank"
-									rel="noreferrer"
-									onClick={() => setOpen(false)}
-									style={{ color: 'inherit', textDecoration: 'none', display: 'block' }}
-								>
-									{label}
-								</a>
-							) : (
-								<Card
-									key={item.text}
-									as="button"
-									role="menuitem"
-									tone={item.tone === 'critical' ? 'critical' : 'default'}
-									radius={1}
-									onClick={() => runAction(item)}
-									style={{ display: 'block', width: '100%', textAlign: 'left', cursor: 'pointer', border: 0, background: 'none' }}
-								>
-									{label}
-								</Card>
-							)
-						})}
-					</Stack>
-				</Card>
-			)}
-		</div>
-	)
-}
-
-/* ------------------------------------------------------------------- code -- */
-
-/** The real Code when the installed @sanity/ui still exports it, otherwise undefined. */
-const InstalledCode = INSTALLED.Code as
-	| React.ComponentType<{ size?: number; style?: CSSProperties; children: ReactNode }>
-	| undefined
-
-/** Monospace styling for the fallback Code element, approximating @sanity/ui's `size={1}`. */
-const FALLBACK_CODE_STYLE: CSSProperties = {
-	fontFamily: 'ui-monospace, SFMono-Regular, Menlo, Consolas, monospace',
-	fontSize: '0.8125rem',
-	lineHeight: 1.4,
-	margin: 0,
-}
-
-/** Monospace block. Uses Studio's Code where available, a plain `<code>` on @sanity/ui v4+. */
-export function Code({ style, children }: { style?: CSSProperties; children: ReactNode }): React.JSX.Element {
-	if (InstalledCode) return <InstalledCode size={1} style={style}>{children}</InstalledCode>
-	return <code style={{ ...FALLBACK_CODE_STYLE, ...style }}>{children}</code>
-}

package/src/version.ts

@@ -1,2 +0,0 @@
-// Package version — keep in sync with package.json
-export const VERSION = '1.1.1'