@sanity/block-insert-picker 0.0.1 → 1.0.1

package/dist/index.js

@@ -0,0 +1,1195 @@
+import { c } from "react/compiler-runtime";
+import { useEditor } from "@portabletext/editor";
+import { Box, Card, Flex, Hotkeys, Popover, Stack, Text, useToast } from "@sanity/ui";
+import { useContext, useEffect, useId, useLayoutEffect, useMemo, useReducer, useRef, useState } from "react";
+import { useFormCallbacks, useResolveInitialValueForType, useSchema } from "sanity";
+import { defineBehavior, effect, forward, raise } from "@portabletext/editor/behaviors";
+import { blockOffsetsToSelection, getTextBlockText, isTextBlock } from "@portabletext/editor/utils";
+import { PortableTextMemberItemsContext, PortableTextMemberSchemaTypesContext } from "sanity/_singletons";
+import { getBlockTextBefore, getFirstBlock, getFocusBlock, getFocusTextBlock, isSelectionCollapsed } from "@portabletext/editor/selectors";
+import { defineInputRule, defineInputRuleBehavior } from "@portabletext/plugin-input-rule";
+import { BlockElementIcon } from "@sanity/icons/BlockElement";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+/**
+* The member's own name plus every name up its compiled `type` chain, most
+* specific first: `{type: 'image', name: 'photo'}` yields `['photo',
+* 'image', ...]`. Metadata and presets match against this chain so curation
+* can target either the member name or the underlying type name.
+*/
+function typeNameChain(memberType) {
+	let names = [], current = memberType;
+	for (; current && typeof current.name == "string";) names.push(current.name), current = current.type && typeof current.type == "object" && "name" in current.type ? current.type : void 0;
+	return names;
+}
+/**
+* Derives picker items from a portable-text array's insertable member types
+* (see PickerItemsContext), so the picker automatically covers every object
+* block the schema allows. The optional metadata list curates triggers,
+* keywords, grouping, badges, visibility, and descriptions per member type;
+* its array order is the sort rank (see PickerItemMetadata). Titles and
+* icons intentionally stay unresolved here: BlockInsertPicker resolves
+* presentation from the member schema type, which carries member-level
+* config (a member-specific icon, a per-member title override).
+*/
+function derivePickerItems(context, metadata = []) {
+	return context.memberTypes.map((memberType, schemaIndex) => {
+		let chain = typeNameChain(memberType), nameRank = metadata.findIndex((entry) => entry.type === memberType.name), rank = nameRank === -1 ? metadata.findIndex((entry) => chain.includes(entry.type)) : nameRank;
+		return {
+			entry: rank === -1 ? void 0 : metadata[rank],
+			name: memberType.name,
+			rank: rank === -1 ? 2 ** 53 - 1 : rank,
+			schemaIndex
+		};
+	}).filter(({ entry }) => !entry?.hidden).sort((a, b) => a.rank - b.rank || a.schemaIndex - b.schemaIndex).map(({ entry, name }) => ({
+		action: {
+			blockType: name,
+			type: "insertBlock"
+		},
+		badge: entry?.badge,
+		description: entry?.description,
+		group: entry?.group,
+		id: name,
+		keywords: entry?.keywords,
+		openOnInsert: entry?.openOnInsert,
+		title: "",
+		trigger: entry?.trigger
+	}));
+}
+/**
+* Metadata entries whose `type` matches neither a member name nor any name
+* in a member's resolved type chain — almost always a typo. Surfaced as a
+* dev-mode warning by BlockInsertPicker.
+*/
+function unknownMetadataTypes(context, metadata) {
+	let known = new Set(context.memberTypes.flatMap((memberType) => typeNameChain(memberType)));
+	return metadata.map((entry) => entry.type).filter((type) => !known.has(type));
+}
+function filterPickerItems(items, query) {
+	if (query === "" || query === "/") return items;
+	let queryLower = query.toLowerCase(), bareQuery = queryLower.startsWith("/") ? queryLower.slice(1) : queryLower;
+	return items.filter((item) => {
+		let bareTrigger = item.trigger?.toLowerCase().replace(/^\//, "");
+		return bareTrigger && bareQuery !== "" && bareTrigger.startsWith(bareQuery) ? !0 : bareQuery !== "" && !!(item.title.toLowerCase().includes(bareQuery) || item.description?.toLowerCase().includes(bareQuery) || item.keywords?.some((kw) => kw.toLowerCase().includes(bareQuery)));
+	});
+}
+/**
+* Flattens sections back into the single index space that keyboard navigation,
+* selection, and scroll-into-view all share. Rendering the sections and
+* indexing this array must stay derived from the same `groupPickerItems` call
+* so Enter inserts exactly the highlighted row.
+*/
+function flattenSections(sections) {
+	return sections.flatMap((section) => section.items);
+}
+/**
+* Partitions items into sections by their `group`, preserving the incoming
+* order within each section and ordering the sections by first appearance.
+*
+* Because the caller feeds rank-ordered items (see derivePickerItems), the
+* first-appearance rule places the section holding the most-used block first,
+* without a separate ordering constant to drift out of sync. Items without a
+* group collapse into a single `group: null` section (e.g. a curated `items`
+* prop), so the flat/ungrouped case stays a no-op reordering.
+*/
+function groupPickerItems(items) {
+	let order = [], byGroup = /* @__PURE__ */ new Map();
+	for (let item of items) {
+		let key = item.group ?? null, bucket = byGroup.get(key);
+		bucket || (bucket = [], byGroup.set(key, bucket), order.push(key)), bucket.push(item);
+	}
+	return order.map((key) => ({
+		group: key,
+		items: byGroup.get(key)
+	}));
+}
+/**
+* Performs the picker insertion as a single behavior action set so the whole
+* operation is one undo step, and cleans up the typed "/query" text with
+* delete.text over exactly that range (never delete.block) so text that
+* already existed in the anchor block can't be destroyed: the caret can sit
+* at offset 0 of a populated block and still open the picker.
+*/
+function createInsertBehavior() {
+	return defineBehavior({
+		actions: [(_, { anchor, block, cleanup, placement }) => [...cleanup ? [raise({
+			at: cleanup,
+			type: "delete.text"
+		})] : [], raise({
+			block,
+			placement,
+			select: "start",
+			type: "insert.block",
+			...anchor ? { at: anchor } : {}
+		})]],
+		guard: ({ event, snapshot }) => {
+			let { anchorBlockKey, block, mode } = event;
+			return {
+				anchor: snapshot.context.value.some((candidate) => candidate._key === anchorBlockKey) ? blockOffsetsToSelection({
+					offsets: {
+						anchor: {
+							offset: 0,
+							path: [{ _key: anchorBlockKey }]
+						},
+						focus: {
+							offset: 0,
+							path: [{ _key: anchorBlockKey }]
+						}
+					},
+					snapshot
+				}) : null,
+				block,
+				cleanup: resolveQueryCleanup(event, snapshot),
+				placement: mode === "slash" ? "auto" : "after"
+			};
+		},
+		on: "custom.blockInsertPicker.insert"
+	});
+}
+function sendInsertPickerItem(editor, payload) {
+	editor.send({
+		type: "custom.blockInsertPicker.insert",
+		...payload
+	});
+}
+/**
+* The query-cleanup half of the insert behavior on its own, for `custom`
+* picker actions that don't insert a block: the typed "/query" text still
+* leaves the document before the host's `onSelect` runs, under the same
+* only-if-unchanged guard as a real insert.
+*/
+function createCleanupQueryBehavior() {
+	return defineBehavior({
+		actions: [(_, cleanup) => [raise({
+			at: cleanup,
+			type: "delete.text"
+		})]],
+		guard: ({ event, snapshot }) => resolveQueryCleanup(event, snapshot) ?? !1,
+		on: "custom.blockInsertPicker.cleanupQuery"
+	});
+}
+function sendCleanupQuery(editor, payload) {
+	editor.send({
+		type: "custom.blockInsertPicker.cleanupQuery",
+		...payload
+	});
+}
+/**
+* The selection spanning the typed "/query" text in the anchor block, when it
+* is safe to delete. Only slash mode leaves query text in the document, and
+* only when the anchor block still starts with the typed query; if it changed
+* underneath us (collaborator edit, uncaptured caret movement) the action is
+* still the user's intent, but nothing may be deleted.
+*/
+function resolveQueryCleanup(event, snapshot) {
+	let { anchorBlockKey, mode, query } = event;
+	if (mode !== "slash" || query.length === 0) return null;
+	let anchorBlock = snapshot.context.value.find((candidate) => candidate._key === anchorBlockKey);
+	return !anchorBlock || !isTextBlock({ schema: snapshot.context.schema }, anchorBlock) || !getTextBlockText(anchorBlock).startsWith(query) ? null : blockOffsetsToSelection({
+		offsets: {
+			anchor: {
+				offset: 0,
+				path: [{ _key: anchorBlockKey }]
+			},
+			focus: {
+				offset: query.length,
+				path: [{ _key: anchorBlockKey }]
+			}
+		},
+		snapshot
+	});
+}
+function insertPickerItem(ctx) {
+	let blockKey = ctx.keyGenerator();
+	sendInsertPickerItem(ctx.editor, {
+		anchorBlockKey: ctx.anchorBlockKey,
+		block: {
+			...ctx.initialValue,
+			_key: blockKey,
+			_type: ctx.blockType
+		},
+		mode: ctx.mode,
+		query: ctx.query
+	}), ctx.onInsertedKey?.(blockKey);
+}
+const DEFAULT_LABELS = {
+	footerAnywhere: "Anywhere",
+	footerDismiss: "Dismiss",
+	footerInsert: "Insert",
+	footerNavigate: "Navigate",
+	insertAnchorRemoved: "The block you were inserting into was removed",
+	insertError: "Could not insert block",
+	noMatches: "No matches for \"{query}\"",
+	positionAnnouncement: "{index} of {count}",
+	title: "Insert block",
+	ungroupedSection: "Other blocks"
+};
+function resolveLabels(overrides) {
+	return overrides ? {
+		...DEFAULT_LABELS,
+		...overrides
+	} : DEFAULT_LABELS;
+}
+/** Fills the `{query}` placeholder in the no-matches label. */
+function formatNoMatches(labels, query) {
+	return labels.noMatches.replace("{query}", () => query);
+}
+/** Fills `{index}`/`{count}` in the screen-reader position announcement. */
+function formatPosition(labels, index, count) {
+	return labels.positionAnnouncement.replace("{index}", () => String(index)).replace("{count}", () => String(count));
+}
+function usePickerItemsContext(arrayTypeName) {
+	let $ = c(7), memberSchemaTypes = useContext(PortableTextMemberSchemaTypesContext), schema = useSchema(), t0;
+	if ($[0] !== arrayTypeName || $[1] !== memberSchemaTypes || $[2] !== schema) {
+		bb0: {
+			if (memberSchemaTypes) {
+				let t1;
+				$[4] !== memberSchemaTypes.blockObjects || $[5] !== memberSchemaTypes.portableText ? (t1 = {
+					memberTypes: memberSchemaTypes.blockObjects,
+					schemaType: memberSchemaTypes.portableText
+				}, $[4] = memberSchemaTypes.blockObjects, $[5] = memberSchemaTypes.portableText, $[6] = t1) : t1 = $[6], t0 = t1;
+				break bb0;
+			}
+			let arrayType = arrayTypeName ? schema.get(arrayTypeName) : void 0;
+			if (!arrayType || arrayType.jsonType !== "array") {
+				t0 = null;
+				break bb0;
+			}
+			t0 = {
+				memberTypes: arrayType.of.filter(_temp$1),
+				schemaType: arrayType
+			};
+		}
+		$[0] = arrayTypeName, $[1] = memberSchemaTypes, $[2] = schema, $[3] = t0;
+	} else t0 = $[3];
+	return t0;
+}
+/**
+* Whether a member resolves to the built-in text block: walk the compiled
+* `type` chain to its root and compare the root's name — the same algorithm
+* Studio's schema bridge uses to bucketize `of`. A literal `name === 'block'`
+* check would miss aliased text blocks (`{name: 'myBlock', type: 'block'}`)
+* and wrongly offer them as object inserts.
+*/
+function _temp$1(member) {
+	return member.jsonType === "object" && !isTextBlockMember(member);
+}
+function isTextBlockMember(memberType) {
+	let current = memberType;
+	for (; current.type && typeof current.type == "object" && "name" in current.type;) current = current.type;
+	return current.name === "block";
+}
+/**
+* Opens a just-inserted block's editing UI (dialog/popover per the member's
+* config) once its member item mounts. An insert lands synchronously, but the
+* member item only exists on a later render — so callers schedule the key and
+* the effect opens it when it appears.
+*
+* Together with memberSchemaTypes.ts, this module is one of exactly two
+* importers of `sanity/_singletons` in this plugin: the subpath is internal
+* with no stability guarantee, so each dependency stays quarantined where it
+* can be swapped for a public API in one place. Consumers that need to react
+* to inserts without this internal should use the `onInsert` seam on the
+* plugin components instead.
+*/
+function useOpenBlockOnInsert() {
+	let $ = c(6), memberItems = useContext(PortableTextMemberItemsContext), { onPathOpen, onSetPathCollapsed } = useFormCallbacks(), pendingKeyRef = useRef(null), t0, t1;
+	$[0] !== memberItems || $[1] !== onPathOpen || $[2] !== onSetPathCollapsed ? (t0 = () => {
+		let key = pendingKeyRef.current;
+		if (!key) return;
+		let item = memberItems.find((m) => m.member.key === key);
+		item && (onPathOpen(item.member.item.path), onSetPathCollapsed(item.member.item.path, !1), pendingKeyRef.current = null);
+	}, t1 = [
+		memberItems,
+		onPathOpen,
+		onSetPathCollapsed
+	], $[0] = memberItems, $[1] = onPathOpen, $[2] = onSetPathCollapsed, $[3] = t0, $[4] = t1) : (t0 = $[3], t1 = $[4]), useEffect(t0, t1);
+	let t2;
+	return $[5] === Symbol.for("react.memo_cache_sentinel") ? (t2 = (blockKey) => {
+		pendingKeyRef.current = blockKey;
+	}, $[5] = t2) : t2 = $[5], t2;
+}
+function createPickerBehavior({ getState, isShortcutEnabled, onIntent }) {
+	return defineBehavior({
+		actions: [(payload, guardResponse) => {
+			let { blockEvent, intent } = guardResponse, sideEffect = effect(() => onIntent(intent));
+			return blockEvent ? [sideEffect] : [sideEffect, forward(payload.event)];
+		}],
+		guard: ({ event, snapshot }) => {
+			let state = getState();
+			if (state.mode === "closed") {
+				if (event.type === "insert.text" && event.text === "/") {
+					let focus = getFocusTextBlock(snapshot);
+					return !focus || !isSelectionCollapsed(snapshot) || getBlockTextBefore(snapshot) !== "" ? !1 : {
+						blockEvent: !1,
+						intent: {
+							anchorBlockKey: focus.node._key,
+							mode: "slash",
+							query: "/",
+							type: "open"
+						}
+					};
+				}
+				if (event.type === "keyboard.keydown" && event.originEvent.key === "/" && (event.originEvent.metaKey || event.originEvent.ctrlKey) && isShortcutEnabled()) {
+					let focus = getFocusBlock(snapshot), fallback = getFirstBlock(snapshot), anchorBlock = focus ?? fallback;
+					return anchorBlock ? {
+						blockEvent: !0,
+						intent: {
+							anchorBlockKey: anchorBlock.node._key,
+							mode: "shortcut",
+							query: "",
+							type: "open"
+						}
+					} : !1;
+				}
+				return !1;
+			}
+			if (event.type === "insert.text") return state.mode === "slash" ? event.text === " " ? {
+				blockEvent: !1,
+				intent: { type: "close" }
+			} : {
+				blockEvent: !1,
+				intent: {
+					query: state.query + event.text,
+					type: "updateQuery"
+				}
+			} : {
+				blockEvent: !0,
+				intent: {
+					query: state.query + event.text,
+					type: "updateQuery"
+				}
+			};
+			if (event.type === "delete.backward") return state.mode === "shortcut" ? state.query.length === 0 ? {
+				blockEvent: !0,
+				intent: { type: "close" }
+			} : {
+				blockEvent: !0,
+				intent: {
+					query: event.unit === "character" ? state.query.slice(0, -1) : "",
+					type: "updateQuery"
+				}
+			} : event.unit === "character" && state.query.length > 1 ? {
+				blockEvent: !1,
+				intent: {
+					query: state.query.slice(0, -1),
+					type: "updateQuery"
+				}
+			} : {
+				blockEvent: !1,
+				intent: { type: "close" }
+			};
+			if (event.type === "delete.forward") return {
+				blockEvent: !1,
+				intent: { type: "close" }
+			};
+			if (event.type === "keyboard.keydown") {
+				let key = event.originEvent.key;
+				if (key === "ArrowDown") return {
+					blockEvent: !0,
+					intent: {
+						delta: 1,
+						type: "navigate"
+					}
+				};
+				if (key === "ArrowUp") return {
+					blockEvent: !0,
+					intent: {
+						delta: -1,
+						type: "navigate"
+					}
+				};
+				if (key === "Enter") return {
+					blockEvent: !0,
+					intent: { type: "select" }
+				};
+				if (key === "Escape") return {
+					blockEvent: !0,
+					intent: { type: "close" }
+				};
+				if (key === "ArrowLeft" || key === "ArrowRight" || key === "Home" || key === "End" || key === "PageUp" || key === "PageDown") return {
+					blockEvent: !1,
+					intent: { type: "close" }
+				};
+			}
+			return !1;
+		},
+		on: "*"
+	});
+}
+function pickerReducer(state, intent) {
+	switch (intent.type) {
+		case "close":
+		case "select": return { mode: "closed" };
+		case "navigate": return state.mode === "closed" ? state : {
+			...state,
+			highlightedIndex: state.highlightedIndex + intent.delta
+		};
+		case "open": return state.mode === "closed" ? {
+			anchorBlockKey: intent.anchorBlockKey,
+			highlightedIndex: 0,
+			mode: intent.mode,
+			query: intent.query
+		} : state;
+		case "setHighlightedIndex": return state.mode === "closed" ? state : {
+			...state,
+			highlightedIndex: intent.index
+		};
+		case "updateQuery": return state.mode === "closed" ? state : {
+			...state,
+			highlightedIndex: 0,
+			query: intent.query
+		};
+		default: return intent;
+	}
+}
+/**
+* Builds InputRules for the configs whose block type the host array actually
+* allows, so a rule can't insert a block the field would reject.
+*/
+function createMarkdownInputRules({ allowedBlockTypes, keyGenerator, onInserted, rules }) {
+	return rules.filter((config) => allowedBlockTypes.has(config.blockType)).map((config) => createInsertRule(config, keyGenerator, onInserted));
+}
+const CODE_FENCE_PATTERN = /^`{3}\S*\s$/, BLOCKQUOTE_PATTERN = /^>\s$/;
+/** Sugar: a blockquote rule ("> " at the start of a block) for `blockType`. */
+function blockquoteRule(options) {
+	return {
+		blockType: options.blockType,
+		buildValue: ({ keyGenerator }) => options.createValue?.({ keyGenerator }) ?? {},
+		pattern: BLOCKQUOTE_PATTERN
+	};
+}
+/**
+* Sugar: a code-fence rule ("```lang␣") for `blockType`. The language table
+* resolves fence tokens (aliases included) to the values the block's language
+* selector stores, plus an optional filename; tokens outside the table pass
+* through as typed so nothing the writer means is lost. `createValue` turns
+* the resolved language and filename into the block's fields.
+*/
+function codeFenceRule(options) {
+	let languages = options.languages ?? [];
+	return {
+		blockType: options.blockType,
+		buildValue: ({ keyGenerator, matchText }) => {
+			let language = normalizeFenceLanguage(fenceLanguageFromMatch(matchText), languages, options.defaultLanguage), filename = language ? languages.find((entry) => entry.value === language)?.filename : void 0;
+			return options.createValue({
+				filename,
+				keyGenerator,
+				language
+			});
+		},
+		pattern: CODE_FENCE_PATTERN
+	};
+}
+/** Strips the leading "```" fence and surrounding whitespace from a match. */
+function fenceLanguageFromMatch(matchText) {
+	return matchText.replace(/^`{3}/, "").trim();
+}
+/**
+* Resolves a typed fence token against a language table: a canonical value,
+* an alias (`py`→python, `yml`→yaml), or — for anything the table doesn't
+* know — the token as typed. An empty token yields `defaultLanguage`.
+*/
+function normalizeFenceLanguage(raw, languages, defaultLanguage) {
+	let token = raw.trim(), lower = token.toLowerCase();
+	if (!lower) return defaultLanguage;
+	for (let { aliases, value } of languages) if (value.toLowerCase() === lower || aliases?.some((alias) => alias.toLowerCase() === lower)) return value;
+	return token;
+}
+function createInsertRule(config, keyGenerator, onInserted) {
+	return defineInputRule({
+		actions: [({ event, snapshot }) => {
+			let match = event.matches[0];
+			if (!match) return [];
+			let block = {
+				...config.buildValue({
+					keyGenerator,
+					matchText: match.text
+				}),
+				_key: keyGenerator(),
+				_type: config.blockType
+			};
+			return [
+				raise({
+					at: blockOffsetsToSelection({
+						offsets: {
+							anchor: match.targetOffsets.anchor,
+							focus: match.targetOffsets.focus
+						},
+						snapshot
+					}) ?? match.selection,
+					type: "delete.text"
+				}),
+				raise({
+					block,
+					placement: "auto",
+					select: "start",
+					type: "insert.block"
+				}),
+				effect(() => onInserted(block))
+			];
+		}],
+		on: config.pattern
+	});
+}
+/**
+* Default triggers and search keywords for block types with fixed, official
+* names: Studio's intrinsic types (`image`, `file`), first-party plugin
+* types (`code`, `table`, `color`, `latex`, `mux.video`), and the Media
+* Library's `sanity.video`. Presets are deliberately presentation-only —
+* they never add items (a type must actually be a member of the array),
+* never set groups (partial grouping would strand unmatched items in an
+* "Other" bucket), never affect rank, and always lose to a host's `items`
+* entry for the same type. Opt out entirely with `presets: false`.
+*/
+const standardBlockPresets = [
+	{
+		keywords: [
+			"photo",
+			"picture",
+			"figure",
+			"media"
+		],
+		trigger: "/image",
+		type: "image"
+	},
+	{
+		keywords: [
+			"attachment",
+			"download",
+			"document"
+		],
+		trigger: "/file",
+		type: "file"
+	},
+	{
+		keywords: [
+			"snippet",
+			"syntax",
+			"fence",
+			"pre"
+		],
+		trigger: "/code",
+		type: "code"
+	},
+	{
+		keywords: [
+			"grid",
+			"rows",
+			"columns",
+			"spreadsheet"
+		],
+		trigger: "/table",
+		type: "table"
+	},
+	{
+		keywords: ["swatch", "palette"],
+		trigger: "/color",
+		type: "color"
+	},
+	{
+		keywords: [
+			"formula",
+			"equation",
+			"math",
+			"tex",
+			"katex"
+		],
+		trigger: "/latex",
+		type: "latex"
+	},
+	{
+		keywords: [
+			"video",
+			"player",
+			"mux"
+		],
+		trigger: "/video",
+		type: "mux.video"
+	},
+	{
+		keywords: [
+			"video",
+			"player",
+			"media"
+		],
+		trigger: "/video",
+		type: "sanity.video"
+	}
+], wellKnownInputRules = [codeFenceRule({
+	blockType: "code",
+	createValue: ({ language }) => language ? { language } : {}
+})];
+/**
+* Fills preset triggers and keywords into derived items that don't already
+* have them, matching presets against each member's resolved type chain so
+* `{type: 'image', name: 'photo'}` still gets the image preset. Host `items`
+* metadata has already been folded in by derivePickerItems, so anything it
+* set wins by construction.
+*/
+function applyPresetMetadata(items, context, presets = standardBlockPresets) {
+	let presetByType = new Map(presets.map((preset) => [preset.type, preset]));
+	return items.map((item) => {
+		if (item.action.type !== "insertBlock" || item.trigger !== void 0 && item.keywords !== void 0) return item;
+		let blockType = item.action.blockType, memberType = context.memberTypes.find((candidate) => candidate.name === blockType);
+		if (!memberType) return item;
+		let preset = typeNameChain(memberType).map((name) => presetByType.get(name)).find(Boolean);
+		return preset ? {
+			...item,
+			keywords: item.keywords ?? preset.keywords,
+			trigger: item.trigger ?? preset.trigger
+		} : item;
+	});
+}
+/**
+* Resolves what a picker row shows for an item, following the same fallback
+* chains Studio's built-in insert menu uses: icon from the member type, its
+* parent type, a reference target, then the generic block icon; title from
+* the member type or its capitalized name. The curated description (from
+* `items` metadata) wins over the schema type's own — curation is the more
+* specific intent.
+*/
+function resolveItemPresentation(item, schemaType) {
+	return schemaType ? {
+		description: item.description ?? schemaType.description,
+		icon: schemaType.icon ?? schemaType.type?.icon ?? schemaType.to?.[0]?.icon ?? BlockElementIcon,
+		title: schemaType.title ?? upperFirst(schemaType.name)
+	} : {
+		description: item.description,
+		icon: item.icon ?? BlockElementIcon,
+		title: item.title || (item.action.type === "insertBlock" ? item.action.blockType : item.id)
+	};
+}
+function upperFirst(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function BlockInsertPicker({ arrayTypeName, filter, items, labels: labelOverrides, onInsert, openOnInsert = !0, presets = !0, resolveItems, shortcut = !0 }) {
+	let editor = useEditor(), openBlockOnInsert = useOpenBlockOnInsert(), itemsContext = usePickerItemsContext(arrayTypeName), schema = useSchema(), resolveInitialValueForType = useResolveInitialValueForType(), toast = useToast(), labels = useMemo(() => resolveLabels(labelOverrides), [labelOverrides]), instanceId = useId(), listboxId = `${instanceId}-listbox`, optionId = (id) => `${instanceId}-option-${id}`, pickerItems = useMemo(() => {
+		if (!itemsContext) return [];
+		let presented = (presets ? applyPresetMetadata(derivePickerItems(itemsContext, items), itemsContext) : derivePickerItems(itemsContext, items)).map((item) => {
+			if (item.action.type !== "insertBlock") return item;
+			let presentation = resolveItemPresentation(item, memberTypeFor(itemsContext, schema, item.action.blockType));
+			return Object.assign(item, {
+				description: presentation.description,
+				icon: presentation.icon,
+				title: presentation.title
+			});
+		});
+		return resolveItems ? [...resolveItems(presented, itemsContext)] : presented;
+	}, [
+		items,
+		itemsContext,
+		presets,
+		resolveItems,
+		schema
+	]), hasItems = pickerItems.length > 0, warnedRef = useRef({});
+	useEffect(() => {
+		if (process.env.NODE_ENV === "production") return;
+		let warned = warnedRef.current;
+		if (!itemsContext && !warned.context) {
+			warned.context = !0, console.warn("[@sanity/block-insert-picker] No Portable Text member schema context found and no `arrayTypeName` resolved to an array type — the picker is disabled for this field.");
+			return;
+		}
+		if (itemsContext && items && !warned.unknown) {
+			let unknown = unknownMetadataTypes(itemsContext, items);
+			unknown.length > 0 && (warned.unknown = !0, console.warn(`[@sanity/block-insert-picker] \`items\` metadata references types that are not members of this array: ${unknown.join(", ")}`));
+		}
+		itemsContext && !hasItems && !warned.empty && (warned.empty = !0, console.warn("[@sanity/block-insert-picker] No insertable items: the array has no non-text-block members (and `resolveItems` added none) — the picker is disabled for this field."));
+	}, [
+		hasItems,
+		items,
+		itemsContext
+	]);
+	let [state, dispatch] = useReducer(pickerReducer, { mode: "closed" }), stateRef = useRef(state);
+	useLayoutEffect(() => {
+		stateRef.current = state;
+	});
+	let shortcutRef = useRef(shortcut);
+	useLayoutEffect(() => {
+		shortcutRef.current = shortcut;
+	});
+	let open = state.mode !== "closed", query = open ? state.query : "", mode = open ? state.mode : null, filterItems = filter ?? filterPickerItems, filterQuery = mode === "slash" ? bareQuery(query) : query, sections = useMemo(() => groupPickerItems(filterItems(pickerItems, filterQuery)), [
+		filterItems,
+		filterQuery,
+		pickerItems
+	]), filtered = useMemo(() => flattenSections(sections), [sections]), sectionOffsets = useMemo(() => {
+		let offsets = [], total = 0;
+		for (let section of sections) offsets.push(total), total += section.items.length;
+		return offsets;
+	}, [sections]), showGroupHeaders = sections.length > 1, insertInFlightRef = useRef(!1), insertItemAtIndex = async (current, idx) => {
+		if (insertInFlightRef.current) {
+			dispatch({ type: "close" });
+			return;
+		}
+		insertInFlightRef.current = !0;
+		try {
+			let visible = flattenSections(groupPickerItems(filterItems(pickerItems, current.mode === "slash" ? bareQuery(current.query) : current.query))), chosen = visible[Math.max(0, Math.min(visible.length - 1, idx))];
+			if (dispatch({ type: "close" }), !chosen) return;
+			if (chosen.action.type === "custom") {
+				sendCleanupQuery(editor, {
+					anchorBlockKey: current.anchorBlockKey,
+					mode: current.mode,
+					query: current.query
+				}), chosen.action.onSelect({
+					closePicker: () => dispatch({ type: "close" }),
+					editor
+				});
+				return;
+			}
+			let blockType = chosen.action.blockType, initialValue, schemaType_0 = memberTypeFor(itemsContext, schema, blockType);
+			schemaType_0 && (initialValue = await resolveInitialValueForType(schemaType_0, {}) ?? void 0);
+			let snapshot = editor.getSnapshot();
+			if (!snapshot.context.value.some((b) => b._key === current.anchorBlockKey)) {
+				toast.push({
+					closable: !0,
+					description: labels.insertAnchorRemoved,
+					status: "warning",
+					title: labels.insertError
+				});
+				return;
+			}
+			insertPickerItem({
+				anchorBlockKey: current.anchorBlockKey,
+				blockType,
+				editor,
+				initialValue,
+				keyGenerator: () => snapshot.context.keyGenerator(),
+				mode: current.mode,
+				onInsertedKey: (key) => {
+					(chosen.openOnInsert ?? openOnInsert) && openBlockOnInsert(key), onInsert?.({
+						blockKey: key,
+						blockType,
+						mode: current.mode,
+						query: current.query,
+						via: "picker"
+					});
+				},
+				query: current.query
+			});
+		} catch (error) {
+			toast.push({
+				closable: !0,
+				description: error instanceof Error ? error.message : String(error),
+				status: "error",
+				title: labels.insertError
+			});
+		} finally {
+			insertInFlightRef.current = !1;
+		}
+	}, selectItemAtIndex = (idx_0) => {
+		let current_0 = stateRef.current;
+		current_0.mode !== "closed" && insertItemAtIndex(current_0, idx_0);
+	}, handleIntent = (intent) => {
+		if (intent.type === "navigate") {
+			let current_1 = stateRef.current;
+			if (current_1.mode === "closed") return;
+			let lastIndex = filtered.length - 1, base = Math.max(0, Math.min(lastIndex, current_1.highlightedIndex)), next = Math.max(0, Math.min(lastIndex, base + intent.delta));
+			dispatch({
+				index: next,
+				type: "setHighlightedIndex"
+			});
+			return;
+		}
+		if (intent.type !== "select") {
+			dispatch(intent);
+			return;
+		}
+		let current_2 = stateRef.current;
+		current_2.mode !== "closed" && insertItemAtIndex(current_2, current_2.highlightedIndex);
+	}, handleIntentRef = useRef(handleIntent);
+	useLayoutEffect(() => {
+		handleIntentRef.current = handleIntent;
+	}), useEffect(() => {
+		if (!hasItems) return;
+		let behavior = createPickerBehavior({
+			getState: () => stateRef.current,
+			isShortcutEnabled: () => shortcutRef.current,
+			onIntent: (intent_0) => handleIntentRef.current(intent_0)
+		}), unregisterPicker = editor.registerBehavior({ behavior }), unregisterInsert = editor.registerBehavior({ behavior: createInsertBehavior() }), unregisterCleanup = editor.registerBehavior({ behavior: createCleanupQueryBehavior() });
+		return () => {
+			unregisterPicker(), unregisterInsert(), unregisterCleanup();
+		};
+	}, [editor, hasItems]), useEffect(() => {
+		!hasItems && stateRef.current.mode !== "closed" && dispatch({ type: "close" });
+	}, [hasItems]);
+	let highlightedIndex = open ? Math.max(0, Math.min(filtered.length - 1, state.highlightedIndex)) : 0, highlightedItem = open ? filtered[highlightedIndex] : void 0, announcement = highlightedItem ? [
+		highlightedItem.title,
+		highlightedItem.description,
+		formatPosition(labels, highlightedIndex + 1, filtered.length)
+	].filter(Boolean).join(", ") : "", [cursorRect, setCursorRect] = useState(null);
+	useLayoutEffect(() => {
+		if (!open) {
+			setCursorRect(null);
+			return;
+		}
+		let snapshot_0 = editor.getSnapshot(), rect = editor.dom.getSelectionRect(snapshot_0);
+		if (rect && (rect.x || rect.y || rect.width || rect.height)) {
+			setCursorRect(rect);
+			return;
+		}
+		let blockRect = editor.dom.getStartBlockElement(snapshot_0)?.getBoundingClientRect();
+		blockRect && setCursorRect(blockRect);
+	}, [editor, open]);
+	let popoverContentRef = useRef(null);
+	useEffect(() => {
+		if (!open) return;
+		let handlePointerDown = (event) => {
+			let target = event.target;
+			target instanceof Node && popoverContentRef.current?.contains(target) || dispatch({ type: "close" });
+		}, editorElement = editor.dom.getEditorElement(), handleFocusOut = (event_0) => {
+			let next_0 = event_0 instanceof FocusEvent ? event_0.relatedTarget : null;
+			next_0 instanceof Node && (editorElement?.contains(next_0) || popoverContentRef.current?.contains(next_0)) || dispatch({ type: "close" });
+		};
+		return document.addEventListener("pointerdown", handlePointerDown, !0), editorElement?.addEventListener("focusout", handleFocusOut), () => {
+			document.removeEventListener("pointerdown", handlePointerDown, !0), editorElement?.removeEventListener("focusout", handleFocusOut);
+		};
+	}, [editor, open]);
+	let highlightedRowRef = useRef(null), lastPointerRef = useRef(null), highlightOnPointerMove = (idx_1, x, y) => {
+		let last = lastPointerRef.current;
+		if (lastPointerRef.current = {
+			x,
+			y
+		}, !last || last.x === x && last.y === y) return;
+		let current_3 = stateRef.current;
+		current_3.mode !== "closed" && idx_1 !== current_3.highlightedIndex && dispatch({
+			index: idx_1,
+			type: "setHighlightedIndex"
+		});
+	};
+	useEffect(() => {
+		highlightedRowRef.current?.scrollIntoView({ block: "nearest" });
+	}, [highlightedIndex]);
+	let cursorElement = useMemo(() => cursorRect ? { getBoundingClientRect: () => cursorRect } : null, [cursorRect]);
+	return open ? filtered.length === 0 ? /* @__PURE__ */ jsx(Popover, {
+		constrainSize: !0,
+		content: /* @__PURE__ */ jsx(Card, {
+			"aria-live": "polite",
+			onMouseDown: preventFocusSteal,
+			padding: 3,
+			radius: 2,
+			ref: popoverContentRef,
+			role: "status",
+			children: /* @__PURE__ */ jsx(Text, {
+				muted: !0,
+				size: 1,
+				children: formatNoMatches(labels, query)
+			})
+		}),
+		fallbackPlacements: ["top-start"],
+		open: !0,
+		placement: "bottom-start",
+		portal: !0,
+		preventOverflow: !0,
+		referenceElement: cursorElement
+	}) : /* @__PURE__ */ jsx(Popover, {
+		constrainSize: !0,
+		content: /* @__PURE__ */ jsxs(Card, {
+			onMouseDown: preventFocusSteal,
+			padding: 1,
+			radius: 2,
+			ref: popoverContentRef,
+			style: {
+				display: "flex",
+				flexDirection: "column",
+				maxHeight: "100%",
+				minWidth: 300
+			},
+			children: [
+				/* @__PURE__ */ jsx("output", {
+					"aria-live": "polite",
+					style: SR_ONLY,
+					children: announcement
+				}),
+				/* @__PURE__ */ jsxs(Flex, {
+					align: "center",
+					flex: "none",
+					gap: 2,
+					padding: 2,
+					children: [/* @__PURE__ */ jsx(Box, {
+						flex: 1,
+						children: /* @__PURE__ */ jsx(Text, {
+							muted: !0,
+							size: 0,
+							style: {
+								letterSpacing: "0.05em",
+								textTransform: "uppercase"
+							},
+							weight: "medium",
+							children: labels.title
+						})
+					}), mode === "shortcut" && query !== "" ? /* @__PURE__ */ jsx(Text, {
+						muted: !0,
+						size: 1,
+						textOverflow: "ellipsis",
+						children: query
+					}) : null]
+				}),
+				/* @__PURE__ */ jsx(Box, {
+					"aria-label": labels.title,
+					id: listboxId,
+					role: "listbox",
+					style: {
+						flex: 1,
+						maxHeight: 320,
+						minHeight: 0,
+						overflowY: "auto"
+					},
+					children: sections.map((section_0, sectionIndex) => {
+						let sectionLabel = section_0.group ?? labels.ungroupedSection, sectionKey = section_0.group === null ? "ungrouped" : `group:${section_0.group}`, rows = section_0.items.map((item_0, rowIndex) => {
+							let idx_2 = (sectionOffsets[sectionIndex] ?? 0) + rowIndex, Icon = item_0.icon, isHighlighted = idx_2 === highlightedIndex;
+							return /* @__PURE__ */ jsx(Card, {
+								"aria-selected": isHighlighted,
+								id: optionId(String(idx_2)),
+								onClick: () => selectItemAtIndex(idx_2),
+								onMouseMove: (event_1) => highlightOnPointerMove(idx_2, event_1.clientX, event_1.clientY),
+								padding: 2,
+								radius: 1,
+								ref: isHighlighted ? highlightedRowRef : void 0,
+								role: "option",
+								style: { cursor: "pointer" },
+								tabIndex: -1,
+								tone: isHighlighted ? "primary" : "default",
+								children: /* @__PURE__ */ jsxs(Flex, {
+									align: "center",
+									gap: 3,
+									children: [
+										/* @__PURE__ */ jsx(Box, {
+											style: {
+												alignItems: "center",
+												display: "flex",
+												height: 22,
+												justifyContent: "center",
+												width: 22
+											},
+											children: Icon ? /* @__PURE__ */ jsx(Icon, {}) : null
+										}),
+										/* @__PURE__ */ jsxs(Stack, {
+											flex: 1,
+											gap: 2,
+											children: [/* @__PURE__ */ jsx(Text, {
+												size: 1,
+												textOverflow: "ellipsis",
+												children: item_0.title
+											}), item_0.description ? /* @__PURE__ */ jsx(Text, {
+												muted: !0,
+												size: 0,
+												textOverflow: "ellipsis",
+												children: item_0.description
+											}) : null]
+										}),
+										item_0.badge ? /* @__PURE__ */ jsx(Box, {
+											flex: "none",
+											children: /* @__PURE__ */ jsx(Text, {
+												muted: !0,
+												size: 0,
+												children: item_0.badge
+											})
+										}) : null,
+										item_0.trigger ? /* @__PURE__ */ jsx(Box, {
+											flex: "none",
+											children: /* @__PURE__ */ jsx(Hotkeys, {
+												fontSize: 0,
+												keys: [item_0.trigger]
+											})
+										}) : null
+									]
+								})
+							}, `${item_0.id}-${idx_2}`);
+						});
+						return showGroupHeaders ? /* @__PURE__ */ jsxs(Box, {
+							"aria-label": sectionLabel,
+							paddingTop: sectionIndex === 0 ? 0 : 2,
+							role: "group",
+							children: [/* @__PURE__ */ jsx(Box, {
+								paddingBottom: 1,
+								paddingTop: 2,
+								paddingX: 2,
+								children: /* @__PURE__ */ jsx(Text, {
+									muted: !0,
+									size: 0,
+									style: {
+										letterSpacing: "0.05em",
+										textTransform: "uppercase"
+									},
+									weight: "medium",
+									children: sectionLabel
+								})
+							}), /* @__PURE__ */ jsx(Stack, {
+								gap: 1,
+								children: rows
+							})]
+						}, sectionKey) : /* @__PURE__ */ jsx(Stack, {
+							gap: 1,
+							children: rows
+						}, sectionKey);
+					})
+				}),
+				/* @__PURE__ */ jsx(Card, {
+					borderTop: !0,
+					flex: "none",
+					padding: 2,
+					radius: 0,
+					children: /* @__PURE__ */ jsxs(Flex, {
+						align: "center",
+						gap: 3,
+						wrap: "wrap",
+						children: [
+							/* @__PURE__ */ jsx(FooterHint, {
+								keys: ["↑", "↓"],
+								label: labels.footerNavigate
+							}),
+							/* @__PURE__ */ jsx(FooterHint, {
+								keys: ["↵"],
+								label: labels.footerInsert
+							}),
+							/* @__PURE__ */ jsx(FooterHint, {
+								keys: ["Esc"],
+								label: labels.footerDismiss
+							}),
+							shortcut ? /* @__PURE__ */ jsx(FooterHint, {
+								keys: [OPEN_MODIFIER, "/"],
+								label: labels.footerAnywhere
+							}) : null
+						]
+					})
+				})
+			]
+		}),
+		fallbackPlacements: ["top-start"],
+		open: !0,
+		placement: "bottom-start",
+		portal: !0,
+		preventOverflow: !0,
+		referenceElement: cursorElement
+	}) : null;
+}
+function FooterHint(t0) {
+	let $ = c(7), { keys, label } = t0, t1;
+	$[0] === keys ? t1 = $[1] : (t1 = /* @__PURE__ */ jsx(Hotkeys, {
+		fontSize: 0,
+		keys
+	}), $[0] = keys, $[1] = t1);
+	let t2;
+	$[2] === label ? t2 = $[3] : (t2 = /* @__PURE__ */ jsx(Text, {
+		muted: !0,
+		size: 0,
+		children: label
+	}), $[2] = label, $[3] = t2);
+	let t3;
+	return $[4] !== t1 || $[5] !== t2 ? (t3 = /* @__PURE__ */ jsxs(Flex, {
+		align: "center",
+		gap: 2,
+		children: [t1, t2]
+	}), $[4] = t1, $[5] = t2, $[6] = t3) : t3 = $[6], t3;
+}
+function memberTypeFor(itemsContext, schema, blockType) {
+	return itemsContext?.memberTypes.find((candidate) => candidate.name === blockType) ?? schema.get(blockType);
+}
+function bareQuery(query) {
+	return query.startsWith("/") ? query.slice(1) : query;
+}
+function preventFocusSteal(event) {
+	event.preventDefault();
+}
+const SR_ONLY = {
+	border: 0,
+	clipPath: "inset(50%)",
+	height: 1,
+	margin: -1,
+	overflow: "hidden",
+	padding: 0,
+	position: "absolute",
+	whiteSpace: "nowrap",
+	width: 1
+}, OPEN_MODIFIER = typeof navigator < "u" && /mac|iphone|ipad|ipod/i.test(navigator.platform || navigator.userAgent || "") ? "⌘" : "Ctrl";
+/**
+* Mounts markdown input rules on the PTE and opens each inserted block for
+* editing once its member item mounts — the same open-on-insert behavior the
+* picker uses, so a fenced code block lands ready to type into.
+*/
+function MarkdownInputRules(t0) {
+	let $ = c(15), { arrayTypeName, onInsert, openOnInsert: t1, rules } = t0, openOnInsert = t1 === void 0 || t1, editor = useEditor(), itemsContext = usePickerItemsContext(arrayTypeName), openBlockOnInsert = useOpenBlockOnInsert(), t2;
+	$[0] === itemsContext?.memberTypes ? t2 = $[1] : (t2 = itemsContext?.memberTypes ?? [], $[0] = itemsContext?.memberTypes, $[1] = t2);
+	let memberTypes = t2, t3;
+	if ($[2] !== memberTypes || $[3] !== rules) {
+		let t4;
+		$[5] === memberTypes ? t4 = $[6] : (t4 = (rule) => {
+			let member = memberTypes.find((candidate_0) => candidate_0.name === rule.blockType) ?? memberTypes.find((candidate) => typeNameChain(candidate).includes(rule.blockType));
+			return member ? [rule.blockType === member.name ? rule : {
+				...rule,
+				blockType: member.name
+			}] : [];
+		}, $[5] = memberTypes, $[6] = t4), t3 = rules.flatMap(t4), $[2] = memberTypes, $[3] = rules, $[4] = t3;
+	} else t3 = $[4];
+	let resolvedRules = t3, onInsertedRef = useRef(_temp), t4;
+	$[7] !== onInsert || $[8] !== openBlockOnInsert || $[9] !== openOnInsert ? (t4 = () => {
+		onInsertedRef.current = (block) => {
+			openOnInsert && openBlockOnInsert(block._key), onInsert?.({
+				blockKey: block._key,
+				blockType: block._type,
+				via: "inputRule"
+			});
+		};
+	}, $[7] = onInsert, $[8] = openBlockOnInsert, $[9] = openOnInsert, $[10] = t4) : t4 = $[10], useLayoutEffect(t4);
+	let t5, t6;
+	return $[11] !== editor || $[12] !== resolvedRules ? (t5 = () => {
+		let inputRules = createMarkdownInputRules({
+			allowedBlockTypes: new Set(resolvedRules.map(_temp2)),
+			keyGenerator: () => editor.getSnapshot().context.keyGenerator(),
+			onInserted: (block_0) => onInsertedRef.current(block_0),
+			rules: resolvedRules
+		});
+		if (inputRules.length !== 0) return editor.registerBehavior({ behavior: defineInputRuleBehavior({ rules: inputRules }) });
+	}, t6 = [editor, resolvedRules], $[11] = editor, $[12] = resolvedRules, $[13] = t5, $[14] = t6) : (t5 = $[13], t6 = $[14]), useEffect(t5, t6), null;
+}
+function _temp2(rule_0) {
+	return rule_0.blockType;
+}
+function _temp() {}
+/**
+* Creates the Portable Text editor plugins component for the block-insert
+* picker: a slash-command / Cmd+/ menu of the blocks the host array allows,
+* plus optional markdown input rules. Zero-config is the intended call —
+* items derive from the array the plugin is mounted on. Attach it to the
+* array type's `components.portableText.plugins`:
+*
+* ```ts
+* defineType({
+*   name: 'content',
+*   type: 'array',
+*   of: [{type: 'block'}, {type: 'callout'}],
+*   components: {
+*     portableText: {
+*       plugins: blockInsertPicker(),
+*     },
+*   },
+* })
+* ```
+*/
+function blockInsertPicker(config = {}) {
+	let { arrayTypeName, filter, inputRules, items, labels, onInsert, openOnInsert, presets, resolveItems, shortcut } = config;
+	return function(props) {
+		return /* @__PURE__ */ jsxs(Fragment, { children: [
+			props.renderDefault(props),
+			inputRules?.length ? /* @__PURE__ */ jsx(MarkdownInputRules, {
+				arrayTypeName,
+				onInsert,
+				openOnInsert,
+				rules: inputRules
+			}) : null,
+			/* @__PURE__ */ jsx(BlockInsertPicker, {
+				arrayTypeName,
+				filter,
+				items,
+				labels,
+				onInsert,
+				openOnInsert,
+				presets,
+				resolveItems,
+				shortcut
+			})
+		] });
+	};
+}
+export { BLOCKQUOTE_PATTERN, BlockInsertPicker, CODE_FENCE_PATTERN, MarkdownInputRules, blockInsertPicker, blockquoteRule, codeFenceRule, derivePickerItems, fenceLanguageFromMatch, filterPickerItems, normalizeFenceLanguage, standardBlockPresets, wellKnownInputRules };
+
+//# sourceMappingURL=index.js.map