@itwin/presentation-components
Version:
React components based on iTwin.js Presentation library
152 lines • 7.24 kB
JavaScript
import { jsx as _jsx } from "react/jsx-runtime";
/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
import { useCallback, useEffect, useMemo, useState } from "react";
import { PropertyValueFormat } from "@itwin/appui-abstract";
import { ComboBox } from "@itwin/itwinui-react";
import { deserializeUniqueValues, findField, serializeUniqueValues, translate } from "../../common/Utils.js";
import { getInstanceFilterFieldName } from "../../instance-filter-builder/Utils.js";
import { FILTER_WARNING_OPTION, VALUE_BATCH_SIZE } from "./ItemsLoader.js";
import { useUniquePropertyValuesLoader } from "./UseUniquePropertyValuesLoader.js";
/** @internal */
export function UniquePropertyValuesSelector(props) {
const { imodel, descriptor, property, onChange, value, descriptorInputKeys, selectedClasses } = props;
const [field, setField] = useState(() => findField(descriptor, getInstanceFilterFieldName(property)));
const [searchInput, setSearchInput] = useState("");
const selectedValues = useMemo(() => getUniqueValueFromProperty(value)?.map((val) => val.displayValue), [value]);
const ruleset = useUniquePropertyValuesRuleset(descriptor.ruleset, field, descriptorInputKeys, selectedClasses);
const { selectOptions, loadedOptions, isLoading } = useUniquePropertyValuesLoader({
imodel,
ruleset,
field,
descriptorInputKeys,
typeName: property.typename,
selectedValues,
filterText: searchInput,
});
const onValueChange = useCallback((newValues) => {
const newSelectedValues = loadedOptions.filter((opt) => newValues.includes(opt.displayValue));
if (newSelectedValues.length === 0) {
onChange({
valueFormat: PropertyValueFormat.Primitive,
displayValue: undefined,
value: undefined,
});
}
else {
const { displayValues, groupedRawValues } = serializeUniqueValues(newSelectedValues);
onChange({
valueFormat: PropertyValueFormat.Primitive,
displayValue: displayValues,
value: groupedRawValues,
});
}
}, [loadedOptions, onChange]);
const emptyContent = useMemo(() => {
return isLoading ? translate("unique-values-property-editor.loading-values") : translate("unique-values-property-editor.no-values");
}, [isLoading]);
useEffect(() => {
setField(findField(descriptor, getInstanceFilterFieldName(property)));
setSearchInput("");
}, [descriptor, property]);
return (_jsx(ComboBox, { multiple: true, enableVirtualization: true, options: selectOptions, onChange: onValueChange, filterFunction: (options, inputValue) => {
const filteredOptions = options
.filter((option) => option.label.toLowerCase().includes(inputValue.toLowerCase()) && option.value !== FILTER_WARNING_OPTION.value)
.slice(0, VALUE_BATCH_SIZE);
if (filteredOptions.length >= VALUE_BATCH_SIZE) {
filteredOptions.push(FILTER_WARNING_OPTION);
}
return filteredOptions;
}, emptyStateMessage: emptyContent, value: selectedValues, clearFilterOnOptionToggle: false, inputProps: {
placeholder: translate("unique-values-property-editor.select-values"),
size: "small",
value: searchInput,
onChange: (e) => setSearchInput(e.target.value),
}, onHide: () => setSearchInput("") }));
}
function getUniqueValueFromProperty(propertyValue) {
if (propertyValue?.valueFormat === PropertyValueFormat.Primitive && typeof propertyValue.value === "string" && propertyValue.displayValue) {
return deserializeUniqueValues(propertyValue.displayValue, propertyValue.value);
}
return [];
}
function useUniquePropertyValuesRuleset(descriptorRuleset, field, descriptorInputKeys, selectedClasses) {
const [ruleset, setRuleset] = useState();
useEffect(() => {
if (descriptorRuleset) {
setRuleset(descriptorRuleset);
return;
}
if (descriptorInputKeys && hasKeys(descriptorInputKeys)) {
setRuleset({
id: "unique-instances-property-values",
rules: [
{
ruleType: "Content",
specifications: [
{
specType: "SelectedNodeInstances",
acceptableClassNames: selectedClasses ? selectedClasses.map(({ name }) => name.split(/[\.:]/)[1]) : undefined,
acceptablePolymorphically: true,
},
],
},
],
});
return;
}
const classInfos = selectedClasses ?? getFieldClassInfos(field);
if (classInfos.length === 0) {
setRuleset(undefined);
return;
}
setRuleset({
id: "unique-class-property-values",
rules: [
{
ruleType: "Content",
specifications: [
{
specType: "ContentInstancesOfSpecificClasses",
classes: createSchemaClasses(classInfos),
},
],
},
],
});
}, [field, descriptorRuleset, descriptorInputKeys, selectedClasses]);
return ruleset;
}
function createSchemaClasses(infos) {
const schemaClassMap = new Map();
infos.forEach((info) => {
const [schemaName, className] = info.name.split(/[\.:]/);
let classNames = schemaClassMap.get(schemaName);
if (!classNames) {
classNames = [];
schemaClassMap.set(schemaName, classNames);
}
if (!classNames.includes(className)) {
classNames.push(className);
}
});
const schemaClasses = [...schemaClassMap.entries()].map(([schemaName, classNames]) => ({ schemaName, classNames, arePolymorphic: true }));
return schemaClasses.length === 1 ? schemaClasses[0] : schemaClasses;
}
function getFieldClassInfos(field) {
if (field?.parent === undefined && field?.isPropertiesField()) {
return field.properties.map((p) => p.property.classInfo);
}
let rootParentField = field?.parent;
while (rootParentField?.parent !== undefined) {
rootParentField = rootParentField.parent;
}
const lastStepToPrimaryClass = rootParentField?.pathToPrimaryClass.slice(-1).pop();
return lastStepToPrimaryClass ? [lastStepToPrimaryClass.targetClassInfo] : [];
}
function hasKeys(descriptorInputKeys) {
return Array.isArray(descriptorInputKeys) ? descriptorInputKeys.length > 0 : !descriptorInputKeys.isEmpty;
}
//# sourceMappingURL=UniquePropertyValuesSelector.js.map