leetcode-tools/dist/index.js

A cli tool to enjoy leetcode!

#!/usr/bin/env node
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const commander_1 = require("commander");
const dotenv_1 = __importDefault(require("dotenv"));
const Leetcode = __importStar(require("./leetcode"));
const Problem = __importStar(require("./problem"));
const Contest = __importStar(require("./contest"));
const Mkdocs = __importStar(require("./mkdocs"));
const path_1 = __importDefault(require("path"));
const log_1 = __importDefault(require("./log"));
const ErrorMsg = __importStar(require("./errorMsg"));
const interface_1 = require("./interface");
const leetcode_api_typescript_1 = require("leetcode-api-typescript");
const fs_1 = __importDefault(require("fs"));
const shelljs_1 = __importDefault(require("shelljs"));
const js_yaml_1 = __importDefault(require("js-yaml"));
const constant_1 = require("./constant");
function addProblemProgram(program) {
    const getDefaultProblemSlug = () => {
        let slug;
        slug = process.env.INIT_CWD?.split(path_1.default.sep).slice(-1)[0];
        slug = slug.split(".").slice(-1)[0];
        return slug;
    };
    const getDefaultDst = () => {
        return process.env.INIT_CWD;
    };
    const getDefaultLangSlug = () => {
        return leetcode_api_typescript_1.LangSlug.cpp;
    };
    const getDefaultIdx = () => {
        return "";
    };
    const makeProblemCommand = (name) => {
        const subProgram = program.command(name);
        subProgram.description("some operations related to the problem");
        const newCommand = subProgram.command("new <slug>");
        const pullCommand = subProgram.command("pull");
        const codeCommand = subProgram.command("code");
        const submitCommand = subProgram.command("submit");
        const submissionCommand = subProgram.command("submission");
        const newAction = async (slug) => {
            const options = newCommand.opts();
            const { dst } = options;
            try {
                await Problem.New(slug, dst);
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        const pullAction = async () => {
            const options = pullCommand.opts();
            const { slug, dst } = options;
            try {
                await Problem.Pull(slug, dst);
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        const codeAction = async () => {
            const options = codeCommand.opts();
            const { slug, dst, idx } = options;
            let { langSlug, fileName } = options;
            try {
                if (!process.env.LEETCODE_TEMPLATE_PATH) {
                    throw new Error(`${ErrorMsg.EnvironmentVariableDoesNotExist} [envName=LEETCODE_TEMPLATE_PATH]`);
                }
                if (!langSlug) {
                    langSlug = getDefaultLangSlug();
                }
                else {
                    langSlug = leetcode_api_typescript_1.LangSlug[langSlug];
                }
                fileName = (0, interface_1.SolutionFileName)(langSlug, idx, { fileName });
                const codeTemplateFileName = (0, interface_1.CodeTemplateFileName)(langSlug);
                const templateContent = fs_1.default
                    .readFileSync(path_1.default.join(process.env.LEETCODE_TEMPLATE_PATH, codeTemplateFileName))
                    .toString();
                await Problem.Code(slug, langSlug, templateContent, path_1.default.join(dst, fileName));
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        const submitAction = async () => {
            const options = submitCommand.opts();
            const { slug, dst, idx } = options;
            let { langSlug, fileName } = options;
            try {
                if (!langSlug) {
                    langSlug = getDefaultLangSlug();
                }
                else {
                    langSlug = leetcode_api_typescript_1.LangSlug[langSlug];
                }
                fileName = (0, interface_1.SolutionFileName)(langSlug, idx, { fileName });
                const codePath = path_1.default.join(dst, fileName);
                log_1.default.Info(`codePath: ${codePath}`);
                const code = fs_1.default.readFileSync(codePath).toString();
                await Problem.Submit(slug, langSlug, code);
            }
            catch (err) {
                console.log(err);
            }
        };
        const submissionAction = async () => {
            const options = submissionCommand.opts();
            const { slug } = options;
            try {
                await Problem.GetSubmissions(slug);
            }
            catch (err) {
                console.log(err);
            }
        };
        newCommand
            .option("-d, --dst <string>", "", getDefaultDst())
            .action(newAction);
        pullCommand
            .option("-s --slug <string>", "", getDefaultProblemSlug())
            .option("-d, --dst <string>", "", getDefaultDst())
            .action(pullAction);
        codeCommand
            .option("-s --slug <string>", "", getDefaultProblemSlug())
            .option("-d --dst <string>", "", getDefaultDst())
            .option("-i --idx <number>", "", getDefaultIdx())
            .option("--langSlug <string>")
            .option("--fileName <string>")
            .action(codeAction);
        submitCommand
            .option("-s --slug <string>", "", getDefaultProblemSlug())
            .option("-d --dst <string>", "", getDefaultDst())
            .option("-i --idx <number>", "", getDefaultIdx())
            .option("--langSlug <string>")
            .option("--fileName <string>")
            .action(submitAction);
        submissionCommand
            .option("-s --slug <string>", "", getDefaultProblemSlug())
            .action(submissionAction);
    };
    makeProblemCommand("problem");
    makeProblemCommand("p");
}
function addContestProgram(program) {
    const getDefaultDst = () => {
        return process.env.INIT_CWD;
    };
    const getDefaultContestType = () => {
        return process.env.INIT_CWD?.split(path_1.default.sep).slice(-1)[0];
    };
    const getDefaultContestSlug = () => {
        return process.env.INIT_CWD?.split(path_1.default.sep).slice(-2).join("-");
    };
    const makeContestCommand = (name) => {
        const subProgram = program.command(name);
        subProgram.description("some operations related to the contest");
        const newCommand = subProgram.command("new <id>");
        const pullCommand = subProgram.command("pull");
        const newAction = async (id) => {
            const options = newCommand.opts();
            const { dst, contestType } = options;
            const contestSlug = [contestType, id.toString()].join("-");
            try {
                await Contest.New(contestSlug, dst);
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        const pullAction = async () => {
            const options = pullCommand.opts();
            const { dst, contestSlug } = options;
            try {
                await Contest.Pull(contestSlug, dst);
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        newCommand
            .option("-d --dst <string>", "", getDefaultDst())
            .option("-t --contestType <string>", "", getDefaultContestType())
            .action(newAction);
        pullCommand
            .option("-d --dst <string>", "", getDefaultDst())
            .option("-s --contestSlug <string>", "", getDefaultContestSlug())
            .action(pullAction);
    };
    makeContestCommand("contest");
    makeContestCommand("c");
}
function addMkdocsProgram(program) {
    const getDefaultSrc = () => {
        return path_1.default.join(process.env.INIT_CWD, "docs");
    };
    const getDefaultLeetcodeSrc = () => {
        return path_1.default.join(process.env.INIT_CWD, "leetcode");
    };
    const getDefaultDst = () => {
        return path_1.default.join(process.env.INIT_CWD, "_docs");
    };
    const getDefaultNavTemplateFile = () => {
        return path_1.default.join(process.env.INIT_CWD, "nav.template.yml");
    };
    const getDefaultConfigTemplateFile = () => {
        return path_1.default.join(process.env.INIT_CWD, "mkdocs.template.yml");
    };
    const getDefaultConfigDstFile = () => {
        return path_1.default.join(process.env.INIT_CWD, "mkdocs.yml");
    };
    const makeMkdocsCommand = (name) => {
        const subProgram = program.command(name);
        subProgram.description("some operations related to the markdown");
        const buildCommand = subProgram.command("build");
        const buildAction = async () => {
            const options = buildCommand.opts();
            const { src, leetcodeSrc, dst, navTemplateFile, configTemplateFile, configDstFile, } = options;
            try {
                if (!fs_1.default.existsSync(configTemplateFile)) {
                    throw new Error(`${ErrorMsg.FileDoesNotExist}. [file=${configTemplateFile}]`);
                }
                if (fs_1.default.existsSync(dst)) {
                    fs_1.default.rmSync(dst, { recursive: true });
                }
                fs_1.default.mkdirSync(dst, { recursive: true });
                fs_1.default.copyFileSync(configTemplateFile, configDstFile);
                shelljs_1.default.cp("-R", `${src}/*`, dst);
                // eslint-disable-next-line @typescript-eslint/no-explicit-any
                let navObject = null;
                if (fs_1.default.existsSync(navTemplateFile)) {
                    navObject = js_yaml_1.default.load(fs_1.default.readFileSync(navTemplateFile, "utf8"));
                }
                else {
                    navObject = { nav: [] };
                }
                const buildContent = async (name) => {
                    const docsRelativePath = name;
                    const problemSrcPath = path_1.default.join(leetcodeSrc, docsRelativePath);
                    const problemDstPath = path_1.default.join(dst, docsRelativePath);
                    shelljs_1.default.cp("-R", problemSrcPath, problemDstPath);
                    navObject.nav.push({
                        [constant_1.MkdocsTabTitle[name]]: await Mkdocs.Build(name)(problemSrcPath, problemDstPath, docsRelativePath),
                    });
                };
                await buildContent("problems");
                await buildContent("weekly-contest");
                await buildContent("biweekly-contest");
                const navYamlString = js_yaml_1.default.dump(navObject);
                fs_1.default.appendFileSync(configDstFile, "\n" + navYamlString);
            }
            catch (err) {
                log_1.default.Error(err);
            }
        };
        buildCommand
            .option("-s --src <string>", "", getDefaultSrc())
            .option("--leetcodeSrc <string>", "", getDefaultLeetcodeSrc())
            .option("-d --dst <string>", "", getDefaultDst())
            .option("-n --navTemplateFile <string>", "", getDefaultNavTemplateFile())
            .option("--configTemplateFile <string>", "", getDefaultConfigTemplateFile())
            .option("--configDstFile <string>", "", getDefaultConfigDstFile())
            .action(buildAction);
    };
    makeMkdocsCommand("mkdocs");
    makeMkdocsCommand("md");
}
(async () => {
    dotenv_1.default.config();
    await Leetcode.Login();
    const program = new commander_1.Command();
    program.description("A cli tool to enjoy leetcode!");
    addProblemProgram(program);
    addContestProgram(program);
    addMkdocsProgram(program);
    await program.parseAsync(process.argv);
})();
//# sourceMappingURL=index.js.map