@sanity/hierarchical-document-list 2.1.2 → 3.0.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Sanity.io
+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

package/README.md

@@ -1,7 +1,5 @@
 # sanity-plugin-hierarchical-document-list
 
-> This is a **Sanity Studio v3** plugin.
-
 Plugin for visually organizing documents as hierarchies in the [Sanity studio](https://www.sanity.io/docs/sanity-studio). Applications include:
 
 - Tables of content - such as a book's sections and chapters
@@ -14,10 +12,8 @@ Plugin for visually organizing documents as hierarchies in the [Sanity studio](h
 
 If you're looking for a way to order documents on a flat list, refer to [@sanity/orderable-document-list](https://github.com/sanity-io/orderable-document-list).
 
-
 ## Installation
 
-
 ```bash
 # From the root of your sanity project
 npm i @sanity/hierarchical-document-list
@@ -31,17 +27,16 @@ npm i @sanity/hierarchical-document-list
 // sanity.config.js
 import {defineConfig} from 'sanity'
 import {hierarchicalDocumentList, hierarchyTree} from '@sanity/hierarchical-document-list'
- 
+
 export default defineConfig({
-   // ...
-   plugins: [hierarchicalDocumentList()],
-   schema: {
+  // ...
+  plugins: [hierarchicalDocumentList()],
+  schema: {
     types: [
       //...,
-      hierarchyTree
-    ]
-   }
-
+      hierarchyTree,
+    ],
+  },
 })
 ```
 
@@ -53,14 +48,19 @@ export default defineConfig({
 // sanity.config.ts
 import {defineConfig} from 'sanity'
 import {deskTool} from 'sanity/desk'
-import {createDeskHierarchy, hierarchicalDocumentList, hierarchyTree} from '@sanity/hierarchical-document-list'
+import {
+  createDeskHierarchy,
+  hierarchicalDocumentList,
+  hierarchyTree,
+} from '@sanity/hierarchical-document-list'
 
 export default defineConfig({
   // ...
   plugins: [
     deskTool({
       // NOTE: I'n V3 you MUST pass S and Context along to createDeskHierarchy as props
-      structure: (S, context) =>  S.list()
+      structure: (S, context) =>
+        S.list()
           .title('Content')
           .items([
             ...S.documentTypeListItems(), // or whatever other structure you have
@@ -83,26 +83,26 @@ export default defineConfig({
               referenceOptions: {
                 filter: 'status in $acceptedStatuses',
                 filterParams: {
-                  acceptedStatuses: ['published', 'approved']
-                }
+                  acceptedStatuses: ['published', 'approved'],
+                },
               },
 
               // ❓ Optional: limit the depth of your hierarachies
               maxDepth: 3,
 
               // ❓ Optional: subarray of referenceTo, when it should not be possible to create new types from all referenceTo types
-              creatableTypes: ['site.page']
-            })
-          ])
+              creatableTypes: ['site.page'],
+            }),
+          ]),
     }),
-    hierarchicalDocumentList()
+    hierarchicalDocumentList(),
   ],
   schema: {
     types: [
       //...,
-      hierarchyTree
-    ]
-  }
+      hierarchyTree,
+    ],
+  },
 })
 ```
 
@@ -287,12 +287,12 @@ export const hierarchicalOptions = {
   referenceOptions: {
     filter: 'status in $acceptedStatuses',
     filterParams: {
-      acceptedStatuses: ['published', 'approved']
-    }
+      acceptedStatuses: ['published', 'approved'],
+    },
   },
 
   // ❓ Optional: limit the depth of your hierarachies
-  maxDept: 3
+  maxDept: 3,
 }
 
 export default createHierarchicalSchemas(hierarchicalOptions)
@@ -309,8 +309,8 @@ export default createSchema({
   name: 'default',
   types: schemaTypes.concat([
     // ...Other schemas
-    ...hierarchicalSchemas // add all items in the array of hierarchical schemas
-  ])
+    ...hierarchicalSchemas, // add all items in the array of hierarchical schemas
+  ]),
 })
 ```
 
@@ -320,7 +320,7 @@ Then, in your desk structure where you added the hierarchical document(s), inclu
 createDeskHierarchy({
   // Include whatever values you defined in your schema in the step above
   documentType: 'myCustomHierarchicalType', // the name of your document type
-  fieldKeyInDocument: 'customTreeDataKey' // the name of the hierarchical field
+  fieldKeyInDocument: 'customTreeDataKey', // the name of the hierarchical field
   // ...
 })
 
@@ -328,7 +328,7 @@ createDeskHierarchy({
 import {hierarchicalOptions} from './hierarchicalSchemas'
 
 createDeskHierarchy({
-  ...hierarchicalOptions
+  ...hierarchicalOptions,
   // ...
 })
 ```

package/dist/index.d.ts

@@ -1,194 +1,34 @@
-import {ArraySchemaType} from 'sanity'
-import type {ConfigContext} from 'sanity'
-import {DocumentDefinition} from 'sanity'
-import {Plugin as Plugin_2} from 'sanity'
-import {PreviewConfig} from 'sanity'
-import * as React_2 from 'react'
-import {StructureBuilder} from 'sanity/desk'
-
-export declare function createDeskHierarchy(props: TreeProps): any
-
-export declare function createHierarchicalSchemas(options: SchemaOptions): (
-  | {
-      name: string
-      title: string
-      type: string
-      fields: (
-        | {
-            name: string
-            type: string
-          }
-        | {
-            name: string
-            type: string
-            title: string
-            fields: (
-              | {
-                  name: string
-                  type: string
-                  weak?: undefined
-                  to?: undefined
-                  options?: undefined
-                }
-              | {
-                  name: string
-                  type: string
-                  weak: boolean
-                  to: {
-                    type: string
-                  }[]
-                  options:
-                    | {
-                        filter?: string | undefined
-                        filterParams?: Record<string, unknown> | undefined
-                      }
-                    | undefined
-                }
-            )[]
-          }
-      )[]
-    }
-  | {
-      name: string
-      title: string
-      type: string
-      of: (
-        | {
-            name: string
-            title: string
-            type: string
-            fields: (
-              | {
-                  name: string
-                  type: string
-                }
-              | {
-                  name: string
-                  type: string
-                  title: string
-                  fields: (
-                    | {
-                        name: string
-                        type: string
-                        weak?: undefined
-                        to?: undefined
-                        options?: undefined
-                      }
-                    | {
-                        name: string
-                        type: string
-                        weak: boolean
-                        to: {
-                          type: string
-                        }[]
-                        options:
-                          | {
-                              filter?: string | undefined
-                              filterParams?: Record<string, unknown> | undefined
-                            }
-                          | undefined
-                      }
-                  )[]
-                }
-            )[]
-          }
-        | {
-            type: string
-          }
-      )[]
-    }
-  | {
-      name: string | undefined
-      title: string
-      type: string
-      liveEdit: boolean
-      fields: (Omit<ArraySchemaType<unknown>, 'type' | 'of' | 'jsonType'> & {
-        type: string
-        inputComponent: React_2.FC<any>
-        of?: any[] | undefined
-      })[]
-      preview: {
-        select: {
-          id: string
-          tree: string
-        }
-        prepare({id, tree}: {id: string; tree: unknown[]}): Record<string, string>
-      }
-    }
-)[]
-
-export declare function flatDataToTree(data: StoredTreeItem[]): TreeItemWithChildren[]
-
-/**
- * Usage in `sanity.config.ts` (or .js)
- *
- * ```ts
- * import {defineConfig} from 'sanity'
- * import {hierarchicalDocumentList} from '@sanity/hierarchical-document-list'
- *
- * export default defineConfig({
- *   // ...
- *   plugins: [hierarchicalDocumentList()],
- * })
- * ```
- */
-export declare const hierarchicalDocumentList: Plugin_2<void>
-
-export declare const hierarchyTree: {
-  type: 'document'
-  name: 'hierarchy.tree'
-} & Omit<DocumentDefinition, 'preview'> & {
-    preview?: PreviewConfig<Record<string, string>, Record<never, any>> | undefined
-  }
-
-declare const INTERNAL_NODE_TYPE: string
-
-declare const INTERNAL_NODE_VALUE_TYPE: string
-
-declare interface SanityReference {
-  _type: 'reference'
-  _ref: string
-  _weak?: boolean
+import { ArraySchemaType } from "sanity";
+import { FC } from "react";
+declare const INTERNAL_NODE_TYPE: string;
+declare const INTERNAL_NODE_VALUE_TYPE: string;
+interface SanityReference {
+  _type: 'reference';
+  _ref: string;
+  _weak?: boolean;
 }
-
-declare type SchemaOptions = Omit<TreeDeskStructureProps, 'documentId' | 'maxDepth'>
-
 /**
  * Objects saved to tree documents in Sanity's Content Lake
  */
-declare interface StoredTreeItem {
-  _key: string
-  _type: typeof INTERNAL_NODE_TYPE | string
+interface StoredTreeItem {
+  _key: string;
+  _type: typeof INTERNAL_NODE_TYPE;
   value?: {
-    _type: typeof INTERNAL_NODE_VALUE_TYPE | string
-    reference?: SanityReference
-    docType?: string
-  }
+    _type: typeof INTERNAL_NODE_VALUE_TYPE;
+    reference?: SanityReference;
+    docType?: string;
+  };
   /**
    * _key of parent node
    */
-  parent?: string | null
+  parent?: string | null;
 }
-
-declare interface TreeDeskStructureProps extends TreeInputOptions {
-  /**
-   * _id of the document that will hold the tree data.
-   */
-  documentId: string
-  /**
-   * (Optional)
-   * Key for the field representing the hierarchical tree inside the document.
-   * `tree` by default.
-   */
-  fieldKeyInDocument?: string
-}
-
-declare interface TreeInputOptions {
+interface TreeInputOptions {
   /**
    * What document types this hierarchy can refer to.
    * Similar to the `to` property of the [reference field](https://www.sanity.io/docs/reference-type).
    */
-  referenceTo: string[]
+  referenceTo: string[];
   /**
    * Used to provide fine-grained filtering for documents.
    */
@@ -196,45 +36,180 @@ declare interface TreeInputOptions {
     /**
      * Static filter to apply to tree document queries.
      */
-    filter?: string
+    filter?: string;
     /**
      * Parameters / variables to pass to the GROQ query ran to fetch documents.
      */
-    filterParams?: Record<string, unknown>
-  }
+    filterParams?: Record<string, unknown>;
+  };
   /**
    * How deep should editors be allowed to nest items.
    */
-  maxDepth?: number
+  maxDepth?: number;
   /**
    * Schema type for your hierarchical documents.
    * Refer to documentation on how to provide these schemas in your studio.
    *
    * Defautlt: 'hierarchy.tree' - this schema is bundled with the plugin
    */
-  documentType?: string
+  documentType?: string;
 }
-
-declare interface TreeItemWithChildren extends StoredTreeItem {
-  children?: TreeItemWithChildren[]
+interface TreeDeskStructureProps extends TreeInputOptions {
+  /**
+   * _id of the document that will hold the tree data.
+   */
+  documentId: string;
+  /**
+   * (Optional)
+   * Key for the field representing the hierarchical tree inside the document.
+   * `tree` by default.
+   */
+  fieldKeyInDocument?: string;
 }
-
-export declare interface TreeProps extends TreeDeskStructureProps {
+interface TreeProps extends TreeDeskStructureProps {
   /**
    * Visible title above the tree.
    * Also used as the label in the desk list item.
    */
-  title: string
+  title: string;
   /**
    * Optional icon for rendering the item in the desk structure.
    */
-  icon?: any
-  context?: ConfigContext | any
-  S?: StructureBuilder | any
+  icon?: any;
+  /**
+   * The `ConfigContext` available as the second parameter of the structure resolver.
+   */
+  context?: any;
+  /**
+   * The `StructureBuilder` (`S`) available as the first parameter of the structure resolver.
+   */
+  S?: any;
   /**
    * Restrict document types that can be created.
    */
-  creatableTypes?: string[]
+  creatableTypes?: string[];
+}
+declare function createDeskHierarchy(props: TreeProps): any;
+type SchemaOptions = Omit<TreeDeskStructureProps, 'documentId' | 'maxDepth'>;
+declare function createHierarchicalSchemas(options: SchemaOptions): ({
+  name: string | undefined;
+  title: string;
+  type: string;
+  liveEdit: boolean;
+  fields: (Omit<ArraySchemaType<unknown>, "type" | "of" | "jsonType"> & {
+    type: string;
+    inputComponent: FC<any>;
+    of?: any[];
+  })[];
+  preview: {
+    select: {
+      id: string;
+      tree: string;
+    };
+    prepare({
+      id,
+      tree
+    }: {
+      id: string;
+      tree: unknown[];
+    }): Record<string, string>;
+  };
+} | {
+  name: string;
+  title: string;
+  type: string;
+  fields: ({
+    name: string;
+    type: string;
+  } | {
+    name: string;
+    type: string;
+    title: string;
+    fields: ({
+      name: string;
+      type: string;
+      weak?: undefined;
+      to?: undefined;
+      options?: undefined;
+    } | {
+      name: string;
+      type: string;
+      weak: boolean;
+      to: {
+        type: string;
+      }[];
+      options: {
+        filter?: string;
+        filterParams?: Record<string, unknown>;
+      } | undefined;
+    })[];
+  })[];
+} | {
+  name: string;
+  title: string;
+  type: string;
+  of: ({
+    name: string;
+    title: string;
+    type: string;
+    fields: ({
+      name: string;
+      type: string;
+    } | {
+      name: string;
+      type: string;
+      title: string;
+      fields: ({
+        name: string;
+        type: string;
+        weak?: undefined;
+        to?: undefined;
+        options?: undefined;
+      } | {
+        name: string;
+        type: string;
+        weak: boolean;
+        to: {
+          type: string;
+        }[];
+        options: {
+          filter?: string;
+          filterParams?: Record<string, unknown>;
+        } | undefined;
+      })[];
+    })[];
+  } | {
+    type: string;
+  })[];
+})[];
+declare const _default: {
+  type: "document";
+  name: "hierarchy.tree";
+} & Omit<import("sanity").DocumentDefinition, "preview"> & {
+  preview?: import("sanity").PreviewConfig<Record<string, string>, Record<never, any>> | undefined;
+};
+interface TreeItemWithChildren extends StoredTreeItem {
+  [key: string]: unknown;
+  children?: TreeItemWithChildren[];
 }
-
-export {}
+/**
+ * Converts the flat array stored in the Sanity document into a nested tree,
+ * nesting items under their `parent` _key. Items without a `parent` are roots.
+ */
+declare function flatDataToTree(data: StoredTreeItem[]): TreeItemWithChildren[];
+/**
+ * Usage in `sanity.config.ts` (or .js)
+ *
+ * ```ts
+ * import {defineConfig} from 'sanity'
+ * import {hierarchicalDocumentList} from '@sanity/hierarchical-document-list'
+ *
+ * export default defineConfig({
+ *   // ...
+ *   plugins: [hierarchicalDocumentList()],
+ * })
+ * ```
+ */
+declare const hierarchicalDocumentList: import("sanity").Plugin<void>;
+export { type TreeProps, createDeskHierarchy, createHierarchicalSchemas, flatDataToTree, hierarchicalDocumentList, _default as hierarchyTree };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/utils/injectNodeTypeInPatches.ts","../src/types.ts","../src/createDeskHierarchy.tsx","../src/createHierarchicalSchemas.tsx","../src/schemas/hierarchy.tree.ts","../src/utils/flatDataToTree.ts","../src/index.ts"],"mappings":";;cAsBa,kBAAA;AAAA,cACA,wBAAA;AAAA,UClBH,eAAA;EACR,KAAA;EACA,IAAA;EACA,KAAA;AAAA;ADeF;;;AAAA,UCTiB,cAAA;EACf,IAAA;EACA,KAAA,SAAc,kBAAA;EACd,KAAA;IACE,KAAA,SAAc,wBAAA;IACd,SAAA,GAAY,eAAA;IACZ,OAAA;EAAA;EAbF;;;EAkBA,MAAA;AAAA;AAAA,UAgCe,gBAAA;EAkBE;;;;EAbjB,WAAA;EAqCe;;;EAhCf,gBAAA;IAgC8C;;;IA5B5C,MAAA;IAuCgB;;ACvGpB;IDoEI,YAAA,GAAe,MAAM;EAAA;ECpEgC;;;ED0EvD,QAAA;EC3DA;;;;AAQc;AACf;ED0DC,YAAA;AAAA;AAAA,UAUe,sBAAA,SAA+B,gBAAgB;EErF9C;;;EFyFhB,UAAA;EEkCsB;;;;;EF3BtB,kBAAA;AAAA;AAAA,UCvGe,SAAA,SAAkB,sBAAsB;;AFezD;;;EEVE,KAAA;EFU2E;AAC7E;;EENE,IAAA;EFMsF;AAAA;;EEDtF,OAAA;EDjBuB;;;ECqBvB,CAAA;EDnBA;;;ECuBA,cAAA;AAAA;AAAA,iBAesB,mBAAA,CAAoB,KAAgB,EAAT,SAAS;AAAA,KC/BvD,aAAA,GAAgB,IAAI,CAAC,sBAAA;AAAA,iBA2HF,yBAAA,CAA0B,OAAA,EAAS,aAAA;;;;;;;oBApDzC,EAAA;;;;;;;;;;;;MA0CS,EAAA;MAAY,IAAA;IAAA,IAAmB,MAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UE7HhD,oBAAA,SAA6B,cAAc;EAAA,CAElD,GAAA;EACD,QAAA,GAAW,oBAAA;AAAA;;;ALiBgE;AAC7E;iBKXwB,cAAA,CAAe,IAAA,EAAM,cAAA,KAAmB,oBAAoB;;ALUP;AAC7E;;;;AAAwF;;ACpBS;;;;;cKqBpF,wBAAA,mBAAwB,MAAA"}