rebase master

packages/cbioportal-utils/src/oncokb/OncoKbUtils.ts

@@ -285,23 +285,23 @@ export function calculateOncoKbAvailableDataType(
     annotations: IndicatorQueryResp[]
 ) {
     // Always show oncogenicity icon as long as the annotation exists
-    const availableDataTypes = [];
+    const availableDataTypes = new Set<OncoKbCardDataType>();
     if (annotations.length > 0) {
-        availableDataTypes.push(OncoKbCardDataType.BIOLOGICAL);
+        availableDataTypes.add(OncoKbCardDataType.BIOLOGICAL);
     }
     annotations.forEach(annotation => {
         if (!!annotation.highestSensitiveLevel) {
-            availableDataTypes.push(OncoKbCardDataType.TXS);
+            availableDataTypes.add(OncoKbCardDataType.TXS);
         }
         if (!!annotation.highestResistanceLevel) {
-            availableDataTypes.push(OncoKbCardDataType.TXR);
+            availableDataTypes.add(OncoKbCardDataType.TXR);
         }
         if (!!annotation.highestPrognosticImplicationLevel) {
-            availableDataTypes.push(OncoKbCardDataType.PX);
+            availableDataTypes.add(OncoKbCardDataType.PX);
         }
         if (!!annotation.highestDiagnosticImplicationLevel) {
-            availableDataTypes.push(OncoKbCardDataType.DX);
+            availableDataTypes.add(OncoKbCardDataType.DX);
         }
     });
-    return _.uniq(availableDataTypes);
+    return Array.from(availableDataTypes);
 }

packages/react-mutation-mapper/src/component/column/Annotation.tsx

@@ -103,6 +103,7 @@ function getDefaultTumorType(): string {
     return 'Unknown';
 }
 
+const memoized: Map<string, IAnnotation> = new Map();
 export function getAnnotationData(
     mutation?: Mutation,
     oncoKbCancerGenes?: RemoteData<CancerGene[] | Error | undefined>,
@@ -118,6 +119,27 @@ export function getAnnotationData(
     let value: Partial<IAnnotation>;
 
     if (mutation) {
+        var key = '';
+        const memoize =
+            !!oncoKbCancerGenes &&
+            oncoKbCancerGenes?.isComplete &&
+            !!hotspotData &&
+            hotspotData?.isComplete &&
+            !!myCancerGenomeData &&
+            !!oncoKbData &&
+            oncoKbData?.isComplete &&
+            !!civicGenes &&
+            civicGenes?.isComplete &&
+            !!civicVariants &&
+            civicVariants?.isComplete;
+        if (memoize) {
+            key = JSON.stringify(mutation) + !!usingPublicOncoKbInstance;
+            const val = memoized.get(key);
+            if (val) {
+                return val;
+            }
+        }
+
         const entrezGeneId = resolveEntrezGeneId(mutation);
 
         let oncoKbIndicator: IndicatorQueryResp | undefined;
@@ -244,6 +266,9 @@ export function getAnnotationData(
                 oncoKbIndicator: undefined,
             };
         }
+        if (memoize) {
+            memoized.set(key, value as any);
+        }
     } else {
         value = DEFAULT_ANNOTATION_DATA;
     }

packages/react-mutation-mapper/src/filter/CategoricalFilter.ts

@@ -0,0 +1,9 @@
+import { DataFilter } from '../model/DataFilter';
+
+export type CategoricalFilterValue = {
+    filterCondition: string;
+    filterString: string;
+    selections: Set<string>;
+};
+
+export type CategoricalFilter = DataFilter<CategoricalFilterValue>;

packages/react-mutation-mapper/src/filter/NumericalFilter.ts

@@ -0,0 +1,9 @@
+import { DataFilter } from '../model/DataFilter';
+
+export type NumericalFilterValue = {
+    lowerBound: number;
+    upperBound: number;
+    hideEmptyValues: boolean;
+};
+
+export type NumericalFilter = DataFilter<NumericalFilterValue>;

packages/react-mutation-mapper/src/index.tsx

@@ -140,6 +140,14 @@ export { MutationFilter } from './filter/MutationFilter';
 export { OncoKbFilter } from './filter/OncoKbFilter';
 export { PositionFilter } from './filter/PositionFilter';
 export { ProteinImpactTypeFilter } from './filter/ProteinImpactTypeFilter';
+export {
+    NumericalFilter,
+    NumericalFilterValue,
+} from './filter/NumericalFilter';
+export {
+    CategoricalFilter,
+    CategoricalFilterValue,
+} from './filter/CategoricalFilter';
 
 export { DataFilter, DataFilterType } from './model/DataFilter';
 export { DataStore } from './model/DataStore';

packages/react-mutation-mapper/src/util/FilterUtils.ts

@@ -9,6 +9,8 @@ import { MutationFilter, MutationFilterValue } from '../filter/MutationFilter';
 import { MutationStatusFilter } from '../filter/MutationStatusFilter';
 import { PositionFilter } from '../filter/PositionFilter';
 import { ProteinImpactTypeFilter } from '../filter/ProteinImpactTypeFilter';
+import { NumericalFilterValue } from '../filter/NumericalFilter';
+import { CategoricalFilterValue } from '../filter/CategoricalFilter';
 import DataStore from '../model/DataStore';
 import { DataFilter, DataFilterType } from '../model/DataFilter';
 import { ApplyFilterFn } from '../model/FilterApplier';
@@ -206,7 +208,10 @@ export function groupDataByProteinImpactType(sortedFilteredData: any[]) {
 }
 
 export function onFilterOptionSelect(
-    selectedValues: string[],
+    selectedValues:
+        | string[]
+        | NumericalFilterValue[]
+        | CategoricalFilterValue[],
     allValuesSelected: boolean,
     dataStore: DataStore,
     dataFilterType: string,

src/pages/resultsView/ResultsViewPageStore.ts

@@ -251,10 +251,31 @@ import oql_parser, {
 import {
     ANNOTATED_PROTEIN_IMPACT_FILTER_TYPE,
     createAnnotatedProteinImpactTypeFilter,
+    createNumericalFilter,
+    createCategoricalFilter,
 } from 'shared/lib/MutationUtils';
 import ComplexKeyCounter from 'shared/lib/complexKeyDataStructures/ComplexKeyCounter';
 import { chunkCalls } from 'cbioportal-utils';
 import SampleSet from 'shared/lib/sampleDataStructures/SampleSet';
+import {
+    MutationTableColumnType,
+    getTextForDataField,
+} from 'shared/components/mutationTable/MutationTable';
+import { getClonalValue } from 'shared/components/mutationTable/column/clonal/ClonalColumnFormatter';
+import { getCancerCellFractionValue } from 'shared/components/mutationTable/column/cancerCellFraction/CancerCellFractionColumnFormatter';
+import { getExpectedAltCopiesValue } from 'shared/components/mutationTable/column/expectedAltCopies/ExpectedAltCopiesColumnFormatter';
+import TumorAlleleFreqColumnFormatter from 'shared/components/mutationTable/column/TumorAlleleFreqColumnFormatter';
+import NormalAlleleFreqColumnFormatter from 'shared/components/mutationTable/column/NormalAlleleFreqColumnFormatter';
+import ChromosomeColumnFormatter from 'shared/components/mutationTable/column/ChromosomeColumnFormatter';
+import { getASCNMethodValue } from 'shared/components/mutationTable/column/ascnMethod/ASCNMethodColumnFormatter';
+import SampleColumnFormatter from 'shared/components/mutationTable/column/SampleColumnFormatter';
+import GeneColumnFormatter from 'shared/components/mutationTable/column/GeneColumnFormatter';
+import ProteinChangeColumnFormatter from 'shared/components/mutationTable/column/ProteinChangeColumnFormatter';
+import MutationTypeColumnFormatter from 'shared/components/mutationTable/column/MutationTypeColumnFormatter';
+import VariantTypeColumnFormatter from 'shared/components/mutationTable/column/VariantTypeColumnFormatter';
+import HgvsgColumnFormatter from 'shared/components/mutationTable/column/HgvsgColumnFormatter';
+import ClinvarColumnFormatter from 'shared/components/mutationTable/column/ClinvarColumnFormatter';
+import SignalColumnFormatter from 'shared/components/mutationTable/column/SignalColumnFormatter';
 
 type Optional<T> =
     | { isApplicable: true; value: T }
@@ -3449,16 +3470,118 @@ export class ResultsViewPageStore {
         },
     });
 
+    @computed get customDataFilterAppliers() {
+        return {
+            [ANNOTATED_PROTEIN_IMPACT_FILTER_TYPE]: createAnnotatedProteinImpactTypeFilter(
+                this.isPutativeDriver
+            ),
+            [MutationTableColumnType.CLONAL]: createNumericalFilter(
+                (d: Mutation) => {
+                    const val = getClonalValue(d);
+                    return val ? +val : null;
+                }
+            ),
+            [MutationTableColumnType.CANCER_CELL_FRACTION]: createNumericalFilter(
+                (d: Mutation) => {
+                    const val = getCancerCellFractionValue(d);
+                    return val ? +val : null;
+                }
+            ),
+            [MutationTableColumnType.EXPECTED_ALT_COPIES]: createNumericalFilter(
+                (d: Mutation) => {
+                    const val = getExpectedAltCopiesValue(d);
+                    return val ? +val : null;
+                }
+            ),
+            [MutationTableColumnType.TUMOR_ALLELE_FREQ]: createNumericalFilter(
+                (d: Mutation) =>
+                    TumorAlleleFreqColumnFormatter.getSortValue([d])
+            ),
+            [MutationTableColumnType.NORMAL_ALLELE_FREQ]: createNumericalFilter(
+                (d: Mutation) =>
+                    NormalAlleleFreqColumnFormatter.getSortValue([d])
+            ),
+            [MutationTableColumnType.REF_READS_N]: createNumericalFilter(
+                (d: Mutation) => d.normalRefCount
+            ),
+            [MutationTableColumnType.VAR_READS_N]: createNumericalFilter(
+                (d: Mutation) => d.normalAltCount
+            ),
+            [MutationTableColumnType.REF_READS]: createNumericalFilter(
+                (d: Mutation) => d.tumorRefCount
+            ),
+            [MutationTableColumnType.VAR_READS]: createNumericalFilter(
+                (d: Mutation) => d.tumorAltCount
+            ),
+            [MutationTableColumnType.START_POS]: createNumericalFilter(
+                (d: Mutation) => {
+                    const val = getTextForDataField([d], 'startPosition');
+                    return val ? +val : null;
+                }
+            ),
+            [MutationTableColumnType.END_POS]: createNumericalFilter(
+                (d: Mutation) => {
+                    const val = getTextForDataField([d], 'endPosition');
+                    return val ? +val : null;
+                }
+            ),
+            [MutationTableColumnType.SAMPLE_ID]: createCategoricalFilter(
+                (d: Mutation) => SampleColumnFormatter.getTextValue([d])
+            ),
+            [MutationTableColumnType.GENE]: createCategoricalFilter(
+                (d: Mutation) => GeneColumnFormatter.getTextValue([d])
+            ),
+            [MutationTableColumnType.PROTEIN_CHANGE]: createCategoricalFilter(
+                (d: Mutation) => ProteinChangeColumnFormatter.getTextValue([d])
+            ),
+            [MutationTableColumnType.CHROMOSOME]: createCategoricalFilter(
+                (d: Mutation) => ChromosomeColumnFormatter.getData([d]) || ''
+            ),
+            [MutationTableColumnType.REF_ALLELE]: createCategoricalFilter(
+                (d: Mutation) => getTextForDataField([d], 'referenceAllele')
+            ),
+            [MutationTableColumnType.VAR_ALLELE]: createCategoricalFilter(
+                (d: Mutation) => getTextForDataField([d], 'variantAllele')
+            ),
+            [MutationTableColumnType.MUTATION_TYPE]: createCategoricalFilter(
+                (d: Mutation) =>
+                    MutationTypeColumnFormatter.getDisplayValue([d])
+            ),
+            [MutationTableColumnType.VARIANT_TYPE]: createCategoricalFilter(
+                (d: Mutation) => VariantTypeColumnFormatter.getTextValue([d])
+            ),
+            [MutationTableColumnType.CENTER]: createCategoricalFilter(
+                (d: Mutation) => getTextForDataField([d], 'center')
+            ),
+            [MutationTableColumnType.HGVSG]: createCategoricalFilter(
+                (d: Mutation) => HgvsgColumnFormatter.download([d])
+            ),
+            [MutationTableColumnType.ASCN_METHOD]: createCategoricalFilter(
+                (d: Mutation) => getASCNMethodValue(d)
+            ),
+            [MutationTableColumnType.CLINVAR]: createCategoricalFilter(
+                (d: Mutation) =>
+                    ClinvarColumnFormatter.download(
+                        [d],
+                        this.indexedVariantAnnotations
+                    )
+            ),
+            [MutationTableColumnType.SIGNAL]: createCategoricalFilter(
+                (d: Mutation) =>
+                    SignalColumnFormatter.download(
+                        [d],
+                        this.indexedVariantAnnotations
+                    )
+            ),
+        };
+    }
+
     public createMutationMapperStoreForSelectedGene(gene: Gene) {
         const store = new ResultsViewMutationMapperStore(
             AppConfig.serverConfig,
             {
                 filterMutationsBySelectedTranscript: true,
-                filterAppliersOverride: {
-                    [ANNOTATED_PROTEIN_IMPACT_FILTER_TYPE]: createAnnotatedProteinImpactTypeFilter(
-                        this.isPutativeDriver
-                    ),
-                },
+                filterAppliersOverride: this.customDataFilterAppliers,
             },
             gene,
             this.filteredSamples,