denoify/lib/config/parseParams.js

For NPM module authors that would like to support Deno but do not want to write and maintain a port.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getDenoifyParamsWithCosmiconfig = exports.parseAsDenoifyConfig = exports.parseAsDenoifyParams = void 0;
const fs = require("fs");
const cosmiconfig_1 = require("cosmiconfig");
const _1 = require(".");
const path_1 = require("path");
const guardAsOptionalString = (string) => (typeof string === "string" ? string : undefined);
const guardAsString = (param) => {
    if (typeof param.string === "string") {
        return param.string;
    }
    throw new Error(param.errorMessage);
};
function parseAsDenoifyParams(denoifyParams) {
    if (denoifyParams === undefined) {
        return undefined;
    }
    const generateErrorMessage = ({ name, type, param }) => [
        "Denoify configuration Error",
        `Expect ${name} to be ${type}, got ${param} instead`,
        "See: https://github.com/garronej/my_dummy_npm_and_deno_module"
    ].join("\n");
    const { includes } = denoifyParams;
    return {
        "replacer": guardAsOptionalString(denoifyParams.replacer),
        "out": guardAsOptionalString(denoifyParams.out),
        "index": guardAsOptionalString(denoifyParams.index),
        "includes": !Array.isArray(includes)
            ? undefined
            : includes.map(element => {
                const result = guardAsOptionalString(element);
                if (result !== undefined) {
                    return result;
                }
                if (typeof element !== "object") {
                    throw new Error(generateErrorMessage({
                        "param": includes,
                        "name": "element in includes",
                        "type": "object with type: { destDir: string?, destBasename: string?, src: string }"
                    }));
                }
                return {
                    "destDir": guardAsOptionalString(element.destDir),
                    "destBasename": guardAsOptionalString(element.destBasename),
                    "src": guardAsString({
                        string: element.src,
                        errorMessage: generateErrorMessage({
                            "type": "string",
                            "param": element.src,
                            "name": "src in includes array"
                        })
                    })
                };
            }),
        "ports": denoifyParams.ports === undefined || denoifyParams.ports === null
            ? undefined
            : Object.entries(denoifyParams.ports).reduce((prev, [portName, string]) => ({
                ...prev,
                [portName]: guardAsString({
                    string,
                    errorMessage: generateErrorMessage({
                        "param": string,
                        "type": "string",
                        "name": "value of ports object"
                    })
                })
            }), {})
    };
}
exports.parseAsDenoifyParams = parseAsDenoifyParams;
function parseAsDenoifyConfig({ configFileType }) {
    switch (configFileType.type) {
        case "absent":
            return undefined;
        case "json": {
            const parsed = JSON.parse(configFileType.configFileRawContent);
            return parseAsDenoifyParams(configFileType.configFileBasename !== _1.default.packageJson ? parsed : parsed.denoify);
        }
        case "js": {
            const cacheFilePath = (0, path_1.join)(process.cwd(), "node_modules", ".cache", "denoify", "cacheDirPath", "config.js");
            {
                const dirPath = (0, path_1.dirname)(cacheFilePath);
                if (!fs.existsSync(dirPath)) {
                    fs.mkdirSync(dirPath, {
                        "recursive": true
                    });
                }
            }
            fs.writeFileSync(cacheFilePath, configFileType.configFileRawContent);
            // cosmiconfig internally uses import-fresh to parse JS config
            // import-fresh only support commonjs export, so we can use require
            const denoifyParams = parseAsDenoifyParams(require(cacheFilePath));
            fs.rmSync(cacheFilePath, { "force": true });
            return denoifyParams;
        }
    }
}
exports.parseAsDenoifyConfig = parseAsDenoifyConfig;
async function getDenoifyParamsWithCosmiconfig() {
    const explorer = (0, cosmiconfig_1.cosmiconfig)("denoify");
    const search = await explorer.search();
    if (search) {
        console.log(`Configurations from ${search.filepath} are used`);
    }
    return parseAsDenoifyParams(search?.config ?? undefined);
}
exports.getDenoifyParamsWithCosmiconfig = getDenoifyParamsWithCosmiconfig;