@fluid-topics/ft-wc-utils 1.1.26 → 1.1.28

package/build/ClusteringHelper.d.ts

@@ -0,0 +1,24 @@
+import { FtMetadata, FtMetadataDescriptor, FtSearchResultClusterEntry } from "@fluid-topics/public-api";
+export interface FlatMetadata {
+    key: string;
+    value: string;
+    displayValue: string;
+}
+export interface ClusterItem {
+    metadata: FlatMetadata;
+    result: FtSearchResultClusterEntry;
+}
+export declare class ClusteringHelper {
+    private allResults;
+    private selectedResult;
+    private clusteringMetadata;
+    private metadataDescriptors;
+    constructor(allResults: Array<FtSearchResultClusterEntry>, selectedResult: FtSearchResultClusterEntry, clusteringMetadata: Set<string>, metadataDescriptors: Array<FtMetadataDescriptor>);
+    static extractResultMetadata(result: FtSearchResultClusterEntry): FlatMetadata[];
+    static flattenMetadata(metadata: FtMetadata): FlatMetadata;
+    computeClustersItemsForMetadata(key: string, locale: string): ClusterItem[];
+    private compareMetadata;
+    private findMatchingResult;
+    private findResultMatchingMetadata;
+    private resultMatchesMetadata;
+}

package/build/ClusteringHelper.js

@@ -0,0 +1,65 @@
+export class ClusteringHelper {
+    constructor(allResults, selectedResult, clusteringMetadata, metadataDescriptors) {
+        this.allResults = allResults;
+        this.selectedResult = selectedResult;
+        this.clusteringMetadata = clusteringMetadata;
+        this.metadataDescriptors = metadataDescriptors;
+    }
+    static extractResultMetadata(result) {
+        var _a, _b;
+        return ((_b = (_a = result === null || result === void 0 ? void 0 : result.map) !== null && _a !== void 0 ? _a : result === null || result === void 0 ? void 0 : result.document) !== null && _b !== void 0 ? _b : result === null || result === void 0 ? void 0 : result.topic).metadata.map(m => ClusteringHelper.flattenMetadata(m));
+    }
+    static flattenMetadata(metadata) {
+        if (metadata.hierarchicalValues) {
+            const values = [];
+            const displayValues = [];
+            metadata.hierarchicalValues.forEach(tree => {
+                values.push(tree.join(" > "));
+                if (tree.length > 2) {
+                    displayValues.push(`... > ${tree[tree.length - 1]}`);
+                }
+                else {
+                    displayValues.push(tree.join(" > "));
+                }
+            });
+            return { key: metadata.key, value: values.join(", "), displayValue: displayValues.join(", ") };
+        }
+        else {
+            const value = metadata.values.join(", ");
+            return { key: metadata.key, value: value, displayValue: value };
+        }
+    }
+    computeClustersItemsForMetadata(key, locale) {
+        const metadataValues = this.allResults
+            .flatMap(result => ClusteringHelper.extractResultMetadata(result).filter(m => m.key === key))
+            .filter((flatMeta, index, array) => array.findIndex(i => i.value === flatMeta.value) === index); // for unicity
+        return metadataValues.map(flatMeta => ({
+            result: this.findMatchingResult(key, flatMeta.value),
+            metadata: flatMeta
+        })).sort((a, b) => this.compareMetadata(a.metadata.value, b.metadata.value, key, locale));
+    }
+    compareMetadata(a, b, key, locale) {
+        let descriptor = this.metadataDescriptors.find((descriptor) => key == descriptor.key);
+        let sortRule = (descriptor === null || descriptor === void 0 ? void 0 : descriptor.sortRule) || "NONE";
+        let reverseOrder = (descriptor === null || descriptor === void 0 ? void 0 : descriptor.reverseSort) || false;
+        if (sortRule == "ALPHABET" || sortRule == "VERSION") {
+            let result = a.localeCompare(b, locale, { numeric: true });
+            return reverseOrder ? result * -1 : result;
+        }
+        return 0;
+    }
+    findMatchingResult(key, value) {
+        var _a, _b;
+        let currentResultMetadata = ClusteringHelper.extractResultMetadata(this.selectedResult)
+            .filter(m => this.clusteringMetadata.has(m.key));
+        let newExpectedMetadata = [...currentResultMetadata.filter(m => m.key !== key), { key, value, displayValue: value }];
+        return (_b = (_a = this.findResultMatchingMetadata(newExpectedMetadata)) !== null && _a !== void 0 ? _a : this.findResultMatchingMetadata([{ key, value, displayValue: value }])) !== null && _b !== void 0 ? _b : this.allResults[0];
+    }
+    findResultMatchingMetadata(metadata) {
+        return this.allResults.find(entry => this.resultMatchesMetadata(entry, metadata));
+    }
+    resultMatchesMetadata(result, expectedMetadata) {
+        let resultMetadata = ClusteringHelper.extractResultMetadata(result);
+        return expectedMetadata.every(em => resultMetadata.some(rm => rm.key == em.key && rm.value == em.value));
+    }
+}