svg-term-cli/lib/cli.js

#!/usr/bin/env node
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const os = require("os");
const path = require("path");
const guess_terminal_1 = require("guess-terminal");
const macosAppConfig = require("macos-app-config");
const meow = require("meow");
const parsers = require("term-schemes");
const term_schemes_1 = require("term-schemes");
const plist = require('plist');
const fetch = require('node-fetch');
const getStdin = require('get-stdin');
const { render } = require('svg-term');
const sander = require('@marionebl/sander');
withCli(main, `
  Usage
    $ svg-term [options]

  Options
    --at            timestamp of frame to render in ms [number]
    --cast          asciinema cast id to download [string], required if no stdin provided
    --cursor        display cursor, defaults to true [boolean]
    --frame         wether to frame the result with an application window [boolean]
    --from          lower range of timeline to render in ms [number]
    --height        height in lines [number]
    --help          print this help [boolean]
    --out           output file, emits to stdout if omitted
    --padding       distance between text and image bounds
    --padding-x     distance between text and image bounds on x axis
    --padding-y     distance between text and image bounds on y axis
    --profile       terminal profile file to use [file], requires --term
    --term          terminal profile format, requires [iterm2, xrdb, xresources, terminator, konsole, terminal, remmina, termite, tilda, xcfe] --profile
    --to            upper range of timeline to render in ms [number]
    --width         width in columns [number]

  Examples
    $ echo rec.json | svg-term 
    $ svg-term --cast 113643 
    $ svg-term --cast 113643 --out examples/parrot.svg
`);
function main(cli) {
    return __awaiter(this, void 0, void 0, function* () {
        const input = yield getInput(cli);
        const error = cliError(cli);
        if (!input) {
            throw error(`svg-term: either stdin or --cast are required`);
        }
        const malformed = ensure(['height', 'width'], cli.flags, (name, val) => {
            if (!(name in cli.flags)) {
                return;
            }
            const candidate = parseInt(val, 10);
            if (isNaN(candidate)) {
                return new TypeError(`${name} expected to be number, received "${val}"`);
            }
        });
        if (malformed.length > 0) {
            throw error(`svg-term: ${malformed.map(m => m.message).join('\n')}`);
        }
        const missingValue = ensure(['cast', 'out', 'profile'], cli.flags, (name, val) => {
            if (!(name in cli.flags)) {
                return;
            }
            if (name === 'cast' && typeof val === 'number') {
                return;
            }
            if (typeof val !== 'string') {
                return new TypeError(`${name} expected to be string, received "${val}"`);
            }
        });
        if (missingValue.length > 0) {
            throw error(`svg-term: ${missingValue.map(m => m.message).join('\n')}`);
        }
        const shadowed = ensure(['at', 'from', 'to'], cli.flags, (name, val) => {
            if (!(name in cli.flags)) {
                return;
            }
            if (typeof val !== 'number' || isNaN(val)) {
                return new TypeError(`${name} expected to be number, received "${val}"`);
            }
            if (name !== 'at' && typeof cli.flags.at === 'number') {
                return new TypeError(`--at flag disallows --${name}`);
            }
        });
        if (shadowed.length > 0) {
            throw error(`svg-term: ${shadowed.map(m => m.message).join('\n')}`);
        }
        const term = guess_terminal_1.guessTerminal() || cli.flags.term;
        const profile = term ? guessProfile(term) || cli.flags.profile : cli.flags.profile;
        const guess = {
            term,
            profile
        };
        if (('term' in cli.flags) || ('profile' in cli.flags)) {
            const unsatisfied = ['term', 'profile'].filter(n => !Boolean(guess[n]));
            if (unsatisfied.length > 0) {
                throw error(`svg-term: --term and --profile must be used together, ${unsatisfied.join(', ')} missing`);
            }
        }
        const unknown = ensure(['term'], cli.flags, (name, val) => {
            if (!(name in cli.flags)) {
                return;
            }
            if (!(cli.flags.term in term_schemes_1.TermSchemes)) {
                return new TypeError(`${name} expected to be one of ${Object.keys(term_schemes_1.TermSchemes).join(', ')}, received "${val}"`);
            }
        });
        if (unknown.length > 0) {
            throw error(`svg-term: ${unknown.map(m => m.message).join('\n')}`);
        }
        const p = guess.profile || '';
        const isFileProfile = ['~', '/', '.'].indexOf(p.charAt(0)) > -1;
        if (isFileProfile && 'profile' in cli.flags) {
            const missing = !fs.existsSync(path.join(process.cwd(), cli.flags.profile));
            if (missing) {
                throw error(`svg-term: ${cli.flags.profile} must be readable file but was not found`);
            }
        }
        const theme = getTheme(guess);
        const svg = render(input, {
            at: toNumber(cli.flags.at),
            cursor: toBoolean(cli.flags.cursor, true),
            from: toNumber(cli.flags.from),
            paddingX: toNumber(cli.flags.paddingX || cli.flags.padding),
            paddingY: toNumber(cli.flags.paddingY || cli.flags.padding),
            to: toNumber(cli.flags.to),
            height: toNumber(cli.flags.height),
            theme,
            width: toNumber(cli.flags.width),
            window: toBoolean(cli.flags.frame, false)
        });
        if (typeof cli.flags.out === 'string') {
            sander.writeFile(cli.flags.out, Buffer.from(svg));
        }
        else {
            process.stdout.write(svg);
        }
    });
}
function ensure(names, flags, predicate) {
    return names.map(name => predicate(name, flags[name])).filter(e => e instanceof Error);
}
function cliError(cli) {
    return (message) => {
        const err = new Error(message);
        err.help = () => cli.help;
        return err;
    };
}
function getConfig(term) {
    switch (term) {
        case guess_terminal_1.GuessedTerminal.terminal: {
            return macosAppConfig.sync(term)[0];
        }
        case guess_terminal_1.GuessedTerminal.iterm2: {
            return macosAppConfig.sync(term)[0];
        }
        default:
            return null;
    }
}
function getPresets(term) {
    const config = getConfig(term);
    switch (term) {
        case guess_terminal_1.GuessedTerminal.terminal: {
            return config['Window Settings'];
        }
        case guess_terminal_1.GuessedTerminal.iterm2: {
            return config['Custom Color Presets'];
        }
        default:
            return null;
    }
}
function guessProfile(term) {
    if (os.platform() !== 'darwin') {
        return null;
    }
    const config = getConfig(term);
    if (!config) {
        return null;
    }
    switch (term) {
        case guess_terminal_1.GuessedTerminal.terminal: {
            return config['Default Window Settings'];
        }
        case guess_terminal_1.GuessedTerminal.iterm2: {
            const presets = config['Custom Color Presets'];
        }
        default:
            return null;
    }
}
function getInput(cli) {
    return __awaiter(this, void 0, void 0, function* () {
        if (cli.flags.cast) {
            const response = yield fetch(`https://asciinema.org/a/${cli.flags.cast}.cast?dl=true`);
            return response.text();
        }
        return yield getStdin();
    });
}
function getParser(term) {
    switch (term) {
        case term_schemes_1.TermSchemes.iterm2:
            return parsers.iterm2;
        case term_schemes_1.TermSchemes.konsole:
            return parsers.konsole;
        case term_schemes_1.TermSchemes.remmina:
            return parsers.remmina;
        case term_schemes_1.TermSchemes.terminal:
            return parsers.terminal;
        case term_schemes_1.TermSchemes.terminator:
            return parsers.terminator;
        case term_schemes_1.TermSchemes.termite:
            return parsers.termite;
        case term_schemes_1.TermSchemes.tilda:
            return parsers.tilda;
        case term_schemes_1.TermSchemes.xcfe:
            return parsers.xfce;
        case term_schemes_1.TermSchemes.xresources:
            return parsers.xresources;
        case term_schemes_1.TermSchemes.xterm:
            return parsers.xterm;
        default:
            throw new Error(`unknown term parser: ${term}`);
    }
}
function getTheme(guess) {
    if (guess.term === null || guess.profile === null) {
        return null;
    }
    const p = guess.profile || '';
    const isFileProfile = ['~', '/', '.'].indexOf(p.charAt(0)) > -1;
    return isFileProfile
        ? parseTheme(guess.term, guess.profile)
        : extractTheme(guess.term, guess.profile);
}
function parseTheme(term, input) {
    const parser = getParser(term);
    return parser(String(fs.readFileSync(input)));
}
function extractTheme(term, name) {
    if (!(term in guess_terminal_1.GuessedTerminal)) {
        return null;
    }
    if (os.platform() !== 'darwin') {
        return null;
    }
    if (term === guess_terminal_1.GuessedTerminal.hyper) {
        const filename = path.resolve(os.homedir(), '.hyper.js');
        const theme = parsers.hyper(String(fs.readFileSync(filename)), { filename });
        return theme;
    }
    const presets = getPresets(term);
    if (!presets) {
        return null;
    }
    const theme = presets[name];
    const parser = getParser(term);
    if (!theme) {
        return null;
    }
    switch (term) {
        case guess_terminal_1.GuessedTerminal.iterm2: {
            return parser(plist.build(theme));
        }
        case guess_terminal_1.GuessedTerminal.terminal:
            return parser(plist.build(theme));
        default:
            return null;
    }
}
function toNumber(input) {
    if (!input) {
        return null;
    }
    const candidate = parseInt(input, 10);
    if (isNaN(candidate)) {
        return null;
    }
    return candidate;
}
function toBoolean(input, fb) {
    if (typeof input === 'undefined') {
        return fb;
    }
    if (input === 'false') {
        return false;
    }
    if (input === 'true') {
        return true;
    }
    return input === true;
}
function withCli(fn, help = '') {
    return main(meow(help))
        .catch(err => {
        setTimeout(() => {
            if (typeof err.help === 'function') {
                console.log(err.help());
                console.log('\n', err.message);
                process.exit(1);
            }
            throw err;
        }, 0);
    });
}