@wyw-in-js/transform 0.5.5 → 0.7.0

package/types/utils/removeDangerousCode.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeDangerousCode = void 0;
+const core_1 = require("@babel/core");
 const findIdentifiers_1 = require("./findIdentifiers");
 const isUnnecessaryReactCall_1 = require("./isUnnecessaryReactCall");
 const scopeHelpers_1 = require("./scopeHelpers");
 const JSXElementsRemover_1 = require("./visitors/JSXElementsRemover");
+const collectExportsAndImports_1 = require("./collectExportsAndImports");
 const isGlobal = (id) => {
     if (!(0, findIdentifiers_1.nonType)(id)) {
         return false;
@@ -49,7 +51,125 @@ const getPropertyName = (path) => {
     }
     return null;
 };
-const removeDangerousCode = (programPath) => {
+const getImport = (path) => {
+    const programPath = path.findParent((p) => p.isProgram());
+    if (!programPath) {
+        return undefined;
+    }
+    const { imports } = (0, collectExportsAndImports_1.collectExportsAndImports)(programPath);
+    if (path.isIdentifier()) {
+        const binding = path.scope.getBinding(path.node.name);
+        const matched = binding &&
+            imports.find((imp) => imp.imported !== 'side-effect' && binding.path.isAncestor(imp.local));
+        if (matched) {
+            return [matched.source, matched.imported];
+        }
+    }
+    if (path.isMemberExpression()) {
+        const leftPath = path.get('object');
+        if (!leftPath.isIdentifier()) {
+            // Nested member expression. Not supported yet.
+            return undefined;
+        }
+        const rightPath = path.get('property');
+        if (!rightPath.isIdentifier()) {
+            return undefined;
+        }
+        const binding = path.scope.getBinding(leftPath.node.name);
+        const matched = binding &&
+            imports.find((imp) => imp.imported !== 'side-effect' && binding.path.isAncestor(imp.local));
+        if (matched) {
+            return [matched.source, rightPath.node.name];
+        }
+    }
+    return undefined;
+};
+const getTypeImport = (path) => {
+    // We are looking for either Identifier or TSQualifiedName in path
+    if (path.isIdentifier()) {
+        const binding = path.scope.getBinding(path.node.name);
+        if (!binding) {
+            return undefined;
+        }
+        if (!binding.path.isImportSpecifier() ||
+            !binding.path.parentPath.isImportDeclaration()) {
+            return undefined;
+        }
+        const importDeclaration = binding.path.parentPath;
+        const imported = binding.path.get('imported');
+        const source = importDeclaration.node.source.value;
+        const importedNode = imported.node;
+        return [
+            source,
+            core_1.types.isIdentifier(importedNode) ? importedNode.name : importedNode.value,
+        ];
+    }
+    if (path.isTSQualifiedName()) {
+        const leftPath = path.get('left');
+        if (!leftPath.isIdentifier()) {
+            // Nested type. Not supported yet.
+            return undefined;
+        }
+        const rightPath = path.get('right');
+        const binding = path.scope.getBinding(leftPath.node.name);
+        if (!binding) {
+            return undefined;
+        }
+        if ((!binding.path.isImportDefaultSpecifier() &&
+            !binding.path.isImportNamespaceSpecifier()) ||
+            !binding.path.parentPath.isImportDeclaration()) {
+            return undefined;
+        }
+        return [binding.path.parentPath.node.source.value, rightPath.node.name];
+    }
+    return undefined;
+};
+const isTypeMatch = (id, types) => {
+    const typeAnnotation = id.get('typeAnnotation');
+    if (!typeAnnotation.isTSTypeAnnotation()) {
+        return false;
+    }
+    const typeReference = typeAnnotation.get('typeAnnotation');
+    if (!typeReference.isTSTypeReference()) {
+        return false;
+    }
+    const typeName = typeReference.get('typeName');
+    const matchedImport = getTypeImport(typeName);
+    return (matchedImport !== undefined &&
+        matchedImport[0] in types &&
+        types[matchedImport[0]].includes(matchedImport[1]));
+};
+const isHOC = (path, hocs) => {
+    let calleePath = path;
+    while (calleePath.isCallExpression()) {
+        calleePath = calleePath.get('callee');
+    }
+    const matchedImport = getImport(calleePath);
+    return (matchedImport !== undefined &&
+        matchedImport[0] in hocs &&
+        hocs[matchedImport[0]].includes(matchedImport[1]));
+};
+const defaultPlaceholder = '...';
+const defaultReactComponentTypes = [
+    'ExoticComponent',
+    'FC',
+    'ForwardRefExoticComponent',
+    'FunctionComponent',
+    'LazyExoticComponent',
+    'MemoExoticComponent',
+    'NamedExoticComponent',
+];
+const removeDangerousCode = (programPath, options) => {
+    const hocs = options?.hocs ?? {};
+    const componentTypes = options?.componentTypes ?? {
+        react: [defaultPlaceholder],
+    };
+    if (Array.isArray(componentTypes.react) &&
+        componentTypes.react.includes(defaultPlaceholder)) {
+        const idx = componentTypes.react.indexOf(defaultPlaceholder);
+        componentTypes.react = [...componentTypes.react];
+        componentTypes.react.splice(idx, 1, ...defaultReactComponentTypes);
+    }
     programPath.traverse({
         // JSX can be replaced with a dummy value,
         // but we have to do it after we processed template tags.
@@ -58,6 +178,13 @@ const removeDangerousCode = (programPath) => {
                 if ((0, isUnnecessaryReactCall_1.isUnnecessaryReactCall)(p)) {
                     (0, JSXElementsRemover_1.JSXElementsRemover)(p);
                 }
+                if (isHOC(p, hocs)) {
+                    (0, scopeHelpers_1.applyAction)([
+                        'replace',
+                        p,
+                        core_1.types.arrowFunctionExpression([], core_1.types.nullLiteral()),
+                    ]);
+                }
             },
         },
         JSXElement: {
@@ -136,6 +263,20 @@ const removeDangerousCode = (programPath) => {
                 { type: 'StringLiteral', value: 'undefined' },
             ]);
         },
+        VariableDeclarator(p) {
+            const id = p.get('id');
+            const init = p.get('init');
+            if (id.isIdentifier() &&
+                isTypeMatch(id, componentTypes) &&
+                init.isExpression()) {
+                // Variable is typed as a React component. We can replace its value with a null-function.
+                (0, scopeHelpers_1.applyAction)([
+                    'replace',
+                    init,
+                    core_1.types.arrowFunctionExpression([], core_1.types.nullLiteral()),
+                ]);
+            }
+        },
     }, {
         globals: [],
         windowScoped: new Set(),