@hakobu/hakobu 1.0.0

package/lib-es5/detector.js

@@ -0,0 +1,421 @@
+"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 });
+exports.detect = exports.parse = exports.visitorUseSCWD = exports.visitorMalformed = exports.visitorNonLiteral = exports.visitorSuccessful = void 0;
+const babelTypes = __importStar(require("@babel/types"));
+const babel = __importStar(require("@babel/parser"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const log_1 = require("./log");
+const common_1 = require("./common");
+function isLiteral(node) {
+    if (node == null) {
+        return false;
+    }
+    if (!node.type.endsWith('Literal')) {
+        return false;
+    }
+    if (node.type === 'TemplateLiteral' && node.expressions.length !== 0) {
+        return false;
+    }
+    return true;
+}
+function getLiteralValue(node) {
+    if (node.type === 'TemplateLiteral') {
+        return node.quasis[0].value.raw;
+    }
+    if (node.type === 'NullLiteral') {
+        throw new Error('Unexpected null in require expression');
+    }
+    if (node.type === 'RegExpLiteral') {
+        throw new Error('Unexpected regexp in require expression');
+    }
+    return node.value;
+}
+function reconstructSpecifiers(specs) {
+    if (!specs || !specs.length) {
+        return '';
+    }
+    const defaults = [];
+    for (const spec of specs) {
+        if (babelTypes.isImportDefaultSpecifier(spec)) {
+            defaults.push(spec.local.name);
+        }
+    }
+    const nonDefaults = [];
+    for (const spec of specs) {
+        if (babelTypes.isImportSpecifier(spec)) {
+            const importedName = babelTypes.isIdentifier(spec.imported)
+                ? spec.imported.name
+                : spec.imported.value;
+            if (spec.local.name === importedName) {
+                nonDefaults.push(spec.local.name);
+            }
+            else {
+                nonDefaults.push(`${importedName} as ${spec.local.name}`);
+            }
+        }
+    }
+    if (nonDefaults.length) {
+        defaults.push(`{ ${nonDefaults.join(', ')} }`);
+    }
+    return defaults.join(', ');
+}
+function reconstruct(node) {
+    let v = (0, generator_1.default)(node, { comments: false }).code.replace(/\n/g, '');
+    let v2;
+    while (true) {
+        v2 = v.replace(/\[ /g, '[').replace(/ \]/g, ']').replace(/ {2}/g, ' ');
+        if (v2 === v) {
+            break;
+        }
+        v = v2;
+    }
+    return v2;
+}
+function forge(pattern, was) {
+    return pattern
+        .replace('{c1}', ', ')
+        .replace('{v1}', `"${was.v1}"`)
+        .replace('{c2}', was.v2 ? ', ' : '')
+        .replace('{v2}', was.v2 ? `"${was.v2}"` : '')
+        .replace('{c3}', was.v3 ? ' from ' : '')
+        .replace('{v3}', was.v3 ? was.v3 : '');
+}
+function valid2(v2) {
+    return (v2 === undefined ||
+        v2 === null ||
+        v2 === 'must-exclude' ||
+        v2 === 'may-exclude');
+}
+function visitorRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    if (!n.arguments || !isLiteral(n.arguments[0])) {
+        return null;
+    }
+    return {
+        v1: getLiteralValue(n.arguments[0]),
+        v2: isLiteral(n.arguments[1]) ? getLiteralValue(n.arguments[1]) : null,
+    };
+}
+function visitorRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    if (!n.arguments || !isLiteral(n.arguments[0])) {
+        return null;
+    }
+    return {
+        v1: getLiteralValue(n.arguments[0]),
+        v2: isLiteral(n.arguments[1]) ? getLiteralValue(n.arguments[1]) : null,
+    };
+}
+function visitorImport(n) {
+    if (!babelTypes.isImportDeclaration(n)) {
+        return null;
+    }
+    return { v1: n.source.value, v3: reconstructSpecifiers(n.specifiers) };
+}
+function visitorPathJoin(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object &&
+        n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'path' &&
+        n.callee.property &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'join';
+    if (!ci) {
+        return null;
+    }
+    const dn = n.arguments[0] &&
+        n.arguments[0].type === 'Identifier' &&
+        n.arguments[0].name === '__dirname';
+    if (!dn) {
+        return null;
+    }
+    const f = n.arguments && isLiteral(n.arguments[1]) && n.arguments.length === 2; // TODO concat them
+    if (!f) {
+        return null;
+    }
+    return { v1: getLiteralValue(n.arguments[1]) };
+}
+function visitorSuccessful(node, test = false) {
+    let was = visitorRequireResolve(node);
+    if (was) {
+        if (test) {
+            return forge('require.resolve({v1}{c2}{v2})', was);
+        }
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            aliasType: common_1.ALIAS_AS_RESOLVABLE,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    was = visitorRequire(node);
+    if (was) {
+        if (test) {
+            return forge('require({v1}{c2}{v2})', was);
+        }
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            aliasType: common_1.ALIAS_AS_RESOLVABLE,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    was = visitorImport(node);
+    if (was) {
+        if (test) {
+            return forge('import {v3}{c3}{v1}', was);
+        }
+        return { alias: was.v1, aliasType: common_1.ALIAS_AS_RESOLVABLE };
+    }
+    was = visitorPathJoin(node);
+    if (was) {
+        if (test) {
+            return forge('path.join(__dirname{c1}{v1})', was);
+        }
+        return { alias: was.v1, aliasType: common_1.ALIAS_AS_RELATIVE, mayExclude: false };
+    }
+    return null;
+}
+exports.visitorSuccessful = visitorSuccessful;
+function nonLiteralRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    if (isLiteral(n.arguments[0])) {
+        return null;
+    }
+    const m = n.arguments[1];
+    if (!m) {
+        return { v1: reconstruct(n.arguments[0]) };
+    }
+    if (!isLiteral(n.arguments[1])) {
+        return null;
+    }
+    return {
+        v1: reconstruct(n.arguments[0]),
+        v2: getLiteralValue(n.arguments[1]),
+    };
+}
+function nonLiteralRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    if (isLiteral(n.arguments[0])) {
+        return null;
+    }
+    const m = n.arguments[1];
+    if (!m) {
+        return { v1: reconstruct(n.arguments[0]) };
+    }
+    if (!isLiteral(n.arguments[1])) {
+        return null;
+    }
+    return {
+        v1: reconstruct(n.arguments[0]),
+        v2: getLiteralValue(n.arguments[1]),
+    };
+}
+function visitorNonLiteral(n) {
+    const was = nonLiteralRequireResolve(n) || nonLiteralRequire(n);
+    if (was) {
+        if (!valid2(was.v2)) {
+            return null;
+        }
+        return {
+            alias: was.v1,
+            mustExclude: was.v2 === 'must-exclude',
+            mayExclude: was.v2 === 'may-exclude',
+        };
+    }
+    return null;
+}
+exports.visitorNonLiteral = visitorNonLiteral;
+function isRequire(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isIdentifier(n.callee)) {
+        return null;
+    }
+    if (n.callee.name !== 'require') {
+        return null;
+    }
+    const f = n.arguments && n.arguments[0];
+    if (!f) {
+        return null;
+    }
+    return { v1: reconstruct(n.arguments[0]) };
+}
+function isRequireResolve(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'require' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    const f = n.type === 'CallExpression' && n.arguments && n.arguments[0];
+    if (!f) {
+        return null;
+    }
+    return { v1: reconstruct(n.arguments[0]) };
+}
+function visitorMalformed(n) {
+    const was = isRequireResolve(n) || isRequire(n);
+    if (was) {
+        return { alias: was.v1 };
+    }
+    return null;
+}
+exports.visitorMalformed = visitorMalformed;
+function visitorUseSCWD(n) {
+    if (!babelTypes.isCallExpression(n)) {
+        return null;
+    }
+    if (!babelTypes.isMemberExpression(n.callee)) {
+        return null;
+    }
+    const ci = n.callee.object.type === 'Identifier' &&
+        n.callee.object.name === 'path' &&
+        n.callee.property.type === 'Identifier' &&
+        n.callee.property.name === 'resolve';
+    if (!ci) {
+        return null;
+    }
+    const was = { v1: n.arguments.map(reconstruct).join(', ') };
+    if (was) {
+        return { alias: was.v1 };
+    }
+    return null;
+}
+exports.visitorUseSCWD = visitorUseSCWD;
+function traverse(ast, visitor) {
+    // modified esprima-walk to support
+    // visitor return value and "trying" flag
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const stack = [[ast, false]];
+    for (let i = 0; i < stack.length; i += 1) {
+        const item = stack[i];
+        const [node] = item;
+        if (node) {
+            const trying = item[1] || babelTypes.isTryStatement(node);
+            if (visitor(node, trying)) {
+                for (const key in node) {
+                    if (node[key]) {
+                        const child = node[key];
+                        if (child instanceof Array) {
+                            for (let j = 0; j < child.length; j += 1) {
+                                stack.push([child[j], trying]);
+                            }
+                        }
+                        else if (child && typeof child.type === 'string') {
+                            stack.push([child, trying]);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+function parse(body) {
+    return babel.parse(body, {
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+    });
+}
+exports.parse = parse;
+function detect(body, visitor, file) {
+    let json;
+    try {
+        json = parse(body);
+    }
+    catch (error) {
+        const fileInfo = file ? ` in ${file}` : '';
+        log_1.log.warn(`Babel parse has failed: ${error.message}${fileInfo}`);
+    }
+    if (!json) {
+        return;
+    }
+    traverse(json, visitor);
+}
+exports.detect = detect;
+//# sourceMappingURL=detector.js.map