molstar 3.0.1 → 3.0.2

package/lib/commonjs/cli/cif2bcif/converter.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * Copyright (c) 2017 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Sebastian Bittrich <sebastian.bittrich@rcsb.org>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convert = void 0;
+var tslib_1 = require("tslib");
+var cif_1 = require("../../mol-io/reader/cif");
+var cif_2 = require("../../mol-io/writer/cif");
+var util = (0, tslib_1.__importStar)(require("util"));
+var fs = (0, tslib_1.__importStar)(require("fs"));
+var zlib = (0, tslib_1.__importStar)(require("zlib"));
+var mol_task_1 = require("../../mol-task");
+var binary_cif_1 = require("../../mol-io/common/binary-cif");
+var encoder_1 = require("../../mol-io/writer/cif/encoder");
+function showProgress(p) {
+    process.stdout.write("\r".concat(new Array(80).join(' ')));
+    process.stdout.write("\r".concat(mol_task_1.Progress.format(p)));
+}
+var readFileAsync = util.promisify(fs.readFile);
+var unzipAsync = util.promisify(zlib.unzip);
+function readFile(ctx, filename) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var isGz, input, str, data, _a;
+        return (0, tslib_1.__generator)(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    isGz = /\.gz$/i.test(filename);
+                    if (!filename.match(/\.bcif/)) return [3 /*break*/, 5];
+                    return [4 /*yield*/, readFileAsync(filename)];
+                case 1:
+                    input = _b.sent();
+                    if (!isGz) return [3 /*break*/, 3];
+                    return [4 /*yield*/, unzipAsync(input)];
+                case 2:
+                    input = _b.sent();
+                    _b.label = 3;
+                case 3: return [4 /*yield*/, cif_1.CIF.parseBinary(new Uint8Array(input)).runInContext(ctx)];
+                case 4: return [2 /*return*/, _b.sent()];
+                case 5:
+                    str = void 0;
+                    if (!isGz) return [3 /*break*/, 8];
+                    _a = unzipAsync;
+                    return [4 /*yield*/, readFileAsync(filename)];
+                case 6: return [4 /*yield*/, _a.apply(void 0, [_b.sent()])];
+                case 7:
+                    data = _b.sent();
+                    str = data.toString('utf8');
+                    return [3 /*break*/, 10];
+                case 8: return [4 /*yield*/, readFileAsync(filename, 'utf8')];
+                case 9:
+                    str = _b.sent();
+                    _b.label = 10;
+                case 10: return [4 /*yield*/, cif_1.CIF.parseText(str).runInContext(ctx)];
+                case 11: return [2 /*return*/, _b.sent()];
+            }
+        });
+    });
+}
+function getCIF(ctx, filename) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var parsed;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, readFile(ctx, filename)];
+                case 1:
+                    parsed = _a.sent();
+                    if (parsed.isError) {
+                        throw new Error(parsed.toString());
+                    }
+                    return [2 /*return*/, parsed.result];
+            }
+        });
+    });
+}
+function getCategoryInstanceProvider(cat, fields) {
+    return {
+        name: cat.name,
+        instance: function () { return cif_2.CifWriter.categoryInstance(fields, { data: cat, rowCount: cat.rowCount }); }
+    };
+}
+function classify(name, field) {
+    var type = (0, cif_1.getCifFieldType)(field);
+    if (type['@type'] === 'str') {
+        return { name: name, type: 0 /* Str */, value: field.str, valueKind: field.valueKind };
+    }
+    else if (type['@type'] === 'float') {
+        var encoder = (0, binary_cif_1.classifyFloatArray)(field.toFloatArray({ array: Float64Array }));
+        return cif_2.CifWriter.Field.float(name, field.float, { valueKind: field.valueKind, encoder: encoder, typedArray: Float64Array });
+    }
+    else {
+        var encoder = (0, binary_cif_1.classifyIntArray)(field.toIntArray({ array: Int32Array }));
+        return cif_2.CifWriter.Field.int(name, field.int, { valueKind: field.valueKind, encoder: encoder, typedArray: Int32Array });
+    }
+}
+function convert(path, asText, hints, filter) {
+    var _this = this;
+    if (asText === void 0) { asText = false; }
+    return mol_task_1.Task.create('BinaryCIF', function (ctx) { return (0, tslib_1.__awaiter)(_this, void 0, void 0, function () {
+        var encodingProvider, cif, encoder, maxProgress, _i, _a, b, _b, _c, c, current, _d, _e, b, _f, _g, c, cat, fields, _h, _j, f, ret;
+        return (0, tslib_1.__generator)(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    encodingProvider = hints
+                        ? cif_2.CifWriter.createEncodingProviderFromJsonConfig(hints)
+                        : { get: function (c, f) { return void 0; } };
+                    return [4 /*yield*/, getCIF(ctx, path)];
+                case 1:
+                    cif = _k.sent();
+                    encoder = cif_2.CifWriter.createEncoder({
+                        binary: !asText,
+                        encoderName: 'mol*/ciftools cif2bcif',
+                        binaryAutoClassifyEncoding: true,
+                        binaryEncodingPovider: encodingProvider
+                    });
+                    if (filter) {
+                        encoder.setFilter(encoder_1.Category.filterOf(filter));
+                    }
+                    maxProgress = 0;
+                    for (_i = 0, _a = cif.blocks; _i < _a.length; _i++) {
+                        b = _a[_i];
+                        maxProgress += b.categoryNames.length;
+                        for (_b = 0, _c = b.categoryNames; _b < _c.length; _b++) {
+                            c = _c[_b];
+                            maxProgress += b.categories[c].fieldNames.length;
+                        }
+                    }
+                    current = 0;
+                    _d = 0, _e = cif.blocks;
+                    _k.label = 2;
+                case 2:
+                    if (!(_d < _e.length)) return [3 /*break*/, 11];
+                    b = _e[_d];
+                    encoder.startDataBlock(b.header);
+                    _f = 0, _g = b.categoryNames;
+                    _k.label = 3;
+                case 3:
+                    if (!(_f < _g.length)) return [3 /*break*/, 10];
+                    c = _g[_f];
+                    cat = b.categories[c];
+                    fields = [];
+                    _h = 0, _j = cat.fieldNames;
+                    _k.label = 4;
+                case 4:
+                    if (!(_h < _j.length)) return [3 /*break*/, 7];
+                    f = _j[_h];
+                    fields.push(classify(f, cat.getField(f)));
+                    current++;
+                    if (!ctx.shouldUpdate) return [3 /*break*/, 6];
+                    return [4 /*yield*/, ctx.update({ message: 'Encoding...', current: current, max: maxProgress })];
+                case 5:
+                    _k.sent();
+                    _k.label = 6;
+                case 6:
+                    _h++;
+                    return [3 /*break*/, 4];
+                case 7:
+                    encoder.writeCategory(getCategoryInstanceProvider(b.categories[c], fields));
+                    current++;
+                    if (!ctx.shouldUpdate) return [3 /*break*/, 9];
+                    return [4 /*yield*/, ctx.update({ message: 'Encoding...', current: current, max: maxProgress })];
+                case 8:
+                    _k.sent();
+                    _k.label = 9;
+                case 9:
+                    _f++;
+                    return [3 /*break*/, 3];
+                case 10:
+                    _d++;
+                    return [3 /*break*/, 2];
+                case 11: return [4 /*yield*/, ctx.update('Exporting...')];
+                case 12:
+                    _k.sent();
+                    ret = encoder.getData();
+                    return [4 /*yield*/, ctx.update('Done.\n')];
+                case 13:
+                    _k.sent();
+                    return [2 /*return*/, ret];
+            }
+        });
+    }); }).run(showProgress, 250);
+}
+exports.convert = convert;
+//# sourceMappingURL=converter.js.map

package/lib/commonjs/cli/cif2bcif/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export {};

package/lib/commonjs/cli/cif2bcif/index.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Copyright (c) 2017-2019 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author David Sehnal <david.sehnal@gmail.com>
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var argparse = (0, tslib_1.__importStar)(require("argparse"));
+var util = (0, tslib_1.__importStar)(require("util"));
+var fs = (0, tslib_1.__importStar)(require("fs"));
+var zlib = (0, tslib_1.__importStar)(require("zlib"));
+var converter_1 = require("./converter");
+require('util.promisify').shim();
+function process(srcPath, outPath, configPath, filterPath) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var config, filter, res;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    config = configPath ? JSON.parse(fs.readFileSync(configPath, 'utf8')) : void 0;
+                    filter = filterPath ? fs.readFileSync(filterPath, 'utf8') : void 0;
+                    return [4 /*yield*/, (0, converter_1.convert)(srcPath, false, config, filter)];
+                case 1:
+                    res = _a.sent();
+                    return [4 /*yield*/, write(outPath, res)];
+                case 2:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+var zipAsync = util.promisify(zlib.gzip);
+function write(outPath, res) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var isGz;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    isGz = /\.gz$/i.test(outPath);
+                    if (!isGz) return [3 /*break*/, 2];
+                    return [4 /*yield*/, zipAsync(res)];
+                case 1:
+                    res = _a.sent();
+                    _a.label = 2;
+                case 2:
+                    fs.writeFileSync(outPath, res);
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function run(args) {
+    process(args.src, args.out, args.config, args.filter);
+}
+var parser = new argparse.ArgumentParser({
+    add_help: true,
+    description: 'Convert any CIF file to a BCIF file'
+});
+parser.add_argument('src', {
+    help: 'Source CIF path'
+});
+parser.add_argument('out', {
+    help: 'Output BCIF path'
+});
+parser.add_argument('-c', '--config', {
+    help: 'Optional encoding strategy/precision config path',
+    required: false
+});
+parser.add_argument('-f', '--filter', {
+    help: 'Optional filter whitelist/blacklist path',
+    required: false
+});
+var args = parser.parse_args();
+if (args) {
+    run(args);
+}
+//# sourceMappingURL=index.js.map

package/lib/commonjs/cli/cifschema/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+/**
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+export {};

package/lib/commonjs/cli/cifschema/index.js

@@ -0,0 +1,397 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Copyright (c) 2017-2021 mol* contributors, licensed under MIT, See LICENSE file for more info.
+ *
+ * @author Alexander Rose <alexander.rose@weirdbyte.de>
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var argparse = (0, tslib_1.__importStar)(require("argparse"));
+var fs = (0, tslib_1.__importStar)(require("fs"));
+var path = (0, tslib_1.__importStar)(require("path"));
+var node_fetch_1 = (0, tslib_1.__importDefault)(require("node-fetch"));
+var parser_1 = require("../../mol-io/reader/csv/parser");
+var parser_2 = require("../../mol-io/reader/cif/text/parser");
+var cif_dic_1 = require("./util/cif-dic");
+var generate_1 = require("./util/generate");
+var helper_1 = require("./util/helper");
+function getDicVersion(block) {
+    return block.categories.dictionary.getField('version').str(0);
+}
+function getDicNamespace(block) {
+    return block.categories.dictionary.getField('namespace').str(0);
+}
+function runGenerateSchemaMmcif(name, fieldNamesPath, typescript, out, moldbImportPath, addAliases) {
+    if (typescript === void 0) { typescript = false; }
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var mmcifDic, ihmDic, maDic, mmcifDicVersion, ihmDicVersion, maDicVersion, version, frames, schema;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureMmcifDicAvailable()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(MMCIF_DIC_PATH, 'utf8')).run()];
+                case 2:
+                    mmcifDic = _a.sent();
+                    if (mmcifDic.isError)
+                        throw mmcifDic;
+                    return [4 /*yield*/, ensureIhmDicAvailable()];
+                case 3:
+                    _a.sent();
+                    return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(IHM_DIC_PATH, 'utf8')).run()];
+                case 4:
+                    ihmDic = _a.sent();
+                    if (ihmDic.isError)
+                        throw ihmDic;
+                    return [4 /*yield*/, ensureMaDicAvailable()];
+                case 5:
+                    _a.sent();
+                    return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(MA_DIC_PATH, 'utf8')).run()];
+                case 6:
+                    maDic = _a.sent();
+                    if (maDic.isError)
+                        throw maDic;
+                    mmcifDicVersion = getDicVersion(mmcifDic.result.blocks[0]);
+                    ihmDicVersion = getDicVersion(ihmDic.result.blocks[0]);
+                    maDicVersion = getDicVersion(maDic.result.blocks[0]);
+                    version = "Dictionary versions: mmCIF ".concat(mmcifDicVersion, ", IHM ").concat(ihmDicVersion, ", MA ").concat(maDicVersion, ".");
+                    frames = (0, tslib_1.__spreadArray)((0, tslib_1.__spreadArray)((0, tslib_1.__spreadArray)([], mmcifDic.result.blocks[0].saveFrames, true), ihmDic.result.blocks[0].saveFrames, true), maDic.result.blocks[0].saveFrames, true);
+                    schema = (0, cif_dic_1.generateSchema)(frames);
+                    return [4 /*yield*/, runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases)];
+                case 7:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function runGenerateSchemaCifCore(name, fieldNamesPath, typescript, out, moldbImportPath, addAliases) {
+    if (typescript === void 0) { typescript = false; }
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var cifCoreDic, cifCoreDicVersion, version, frames, imports, schema;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureCifCoreDicAvailable()];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(CIF_CORE_DIC_PATH, 'utf8')).run()];
+                case 2:
+                    cifCoreDic = _a.sent();
+                    if (cifCoreDic.isError)
+                        throw cifCoreDic;
+                    cifCoreDicVersion = getDicVersion(cifCoreDic.result.blocks[0]);
+                    version = "Dictionary versions: CifCore ".concat(cifCoreDicVersion, ".");
+                    frames = (0, tslib_1.__spreadArray)([], cifCoreDic.result.blocks[0].saveFrames, true);
+                    return [4 /*yield*/, resolveImports(frames, DIC_DIR)];
+                case 3:
+                    imports = _a.sent();
+                    schema = (0, cif_dic_1.generateSchema)(frames, imports);
+                    return [4 /*yield*/, runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases)];
+                case 4:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function resolveImports(frames, baseDir) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var imports, _i, frames_1, d, importGet, _a, importGet_1, g, file, dic;
+        return (0, tslib_1.__generator)(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    imports = new Map();
+                    _i = 0, frames_1 = frames;
+                    _b.label = 1;
+                case 1:
+                    if (!(_i < frames_1.length)) return [3 /*break*/, 6];
+                    d = frames_1[_i];
+                    if (!('import' in d.categories)) return [3 /*break*/, 5];
+                    importGet = (0, helper_1.parseImportGet)(d.categories['import'].getField('get').str(0));
+                    _a = 0, importGet_1 = importGet;
+                    _b.label = 2;
+                case 2:
+                    if (!(_a < importGet_1.length)) return [3 /*break*/, 5];
+                    g = importGet_1[_a];
+                    file = g.file;
+                    if (!file)
+                        return [3 /*break*/, 4];
+                    if (imports.has(file))
+                        return [3 /*break*/, 4];
+                    return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(path.join(baseDir, file), 'utf8')).run()];
+                case 3:
+                    dic = _b.sent();
+                    if (dic.isError)
+                        throw dic;
+                    imports.set(file, (0, tslib_1.__spreadArray)([], dic.result.blocks[0].saveFrames, true));
+                    _b.label = 4;
+                case 4:
+                    _a++;
+                    return [3 /*break*/, 2];
+                case 5:
+                    _i++;
+                    return [3 /*break*/, 1];
+                case 6: return [2 /*return*/, imports];
+            }
+        });
+    });
+}
+function runGenerateSchemaDic(name, dicPath, fieldNamesPath, typescript, out, moldbImportPath, addAliases) {
+    if (typescript === void 0) { typescript = false; }
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var dic, dicVersion, dicName, version, frames, imports, schema;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, parser_2.parseCifText)(fs.readFileSync(dicPath, 'utf8')).run()];
+                case 1:
+                    dic = _a.sent();
+                    if (dic.isError)
+                        throw dic;
+                    dicVersion = getDicVersion(dic.result.blocks[0]);
+                    dicName = getDicNamespace(dic.result.blocks[0]);
+                    version = "Dictionary versions: ".concat(dicName, " ").concat(dicVersion, ".");
+                    frames = (0, tslib_1.__spreadArray)([], dic.result.blocks[0].saveFrames, true);
+                    return [4 /*yield*/, resolveImports(frames, path.dirname(dicPath))];
+                case 2:
+                    imports = _a.sent();
+                    schema = (0, cif_dic_1.generateSchema)(frames, imports);
+                    return [4 /*yield*/, runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function runGenerateSchema(name, version, schema, fieldNamesPath, typescript, out, moldbImportPath, addAliases) {
+    if (typescript === void 0) { typescript = false; }
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var filter, _a, output;
+        return (0, tslib_1.__generator)(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!fieldNamesPath) return [3 /*break*/, 2];
+                    return [4 /*yield*/, getFieldNamesFilter(fieldNamesPath)];
+                case 1:
+                    _a = _b.sent();
+                    return [3 /*break*/, 3];
+                case 2:
+                    _a = undefined;
+                    _b.label = 3;
+                case 3:
+                    filter = _a;
+                    output = typescript ? (0, generate_1.generate)(name, version, schema, filter, moldbImportPath, addAliases) : JSON.stringify(schema, undefined, 4);
+                    if (out) {
+                        fs.writeFileSync(out, output);
+                    }
+                    else {
+                        console.log(output);
+                    }
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function getFieldNamesFilter(fieldNamesPath) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var fieldNamesStr, parsed, csvFile, fieldNamesCol, fieldNames, filter;
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    fieldNamesStr = fs.readFileSync(fieldNamesPath, 'utf8');
+                    return [4 /*yield*/, (0, parser_1.parseCsv)(fieldNamesStr, { noColumnNames: true }).run()];
+                case 1:
+                    parsed = _a.sent();
+                    if (parsed.isError)
+                        throw parser.error;
+                    csvFile = parsed.result;
+                    fieldNamesCol = csvFile.table.getColumn('0');
+                    if (!fieldNamesCol)
+                        throw new Error('error getting fields columns');
+                    fieldNames = fieldNamesCol.toStringArray();
+                    filter = {};
+                    fieldNames.forEach(function (name, i) {
+                        var _a = name.split('.'), category = _a[0], field = _a[1];
+                        // console.log(category, field)
+                        if (!filter[category])
+                            filter[category] = {};
+                        filter[category][field] = true;
+                    });
+                    return [2 /*return*/, filter];
+            }
+        });
+    });
+}
+function ensureMmcifDicAvailable() {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureDicAvailable(MMCIF_DIC_PATH, MMCIF_DIC_URL)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    }); });
+}
+function ensureIhmDicAvailable() {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureDicAvailable(IHM_DIC_PATH, IHM_DIC_URL)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    }); });
+}
+function ensureMaDicAvailable() {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () { return (0, tslib_1.__generator)(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, ensureDicAvailable(MA_DIC_PATH, MA_DIC_URL)];
+            case 1:
+                _a.sent();
+                return [2 /*return*/];
+        }
+    }); });
+}
+function ensureCifCoreDicAvailable() {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        return (0, tslib_1.__generator)(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ensureDicAvailable(CIF_CORE_DIC_PATH, CIF_CORE_DIC_URL)];
+                case 1:
+                    _a.sent();
+                    return [4 /*yield*/, ensureDicAvailable(CIF_CORE_ENUM_PATH, CIF_CORE_ENUM_URL)];
+                case 2:
+                    _a.sent();
+                    return [4 /*yield*/, ensureDicAvailable(CIF_CORE_ATTR_PATH, CIF_CORE_ATTR_URL)];
+                case 3:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    });
+}
+function ensureDicAvailable(dicPath, dicUrl) {
+    return (0, tslib_1.__awaiter)(this, void 0, void 0, function () {
+        var name_1, data, _a, _b, _c;
+        return (0, tslib_1.__generator)(this, function (_d) {
+            switch (_d.label) {
+                case 0:
+                    if (!(FORCE_DIC_DOWNLOAD || !fs.existsSync(dicPath))) return [3 /*break*/, 3];
+                    name_1 = dicUrl.substr(dicUrl.lastIndexOf('/') + 1);
+                    console.log("downloading ".concat(name_1, "..."));
+                    return [4 /*yield*/, (0, node_fetch_1.default)(dicUrl)];
+                case 1:
+                    data = _d.sent();
+                    if (!fs.existsSync(DIC_DIR)) {
+                        fs.mkdirSync(DIC_DIR);
+                    }
+                    _b = (_a = fs).writeFileSync;
+                    _c = [dicPath];
+                    return [4 /*yield*/, data.text()];
+                case 2:
+                    _b.apply(_a, _c.concat([_d.sent()]));
+                    console.log("done downloading ".concat(name_1));
+                    _d.label = 3;
+                case 3: return [2 /*return*/];
+            }
+        });
+    });
+}
+var DIC_DIR = path.resolve(__dirname, '../../../../build/dics/');
+var MMCIF_DIC_PATH = "".concat(DIC_DIR, "/mmcif_pdbx_v50.dic");
+var MMCIF_DIC_URL = 'http://mmcif.wwpdb.org/dictionaries/ascii/mmcif_pdbx_v50.dic';
+var IHM_DIC_PATH = "".concat(DIC_DIR, "/ihm-extension.dic");
+var IHM_DIC_URL = 'https://raw.githubusercontent.com/ihmwg/IHM-dictionary/master/ihm-extension.dic';
+var MA_DIC_PATH = "".concat(DIC_DIR, "/ma-extension.dic");
+var MA_DIC_URL = 'https://raw.githubusercontent.com/ihmwg/MA-dictionary/master/mmcif_ma.dic';
+var CIF_CORE_DIC_PATH = "".concat(DIC_DIR, "/cif_core.dic");
+var CIF_CORE_DIC_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/cif_core.dic';
+var CIF_CORE_ENUM_PATH = "".concat(DIC_DIR, "/templ_enum.cif");
+var CIF_CORE_ENUM_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/templ_enum.cif';
+var CIF_CORE_ATTR_PATH = "".concat(DIC_DIR, "/templ_attr.cif");
+var CIF_CORE_ATTR_URL = 'https://raw.githubusercontent.com/COMCIFS/cif_core/master/templ_attr.cif';
+var parser = new argparse.ArgumentParser({
+    add_help: true,
+    description: 'Create schema from mmcif dictionary (v50 plus IHM and entity_branch extensions, downloaded from wwPDB)'
+});
+parser.add_argument('--preset', '-p', {
+    default: '',
+    choices: ['', 'mmCIF', 'CCD', 'BIRD', 'CifCore'],
+    help: 'Preset name'
+});
+parser.add_argument('--name', '-n', {
+    default: '',
+    help: 'Schema name'
+});
+parser.add_argument('--out', '-o', {
+    help: 'Generated schema output path, if not given printed to stdout'
+});
+parser.add_argument('--targetFormat', '-tf', {
+    default: 'typescript-molstar',
+    choices: ['typescript-molstar', 'json-internal'],
+    help: 'Target format'
+});
+parser.add_argument('--dicPath', '-d', {
+    default: '',
+    help: 'Path to dictionary'
+});
+parser.add_argument('--fieldNamesPath', '-fn', {
+    default: '',
+    help: 'Field names to include'
+});
+parser.add_argument('--forceDicDownload', '-f', {
+    action: 'store_true',
+    help: 'Force download of dictionaries'
+});
+parser.add_argument('--moldataImportPath', '-mip', {
+    default: 'molstar/lib/mol-data',
+    help: 'mol-data import path (for typescript target only)'
+});
+parser.add_argument('--addAliases', '-aa', {
+    action: 'store_true',
+    help: 'Add field name/path aliases'
+});
+var args = parser.parse_args();
+var FORCE_DIC_DOWNLOAD = args.forceDicDownload;
+switch (args.preset) {
+    case 'mmCIF':
+        args.name = 'mmCIF';
+        args.dic = 'mmCIF';
+        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/mmcif-field-names.csv');
+        break;
+    case 'CCD':
+        args.name = 'CCD';
+        args.dic = 'mmCIF';
+        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/ccd-field-names.csv');
+        break;
+    case 'BIRD':
+        args.name = 'BIRD';
+        args.dic = 'mmCIF';
+        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/bird-field-names.csv');
+        break;
+    case 'CifCore':
+        args.name = 'CifCore';
+        args.dic = 'CifCore';
+        args.fieldNamesPath = path.resolve(__dirname, '../../../../data/cif-field-names/cif-core-field-names.csv');
+        break;
+}
+if (args.name) {
+    var typescript = args.targetFormat === 'typescript-molstar';
+    if (args.dicPath) {
+        runGenerateSchemaDic(args.name, args.dicPath, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(function (e) {
+            console.error(e);
+        });
+    }
+    else if (args.dic === 'mmCIF') {
+        runGenerateSchemaMmcif(args.name, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(function (e) {
+            console.error(e);
+        });
+    }
+    else if (args.dic === 'CifCore') {
+        runGenerateSchemaCifCore(args.name, args.fieldNamesPath, typescript, args.out, args.moldataImportPath, args.addAliases).catch(function (e) {
+            console.error(e);
+        });
+    }
+}
+//# sourceMappingURL=index.js.map