@fimbul/wotan/src/utils.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.djb2 = exports.getOutputFileNamesOfProjectReference = exports.iterateProjectReferences = exports.invertChangeRange = exports.hasParseErrors = exports.addUnique = exports.flatMap = exports.mapDefined = exports.hasSupportedExtension = exports.calculateChangeRange = exports.assertNever = exports.format = exports.unixifyPath = exports.resolveCachedResult = exports.arrayify = exports.emptyArray = exports.OFFSET_TO_NODE_MODULES = void 0;
const json5 = require("json5");
const yaml = require("js-yaml");
const path = require("path");
/**
 * Number of .. until the containing node_modules.
 * __dirname -> src
 * ..        -> project root
 * ../..     -> node_modules (or @scope)
 * ../../..  -> node_modules if @scoped package
 */
exports.OFFSET_TO_NODE_MODULES = 3;
exports.emptyArray = [];
function arrayify(maybeArr) {
    return Array.isArray(maybeArr)
        ? maybeArr
        : maybeArr === undefined
            ? exports.emptyArray
            : [maybeArr];
}
exports.arrayify = arrayify;
function resolveCachedResult(cache, key, cb) {
    let result = cache.get(key);
    if (result === undefined && !cache.has(key)) {
        result = cb(key);
        cache.set(key, result);
    }
    return result;
}
exports.resolveCachedResult = resolveCachedResult;
function unixifyPath(p) {
    return p.replace(/\\/g, '/');
}
exports.unixifyPath = unixifyPath;
function format(value, fmt = "yaml" /* Yaml */) {
    value = convertToPrintable(value) || {};
    switch (fmt) {
        case "json" /* Json */:
            return JSON.stringify(value, undefined, 2);
        case "json5" /* Json5 */:
            return json5.stringify(value, undefined, 2);
        case "yaml" /* Yaml */:
            return yaml.dump(value, {
                indent: 2,
                schema: yaml.JSON_SCHEMA,
                sortKeys: true,
            });
        default:
            return assertNever(fmt);
    }
}
exports.format = format;
function convertToPrintable(value) {
    if (value == undefined || typeof value !== 'object')
        return value;
    if (value instanceof Map) {
        const obj = {};
        for (const [k, v] of value)
            if (v !== undefined)
                obj[k] = v;
        value = obj;
    }
    if (Array.isArray(value)) {
        const result = mapDefined(value, convertToPrintable);
        return result.length === 0 ? undefined : result;
    }
    const keys = Object.keys(value);
    if (keys.length === 0)
        return;
    let added = false;
    const newValue = {};
    for (const key of keys) {
        const converted = convertToPrintable(value[key]);
        if (converted !== undefined) {
            newValue[key] = converted;
            added = true;
        }
    }
    return added ? newValue : undefined;
}
function assertNever(v) {
    throw new Error(`unexpected value '${v}'`);
}
exports.assertNever = assertNever;
function calculateChangeRange(original, changed) {
    const diff = changed.length - original.length;
    let start = 0;
    let end = original.length;
    const minEnd = diff >= 0 ? end : changed.length;
    for (; start < minEnd && original[start] === changed[start]; ++start)
        ;
    if (start !== minEnd) {
        const maxStart = end - minEnd + start;
        for (let changedEnd = changed.length; maxStart < end && original[end - 1] === changed[changedEnd - 1]; --end, --changedEnd)
            ;
    }
    const length = end - start;
    return {
        span: {
            start,
            length,
        },
        newLength: length + diff,
    };
}
exports.calculateChangeRange = calculateChangeRange;
function hasSupportedExtension(fileName, extensions) {
    const ext = path.extname(fileName);
    return /^\.[jt]sx?$/.test(ext) || extensions !== undefined && extensions.includes(ext);
}
exports.hasSupportedExtension = hasSupportedExtension;
function mapDefined(input, cb) {
    const result = [];
    for (const item of input) {
        const current = cb(item);
        if (current !== undefined)
            result.push(current);
    }
    return result;
}
exports.mapDefined = mapDefined;
function flatMap(input, cb) {
    const result = [];
    for (const item of input)
        result.push(...cb(item));
    return result;
}
exports.flatMap = flatMap;
/**
 * Adds an item to an array if it's not already included.
 * @returns true if the item was not present in the array
 * */
function addUnique(arr, item) {
    if (arr.includes(item))
        return false;
    arr.push(item);
    return true;
}
exports.addUnique = addUnique;
function hasParseErrors(sourceFile) {
    return sourceFile.parseDiagnostics.length !== 0;
}
exports.hasParseErrors = hasParseErrors;
function invertChangeRange(range) {
    return {
        span: {
            start: range.span.start,
            length: range.newLength,
        },
        newLength: range.span.length,
    };
}
exports.invertChangeRange = invertChangeRange;
function iterateProjectReferences(references) {
    return iterateProjectReferencesWorker(references, []);
}
exports.iterateProjectReferences = iterateProjectReferences;
function* iterateProjectReferencesWorker(references, seen) {
    if (references === undefined)
        return;
    for (const ref of references) {
        if (ref === undefined || !addUnique(seen, ref.sourceFile.fileName))
            continue;
        yield ref;
        yield* iterateProjectReferencesWorker(ref.references, seen);
    }
}
function getOutputFileNamesOfProjectReference(ref) {
    const options = ref.commandLine.options;
    const outFile = options.outFile || options.out;
    if (outFile)
        return [getOutFileDeclarationName(outFile)];
    const projectDirectory = path.dirname(ref.sourceFile.fileName);
    return mapDefined(ref.commandLine.fileNames, (fileName) => getDeclarationOutputName(fileName, options, projectDirectory));
}
exports.getOutputFileNamesOfProjectReference = getOutputFileNamesOfProjectReference;
// TODO remove once https://github.com/Microsoft/TypeScript/issues/26410 is resolved
function getDeclarationOutputName(fileName, options, projectDirectory) {
    const extension = path.extname(fileName);
    switch (extension) {
        case '.tsx':
        case '.js':
        case '.jsx':
            break;
        case '.ts':
            if (path.extname(fileName.slice(0, -extension.length)) !== '.d')
                break;
        // falls through: .d.ts files produce no output
        default:
            return;
    }
    fileName = fileName.slice(0, -extension.length) + '.d.ts';
    return unixifyPath(path.resolve(options.declarationDir || options.outDir || projectDirectory, path.relative(options.rootDir || projectDirectory, fileName)));
}
function getOutFileDeclarationName(outFile) {
    // outFile ignores declarationDir
    return outFile.slice(0, -path.extname(outFile).length) + '.d.ts';
}
function djb2(str) {
    let hash = 5381;
    for (let i = 0; i < str.length; ++i)
        hash = ((hash << 5) + hash) + str.charCodeAt(i);
    return hash;
}
exports.djb2 = djb2;
//# sourceMappingURL=utils.js.map