@driftime/sanity-plugin-handbook 0.4.0 → 0.4.1

package/README.md

@@ -17,9 +17,11 @@
 
 ## Overview
 
-Every content model comes with knowledge the schema alone cannot hold: what a field is for, which values work best, and how the team writes. Handbook gives that knowledge a place in the Studio, as a tool in the navigation, so an author reaches the guidance beside the content it describes.
+Every content model comes with knowledge the schema alone can't hold: what a field is for, which values work best, and how the site's content should be written. Handbook gives that knowledge a place in the Studio, so authors find the guidance right beside the content it describes.
 
-The first part of the Handbook is generated from the schema. Every document type is listed with its fields, and each field shows its type, its description, an example value, and any tips or cautions written alongside its definition, so the documentation stays in step with the editor it describes. The second part is written by the team. Guides are Portable Text documents for house style, editorial process, and anything too long for a field description, arranged into groups in the same sidebar.
+Most of it needs no writing at all. Handbook reads the documentation straight from the schema, listing every document type and every field with its description, an example value, and any tips or cautions defined alongside it. When the schema changes, the Handbook changes with it.
+
+The rest is written by the site's editors. Guides cover house style, editorial process, and anything too long for a field description, arranged into groups in the same sidebar.
 
 <br />
 
@@ -36,7 +38,7 @@ The first part of the Handbook is generated from the schema. Every document type
 
 ## Installation
 
-Handbook is built for Sanity Studio 6.10 and React 19 and declares both as peer dependencies, so the Studio needs to be on those versions already. Node 22.12 or later is required.
+Handbook is built for Sanity Studio 6.10 and React 19 and declares both as peer dependencies, so the Studio needs to be on those versions already. Node 20.19 or later is required, or 22.12 or later on Node 22.
 
 ```bash
 bun add -E @driftime/sanity-plugin-handbook
@@ -127,7 +129,7 @@ export const page = defineType({
   description: "General-purpose pages.",
   handbook: {
     description:
-      "Standalone pages for anything that does not warrant a document type of its own. Each is reached at its own address and assembled from blocks rather than following a fixed layout.",
+      "Standalone pages for any content that doesn't need a document type of its own. Each page has its own address and is built from blocks rather than following a fixed layout.",
   },
   fields: [
     defineField({
@@ -136,9 +138,9 @@ export const page = defineType({
       description: "Appears in navigation, browser tabs, and search results.",
       handbook: {
         description:
-          "The name this document goes by wherever it is referred to rather than read — navigation menus, browser tabs, search results, and the Studio's own lists. Every document needs one, and it stands behind both the slug and the SEO title whenever those are left blank.",
+          "What the document is called wherever it's listed: navigation menus, browser tabs, search results, and the Studio's own lists. Every document needs one, and it's also used to generate the slug and as the SEO title when those fields are left empty.",
         example: "About Acme Inc.",
-        tip: "Keep it short enough to sit comfortably in a navigation menu.",
+        tip: "Keep it short enough to fit in a navigation menu without wrapping.",
       },
     }),
     defineField({
@@ -148,7 +150,7 @@ export const page = defineType({
       options: { source: "title" },
       handbook: {
         description:
-          "The last part of the page's web address. Generate it from the title and then edit it if the result reads awkwardly — shorter is almost always better.",
+          "The last part of the page's web address. Generate it from the title, then edit it if the result is long or unclear. Shorter slugs are usually better.",
         example: "about-acme-inc",
         caution: "Changing the slug of a published page breaks every link that already points at it.",
       },
@@ -161,7 +163,7 @@ export const page = defineType({
 | ------------- | -------- | --------------------------------------------------------------------------- |
 | `title`       | `string` | Replaces the field or document title in the Handbook.                       |
 | `description` | `string` | Replaces the description, shown under the heading.                          |
-| `example`     | `string` | An example value, shown in italics beneath the description.                 |
+| `example`     | `string` | An example value, shown in italics below the description.                   |
 | `tip`         | `string` | Guidance for the author, shown as a hint icon that opens on hover or click. |
 | `info`        | `string` | Extra context about how the field is used, shown the same way.              |
 | `caution`     | `string` | A warning about constraints or pitfalls, shown the same way.                |
@@ -192,7 +194,7 @@ handbookPlugin({
 
 ### Nested Fields
 
-An object or array field has a control beneath its description that counts its subfields and expands to list them, each documented the way a top-level field is. An array with one member type lists that type's fields, and an array with several lists the members themselves. Sanity's own types, such as `image`, `file`, and `slug`, are not expanded, so a custom type built on one of them shows only the fields added to it. A type that contains itself is listed once, with a note referring back to the first occurrence in place of a second expansion.
+An object or array field has a control below its description that counts its subfields and expands to list them, each documented the way a top-level field is. An array with one member type lists that type's fields, and an array with several lists the members themselves. Sanity's own types, such as `image`, `file`, and `slug`, are not expanded, so a custom type built on one of them shows only the fields added to it. A type that contains itself is listed once, with a note referring back to the first occurrence in place of a second expansion.
 
 <br />
 
@@ -241,7 +243,7 @@ A guide has a title, an optional description, and a Portable Text body offering:
 
 ### Adding Guides to the Structure
 
-Guides are read in the Handbook tool and written in the Structure tool, and they appear in the Structure tool only once its resolver adds them. `handbookStructure` returns the two list items for that, an editor for the singleton and a list of the guides. It reads the current user from the Structure context, and returns an empty array for anyone who is not an editor, so the resolver needs both of its arguments.
+Guides are read in the Handbook tool and written in the Structure tool, and they appear in the Structure tool only once its resolver adds them. `handbookStructure` returns the two list items for that, an editor for the singleton and a list of the guides in the order they were created. It reads the current user from the Structure context, and returns an empty array for anyone who is not an editor, so the resolver needs both of its arguments.
 
 ```typescript
 import { handbookStructure } from "@driftime/sanity-plugin-handbook";
@@ -263,7 +265,7 @@ export const structure: StructureResolver = (structureBuilder, context) => {
 };
 ```
 
-The filter keeps the two Handbook document types out of a list built from every registered type, and the divider is added only when there is something to put beneath it. A Studio running several workspaces with different editors passes the workspace's own list as a third argument, since the plugin otherwise reads the list from whichever workspace was configured last.
+The filter keeps the two Handbook document types out of a list built from every registered type, and the divider is added only when there is something to show below it. A Studio running several workspaces with different editors passes the workspace's own list as a third argument, since the plugin otherwise reads the list from whichever workspace was configured last.
 
 <br />
 
@@ -271,7 +273,7 @@ The filter keeps the two Handbook document types out of a list built from every
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-groups-dark.png" />
     <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-groups-light.png" />
-    <img src="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-groups-light.png" alt="The Handbook singleton open in the Structure tool, showing two guide groups with reorder handles and the guides referenced in each" />
+    <img src="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-groups-light.png" alt="The Handbook singleton open in the Structure tool, showing three guide groups with reorder handles and the guides referenced in each" />
   </picture>
   <p align="center"><sub><em>The Handbook singleton in the Structure tool, where groups and their order are arranged.</em></sub></p>
 </figure>
@@ -282,7 +284,7 @@ The filter keeps the two Handbook document types out of a list built from every
   <picture>
     <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-editor-dark.png" />
     <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-editor-light.png" />
-    <img src="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-editor-light.png" alt="The Handbook Guides list in the Structure tool beside an open guide, showing its title, description, and rich text editor" />
+    <img src="https://raw.githubusercontent.com/driftime/sanity-plugins/HEAD/packages/handbook/assets/handbook-editor-light.png" alt="The Handbook Guides list in the Structure tool beside an open guide, showing its rich text editor and toolbar" />
   </picture>
   <p align="center"><sub><em>The guides list in the Structure tool beside an open guide.</em></sub></p>
 </figure>
@@ -423,7 +425,7 @@ interface GuidePageProps {
 | `_type`       | `string`                     | both                | `handbook.handbook` for the singleton, `handbook.guide` for a guide. |
 | `groups`      | `SanityHandbookGuideGroup[]` | `handbook.handbook` | The groups in sidebar order, each with a `title` and its `guides`.   |
 | `title`       | `string`                     | `handbook.guide`    | The guide's title, shown in the sidebar and as its heading.          |
-| `description` | `string`                     | `handbook.guide`    | An optional introduction shown beneath the heading.                  |
+| `description` | `string`                     | `handbook.guide`    | An optional introduction shown below the heading.                    |
 | `content`     | `PortableTextBlock[]`        | `handbook.guide`    | The body, holding text blocks and the blocks below.                  |
 
 The blocks a body can hold each have a type of their own, and the link annotation is stored in a text block's `markDefs`. A horizontal rule, `handbook.horizontalRule`, carries no fields.
@@ -431,10 +433,10 @@ The blocks a body can hold each have a type of their own, and the link annotatio
 | Field      | Type                           | Block              | Purpose                                                                      |
 | ---------- | ------------------------------ | ------------------ | ---------------------------------------------------------------------------- |
 | `asset`    | `{ url?: string }`             | `handbook.image`   | The image, once the query resolves its reference to a URL.                   |
-| `caption`  | `string`                       | `handbook.image`   | An optional caption shown beneath the image.                                 |
+| `caption`  | `string`                       | `handbook.image`   | An optional caption shown below the image.                                   |
 | `alt`      | `string`                       | `handbook.image`   | Optional alternative text for the image.                                     |
 | `asset`    | `{ url?: string }`             | `handbook.video`   | The video, once the query resolves its reference to a URL.                   |
-| `caption`  | `string`                       | `handbook.video`   | An optional caption shown beneath the video.                                 |
+| `caption`  | `string`                       | `handbook.video`   | An optional caption shown below the video.                                   |
 | `code`     | `string`                       | `handbook.code`    | The source code.                                                             |
 | `language` | `string`                       | `handbook.code`    | The language it is highlighted as.                                           |
 | `variant`  | `SanityHandbookCalloutVariant` | `handbook.callout` | `tip`, `info`, or `warning`.                                                 |

package/dist/index.d.ts

@@ -3,237 +3,230 @@ import { CurrentUser, DocumentDefinition, KeyedSegment, PortableTextBlock, Porta
 import { StructureBuilder } from "sanity/structure";
 declare module "@sanity/types" {
   interface FieldDefinitionBase {
+    /** Handbook documentation for the field. */
     handbook?: SanityHandbookMetadata;
   }
   interface DocumentDefinition {
+    /** Handbook documentation for the document type. */
     handbook?: SanityHandbookMetadata;
   }
 }
 /**
- * Documentation a schema author attaches to a field or document, shown wherever the Handbook renders it.
+ * Documentation added to a field or document definition, shown in the Handbook.
  *
  * @public
  */
 interface SanityHandbookMetadata {
-  /** Display title override for the field or document. */
+  /** Title to show instead of the schema title. */
   title?: string;
-  /** Description shown beneath the field or document heading. */
+  /** Description shown below the field or document heading. */
   description?: string;
-  /** Illustrative example value for the field. */
+  /** Example value for the field. */
   example?: string;
-  /** Helpful tip displayed as a popover hint. */
+  /** Tip, shown as a hint icon. */
   tip?: string;
-  /** Informational note displayed as a popover hint. */
+  /** Extra information, shown as a hint icon. */
   info?: string;
-  /** Warning displayed as a popover hint. */
+  /** Warning, shown as a hint icon. */
   caution?: string;
 }
 /**
- * A named part a set of document types plays in the content model, shown as one sidebar section.
+ * A group of document types with the same role in the content model, shown as one sidebar section.
  *
  * @public
  */
 interface SanityHandbookDocumentRole {
-  /** Display title for the document role. */
+  /** Role title. */
   title: string;
-  /** Brief description of the role's purpose. */
+  /** Short description of the role. */
   description?: string;
-  /** Document definitions filling this role. */
+  /** Document definitions in the role. */
   documents: DocumentDefinition[];
 }
 /**
- * A Portable Text block a consumer adds to guide content, pairing its schema with how it renders.
+ * A custom Portable Text block for guides: its schema and the component that renders it.
  *
  * @public
  */
 interface SanityHandbookBlockDefinition {
-  /** Sanity schema type definition for the custom block. */
+  /** Schema type definition for the block. */
   schema: SchemaTypeDefinition;
-  /** React component for rendering the block in the Handbook viewer. */
+  /** Component that renders the block in the Handbook. */
   component: ComponentType<{
     value: PortableTextObject;
   }>;
 }
 /**
- * Everything the plugin accepts, of which only the document roles are required.
+ * Plugin configuration. Only `roles` is required.
  *
  * @public
  */
 interface SanityHandbookConfig {
-  /** Title shown in the Studio tool navigation. `"Handbook"` when omitted. */
+  /** Title in the Studio's tool menu. Defaults to `"Handbook"`. */
   title?: string;
-  /** Heading displayed at the top of the sidebar. `"Handbook"` when omitted. */
+  /** Heading at the top of the sidebar. Defaults to `"Handbook"`. */
   sidebarTitle?: string;
-  /** Document roles, each shown as a labelled section in the sidebar. */
+  /** Document roles, each shown as a section in the sidebar. */
   roles: SanityHandbookDocumentRole[];
-  /** Custom Portable Text block definitions for guide content. None when omitted. */
+  /** Custom Portable Text blocks for guides. Defaults to none. */
   blocks?: SanityHandbookBlockDefinition[];
-  /** Email addresses permitted to edit Handbook documents. Everyone when omitted. */
+  /** Email addresses of the people who can edit Handbook documents. Defaults to everyone. */
   editors?: string[];
-  /** Fallback message shown when a field has no description. A prompt to ask the development team when omitted. */
+  /** Message shown for fields without a description. Defaults to a prompt to ask the development team. */
   undocumentedFieldMessage?: string;
 }
 /**
- * Creates a Handbook tool for Sanity Studio, generating documentation from document type schemas
- * alongside the Portable Text guides authored in the dataset.
+ * Adds a Handbook tool to Sanity Studio, with documentation generated from the schema and guides written
+ * in the Studio.
  *
- * @param config - Plugin configuration.
- * @returns Sanity plugin definition.
+ * @param config - The plugin configuration.
+ * @returns The plugin.
  * @public
  */
 export declare const handbookPlugin: import("sanity").Plugin<SanityHandbookConfig>;
 /**
- * Creates the Structure tool items for Handbook documents, yielding nothing when the current user is
- * not permitted to edit them.
+ * Creates Structure tool items for the Handbook documents, or none when the current user can't edit them.
  *
- * @param structureBuilder - The Sanity Structure builder instance.
- * @param context - The Structure context carrying the current user.
- * @param editors - Email addresses permitted to edit, defaulting to the configured list.
- * @returns The list items for the Handbook singleton and the guides list.
+ * @param structureBuilder - The structure builder.
+ * @param context - The structure context, with the current user.
+ * @param editors - Email addresses of the editors, defaulting to the configured list.
+ * @returns List items for the Handbook document and the guides list, oldest guide first.
  * @public
  */
 export declare function handbookStructure(structureBuilder: StructureBuilder, context: {
   currentUser: CurrentUser | null;
 }, editors?: string[]): import("sanity/structure").ListItemBuilder[];
 /**
- * Checks whether the current user is permitted to edit Handbook content, treating an absent list as
- * unrestricted access.
+ * Checks whether the current user can edit Handbook documents. Without an editors list, everyone can.
  *
- * @param editors - Email addresses permitted to edit, defaulting to the configured list.
+ * @param editors - Email addresses of the editors, defaulting to the configured list.
  * @returns Whether the current user can edit Handbook documents.
  * @public
  */
 export declare function useIsHandbookEditor(editors?: string[]): boolean;
-/**
- * Drops a type's catch-all index signature, so a mistyped field name is an error rather than an
- * unknown value.
- *
- */
+/** Removes a type's index signatures, so a misspelt property is an error rather than `unknown`. */
 type Strict<T> = { [K in keyof T as string extends K ? never : number extends K ? never : K]: T[K]; };
-/**
- * Array of objects each carrying the key Sanity assigns to array items, keeping members identifiable.
- *
- */
+/** Array whose items carry the `_key` Sanity gives array members. */
 type SanityKeyedArray<T> = (KeyedSegment & T)[];
 /**
- * A single Handbook page, authored as rich text and rendered in the tool.
+ * A Handbook guide, written in rich text and shown in the tool.
  *
  * @public
  */
 type SanityHandbookGuide = Strict<SanityDocument> & {
   _type: typeof guideTypeName;
-  /** Display title for this guide. */
+  /** Guide title. */
   title: string;
-  /** Brief description shown beneath the guide heading. */
+  /** Short description below the guide heading. */
   description?: string;
-  /** Portable Text content of the guide. */
+  /** Portable Text content. */
   content: SanityKeyedArray<PortableTextBlock>;
 };
-/** Document type name of an individual guide. */
+/** Schema type name of the guide document. */
 declare const guideTypeName = "handbook.guide";
 /**
- * A titled run of guides in the sidebar, holding them in the order they appear.
+ * A group of guides in the sidebar, in order.
  *
  * @public
  */
 interface SanityHandbookGuideGroup {
-  /** Display title for this group in the sidebar. */
+  /** Group title in the sidebar. */
   title: string;
-  /** Ordered array of guide references. */
+  /** Guides in the group, in order. */
   guides: SanityKeyedArray<SanityHandbookGuide>;
 }
 /**
- * The singleton naming every guide group and the order the sidebar lists them in.
+ * The Handbook document, listing the guide groups in sidebar order.
  *
  * @public
  */
 type SanityHandbook = Strict<SanityDocument> & {
   _type: typeof handbookTypeName;
-  /** Ordered array of groups, each containing a title and guide references. */
+  /** Guide groups, in order. */
   groups: SanityKeyedArray<SanityHandbookGuideGroup>;
 };
-/** Document type name of the Handbook singleton. */
+/** Schema type name of the Handbook document. */
 declare const handbookTypeName = "handbook.handbook";
 /**
- * An image placed in a guide, with the caption and alternative text shown alongside it.
+ * An image in a guide, with its caption and alternative text.
  *
  * @public
  */
 type SanityHandbookImage = Strict<PortableTextObject> & {
   _type: typeof imageTypeName;
-  /** Uploaded image asset, narrowed by the query to the URL the viewer renders. */
+  /** Image asset, reduced by the query to its URL. */
   asset?: {
     url?: string;
   };
-  /** Text displayed beneath the image. */
+  /** Text shown below the image. */
   caption?: string;
-  /** Alternative text for screen readers. */
+  /** Alternative text. */
   alt?: string;
 };
-/** Type name of the image block. */
+/** Schema type name of the image block. */
 declare const imageTypeName = "handbook.image";
 /**
- * A video placed in a guide, with the caption shown beneath it.
+ * A video in a guide, with its caption.
  *
  * @public
  */
 type SanityHandbookVideo = Strict<PortableTextObject> & {
   _type: typeof videoTypeName;
-  /** Uploaded video asset, narrowed by the query to the URL the viewer renders. */
+  /** Video asset, reduced by the query to its URL. */
   asset?: {
     url?: string;
   };
-  /** Text displayed beneath the video. */
+  /** Text shown below the video. */
   caption?: string;
 };
-/** Type name of the video block. */
+/** Schema type name of the video block. */
 declare const videoTypeName = "handbook.video";
 /**
- * A block of source code, rendered with syntax highlighting for its language.
+ * A code block, highlighted for its language.
  *
  * @public
  */
 type SanityHandbookCode = Strict<PortableTextObject> & {
   _type: typeof codeTypeName;
-  /** Source code to display. */
+  /** Code to display. */
   code?: string;
-  /** Programming language used for syntax highlighting. */
+  /** Language used for syntax highlighting. */
   language?: string;
 };
-/** Type name of the code block. */
+/** Schema type name of the code block. */
 declare const codeTypeName = "handbook.code";
 /**
- * The intent a callout is drawn with, choosing its icon and tone.
+ * Kind of callout, which sets its icon and tone.
  *
  * @public
  */
 type SanityHandbookCalloutVariant = "tip" | "info" | "warning";
 /**
- * A highlighted message set apart from the surrounding guide text.
+ * A highlighted message in a guide.
  *
  * @public
  */
 type SanityHandbookCallout = Strict<PortableTextObject> & {
   _type: typeof calloutTypeName;
-  /** Visual style and intent of the callout. */
+  /** Kind of callout. */
   variant: SanityHandbookCalloutVariant;
-  /** Portable Text content displayed inside the callout, which offers no inline objects. */
+  /** Portable Text inside the callout, without inline objects. */
   body: SanityKeyedArray<PortableTextTextBlock<PortableTextSpan>>;
 };
-/** Type name of the callout block. */
+/** Schema type name of the callout block. */
 declare const calloutTypeName = "handbook.callout";
 /**
- * A divider between sections of a guide, carrying no authored content of its own.
+ * A divider between sections of a guide.
  *
  * @public
  */
 type SanityHandbookHorizontalRule = Strict<PortableTextObject> & {
   _type: typeof horizontalRuleTypeName;
 };
-/** Type name of the horizontal rule block. */
+/** Schema type name of the horizontal rule block. */
 declare const horizontalRuleTypeName = "handbook.horizontalRule";
 /**
- * A web address applied to a run of guide text.
+ * A link on a run of guide text.
  *
  * @public
  */

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/plugin.ts","../src/lib/structure.ts","../src/hooks/use-is-handbook-editor.ts","../src/types.ts"],"mappings":";;;;YAoBY;IACR,WAAW;;YAIH;IACR,WAAW;;;;;;;;UASE;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;UAQe;;EAEf;;EAEA;;EAEA,WAAW;;;;;;;UAQI;;EAEf,QAAQ;;EAER,WAAW;IAAgB,OAAO;;;;;;;;UAQnB;;EAEf;;EAEA;;EAEA,OAAO;;EAEP,SAAS;;EAET;;EAEA;;;;;;;;;;qBAWW,iCAAc,OAAA;;;;;;;;;;;wBCrFX,kBACd,kBAAkB,kBAClB;EAAW,aAAa;GACxB,gDAAkB;;;;;;;;;wBCVJ,oBAAoB;;;;;;KCExB,OAAO,QAAQ,WAAW,oBAAoB,2BAA2B,YAAY,IAAI,EAAE;;;;;KAM3F,iBAAiB,MAAM,eAAe;;;;;;KAOtC,sBAAsB,OAAO;EACvC,cAAc;;EAEd;;EAEA;;EAEA,SAAS,iBAAiB;;;cAIf;;;;;;UAOI;;EAEf;;EAEA,QAAQ,iBAAiB;;;;;;;KAQf,iBAAiB,OAAO;EAClC,cAAc;;EAEd,QAAQ,iBAAiB;;;cAId;;;;;;KAOD,sBAAsB,OAAO;EACvC,cAAc;;EAEd;IAAU;;;EAEV;;EAEA;;;cAIW;;;;;;KAOD,sBAAsB,OAAO;EACvC,cAAc;;EAEd;IAAU;;;EAEV;;;cAIW;;;;;;KAOD,qBAAqB,OAAO;EACtC,cAAc;;EAEd;;EAEA;;;cAIW;;;;;;KAOD;;;;;;KAOA,wBAAwB,OAAO;EACzC,cAAc;;EAEd,SAAS;;EAET,MAAM,iBAAiB,sBAAsB;;;cAIlC;;;;;;KAOD,+BAA+B,OAAO;EAChD,cAAc;;;cAIH;;;;;;KAOD,qBAAqB,OAAO;EACtC;;EAEA"}
+{"version":3,"file":"index.d.ts","names":["ComponentType","DocumentDefinition","PortableTextObject","SchemaTypeDefinition","_0","SanityHandbookMetadata","sideEffect","SanityHandbookDocumentRole","SanityHandbookBlockDefinition","SanityHandbookConfig","handbookPlugin","CurrentUser","StructureBuilder","handbookStructure","useIsHandbookEditor","KeyedSegment","PortableTextBlock","PortableTextObject","PortableTextSpan","PortableTextTextBlock","SanityDocument","Strict","T","K","SanityKeyedArray","SanityHandbookGuide","guideTypeName","SanityHandbookGuideGroup","SanityHandbook","handbookTypeName","SanityHandbookImage","imageTypeName","SanityHandbookVideo","videoTypeName","SanityHandbookCode","codeTypeName","SanityHandbookCalloutVariant","SanityHandbookCallout","calloutTypeName","SanityHandbookHorizontalRule","horizontalRuleTypeName","SanityHandbookLink"],"sources":["../src/plugin.ts","../src/lib/structure.ts","../src/hooks/use-is-handbook-editor.ts","../src/types.ts"],"mappings":";;;;YAoBY;;IAER,WAAWK;;YAIH;;IAER,WAAWA;;;;;;;;UASEA;;EAEf;;EAEA;;EAEA;;EAEA;;EAEA;;EAEA;;;;;;;UAQeE;;EAEf;;EAEA;;EAEA,WAAWN;;;;;;;UAQIO;;EAEf,QAAQL;;EAER,WAAWH;IAAgB,OAAOE;;;;;;;;UAQnBO;;EAEf;;EAEA;;EAEA,OAAOF;;EAEP,SAASC;;EAET;;EAEA;;;;;;;;;;qBAWWE,iCAAc,OAAAD;;;;;;;;;;wBCxFXI,kBACd,kBAAkBD,kBAClB;EAAW,aAAaD;GACxB,gDAAkB;;;;;;;;wBCVJG,oBAAoB;;KCDxBO,OAAO,QAAQ,WAAWC,oBAAoBC,2BAA2BA,YAAYA,IAAID,EAAEC;;KAG3FC,iBAAiB,MAAMT,eAAeO;;;;;;KAOtCG,sBAAsBJ,OAAOD;EACvC,cAAcM;;EAEd;;EAEA;;EAEA,SAASF,iBAAiBR;;;cAIfU;;;;;;UAOIC;;EAEf;;EAEA,QAAQH,iBAAiBC;;;;;;;KAQfG,iBAAiBP,OAAOD;EAClC,cAAcS;;EAEd,QAAQL,iBAAiBG;;;cAIdE;;;;;;KAODC,sBAAsBT,OAAOJ;EACvC,cAAcc;;EAEd;IAAU;;;EAEV;;EAEA;;;cAIWA;;;;;;KAODC,sBAAsBX,OAAOJ;EACvC,cAAcgB;;EAEd;IAAU;;;EAEV;;;cAIWA;;;;;;KAODC,qBAAqBb,OAAOJ;EACtC,cAAckB;;EAEd;;EAEA;;;cAIWA;;;;;;KAODC;;;;;;KAOAC,wBAAwBhB,OAAOJ;EACzC,cAAcqB;;EAEd,SAASF;;EAET,MAAMZ,iBAAiBL,sBAAsBD;;;cAIlCoB;;;;;;KAODC,+BAA+BlB,OAAOJ;EAChD,cAAcuB;;;cAIHA;;;;;;KAODC,qBAAqBpB,OAAOJ;EACtC;;EAEA"}