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

package/lib/commonjs/RcsbGraphQL/RcsbClient.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rcsbClient = void 0;
+const tslib_1 = require("tslib");
+const RcsbQueryAnnotations_1 = require("./RcsbQueryAnnotations");
+const RcsbQueryAlignment_1 = require("./RcsbQueryAlignment");
+const RcsbQueryEntryInstances_1 = require("./RcsbQueryEntryInstances");
+const RcsbQueryMultipleEntityInstances_1 = require("./RcsbQueryMultipleEntityInstances");
+const RcsbQueryGroup_1 = require("./RcsbQueryGroup");
+const RcsbQueryMultipleEntriesProperties_1 = require("./RcsbQueryMultipleEntriesProperties");
+const RcsbQueryInterfaceInstances_1 = require("./RcsbQueryInterfaceInstances");
+const RcsbQueryAssemblyInterfaces_1 = require("./RcsbQueryAssemblyInterfaces");
+const RcsbRequestClient_1 = require("../RcsbRequest/RcsbRequestClient");
+const RcsbQueryMultipleInstanceSequences_1 = require("./RcsbQueryMultipleInstanceSequences");
+//TODO Implement a cache to store requests and avoid duplication
+class RcsbClientClass {
+    constructor(get) {
+        this.rcsbQueryAnnotations = new RcsbQueryAnnotations_1.RcsbQueryAnnotations(get.borrego);
+        this.rcsbQueryGroupAnnotations = new RcsbQueryAnnotations_1.RcsbQueryGroupAnnotations(get.borrego);
+        this.rcsbQueryAlignment = new RcsbQueryAlignment_1.RcsbQueryAlignment(get.borrego);
+        this.rcsbQueryGroupAlignment = new RcsbQueryAlignment_1.RcsbQueryGroupAlignment(get.borrego);
+        this.rcsbQueryEntityInstances = new RcsbQueryEntryInstances_1.RcsbQueryEntryInstances(get.yosemite);
+        this.rcsbQueryMutipleEntityInstances = new RcsbQueryMultipleEntityInstances_1.RcsbQueryMultipleEntityInstances(get.yosemite);
+        this.rcsbQueryEntryProperties = new RcsbQueryMultipleEntriesProperties_1.RcsbQueryMultipleEntriesProperties(get.yosemite);
+        this.rcsbQueryInterfaceInstances = new RcsbQueryInterfaceInstances_1.RcsbQueryInterfaceInstances(get.yosemite);
+        this.rcsbQueryAssemblyInterfaces = new RcsbQueryAssemblyInterfaces_1.RcsbQueryAssemblyInterfaces(get.yosemite);
+        this.rcsbQueryGroup = new RcsbQueryGroup_1.RcsbQueryGroup(get.yosemite);
+        this.rcsbQueryMultipleInstanceSequences = new RcsbQueryMultipleInstanceSequences_1.RcsbQueryMultipleInstanceSequences(get.yosemite);
+    }
+    requestRcsbPdbAnnotations(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryAnnotations.request(requestConfig);
+        });
+    }
+    requestRcsbPdbGroupAnnotations(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryGroupAnnotations.request(requestConfig);
+        });
+    }
+    requestAlignment(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryAlignment.request(requestConfig);
+        });
+    }
+    requestGroupAlignment(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryGroupAlignment.request(requestConfig);
+        });
+    }
+    requestEntityInstances(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryEntityInstances.request(requestConfig);
+        });
+    }
+    requestMultipleEntityInstances(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryMutipleEntityInstances.request(requestConfig);
+        });
+    }
+    requestGroupInfo(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryGroup.request(requestConfig);
+        });
+    }
+    requestMultipleEntriesProperties(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryEntryProperties.request(requestConfig);
+        });
+    }
+    requestInterfaceInstances(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryInterfaceInstances.request(requestConfig);
+        });
+    }
+    requestAssemblyInterfaces(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryAssemblyInterfaces.request(requestConfig);
+        });
+    }
+    requestMultipleInstanceSequences(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.rcsbQueryMultipleInstanceSequences.request(requestConfig);
+        });
+    }
+}
+exports.rcsbClient = new RcsbClientClass({ borrego: () => RcsbRequestClient_1.rcsbRequestClient.borrego, yosemite: () => RcsbRequestClient_1.rcsbRequestClient.yosemite });

package/lib/commonjs/RcsbGraphQL/RcsbCoreQueryInterface.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export interface RcsbCoreQueryInterface<Q, R> {
+    readonly getClient: () => GraphQLRequest;
+    request(requestConfig: Q): Promise<R>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbCoreQueryInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/RcsbGraphQL/RcsbQueryAlignment.d.ts

@@ -0,0 +1,20 @@
+import { AlignmentResponse, QueryAlignmentArgs, QueryGroup_AlignmentArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryAlignment implements RcsbCoreQueryInterface<QueryAlignmentArgs, AlignmentResponse> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryAlignmentArgs): Promise<AlignmentResponse>;
+}
+export type RcsbQueryGroupAlignmentArguments = QueryGroup_AlignmentArgs & {
+    page: {
+        first: number;
+        after: string;
+    };
+    excludeLogo?: boolean;
+};
+export declare class RcsbQueryGroupAlignment implements RcsbCoreQueryInterface<RcsbQueryGroupAlignmentArguments, AlignmentResponse> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: RcsbQueryGroupAlignmentArguments): Promise<AlignmentResponse>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryAlignment.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryGroupAlignment = exports.RcsbQueryAlignment = void 0;
+const tslib_1 = require("tslib");
+const QueryAlignments_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Borrego/QueryAlignments.graphql"));
+const QueryGroupAlignments_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Borrego/QueryGroupAlignments.graphql"));
+const QueryGroupAlignmentsNoLogo_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Borrego/QueryGroupAlignmentsNoLogo.graphql"));
+class RcsbQueryAlignment {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.getClient().request({
+                    queryId: requestConfig.queryId,
+                    from: requestConfig.from,
+                    to: requestConfig.to,
+                    range: requestConfig.range
+                }, QueryAlignments_graphql_1.default);
+                return result.alignment;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryAlignment = RcsbQueryAlignment;
+class RcsbQueryGroupAlignment {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.getClient().request({ group: requestConfig.group, groupId: requestConfig.groupId, filter: requestConfig.filter, first: requestConfig.page.first, after: requestConfig.page.after }, requestConfig.excludeLogo ? QueryGroupAlignmentsNoLogo_graphql_1.default : QueryGroupAlignments_graphql_1.default);
+                return result.group_alignment;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryGroupAlignment = RcsbQueryGroupAlignment;

package/lib/commonjs/RcsbGraphQL/RcsbQueryAnnotations.d.ts

@@ -0,0 +1,13 @@
+import { AnnotationFeatures, QueryAnnotationsArgs, QueryGroup_AnnotationsArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Borrego/GqlTypes";
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryAnnotations implements RcsbCoreQueryInterface<QueryAnnotationsArgs, Array<AnnotationFeatures>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryAnnotationsArgs): Promise<Array<AnnotationFeatures>>;
+}
+export declare class RcsbQueryGroupAnnotations implements RcsbCoreQueryInterface<QueryGroup_AnnotationsArgs, Array<AnnotationFeatures>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryGroup_AnnotationsArgs): Promise<Array<AnnotationFeatures>>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryAnnotations.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryGroupAnnotations = exports.RcsbQueryAnnotations = void 0;
+const tslib_1 = require("tslib");
+const QueryAnnotations_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Borrego/QueryAnnotations.graphql"));
+const QueryGroupAnnotations_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Borrego/QueryGroupAnnotations.graphql"));
+class RcsbQueryAnnotations {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const annotationsResponse = yield this.getClient().request({
+                    queryId: requestConfig.queryId,
+                    reference: requestConfig.reference,
+                    sources: requestConfig.sources,
+                    filters: requestConfig.filters,
+                    range: requestConfig.range
+                }, QueryAnnotations_graphql_1.default);
+                return annotationsResponse.annotations;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryAnnotations = RcsbQueryAnnotations;
+class RcsbQueryGroupAnnotations {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const annotationsResponse = yield this.getClient().request(requestConfig, QueryGroupAnnotations_graphql_1.default);
+                return annotationsResponse.group_annotations;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryGroupAnnotations = RcsbQueryGroupAnnotations;

package/lib/commonjs/RcsbGraphQL/RcsbQueryAssemblyInterfaces.d.ts

@@ -0,0 +1,8 @@
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { CoreAssembly, QueryAssembliesArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryAssemblyInterfaces implements RcsbCoreQueryInterface<QueryAssembliesArgs, Array<CoreAssembly>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryAssembliesArgs): Promise<Array<CoreAssembly>>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryAssemblyInterfaces.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryAssemblyInterfaces = void 0;
+const tslib_1 = require("tslib");
+const QueryAssemblyInterfaces_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryAssemblyInterfaces.graphql"));
+class RcsbQueryAssemblyInterfaces {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.getClient().request(requestConfig, QueryAssemblyInterfaces_graphql_1.default);
+                return response.assemblies;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryAssemblyInterfaces = RcsbQueryAssemblyInterfaces;

package/lib/commonjs/RcsbGraphQL/RcsbQueryEntryInstances.d.ts

@@ -0,0 +1,8 @@
+import { CoreEntry, QueryEntryArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryEntryInstances implements RcsbCoreQueryInterface<QueryEntryArgs, CoreEntry> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryEntryArgs): Promise<CoreEntry>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryEntryInstances.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryEntryInstances = void 0;
+const tslib_1 = require("tslib");
+const QueryEntryInstances_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryEntryInstances.graphql"));
+class RcsbQueryEntryInstances {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.getClient().request({
+                    entry_id: requestConfig.entry_id,
+                }, QueryEntryInstances_graphql_1.default);
+                return response.entry;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryEntryInstances = RcsbQueryEntryInstances;

package/lib/commonjs/RcsbGraphQL/RcsbQueryGroup.d.ts

@@ -0,0 +1,8 @@
+import { GroupPolymerEntity, QueryPolymer_Entity_GroupArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryGroup implements RcsbCoreQueryInterface<QueryPolymer_Entity_GroupArgs, GroupPolymerEntity> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryPolymer_Entity_GroupArgs): Promise<GroupPolymerEntity>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryGroup.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryGroup = void 0;
+const tslib_1 = require("tslib");
+const QueryGroup_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryGroup.graphql"));
+class RcsbQueryGroup {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.getClient().request({
+                    group_id: requestConfig.group_id
+                }, QueryGroup_graphql_1.default);
+                return response.group;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryGroup = RcsbQueryGroup;

package/lib/commonjs/RcsbGraphQL/RcsbQueryInterfaceInstances.d.ts

@@ -0,0 +1,8 @@
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { CoreInterface, QueryInterfacesArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryInterfaceInstances implements RcsbCoreQueryInterface<QueryInterfacesArgs, Array<CoreInterface>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryInterfacesArgs): Promise<Array<CoreInterface>>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryInterfaceInstances.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryInterfaceInstances = void 0;
+const tslib_1 = require("tslib");
+const QueryInterfaceInstances_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryInterfaceInstances.graphql"));
+class RcsbQueryInterfaceInstances {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.getClient().request(requestConfig, QueryInterfaceInstances_graphql_1.default);
+                return response.interfaces;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryInterfaceInstances = RcsbQueryInterfaceInstances;

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleEntityInstances.d.ts

@@ -0,0 +1,8 @@
+import { CorePolymerEntity, QueryPolymer_EntitiesArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryMultipleEntityInstances implements RcsbCoreQueryInterface<QueryPolymer_EntitiesArgs, Array<CorePolymerEntity>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryPolymer_EntitiesArgs): Promise<Array<CorePolymerEntity>>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleEntityInstances.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryMultipleEntityInstances = void 0;
+const tslib_1 = require("tslib");
+const QueryMultipleEntityInstances_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryMultipleEntityInstances.graphql"));
+class RcsbQueryMultipleEntityInstances {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.getClient().request({
+                    entity_ids: requestConfig.entity_ids,
+                }, QueryMultipleEntityInstances_graphql_1.default);
+                return result.polymer_entities;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryMultipleEntityInstances = RcsbQueryMultipleEntityInstances;

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleEntriesProperties.d.ts

@@ -0,0 +1,8 @@
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { CoreEntry, QueryEntriesArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryMultipleEntriesProperties implements RcsbCoreQueryInterface<QueryEntriesArgs, Array<CoreEntry>> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryEntriesArgs): Promise<Array<CoreEntry>>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleEntriesProperties.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryMultipleEntriesProperties = void 0;
+const tslib_1 = require("tslib");
+const QueryMultipleEntriesProperties_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryMultipleEntriesProperties.graphql"));
+class RcsbQueryMultipleEntriesProperties {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.getClient().request({
+                    entry_ids: requestConfig.entry_ids,
+                }, QueryMultipleEntriesProperties_graphql_1.default);
+                return response.entries;
+            }
+            catch (error) {
+                console.error(error);
+                throw error;
+            }
+        });
+    }
+}
+exports.RcsbQueryMultipleEntriesProperties = RcsbQueryMultipleEntriesProperties;

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleInstanceSequences.d.ts

@@ -0,0 +1,8 @@
+import { RcsbCoreQueryInterface } from "./RcsbCoreQueryInterface";
+import { CorePolymerEntityInstance, QueryPolymer_Entity_InstancesArgs } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/Types/Yosemite/GqlTypes";
+import { GraphQLRequest } from "@rcsb/rcsb-api-tools/build/RcsbGraphQL/GraphQLRequest";
+export declare class RcsbQueryMultipleInstanceSequences implements RcsbCoreQueryInterface<QueryPolymer_Entity_InstancesArgs, CorePolymerEntityInstance[]> {
+    readonly getClient: () => GraphQLRequest;
+    constructor(getClient: () => GraphQLRequest);
+    request(requestConfig: QueryPolymer_Entity_InstancesArgs): Promise<CorePolymerEntityInstance[]>;
+}

package/lib/commonjs/RcsbGraphQL/RcsbQueryMultipleInstanceSequences.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcsbQueryMultipleInstanceSequences = void 0;
+const tslib_1 = require("tslib");
+const QueryMultipleInstanceSequences_graphql_1 = tslib_1.__importDefault(require("../RcsbQueries/Yosemite/QueryMultipleInstanceSequences.graphql"));
+class RcsbQueryMultipleInstanceSequences {
+    constructor(getClient) {
+        this.getClient = getClient;
+    }
+    request(requestConfig) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield this.getClient().request({
+                    instance_ids: requestConfig.instance_ids
+                }, QueryMultipleInstanceSequences_graphql_1.default);
+                return result.polymer_entity_instances;
+            }
+            catch (error) {
+                console.error(error);
+                throw new Error(error);
+            }
+        });
+    }
+}
+exports.RcsbQueryMultipleInstanceSequences = RcsbQueryMultipleInstanceSequences;

package/lib/commonjs/RcsbGroupWeb/RcsbGroupBuilder.d.ts

@@ -0,0 +1,17 @@
+import { SearchQuery } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchQueryInterface";
+import { GroupProvenanceId } from "@rcsb/rcsb-api-tools/build/RcsbDw/Types/DwEnums";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+import { GroupChartAdditionalProperties } from "./RcsbGroupView/RcsbGroupChart/GroupChartAdditionalProperties";
+import { SearchQueryContextManagerSubjectInterface } from "./RcsbGroupView/RcsbGroupSeacrhQuery/SearchQueryContextManager";
+import { Subscription } from "rxjs";
+import { RcsbGroupContentTextInterface } from "./RcsbGroupView/RcsbGroupContent/RcsbGroupContentComponent";
+import { ResidueChartInterface } from "./RcsbGroupView/RcsbResidueChart/ResidueChartTools/ResidueChartTools";
+import { ChartDisplayConfigInterface } from "@rcsb/rcsb-charts/lib/RcsbChartComponent/ChartConfigInterface";
+export declare function buildSearchRequest(elementId: string, searchQuery: SearchQuery, returnType: ReturnType): Promise<void>;
+export declare function buildGroup(elementId: string, groupProvenance: GroupProvenanceId, groupId: string, query?: SearchQuery, facetLayoutGrid?: string[], additionalProperties?: GroupChartAdditionalProperties): Promise<void>;
+export declare function buildGroupMembers(elementId: string, groupProvenance: GroupProvenanceId, groupId: string, nRows: number, nColumns: number, query?: SearchQuery): void;
+export declare function buildGroupContent(elementId: string, groupProvenance: GroupProvenanceId, groupId: string, query?: SearchQuery, textConfig?: RcsbGroupContentTextInterface): void;
+export declare function buildResidueDistribution(elementId: string, granularity: ResidueChartInterface["granularity"], rcsbId: string, facetLayoutGrid?: string[], chartDisplayConfig?: Partial<ChartDisplayConfigInterface>): void;
+export declare const searchQueryContextManager: {
+    subscribe(f: (o: SearchQueryContextManagerSubjectInterface) => void): Subscription;
+};

package/lib/commonjs/RcsbGroupWeb/RcsbGroupBuilder.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchQueryContextManager = exports.buildResidueDistribution = exports.buildGroupContent = exports.buildGroupMembers = exports.buildGroup = exports.buildSearchRequest = void 0;
+const tslib_1 = require("tslib");
+const RcsbGroupDisplay_1 = require("./RcsbGroupView/RcsbGroupDisplay");
+const EntityGranularitySearchFacetStore_1 = require("../RcsbSeacrh/FacetStore/EntityGranularitySearchFacetStore");
+const SearchQueryContextManager_1 = require("./RcsbGroupView/RcsbGroupSeacrhQuery/SearchQueryContextManager");
+function buildSearchRequest(elementId, searchQuery, returnType) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield RcsbGroupDisplay_1.RcsbGroupDisplay.displayRcsbSearchStats(elementId, EntityGranularitySearchFacetStore_1.entityGranularityGroupFacetStore, searchQuery, returnType);
+    });
+}
+exports.buildSearchRequest = buildSearchRequest;
+function buildGroup(elementId, groupProvenance, groupId, query, facetLayoutGrid, additionalProperties) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        yield RcsbGroupDisplay_1.RcsbGroupDisplay.displaySearchAttributes(elementId, groupProvenance, groupId, query, facetLayoutGrid, additionalProperties);
+    });
+}
+exports.buildGroup = buildGroup;
+function buildGroupMembers(elementId, groupProvenance, groupId, nRows, nColumns, query) {
+    RcsbGroupDisplay_1.RcsbGroupDisplay.displayGroupMembers(elementId, groupProvenance, groupId, nRows, nColumns, query);
+}
+exports.buildGroupMembers = buildGroupMembers;
+function buildGroupContent(elementId, groupProvenance, groupId, query, textConfig) {
+    RcsbGroupDisplay_1.RcsbGroupDisplay.displayGroupContent(elementId, groupProvenance, groupId, query, textConfig);
+}
+exports.buildGroupContent = buildGroupContent;
+function buildResidueDistribution(elementId, granularity, rcsbId, facetLayoutGrid, chartDisplayConfig) {
+    RcsbGroupDisplay_1.RcsbGroupDisplay.displayResidueDistribution(elementId, granularity, rcsbId, facetLayoutGrid, chartDisplayConfig);
+}
+exports.buildResidueDistribution = buildResidueDistribution;
+exports.searchQueryContextManager = {
+    subscribe(f) {
+        return SearchQueryContextManager_1.SearchQueryContextManager.subscribe(f);
+    }
+};

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbGroupChart/GroupChartAdditionalProperties.d.ts

@@ -0,0 +1,10 @@
+import { ChartMapType } from "./GroupChartLayout";
+export interface GroupChartAdditionalProperties {
+    componentMountCallback(chartMap?: ChartMapType, layout?: string[]): void;
+    layoutConfig: LayoutConfigInterface;
+}
+export interface LayoutConfigInterface {
+    [layoutKey: string]: {
+        title: string | undefined;
+    };
+}

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbGroupChart/GroupChartAdditionalProperties.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/commonjs/RcsbGroupWeb/RcsbGroupView/RcsbGroupChart/GroupChartEvents.d.ts

@@ -0,0 +1,6 @@
+import { RcsbChartInterface } from "../../../RcsbSeacrh/FacetTools";
+import { ReturnType } from "@rcsb/rcsb-api-tools/build/RcsbSearch/Types/SearchEnums";
+export declare namespace GroupChartEvents {
+    function addBarClickCallback(chart: RcsbChartInterface, returnType: ReturnType): void;
+    function addTooltipText(chart: RcsbChartInterface): void;
+}