The code imports dependencies, including a selectAst function, and uses it to define a getRequires function that extracts require statements from JavaScript code. The getRequires function is then exported as a module, making it available for use in other parts of the application.

Run example

npm run import -- "get requires"

get requires

var importer = require('../Core');
var {selectAst} = importer.import("select code tree")

// TODO: use this in files and gulp script 
//   require("module").builtinModules
function getRequires(code) {
    return [].concat.apply([], selectAst([
        `//CallExpression[./Identifier[@name="require"]]`,
        (ctx) => {
            var req = selectAst([`.//Literal/@value`], ctx)
            if(req.length === 0) throw new Error(
                `dynamic require: ${JSON.stringify(htmlToTree(ctx))}`)
            return req;
        }
    ], code))
}


module.exports = {
    getRequires
}

const { selectAst } = require('../Core');

/**
 * Extracts the require statements from the given code.
 * 
 * @param {string} code The code to extract require statements from.
 * @returns {string[]} An array of require statements.
 */
function getRequires(code) {
    const requires = selectAst([
        'CallExpression[./Identifier[@name="require"]]',
        (ctx) => {
            const values = selectAst(['./Literal[@value]', './TemplateLiteral[@value]'], ctx);
            if (values.length === 0) {
                throw new Error(`Dynamic require: ${JSON.stringify(selectAst(['//code'], ctx))}`);
            }
            return values;
        }
    ], code);

    // Remove duplicates and empty values
    return requires.filter((require, index, self) => {
        return self.indexOf(require) === index && require.trim()!== '';
    });
}

module.exports = { getRequires };

Code Breakdown

Importing Dependencies

var importer = require('../Core');
var {selectAst} = importer.import('select code tree')

• The code imports a module named ../Core and assigns it to the importer variable.
• It then imports a function named selectAst from the importer module using the import method. The string 'select code tree' is likely a key or identifier for the selectAst function within the importer module.

Defining the getRequires Function

function getRequires(code) {
    return [].concat.apply([], selectAst([
        `//CallExpression[./Identifier[@name="require"]]`,
        (ctx) => {
            var req = selectAst([`.//Literal/@value`], ctx)
            if(req.length === 0) throw new Error(
                `dynamic require: ${JSON.stringify(htmlToTree(ctx))}`)
            return req;
        }
    ], code))
}

• The getRequires function takes a single argument code, which is likely a string representing JavaScript code.
• It uses the selectAst function to extract relevant data from the code string.
• The selectAst function is called with an array of two elements:
  • A string that appears to be a CSS-like selector for a specific pattern in the code.
  • A callback function that takes a context object ctx as an argument.
• Within the callback function, another call to selectAst is made to extract the value of a Literal node.
• If no Literal node is found, an error is thrown with a message that includes the context object's HTML representation using htmlToTree.
• The results of the two selectAst calls are concatenated and returned by the getRequires function.

Exporting the getRequires Function

module.exports = {
    getRequires
}

• The getRequires function is exported as a module, making it available for use in other parts of the application.