@kopexa/tiptap 17.6.18 → 17.7.2

package/dist/index.d.mts

@@ -1,25 +1,692 @@
+import * as _tiptap_core from '@tiptap/core';
+import { Node, JSONContent } from '@tiptap/core';
 export { Content, JSONContent } from '@tiptap/core';
-export { EditorFileHandler, EditorFileProvider, EditorFileProviderProps, useEditorFile, useEditorFileRequired } from './context/editor-file-context.mjs';
-export { default as CalloutNode, CalloutAttrs as CalloutNodeAttrs, CalloutVariant } from './extensions/callout/index.mjs';
-export { ImageNode } from './extensions/image/index.mjs';
-export { ImageUploadNode } from './extensions/image-upload/index.mjs';
-export { default as MathBlock, MathBlockAttrs } from './extensions/math/index.mjs';
-export { default as TocNode } from './extensions/toc/index.mjs';
-export { default as VariableNode, VariableNodeAttrs, VariableOptions } from './extensions/variable/index.mjs';
-export { extractVariablesFromContent } from './extensions/variable/extract-variables.mjs';
-export { VariableProvider, VariableProviderProps, useVariables, useVariablesWithFallback } from './extensions/variable/variable-context.mjs';
-export { VariableFillerDialog, VariableFillerDialogProps } from './extensions/variable/variable-filler-dialog.mjs';
-export { VariableDefinition, VariableSuggestion, VariableSuggestionProps } from './extensions/variable/variable-suggestion.mjs';
-export { GetExtensionsOptions, getExtensions } from './hooks/use-create-editor.mjs';
-export { BasicEditor as Editor } from './presets/basic/index.mjs';
-export { convertFileToBase64, handleImageUpload, isAllowedUri, sanitizeUrl } from './utils/index.mjs';
-export { default as InlineMath, InlineMathAttrs } from './extensions/math/inline-math.mjs';
-import 'react/jsx-runtime';
-import 'react';
-import './extensions/image/image-view.mjs';
-import '@tiptap/react';
-import './extensions/image/messages.mjs';
-import './extensions/image-upload/image-upload-view.mjs';
-import './extensions/image-upload/messages.mjs';
-import '@kopexa/extension-controlref';
-import '@kopexa/theme';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { HocuspocusProvider } from '@hocuspocus/provider';
+import * as React from 'react';
+import { ReactNode } from 'react';
+import * as Y from 'yjs';
+import { Editor, Extensions, Content, JSONContent as JSONContent$1 } from '@tiptap/react';
+import { ControlResolver } from '@kopexa/extension-controlref';
+import { PagesOptions } from '@kopexa/extension-pages';
+import { EditorBasicVariants } from '@kopexa/theme';
+
+type CollaborationStatus = "connecting" | "connected" | "disconnected";
+interface CollabUser {
+    id: string;
+    name: string;
+    color?: string;
+    avatar?: string;
+}
+/** A resolved user with a guaranteed color. */
+interface ResolvedCollabUser extends CollabUser {
+    color: string;
+}
+interface CollaborationState {
+    /** Current WebSocket connection status. */
+    status: CollaborationStatus;
+    /** True when reconnecting after a previous disconnect. */
+    isReconnecting: boolean;
+    /** True when both remote and local are synced. */
+    synced: boolean;
+    /** Whether the remote provider has synced at least once. */
+    remoteSynced: boolean;
+    /** Whether local IndexedDB persistence has synced. */
+    localSynced: boolean;
+    /** Timestamp of the last successful remote sync. */
+    lastSyncedAt: Date | null;
+    /** Active collaborators (from awareness protocol). */
+    collabUsers: ResolvedCollabUser[];
+    /** The Hocuspocus WebSocket provider. */
+    provider: HocuspocusProvider | null;
+    /** The shared Yjs document. */
+    ydoc: Y.Doc;
+    /** The current user with resolved color. */
+    user: ResolvedCollabUser;
+}
+interface CollaborationProviderProps {
+    /** Unique document identifier for the collaboration room. */
+    documentId: string;
+    /** WebSocket URL of the Hocuspocus server. */
+    url: string;
+    /**
+     * Async function to get a fresh auth token.
+     * Called on every connect and reconnect for token renewal.
+     */
+    getToken: () => Promise<string> | string;
+    /** Current user info for presence/cursors. */
+    user: CollabUser;
+    /**
+     * Enable local IndexedDB persistence for offline caching.
+     * @default true
+     */
+    enableLocalPersistence?: boolean;
+    children: ReactNode;
+}
+declare function CollaborationProvider({ documentId, url, getToken, user, enableLocalPersistence, children, }: CollaborationProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Returns the collaboration state, or `null` if outside a CollaborationProvider.
+ * This is how `useCreateEditor` detects whether to enable collaboration.
+ */
+declare function useCollaboration(): CollaborationState | null;
+/**
+ * Returns the collaboration state, or throws if not inside a CollaborationProvider.
+ * Use in components that require collaboration to be active.
+ */
+declare function useCollaborationRequired(): CollaborationState;
+
+interface EditorFileHandler {
+    /**
+     * Upload a file and return a reference string.
+     * The reference format is determined by the backend (e.g., UUID, custom scheme).
+     * @param file The file to upload
+     * @param onProgress Optional progress callback (0-100)
+     * @returns Promise resolving to a reference string
+     */
+    upload: (file: File, onProgress?: (percent: number) => void) => Promise<string>;
+    /**
+     * Resolve a reference to a displayable URL.
+     * Typically returns a signed URL from your storage backend.
+     * @param ref The reference string from upload
+     * @returns Promise resolving to a displayable URL
+     */
+    resolve: (ref: string) => Promise<string>;
+    /**
+     * Check if a src string is a reference that needs resolving.
+     * Returns false for already-valid URLs (https://, data:, etc.)
+     * @param src The src attribute value
+     * @returns true if this needs to be resolved
+     */
+    isReference: (src: string) => boolean;
+}
+interface EditorFileContextValue extends EditorFileHandler {
+    /**
+     * Whether file handling is available
+     */
+    isAvailable: true;
+}
+interface EditorFileProviderProps {
+    children: ReactNode;
+    /**
+     * Upload handler - called when user pastes/drops a file
+     */
+    onUpload: EditorFileHandler["upload"];
+    /**
+     * Resolve handler - called to get displayable URL from reference
+     */
+    onResolve: EditorFileHandler["resolve"];
+    /**
+     * Check if src needs resolving (default: not starting with http/https/data)
+     */
+    isReference?: EditorFileHandler["isReference"];
+    /**
+     * Cache TTL buffer in ms (default: 2 minutes)
+     * URLs are refreshed this much before actual expiry
+     */
+    cacheBuffer?: number;
+    /**
+     * Default cache TTL in ms if not determined from response (default: 10 minutes)
+     */
+    defaultCacheTtl?: number;
+}
+declare function EditorFileProvider({ children, onUpload, onResolve, isReference, cacheBuffer, defaultCacheTtl, }: EditorFileProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access file handling capabilities.
+ * Returns null if no EditorFileProvider is present (files not supported).
+ */
+declare function useEditorFile(): EditorFileContextValue | null;
+/**
+ * Hook that throws if file handling is not available.
+ * Use this in components that require file support.
+ */
+declare function useEditorFileRequired(): EditorFileContextValue;
+
+type CalloutVariant = "default" | "info" | "success" | "warning" | "destructive";
+interface CalloutNodeAttrs {
+    /**
+     * Visual variant of the callout
+     * @default "info"
+     */
+    variant: CalloutVariant;
+    /**
+     * Optional title for the callout
+     * @default null
+     */
+    title: string | null;
+}
+interface CalloutOptions {
+    /**
+     * Custom HTML attributes for the Callout wrapper element.
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        calloutNode: {
+            /**
+             * Insert a callout node
+             */
+            insertCallout: (variant?: CalloutVariant) => ReturnType;
+            /**
+             * Update callout settings
+             */
+            updateCalloutSettings: (attrs: Partial<CalloutNodeAttrs>) => ReturnType;
+        };
+    }
+}
+/**
+ * Callout Node Extension
+ *
+ * Inserts a callout block with different variants (info, warning, success, error)
+ * Supports editable content inside the callout.
+ */
+declare const CalloutNode: Node<CalloutOptions, any>;
+
+interface ImageNodeOptions {
+    /**
+     * Whether to allow base64 images
+     * @default true
+     */
+    allowBase64: boolean;
+    /**
+     * HTML attributes to add to the image element
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+/**
+ * Extended Image extension with file reference resolution support
+ *
+ * This extension wraps @tiptap/extension-image and adds:
+ * - File reference resolution via EditorFileProvider
+ * - Loading states while resolving URLs
+ * - Error handling for failed resolution
+ * - Upload state tracking for drag & drop uploads
+ */
+declare const ImageNode: _tiptap_core.Node<ImageNodeOptions, any>;
+
+interface ImageUploadNodeOptions {
+    /**
+     * Allowed MIME types for upload
+     * @default ["image/*"]
+     */
+    accept: string;
+    /**
+     * Maximum file size in bytes (0 = unlimited)
+     * @default 0
+     */
+    maxSize: number;
+    /**
+     * HTML attributes to add to the wrapper element
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        imageUpload: {
+            /**
+             * Insert an image upload placeholder
+             */
+            setImageUpload: () => ReturnType;
+        };
+    }
+}
+/**
+ * ImageUploadNode - Upload placeholder that converts to a regular image node
+ *
+ * This extension provides a file upload UI that, after successful upload,
+ * replaces itself with a standard `image` node from @tiptap/extension-image.
+ *
+ * This separation allows:
+ * - Clean coexistence with the standard image extension
+ * - Upload UI only when needed
+ * - Standard image handling for display
+ */
+declare const ImageUploadNode: Node<ImageUploadNodeOptions, any>;
+
+interface InlineMathAttrs {
+    /**
+     * The LaTeX formula content
+     */
+    latex: string;
+}
+interface InlineMathOptions {
+    /**
+     * Custom HTML attributes for the inline math wrapper element.
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        inlineMath: {
+            /**
+             * Insert inline math
+             */
+            insertInlineMath: (latex?: string) => ReturnType;
+        };
+    }
+}
+/**
+ * Inline Math Node Extension
+ *
+ * Renders inline LaTeX formulas using KaTeX.
+ */
+declare const InlineMath: Node<InlineMathOptions, any>;
+
+interface MathBlockAttrs {
+    /**
+     * The LaTeX formula content
+     */
+    latex: string;
+}
+interface MathBlockOptions {
+    /**
+     * Custom HTML attributes for the Math block wrapper element.
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        mathBlock: {
+            /**
+             * Insert a math block
+             */
+            insertMathBlock: (latex?: string) => ReturnType;
+            /**
+             * Update math block content
+             */
+            updateMathBlock: (latex: string) => ReturnType;
+        };
+    }
+}
+/**
+ * Math Block Node Extension
+ *
+ * Renders LaTeX formulas using KaTeX.
+ * Provides an editor dialog for editing formulas.
+ */
+declare const MathBlock: Node<MathBlockOptions, any>;
+
+interface TocNodeAttrs {
+    /**
+     * Minimum heading level to include (1-6)
+     * @default 1
+     */
+    minLevel: number;
+    /**
+     * Maximum heading level to include (1-6)
+     * @default 6
+     */
+    maxLevel: number;
+    /**
+     * Show hierarchical numbering (1, 1.1, 1.1.1)
+     * @default false
+     */
+    numbered: boolean;
+    /**
+     * Visual style variant
+     * @default "default"
+     */
+    style: "default" | "flat" | "compact";
+}
+interface TocOptions {
+    /**
+     * Custom HTML attributes for the ToC wrapper element.
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        tableOfContentsNode: {
+            /**
+             * Insert a table of contents node
+             */
+            insertTableOfContents: () => ReturnType;
+            /**
+             * Update table of contents settings
+             */
+            updateTocSettings: (attrs: Partial<TocNodeAttrs>) => ReturnType;
+        };
+    }
+}
+/**
+ * Table of Contents Node Extension
+ *
+ * Inserts an inline table of contents that automatically updates
+ * based on headings in the document.
+ */
+declare const TocNode: Node<TocOptions, any>;
+
+interface VariableNodeAttrs {
+    /** The variable name/key (e.g., "companyName") */
+    name: string;
+    /** Optional fallback value if variable is not resolved */
+    fallback?: string;
+    /** Optional category for grouping (e.g., "company", "user", "date") */
+    category?: string;
+}
+interface VariableOptions {
+    /**
+     * HTML attributes to add to the variable element.
+     */
+    HTMLAttributes: Record<string, unknown>;
+}
+declare module "@tiptap/core" {
+    interface Commands<ReturnType> {
+        variable: {
+            /**
+             * Insert a variable node
+             */
+            insertVariable: (attrs: VariableNodeAttrs) => ReturnType;
+        };
+    }
+}
+/**
+ * VariableNode Extension
+ *
+ * Allows inserting template variables like {{companyName}} into documents.
+ * Variables are rendered as inline chips and can be resolved when rendering
+ * the final document.
+ *
+ * Triggered by typing `{{` which opens a suggestion menu.
+ */
+declare const VariableNode: Node<VariableOptions, any>;
+
+interface VariableDefinition {
+    /** The variable key/name */
+    name: string;
+    /** Display label for the variable */
+    label: string;
+    /** Optional description */
+    description?: string;
+    /** Category for grouping */
+    category?: string;
+    /** Default/fallback value */
+    fallback?: string;
+}
+interface VariableSuggestionProps {
+    editor?: Editor | null;
+    /**
+     * List of available variables to suggest
+     */
+    variables: VariableDefinition[];
+}
+/**
+ * Variable Suggestion Menu
+ *
+ * A suggestion popup triggered by typing `{{` that shows available
+ * template variables for insertion.
+ */
+declare function VariableSuggestion({ editor, variables, }: VariableSuggestionProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Extracts all variable nodes from a TipTap document.
+ *
+ * Recursively scans the document content and returns unique variables.
+ *
+ * @param content - The TipTap JSONContent to scan
+ * @returns Array of unique variable definitions found in the document
+ */
+declare function extractVariablesFromContent(content: JSONContent | undefined): VariableDefinition[];
+
+interface VariableContextValue {
+    /** Available variables for template insertion */
+    variables: VariableDefinition[];
+    /** Resolve a variable to its current value */
+    resolveVariable?: (name: string) => string | undefined;
+}
+interface VariableProviderProps {
+    children: React.ReactNode;
+    /**
+     * List of available variables
+     */
+    variables: VariableDefinition[];
+    /**
+     * Optional function to resolve a variable name to its current value.
+     * Used for preview/rendering purposes.
+     */
+    resolveVariable?: (name: string) => string | undefined;
+}
+/**
+ * Provider for template variables
+ *
+ * Wrap your editor with this provider to make variables available
+ * for the suggestion menu and variable panel.
+ *
+ * @example
+ * ```tsx
+ * const variables = [
+ *   { name: 'companyName', label: 'Company Name', category: 'Company' },
+ *   { name: 'userName', label: 'User Name', category: 'User' },
+ * ];
+ *
+ * <VariableProvider variables={variables}>
+ *   <Editor />
+ * </VariableProvider>
+ * ```
+ */
+declare function VariableProvider({ children, variables, resolveVariable, }: VariableProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access variable context
+ *
+ * Returns null if used outside of VariableProvider
+ */
+declare function useVariables(): VariableContextValue | null;
+/**
+ * Hook to access variables with fallback
+ *
+ * @param fallbackVariables - Variables to use if no provider is present
+ */
+declare function useVariablesWithFallback(fallbackVariables?: VariableDefinition[]): VariableDefinition[];
+
+interface VariableFillerDialogProps {
+    /**
+     * Whether the dialog is open
+     */
+    open: boolean;
+    /**
+     * Callback when the dialog open state changes
+     */
+    onOpenChange: (open: boolean) => void;
+    /**
+     * Available variables to fill
+     */
+    variables: VariableDefinition[];
+    /**
+     * Current variable values
+     */
+    values: Record<string, string>;
+    /**
+     * Callback when variables are saved
+     */
+    onSave: (values: Record<string, string>) => void;
+    /**
+     * Dialog title
+     */
+    title?: string;
+    /**
+     * Dialog description
+     */
+    description?: string;
+}
+/**
+ * A dialog for filling in template variables
+ *
+ * Shows all available variables grouped by category with input fields.
+ * User can fill in values and save.
+ */
+declare function VariableFillerDialog({ open, onOpenChange, variables, values, onSave, title, description, }: VariableFillerDialogProps): react_jsx_runtime.JSX.Element;
+
+type GetExtensionsOptions = {
+    editable?: boolean;
+    placeholder?: string;
+    /**
+     * Enable the control block feature (experimental).
+     * @default false
+     */
+    enableControls?: boolean;
+    /**
+     * Resolver for control lookups. Only used when `enableControls` is true.
+     */
+    controlResolver?: ControlResolver;
+    /**
+     * File handler for image uploads. When provided, enables:
+     * - Drag & drop images
+     * - Paste images
+     * - Image display with URL resolution
+     */
+    fileHandler?: EditorFileHandler | null;
+    /**
+     * Enable template variables (e.g., {{companyName}}).
+     * Variables can be inserted by typing `{{`.
+     * @default false
+     */
+    enableVariables?: boolean;
+    /**
+     * Enable page pagination (A4-like document layout with page breaks).
+     * When provided, the Pages extension is configured with these options.
+     */
+    pagesOptions?: Partial<PagesOptions>;
+    /**
+     * Collaboration context from CollaborationProvider.
+     * When provided, enables real-time collaborative editing with Yjs.
+     * Automatically replaces History with Yjs undo manager.
+     * @internal — set automatically by useCreateEditor, not by consumers.
+     */
+    collaboration?: CollaborationState | null;
+    /**
+     * Additional custom extensions to append after the built-in ones.
+     * Combine with `disabled` to replace built-in extensions with custom ones.
+     */
+    customExtensions?: Extensions;
+    /**
+     * Disable specific built-in extensions by name.
+     *
+     * All built-in extensions are **enabled by default**. Set an extension's
+     * TipTap name to `false` to exclude it from the editor. Omitted keys
+     * (or `undefined`) keep the extension active.
+     *
+     * Built-in extension names:
+     * - Core: `starterKit`, `textAlign`, `selection`, `trailingNode`,
+     *   `uniqueId`, `uiState`, `placeholder`, `characterCount`, `typography`
+     * - Lists: `taskList`, `taskItem`
+     * - Text: `textStyleKit`, `highlight`, `superscript`, `subscript`, `link`
+     * - Code: `codeKit`
+     * - Table: `tableKit`
+     * - Blocks: `tableOfContents`, `tableOfContentsNode`, `calloutNode`,
+     *   `mathBlock`, `inlineMath`, `invisibleCharacters`
+     * - Images: `image`, `imageUpload`
+     *
+     * @example
+     * ```ts
+     * // Replace the built-in table with a custom one
+     * getExtensions({
+     *   disabled: { tableKit: false },
+     *   customExtensions: [MyCustomTable],
+     * })
+     * ```
+     */
+    disabled?: Record<string, false>;
+};
+/**
+ * getExtensions returns all kopexa used extensions for our editor.
+ * this export is important, and should be used in every editor instance even
+ * the collaborative one, to ensure that all extensions are registered correctly.
+ */
+declare function getExtensions({ editable, placeholder, enableControls, controlResolver, fileHandler, enableVariables, pagesOptions, collaboration, customExtensions, disabled, }: GetExtensionsOptions): Extensions;
+
+/**
+ * Tracks the current document visibility state ('visible' | 'hidden').
+ * Uses useSyncExternalStore for tear-free reads.
+ */
+declare function useDocumentVisibility(): DocumentVisibilityState;
+
+interface UseIdleOptions {
+    /** Start as idle. @default false */
+    initialState?: boolean;
+}
+interface UseIdleReturn {
+    /** Whether the user is currently idle. */
+    isIdle: boolean;
+    /** Reset the idle timer manually (e.g., on reconnect). */
+    resetIdle: () => void;
+}
+/**
+ * Tracks user idle state based on input activity.
+ * All event listeners are passive for zero scroll-blocking overhead.
+ *
+ * @param timeout Milliseconds of inactivity before considered idle.
+ * @param options Configuration options.
+ */
+declare function useIdle(timeout: number, options?: UseIdleOptions): UseIdleReturn;
+
+type BasicEditorProps = GetExtensionsOptions & EditorBasicVariants & {
+    content?: Content | undefined;
+    onChange?: (content: JSONContent$1) => void;
+    /**
+     * This Editor wraps react-intl, if no provider is found in
+     * the parent tree, we provide our own <IntlProvider /> with
+     * @default en
+     */
+    locale?: string;
+    /**
+     * Available template variables.
+     * When provided, enables variable insertion via `{{` trigger.
+     */
+    variables?: VariableDefinition[];
+    /**
+     * Values for template variables.
+     * Maps variable names to their resolved values.
+     */
+    variableValues?: Record<string, string>;
+    /**
+     * Whether to show the toolbar.
+     * @default true
+     */
+    showToolbar?: boolean;
+};
+declare const BasicEditor: ({ variant, bordered, content, variables, variableValues, showToolbar, pagesOptions, ...options }: BasicEditorProps) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Handles image upload with progress tracking and abort capability
+ * @param file The file to upload
+ * @param onProgress Optional callback for tracking upload progress
+ * @param abortSignal Optional AbortSignal for cancelling the upload
+ * @returns Promise resolving to the URL of the uploaded image
+ */
+declare const handleImageUpload: (file: File, onProgress?: (event: {
+    progress: number;
+}) => void, abortSignal?: AbortSignal) => Promise<string>;
+/**
+ * Converts a File to base64 string
+ * @param file The file to convert
+ * @param abortSignal Optional AbortSignal for cancelling the conversion
+ * @returns Promise resolving to the base64 representation of the file
+ */
+declare const convertFileToBase64: (file: File, abortSignal?: AbortSignal) => Promise<string>;
+type ProtocolOptions = {
+    /**
+     * The protocol scheme to be registered.
+     * @default '''
+     * @example 'ftp'
+     * @example 'git'
+     */
+    scheme: string;
+    /**
+     * If enabled, it allows optional slashes after the protocol.
+     * @default false
+     * @example true
+     */
+    optionalSlashes?: boolean;
+};
+type ProtocolConfig = Array<ProtocolOptions | string>;
+declare function isAllowedUri(uri: string | undefined, protocols?: ProtocolConfig): true | RegExpMatchArray | null;
+declare function sanitizeUrl(inputUrl: string, baseUrl: string, protocols?: ProtocolConfig): string;
+
+/**
+ * Generates a deterministic hex color from a string ID.
+ * Uses a simple hash to derive a hue, with fixed saturation (65%)
+ * and lightness (55%) for readable cursor colors on white backgrounds.
+ */
+declare function generateColorFromId(id: string): string;
+
+export { CalloutNode, type CalloutNodeAttrs, type CalloutVariant, type CollabUser, CollaborationProvider, type CollaborationProviderProps, type CollaborationState, type CollaborationStatus, BasicEditor as Editor, type EditorFileHandler, EditorFileProvider, type EditorFileProviderProps, type GetExtensionsOptions, ImageNode, ImageUploadNode, InlineMath, type InlineMathAttrs, MathBlock, type MathBlockAttrs, type ResolvedCollabUser, TocNode, type VariableDefinition, VariableFillerDialog, type VariableFillerDialogProps, VariableNode, type VariableNodeAttrs, type VariableOptions, VariableProvider, type VariableProviderProps, VariableSuggestion, type VariableSuggestionProps, convertFileToBase64, extractVariablesFromContent, generateColorFromId, getExtensions, handleImageUpload, isAllowedUri, sanitizeUrl, useCollaboration, useCollaborationRequired, useDocumentVisibility, useEditorFile, useEditorFileRequired, useIdle, useVariables, useVariablesWithFallback };