luna-manager/out/luna.js

Manager for Luna projects

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const request = require("request");
const extract_zip = require("extract-zip");
exports.baseUrl = "https://raw.githubusercontent.com/XyronLabs/Luna-extensions/master/";
exports.extensionFolder = "/res/lua/extensions/";
function newProject(path, printfn) {
    checkForUpdates(path, printfn, true);
}
exports.newProject = newProject;
function checkForUpdates(path, printfn, force) {
    printfn("Luna is checking for updates, please wait...");
    let currentVersion = checkCurrentBinariesVersion(path);
    checkRemoteBinariesVersion((remoteVersion) => {
        printfn("Current version: " + currentVersion);
        printfn("Remote version: " + remoteVersion);
        if (!remoteVersion) {
            printfn("Error fetching the latest version!");
            return;
        }
        if (!currentVersion || currentVersion < remoteVersion || force)
            updateBinaries(path, printfn, remoteVersion);
        else
            printfn('Luna is up to date!\n');
    });
}
exports.checkForUpdates = checkForUpdates;
function checkCurrentBinariesVersion(path) {
    if (fs.existsSync(path + '/luna.json')) {
        return require(path + '/luna.json').version;
    }
    else {
        return undefined;
    }
}
exports.checkCurrentBinariesVersion = checkCurrentBinariesVersion;
function checkRemoteBinariesVersion(_callback) {
    request.get({ url: 'https://raw.githubusercontent.com/XyronLabs/Luna/master/resources/build/vscode_version' }, (err, response, body) => {
        _callback(body);
    });
}
exports.checkRemoteBinariesVersion = checkRemoteBinariesVersion;
function updateBinaries(path, printfn, remoteVersion) {
    printfn("Installing Luna " + remoteVersion + " to this folder: " + path);
    printfn("Please wait until this process is finished...");
    let url = 'https://github.com/XyronLabs/Luna/releases/download/' + remoteVersion + '/luna-' + remoteVersion + '_standalone_' + process.platform + '.zip';
    request.get({ url: url, encoding: 'binary' }, (err, response, body) => {
        if (err) {
            printfn(err);
        }
        else {
            fs.writeFileSync(path + "/luna.zip", body, 'binary');
            extract_zip(path + "/luna.zip", { dir: path + "" }, (err) => {
                if (err) {
                    printfn("Could not update Luna to version " + remoteVersion + "\n");
                }
                else {
                    fs.unlinkSync(path + "/luna.zip");
                    printfn("Luna was successfully updated!\n");
                    if (fs.existsSync(path + '/luna.json')) {
                        let l = require(path + '/luna.json');
                        l.version = remoteVersion;
                        fs.writeFileSync(path + '/luna.json', JSON.stringify(l));
                    }
                    else {
                        fs.appendFileSync(path + '/luna.json', JSON.stringify({ version: remoteVersion }));
                    }
                }
            });
        }
    });
}
exports.updateBinaries = updateBinaries;
function updateExtension(path, printfn, packageName) {
    request.get({ url: exports.baseUrl + packageName + "/extension.json" }, (err, response, body) => {
        if (err) {
            printfn("Couldn't get extension data");
            return;
        }
        let obj = JSON.parse(body);
        if (!obj.files)
            obj.files = [];
        obj.files.push("init.lua");
        obj.files.push("extension.json");
        if (obj.dependencies) {
            for (let d of obj.dependencies) {
                updateExtension(path, printfn, d);
            }
        }
        let directoryTree = "";
        for (let currDir of packageName.split('/')) {
            directoryTree += currDir + "/";
            if (!fs.existsSync(path + exports.extensionFolder + directoryTree))
                fs.mkdirSync(path + exports.extensionFolder + directoryTree);
        }
        printfn("Installing " + obj.name + " " + obj.version);
        for (let f of obj.files) {
            request.get({ url: exports.baseUrl + packageName + "/" + f }, (err, response, body) => {
                if (err) {
                    printfn("Couldn't download file: " + f);
                    return;
                }
                fs.writeFileSync(path + exports.extensionFolder + packageName + "/" + f, body);
            });
        }
        printfn("Installed " + obj.name + " " + obj.version + " successfully!");
    });
}
exports.updateExtension = updateExtension;
function checkInstalledExtensions(path, printfn, force) {
    printfn("Checking for extension updates");
    let extensions = checkFolderForExtensions(path);
    extensions.forEach(e => {
        let extensionData = require(getExtensionData(path, e));
        request.get({ url: exports.baseUrl + e + "/extension.json" }, (err, response, body) => {
            let remoteData = JSON.parse(body);
            printfn(`Extension: ${extensionData.name}, local version = ${extensionData.version}, remote version = ${remoteData.version}`);
            if (extensionData.version < remoteData.version || force) {
                updateExtension(path, printfn, e);
            }
        });
    });
}
exports.checkInstalledExtensions = checkInstalledExtensions;
function checkFolderForExtensions(path, folder = "", extensionList = []) {
    if (!fs.existsSync(path + exports.extensionFolder + folder))
        return [];
    let folders = fs.readdirSync(path + exports.extensionFolder + folder);
    folders.forEach(f => {
        if (fs.existsSync(getExtensionData(path, folder + "/" + f))) {
            extensionList.push(folder + "/" + f);
        }
        else {
            return checkFolderForExtensions(path, folder + "/" + f, extensionList);
        }
    });
    return extensionList;
}
exports.checkFolderForExtensions = checkFolderForExtensions;
function getExtensionData(path, packageName) {
    return path + exports.extensionFolder + packageName + "/extension.json";
}
exports.getExtensionData = getExtensionData;
function removeExtension(path, printfn, selected, extensionsData, errCallback) {
    let packageName = selected.path;
    // Check if an installed extension depends on this one
    let ableToRemove = true;
    extensionsData.forEach(element => {
        if (element.dependencies) {
            element.dependencies.forEach(d => {
                if (d == packageName) {
                    errCallback(`Can't remove ${selected.name} [${selected.version}] extension, ${element.name} [${element.version}] depends on this extension`);
                    ableToRemove = false;
                    return;
                }
            });
        }
    });
    if (ableToRemove) {
        for (let file of fs.readdirSync(path + exports.extensionFolder + packageName))
            fs.unlinkSync(path + exports.extensionFolder + packageName + "/" + file);
        fs.rmdirSync(path + exports.extensionFolder + packageName);
        printfn("Removed extension: " + packageName);
        let f = packageName.split('/');
        if (f.length > 2) {
            let rootFolder = fs.readdirSync(path + exports.extensionFolder + f[1]);
            if (rootFolder.length == 0)
                fs.rmdirSync(path + exports.extensionFolder + f[1]);
        }
    }
}
exports.removeExtension = removeExtension;
function getRemoteAvaliableExtensions(_callback) {
    let extensionsData = [];
    request.get({ url: exports.baseUrl + 'luna_extensions.json' }, (err, res, body) => {
        let extensionPaths = JSON.parse(body);
        extensionPaths.forEach(path => {
            request.get({ url: exports.baseUrl + path + "/extension.json" }, (err, res, body) => {
                extensionsData.push(JSON.parse(body));
                if (extensionsData.length == extensionPaths.length) {
                    _callback(extensionsData);
                }
            });
        });
    });
}
exports.getRemoteAvaliableExtensions = getRemoteAvaliableExtensions;