liferay-npm-bundler-preset-reactjs/node_modules/babel-plugin-wrap-modules-amd/lib/index.js

liferay npm bundler preset react

"use strict";
/**
 * SPDX-FileCopyrightText: © 2017 Liferay, Inc. <https://liferay.com>
 * SPDX-License-Identifier: LGPL-3.0-or-later
 */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (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 babel_template_1 = __importDefault(require("babel-template"));
const fs_1 = __importDefault(require("fs"));
const babelIpc = __importStar(require("liferay-npm-build-tools-common/lib/babel-ipc"));
const plugin_logger_1 = __importDefault(require("liferay-npm-build-tools-common/lib/plugin-logger"));
const buildDefine = babel_template_1.default(`
     define(DEPS, function(module, exports, require) {
        // Make module believe it is running under Node.js
		var define = undefined;
		var global = window;
		{
		  SOURCE
		}
     })
 `);
/**
 * @return {object} a babel visitor
 */
function default_1({ types: t }) {
    const wrapVisitor = {
        Identifier(path, state) {
            const { node } = path;
            const { dependencies } = state;
            const { log } = babelIpc.get(state, () => ({
                log: new plugin_logger_1.default(),
            }));
            if (node.name === 'require') {
                const parent = path.parent;
                if (path.scope.hasBinding('require') &&
                    !state['webpackWarnIssued']) {
                    state['webpackWarnIssued'] = true;
                    log.warn('wrap-modules-amd', `Module looks like a webpack bundle, local require() ` +
                        `calls will be ignored`).linkToIssue(389);
                    return;
                }
                if (!t.isCallExpression(parent) ||
                    parent.callee !== node ||
                    parent.arguments.length !== 1) {
                    return;
                }
                const argument0 = parent.arguments[0];
                if (argument0.type === 'StringLiteral') {
                    const moduleName = argument0.value;
                    dependencies[moduleName] = moduleName;
                    return;
                }
                if (argument0.type === 'TemplateLiteral' &&
                    argument0.quasis.length === 1) {
                    const moduleName = argument0.quasis[0].value.raw;
                    dependencies[moduleName] = moduleName;
                    return;
                }
                log.error('wrap-modules-amd', 'Module has a non static require, which is not ' +
                    'supported: module may fail when executed').linkToIssue(588);
            }
        },
    };
    return {
        visitor: {
            Program: {
                exit(path, state) {
                    const { filename } = state.file.opts;
                    const { log } = babelIpc.get(state, () => ({
                        log: new plugin_logger_1.default(),
                    }));
                    let dependencies = {};
                    // We must traverse the AST again because some plugins emit
                    // their require() calls after exiting Program node :-(
                    state.dependencies = dependencies;
                    path.traverse(wrapVisitor, state);
                    const { node } = path;
                    const { body } = node;
                    dependencies = Object.keys(dependencies).map((dep) => `'${dep}'`);
                    const buildDeps = babel_template_1.default(`[
                         'module', 'exports', 'require' 
                         ${dependencies.length ? ',' : ''} 
                         ${dependencies.join()}
					 ]`);
                    let defineNode = buildDefine({
                        SOURCE: body,
                        DEPS: buildDeps(),
                    });
                    defineNode = applyUserDefinedTemplateIfPresent(filename, defineNode, log);
                    if (!Array.isArray(defineNode)) {
                        defineNode = [defineNode];
                    }
                    node.body = defineNode;
                    if (!dependencies.length) {
                        log.info('wrap-modules-amd', 'No dependencies detected');
                    }
                    else {
                        log.info('wrap-modules-amd', `Detected dependencies: ${dependencies.join(', ')}`);
                    }
                },
            },
        },
    };
}
exports.default = default_1;
function applyUserDefinedTemplateIfPresent(filename, defineNode, log) {
    const templateFile = `${filename}.wrap-modules-amd.template`;
    if (!fs_1.default.existsSync(templateFile)) {
        return defineNode;
    }
    log.info('wrap-modules-amd', 'Applied user template to wrap file');
    const buildUserTemplate = babel_template_1.default(`
		(function() {
			${fs_1.default.readFileSync(templateFile).toString()}
		})();
	`);
    fs_1.default.unlinkSync(templateFile);
    return buildUserTemplate({
        __WRAPPED_MODULE__: defineNode,
    });
}