devsite/node_modules/with/lib/globals.js
2024-07-07 18:49:38 -07:00

190 lines
6.5 KiB
JavaScript

"use strict";
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 (Object.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 assert_never_1 = __importDefault(require("assert-never"));
const babel_walk_1 = require("babel-walk");
const t = __importStar(require("@babel/types"));
const reference_1 = __importDefault(require("./reference"));
const isScope = (node) => t.isFunctionParent(node) || t.isProgram(node);
const isBlockScope = (node) => t.isBlockStatement(node) || isScope(node);
const declaresArguments = (node) => t.isFunction(node) && !t.isArrowFunctionExpression(node);
const declaresThis = declaresArguments;
const LOCALS_SYMBOL = Symbol('locals');
const getLocals = (node) => node[LOCALS_SYMBOL];
const declareLocals = (node) => (node[LOCALS_SYMBOL] = node[LOCALS_SYMBOL] || new Set());
const setLocal = (node, name) => declareLocals(node).add(name);
// First pass
function declareFunction(node) {
for (const param of node.params) {
declarePattern(param, node);
}
const id = node.id;
if (id) {
setLocal(node, id.name);
}
}
function declarePattern(node, parent) {
switch (node.type) {
case 'Identifier':
setLocal(parent, node.name);
break;
case 'ObjectPattern':
for (const prop of node.properties) {
switch (prop.type) {
case 'RestElement':
declarePattern(prop.argument, parent);
break;
case 'ObjectProperty':
declarePattern(prop.value, parent);
break;
default:
assert_never_1.default(prop);
break;
}
}
break;
case 'ArrayPattern':
for (const element of node.elements) {
if (element)
declarePattern(element, parent);
}
break;
case 'RestElement':
declarePattern(node.argument, parent);
break;
case 'AssignmentPattern':
declarePattern(node.left, parent);
break;
// istanbul ignore next
default:
throw new Error('Unrecognized pattern type: ' + node.type);
}
}
function declareModuleSpecifier(node, _state, parents) {
for (let i = parents.length - 2; i >= 0; i--) {
if (isScope(parents[i])) {
setLocal(parents[i], node.local.name);
return;
}
}
}
const firstPass = babel_walk_1.ancestor({
VariableDeclaration(node, _state, parents) {
for (let i = parents.length - 2; i >= 0; i--) {
if (node.kind === 'var'
? t.isFunctionParent(parents[i])
: isBlockScope(parents[i])) {
for (const declaration of node.declarations) {
declarePattern(declaration.id, parents[i]);
}
return;
}
}
},
FunctionDeclaration(node, _state, parents) {
if (node.id) {
for (let i = parents.length - 2; i >= 0; i--) {
if (isScope(parents[i])) {
setLocal(parents[i], node.id.name);
return;
}
}
}
},
Function: declareFunction,
ClassDeclaration(node, _state, parents) {
for (let i = parents.length - 2; i >= 0; i--) {
if (isScope(parents[i])) {
setLocal(parents[i], node.id.name);
return;
}
}
},
TryStatement(node) {
if (node.handler === null)
return;
if (node.handler.param === null)
return;
declarePattern(node.handler.param, node.handler);
},
ImportDefaultSpecifier: declareModuleSpecifier,
ImportSpecifier: declareModuleSpecifier,
ImportNamespaceSpecifier: declareModuleSpecifier,
});
// Second pass
const secondPass = babel_walk_1.ancestor({
Identifier(node, state, parents) {
var _a;
const name = node.name;
if (name === 'undefined')
return;
const lastParent = parents[parents.length - 2];
if (lastParent) {
if (!reference_1.default(node, lastParent))
return;
for (const parent of parents) {
if (name === 'arguments' && declaresArguments(parent)) {
return;
}
if ((_a = getLocals(parent)) === null || _a === void 0 ? void 0 : _a.has(name)) {
return;
}
}
}
state.globals.push(node);
},
ThisExpression(node, state, parents) {
for (const parent of parents) {
if (declaresThis(parent)) {
return;
}
}
state.globals.push(node);
},
});
function findGlobals(ast) {
const globals = [];
// istanbul ignore if
if (!t.isNode(ast)) {
throw new TypeError('Source must be a Babylon AST');
}
firstPass(ast, undefined);
secondPass(ast, { globals });
const groupedGlobals = new Map();
for (const node of globals) {
const name = node.type === 'ThisExpression' ? 'this' : node.name;
const existing = groupedGlobals.get(name);
if (existing) {
existing.push(node);
}
else {
groupedGlobals.set(name, [node]);
}
}
return [...groupedGlobals]
.map(([name, nodes]) => ({ name, nodes }))
.sort((a, b) => (a.name < b.name ? -1 : 1));
}
exports.default = findGlobals;
//# sourceMappingURL=globals.js.map