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

package/lib/commonjs/RcsbSeacrh/FacetTools.d.ts

@@ -0,0 +1,62 @@
+import { BucketFacet } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchResultInterface";
+import { FacetMemberInterface } from "./FacetStore/FacetMemberInterface";
+import { AttributeTextQueryParameters } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchQueryInterface";
+import { Service } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { ChartDisplayConfigInterface, ChartObjectInterface, ChartType } from "@rcsb/rcsb-charts/lib/RcsbChartComponent/ChartConfigInterface";
+import { RcsbSearchAttributeType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata";
+export type SearchFilter = {
+    attribute: RcsbSearchAttributeType;
+    value: AttributeTextQueryParameters['value'];
+    operator: AttributeTextQueryParameters["operator"];
+    service: Service.Text | Service.TextChem;
+};
+export interface RcsbChartInterface<T = any> {
+    chartType: ChartType;
+    labelList?: string[];
+    attribute: RcsbSearchAttributeType;
+    attributeName: string;
+    chartConfig?: FacetMemberInterface["chartConfig"];
+    title?: string;
+    data: ChartObjectInterface<T>[];
+    filters?: SearchFilter[];
+    contentType: FacetMemberInterface['contentType'];
+}
+export declare class FacetTools {
+    static getResultDrilldowns(facetMembers: FacetMemberInterface[], searchResultFacets: Array<BucketFacet>): Array<RcsbChartInterface>;
+    static subtractDrilldowns(partial: Array<RcsbChartInterface>, full: Array<RcsbChartInterface>): Array<RcsbChartInterface>;
+    static getFacetFromName(facetMembers: FacetMemberInterface[], name: string): FacetMemberInterface | undefined;
+    static addChartDisplayConfig(chart: RcsbChartInterface, chartDisplayConfig: Partial<ChartDisplayConfigInterface>): {
+        chartConfig: {
+            chartDisplayConfig: Partial<ChartDisplayConfigInterface>;
+            mostPopulatedGroups?: number | undefined;
+            domainMinValue?: number | undefined;
+            domainMaxValue?: number | undefined;
+            domainEmptyBins?: boolean | undefined;
+            histogramBinIncrement?: number | undefined;
+            tickIncrement?: {
+                origin: number;
+                increment: number;
+            } | undefined;
+            tickFormat?: {
+                domAxis?: ((x: string | number) => string) | undefined;
+                imgAxis?: ((x: string | number) => string) | undefined;
+            } | undefined;
+            axisLabel?: string | undefined;
+            barClickCallback?: import("@rcsb/rcsb-charts/lib/RcsbChartComponent/ChartConfigInterface").BarClickCallbackType | undefined;
+            sort?: ((b: import("@rcsb/rcsb-charts/lib/RcsbChartDataProvider/ChartDataProviderInterface").ChartDataColumnInterface<any>, a: import("@rcsb/rcsb-charts/lib/RcsbChartDataProvider/ChartDataProviderInterface").ChartDataColumnInterface<any>) => number) | undefined;
+            tooltipText?: ((a: import("@rcsb/rcsb-charts/lib/RcsbChartDataProvider/ChartDataProviderInterface").ChartDataValueInterface<any>) => string | string[] | undefined) | undefined;
+            mergeDomainMaxValue?: number | undefined;
+        };
+        chartType: ChartType;
+        labelList?: string[] | undefined;
+        attribute: RcsbSearchAttributeType;
+        attributeName: string;
+        title?: string | undefined;
+        data: ChartObjectInterface<any>[];
+        filters?: SearchFilter[] | undefined;
+        contentType: "string" | "number" | "date";
+    };
+    private static includeMissingFacets;
+    private static getFacetChartTypeFromAttribute;
+    private static getFacetFiltersFromName;
+}

package/lib/commonjs/RcsbSeacrh/FacetTools.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FacetTools = void 0;
+const lodash_1 = require("lodash");
+const SearchFacetTools_1 = require("@rcsb/rcsb-search-tools/lib/SearchParseTools/SearchFacetTools");
+class FacetTools {
+    static getResultDrilldowns(facetMembers, searchResultFacets) {
+        const out = new Array();
+        const bucketList = (0, SearchFacetTools_1.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 = (0, lodash_1.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({}, (0, lodash_1.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
+        }));
+    }
+}
+exports.FacetTools = FacetTools;
+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/commonjs/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/commonjs/RcsbSeacrh/SearchQueryTools.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SearchQueryTools = void 0;
+const SearchEnums_1 = require("@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums");
+const SearchMetadata_1 = require("@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchMetadata");
+const lodash_1 = require("lodash");
+const DwEnums_1 = require("@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums");
+const DepositionGroupFacetStore_1 = require("./FacetStore/DepositionGroupFacetStore");
+const SequenceGroupFacetStore_1 = require("./FacetStore/SequenceGroupFacetStore");
+const UniprotGroupFacetStore_1 = require("./FacetStore/UniprotGroupFacetStore");
+const SearchQueryTools_1 = require("@rcsb/rcsb-search-tools/lib/SearchQueryTools/SearchQueryTools");
+var SearchQueryTools;
+(function (SearchQueryTools) {
+    function searchGroupQuery(groupProvenance, groupId, service) {
+        const groupSearchAttr = getSearchAttribute(groupProvenance);
+        return (0, SearchQueryTools_1.buildAttributeQuery)({
+            attribute: groupSearchAttr.path,
+            value: groupId,
+            operator: groupSearchAttr.operator.ExactMatch,
+            service: service !== null && service !== void 0 ? service : SearchEnums_1.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 = SearchEnums_1.LogicalOperator.And) {
+        return (0, SearchQueryTools_1.buildRequestFromCombinedSearchQuery)(searchQuery, node, returnType, logicalOperator, {
+            paginate: {
+                start: 0,
+                rows: 25
+            },
+            scoring_strategy: SearchEnums_1.ScoringStrategy.Combined,
+            sort: [
+                {
+                    sort_by: SearchEnums_1.RelevanceScoreRankingOption.Score,
+                    direction: SearchEnums_1.SortDirection.Desc
+                }
+            ],
+            results_content_type: resultsContentType
+        });
+    }
+    SearchQueryTools.buildNodeSearchQuery = buildNodeSearchQuery;
+    function buildSearchQuery(searchQuery, returnType) {
+        return (0, SearchQueryTools_1.buildRequestFromSearchQuery)(searchQuery, returnType, {
+            paginate: {
+                start: 0,
+                rows: 25
+            },
+            scoring_strategy: SearchEnums_1.ScoringStrategy.Combined,
+            sort: [
+                {
+                    sort_by: SearchEnums_1.RelevanceScoreRankingOption.Score,
+                    direction: SearchEnums_1.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 (0, SearchQueryTools_1.buildAttributeQuery)({
+            attribute,
+            value,
+            operator,
+            service,
+            negation
+        });
+    }
+    SearchQueryTools.searchAttributeQuery = searchAttributeQuery;
+    function addNodeToSearchQuery(node, searchQuery, logicalOperator = SearchEnums_1.LogicalOperator.And) {
+        if (searchQuery.type === SearchEnums_1.Type.Group && searchQuery.logical_operator === logicalOperator) {
+            const query = (0, lodash_1.cloneDeep)(searchQuery);
+            query.nodes.push(node);
+            return query;
+        }
+        return {
+            type: SearchEnums_1.Type.Group,
+            logical_operator: logicalOperator,
+            nodes: [
+                searchQuery,
+                node
+            ]
+        };
+    }
+    SearchQueryTools.addNodeToSearchQuery = addNodeToSearchQuery;
+    function getFacetStoreFromGroupProvenance(groupProvenanceId) {
+        switch (groupProvenanceId) {
+            case DwEnums_1.GroupProvenanceId.ProvenanceMatchingDepositGroupId:
+                return DepositionGroupFacetStore_1.depositionGroupFacetStore;
+            case DwEnums_1.GroupProvenanceId.ProvenanceSequenceIdentity:
+                return SequenceGroupFacetStore_1.sequenceGroupFacetStore;
+            case DwEnums_1.GroupProvenanceId.ProvenanceMatchingUniprotAccession:
+                return UniprotGroupFacetStore_1.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 DwEnums_1.GroupProvenanceId.ProvenanceMatchingDepositGroupId:
+                return SearchMetadata_1.RcsbSearchMetadata.RcsbEntryGroupMembership.GroupId;
+            case DwEnums_1.GroupProvenanceId.ProvenanceSequenceIdentity:
+                return SearchMetadata_1.RcsbSearchMetadata.RcsbPolymerEntityGroupMembership.GroupId;
+            case DwEnums_1.GroupProvenanceId.ProvenanceMatchingUniprotAccession:
+                return SearchMetadata_1.RcsbSearchMetadata.RcsbPolymerEntityGroupMembership.GroupId;
+        }
+    }
+})(SearchQueryTools || (exports.SearchQueryTools = SearchQueryTools = {}));

package/lib/commonjs/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/commonjs/RcsbSeacrh/SearchRequestProperty.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchRequestProperty = void 0;
+const tslib_1 = require("tslib");
+const RcsbRequestClient_1 = require("../RcsbRequest/RcsbRequestClient");
+const SearchQueryTools_1 = require("./SearchQueryTools");
+class SearchRequestProperty {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    _requestFacets(config) {
+        return tslib_1.__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 tslib_1.__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 tslib_1.__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: SearchQueryTools_1.SearchQueryTools.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 tslib_1.__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: SearchQueryTools_1.SearchQueryTools.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 tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.getClient().request(query);
+        });
+    }
+}
+exports.searchRequestProperty = new SearchRequestProperty(() => RcsbRequestClient_1.rcsbRequestClient.arches);

package/lib/commonjs/RcsbServerConfig/ServerConfig.d.ts

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

package/lib/commonjs/RcsbServerConfig/ServerConfig.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcsbFvWebAppPath = void 0;
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("path"));
+exports.rcsbFvWebAppPath = path.resolve(__dirname);

package/lib/commonjs/RcsbServerConfig/codegen.borrego.json

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

package/lib/commonjs/RcsbServerConfig/codegen.yosemite.json

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

package/lib/commonjs/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/commonjs/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/commonjs/RcsbUtils/Groups/GroupGapLessTransformer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupGapLessTransformer = void 0;
+const Logo_1 = require("../TrackGenerators/Logo");
+const Assertions_1 = require("../Helpers/Assertions");
+var assertElementListDefined = Assertions_1.Assertions.assertElementListDefined;
+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_1.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];
+                });
+            });
+        });
+    }
+}
+exports.GroupGapLessTransformer = GroupGapLessTransformer;

package/lib/commonjs/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/commonjs/RcsbUtils/Groups/GroupPropertiesProvider.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupPropertiesProvider = void 0;
+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"
+                });
+            });
+        }
+    }
+}
+exports.GroupPropertiesProvider = GroupPropertiesProvider;

package/lib/commonjs/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/commonjs/RcsbUtils/Groups/GroupProvenanceToAggregationType.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupProvenanceToReturnType = void 0;
+const DwEnums_1 = require("@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums");
+const SearchEnums_1 = require("@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums");
+exports.groupProvenanceToReturnType = {
+    [DwEnums_1.GroupProvenanceId.ProvenanceMatchingDepositGroupId]: SearchEnums_1.ReturnType.Entry,
+    [DwEnums_1.GroupProvenanceId.ProvenanceMatchingUniprotAccession]: SearchEnums_1.ReturnType.PolymerEntity,
+    [DwEnums_1.GroupProvenanceId.ProvenanceSequenceIdentity]: SearchEnums_1.ReturnType.PolymerEntity,
+};

package/lib/commonjs/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>[][];
+}