drugflow-molstar
Version:
Molstar implementation for DrugFlow
188 lines (187 loc) • 8.45 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.DomainAnnotationsProvider = exports.DomainAnnotationsParams = exports.DomainAnnotations = void 0;
var tslib_1 = require("tslib");
var structure_1 = require("Molstar/mol-model/structure");
var wrapper_1 = require("Molstar/mol-model-props/common/wrapper");
var custom_model_property_1 = require("Molstar/mol-model-props/common/custom-model-property");
var param_definition_1 = require("Molstar/mol-util/param-definition");
var array_1 = require("Molstar/mol-util/array");
var assets_1 = require("Molstar/mol-util/assets");
var custom_property_1 = require("Molstar/mol-model/custom-property");
var DomainAnnotations;
(function (DomainAnnotations) {
DomainAnnotations.DefaultServerUrl = 'https://www.ebi.ac.uk/pdbe/api/mappings';
function getEntryUrl(pdbId, serverUrl) {
return "".concat(serverUrl, "/").concat(pdbId.toLowerCase());
}
DomainAnnotations.getEntryUrl = getEntryUrl;
function isApplicable(model) {
return !!model && structure_1.Model.hasPdbId(model);
}
DomainAnnotations.isApplicable = isApplicable;
function fromJson(model, data) {
var info = wrapper_1.PropertyWrapper.createInfo();
var domainMap = createdomainMapFromJson(model, data);
return { info: info, data: domainMap };
}
DomainAnnotations.fromJson = fromJson;
function fromServer(ctx, model, props) {
return tslib_1.__awaiter(this, void 0, void 0, function () {
var url, json, data;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
url = assets_1.Asset.getUrlAsset(ctx.assetManager, getEntryUrl(model.entryId, props.serverUrl));
return [4 /*yield*/, ctx.assetManager.resolve(url, 'json').runInContext(ctx.runtime)];
case 1:
json = _a.sent();
data = json.data[model.entryId.toLowerCase()];
if (!data)
throw new Error('missing data');
return [2 /*return*/, { value: fromJson(model, data), assets: [json] }];
}
});
});
}
DomainAnnotations.fromServer = fromServer;
var _emptyArray = [];
function getDomains(e) {
if (!structure_1.Unit.isAtomic(e.unit))
return _emptyArray;
var prop = exports.DomainAnnotationsProvider.get(e.unit.model).value;
if (!prop || !prop.data)
return _emptyArray;
var rI = e.unit.residueIndex[e.element];
return prop.data.domains.has(rI) ? prop.data.domains.get(rI) : _emptyArray;
}
DomainAnnotations.getDomains = getDomains;
function getDomainTypes(structure) {
if (!structure)
return _emptyArray;
var prop = exports.DomainAnnotationsProvider.get(structure.models[0]).value;
if (!prop || !prop.data)
return _emptyArray;
return prop.data.domainTypes;
}
DomainAnnotations.getDomainTypes = getDomainTypes;
function getDomainNames(structure) {
if (!structure)
return _emptyArray;
var prop = exports.DomainAnnotationsProvider.get(structure.models[0]).value;
if (!prop || !prop.data)
return _emptyArray;
return prop.data.domainNames;
}
DomainAnnotations.getDomainNames = getDomainNames;
})(DomainAnnotations || (exports.DomainAnnotations = DomainAnnotations = {}));
exports.DomainAnnotationsParams = {
serverUrl: param_definition_1.ParamDefinition.Text(DomainAnnotations.DefaultServerUrl, { description: 'JSON API Server URL' })
};
exports.DomainAnnotationsProvider = custom_model_property_1.CustomModelProperty.createProvider({
label: 'Domain annotations',
descriptor: (0, custom_property_1.CustomPropertyDescriptor)({
name: 'domain_annotations'
}),
type: 'static',
defaultParams: exports.DomainAnnotationsParams,
getParams: function (data) { return exports.DomainAnnotationsParams; },
isApplicable: function (data) { return DomainAnnotations.isApplicable(data); },
obtain: function (ctx, data, props) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
var p;
return tslib_1.__generator(this, function (_a) {
switch (_a.label) {
case 0:
p = tslib_1.__assign(tslib_1.__assign({}, param_definition_1.ParamDefinition.getDefaultValues(exports.DomainAnnotationsParams)), props);
return [4 /*yield*/, DomainAnnotations.fromServer(ctx, data, p)];
case 1: return [2 /*return*/, _a.sent()];
}
});
}); }
});
function findChainLabel(map, label_entity_id, label_asym_id) {
var entityIndex = map.entities.getEntityIndex;
var eI = entityIndex(label_entity_id);
if (eI < 0 || !map.entity_index_label_asym_id.has(eI))
return -1;
var cm = map.entity_index_label_asym_id.get(eI);
if (!cm)
return -1;
return cm.has(label_asym_id) ? cm.get(label_asym_id) : -1;
}
function findResidue(modelData, map, label_entity_id, label_asym_id, label_seq_id) {
var cI = findChainLabel(map, label_entity_id, label_asym_id);
if (cI < 0)
return -1;
var rm = map.chain_index_auth_seq_id.get(cI);
return rm.has(label_seq_id) ? rm.get(label_seq_id) : -1;
}
function createdomainMapFromJson(modelData, data) {
var e_1, _a, e_2, _b, e_3, _c;
var domainTypes = [];
var domainNames = [];
var ret = new Map();
var defaultDomains = ['Pfam', 'InterPro', 'CATH', 'SCOP'];
try {
for (var _d = tslib_1.__values(Object.keys(data)), _e = _d.next(); !_e.done; _e = _d.next()) {
var db_name = _e.value;
if (defaultDomains.indexOf(db_name) === -1)
continue;
var tempDomains = [];
domainTypes.push(db_name);
var db = data[db_name];
try {
for (var _f = (e_2 = void 0, tslib_1.__values(Object.keys(db))), _g = _f.next(); !_g.done; _g = _f.next()) {
var db_code = _g.value;
var domain = db[db_code];
try {
for (var _h = (e_3 = void 0, tslib_1.__values(domain.mappings)), _j = _h.next(); !_j.done; _j = _h.next()) {
var map = _j.value;
(0, array_1.arraySetAdd)(tempDomains, domain.identifier);
var indexData = modelData.atomicHierarchy.index;
var indexMap = indexData.map;
for (var i = map.start.residue_number; i <= map.end.residue_number; i++) {
var seq_id = i;
var idx = findResidue(modelData, indexMap, map.entity_id + '', map.chain_id, seq_id);
var addVal = [domain.identifier];
var prevVal = ret.get(idx);
if (prevVal) {
prevVal.push(domain.identifier);
addVal = prevVal;
}
ret.set(idx, addVal);
}
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
}
finally { if (e_3) throw e_3.error; }
}
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
}
finally { if (e_2) throw e_2.error; }
}
domainNames.push(tempDomains);
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
}
finally { if (e_1) throw e_1.error; }
}
return {
domains: structure_1.IndexedCustomProperty.fromResidueMap(ret),
domainNames: domainNames,
domainTypes: domainTypes
};
}