Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.activeviam.com/llms.txt

Use this file to discover all available pages before exploring further.

​
useActivePageKeyFromUrl

Hook returning the active dashboard page key from the URL, if any. Defaults to the first page specified in the dashboard state. 
useActivePageKeyFromUrl();
Returns: string | undefined

​
useActivity

React hook returning:
  • the value for the given activity key
  • a function to update this value
  • whether the activity is loading 
useActivity(key);
ArgumentTypeDescription
keyT
Returns: [Activity[T] | null, (value: Activity[T]) => void, { isLoading: boolean; }]

​
useAtotiClient

React hook returning the AtotiClient at serverKey. 
useAtotiClient(serverKey);
ArgumentTypeDescription
serverKeystring | undefined
Returns: AtotiClient | undefined Throws: ClientsNotFoundError when no clients are provided via ClientsProvider. AtotiClientNotFoundError when serverKey is defined but no AtotiClient is provided for this key via ClientsProvider.

​
useAtotiClients

React hook returning the map of all registered AtotiClients. 
useAtotiClients();
Returns: { [serverKey: string]: AtotiClient; }

​
useConnectionStatuses

React hook returning the overall status of the connection with the registered Atoti clients. 
useConnectionStatuses();
Returns: { [serverKey: string]: ConnectionStatus; }

​
useContentClient

React hook returning the ContentClient. 
useContentClient(options);
ArgumentTypeDescription
options{
   throwIfMissing: boolean;
}
Returns: ContentClient<Settings> | undefined Throws: ClientsNotFoundError when no clients are provided via ClientsProvider, unless throwIfMissing is set to false. ContentClientNotFoundError when no ContentClient is provided via ClientsProvider, unless throwIfMissing is set to false.

​
useCube

React hook returning a cube. Defaults serverKey to the key of the first provided server, when props.widgetState.serverKey is not defined. Defaults cube to the first cube of the target server, when props.widgetState.query.mdx does not include a cube name and no widgetState.initialCubeName is defined. 
useCube(widgetState);
ArgumentTypeDescription
widgetStateT
Returns: { cube: Cube; dataModel: DataModel; serverKey: string; } Throws:

​
useDataModel

React hook returning the DataModel of the Atoti server identified by serverKey. 
useDataModel(serverKey);
ArgumentTypeDescription
serverKeystring | undefined
Returns: DataModel | undefined Throws: DataModelNotFoundError when serverKey is defined but the data model could not be found.

​
useDataModels

React hook returning the data models of all Atoti servers to which the client is connected. When includeLoadingAndErroredDataModels is true, also includes unreachable servers as errored. 
useDataModels(options);
If “options.includeLoadingAndErroredDataModels” is set to false, only the successfully loaded data models will be returned.
ArgumentTypeDescription
options{
   includeLoadingAndErroredDataModels: true;
}
Returns: DataModels<true>

​
useIsModalMounted

Hook returning whether a modal should be mounted/unmounted depending on whether it is visible. It allows to reset the state of a Modal declaratively, without losing Ant Design’s close animation. See https://github.com/activeviam/atoti-ui/pull/1465\#issuecomment-862306468. 
useIsModalMounted(isModalVisible);
ArgumentTypeDescription
isModalVisibleboolean
Returns: boolean For example: 
const ModalParent = () => {
  const [isModalVisible, setIsModalVisible] = useState(false);
  const isModalMounted = useIsModalMounted(isModalVisible);
  const handleModalClosed = () => {setIsModalVisible(false);};
  return isModalMounted &&
     <Modal
         isVisible={isModalVisible}
         onSubmit={handleModalClosed}
         onCancel={handleModalClosed}
      >
         <ModalChildren />
     </Modal>
}

​
useIsPresenting

React hook returning the current state of isPresenting. 
useIsPresenting();
Returns: boolean

​
useJwt

React hook returning the JWT allowing to authenticate the communication with the servers. 
useJwt();
Returns: string

​
useLogout

React hook returning a callback to logout the user. 
useLogout();
Returns: (() => Promise<void>) | null

​
useMenuItemCreateFolder

React hook returning a menu item to create a folder. 
useMenuItemCreateFolder(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemDeleteFilesAndFolders

React hook returning a menu item to delete several files and folders. 
useMenuItemDeleteFilesAndFolders(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemExportFilesAndFolders

React hook returning a menu item to export the content of a file, a folder or a combination of files and folders. 
useMenuItemExportFilesAndFolders(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemImportFilesAndFolders

React hook returning a menu item to import a file, a folder, or a combination of files and folders into another folder. 
useMenuItemImportFilesAndFolders(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemMakeCopyOfFile

React hook returning a menu item to make a copy of a file. 
useMenuItemMakeCopyOfFile(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemMoveFilesAndFolders

React hook returning a menu item to move files and folders into a folder. 
useMenuItemMoveFilesAndFolders({
  onAfterSubmit,
  selectedFilesAndFolders: selectedFilesAndFoldersOrServer,
  pathToParentFolder,
  contentTree,
  contentType,
});
ArgumentTypeDescription
{
   onAfterSubmit,
   selectedFilesAndFolders: selectedFilesAndFoldersOrServer,
   pathToParentFolder,
   contentTree,
   contentType,
}		FileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemRenameFileOrFolder

React hook returning a menu item to rename a folder or a file. 
useMenuItemRenameFileOrFolder(props);
ArgumentTypeDescription
propsFileListMenuItemProps
Returns: MenuItemType | null

​
useMenuItemShareFileOrFolder

React hook returning a menu item to edit permissions for the underlying file or folder. 
useMenuItemShareFileOrFolder({
  selectedFilesAndFolders,
  pathToParentFolder,
  contentType,
});
ArgumentTypeDescription
{
   selectedFilesAndFolders,
   pathToParentFolder,
   contentType,
}		FileListMenuItemProps
Returns: MenuItemType | null

​
useModal

React hook returning functions to open a modal, and close the active modal. The functions are provided by a ModalsProvider. Note: in most cases, you do not need this API, and you can use a regular declarative <Modal />. This imperative API is useful when the modal lifecycle needs to be decoupled from that of its trigger, for example when opening a modal through a context menu item. 
useModal();
Returns: { openModal: { <PropsType extends object>(modalKey: string, initialProps: PropsType): void; (modalKey: string): void; }; closeModal: () => void; }

​
useOnDataModelClicked

React hook accepting a listener on data model tree clicks. Calls this listener each time a node is clicked in the data model tree. 
useOnDataModelClicked(listener);
ArgumentTypeDescription
listenerDataModelClickListener
Returns: void

​
useOnDataModelNodeClickedForDataVisualizationWidget

React hook allowing to add fields onto a data visualization widget. To be used on a WidgetPlugin. 
useOnDataModelNodeClickedForDataVisualizationWidget(widgetState);
ArgumentTypeDescription
widgetStateWidgetState
Returns: (node: DataModelNode) => WidgetState

​
usePermission

React hook returning:
  • the permission value for the given key
  • a function to update this permission when authenticated as a user with admin privileges
  • an object indicating whether the permissions are loading and whether the permission has explicitly been set 
usePermission(key);
ArgumentTypeDescription
keyT
Returns: [ Permissions[T], (value: Permissions[T]) => Promise<void>, { isLoading: boolean; isSet: boolean; } ]

​
usePersisted

React hook returning the value for the key in the browser local storage and the function to update it. 
usePersisted(key, initialValue);
ArgumentTypeDescription
keystring
initialValueT
Returns: [T | undefined, (newValue: T) => void]

​
usePositionInDashboard

Returns the PositionInDashboard of the widget in the dashboard. 
usePositionInDashboard();
Returns: PositionInDashboard | null

​
useQuery

React hook returning the up-to-date Query corresponding to queryId. 
useQuery({
  serverKey,
  queryId,
});
ArgumentTypeDescription
{
   serverKey,
   queryId,
}		{
   serverKey?: string;
   queryId?: string;
}
Returns: Query<MdxString> | undefined

​
useQueryResult

React hook allowing to subscribe to a query’s result. If query is provided, also runs the query. serverKey identifies which server to run the query against. queryId identifies the query. query is the MDX that indicates which data to retrieve from Atoti Server. This data is displayed in the widget. 
useQueryResult({
  serverKey,
  queryId,
  query,
});
ArgumentTypeDescription
{
   serverKey,
   queryId,
   query,
}		{
   serverKey?: string;
   queryId?: string;
   query?: Query<MdxString>;
}
Returns: QueryResult<ResultType> Remarks: If queryId is not provided, the subscription is canceled and an empty result is returned.

​
useRequestInit

Returns the requestInit from the React context. 
useRequestInit();
Returns: RequestInit

​
useSetting

React hook returning:
  • the setting value for the given key
  • a function to update this setting
  • an object containing a property for whether the settings are loading
See CoreSettings 
useSetting(key);
ArgumentTypeDescription
keyK
Returns: [ Settings[K], (newValue: Settings[K]) => Promise<void>, { isLoading: boolean; } ]

​
useSwitchedWidgetState

React Hook returning the switched widget state if switched or the original state if not switched. 
useSwitchedWidgetState(widgetState, queryId);
ArgumentTypeDescription
widgetStateWidgetState
queryIdstring
Returns: WidgetState

​
useTheme

React hook returning the Theme. 
useTheme();
Returns: Theme

​
useTree

React hook returning the dashboards or widgets tree. 
useTree(type, options);
ArgumentTypeDescription
typeT
options{
   throwIfContentClientMissing: boolean;
}
Returns: ContentRecord<DashboardMetaData | WidgetMetaData | FilterMetaData> | null Throws: ContentClientNotFoundError when no ContentClient is provided via ClientsProvider, unless throwIfContentClientMissing is set to false.

​
useUser

React hook returning the User. 
useUser(options);
ArgumentTypeDescription
options{
   throwIfMissing: boolean;
}
Returns: User | undefined Throws: UserNotFoundError when no User is provided via UserProvider, unless throwIfMissing is set to false.

​
useUserNames

React hook returning the provided usernames from context. 
useUserNames();
Returns: UserName[] | null

​
useUserRoles

React hook returning the user roles from context. 
useUserRoles();
Returns: UserRole[] | null

​
useWebsocketHeaders

React hook returning the headers to be set on “REGISTER” and “UPDATE” websocket messages. 
useWebsocketHeaders();
Returns: Record<string, string> | undefined

​
useWidgetName

React Hook returning either widgetState.name if defined otherwise returns a translated initial name from the widget plugin. 
useWidgetName(widgetState);
ArgumentTypeDescription
widgetStateAWidgetState
Returns: string

​
useWidgetPluginKeys

React hook returning the keys of all the registered widget plugins. 
useWidgetPluginKeys();
Returns: string[]

​
useWidgetPlugins

React hook returning the widget plugins corresponding to widgetKeys. 
useWidgetPlugins(widgetKeys);
ArgumentTypeDescription
widgetKeysstring[]
Returns: WidgetPlugin[]

​
useWidgetQueryResult

React hook running the widget’s Query, impacted by the user/dashboard/page filters and query contexts, and returning its result. When the widget is in an inactive dashboard page or deferred updates are enabled: - The query is paused if it was in real-time mode. - Updates to the query on the client side are not forwarded to the server. 
useWidgetQueryResult({
  serverKey,
  queryId,
  widgetState,
  dashboardState,
  pageKey,
  cube,
  queryRanges,
  isDeferred,
});
ArgumentTypeDescription
{
   serverKey,
   queryId,
   widgetState,
   dashboardState,
   pageKey,
   cube,
   queryRanges,
   isDeferred,
}		{
   serverKey?: string;
   queryId?: string;
   widgetState: WidgetWithQueryState<MdxType>;
   dashboardState?: DashboardState;
   pageKey?: string;
   cube: Cube;
   queryRanges?: Partial<{
     [axisId in AxisId]: QueryRange;
  }>;
   isDeferred?: boolean;
}
Returns: QueryResult<MdxType extends MdxSelect ? CellSet : DrillthroughResult>