@powerhousedao/reactor-browser 5.1.0 → 5.2.0-dev.1

package/README.md

@@ -1,692 +1,506 @@
-# Editor state management hooks
+# Reactor Browser Hooks API Documentation
 
-This library provides hooks intended to be used by editors (including drive editors) which will be rendered inside of Powerhouse applications such as Connect and Vetra.
+This document contains all documentation comments for the hooks exported from `packages/reactor-browser/src/hooks/index.ts`.
 
-## Key concepts
+## Table of Contents
 
-### Reactor
+- [Allowed Document Model Modules](#allowed-document-model-modules)
+- [Child Nodes](#child-nodes)
+- [Config: Editor](#config-editor)
+- [Config: Set Config by Object](#config-set-config-by-object)
+- [Config: Use Value by Key](#config-use-value-by-key)
+- [Document by ID](#document-by-id)
+- [Document Cache](#document-cache)
+- [Document of Type](#document-of-type)
+- [Document Types](#document-types)
+- [Drives](#drives)
+- [Items in Selected Drive](#items-in-selected-drive)
+- [Items in Selected Folder](#items-in-selected-folder)
+- [Modals](#modals)
+- [Node by ID](#node-by-id)
+- [Node Path](#node-path)
+- [Revision History](#revision-history)
+- [Selected Document](#selected-document)
+- [Selected Drive](#selected-drive)
+- [Selected Folder](#selected-folder)
+- [Selected Node](#selected-node)
+- [Selected Timeline Item](#selected-timeline-item)
+- [Supported Document Types](#supported-document-types)
+- [Timeline Revision](#timeline-revision)
+- [Use Get Switchboard Link](#use-get-switchboard-link)
+- [Vetra Packages](#vetra-packages)
 
-All of the data used by these hooks is ultimately derived from the `Reactor`, which manages the asynchronous eventually consistent state of drives and documents.
+---
 
-### Selected drives, folders and documents
+## Allowed Document Model Modules
 
-In the application, there are certain items that can be set as "selected".
+### `useAllowedDocumentModelModules`
 
-- selected drive
-- selected folder
-- selected document
+No documentation available.
 
-We provide hooks for getting the selected item for each:
+---
 
-`useSelectedDrive`
-`useSelectedFolder`
-`useSelectedDocument`
+## Child Nodes
 
-Folders and documents are part of a given drive, so they will both be undefined if the selected drive is undefined.
+### `useNodesInSelectedDriveOrFolder`
 
-_Either_ a folder or a document can be selected but not both, so if one is defined then the other will be undefined.
+Returns the child nodes for the selected drive or folder.
 
-To set the selected drive, we provide a function `setSelectedDrive` which takes either a `DocumentDriveDocument` or a `DocumentDriveDocument['header']['slug']`.
+---
 
-To set the selected document/folder, we provide a function `setSelectedNode` which returns a setter function which can be used for _both_ documents and folders. This function takes either a `Node` or a slug which can be the url slug or the node's id.
+## Document by ID
 
-## Hooks
+### `useDocumentById`
 
-### Reactor
+Returns a document by id.
 
-```ts
-function useReactor(): Reactor | undefined;
-```
+### `useDocumentsByIds`
 
-Returns the reactor instance.
+Returns documents by ids.
 
-##### Usage
+---
 
-```jsx
-import { useReactor } from '@powerhousedao/state`
+## Document Cache
 
-function MyEditorComponent() {
-  const reactor = useReactor();
-}
-```
+### `useDocumentCache`
 
-### Drives
+Returns all documents in the reactor.
 
-#### useDrives
+### `setDocumentCache`
 
-```ts
-function useDrives(): DocumentDriveDocument[] | undefined;
-```
+Sets all of the documents in the reactor.
 
-Returns the drives for a reactor.
+### `addDocumentCacheEventHandler`
 
-##### Usage
+Adds an event handler for all of the documents in the reactor.
 
-```jsx
-import { useDrives } from "@powerhousedao/state";
+### `useDocument`
 
-function MyEditorComponent() {
-  const drives = useDrives();
-}
-```
+Retrieves a document from the reactor and subscribes to changes using React Suspense.
+This hook will suspend rendering while the document is loading.
 
-#### useDriveById
+**Parameters:**
+- `id` - The document ID to retrieve, or null/undefined to skip retrieval
 
-```ts
-function useDriveById(
-  id: string | null | undefined,
-): DocumentDriveDocument | undefined;
-```
+**Returns:** The document if found, or undefined if id is null/undefined
 
-Returns a drive by id.
+### `useDocuments`
 
-##### Usage
+Retrieves multiple documents from the reactor using React Suspense.
+This hook will suspend rendering while any of the documents are loading.
 
-```jsx
-import { useDriveById } from "@powerhousedao/state";
+**Parameters:**
+- `ids` - Array of document IDs to retrieve, or null/undefined to skip retrieval
 
-function MyEditorComponent() {
-  const driveById = useDriveById();
-}
-```
+**Returns:** An array of documents if found, or empty array if ids is null/undefined
 
-#### useSelectedDrive
+### `useGetDocument`
 
-```ts
-function useSelectedDrive(): DocumentDriveDocument | undefined;
-```
+Returns a function to retrieve a document from the cache.
+The returned function fetches and returns a document by ID.
 
-Returns the selected drive. You can se the selected drive with `setSelectedDrive`.
+**Returns:** A function that takes a document ID and returns a Promise of the document
 
-##### Usage
+### `useGetDocuments`
 
-```jsx
-import { useSelectedDrive } from "@powerhousedao/state";
+Returns a function to retrieve multiple documents from the cache.
+The returned function fetches and returns documents by their IDs.
 
-function MyEditorComponent() {
-  const selectedDrive = useSelectedDrive();
-}
-```
+**Returns:** A function that takes an array of document IDs and returns a Promise of the documents
 
-#### drive properties convenience hooks
+### `useGetDocumentAsync`
 
-We provide hooks for accessing various properties on the drive object for your convenience. These use the above hooks to get a drive and then return properties in the object.
+Retrieves a document from the reactor without suspending rendering.
+Returns the current state of the document loading operation.
 
-```ts
-/** Returns the remote URL for a drive. */
-function useDriveRemoteUrl(
-  driveId: string | null | undefined,
-): string | undefined;
+**Parameters:**
+- `id` - The document ID to retrieve, or null/undefined to skip retrieval
 
-/** Returns the pull responder trigger for a drive. */
-function useDrivePullResponderTrigger(
-  driveId: string | null | undefined,
-): Trigger | undefined;
+**Returns:** An object containing:
+- `status`: "initial" | "pending" | "success" | "error"
+- `data`: The document if successfully loaded
+- `isPending`: Boolean indicating if the document is currently loading
+- `error`: Any error that occurred during loading
+- `reload`: Function to force reload the document from cache
 
-/** Returns the pull responder URL for a drive. */
-function useDrivePullResponderUrl(
-  driveId: string | null | undefined,
-): string | undefined;
+---
 
-/** Returns whether a drive is remote. */
-function useDriveIsRemote(driveId: string | null | undefined): boolean;
+## Document of Type
 
-/** Returns the sharing type for a drive. */
-function useDriveSharingType(
-  driveId: string | null | undefined,
-): SharingType | undefined;
+### `useDocumentOfType`
 
-/** Returns  whether a drive is available offline. */
-function useDriveAvailableOffline(driveId: string | null | undefined): boolean;
-```
+Returns a document of a specific type, throws an error if the found document has a different type.
 
-##### Usage
+---
 
-```jsx
-import {
-  useDriveRemoteUrl,
-  useDrivePullResponderTrigger,
-  useDrivePullResponderUrl,
-  useDriveIsRemote,
-  useDriveSharingType,
-  useDriveAvailableOffline,
-} from "@powerhousedao/state";
+## Document Types
 
-function MyEditorComponent() {
-  const myDriveId = "some-drive-id";
-  const driveRemoteUrl = useDriveRemoteUrl(myDriveId);
-  const drivePullResponderTrigger = useDrivePullResponderTrigger(myDriveId);
-  const drivePullResponderUrl = useDrivePullResponderUrl(myDriveId);
-  const driveIsRemote = useDriveIsRemote(myDriveId);
-  const driveSharingType = useDriveSharingType(myDriveId);
-  const driveAvailableOffline = useDriveAvailableOffline(myDriveId);
+### `useDocumentTypes`
 
-  console.log({
-    driveRemoteUrl,
-    drivePullResponderTrigger,
-    drivePullResponderUrl,
-    driveIsRemote,
-    driveSharingType,
-    driveAvailableOffline,
-  });
-}
-```
+Returns the document types a drive editor supports.
 
-### Documents
+If present, uses the `allowedDocumentTypes` config value.
+Otherwise, uses the supported document types from the reactor.
 
-#### useDocumentById
+---
 
-```ts
-function useDocumentById(id: string | null | undefined): PHDocument | undefined;
-```
+## Drives
 
-Returns a document and a dispatch function by id.
+### `useDrives`
 
-##### Usage
+Returns all of the drives in the reactor.
 
-```jsx
-import { useDocumentById } from "@powerhousedao/state";
+### `setDrives`
 
-function MyEditorComponent() {
-  const myDocumentId = "some-document-id";
-  const [document, dispatch] = useDocumentById(myDocumentId);
-}
-```
+Sets the drives in the reactor.
 
-#### useGetDocument
+### `addDrivesEventHandler`
 
-```ts
-function useGetDocument(id: string | null | undefined): PHDocument | undefined;
-```
+Adds an event handler for the drives.
 
-Retrieves a document from the reactor and subscribes to changes using React Suspense. This hook will suspend rendering while the document is loading.
+---
 
-##### Usage
+## Items in Selected Drive
 
-```jsx
-import { useGetDocument } from "@powerhousedao/state";
+### `useNodesInSelectedDrive`
 
-function MyEditorComponent() {
-  const documentId = "some-document-id";
-  const document = useGetDocument(documentId);
-}
-```
+Returns the nodes in the selected drive.
 
-#### useGetDocuments
+### `useFileNodesInSelectedDrive`
 
-```ts
-function useGetDocuments(
-  ids: string[] | null | undefined,
-): PHDocument[] | undefined;
-```
+Returns the file nodes in the selected drive.
 
-Retrieves multiple documents from the reactor using React Suspense. This hook will suspend rendering while any of the documents are loading.
+### `useFolderNodesInSelectedDrive`
 
-##### Usage
+Returns the folder nodes in the selected drive.
 
-```jsx
-import { useGetDocuments } from "@powerhousedao/state";
+### `useDocumentsInSelectedDrive`
 
-function MyEditorComponent() {
-  const documentIds = ["doc-id-1", "doc-id-2", "doc-id-3"];
-  const documents = useGetDocuments(documentIds);
-}
-```
+Returns the documents in the selected drive.
 
-#### useGetDocumentAsync
+### `useDocumentTypesInSelectedDrive`
 
-```ts
-function useGetDocumentAsync(id: string | null | undefined): {
-  status: "initial" | "pending" | "success" | "error";
-  data: PHDocument | undefined;
-  isPending: boolean;
-  error: unknown;
-  reload: (() => void) | undefined;
-};
-```
+Returns the document types supported by the selected drive, as defined by the document model documents present in the drive.
 
-Retrieves a document from the reactor without suspending rendering. Returns the current state of the document loading operation, including status, data, error, and a reload function.
+---
 
-##### Usage
+## Items in Selected Folder
 
-```jsx
-import { useGetDocumentAsync } from "@powerhousedao/state";
+### `useNodesInSelectedFolder`
 
-function MyEditorComponent() {
-  const documentId = "some-document-id";
-  const { status, data, isPending, error, reload } =
-    useGetDocumentAsync(documentId);
+Returns the nodes in the selected folder.
 
-  if (isPending) {
-    return <div>Loading...</div>;
-  }
+### `useFileNodesInSelectedFolder`
 
-  if (error) {
-    return <div>Error: {error.message}</div>;
-  }
+Returns the file nodes in the selected folder.
 
-  if (status === "success" && data) {
-    return <div>Document: {data.name}</div>;
-  }
-}
-```
+### `useFolderNodesInSelectedFolder`
 
-#### useDocumentsInSelectedDrive
+Returns the folder nodes in the selected folder.
 
-```ts
-function useDocumentsInSelectedDrive(): PHDocument[] | undefined;
-```
+### `useDocumentsInSelectedFolder`
 
-Returns the documents in the reactor for the selected drive.
+Returns the documents in the selected folder.
 
-##### Usage
+---
 
-```jsx
-import { useDocumentsInSelectedDrive } from "@powerhousedao/state";
+## Modals
 
-function MyEditorComponent() {
-  const selectedDriveDocuments = useDocumentsInSelectedDrive();
-}
-```
+### `usePHModal`
 
-#### useSelectedDocument
+Returns the current modal.
 
-```ts
-function useSelectedDocument(): PHDocument | undefined;
-```
+### `setPHModal`
 
-Returns the selected document. You can set the selected document with `setSelectedNode`.
+Sets the current modal.
 
-##### Usage
+### `addModalEventHandler`
 
-```jsx
-import { useSelectedDocument } from "@powerhousedao/state";
+Adds an event handler for the modal.
 
-function MyEditorComponent() {
-  const selectedDocument = useSelectedDocument();
-}
-```
+### `showPHModal`
 
-### Nodes
+Shows a modal.
 
-"Nodes" refers to the items found in a given drive's `state.global.nodes` array. Nodes can represent both files (documents) and folders.
+### `closePHModal`
 
-A document in a drive will have a node in the drive's node list which has the same id as the document.
+Closes the current modal.
 
-Nodes have an optional `parentFolder` field, which is the id of a folder node in the drive when it is defined. If it is undefined, the node is a direct child of the drive.
+### `showCreateDocumentModal`
 
-A given folder node's children are the nodes in the drive's node list which have their parent folder set to the folder node's id.
+Shows the create document modal.
 
-```ts
-type FileNode = {
-  documentType: string;
-  id: string;
-  kind: string;
-  name: string;
-  parentFolder: string | null | undefined;
-};
+### `showDeleteNodeModal`
 
-type FolderNode = {
-  id: string;
-  kind: string;
-  name: string;
-  parentFolder: string | null | undefined;
-};
+Shows the delete node modal.
 
-type Node = FileNode | FolderNode;
-```
+---
 
-#### useNodes
+## Node by ID
 
-Ideally you should not need to handle the list of nodes directly, since we already provide documents and folders. But these hooks are provided just in case.
+### `useNodeById`
 
-```ts
-function useNodes(): Node[] | undefined;
-```
+Returns a node in the selected drive by id.
 
-Returns the nodes for a drive.
+---
 
-##### Usage
+## Node Path
 
-```jsx
-import { useNodes } from "@powerhousedao/state";
+### `useNodePathById`
 
-function MyEditorComponent() {
-  const nodes = useNodes();
-}
-```
+Returns the path to a node in the selected drive.
 
-#### useNodeById
+### `useSelectedNodePath`
 
-```ts
-function useNodeById(id: string | null | undefined): Node | undefined;
-```
+Returns the path to the currently selected node in the selected drive.
 
-Returns a node in the selected drive by id.
+---
 
-##### Usage
+## Revision History
 
-```jsx
-import { useNodeById } from "@powerhousedao/state";
+### `useRevisionHistoryVisible`
 
-function MyEditorComponent() {
-  const myFolderId = "some-folder-id";
-  const myDocumentId = "some-document-id";
-  const myFolderNode = useNodeById(myFolderId);
-  const myFileNode = useNodeById(myDocumentId);
-}
-```
+Returns whether revision history is visible.
 
-#### useSelectedFolder
+### `setRevisionHistoryVisible`
 
-```ts
-function useSelectedFolder(): FolderNode | undefined;
-```
+Sets revision history visibility.
 
-Returns the selected folder. You can set the selected folder with `setSelectedNode`
+### `addRevisionHistoryVisibleEventHandler`
 
-##### Usage
+Adds event handler for revision history visibility.
 
-```jsx
-import { useSelectedFolder } from "@powerhousedao/state";
+### `showRevisionHistory`
 
-function MyEditorComponent() {
-  const selectedFolder = useSelectedFolder();
-}
-```
+Shows the revision history.
 
-#### useSelectedNodePath
+### `hideRevisionHistory`
 
-```ts
-function useSelectedNodePath(): Node[];
-```
+Hides the revision history.
 
-Returns the path to the selected node. Useful for navigational components like breadcrumbs.
+---
 
-##### Usage
+## Selected Document
 
-```jsx
-import { useSelectedNodePath } from '@powerhousedao/state';
+### `useSelectedDocumentId`
 
-function MyEditorComponent() {
-  const nodes = useSelectedNodePath();
+Returns the selected document id.
 
-  return <Breadcrumbs nodes={nodes}>
-}
-```
+### `useSelectedDocument`
 
-#### useChildNodes/useFolderChildNodes/useFileChildNodes
+Returns the selected document.
 
-```ts
-function useChildNodes(): Node[];
-```
+### `useSelectedDocumentOfType`
 
-Returns the child nodes for the selected drive or folder.
+Returns the selected document of a specific type, throws an error if the found document has a different type.
+
+---
+
+## Selected Drive
+
+### `useSelectedDriveId`
+
+Returns the selected drive id.
+
+### `setSelectedDriveId`
+
+Sets the selected drive id.
+
+### `addSelectedDriveIdEventHandler`
+
+Adds an event handler for the selected drive id.
+
+### `useSelectedDrive`
+
+Returns the selected drive.
+
+### `useSelectedDriveSafe`
+
+Returns the selected drive, or undefined if no drive is selected.
+
+---
+
+## Selected Folder
+
+### `useSelectedFolder`
+
+Returns the selected folder.
+
+---
+
+## Selected Node
+
+### `useSelectedNode`
+
+Returns the selected node.
+
+### `setSelectedNode`
+
+Sets the selected node (file or folder).
 
-```ts
-function useFolderChildNodes(): FolderNode[];
-```
+---
 
-Returns the folder child nodes for the selected drive or folder.
+## Selected Timeline Item
 
-```ts
-function useFileChildNodes(): FileNode[];
-```
+### `useSelectedTimelineItem`
 
-Returns the file (document) child nodes for the selected drive or folder.
+Returns the selected timeline item.
 
-##### Usage
+### `setSelectedTimelineItem`
 
-```jsx
-import { useChildNodes, useFolderChildNodes, useFileChildNodes } from '@powerhousedao/state';
+Sets the selected timeline item.
 
-function MyEditorComponent() {
-  const nodes = useChildNodes();
-  const fileNodes = useChildFileNodes();
-  const folderNodes = useChildFolderNodes();
+### `addSelectedTimelineItemEventHandler`
 
-  return (
-    <div>
-     <FilesAndFolders nodes={nodes}>
-     <Files fileNodes={fileNodes}>
-     <Folders folderNodes={folderNodes}>
-    </div>
- )
-}
-```
+Adds event handler for selected timeline item.
 
-#### useChildNodesForId/useFolderChildNodesForId/useFileChildNodesForId
+---
 
-```ts
-function useChildNodesForId(id: string | null | undefined): Node[];
-```
+## Supported Document Types
 
-Returns the child nodes for a drive or folder by id.
+### `useSupportedDocumentTypesInReactor`
 
-```ts
-function useFolderChildNodesForId(id: string | null | undefined): FolderNode[];
-```
+Returns the supported document types for the reactor (derived from the document model modules).
 
-Returns the folder child nodes for a drive or folder by id.
+---
 
-```ts
-function useFileChildNodesForId(id: string | null | undefined): FileNode[];
-```
+## Timeline Revision
 
-Returns the file (document) child nodes for a drive or folder by id.
+### `useSelectedTimelineRevision`
 
-##### Usage
+Returns the selected timeline revision.
 
-```jsx
-import { useChildNodesForId, useFolderChildNodesForId, useFileChildNodesForId } from '@powerhousedao/state';
+### `setSelectedTimelineRevision`
 
-function MyEditorComponent() {
-  const driveOrFolderId = 'some-drive-or-folder-id';
-  const nodes = useChildNodesForId(driveOrFolderId);
-  const fileNodes = useFileChildNodesForId(driveOrFolderId);
-  const folderNodes = useFolderChildNodesForId(driveOrFolderId);
+Sets the selected timeline revision.
 
-  return (
-    <div>
-     <FilesAndFolders nodes={nodes}>
-     <Files fileNodes={fileNodes}>
-     <Folders folderNodes={folderNodes}>
-    </div>
- )
-}
-```
+### `addSelectedTimelineRevisionEventHandler`
 
-#### useNodeName/useNodeKind
+Adds an event handler for the selected timeline revision.
 
-```ts
-function useNodeName(id: string | null | undefined): string | undefined;
-```
+---
 
-Returns the name of a node.
+## Use Get Switchboard Link
 
-```ts
-function useNodeKind(id: string | null | undefined): NodeKind | undefined;
-```
+### `useGetSwitchboardLink`
 
-Returns the kind of a node.
+Hook that returns a function to generate a document's switchboard URL.
+Only returns a function for documents in remote drives.
+Returns null for local drives or when the document/drive cannot be determined.
 
-##### Usage
+The returned function generates a fresh bearer token and builds the switchboard URL
+with authentication when called.
 
-```jsx
-import { useNodeName, useNodeKind } from "@powerhousedao/state";
+**Parameters:**
+- `document` - The document to create a switchboard URL generator for
 
-function MyEditorComponent() {
-  const nodeId = "some-node-id";
-  const nodeName = useNodeName(nodeId);
-  const nodeKind = useNodeKind(nodeId);
+**Returns:** An async function that returns the switchboard URL, or null if not applicable
 
-  if (nodeKind === "file") {
-    return <File name={nodeName} />;
-  }
+---
 
-  if (nodeKind === "folder") {
-    return <Folder name={nodeName} />;
-  }
-}
-```
+## Vetra Packages
 
-### Vetra packages and modules
+### `useVetraPackages`
 
-Vetra packages hold code which can plug into your Connect application. This includes common default modules like the document model document model editor and document drive document model, as well as the modules from your local project and the various packages you have installed.
+Returns all of the Vetra packages loaded by the Connect instance.
 
-These modules can be for:
+### `addVetraPackagesEventHandler`
 
-- document models
-- editors
-- subgraphs
-- import scripts
-- processors
+Adds the Vetra packages event handler.
 
-Each Vetra package contains a `modules` field which optionally contains lists of these modules.
+### `setVetraPackages`
 
-#### useVetraPackages
+Sets the Vetra packages for the Connect instance.
 
-```ts
-function useVetraPackages(): VetraPackage[] | undefined;
-```
+---
 
-Returns all of the Vetra packages in your Connect app.
 
-##### Usage
+## Config: Editor
 
-```jsx
-import { useVetraPackages } from "@powerhousedao/state";
+### `setIsExternalControlsEnabled`
 
-function MyEditorComponent() {
-  const vetraPackages = useVetraPackages();
-}
-```
+Sets whether external controls are enabled for a given editor.
 
-#### useDocumentModelModules
+### `useIsExternalControlsEnabled`
 
-```ts
-function useDocumentModelModules(): DocumentModelModule[] | undefined;
-```
+Gets whether external controls are enabled for a given editor.
 
-Returns the document model modules from your Vetra packages.
+### `addIsExternalControlsEnabledEventHandler`
 
-##### Usage
+Adds an event handler for when the external controls enabled state changes.
 
-```jsx
-import { useDocumentModelModules } from "@powerhousedao/state";
+### `setIsDragAndDropEnabled`
 
-function MyEditorComponent() {
-  const documentModelModules = useDocumentModelModules();
-}
-```
+Sets whether drag and drop is enabled for a given drive editor.
 
-#### useDocumentModelModuleById
+### `useIsDragAndDropEnabled`
 
-```ts
-function useDocumentModelModuleById(): DocumentModelModule[] | undefined;
-```
+Gets whether drag and drop is enabled for a given drive editor.
 
-Returns the document model for a given id (document type).
-_NOTE_ What we call here an id is really the value in the "document type" field in the document model editor
-_NOTE_ Connect assumes that these document types (ids) are unique. It is your responsibility to enforce this.
+### `addIsDragAndDropEnabledEventHandler`
 
-##### Usage
+Adds an event handler for when the drag and drop enabled state changes.
 
-```jsx
-import { useDocumentModelModuleById } from "@powerhousedao/state";
+### `setAllowedDocumentTypes`
 
-function MyEditorComponent() {
-  const documentType = "my-org/my-document";
-  const documentModelModuleById = useDocumentModelModuleById(documentType);
-}
-```
+Sets the allowed document types for a given drive editor.
 
-#### useEditorModules
+### `useAllowedDocumentTypes`
 
-```ts
-function useEditorModules(): EditorModule[] | undefined;
-```
+Defines the document types a drive supports.
 
-Returns the editor modules from your Vetra packages.
+Defaults to all of the document types registered in the reactor.
 
-##### Usage
+### `addAllowedDocumentTypesEventHandler`
 
-```jsx
-import { useEditorModules } from "@powerhousedao/state";
+Adds an event handler for when the allowed document types for a given drive editor changes.
 
-function MyEditorComponent() {
-  const editorModules = useEditorModules();
-}
-```
+---
 
-#### useDriveEditorModules
+## Config: Set Config by Object
 
-```ts
-function useDriveEditorModules(): DriveEditorModule[] | undefined;
-```
+### `setPHDriveEditorConfig`
 
-Returns the drive editor modules from your Vetra packages.
+Sets the global drive config.
 
-##### Usage
+Pass in a partial object of the global drive config to set.
 
-```jsx
-import { useDriveEditorModules } from "@powerhousedao/state";
+### `setPHDocumentEditorConfig`
 
-function MyDriveEditorComponent() {
-  const driveEditorModules = useDriveEditorModules();
-}
-```
+Sets the global document config.
 
-#### useProcessorModules
+Pass in a partial object of the global document config to set.
 
-```ts
-function useProcessorModules(): ProcessorModule[] | undefined;
-```
+### `useSetPHDriveEditorConfig`
 
-Returns the processor modules from your Vetra packages.
+Wrapper hook for setting the global drive editor config.
 
-##### Usage
+Automatically sets the global drive editor config when the component mounts.
 
-```jsx
-import { useProcessorModules } from "@powerhousedao/state";
+Pass in a partial object of the global drive editor config to set.
 
-function MyProcessorComponent() {
-  const processorModules = useProcessorModules();
-}
-```
+### `useSetPHDocumentEditorConfig`
 
-#### useSubgraphModules
+Wrapper hook for setting the global document editor config.
 
-```ts
-function useSubgraphModules(): SubgraphModule[] | undefined;
-```
+Automatically sets the global document editor config when the component mounts.
 
-Returns the subgraph modules from your Vetra packages.
+Pass in a partial object of the global document editor config to set.
 
-##### Usage
+---
 
-```jsx
-import { useSubgraphModules } from "@powerhousedao/state";
+## Config: Use Value by Key
 
-function MySubgraphComponent() {
-  const subgraphModules = useSubgraphModules();
-}
-```
+### `usePHDriveEditorConfigByKey`
 
-#### useImportScriptModules
+Gets the value of an item in the global drive config for a given key.
 
-```ts
-function useImportScriptModules(): ImportScriptModule[] | undefined;
-```
+Strongly typed, inferred from type definition for the key.
 
-Returns the import script modules from your Vetra packages.
+### `usePHDocumentEditorConfigByKey`
 
-##### Usage
+Gets the value of an item in the global document config for a given key.
 
-```jsx
-import { useImportScriptModules } from "@powerhousedao/state";
+Strongly typed, inferred from type definition for the key.
 
-function MyImportScriptComponent() {
-  const importScriptModules = useImportScriptModules();
-}
-```
+---