magica/dist/src/main/main.js

ImageMagick for browser and Node.js, easy setup, high level API and Command Line Interface, including WASM binary for an easy setup.

"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 __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const misc_utils_of_mine_generic_1 = require("misc-utils-of-mine-generic");
const p_queue_1 = __importDefault(require("p-queue"));
const file_1 = require("../file/file");
const protected_1 = require("../file/protected");
const imageUtil_1 = require("../image/imageUtil");
const magickLoaded_1 = require("../imageMagick/magickLoaded");
const options_1 = require("../options");
const fileUtil_1 = require("../util/fileUtil");
const lsR_1 = require("../util/lsR");
const mkdirp_1 = require("../util/mkdirp");
const rmRf_1 = require("../util/rmRf");
const command_1 = require("./command");
let queue;
function getQueue() {
    if (!queue) {
        queue = new p_queue_1.default({
            autoStart: true,
            concurrency: options_1.getOption('mainConcurrency'),
            interval: options_1.getOption('mainInterval')
        });
    }
    return queue;
}
function main(o) {
    if (o.useNative || options_1.getOption('useNative')) {
        throw 'useNative not supported yet';
    }
    return getQueue().add(() => __awaiter(this, void 0, void 0, function* () {
        yield magickLoaded_1.magickLoaded;
        return mainSync(Object.assign(Object.assign({}, o), { inputFiles: yield file_1.File.resolve(o.inputFiles) }));
    }));
}
exports.main = main;
function mainSync(options) {
    const t0 = Date.now();
    misc_utils_of_mine_generic_1.objectKeys(options_1.getOptions())
        .filter(k => misc_utils_of_mine_generic_1.notUndefined(options[k]))
        .forEach(k => options_1.setOptions({ [k]: options[k] }));
    const { emscriptenNodeFsRoot, debug } = options_1.getOptions();
    debug && console.log('main call given options: ', options);
    const { FS, main } = magickLoaded_1.getMagick();
    FS.chdir(emscriptenNodeFsRoot);
    options.inputFiles.forEach(f => {
        const dirName = misc_utils_of_mine_generic_1.dirname(f.name);
        if (dirName.trim()) {
            mkdirp_1.mkdirp(dirName, p => FS.analyzePath(p).exists, FS.mkdir);
        }
        debug && console.log('FS.write', f.name);
        fileUtil_1.writeFile(f, FS);
    });
    const beforeTree = lsR_1.listFilesRecursively(emscriptenNodeFsRoot, FS);
    let returnValue;
    var processedCommand = command_1.processCommand(options.command);
    if (options.verbose) {
        processedCommand.splice(1, 0, '-verbose');
    }
    debug && console.log('main processed command:', processedCommand);
    try {
        returnValue = main(processedCommand);
    }
    catch (error) {
        debug && console.error('MAIN error', error);
        returnValue = {
            stderr: [],
            stdout: [],
            error,
            returnValue: undefined
        };
    }
    var verbose = options.verbose ? misc_utils_of_mine_generic_1.tryTo(() => imageUtil_1.parseConvertVerbose(returnValue.stdout)) || [] : [];
    const outputFiles = lsR_1.listFilesRecursively(emscriptenNodeFsRoot, FS)
        .filter(f => !beforeTree.find(b => b.path === f.path)) // tree diff
        .map(f => {
        const file = fileUtil_1.readFile(f.path, FS);
        var v = verbose.find(v => file.name.endsWith(v.outputName));
        if (v) {
            file.width = v.outputSize.width;
            file.height = v.outputSize.height;
        }
        if (options.protectOutputFiles) {
            protected_1.protectFile(file);
        }
        return file;
    });
    const removed = [];
    lsR_1.ls(emscriptenNodeFsRoot, FS)
        .filter(f => !protected_1.isProtectedFile(f))
        .forEach(f => rmRf_1.rmRf(f, FS, f => !protected_1.isProtectedFile(f), removed));
    options.debug && console.log(`Removed files: ${removed}\nProtected files: ${lsR_1.ls(emscriptenNodeFsRoot, FS).map(protected_1.isProtectedFile)}`);
    return Object.assign(Object.assign({}, returnValue), { outputFiles,
        verbose, times: {
            total: Date.now() - t0
        } });
}
exports.mainSync = mainSync;
//# sourceMappingURL=main.js.map