@itwin/presentation-hierarchies 0.1.0

package/lib/esm/hierarchies/HierarchyNode.d.ts

@@ -0,0 +1,337 @@
+import { ConcatenatedValue, InstanceKey, OmitOverUnion, PrimitiveValue } from "@itwin/presentation-shared";
+import { ClassGroupingNodeKey, GroupingNodeKey, HierarchyNodeKey, InstancesNodeKey, LabelGroupingNodeKey, PropertyGroupingNodeKey, PropertyOtherValuesGroupingNodeKey, PropertyValueGroupingNodeKey, PropertyValueRangeGroupingNodeKey, StandardHierarchyNodeKey } from "./HierarchyNodeKey";
+/**
+ * A data structure that represents a single non-grouping hierarchy node.
+ */
+interface BaseHierarchyNode {
+    /** Identifiers of all node ancestors. Can be used to identify a node in the hierarchy. */
+    parentKeys: HierarchyNodeKey[];
+    /** Node's display label. */
+    label: string;
+    /** A flag indicating whether the node has children or not. */
+    children: boolean;
+    /** A flag indicating whether this node should be auto-expanded in the UI. */
+    autoExpand?: boolean;
+    /** Additional data that may be assigned to this node. */
+    extendedData?: {
+        [key: string]: any;
+    };
+}
+/**
+ * A data structure that represents a single non-grouping hierarchy node.
+ * @beta
+ */
+export interface NonGroupingHierarchyNode extends BaseHierarchyNode {
+    /** An identifier to identify the node in its hierarchy level. */
+    key: string | InstancesNodeKey;
+    /**
+     * Identifies whether the hierarchy level below this node supports filtering. If not, supplying an instance
+     * filter when requesting child hierarchy level will have no effect.
+     */
+    supportsFiltering?: boolean;
+}
+/**
+ * A data structure that represents a grouping node that groups other nodes.
+ * @beta
+ */
+export interface GroupingHierarchyNode extends BaseHierarchyNode {
+    /** An identifier to identify this grouping node in its hierarchy level. */
+    key: GroupingNodeKey;
+    /**
+     * Keys of all instances grouped by this node, including deeply nested under
+     * other grouping nodes.
+     */
+    groupedInstanceKeys: InstanceKey[];
+    /** The closest ancestor node that is not a grouping node. May be `undefined` if the grouping node grouped root level nodes. */
+    nonGroupingAncestor?: ParentHierarchyNode<NonGroupingHierarchyNode>;
+}
+/**
+ * A data structure that represents a single hierarchy node.
+ * @beta
+ */
+export type HierarchyNode = NonGroupingHierarchyNode | GroupingHierarchyNode;
+/** @beta */
+export declare namespace HierarchyNode {
+    /** Checks whether the given node is a custom node */
+    function isCustom<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedCustomHierarchyNode : NonGroupingHierarchyNode) & {
+        key: string;
+    };
+    /** Checks whether the given node is a standard (iModel content based) node */
+    function isStandard<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: StandardHierarchyNodeKey;
+    };
+    /** Checks whether the given node is an ECInstances-based node */
+    function isInstancesNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedInstanceHierarchyNode : NonGroupingHierarchyNode) & {
+        key: InstancesNodeKey;
+    };
+    /** Checks whether the given node is a grouping node */
+    function isGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is a class grouping node */
+    function isClassGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: ClassGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is a label grouping node */
+    function isLabelGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: LabelGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is property grouping node for other values  */
+    function isPropertyOtherValuesGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: PropertyOtherValuesGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is a property value grouping node */
+    function isPropertyValueGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: PropertyValueGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is a property value range grouping node */
+    function isPropertyValueRangeGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: PropertyValueRangeGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+    /** Checks whether the given node is a property grouping node */
+    function isPropertyGroupingNode<TNode extends {
+        key: HierarchyNodeKey;
+    }>(node: TNode): node is TNode & {
+        key: PropertyGroupingNodeKey;
+        supportsFiltering?: undefined;
+    } & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode);
+}
+/**
+ * A type of `HierarchyNode` that doesn't know about its children and is an input when requesting
+ * them using `HierarchyProvider.getNodes`.
+ *
+ * @internal
+ */
+export type ParentHierarchyNode<TBase = HierarchyNode> = OmitOverUnion<TBase, "children">;
+/**
+ * Base processing parameters that apply to every node.
+ */
+interface HierarchyNodeProcessingParamsBase {
+    /** Indicates if this node should be hidden if it has no child nodes. */
+    hideIfNoChildren?: boolean;
+    /** Indicates that this node should always be hidden and its children should be loaded in its place. */
+    hideInHierarchy?: boolean;
+}
+/**
+ * A data structure for defining nodes' grouping requirements.
+ */
+interface HierarchyNodeGroupingParams {
+    byLabel?: HierarchyNodeLabelGroupingParams;
+    byClass?: boolean | HierarchyNodeGroupingParamsBase;
+    byBaseClasses?: HierarchyNodeBaseClassGroupingParams;
+    byProperties?: HierarchyNodePropertiesGroupingParams;
+}
+/**
+ * A data structure for defining params specifically used for label grouping.
+ */
+interface HierarchyNodeLabelGroupingBaseParams {
+    /** Label grouping option that determines whether to group nodes or to merge them. Defaults to "group".*/
+    action?: "group" | "merge";
+    /** Value that needs to match in order for nodes to be grouped or merged.*/
+    groupId?: string;
+}
+/**
+ * A data structure for defining label merging.
+ */
+interface HierarchyNodeLabelGroupingMergeParams extends HierarchyNodeLabelGroupingBaseParams {
+    action: "merge";
+}
+/**
+ * A data structure for defining label grouping with additional parameters.
+ */
+interface HierarchyNodeLabelGroupingGroupParams extends HierarchyNodeLabelGroupingBaseParams, HierarchyNodeGroupingParamsBase {
+    action?: "group";
+}
+/**
+ * A data structure for defining possible label grouping types.
+ * @internal
+ */
+export type HierarchyNodeLabelGroupingParams = boolean | HierarchyNodeLabelGroupingMergeParams | HierarchyNodeLabelGroupingGroupParams;
+/**
+ * Grouping parameters that are shared across all types of groupings.
+ * @internal
+ */
+export interface HierarchyNodeGroupingParamsBase {
+    /** Hiding option that determines whether to hide group nodes which have no siblings at the same hierarchy level. */
+    hideIfNoSiblings?: boolean;
+    /** Hiding option that determines whether to hide group nodes which have only one node as its children. */
+    hideIfOneGroupedNode?: boolean;
+    /** Option which auto expands grouping nodes' children when it has single child or always. */
+    autoExpand?: HierarchyNodeAutoExpandProp;
+}
+/**
+ * Defines possible values for `BaseGroupingParams.autoExpand` attribute:
+ * - `single-child` - set the grouping node to auto-expand if it groups a single node.
+ * - `always` - always set the grouping node to auto-expand.
+ *
+ * @internal
+ */
+export type HierarchyNodeAutoExpandProp = "single-child" | "always";
+/**
+ * A data structure that represents base class grouping.
+ */
+interface HierarchyNodeBaseClassGroupingParams extends HierarchyNodeGroupingParamsBase {
+    /**
+     * Full names of classes, which should be used to group the node. Only has effect if the node
+     * represents an instance of that class.
+     *
+     * Full class name format: `SchemaName.ClassName`.
+     */
+    fullClassNames: string[];
+}
+/**
+ * A data structure that represents properties grouping.
+ * @internal
+ */
+export interface HierarchyNodePropertiesGroupingParams extends HierarchyNodeGroupingParamsBase {
+    /**
+     * Full name of a class whose properties are used to group the node. Only has effect if the node
+     * represents an instance of that class.
+     *
+     * Full class name format: `SchemaName.ClassName`.
+     */
+    propertiesClassName: string;
+    /**
+     * Property grouping option that determines whether to group nodes whose grouping value is not set or is set to an empty string.
+     *
+     * Label of the created grouping node will be `Not Specified`.
+     */
+    createGroupForUnspecifiedValues?: boolean;
+    /**
+     * Property grouping option that determines whether to group nodes whose grouping value doesn't fit within any of the provided
+     * ranges, or is not a numeric value.
+     *
+     * Label of the created grouping node will be `Other`.
+     */
+    createGroupForOutOfRangeValues?: boolean;
+    /**
+     * Properties of the specified class, by which the nodes should be grouped. Each provided group definition results in a
+     * grouping hierarchy level.
+     *
+     * Example usage:
+     * ```ts
+     * propertyGroups: [
+     *   {
+     *     propertyName: "type",
+     *     propertyValue: "Wall"
+     *   },
+     *   {
+     *     propertyName: "length",
+     *     propertyValue: 15,
+     *     ranges: [
+     *       { fromValue: 1, toValue: 10, rangeLabel: "Small" },
+     *       { fromValue: 11, toValue: 20, rangeLabel: "Medium" }
+     *     ]
+     *   },
+     * ]
+     * ```
+     */
+    propertyGroups: HierarchyNodePropertyGroup[];
+}
+/**
+ * A data structure that represents specific properties' grouping params.
+ * @internal
+ */
+export interface HierarchyNodePropertyGroup {
+    /** A string indicating the name of the property to group by. */
+    propertyName: string;
+    /**  Value of the property, which will be used to group the node. */
+    propertyValue?: PrimitiveValue;
+    /** Ranges are used to group nodes by numeric properties which are within specified bounds. */
+    ranges?: HierarchyNodePropertyValueRange[];
+}
+/**
+ * A data structure that represents boundaries for a value.
+ * @internal
+ */
+export interface HierarchyNodePropertyValueRange {
+    /** Defines the lower bound of the range. */
+    fromValue: number;
+    /** Defines the upper bound of the range. */
+    toValue: number;
+    /** Defines the range label. Will be used as `PropertyValueRangeGroupingNode` node's display label. */
+    rangeLabel?: string;
+}
+/**
+ * Processing parameters that apply to instance nodes.
+ * @internal
+ */
+export interface InstanceHierarchyNodeProcessingParams extends HierarchyNodeProcessingParamsBase {
+    grouping?: HierarchyNodeGroupingParams;
+}
+/**
+ * A custom (not based on data in an iModel) node that has processing parameters.
+ * @internal
+ */
+export type ProcessedCustomHierarchyNode = Omit<NonGroupingHierarchyNode, "key" | "children"> & {
+    key: string;
+    children?: boolean;
+    processingParams?: HierarchyNodeProcessingParamsBase;
+};
+/**
+ * An instances' (based on data in an iModel) node that has processing parameters.
+ * @internal
+ */
+export type ProcessedInstanceHierarchyNode = Omit<NonGroupingHierarchyNode, "key" | "children"> & {
+    key: InstancesNodeKey;
+    children?: boolean;
+    processingParams?: InstanceHierarchyNodeProcessingParams;
+};
+/**
+ * A grouping node that groups either instance nodes or other grouping nodes.
+ * @internal
+ */
+export type ProcessedGroupingHierarchyNode = Omit<GroupingHierarchyNode, "children"> & {
+    children: Array<ProcessedGroupingHierarchyNode | ProcessedInstanceHierarchyNode>;
+};
+/**
+ * A `HierarchyNode` that may have processing parameters defining whether it should be hidden under some conditions,
+ * how it should be grouped, sorted, etc.
+ *
+ * Type guards under `HierarchyNode` namespace can be used to differentiate between different sub-types of
+ * `ProcessedHierarchyNode`.
+ *
+ * @beta
+ */
+export type ProcessedHierarchyNode = ProcessedCustomHierarchyNode | ProcessedInstanceHierarchyNode | ProcessedGroupingHierarchyNode;
+/**
+ * A `ProcessedHierarchyNode` that has an unformatted label in a form of `ConcatenatedValue`. Generally this is
+ * returned when the node is just parsed from query results.
+ * @beta
+ */
+export type ParsedHierarchyNode<TBase = ParsedCustomHierarchyNode | ParsedInstanceHierarchyNode> = OmitOverUnion<TBase, "label" | "parentKeys"> & {
+    label: string | ConcatenatedValue;
+};
+/**
+ * A kind of `ProcessedCustomHierarchyNode` that has unformatted label and doesn't know about its ancestors.
+ * @internal
+ */
+export type ParsedCustomHierarchyNode = ParsedHierarchyNode<ProcessedCustomHierarchyNode>;
+/**
+ * A kind of `ProcessedInstanceHierarchyNode` that has unformatted label and doesn't know about its ancestors.
+ * @internal
+ */
+export type ParsedInstanceHierarchyNode = ParsedHierarchyNode<ProcessedInstanceHierarchyNode>;
+export {};
+//# sourceMappingURL=HierarchyNode.d.ts.map

package/lib/esm/hierarchies/HierarchyNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HierarchyNode.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyNode.ts"],"names":[],"mappings":"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"}

package/lib/esm/hierarchies/HierarchyNode.js

@@ -0,0 +1,61 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+import { HierarchyNodeKey, } from "./HierarchyNodeKey";
+/** @beta */
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export var HierarchyNode;
+(function (HierarchyNode) {
+    /** Checks whether the given node is a custom node */
+    function isCustom(node) {
+        return HierarchyNodeKey.isCustom(node.key);
+    }
+    HierarchyNode.isCustom = isCustom;
+    /** Checks whether the given node is a standard (iModel content based) node */
+    function isStandard(node) {
+        return HierarchyNodeKey.isStandard(node.key);
+    }
+    HierarchyNode.isStandard = isStandard;
+    /** Checks whether the given node is an ECInstances-based node */
+    function isInstancesNode(node) {
+        return HierarchyNodeKey.isInstances(node.key);
+    }
+    HierarchyNode.isInstancesNode = isInstancesNode;
+    /** Checks whether the given node is a grouping node */
+    function isGroupingNode(node) {
+        return HierarchyNodeKey.isGrouping(node.key);
+    }
+    HierarchyNode.isGroupingNode = isGroupingNode;
+    /** Checks whether the given node is a class grouping node */
+    function isClassGroupingNode(node) {
+        return HierarchyNodeKey.isClassGrouping(node.key);
+    }
+    HierarchyNode.isClassGroupingNode = isClassGroupingNode;
+    /** Checks whether the given node is a label grouping node */
+    function isLabelGroupingNode(node) {
+        return HierarchyNodeKey.isLabelGrouping(node.key);
+    }
+    HierarchyNode.isLabelGroupingNode = isLabelGroupingNode;
+    /** Checks whether the given node is property grouping node for other values  */
+    function isPropertyOtherValuesGroupingNode(node) {
+        return HierarchyNodeKey.isPropertyOtherValuesGrouping(node.key);
+    }
+    HierarchyNode.isPropertyOtherValuesGroupingNode = isPropertyOtherValuesGroupingNode;
+    /** Checks whether the given node is a property value grouping node */
+    function isPropertyValueGroupingNode(node) {
+        return HierarchyNodeKey.isPropertyValueGrouping(node.key);
+    }
+    HierarchyNode.isPropertyValueGroupingNode = isPropertyValueGroupingNode;
+    /** Checks whether the given node is a property value range grouping node */
+    function isPropertyValueRangeGroupingNode(node) {
+        return HierarchyNodeKey.isPropertyValueRangeGrouping(node.key);
+    }
+    HierarchyNode.isPropertyValueRangeGroupingNode = isPropertyValueRangeGroupingNode;
+    /** Checks whether the given node is a property grouping node */
+    function isPropertyGroupingNode(node) {
+        return HierarchyNodeKey.isPropertyGrouping(node.key);
+    }
+    HierarchyNode.isPropertyGroupingNode = isPropertyGroupingNode;
+})(HierarchyNode || (HierarchyNode = {}));
+//# sourceMappingURL=HierarchyNode.js.map

package/lib/esm/hierarchies/HierarchyNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HierarchyNode.js","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyNode.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAGhG,OAAO,EAGL,gBAAgB,GAQjB,MAAM,oBAAoB,CAAC;AAwD5B,YAAY;AACZ,2DAA2D;AAC3D,MAAM,KAAW,aAAa,CAuE7B;AAvED,WAAiB,aAAa;IAC5B,qDAAqD;IACrD,SAAgB,QAAQ,CACtB,IAAW;QAEX,OAAO,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC7C,CAAC;IAJe,sBAAQ,WAIvB,CAAA;IACD,8EAA8E;IAC9E,SAAgB,UAAU,CAA0C,IAAW;QAC7E,OAAO,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAFe,wBAAU,aAEzB,CAAA;IACD,iEAAiE;IACjE,SAAgB,eAAe,CAC7B,IAAW;QAEX,OAAO,gBAAgB,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAChD,CAAC;IAJe,6BAAe,kBAI9B,CAAA;IACD,uDAAuD;IACvD,SAAgB,cAAc,CAC5B,IAAW;QAEX,OAAO,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC/C,CAAC;IAJe,4BAAc,iBAI7B,CAAA;IACD,6DAA6D;IAC7D,SAAgB,mBAAmB,CACjC,IAAW;QAIX,OAAO,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpD,CAAC;IANe,iCAAmB,sBAMlC,CAAA;IACD,6DAA6D;IAC7D,SAAgB,mBAAmB,CACjC,IAAW;QAIX,OAAO,gBAAgB,CAAC,eAAe,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACpD,CAAC;IANe,iCAAmB,sBAMlC,CAAA;IACD,gFAAgF;IAChF,SAAgB,iCAAiC,CAC/C,IAAW;QAIX,OAAO,gBAAgB,CAAC,6BAA6B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAClE,CAAC;IANe,+CAAiC,oCAMhD,CAAA;IACD,sEAAsE;IACtE,SAAgB,2BAA2B,CACzC,IAAW;QAIX,OAAO,gBAAgB,CAAC,uBAAuB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IANe,yCAA2B,8BAM1C,CAAA;IACD,4EAA4E;IAC5E,SAAgB,gCAAgC,CAC9C,IAAW;QAIX,OAAO,gBAAgB,CAAC,4BAA4B,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACjE,CAAC;IANe,8CAAgC,mCAM/C,CAAA;IACD,gEAAgE;IAChE,SAAgB,sBAAsB,CACpC,IAAW;QAIX,OAAO,gBAAgB,CAAC,kBAAkB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IACvD,CAAC;IANe,oCAAsB,yBAMrC,CAAA;AACH,CAAC,EAvEgB,aAAa,KAAb,aAAa,QAuE7B","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { ConcatenatedValue, InstanceKey, OmitOverUnion, PrimitiveValue } from \"@itwin/presentation-shared\";\nimport {\n  ClassGroupingNodeKey,\n  GroupingNodeKey,\n  HierarchyNodeKey,\n  InstancesNodeKey,\n  LabelGroupingNodeKey,\n  PropertyGroupingNodeKey,\n  PropertyOtherValuesGroupingNodeKey,\n  PropertyValueGroupingNodeKey,\n  PropertyValueRangeGroupingNodeKey,\n  StandardHierarchyNodeKey,\n} from \"./HierarchyNodeKey\";\n\n/**\n * A data structure that represents a single non-grouping hierarchy node.\n */\ninterface BaseHierarchyNode {\n  /** Identifiers of all node ancestors. Can be used to identify a node in the hierarchy. */\n  parentKeys: HierarchyNodeKey[];\n  /** Node's display label. */\n  label: string;\n  /** A flag indicating whether the node has children or not. */\n  children: boolean;\n  /** A flag indicating whether this node should be auto-expanded in the UI. */\n  autoExpand?: boolean;\n  /** Additional data that may be assigned to this node. */\n  extendedData?: { [key: string]: any };\n}\n\n/**\n * A data structure that represents a single non-grouping hierarchy node.\n * @beta\n */\nexport interface NonGroupingHierarchyNode extends BaseHierarchyNode {\n  /** An identifier to identify the node in its hierarchy level. */\n  key: string | InstancesNodeKey;\n  /**\n   * Identifies whether the hierarchy level below this node supports filtering. If not, supplying an instance\n   * filter when requesting child hierarchy level will have no effect.\n   */\n  supportsFiltering?: boolean;\n}\n\n/**\n * A data structure that represents a grouping node that groups other nodes.\n * @beta\n */\nexport interface GroupingHierarchyNode extends BaseHierarchyNode {\n  /** An identifier to identify this grouping node in its hierarchy level. */\n  key: GroupingNodeKey;\n\n  /**\n   * Keys of all instances grouped by this node, including deeply nested under\n   * other grouping nodes.\n   */\n  groupedInstanceKeys: InstanceKey[];\n\n  /** The closest ancestor node that is not a grouping node. May be `undefined` if the grouping node grouped root level nodes. */\n  nonGroupingAncestor?: ParentHierarchyNode<NonGroupingHierarchyNode>;\n}\n\n/**\n * A data structure that represents a single hierarchy node.\n * @beta\n */\nexport type HierarchyNode = NonGroupingHierarchyNode | GroupingHierarchyNode;\n\n/** @beta */\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport namespace HierarchyNode {\n  /** Checks whether the given node is a custom node */\n  export function isCustom<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedCustomHierarchyNode : NonGroupingHierarchyNode) & { key: string } {\n    return HierarchyNodeKey.isCustom(node.key);\n  }\n  /** Checks whether the given node is a standard (iModel content based) node */\n  export function isStandard<TNode extends { key: HierarchyNodeKey }>(node: TNode): node is TNode & { key: StandardHierarchyNodeKey } {\n    return HierarchyNodeKey.isStandard(node.key);\n  }\n  /** Checks whether the given node is an ECInstances-based node */\n  export function isInstancesNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedInstanceHierarchyNode : NonGroupingHierarchyNode) & { key: InstancesNodeKey } {\n    return HierarchyNodeKey.isInstances(node.key);\n  }\n  /** Checks whether the given node is a grouping node */\n  export function isGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & (TNode extends ProcessedHierarchyNode ? ProcessedGroupingHierarchyNode : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isGrouping(node.key);\n  }\n  /** Checks whether the given node is a class grouping node */\n  export function isClassGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: ClassGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isClassGrouping(node.key);\n  }\n  /** Checks whether the given node is a label grouping node */\n  export function isLabelGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: LabelGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isLabelGrouping(node.key);\n  }\n  /** Checks whether the given node is property grouping node for other values  */\n  export function isPropertyOtherValuesGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: PropertyOtherValuesGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isPropertyOtherValuesGrouping(node.key);\n  }\n  /** Checks whether the given node is a property value grouping node */\n  export function isPropertyValueGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: PropertyValueGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isPropertyValueGrouping(node.key);\n  }\n  /** Checks whether the given node is a property value range grouping node */\n  export function isPropertyValueRangeGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: PropertyValueRangeGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isPropertyValueRangeGrouping(node.key);\n  }\n  /** Checks whether the given node is a property grouping node */\n  export function isPropertyGroupingNode<TNode extends { key: HierarchyNodeKey }>(\n    node: TNode,\n  ): node is TNode & { key: PropertyGroupingNodeKey; supportsFiltering?: undefined } & (TNode extends ProcessedHierarchyNode\n      ? ProcessedGroupingHierarchyNode\n      : GroupingHierarchyNode) {\n    return HierarchyNodeKey.isPropertyGrouping(node.key);\n  }\n}\n\n/**\n * A type of `HierarchyNode` that doesn't know about its children and is an input when requesting\n * them using `HierarchyProvider.getNodes`.\n *\n * @internal\n */\nexport type ParentHierarchyNode<TBase = HierarchyNode> = OmitOverUnion<TBase, \"children\">;\n\n/**\n * Base processing parameters that apply to every node.\n */\ninterface HierarchyNodeProcessingParamsBase {\n  /** Indicates if this node should be hidden if it has no child nodes. */\n  hideIfNoChildren?: boolean;\n  /** Indicates that this node should always be hidden and its children should be loaded in its place. */\n  hideInHierarchy?: boolean;\n}\n\n/**\n * A data structure for defining nodes' grouping requirements.\n */\ninterface HierarchyNodeGroupingParams {\n  byLabel?: HierarchyNodeLabelGroupingParams;\n  byClass?: boolean | HierarchyNodeGroupingParamsBase;\n  byBaseClasses?: HierarchyNodeBaseClassGroupingParams;\n  byProperties?: HierarchyNodePropertiesGroupingParams;\n}\n\n/**\n * A data structure for defining params specifically used for label grouping.\n */\ninterface HierarchyNodeLabelGroupingBaseParams {\n  /** Label grouping option that determines whether to group nodes or to merge them. Defaults to \"group\".*/\n  action?: \"group\" | \"merge\";\n  /** Value that needs to match in order for nodes to be grouped or merged.*/\n  groupId?: string;\n}\n\n/**\n * A data structure for defining label merging.\n */\ninterface HierarchyNodeLabelGroupingMergeParams extends HierarchyNodeLabelGroupingBaseParams {\n  action: \"merge\";\n}\n\n/**\n * A data structure for defining label grouping with additional parameters.\n */\ninterface HierarchyNodeLabelGroupingGroupParams extends HierarchyNodeLabelGroupingBaseParams, HierarchyNodeGroupingParamsBase {\n  action?: \"group\";\n}\n\n/**\n * A data structure for defining possible label grouping types.\n * @internal\n */\nexport type HierarchyNodeLabelGroupingParams = boolean | HierarchyNodeLabelGroupingMergeParams | HierarchyNodeLabelGroupingGroupParams;\n\n/**\n * Grouping parameters that are shared across all types of groupings.\n * @internal\n */\nexport interface HierarchyNodeGroupingParamsBase {\n  /** Hiding option that determines whether to hide group nodes which have no siblings at the same hierarchy level. */\n  hideIfNoSiblings?: boolean;\n  /** Hiding option that determines whether to hide group nodes which have only one node as its children. */\n  hideIfOneGroupedNode?: boolean;\n  /** Option which auto expands grouping nodes' children when it has single child or always. */\n  autoExpand?: HierarchyNodeAutoExpandProp;\n}\n\n/**\n * Defines possible values for `BaseGroupingParams.autoExpand` attribute:\n * - `single-child` - set the grouping node to auto-expand if it groups a single node.\n * - `always` - always set the grouping node to auto-expand.\n *\n * @internal\n */\nexport type HierarchyNodeAutoExpandProp = \"single-child\" | \"always\";\n\n/**\n * A data structure that represents base class grouping.\n */\ninterface HierarchyNodeBaseClassGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full names of classes, which should be used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  fullClassNames: string[];\n}\n\n/**\n * A data structure that represents properties grouping.\n * @internal\n */\nexport interface HierarchyNodePropertiesGroupingParams extends HierarchyNodeGroupingParamsBase {\n  /**\n   * Full name of a class whose properties are used to group the node. Only has effect if the node\n   * represents an instance of that class.\n   *\n   * Full class name format: `SchemaName.ClassName`.\n   */\n  propertiesClassName: string;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value is not set or is set to an empty string.\n   *\n   * Label of the created grouping node will be `Not Specified`.\n   */\n  createGroupForUnspecifiedValues?: boolean;\n  /**\n   * Property grouping option that determines whether to group nodes whose grouping value doesn't fit within any of the provided\n   * ranges, or is not a numeric value.\n   *\n   * Label of the created grouping node will be `Other`.\n   */\n  createGroupForOutOfRangeValues?: boolean;\n  /**\n   * Properties of the specified class, by which the nodes should be grouped. Each provided group definition results in a\n   * grouping hierarchy level.\n   *\n   * Example usage:\n   * ```ts\n   * propertyGroups: [\n   *   {\n   *     propertyName: \"type\",\n   *     propertyValue: \"Wall\"\n   *   },\n   *   {\n   *     propertyName: \"length\",\n   *     propertyValue: 15,\n   *     ranges: [\n   *       { fromValue: 1, toValue: 10, rangeLabel: \"Small\" },\n   *       { fromValue: 11, toValue: 20, rangeLabel: \"Medium\" }\n   *     ]\n   *   },\n   * ]\n   * ```\n   */\n  propertyGroups: HierarchyNodePropertyGroup[];\n}\n\n/**\n * A data structure that represents specific properties' grouping params.\n * @internal\n */\nexport interface HierarchyNodePropertyGroup {\n  /** A string indicating the name of the property to group by. */\n  propertyName: string;\n  /**  Value of the property, which will be used to group the node. */\n  propertyValue?: PrimitiveValue;\n  /** Ranges are used to group nodes by numeric properties which are within specified bounds. */\n  ranges?: HierarchyNodePropertyValueRange[];\n}\n\n/**\n * A data structure that represents boundaries for a value.\n * @internal\n */\nexport interface HierarchyNodePropertyValueRange {\n  /** Defines the lower bound of the range. */\n  fromValue: number;\n  /** Defines the upper bound of the range. */\n  toValue: number;\n  /** Defines the range label. Will be used as `PropertyValueRangeGroupingNode` node's display label. */\n  rangeLabel?: string;\n}\n\n/**\n * Processing parameters that apply to instance nodes.\n * @internal\n */\nexport interface InstanceHierarchyNodeProcessingParams extends HierarchyNodeProcessingParamsBase {\n  grouping?: HierarchyNodeGroupingParams;\n}\n\n/**\n * A custom (not based on data in an iModel) node that has processing parameters.\n * @internal\n */\nexport type ProcessedCustomHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: string;\n  children?: boolean;\n  processingParams?: HierarchyNodeProcessingParamsBase;\n};\n/**\n * An instances' (based on data in an iModel) node that has processing parameters.\n * @internal\n */\nexport type ProcessedInstanceHierarchyNode = Omit<NonGroupingHierarchyNode, \"key\" | \"children\"> & {\n  key: InstancesNodeKey;\n  children?: boolean;\n  processingParams?: InstanceHierarchyNodeProcessingParams;\n};\n/**\n * A grouping node that groups either instance nodes or other grouping nodes.\n * @internal\n */\nexport type ProcessedGroupingHierarchyNode = Omit<GroupingHierarchyNode, \"children\"> & {\n  children: Array<ProcessedGroupingHierarchyNode | ProcessedInstanceHierarchyNode>;\n};\n/**\n * A `HierarchyNode` that may have processing parameters defining whether it should be hidden under some conditions,\n * how it should be grouped, sorted, etc.\n *\n * Type guards under `HierarchyNode` namespace can be used to differentiate between different sub-types of\n * `ProcessedHierarchyNode`.\n *\n * @beta\n */\nexport type ProcessedHierarchyNode = ProcessedCustomHierarchyNode | ProcessedInstanceHierarchyNode | ProcessedGroupingHierarchyNode;\n\n/**\n * A `ProcessedHierarchyNode` that has an unformatted label in a form of `ConcatenatedValue`. Generally this is\n * returned when the node is just parsed from query results.\n * @beta\n */\nexport type ParsedHierarchyNode<TBase = ParsedCustomHierarchyNode | ParsedInstanceHierarchyNode> = OmitOverUnion<TBase, \"label\" | \"parentKeys\"> & {\n  label: string | ConcatenatedValue;\n};\n/**\n * A kind of `ProcessedCustomHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @internal\n */\nexport type ParsedCustomHierarchyNode = ParsedHierarchyNode<ProcessedCustomHierarchyNode>;\n/**\n * A kind of `ProcessedInstanceHierarchyNode` that has unformatted label and doesn't know about its ancestors.\n * @internal\n */\nexport type ParsedInstanceHierarchyNode = ParsedHierarchyNode<ProcessedInstanceHierarchyNode>;\n"]}

package/lib/esm/hierarchies/HierarchyNodeIdentifier.d.ts

@@ -0,0 +1,33 @@
+import { InstanceKey } from "@itwin/presentation-shared";
+/**
+ * An identifier that can be used to identify either an ECInstance or a custom node.
+ *
+ * This is different from `HierarchyNodeKey` - the key can represent more types of nodes and,
+ * in case of `InstancesNodeKey`, contains information about all instances the node represents.
+ * `HierarchyNodeIdentifier`, on the other hand, is used for matching a node, so it only needs
+ * to contain information about a single instance or custom node key.
+ *
+ * @beta
+ */
+export type HierarchyNodeIdentifier = InstanceKey | {
+    key: string;
+};
+/** @beta */
+export declare namespace HierarchyNodeIdentifier {
+    /** Checks whether the given identifier is an instance node identifier */
+    function isInstanceNodeIdentifier(id: HierarchyNodeIdentifier): id is InstanceKey;
+    /** Checks whether the given identifier is a custom node identifier */
+    function isCustomNodeIdentifier(id: HierarchyNodeIdentifier): id is {
+        key: string;
+    };
+    /** Checks two identifiers for equality */
+    function equal(lhs: HierarchyNodeIdentifier, rhs: HierarchyNodeIdentifier): boolean;
+}
+/**
+ * A path of hierarchy node identifiers, typically used to describe a path from root down
+ * to specific node deep in the hierarchy.
+ *
+ * @beta
+ */
+export type HierarchyNodeIdentifiersPath = HierarchyNodeIdentifier[];
+//# sourceMappingURL=HierarchyNodeIdentifier.d.ts.map

package/lib/esm/hierarchies/HierarchyNodeIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HierarchyNodeIdentifier.d.ts","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyNodeIdentifier.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD;;;;;;;;;GASG;AACH,MAAM,MAAM,uBAAuB,GAAG,WAAW,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpE,YAAY;AAEZ,yBAAiB,uBAAuB,CAAC;IACvC,yEAAyE;IACzE,SAAgB,wBAAwB,CAAC,EAAE,EAAE,uBAAuB,GAAG,EAAE,IAAI,WAAW,CAEvF;IAED,sEAAsE;IACtE,SAAgB,sBAAsB,CAAC,EAAE,EAAE,uBAAuB,GAAG,EAAE,IAAI;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAEzF;IAED,0CAA0C;IAC1C,SAAgB,KAAK,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,EAAE,uBAAuB,WAQ/E;CACF;AAED;;;;;GAKG;AACH,MAAM,MAAM,4BAA4B,GAAG,uBAAuB,EAAE,CAAC"}

package/lib/esm/hierarchies/HierarchyNodeIdentifier.js

@@ -0,0 +1,31 @@
+/*---------------------------------------------------------------------------------------------
+ * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+ * See LICENSE.md in the project root for license terms and full copyright notice.
+ *--------------------------------------------------------------------------------------------*/
+/** @beta */
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export var HierarchyNodeIdentifier;
+(function (HierarchyNodeIdentifier) {
+    /** Checks whether the given identifier is an instance node identifier */
+    function isInstanceNodeIdentifier(id) {
+        return !!id.id;
+    }
+    HierarchyNodeIdentifier.isInstanceNodeIdentifier = isInstanceNodeIdentifier;
+    /** Checks whether the given identifier is a custom node identifier */
+    function isCustomNodeIdentifier(id) {
+        return !!id.key;
+    }
+    HierarchyNodeIdentifier.isCustomNodeIdentifier = isCustomNodeIdentifier;
+    /** Checks two identifiers for equality */
+    function equal(lhs, rhs) {
+        if (isInstanceNodeIdentifier(lhs) && isInstanceNodeIdentifier(rhs)) {
+            return lhs.className === rhs.className && lhs.id === rhs.id;
+        }
+        if (isCustomNodeIdentifier(lhs) && isCustomNodeIdentifier(rhs)) {
+            return lhs.key === rhs.key;
+        }
+        return false;
+    }
+    HierarchyNodeIdentifier.equal = equal;
+})(HierarchyNodeIdentifier || (HierarchyNodeIdentifier = {}));
+//# sourceMappingURL=HierarchyNodeIdentifier.js.map

package/lib/esm/hierarchies/HierarchyNodeIdentifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"HierarchyNodeIdentifier.js","sourceRoot":"","sources":["../../../src/hierarchies/HierarchyNodeIdentifier.ts"],"names":[],"mappings":"AAAA;;;gGAGgG;AAgBhG,YAAY;AACZ,2DAA2D;AAC3D,MAAM,KAAW,uBAAuB,CAqBvC;AArBD,WAAiB,uBAAuB;IACtC,yEAAyE;IACzE,SAAgB,wBAAwB,CAAC,EAA2B;QAClE,OAAO,CAAC,CAAE,EAAkB,CAAC,EAAE,CAAC;IAClC,CAAC;IAFe,gDAAwB,2BAEvC,CAAA;IAED,sEAAsE;IACtE,SAAgB,sBAAsB,CAAC,EAA2B;QAChE,OAAO,CAAC,CAAE,EAAsB,CAAC,GAAG,CAAC;IACvC,CAAC;IAFe,8CAAsB,yBAErC,CAAA;IAED,0CAA0C;IAC1C,SAAgB,KAAK,CAAC,GAA4B,EAAE,GAA4B;QAC9E,IAAI,wBAAwB,CAAC,GAAG,CAAC,IAAI,wBAAwB,CAAC,GAAG,CAAC,EAAE,CAAC;YACnE,OAAO,GAAG,CAAC,SAAS,KAAK,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,EAAE,CAAC;QAC9D,CAAC;QACD,IAAI,sBAAsB,CAAC,GAAG,CAAC,IAAI,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/D,OAAO,GAAG,CAAC,GAAG,KAAK,GAAG,CAAC,GAAG,CAAC;QAC7B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IARe,6BAAK,QAQpB,CAAA;AACH,CAAC,EArBgB,uBAAuB,KAAvB,uBAAuB,QAqBvC","sourcesContent":["/*---------------------------------------------------------------------------------------------\n * Copyright (c) Bentley Systems, Incorporated. All rights reserved.\n * See LICENSE.md in the project root for license terms and full copyright notice.\n *--------------------------------------------------------------------------------------------*/\n\nimport { InstanceKey } from \"@itwin/presentation-shared\";\n\n/**\n * An identifier that can be used to identify either an ECInstance or a custom node.\n *\n * This is different from `HierarchyNodeKey` - the key can represent more types of nodes and,\n * in case of `InstancesNodeKey`, contains information about all instances the node represents.\n * `HierarchyNodeIdentifier`, on the other hand, is used for matching a node, so it only needs\n * to contain information about a single instance or custom node key.\n *\n * @beta\n */\nexport type HierarchyNodeIdentifier = InstanceKey | { key: string };\n\n/** @beta */\n// eslint-disable-next-line @typescript-eslint/no-redeclare\nexport namespace HierarchyNodeIdentifier {\n  /** Checks whether the given identifier is an instance node identifier */\n  export function isInstanceNodeIdentifier(id: HierarchyNodeIdentifier): id is InstanceKey {\n    return !!(id as InstanceKey).id;\n  }\n\n  /** Checks whether the given identifier is a custom node identifier */\n  export function isCustomNodeIdentifier(id: HierarchyNodeIdentifier): id is { key: string } {\n    return !!(id as { key: string }).key;\n  }\n\n  /** Checks two identifiers for equality */\n  export function equal(lhs: HierarchyNodeIdentifier, rhs: HierarchyNodeIdentifier) {\n    if (isInstanceNodeIdentifier(lhs) && isInstanceNodeIdentifier(rhs)) {\n      return lhs.className === rhs.className && lhs.id === rhs.id;\n    }\n    if (isCustomNodeIdentifier(lhs) && isCustomNodeIdentifier(rhs)) {\n      return lhs.key === rhs.key;\n    }\n    return false;\n  }\n}\n\n/**\n * A path of hierarchy node identifiers, typically used to describe a path from root down\n * to specific node deep in the hierarchy.\n *\n * @beta\n */\nexport type HierarchyNodeIdentifiersPath = HierarchyNodeIdentifier[];\n"]}