@sanity/block-insert-picker 0.0.1 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sanity.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,45 +1,152 @@
 # @sanity/block-insert-picker
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@sanity/block-insert-picker`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Slash-command block-insert picker and markdown input rules for Portable Text fields in Sanity Studio.
+
+Type `/` at the start of a line (or press `Cmd`/`Ctrl` + `/` anywhere) to open a caret-anchored menu of every object block the field's schema allows — searchable by title, trigger, and alias keywords, grouped into sections, keyboard-first. Selecting an item resolves the member type's initial value, inserts the block as a single undo step, and opens it for editing. Optional markdown input rules give the heaviest block types an even faster path, for example ` ```ts ` + space straight into a code block.
+
+## Installation
+
+```sh
+npm install @sanity/block-insert-picker
+```
+
+Requires `sanity` v5.6 or later.
+
+## Usage
+
+Attach the picker to a Portable Text array type via `components.portableText.plugins`. Zero config is the intended call — the picker detects the array it is mounted on and derives its items from that array's members, so it only ever offers blocks the field accepts:
+
+```ts
+import {blockInsertPicker} from '@sanity/block-insert-picker'
+import {defineType} from 'sanity'
+
+export const content = defineType({
+  name: 'content',
+  type: 'array',
+  of: [{type: 'block'}, {type: 'callout'}, {type: 'codeBlock'}],
+  components: {
+    portableText: {
+      plugins: blockInsertPicker(),
+    },
+  },
+})
+```
+
+Titles, icons, and descriptions come from each member's schema type (with the same fallbacks Studio's built-in insert menu uses), and detection handles aliased members (`{type: 'image', name: 'photo'}`) and inline-declared members with full fidelity.
+
+When an array derives zero items — its only member is the text block — and no `inputRules` are configured, the picker disables itself: no behaviors register and `/` inserts plain text (with a `console.warn` in dev builds). Items appended via `resolveItems` (or configured `inputRules`) re-enable it, so a custom-command-only picker on a text-only field works.
+
+### Curating items
+
+The optional `items` metadata curates the derived items — slash triggers, alias keywords, section grouping, badges, per-item visibility, and rank (array order). Entries match a member's name or any name in its resolved type chain, and a curated `description` wins over the schema type's:
+
+```ts
+blockInsertPicker({
+  items: [
+    {
+      type: 'codeBlock',
+      trigger: '/code',
+      keywords: ['snippet', 'syntax'],
+      group: 'Code',
+      description: 'Syntax-highlighted code sample',
+    },
+    {
+      type: 'callout',
+      trigger: '/callout',
+      keywords: ['note', 'warning', 'tip'],
+      group: 'Callouts',
+    },
+    {type: 'legacyEmbed', hidden: true},
+  ],
+})
+```
+
+Members without an entry still get picker items, appended in schema order. Entries whose `type` matches no member log a dev-mode warning.
+
+### Presets for well-known blocks
+
+Members whose type resolves to a well-known name — `image`, `file`, `code` (`@sanity/code-input`), `table`, `color`, `latex`, `mux.video`, `sanity.video` — get default triggers and search keywords out of the box. Presets never add items, never group, and always lose to your `items` metadata. Opt out with `presets: false`.
+
+### Markdown input rules
+
+`inputRules` adds typed transforms that replace markdown-style text with an inserted block — one undo step, and the block opens for editing just like a picker insert. Rules are opt-in; two factories cover the common cases:
+
+````ts
+import {blockInsertPicker, blockquoteRule, codeFenceRule} from '@sanity/block-insert-picker'
+
+blockInsertPicker({
+  inputRules: [
+    // "```lang" + space inserts a code block with the language resolved
+    codeFenceRule({
+      blockType: 'codeBlock',
+      defaultLanguage: 'typescript',
+      languages: [
+        {value: 'typescript', aliases: ['ts'], filename: 'index.ts'},
+        {value: 'javascript', aliases: ['js'], filename: 'index.js'},
+      ],
+      createValue: ({language, filename}) => ({
+        language,
+        ...(filename ? {filename} : {}),
+      }),
+    }),
+    // "> " at the start of a block inserts a quote/callout
+    blockquoteRule({
+      blockType: 'callout',
+      createValue: () => ({tone: 'info'}),
+    }),
+  ],
+})
+````
+
+`createValue` builds the inserted block's fields synchronously from the resolved fence language (and optional tab filename), shaped for **your** schema. Each rule's `blockType` resolves against the array's members by name or resolved type chain (aliased members included; the inserted `_type` is always the member name); rules matching nothing are ignored. For fully custom transforms, pass a `{pattern, blockType, buildValue}` config directly. A ready-made `wellKnownInputRules` bundle covers `@sanity/code-input`'s `code` type: `inputRules: [...wellKnownInputRules]`.
+
+### Reacting to inserts
+
+`onInsert` fires after every successful insert, from either path:
+
+```ts
+blockInsertPicker({
+  onInsert: ({blockKey, blockType, via, mode, query}) => {
+    // via is 'picker' or 'inputRule'; mode and query are picker-only
+  },
+})
+```
+
+### Escape hatches
+
+For anything the declarative options don't cover:
+
+- **`resolveItems`** — a function over the fully-presented item list: reorder, remove, relabel, or append items. Appended items can carry a `custom` action that runs your code instead of inserting a block:
+
+  ```ts
+  blockInsertPicker({
+    resolveItems: (items, {schemaType}) => [
+      ...items,
+      {
+        id: 'ai-draft',
+        title: 'Draft with AI',
+        action: {type: 'custom', onSelect: ({editor}) => startDraft(editor)},
+      },
+    ],
+  })
+  ```
+
+- **`filter`** — replaces the built-in matching (case-insensitive substring over title, keywords, and description, plus trigger prefixes). It receives the bare query in both modes; the slash-mode `/` prefix is stripped.
+- **`labels`** — overrides any user-facing string in the picker chrome (header, empty state, footer hints, error toast), for reworded or translated UI.
+- **`shortcut: false`** — disables the `Cmd`/`Ctrl` + `/` shortcut; `openOnInsert: false` — keeps inserted blocks closed (also available per item via metadata).
+- **`BlockInsertPicker` / `MarkdownInputRules`** — the underlying components, exported for hosts composing their own `components.portableText.plugins` chain, along with the pure `derivePickerItems` and `filterPickerItems` utilities.
+- **`arrayTypeName`** — names the array type explicitly, for environments where the member-schema context is unavailable. Normally unnecessary.
+
+## Keyboard reference
+
+| Key                | Action                                             |
+| ------------------ | -------------------------------------------------- |
+| `/` at line start  | Open the picker; keep typing to filter             |
+| `Cmd`/`Ctrl` + `/` | Open the picker anywhere; type to filter privately |
+| `↑` / `↓`          | Move the highlight                                 |
+| `Enter`            | Insert the highlighted block                       |
+| `Escape`           | Dismiss                                            |
+
+## License
+
+[MIT](LICENSE) © Sanity.io

package/dist/index.d.ts

@@ -0,0 +1,385 @@
+import { Editor } from "@portabletext/editor";
+import { ComponentType } from "react";
+import { ArraySchemaType, ObjectSchemaType, PortableTextPluginsProps } from "sanity";
+import "@portabletext/plugin-input-rule";
+/**
+ * Every user-facing string in the picker chrome, centralized so hosts can
+ * translate or reword them via the `labels` option (the same pattern
+ * `@sanity/insert-menu` uses for its label overrides). Item titles and
+ * descriptions are schema/metadata content, not chrome — localize those
+ * through `items` or `resolveItems` instead.
+ */
+type BlockInsertPickerLabels = {
+  /** Popover header; also the listbox aria-label. */
+  title: string;
+  /** Empty state; `{query}` is replaced with the typed filter text. */
+  noMatches: string;
+  /**
+   * Screen-reader position announcement for the highlighted row; `{index}`
+   * and `{count}` are replaced with the 1-based position and list length.
+   */
+  positionAnnouncement: string;
+  /**
+   * Section header for items without a `group`, shown only when grouped
+   * sections are also present.
+   */
+  ungroupedSection: string;
+  /** Footer legend verbs. */
+  footerNavigate: string;
+  footerInsert: string;
+  footerDismiss: string;
+  footerAnywhere: string;
+  /** Toast title when resolving a block's initial value fails. */
+  insertError: string;
+  /**
+   * Toast description when the block the picker was anchored to is deleted
+   * before the insert completes.
+   */
+  insertAnchorRemoved: string;
+};
+/**
+ * Emitted after a block lands in the document, whether via picker selection
+ * or a markdown input rule. The public seam for hosts that need to react to
+ * inserts (analytics, custom focus handling) without reaching into Studio
+ * internals the way the built-in open-on-insert does (see openBlockOnInsert).
+ */
+type PickerInsertEvent = {
+  blockKey: string;
+  blockType: string;
+  via: 'inputRule' | 'picker';
+  /** How the picker was opened; only present when `via` is `'picker'`. */
+  mode?: PickerMode;
+  /** The filter query at select time; only present when `via` is `'picker'`. */
+  query?: string;
+};
+type PickerItem = {
+  id: string;
+  trigger?: string;
+  title: string;
+  /**
+   * One-line explanation shown under the title. Curated metadata wins over
+   * the member schema type's own `description` — curation is the more
+   * specific intent (see resolveItemPresentation).
+   */
+  description?: string;
+  /**
+   * Category label used to partition the menu into sections. Items without a
+   * group render in a single unlabelled list (e.g. a curated `items` prop).
+   */
+  group?: string;
+  icon?: ComponentType;
+  keywords?: readonly string[];
+  /** Short keyboard-style hint rendered at the row's trailing edge. */
+  badge?: string;
+  /** Per-item override of the plugin-level `openOnInsert` default. */
+  openOnInsert?: boolean;
+  action: PickerItemAction;
+};
+/**
+ * What selecting an item does. An open union: further named actions (for
+ * example setting a text style) can be added without a breaking change.
+ * `custom` items never insert anything themselves — the host's `onSelect`
+ * runs with the editor after the picker closes and the typed query text
+ * (slash mode) has been cleaned up.
+ */
+type PickerItemAction = {
+  type: 'custom';
+  onSelect: (context: PickerActionContext) => void;
+} | {
+  type: 'insertBlock';
+  blockType: string;
+};
+/** Handed to a `custom` item's `onSelect` when the item is chosen. */
+interface PickerActionContext {
+  editor: Editor;
+  closePicker: () => void;
+}
+/**
+ * Host-supplied curation for schema-derived picker items, keyed by member
+ * type name (falling back to a name anywhere in the member's resolved type
+ * chain, so `{type: 'image', name: 'photo'}` matches both `photo` and
+ * `image` — the member name wins when both have entries): slash trigger,
+ * alias keywords, section grouping, badge, visibility, per-item
+ * open-on-insert, and description. Array position is the sort rank — members
+ * without an entry still get picker items, appended after the ranked ones in
+ * schema order.
+ */
+type PickerItemMetadata = {
+  type: string;
+  trigger?: string;
+  keywords?: readonly string[];
+  group?: string;
+  description?: string;
+  /** Short keyboard-style hint rendered at the row's trailing edge. */
+  badge?: string;
+  /** Removes the derived item from the picker without touching the schema. */
+  hidden?: boolean;
+  /** Per-item override of the plugin-level `openOnInsert` default. */
+  openOnInsert?: boolean;
+};
+/**
+ * The schema surroundings picker items derive from: the Portable Text array
+ * type itself and its insertable (non-text-block) member types. Sourced from
+ * Studio's member-schema context when available, or resolved from an
+ * explicit `arrayTypeName` otherwise (see memberSchemaTypes.ts).
+ */
+interface PickerItemsContext {
+  schemaType: ArraySchemaType;
+  memberTypes: readonly ObjectSchemaType[];
+}
+/**
+ * Programmatic escape hatch over the derived item list: reorder, remove,
+ * relabel, or append items (including `custom`-action items) after schema
+ * derivation, presets, and `items` metadata have been applied.
+ */
+type PickerItemsResolver = (items: readonly PickerItem[], context: PickerItemsContext) => readonly PickerItem[];
+type PickerMode = 'shortcut' | 'slash';
+type BlockInsertPickerProps = {
+  /**
+   * Per-member curation (trigger, keywords, group, description, badge,
+   * hidden, openOnInsert) merged into the items derived from the array's
+   * members; array order is the rank. Members without an entry still get
+   * items, in schema order.
+   */
+  items?: readonly PickerItemMetadata[];
+  /**
+   * Escape hatch: names the portable-text array type to resolve items from
+   * when Studio's member-schema context is unavailable. With the context
+   * present (any supported sanity version) this is ignored — the containing
+   * array and its members are detected automatically.
+   */
+  arrayTypeName?: string;
+  /**
+   * Programmatic seam over the derived-and-curated item list: reorder,
+   * remove, relabel, or append items (including `custom`-action items).
+   */
+  resolveItems?: PickerItemsResolver;
+  /**
+   * Replaces the built-in matching (see filterPickerItems). Receives the
+   * bare query in both modes — the slash-mode "/" prefix is stripped.
+   */
+  filter?: (items: readonly PickerItem[], query: string) => readonly PickerItem[];
+  /** Overrides for the picker chrome's user-facing strings. */
+  labels?: Partial<BlockInsertPickerLabels>;
+  /** Notified after each successful insert, alongside open-on-insert. */
+  onInsert?: (event: PickerInsertEvent) => void;
+  /**
+   * Whether an inserted block opens for editing (default true). Items can
+   * override per member via their metadata's `openOnInsert`.
+   */
+  openOnInsert?: boolean;
+  /** Whether Cmd/Ctrl+/ opens the picker (default true). */
+  shortcut?: boolean;
+  /**
+   * Whether well-known block types (image, file, code, table, ...) get
+   * default triggers and keywords when the host's `items` doesn't cover
+   * them (default true). See standardBlockPresets.
+   */
+  presets?: boolean;
+};
+declare function BlockInsertPicker({ arrayTypeName, filter, items, labels: labelOverrides, onInsert, openOnInsert, presets, resolveItems, shortcut }: BlockInsertPickerProps): import("react").JSX.Element | null;
+/**
+ * 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).
+ */
+declare function derivePickerItems(context: PickerItemsContext, metadata?: readonly PickerItemMetadata[]): PickerItem[];
+declare function filterPickerItems(items: readonly PickerItem[], query: string): readonly PickerItem[];
+/**
+ * Generic machinery for markdown-style input rules that replace typed text
+ * with an inserted object block, complementing the slash/⌘+/ picker with a
+ * keyboard-only path that mirrors what writers already type in markdown.
+ *
+ * The rules run through `@portabletext/plugin-input-rule` (see
+ * `markdownInputRules.tsx`), which applies the delete + insert as a single
+ * behavior action set — so each transform is one undo step.
+ *
+ * Block values are built synchronously via each config's `buildValue` rather
+ * than resolved from the schema's async initial values: the insert has to
+ * happen inside the rule's action set for that single-undo guarantee to hold,
+ * so anything the writer would otherwise have to fill in (language, filename,
+ * callout type) is seeded from the host's rule config.
+ */
+type KeyGenerator = () => string;
+/**
+ * One markdown input rule: when `pattern` matches the block text, the match
+ * is deleted and a block of `blockType` is inserted in its place, carrying
+ * the fields `buildValue` returns. `buildValue` must stay synchronous so the
+ * delete + insert land in one action set (one undo step).
+ */
+type MarkdownInputRuleConfig = {
+  pattern: RegExp;
+  blockType: string;
+  buildValue: (context: {
+    matchText: string;
+    keyGenerator: KeyGenerator;
+  }) => Record<string, unknown>;
+};
+declare const CODE_FENCE_PATTERN: RegExp;
+declare const BLOCKQUOTE_PATTERN: RegExp;
+/**
+ * A row of a code-fence language table: the stored `value`, the markdown
+ * fence tokens that should resolve to it, and an optional tab filename.
+ */
+type LanguageEntry = {
+  value: string;
+  aliases?: readonly string[];
+  filename?: string;
+};
+/** Sugar: a blockquote rule ("> " at the start of a block) for `blockType`. */
+declare function blockquoteRule(options: {
+  blockType: string;
+  createValue?: (context: {
+    keyGenerator: KeyGenerator;
+  }) => Record<string, unknown>;
+}): MarkdownInputRuleConfig;
+/**
+ * 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.
+ */
+declare function codeFenceRule(options: {
+  blockType: string;
+  languages?: readonly LanguageEntry[];
+  defaultLanguage?: string;
+  createValue: (context: {
+    filename: string | undefined;
+    keyGenerator: KeyGenerator;
+    language: string | undefined;
+  }) => Record<string, unknown>;
+}): MarkdownInputRuleConfig;
+/** Strips the leading "```" fence and surrounding whitespace from a match. */
+declare function fenceLanguageFromMatch(matchText: string): string;
+/**
+ * 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`.
+ */
+declare function normalizeFenceLanguage(raw: string, languages: readonly LanguageEntry[], defaultLanguage?: string): string | undefined;
+type MarkdownInputRulesProps = {
+  /**
+   * Escape hatch: names the portable-text array type when Studio's
+   * member-schema context is unavailable (see BlockInsertPickerProps).
+   * Rules are only enabled for block types the array actually allows.
+   */
+  arrayTypeName?: string;
+  /** The markdown transforms to enable (see inputRules.ts). */
+  rules: readonly MarkdownInputRuleConfig[];
+  /** Notified after each successful insert, alongside open-on-insert. */
+  onInsert?: (event: PickerInsertEvent) => void;
+  /** Whether an inserted block opens for editing (default true). */
+  openOnInsert?: boolean;
+};
+/**
+ * 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.
+ */
+declare function MarkdownInputRules({ arrayTypeName, onInsert, openOnInsert, rules }: MarkdownInputRulesProps): null;
+interface BlockInsertPickerConfig {
+  /**
+   * Per-member curation (slash trigger, alias keywords, section grouping,
+   * description, badge, visibility, per-item open-on-insert) merged into the
+   * items derived from the array's members; array order is the sort rank.
+   * Members without an entry still get picker items, appended in schema
+   * order. Entries whose `type` matches no member warn in dev mode.
+   */
+  items?: readonly PickerItemMetadata[];
+  /**
+   * Programmatic seam over the derived item list — reorder, remove, relabel,
+   * or append items (including `custom`-action items) — running after schema
+   * derivation, presets, and `items` metadata.
+   */
+  resolveItems?: PickerItemsResolver;
+  /**
+   * Markdown-style transforms (for example from the {@link codeFenceRule} and
+   * {@link blockquoteRule} factories) that replace typed text with an
+   * inserted block, as one undo step. Opt-in only; rules targeting block
+   * types the array does not allow are ignored.
+   */
+  inputRules?: readonly MarkdownInputRuleConfig[];
+  /**
+   * Replaces the built-in matching (case-insensitive substring over title,
+   * keywords, and description, plus trigger prefixes). Receives the bare
+   * query in both modes — the slash-mode "/" prefix is stripped.
+   */
+  filter?: (items: readonly PickerItem[], query: string) => readonly PickerItem[];
+  /** Overrides for the picker chrome's user-facing strings. */
+  labels?: Partial<BlockInsertPickerLabels>;
+  /**
+   * Notified after each successful insert — picker selection or input rule —
+   * alongside the built-in open-for-editing behavior.
+   */
+  onInsert?: (event: PickerInsertEvent) => void;
+  /**
+   * Whether an inserted block opens for editing (default true). Items can
+   * override per member via their metadata's `openOnInsert`.
+   */
+  openOnInsert?: boolean;
+  /** Whether Cmd/Ctrl+/ opens the picker (default true). */
+  shortcut?: boolean;
+  /**
+   * Whether well-known block types (image, file, code, table, ...) get
+   * default triggers and keywords when `items` doesn't cover them
+   * (default true). See {@link standardBlockPresets}.
+   */
+  presets?: boolean;
+  /**
+   * Escape hatch: names the portable-text array type to resolve items
+   * against when Studio's member-schema context is unavailable. Normally
+   * unnecessary — the containing array and its members are detected
+   * automatically from where the plugin is mounted.
+   */
+  arrayTypeName?: string;
+}
+/**
+ * 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(),
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function blockInsertPicker(config?: BlockInsertPickerConfig): ComponentType<PortableTextPluginsProps>;
+/**
+ * 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`.
+ */
+declare const standardBlockPresets: readonly PickerItemMetadata[];
+/**
+ * Opt-in input rules for well-known block types — spread into `inputRules`
+ * (`inputRules: [...wellKnownInputRules]`) rather than applied by default.
+ * Today: a code fence for `@sanity/code-input`'s `code` type that stores the
+ * typed fence token as the language. Like all rules, each resolves against
+ * the array's members by name or resolved type chain (so an aliased
+ * `{type: 'code', name: 'snippet'}` member still gets the fence, inserted
+ * with the member's `_type`) and is ignored when nothing matches.
+ */
+declare const wellKnownInputRules: readonly MarkdownInputRuleConfig[];
+export { BLOCKQUOTE_PATTERN, BlockInsertPicker, type BlockInsertPickerConfig, type BlockInsertPickerLabels, type BlockInsertPickerProps, CODE_FENCE_PATTERN, type KeyGenerator, type LanguageEntry, type MarkdownInputRuleConfig, MarkdownInputRules, type MarkdownInputRulesProps, type PickerActionContext, type PickerInsertEvent, type PickerItem, type PickerItemAction, type PickerItemMetadata, type PickerItemsContext, type PickerItemsResolver, type PickerMode, blockInsertPicker, blockquoteRule, codeFenceRule, derivePickerItems, fenceLanguageFromMatch, filterPickerItems, normalizeFenceLanguage, standardBlockPresets, wellKnownInputRules };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/labels.ts","../src/types.ts","../src/blockInsertPicker.tsx","../src/deriveItems.ts","../src/filterItems.ts","../src/inputRules.ts","../src/markdownInputRules.tsx","../src/plugin.tsx","../src/presets.ts"],"mappings":";;;;;;;;;;;KAOY;;EAEV;;EAEA;;;;;EAKA;;;;;EAKA;;EAEA;EACA;EACA;EACA;;EAEA;;;;;EAKA;;;;;;;;KCvBU;EACV;EACA;EACA;;EAEA,OAAO;;EAEP;;KAWU;EACV;EACA;EACA;;;;;;EAMA;;;;;EAKA;EACA,OAAO;EACP;;EAEA;;EAEA;EACA,QAAQ;;;;;;;;;KAUE;EACP;EAAgB,WAAW,SAAS;;EACpC;EAAqB;;;UAGT;EACf,QAAQ;EACR;;;;;;;;;;;;KAaU;EACV;EACA;EACA;EACA;EACA;;EAEA;;EAEA;;EAEA;;;;;;;;UASe;EACf,YAAY;EACZ,sBAAsB;;;;;;;KAQZ,uBACV,gBAAgB,cAChB,SAAS,gCACG;KAEF;KChFA;;;;;;;EAOV,iBAAiB;;;;;;;EAOjB;;;;;EAKA,eAAe;;;;;EAKf,UAAU,gBAAgB,cAAc,2BAA2B;;EAEnE,SAAS,QAAQ;;EAEjB,YAAY,OAAO;;;;;EAKnB;;EAEA;;;;;;EAMA;;iBAGc,oBACd,eACA,QACA,OACA,QAAQ,gBACR,UACA,cACA,SACA,cACA,YACC,yCAAsB,IAAA;;;;;;;;;;;iBCrDT,kBACd,SAAS,oBACT,oBAAmB,uBAClB;iBCpCa,kBACd,gBAAgB,cAChB,yBACU;;;;;;;;;;;;;;;;KCeA;;;;;;;KAQA;EACV,SAAS;EACT;EACA,aAAa;IAAU;IAAmB,cAAc;QAAkB;;cAgC/D,oBAAkB;cAClB,oBAAkB;;;;;KAMnB;EACV;EACA;EACA;;;iBAIc,eAAe;EAC7B;EACA,eAAe;IAAU,cAAc;QAAkB;IACvD;;;;;;;;iBAeY,cAAc;EAC5B;EACA,qBAAqB;EACrB;EACA,cAAc;IACZ;IACA,cAAc;IACd;QACI;IACJ;;iBAoBY,uBAAuB;;;;;;iBASvB,uBACd,aACA,oBAAoB,iBACpB;KC9HU;;;;;;EAMV;;EAEA,gBAAgB;;EAEhB,YAAY,OAAO;;EAEnB;;;;;;;iBAQc,qBACd,eACA,UACA,cACA,SACC;UC1Bc;;;;;;;;EAQf,iBAAiB;;;;;;EAMjB,eAAe;;;;;;;EAOf,sBAAsB;;;;;;EAMtB,UAAU,gBAAgB,cAAc,2BAA2B;;EAEnE,SAAS,QAAQ;;;;;EAKjB,YAAY,OAAO;;;;;EAKnB;;EAEA;;;;;;EAMA;;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;iBAuBc,kBACd,SAAQ,0BACP,cAAc;;;;;;;;;;;cC1EJ,+BAA+B;;;;;;;;;;cAoB/B,8BAA8B"}