"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __spreadArrays = (this && this.__spreadArrays) || function () {
    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
    for (var r = Array(s), k = 0, i = 0; i < il; i++)
        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
            r[k] = a[j];
    return r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ShebangCheck = void 0;
var fs = require("fs");
var path = require("path");
/** checks if a file has a shebang at the top, or if provided a package.json,
 * checks that all bin provided have shebangs, throws an error if they do not
 * have it, useful for testing within CI for npm packages and reliably asserting
 * that a executable file indeed has a shebang at the top. */
var ShebangCheck = /** @class */ (function () {
    function ShebangCheck() {
    }
    ShebangCheck.readFile = function (location) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, fs.promises.readFile(location, 'utf-8')];
                    case 1: return [2 /*return*/, _a.sent()];
                }
            });
        });
    };
    ShebangCheck.readJson = function (location) {
        return __awaiter(this, void 0, void 0, function () {
            var content;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, ShebangCheck.readFile(location)];
                    case 1:
                        content = _a.sent();
                        return [2 /*return*/, JSON.parse(content)];
                }
            });
        });
    };
    ShebangCheck.joinDirname = function (location) {
        var dirname = path.dirname(location);
        return function (p) { return path.join(dirname, p); };
    };
    ShebangCheck.binFiles = function (location) {
        return __awaiter(this, void 0, void 0, function () {
            var joinDirname_1, json;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        if (!(path.extname(location) === '.json')) return [3 /*break*/, 2];
                        joinDirname_1 = ShebangCheck.joinDirname(location);
                        return [4 /*yield*/, ShebangCheck.readJson(location)];
                    case 1:
                        json = _a.sent();
                        if (!json.bin)
                            return [2 /*return*/, []];
                        if (typeof json.bin === 'string')
                            return [2 /*return*/, [joinDirname_1(json.bin)]];
                        return [2 /*return*/, Object.values(json.bin)
                                .map(function (s) { return (typeof s === 'string' ? joinDirname_1(s) : ''); })
                                .filter(function (f) { return f; })];
                    case 2: return [2 /*return*/, [location]];
                }
            });
        });
    };
    ShebangCheck.uniqueBinFiles = function (location) {
        return __awaiter(this, void 0, void 0, function () {
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, ShebangCheck.binFiles(location)];
                    case 1: return [2 /*return*/, (_a.sent()).filter(function (value, index, self) { return self.indexOf(value) === index; })];
                }
            });
        });
    };
    ShebangCheck.files = function (location) {
        return __awaiter(this, void 0, void 0, function () {
            var files;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, ShebangCheck.uniqueBinFiles(location)];
                    case 1:
                        files = _a.sent();
                        return [4 /*yield*/, Promise.all(files.map(function (location) { return __awaiter(_this, void 0, void 0, function () {
                                var content, hasShebang, basename;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0: return [4 /*yield*/, ShebangCheck.readFile(location)];
                                        case 1:
                                            content = _a.sent();
                                            hasShebang = Boolean(content.match(ShebangCheck.pattern));
                                            basename = path.basename(location);
                                            return [2 /*return*/, { location: location, content: content, hasShebang: hasShebang, basename: basename }];
                                    }
                                });
                            }); }))];
                    case 2: return [2 /*return*/, _a.sent()];
                }
            });
        });
    };
    ShebangCheck.multiFile = function () {
        var locations = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            locations[_i] = arguments[_i];
        }
        return __awaiter(this, void 0, void 0, function () {
            var results;
            var _this = this;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        results = [];
                        return [4 /*yield*/, Promise.all(locations.map(function (location) { return __awaiter(_this, void 0, void 0, function () {
                                var data;
                                return __generator(this, function (_a) {
                                    switch (_a.label) {
                                        case 0: return [4 /*yield*/, ShebangCheck.files(location)];
                                        case 1:
                                            data = _a.sent();
                                            results = __spreadArrays(results, data);
                                            return [2 /*return*/];
                                    }
                                });
                            }); }))];
                    case 1:
                        _a.sent();
                        return [2 /*return*/, results];
                }
            });
        });
    };
    ShebangCheck.check = function () {
        var location = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            location[_i] = arguments[_i];
        }
        return __awaiter(this, void 0, void 0, function () {
            var files;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0: return [4 /*yield*/, ShebangCheck.multiFile.apply(ShebangCheck, location)];
                    case 1:
                        files = _a.sent();
                        if (!files.length)
                            throw new Error("file " + location + " is missing shebang");
                        files.forEach(function (_a) {
                            var basename = _a.basename, hasShebang = _a.hasShebang;
                            if (!hasShebang)
                                throw new Error("file " + basename + " is missing shebang");
                        });
                        return [2 /*return*/];
                }
            });
        });
    };
    ShebangCheck.cli = function (process) {
        return __awaiter(this, void 0, void 0, function () {
            var locations, code, files, noun;
            return __generator(this, function (_a) {
                switch (_a.label) {
                    case 0:
                        locations = process.argv.slice(2);
                        if (!locations.length) {
                            process.stderr.write('no file passed in\n');
                            return [2 /*return*/, process.exit(1)];
                        }
                        code = 0;
                        return [4 /*yield*/, ShebangCheck.multiFile.apply(ShebangCheck, locations)];
                    case 1:
                        files = _a.sent();
                        if (!files.length) {
                            noun = locations.length === 1 ? ['file', 'is'] : ['files', 'are'];
                            process.stderr.write(noun[0] + " " + locations.join(', ') + " " + noun[1] + " missing shebang\n");
                            code = 1;
                        }
                        files.forEach(function (_a) {
                            var basename = _a.basename, hasShebang = _a.hasShebang;
                            if (hasShebang) {
                                process.stdout.write("file " + basename + " has shebang\n");
                            }
                            else {
                                process.stderr.write("file " + basename + " is missing shebang\n");
                                code = 1;
                            }
                        });
                        process.exit(code);
                        return [2 /*return*/];
                }
            });
        });
    };
    ShebangCheck.pattern = /^#!(.*)/;
    return ShebangCheck;
}());
exports.ShebangCheck = ShebangCheck;
//# sourceMappingURL=shebang_check.js.map