@rcsb/rcsb-saguaro-app 6.0.0-development.1 → 6.0.0-development.2

package/lib/RcsbSeacrh/FacetTools.js

@@ -0,0 +1,104 @@
+import { cloneDeep } from "lodash";
+import { getBucketsFromFacets } from "@rcsb/rcsb-search-tools/lib/SearchParseTools/SearchFacetTools";
+export class FacetTools {
+    static getResultDrilldowns(facetMembers, searchResultFacets) {
+        const out = new Array();
+        const bucketList = getBucketsFromFacets(searchResultFacets);
+        bucketList.forEach(bucket => {
+            const facet = FacetTools.getFacetFromName(facetMembers, bucket.name);
+            if (!facet)
+                return;
+            const chart = FacetTools.getFacetChartTypeFromAttribute(facetMembers, bucket.name);
+            out.push({
+                chartType: chart.chartType,
+                chartConfig: chart.chartConfig,
+                labelList: [],
+                attributeName: bucket.name,
+                attribute: facet.attribute,
+                title: chart.title,
+                data: applyChartConfigToData(bucket.data, facet === null || facet === void 0 ? void 0 : facet.chartConfig),
+                filters: FacetTools.getFacetFiltersFromName(facetMembers, bucket.name),
+                contentType: facet.contentType
+            });
+        });
+        return out;
+    }
+    static subtractDrilldowns(partial, full) {
+        const diff = cloneDeep(full);
+        const dataMap = new Map();
+        diff.forEach(fullChart => {
+            dataMap.set(fullChart.attributeName, new Map());
+            fullChart.data.forEach(d => {
+                var _a;
+                (_a = dataMap.get(fullChart.attributeName)) === null || _a === void 0 ? void 0 : _a.set(d.label, d);
+            });
+        });
+        partial.forEach(partialChart => {
+            partialChart.data.forEach(d => {
+                var _a;
+                const data = (_a = dataMap.get(partialChart.attributeName)) === null || _a === void 0 ? void 0 : _a.get(d.label);
+                if (data)
+                    data.population -= d.population;
+            });
+        });
+        FacetTools.includeMissingFacets(partial, diff);
+        return diff;
+    }
+    static getFacetFromName(facetMembers, name) {
+        return facetMembers.find((facet) => (facet.attributeName === name));
+    }
+    static addChartDisplayConfig(chart, chartDisplayConfig) {
+        return Object.assign(Object.assign({}, chart), { chartConfig: Object.assign(Object.assign({}, chart.chartConfig), { chartDisplayConfig: chartDisplayConfig }) });
+    }
+    static includeMissingFacets(partial, full) {
+        const partialFacetNameSet = new Set(partial.map(f => f.attributeName));
+        const fullFacetNameSet = new Map(full.map(f => [f.attributeName, f]));
+        fullFacetNameSet.forEach((v, k) => {
+            if (!partialFacetNameSet.has(k)) {
+                partial.push(Object.assign(Object.assign({}, cloneDeep(v)), { data: [] }));
+            }
+        });
+    }
+    static getFacetChartTypeFromAttribute(facetMembers, attribute) {
+        const facet = facetMembers.find((facet) => (facet.attributeName === attribute));
+        if (!facet)
+            throw `Unknown facet attribute ${attribute}`;
+        return { chartType: facet.chartType, chartConfig: facet.chartConfig, title: facet.title };
+    }
+    static getFacetFiltersFromName(facetMembers, attribute) {
+        const facet = facetMembers.find((facet) => (facet.attributeName === attribute));
+        if (!facet)
+            throw `Unknown facet attribute ${attribute}`;
+        const filters = new Array();
+        if (facet.facet.filter) {
+            filters.push(facet.facet.filter);
+        }
+        //TODO second level filters should be considered. However, when included, in some cases e.g. SCOP, the search service returns empty results
+        /*const facets = (facet.facet as TermsFacet | HistogramFacet | DateHistogramFacet | RangeFacet | DateRangeFacet | FilterFacet).facets;
+        if( facets ){
+           facets.forEach(facet=>{
+                if((facet as FilterFacet).filter ){
+                    filters.push((facet as FilterFacet).filter as FilterQueryTerminalNode);
+                }
+            })
+        }*/
+        return filters.map((f) => ({
+            operator: f.parameters.operator,
+            value: f.parameters.value,
+            attribute: f.parameters.attribute,
+            service: f.service
+        }));
+    }
+}
+function applyChartConfigToData(data, chartConfig) {
+    if (chartConfig === null || chartConfig === void 0 ? void 0 : chartConfig.mergeDomainMaxValue)
+        return mergeDomainMaxValue(data, chartConfig.mergeDomainMaxValue);
+    return data;
+}
+function mergeDomainMaxValue(data, domMaxValue) {
+    const n = data.filter(d => parseFloat(d.label.toString()) >= domMaxValue).reduce((prev, curr) => prev + curr.population, 0);
+    return n > 0 ? data.filter(d => parseFloat(d.label.toString()) < domMaxValue).concat({
+        population: n,
+        label: domMaxValue
+    }) : data;
+}

package/lib/RcsbSeacrh/SearchQueryTools.d.ts

@@ -0,0 +1,17 @@
+import { LogicalOperator, ReturnType, Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { RcsbSearchAttributeType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+import { AttributeTextQueryParameters, ResultsContentType, SearchQuery } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchQueryInterface";
+import { FacetStoreInterface } from "./FacetStore/FacetStoreInterface";
+import { GroupProvenanceId } from "@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums";
+import { SearchQueryType } from "@rcsb/rcsb-search-tools/lib/SearchQueryTools/SearchQueryInterfaces";
+export declare namespace SearchQueryTools {
+    function searchGroupQuery(groupProvenance: GroupProvenanceId, groupId: string, service?: Service.Text | Service.TextChem): SearchQueryType;
+    function addGroupNodeToSearchQuery(groupProvenanceId: GroupProvenanceId, groupId: string, searchQuery: SearchQueryType, service?: Service.Text | Service.TextChem): SearchQueryType;
+    function buildNodeSearchQuery(node: SearchQueryType, searchQuery: SearchQueryType, returnType: ReturnType, resultsContentType: ResultsContentType, logicalOperator?: LogicalOperator): SearchQuery;
+    function buildSearchQuery(searchQuery: SearchQueryType, returnType: ReturnType): SearchQuery;
+    function addNewNodeToAttributeSearchQuery(attribute: RcsbSearchAttributeType, value: AttributeTextQueryParameters['value'], operator: AttributeTextQueryParameters["operator"], searchQuery: SearchQueryType, service: Service.Text | Service.TextChem, negation?: boolean): SearchQueryType;
+    function searchAttributeQuery(attribute: RcsbSearchAttributeType, value: AttributeTextQueryParameters['value'], operator: AttributeTextQueryParameters["operator"], service: Service.Text | Service.TextChem, negation?: boolean): SearchQueryType;
+    function addNodeToSearchQuery(node: SearchQueryType, searchQuery: SearchQueryType, logicalOperator?: LogicalOperator): SearchQueryType;
+    function getFacetStoreFromGroupProvenance(groupProvenanceId: GroupProvenanceId): FacetStoreInterface;
+    function searchContentType(searchQuery?: SearchQuery): ResultsContentType;
+}

package/lib/RcsbSeacrh/SearchQueryTools.js

@@ -0,0 +1,114 @@
+import { LogicalOperator, RelevanceScoreRankingOption, ScoringStrategy, Service, SortDirection, Type } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { RcsbSearchMetadata } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+import { cloneDeep } from 'lodash';
+import { GroupProvenanceId } from "@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums";
+import { depositionGroupFacetStore } from "./FacetStore/DepositionGroupFacetStore";
+import { sequenceGroupFacetStore } from "./FacetStore/SequenceGroupFacetStore";
+import { uniprotGroupFacetStore } from "./FacetStore/UniprotGroupFacetStore";
+import { buildAttributeQuery, buildRequestFromCombinedSearchQuery, buildRequestFromSearchQuery } from "@rcsb/rcsb-search-tools/lib/SearchQueryTools/SearchQueryTools";
+export var SearchQueryTools;
+(function (SearchQueryTools) {
+    function searchGroupQuery(groupProvenance, groupId, service) {
+        const groupSearchAttr = getSearchAttribute(groupProvenance);
+        return buildAttributeQuery({
+            attribute: groupSearchAttr.path,
+            value: groupId,
+            operator: groupSearchAttr.operator.ExactMatch,
+            service: service !== null && service !== void 0 ? service : Service.Text
+        });
+    }
+    SearchQueryTools.searchGroupQuery = searchGroupQuery;
+    function addGroupNodeToSearchQuery(groupProvenanceId, groupId, searchQuery, service) {
+        return addNodeToSearchQuery(searchGroupQuery(groupProvenanceId, groupId, service), searchQuery);
+    }
+    SearchQueryTools.addGroupNodeToSearchQuery = addGroupNodeToSearchQuery;
+    function buildNodeSearchQuery(node, searchQuery, returnType, resultsContentType, logicalOperator = LogicalOperator.And) {
+        return buildRequestFromCombinedSearchQuery(searchQuery, node, returnType, logicalOperator, {
+            paginate: {
+                start: 0,
+                rows: 25
+            },
+            scoring_strategy: ScoringStrategy.Combined,
+            sort: [
+                {
+                    sort_by: RelevanceScoreRankingOption.Score,
+                    direction: SortDirection.Desc
+                }
+            ],
+            results_content_type: resultsContentType
+        });
+    }
+    SearchQueryTools.buildNodeSearchQuery = buildNodeSearchQuery;
+    function buildSearchQuery(searchQuery, returnType) {
+        return buildRequestFromSearchQuery(searchQuery, returnType, {
+            paginate: {
+                start: 0,
+                rows: 25
+            },
+            scoring_strategy: ScoringStrategy.Combined,
+            sort: [
+                {
+                    sort_by: RelevanceScoreRankingOption.Score,
+                    direction: SortDirection.Desc
+                }
+            ]
+        });
+    }
+    SearchQueryTools.buildSearchQuery = buildSearchQuery;
+    function addNewNodeToAttributeSearchQuery(attribute, value, operator, searchQuery, service, negation = false) {
+        return addNodeToSearchQuery(searchAttributeQuery(attribute, value, operator, service, negation), searchQuery);
+    }
+    SearchQueryTools.addNewNodeToAttributeSearchQuery = addNewNodeToAttributeSearchQuery;
+    function searchAttributeQuery(attribute, value, operator, service, negation = false) {
+        return buildAttributeQuery({
+            attribute,
+            value,
+            operator,
+            service,
+            negation
+        });
+    }
+    SearchQueryTools.searchAttributeQuery = searchAttributeQuery;
+    function addNodeToSearchQuery(node, searchQuery, logicalOperator = LogicalOperator.And) {
+        if (searchQuery.type === Type.Group && searchQuery.logical_operator === logicalOperator) {
+            const query = cloneDeep(searchQuery);
+            query.nodes.push(node);
+            return query;
+        }
+        return {
+            type: Type.Group,
+            logical_operator: logicalOperator,
+            nodes: [
+                searchQuery,
+                node
+            ]
+        };
+    }
+    SearchQueryTools.addNodeToSearchQuery = addNodeToSearchQuery;
+    function getFacetStoreFromGroupProvenance(groupProvenanceId) {
+        switch (groupProvenanceId) {
+            case GroupProvenanceId.ProvenanceMatchingDepositGroupId:
+                return depositionGroupFacetStore;
+            case GroupProvenanceId.ProvenanceSequenceIdentity:
+                return sequenceGroupFacetStore;
+            case GroupProvenanceId.ProvenanceMatchingUniprotAccession:
+                return uniprotGroupFacetStore;
+        }
+    }
+    SearchQueryTools.getFacetStoreFromGroupProvenance = getFacetStoreFromGroupProvenance;
+    function searchContentType(searchQuery) {
+        var _a, _b;
+        return (_b = (_a = searchQuery === null || searchQuery === void 0 ? void 0 : searchQuery.request_options) === null || _a === void 0 ? void 0 : _a.results_content_type) !== null && _b !== void 0 ? _b : ["computational", "experimental"];
+    }
+    SearchQueryTools.searchContentType = searchContentType;
+    function getSearchAttribute(groupProvenanceId) {
+        switch (groupProvenanceId) {
+            case GroupProvenanceId.ProvenanceMatchingDepositGroupId:
+                return RcsbSearchMetadata.RcsbEntryGroupMembership.GroupId;
+            case GroupProvenanceId.ProvenanceSequenceIdentity:
+                return RcsbSearchMetadata.RcsbPolymerEntityGroupMembership.GroupId;
+            case GroupProvenanceId.ProvenanceMatchingUniprotAccession:
+                return RcsbSearchMetadata.RcsbPolymerEntityGroupMembership.GroupId;
+        }
+    }
+})(SearchQueryTools || (SearchQueryTools = {}));

package/lib/RcsbSeacrh/SearchRequestProperty.d.ts

@@ -0,0 +1,17 @@
+import { SearchRequest } from "@rcsb/rcsb-api-tools/build/RcsbSearch/SearchRequest";
+import { QueryResult } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchResultInterface";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { ResultsContentType, SearchQuery } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchQueryInterface";
+import { FacetType } from "./FacetStore/FacetMemberInterface";
+import { SearchQueryType } from "@rcsb/rcsb-search-tools/lib/SearchQueryTools/SearchQueryInterfaces";
+declare class SearchRequestProperty {
+    private readonly getClient;
+    constructor(getClient: () => SearchRequest);
+    private _requestFacets;
+    requestFacets(query: SearchQueryType, facets: FacetType[], returnType: ReturnType, resultsContentType: ResultsContentType): Promise<QueryResult | null>;
+    requestMembers(query: SearchQuery): Promise<string[]>;
+    requestCount(query: SearchQuery): Promise<number>;
+    request(query: SearchQuery): Promise<QueryResult | null>;
+}
+export declare const searchRequestProperty: SearchRequestProperty;
+export {};

package/lib/RcsbSeacrh/SearchRequestProperty.js

@@ -0,0 +1,70 @@
+import { __awaiter } from "tslib";
+import { rcsbRequestClient } from "../RcsbRequest/RcsbRequestClient";
+import { SearchQueryTools as SQT } from "./SearchQueryTools";
+class SearchRequestProperty {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    _requestFacets(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const facet = config.facets.shift();
+            return yield this.getClient().request({
+                query: config.query,
+                request_options: facet ? {
+                    paginate: {
+                        start: 0,
+                        rows: 0
+                    },
+                    facets: [facet, ...config.facets],
+                    results_content_type: config.resultsContentType
+                } : {
+                    paginate: {
+                        start: 0,
+                        rows: 0
+                    },
+                    results_content_type: config.resultsContentType
+                },
+                return_type: config.returnType
+            });
+        });
+    }
+    requestFacets(query, facets, returnType, resultsContentType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._requestFacets({ query: query, facets: facets, returnType: returnType, resultsContentType: resultsContentType });
+        });
+    }
+    //TODO this should be part of `SearchQueryTools`
+    requestMembers(query) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_c = (_b = (_a = (yield this.getClient().request({
+                query: query.query,
+                request_options: {
+                    return_all_hits: true,
+                    results_content_type: SQT.searchContentType(query)
+                },
+                return_type: query.return_type
+            }))) === null || _a === void 0 ? void 0 : _a.result_set) === null || _b === void 0 ? void 0 : _b.map(item => typeof item === "string" ? item : item.identifier)) !== null && _c !== void 0 ? _c : [];
+        });
+    }
+    //TODO this should be part of `SearchQueryTools`
+    requestCount(query) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            return (_b = (_a = (yield this.getClient().request({
+                query: query.query,
+                request_options: {
+                    return_counts: true,
+                    results_content_type: SQT.searchContentType(query)
+                },
+                return_type: query.return_type
+            }))) === null || _a === void 0 ? void 0 : _a.total_count) !== null && _b !== void 0 ? _b : -1;
+        });
+    }
+    request(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.getClient().request(query);
+        });
+    }
+}
+export const searchRequestProperty = new SearchRequestProperty(() => rcsbRequestClient.arches);

package/lib/RcsbServerConfig/ServerConfig.d.ts

@@ -0,0 +1 @@
+export declare const rcsbFvWebAppPath: string;

package/lib/RcsbServerConfig/ServerConfig.js

@@ -0,0 +1,2 @@
+import * as path from "path";
+export const rcsbFvWebAppPath = path.resolve(__dirname);

package/lib/RcsbServerConfig/codegen.borrego.json

@@ -0,0 +1,4 @@
+{
+    "schema": "https://1d-coordinates.rcsb.org/graphql",
+    "documents": "src/RcsbQueries/Borrego/Query*.graphql"
+}

package/lib/RcsbServerConfig/codegen.yosemite.json

@@ -0,0 +1,4 @@
+{
+    "schema": "https://data.rcsb.org/graphql",
+    "documents": "src/RcsbQueries/Yosemite/Query*.graphql"
+}

package/lib/RcsbServerConfig/web.resources.json

@@ -0,0 +1,43 @@
+{
+    "swiss_model": {
+        "url": "https://swissmodel.expasy.org/repository/uniprot/",
+        "url_suffix": ".json?provider=swissmodel"
+    },
+    "rcsb_entry": {
+        "url": "/structure/"
+    },
+    "rcsb_3d_view": {
+        "url": "/3d-view/"
+    },
+    "rcsb_ligand": {
+        "url": "/ligand/"
+    },
+    "rcsb_uniprot": {
+        "url": "/groups/sequence/polymer_entity/"
+    },
+    "rcsb_search": {
+        "url": "/search?request="
+    },
+    "uniprot": {
+        "url": "https://www.uniprot.org/uniprot/"
+    },
+    "ncbi_summary_nuccore": {
+        "url": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=nuccore&id=",
+        "url_suffix": "&retmode=json"
+    },
+    "ncbi_summary_taxonomy": {
+        "url": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/esummary.fcgi?db=taxonomy&id=",
+        "url_suffix": "&retmode=json"
+    },
+    "ncbi_genome_sequence": {
+        "url": "https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nuccore&",
+        "url_suffix": "&rettype=fasta&retmode=text"
+    },
+    "rcsb_cdn": {
+        "url": "https://cdn.rcsb.org/images/structures/"
+    },
+    "1d3d-alignment": {
+        "url": "/groups/3d-sequence/polymer_entity/",
+        "url_suffix": "?request="
+    }
+}

package/lib/RcsbUtils/Groups/GroupGapLessTransformer.d.ts

@@ -0,0 +1,8 @@
+import { AlignmentResponse, AnnotationFeatures } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+export declare class GroupGapLessTransformer {
+    private readonly gapLessReference;
+    private refLength;
+    private processAlignments;
+    gapLessAlignments(alignments: AlignmentResponse): void;
+    gapLessFeatures(annotations: Array<AnnotationFeatures>): void;
+}

package/lib/RcsbUtils/Groups/GroupGapLessTransformer.js

@@ -0,0 +1,76 @@
+import { Logo } from "../TrackGenerators/Logo";
+import { Assertions } from "../Helpers/Assertions";
+var assertElementListDefined = Assertions.assertElementListDefined;
+export class GroupGapLessTransformer {
+    constructor() {
+        this.gapLessReference = [];
+    }
+    processAlignments(alignment) {
+        var _a, _b;
+        if (this.gapLessReference.length > 0 || !alignment.alignment_logo)
+            return;
+        const querySequenceLogo = new Array();
+        if (alignment.alignment_length && alignment.alignment_length != ((_a = alignment.alignment_logo) === null || _a === void 0 ? void 0 : _a.length))
+            throw new Error("ERROR Alignment length and logo should match");
+        (_b = alignment.alignment_logo) === null || _b === void 0 ? void 0 : _b.forEach(al => {
+            assertElementListDefined(al);
+            querySequenceLogo.push(new Logo(al));
+        });
+        let newIndex = 1;
+        this.gapLessReference[0] = -1;
+        querySequenceLogo.forEach((sl, n) => {
+            if ((sl.get("-") / sl.total()) == 1) {
+                this.gapLessReference[n + 1] = -1;
+            }
+            else {
+                this.gapLessReference[n + 1] = newIndex++;
+            }
+        });
+        this.refLength = newIndex - 1;
+    }
+    gapLessAlignments(alignments) {
+        var _a, _b, _c, _d;
+        this.processAlignments(alignments);
+        if (this.gapLessReference.length == 0)
+            return;
+        if (alignments.target_alignment)
+            (_a = alignments.target_alignment) === null || _a === void 0 ? void 0 : _a.forEach(ta => {
+                var _a;
+                (_a = ta === null || ta === void 0 ? void 0 : ta.aligned_regions) === null || _a === void 0 ? void 0 : _a.forEach(region => {
+                    if (region === null || region === void 0 ? void 0 : region.query_begin)
+                        region.query_begin = this.gapLessReference[region.query_begin];
+                    if (region === null || region === void 0 ? void 0 : region.query_end)
+                        region.query_end = this.gapLessReference[region.query_end];
+                });
+            });
+        else
+            (_c = (_b = alignments.target_alignment_subset) === null || _b === void 0 ? void 0 : _b.edges) === null || _c === void 0 ? void 0 : _c.forEach(edge => {
+                var _a, _b;
+                (_b = (_a = edge === null || edge === void 0 ? void 0 : edge.node) === null || _a === void 0 ? void 0 : _a.aligned_regions) === null || _b === void 0 ? void 0 : _b.forEach(region => {
+                    if (region === null || region === void 0 ? void 0 : region.query_begin)
+                        region.query_begin = this.gapLessReference[region.query_begin];
+                    if (region === null || region === void 0 ? void 0 : region.query_end)
+                        region.query_end = this.gapLessReference[region.query_end];
+                });
+            });
+        alignments.alignment_logo = (_d = alignments.alignment_logo) === null || _d === void 0 ? void 0 : _d.filter((al, n) => this.gapLessReference[n + 1] != -1);
+        if (alignments.alignment_length)
+            alignments.alignment_length = this.refLength;
+    }
+    gapLessFeatures(annotations) {
+        if (this.gapLessReference.length == 0)
+            return;
+        annotations.forEach(ann => {
+            var _a;
+            (_a = ann.features) === null || _a === void 0 ? void 0 : _a.forEach(feature => {
+                var _a;
+                (_a = feature === null || feature === void 0 ? void 0 : feature.feature_positions) === null || _a === void 0 ? void 0 : _a.forEach(position => {
+                    if (position === null || position === void 0 ? void 0 : position.beg_seq_id)
+                        position.beg_seq_id = this.gapLessReference[position.beg_seq_id];
+                    if (position === null || position === void 0 ? void 0 : position.end_seq_id)
+                        position.end_seq_id = this.gapLessReference[position.end_seq_id];
+                });
+            });
+        });
+    }
+}

package/lib/RcsbUtils/Groups/GroupPropertiesProvider.d.ts

@@ -0,0 +1,16 @@
+import { EntryPropertyIntreface } from "../../RcsbCollectTools/DataCollectors/MultipleEntryPropertyCollector";
+export interface GroupPropertiesProviderInterface {
+    entryProperties: Array<EntryPropertyIntreface>;
+}
+interface ItemPropertyInterface {
+    objectId: string;
+    value: number | string;
+}
+export type GroupPropertyType = "experimental_method" | "resolution";
+export declare class GroupPropertiesProvider {
+    private readonly entryProperties;
+    constructor(properties: GroupPropertiesProviderInterface);
+    get(key: GroupPropertyType): ItemPropertyInterface[] | undefined;
+    private getEntryProperties;
+}
+export {};

package/lib/RcsbUtils/Groups/GroupPropertiesProvider.js

@@ -0,0 +1,27 @@
+export class GroupPropertiesProvider {
+    constructor(properties) {
+        this.entryProperties = properties.entryProperties;
+    }
+    get(key) {
+        if (key === "experimental_method" || key === "resolution") {
+            return this.getEntryProperties(key);
+        }
+    }
+    getEntryProperties(key) {
+        if (key === "experimental_method") {
+            return this.entryProperties.map(p => ({
+                objectId: p.rcsbId,
+                value: p.experimentalMethod
+            }));
+        }
+        else if (key === "resolution") {
+            return this.entryProperties.map(p => {
+                var _a;
+                return ({
+                    objectId: p.rcsbId,
+                    value: (_a = p.resolution) !== null && _a !== void 0 ? _a : "NA"
+                });
+            });
+        }
+    }
+}

package/lib/RcsbUtils/Groups/GroupProvenanceToAggregationType.d.ts

@@ -0,0 +1,6 @@
+import { GroupProvenanceId } from "@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+interface GroupProvenanceToReturnType extends Record<GroupProvenanceId, ReturnType> {
+}
+export declare const groupProvenanceToReturnType: GroupProvenanceToReturnType;
+export {};

package/lib/RcsbUtils/Groups/GroupProvenanceToAggregationType.js

@@ -0,0 +1,7 @@
+import { GroupProvenanceId } from "@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+export const groupProvenanceToReturnType = {
+    [GroupProvenanceId.ProvenanceMatchingDepositGroupId]: ReturnType.Entry,
+    [GroupProvenanceId.ProvenanceMatchingUniprotAccession]: ReturnType.PolymerEntity,
+    [GroupProvenanceId.ProvenanceSequenceIdentity]: ReturnType.PolymerEntity,
+};

package/lib/RcsbUtils/Helpers/Assertions.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Assertions {
+    function assertDefined<T>(x: T, message?: string): asserts x is NonNullable<T>;
+    function assertElementListDefined<T>(x: (T | undefined | null)[] | undefined | null, message?: string): asserts x is NonNullable<T>[];
+    function assertElementMatrixDefined<T>(x: ((T | undefined | null)[] | undefined | null)[] | undefined | null, message?: string): asserts x is NonNullable<T>[][];
+}

package/lib/RcsbUtils/Helpers/Assertions.js

@@ -0,0 +1,26 @@
+export var Assertions;
+(function (Assertions) {
+    function assertDefined(x, message) {
+        if (x === null || x === undefined)
+            throw message ? new Error(message) : new Error(`Undefined value`);
+    }
+    Assertions.assertDefined = assertDefined;
+    function assertElementListDefined(x, message) {
+        if (x === null || x === undefined)
+            throw new Error(`Undefined list`);
+        x.forEach((e, n) => {
+            if (e === null || x === undefined)
+                throw message ? new Error(`${message} in index ${n}`) : new Error(`Undefined value in index ${n}`);
+        });
+    }
+    Assertions.assertElementListDefined = assertElementListDefined;
+    function assertElementMatrixDefined(x, message) {
+        if (x === null || x === undefined)
+            throw new Error(`Undefined list`);
+        x.flat().forEach((e, n) => {
+            if (e === null || x === undefined)
+                throw message ? new Error(`${message} in index ${n}`) : new Error(`Undefined value in index ${n}`);
+        });
+    }
+    Assertions.assertElementMatrixDefined = assertElementMatrixDefined;
+})(Assertions || (Assertions = {}));

package/lib/RcsbUtils/Helpers/DataContainer.d.ts

@@ -0,0 +1,9 @@
+export declare class DataContainer<T> {
+    private data;
+    constructor(data?: T);
+    get(): T | undefined;
+    set(data: T | undefined): void;
+}
+export interface DataContainerReader<T> {
+    get(): T | undefined;
+}

package/lib/RcsbUtils/Helpers/DataContainer.js

@@ -0,0 +1,12 @@
+export class DataContainer {
+    constructor(data) {
+        this.data = undefined;
+        this.data = data;
+    }
+    get() {
+        return this.data;
+    }
+    set(data) {
+        this.data = data;
+    }
+}

package/lib/RcsbUtils/Helpers/ObservableHelper.d.ts

@@ -0,0 +1,4 @@
+import { Subject } from "rxjs";
+export declare class ObservableHelper {
+    static oneTimeSubscription<T>(resolve: (x: T) => void, subject: Subject<T>, resolveCondition?: (x: T) => boolean): void;
+}

package/lib/RcsbUtils/Helpers/ObservableHelper.js

@@ -0,0 +1,12 @@
+export class ObservableHelper {
+    static oneTimeSubscription(resolve, subject, resolveCondition) {
+        const s = subject.subscribe({
+            next(x) {
+                if (!resolveCondition || resolveCondition(x)) {
+                    resolve(x);
+                    s.unsubscribe();
+                }
+            }
+        });
+    }
+}

package/lib/RcsbUtils/Helpers/Operator.d.ts

@@ -0,0 +1,5 @@
+export declare class Operator {
+    static uniqueValues<T>(array: Array<T>): T[];
+    static arrayChunk<T>(array: Array<T>, size: number): Array<Array<T>>;
+    static digitGrouping(x: string | number): string;
+}

package/lib/RcsbUtils/Helpers/Operator.js

@@ -0,0 +1,15 @@
+export class Operator {
+    static uniqueValues(array) {
+        return Array.from(new Set(array));
+    }
+    static arrayChunk(array, size) {
+        const out = new Array();
+        for (let i = 0; i < array.length; i += size) {
+            out.push(array.slice(i, i + size));
+        }
+        return out;
+    }
+    static digitGrouping(x) {
+        return parseFloat(x).toLocaleString('en-US');
+    }
+}

package/lib/RcsbUtils/Helpers/SingletonMap.d.ts

@@ -0,0 +1,4 @@
+export declare class SingletonMap {
+    private static readonly map;
+    static update(key: string, obj: any): void;
+}