tree-widget-react.api.md

API Report File for "@itwin/tree-widget-react"

Do not edit this file. It is a report generated by API Extractor.

/// <reference types="node" />
/// <reference types="react" />

import type { BeEvent } from '@itwin/core-bentley';
import type { ClassGroupingNodeKey } from '@itwin/presentation-hierarchies';
import type { ECClassHierarchyInspector } from '@itwin/presentation-shared';
import type { GroupingHierarchyNode } from '@itwin/presentation-hierarchies';
import type { HierarchyFilteringPath } from '@itwin/presentation-hierarchies';
import type { HierarchyNode } from '@itwin/presentation-hierarchies-react';
import type { Id64Arg } from '@itwin/core-bentley';
import type { Id64Array } from '@itwin/core-bentley';
import type { Id64Set } from '@itwin/core-bentley';
import type { Id64String } from '@itwin/core-bentley';
import type { IDisposable } from '@itwin/core-bentley';
import type { ILogger } from '@itwin/presentation-shared';
import type { IModelConnection } from '@itwin/core-frontend';
import type { InstanceKey } from '@itwin/presentation-shared';
import { JSX as JSX_2 } from 'react/jsx-runtime';
import type { Localization } from '@itwin/core-common';
import type { PresentationHierarchyNode } from '@itwin/presentation-hierarchies-react';
import type { PropsWithChildren } from 'react';
import type { ReactNode } from 'react';
import type { SchemaContext } from '@itwin/ecschema-metadata';
import type { SelectionStorage } from '@itwin/presentation-hierarchies-react';
import type { TranslationOptions } from '@itwin/core-common';
import { TreeRenderer as TreeRenderer_2 } from '@itwin/presentation-hierarchies-react';
import type { useIModelTree } from '@itwin/presentation-hierarchies-react';
import type { useSelectionHandler } from '@itwin/presentation-hierarchies-react';
import type { Viewport } from '@itwin/core-frontend';
import type { Widget } from '@itwin/appui-react';

// @beta (undocumented)
export type BaseTreeRendererProps = React.ComponentPropsWithoutRef<typeof TreeRenderer_2>;

// @public
export const CategoriesTreeComponent: {
    (props: CategoriesTreeComponentProps): JSX_2.Element | null;
    ShowAllButton: CategoriesTreeHeaderButtonType;
    HideAllButton: CategoriesTreeHeaderButtonType;
    InvertAllButton: CategoriesTreeHeaderButtonType;
    id: string;
    getLabel(): string;
};

// @public (undocumented)
interface CategoriesTreeComponentProps extends Pick<CategoriesTreeProps, "getSchemaContext" | "selectionStorage" | "hierarchyLevelConfig" | "selectionMode" | "filter" | "emptyTreeContent" | "getActions" | "getDecorations" | "hierarchyConfig"> {
    headerButtons?: Array<(props: CategoriesTreeHeaderButtonProps) => React.ReactNode>;
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    onPerformanceMeasured?: (featureId: string, duration: number) => void;
}

// @public
interface CategoriesTreeHeaderButtonProps extends TreeToolbarButtonProps {
    categories: CategoryInfo[];
    models: Id64Array;
}

// @public (undocumented)
type CategoriesTreeHeaderButtonType = (props: CategoriesTreeHeaderButtonProps) => React.ReactElement | null;

// @beta
interface CategoriesTreeHierarchyConfiguration {
    hideSubCategories: boolean;
    showElements: boolean;
}

// @beta (undocumented)
export function CategoriesTreeIcon({ node }: {
    node: PresentationHierarchyNode;
}): JSX_2.Element | undefined;

// @beta (undocumented)
type CategoriesTreeProps = Pick<VisibilityTreeProps, "imodel" | "getSchemaContext" | "selectionStorage" | "selectionMode" | "emptyTreeContent"> & Pick<VisibilityTreeRendererProps, "getActions" | "getDecorations"> & UseCategoriesTreeProps & {
    hierarchyLevelConfig?: {
        sizeLimit?: number;
    };
};

// @beta
interface CategoryInfo {
    // (undocumented)
    categoryId: Id64String;
    // (undocumented)
    subCategoryIds?: Id64Array;
}

// @beta (undocumented)
interface ChangeCategoryVisibilityStateProps extends GetCategoryVisibilityStatusProps {
    // (undocumented)
    on: boolean;
}

// @beta (undocumented)
interface ChangeGeometricElementsDisplayStateProps {
    // (undocumented)
    categoryId: Id64String;
    // (undocumented)
    elementIds: Id64Set;
    // (undocumented)
    modelId: Id64String;
    // (undocumented)
    on: boolean;
}

// @beta (undocumented)
interface ChangeModelVisibilityStateProps {
    // (undocumented)
    ids: Id64Arg;
    // (undocumented)
    on: boolean;
}

// @beta (undocumented)
type ClassGroupingHierarchyNode = GroupingHierarchyNode & {
    key: ClassGroupingNodeKey;
};

// @public
export function createTreeWidget(props: TreeWidgetProps): Widget;

// @beta (undocumented)
interface ElementsGroupInfo {
    // (undocumented)
    groupingNode: ClassGroupingHierarchyNode;
    // (undocumented)
    parent: {
        ids: Id64String[];
        type: "element";
    } | {
        ids: Id64String[];
        modelIds: Id64String[];
        type: "category";
    };
}

// @beta
export const ExternalSourcesTreeComponent: {
    ({ onFeatureUsed, onPerformanceMeasured, ...props }: ExternalSourcesTreeComponentProps): JSX_2.Element | null;
    id: string;
    getLabel(): string;
};

// @beta (undocumented)
interface ExternalSourcesTreeComponentProps extends Pick<ExternalSourcesTreeProps, "getSchemaContext" | "selectionStorage" | "selectionMode" | "hierarchyLevelConfig" | "selectionMode" | "emptyTreeContent" | "getActions" | "getDecorations"> {
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    onPerformanceMeasured?: (featureId: string, duration: number) => void;
}

// @beta (undocumented)
export function ExternalSourcesTreeIcon({ node }: {
    node: PresentationHierarchyNode;
}): JSX_2.Element | undefined;

// @beta (undocumented)
type ExternalSourcesTreeProps = Pick<TreeProps, "imodel" | "getSchemaContext" | "selectionStorage" | "selectionMode" | "emptyTreeContent"> & Pick<BaseTreeRendererProps, "getActions" | "getDecorations"> & {
    hierarchyLevelConfig?: {
        sizeLimit?: number;
    };
};

// @beta
export class FilterLimitExceededError extends Error {
    constructor(limit: number);
    // (undocumented)
    readonly limit: number;
}

// @public (undocumented)
interface FocusedInstancesContext {
    enabled: boolean;
    loadFocusedItems?: () => AsyncIterableIterator<InstanceKey | GroupingHierarchyNode>;
    toggle: () => void;
}

// @public
export function FocusedInstancesContextProvider({ selectionStorage, imodelKey, children, }: PropsWithChildren<{
    selectionStorage: SelectionStorage;
    imodelKey: string;
}>): JSX_2.Element;

// @beta (undocumented)
type FunctionProps<THook extends (props: any) => any> = Parameters<THook>[0];

// @beta (undocumented)
interface GetCategoryVisibilityStatusProps {
    // (undocumented)
    categoryIds: Id64Arg;
    // (undocumented)
    modelId: Id64String;
    // (undocumented)
    parentElementIds?: Id64Arg;
}

// @beta (undocumented)
interface GetGeometricElementVisibilityStatusProps {
    // (undocumented)
    categoryId: Id64String;
    // (undocumented)
    elementId: Id64String;
    // (undocumented)
    modelId: Id64String;
}

// @beta
export interface HierarchyVisibilityHandler extends IDisposable {
    changeVisibility(node: HierarchyNode, on: boolean): Promise<void>;
    getVisibilityStatus(node: HierarchyNode): Promise<VisibilityStatus> | VisibilityStatus;
    readonly onVisibilityChange: BeEvent<() => void>;
}

// @beta
type HierarchyVisibilityHandlerOverridableMethod<TFunc> = TFunc extends (...args: any[]) => infer TResult ? (props: HierarchyVisibilityHandlerOverridableMethodProps<TFunc>) => TResult : never;

// @beta
type HierarchyVisibilityHandlerOverridableMethodProps<TFunc> = TFunc extends (props: infer TProps) => infer TResult ? TProps & {
    readonly originalImplementation: () => TResult;
    readonly handler: HierarchyVisibilityHandler;
} : never;

// @beta (undocumented)
interface HighlightInfo {
    // (undocumented)
    text: string;
}

// @beta
export const IModelContentTreeComponent: {
    ({ onFeatureUsed, onPerformanceMeasured, ...props }: IModelContentTreeComponentProps): JSX_2.Element | null;
    id: string;
    getLabel(): string;
};

// @beta (undocumented)
interface IModelContentTreeComponentProps extends Pick<IModelContentTreeProps, "getSchemaContext" | "selectionStorage" | "hierarchyConfig" | "hierarchyLevelConfig" | "selectionMode" | "emptyTreeContent" | "getActions" | "getDecorations"> {
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    onPerformanceMeasured?: (featureId: string, duration: number) => void;
}

// @beta
interface IModelContentTreeHierarchyConfiguration {
    hideRootSubject: boolean;
}

// @beta (undocumented)
export function IModelContentTreeIcon({ node }: {
    node: PresentationHierarchyNode;
}): JSX_2.Element | undefined;

// @beta (undocumented)
type IModelContentTreeProps = Pick<TreeProps, "imodel" | "getSchemaContext" | "selectionStorage" | "selectionMode" | "emptyTreeContent"> & Pick<BaseTreeRendererProps, "getActions" | "getDecorations"> & {
    hierarchyLevelConfig?: {
        sizeLimit?: number;
    };
    hierarchyConfig?: Partial<IModelContentTreeHierarchyConfiguration>;
};

// @public
interface ModelInfo {
    // (undocumented)
    id: string;
    // (undocumented)
    isPlanProjection?: boolean;
}

// @public
export const ModelsTreeComponent: {
    (props: ModelsTreeComponentProps): JSX_2.Element | null;
    ShowAllButton: ModelsTreeHeaderButtonType;
    HideAllButton: ModelsTreeHeaderButtonType;
    InvertButton: ModelsTreeHeaderButtonType;
    View2DButton: ModelsTreeHeaderButtonType;
    View3DButton: ModelsTreeHeaderButtonType;
    ToggleInstancesFocusButton: ModelsTreeHeaderButtonType;
    id: string;
    getLabel(): string;
};

// @public (undocumented)
interface ModelsTreeComponentProps extends Pick<ModelsTreeProps, "getSchemaContext" | "selectionStorage" | "hierarchyLevelConfig" | "selectionMode" | "selectionPredicate" | "hierarchyConfig" | "visibilityHandlerOverrides" | "getFilteredPaths" | "filter" | "emptyTreeContent" | "getActions" | "getDecorations"> {
    headerButtons?: Array<(props: ModelsTreeHeaderButtonProps) => React.ReactNode>;
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    onPerformanceMeasured?: (featureId: string, duration: number) => void;
}

// @public
interface ModelsTreeHeaderButtonProps extends TreeToolbarButtonProps {
    models: ModelInfo[];
}

// @public (undocumented)
type ModelsTreeHeaderButtonType = (props: ModelsTreeHeaderButtonProps) => React.ReactElement | null;

// @beta
interface ModelsTreeHierarchyConfiguration {
    elementClassGrouping: "enable" | "enableWithCounts" | "disable";
    elementClassSpecification: string;
    hideRootSubject: boolean;
    hierarchyLevelFiltering: "enable" | "disable";
    showEmptyModels: boolean;
}

// @beta (undocumented)
export function ModelsTreeIcon({ node }: {
    node: PresentationHierarchyNode;
}): JSX_2.Element | undefined;

// @beta (undocumented)
type ModelsTreeProps = Pick<VisibilityTreeProps, "imodel" | "getSchemaContext" | "selectionStorage" | "selectionMode" | "emptyTreeContent"> & Pick<VisibilityTreeRendererProps, "getActions" | "getDecorations"> & UseModelsTreeProps & {
    hierarchyLevelConfig?: {
        sizeLimit?: number;
    };
};

// @beta
export interface ModelsTreeVisibilityHandlerOverrides {
    // (undocumented)
    changeCategoryState?: HierarchyVisibilityHandlerOverridableMethod<(props: ChangeCategoryVisibilityStateProps) => Promise<void>>;
    // (undocumented)
    changeElementGroupingNodeState?: HierarchyVisibilityHandlerOverridableMethod<(props: {
        node: GroupingHierarchyNode;
        on: boolean;
    }) => Promise<void>>;
    // (undocumented)
    changeElementsState?: HierarchyVisibilityHandlerOverridableMethod<(props: ChangeGeometricElementsDisplayStateProps) => Promise<void>>;
    // (undocumented)
    changeModelState?: HierarchyVisibilityHandlerOverridableMethod<(props: ChangeModelVisibilityStateProps) => Promise<void>>;
    // (undocumented)
    changeSubjectNodeState?: HierarchyVisibilityHandlerOverridableMethod<(props: {
        ids: Id64Array;
        on: boolean;
    }) => Promise<void>>;
    // (undocumented)
    getCategoryDisplayStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: GetCategoryVisibilityStatusProps) => Promise<VisibilityStatus>>;
    // (undocumented)
    getElementDisplayStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: GetGeometricElementVisibilityStatusProps) => Promise<VisibilityStatus>>;
    // (undocumented)
    getElementGroupingNodeDisplayStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
        node: GroupingHierarchyNode;
    }) => Promise<VisibilityStatus>>;
    // (undocumented)
    getModelDisplayStatus?: HierarchyVisibilityHandlerOverridableMethod<(props: {
        ids: Id64Arg;
    }) => Promise<VisibilityStatus>>;
    // (undocumented)
    getSubjectNodeVisibility?: HierarchyVisibilityHandlerOverridableMethod<(props: {
        ids: Id64Array;
    }) => Promise<VisibilityStatus>>;
}

// @beta (undocumented)
export function SelectableTree({ buttons, children }: PropsWithChildren<TreehHeaderProps>): JSX_2.Element;

// @beta (undocumented)
export function TelemetryContextProvider({ children, onPerformanceMeasured, onFeatureUsed, componentIdentifier, }: PropsWithChildren<TelemetryContextProviderProps>): JSX_2.Element;

// @beta (undocumented)
interface TelemetryContextProviderProps {
    componentIdentifier: string;
    onFeatureUsed?: (featureId: string) => void;
    onPerformanceMeasured?: (featureId: string, duration: number) => void;
}

// @beta
export function Tree({ getSchemaContext, hierarchyLevelSizeLimit, selectionStorage, imodelAccess: providedIModelAccess, ...props }: TreeProps): JSX_2.Element;

// @public
export interface TreeDefinition {
    getLabel: () => string;
    id: string;
    isSearchable?: boolean;
    render: (props: TreeRenderProps) => React.ReactNode;
    shouldShow?: (imodel: IModelConnection) => Promise<boolean>;
    startIcon?: React.ReactNode;
}

// @beta (undocumented)
interface TreehHeaderProps {
    // (undocumented)
    buttons?: ReactNode;
}

// @beta (undocumented)
interface TreeItemVisibilityButtonProps {
    getVisibilityButtonState: (node: PresentationHierarchyNode) => TreeItemVisibilityButtonState;
    onVisibilityButtonClick: (node: PresentationHierarchyNode, state: TreeItemVisibilityButtonState["state"]) => void;
}

// @beta
interface TreeItemVisibilityButtonState {
    // (undocumented)
    isDisabled?: boolean;
    // (undocumented)
    state: "visible" | "partial" | "hidden";
    // (undocumented)
    tooltip?: string;
}

// @beta (undocumented)
type TreeProps = Pick<FunctionProps<typeof useIModelTree>, "getFilteredPaths" | "getHierarchyDefinition"> & Partial<Pick<FunctionProps<typeof useSelectionHandler>, "selectionMode">> & {
    imodel: IModelConnection;
    getSchemaContext: (imodel: IModelConnection) => SchemaContext;
    treeName: string;
    selectionStorage: SelectionStorage;
    selectionPredicate?: (node: PresentationHierarchyNode) => boolean;
    treeRenderer: (treeProps: Required<Pick<BaseTreeRendererProps, "rootNodes" | "reloadTree" | "expandNode" | "getLabel" | "onFilterClick" | "selectNodes" | "selectionMode" | "isNodeSelected" | "getHierarchyLevelDetails" | "getLabel">>) => ReactNode;
    imodelAccess?: FunctionProps<typeof useIModelTree>["imodelAccess"];
    hierarchyLevelSizeLimit?: number;
    emptyTreeContent?: ReactNode;
    onReload?: () => void;
    highlight?: HighlightInfo;
};

// @beta
export function TreeRenderer({ getActions, getHierarchyLevelDetails, onFilterClick, ...props }: BaseTreeRendererProps): JSX_2.Element;

// @public
interface TreeRenderProps {
    // (undocumented)
    filter?: string;
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    onPerformanceMeasured?: (featureId: string, elapsedTime: number) => void;
}

// @public (undocumented)
interface TreeToolbarButtonProps {
    // (undocumented)
    onFeatureUsed?: (feature: string) => void;
    // (undocumented)
    viewport: Viewport;
}

// @public
export class TreeWidget {
    static get i18n(): Localization;
    static get i18nNamespace(): string;
    static initialize(i18n?: Localization, logger?: ILogger): Promise<void>;
    static get logger(): ILogger;
    static terminate(): void;
    static translate(key: string | string[], options?: TranslationOptions): string;
}

// @public
export function TreeWidgetComponent(props: TreeWidgetProps): JSX_2.Element;

// @public
interface TreeWidgetProps {
    onFeatureUsed?: (feature: string) => void;
    onPerformanceMeasured?: (feature: string, elapsedTime: number) => void;
    trees: TreeDefinition[];
}

// @beta
export function useCategoriesTree({ filter, activeView, onCategoriesFiltered, emptyTreeContent, hierarchyConfig, }: UseCategoriesTreeProps): UseCategoriesTreeResult;

// @public
export function useCategoriesTreeButtonProps({ viewport }: {
    viewport: Viewport;
}): {
    buttonProps: Pick<CategoriesTreeHeaderButtonProps, "categories" | "viewport" | "models">;
    onCategoriesFiltered: (props: {
        categories: CategoryInfo[] | undefined;
        models?: Id64Array;
    }) => void;
};

// @beta (undocumented)
interface UseCategoriesTreeProps {
    // (undocumented)
    activeView: Viewport;
    // (undocumented)
    emptyTreeContent?: ReactNode;
    // (undocumented)
    filter?: string;
    // (undocumented)
    hierarchyConfig?: Partial<CategoriesTreeHierarchyConfiguration>;
    // (undocumented)
    onCategoriesFiltered?: (props: {
        categories: CategoryInfo[] | undefined;
        models?: Id64Array;
    }) => void;
}

// @beta (undocumented)
interface UseCategoriesTreeResult {
    // (undocumented)
    categoriesTreeProps: Pick<VisibilityTreeProps, "treeName" | "getHierarchyDefinition" | "getFilteredPaths" | "visibilityHandlerFactory" | "highlight" | "emptyTreeContent">;
    // (undocumented)
    rendererProps: Required<Pick<VisibilityTreeRendererProps, "getDecorations" | "getSublabel">>;
}

// @public
export function useFocusedInstancesContext(): FocusedInstancesContext;

// @beta
export function useModelsTree({ activeView, filter, hierarchyConfig, visibilityHandlerOverrides, getFilteredPaths, onModelsFiltered, selectionPredicate: nodeTypeSelectionPredicate, emptyTreeContent, }: UseModelsTreeProps): UseModelsTreeResult;

// @public
export function useModelsTreeButtonProps({ imodel, viewport }: {
    imodel: IModelConnection;
    viewport: Viewport;
}): {
    buttonProps: Pick<ModelsTreeHeaderButtonProps, "models" | "viewport">;
    onModelsFiltered: (models: Id64String[] | undefined) => void;
};

// @beta (undocumented)
interface UseModelsTreeProps {
    // (undocumented)
    activeView: Viewport;
    // (undocumented)
    emptyTreeContent?: ReactNode;
    // (undocumented)
    filter?: string;
    // (undocumented)
    getFilteredPaths?: (props: {
        createInstanceKeyPaths: (props: {
            targetItems: Array<InstanceKey | ElementsGroupInfo>;
        } | {
            label: string;
        }) => Promise<HierarchyFilteringPath[]>;
    }) => Promise<HierarchyFilteringPath[]>;
    // (undocumented)
    hierarchyConfig?: Partial<ModelsTreeHierarchyConfiguration>;
    // (undocumented)
    onModelsFiltered?: (modelIds: Id64String[] | undefined) => void;
    selectionPredicate?: (props: {
        node: PresentationHierarchyNode;
        type: "subject" | "model" | "category" | "element" | "elements-class-group";
    }) => boolean;
    // (undocumented)
    visibilityHandlerOverrides?: ModelsTreeVisibilityHandlerOverrides;
}

// @beta (undocumented)
interface UseModelsTreeResult {
    // (undocumented)
    modelsTreeProps: Pick<VisibilityTreeProps, "treeName" | "getHierarchyDefinition" | "getFilteredPaths" | "visibilityHandlerFactory" | "highlight" | "emptyTreeContent" | "selectionPredicate">;
    // (undocumented)
    rendererProps: Required<Pick<VisibilityTreeRendererProps, "getDecorations">>;
}

// @beta
export interface VisibilityStatus {
    isDisabled?: boolean;
    state: "visible" | "partial" | "hidden";
}

// @beta
export function VisibilityTree({ visibilityHandlerFactory, treeRenderer, hierarchyLevelSizeLimit, ...props }: VisibilityTreeProps): JSX_2.Element;

// @beta (undocumented)
type VisibilityTreeProps = Omit<TreeProps, "treeRenderer" | "imodelAccess"> & {
    visibilityHandlerFactory: (props: {
        imodelAccess: ECClassHierarchyInspector;
    }) => HierarchyVisibilityHandler;
    treeRenderer: (treeProps: FunctionProps<TreeProps["treeRenderer"]> & Pick<VisibilityTreeRendererProps, "getVisibilityButtonState" | "onVisibilityButtonClick">) => ReactNode;
};

// @beta
export function VisibilityTreeRenderer({ getVisibilityButtonState, onVisibilityButtonClick: onClick, getActions, onFilterClick, getHierarchyLevelDetails, ...props }: VisibilityTreeRendererProps): JSX_2.Element;

// @beta (undocumented)
type VisibilityTreeRendererProps = BaseTreeRendererProps & TreeItemVisibilityButtonProps;

// (No @packageDocumentation comment for this package)