@wyw-in-js/transform 1.1.0 → 2.0.0-alpha.1

package/types/utils/removeDangerousCode.js

@@ -1,326 +0,0 @@
-"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;
-    }
-    const { scope } = id;
-    const { name } = id.node;
-    return !scope.hasBinding(name) && scope.hasGlobal(name);
-};
-const ssrCheckFields = new Set([
-    'document',
-    'location',
-    'navigator',
-    'sessionStorage',
-    'localStorage',
-    'window',
-]);
-const forbiddenGlobals = new Set([
-    ...ssrCheckFields,
-    '$RefreshReg$',
-    '$RefreshSig$',
-    'XMLHttpRequest',
-    'clearImmediate',
-    'clearInterval',
-    'clearTimeout',
-    'fetch',
-    'navigator',
-    'setImmediate',
-    'setInterval',
-    'setTimeout',
-]);
-const alwaysForbiddenIdentifiers = new Set(['$RefreshReg$', '$RefreshSig$']);
-const isBrowserGlobal = (id) => {
-    const { name } = id.node;
-    if (alwaysForbiddenIdentifiers.has(name)) {
-        return (0, findIdentifiers_1.nonType)(id);
-    }
-    return forbiddenGlobals.has(name) && isGlobal(id);
-};
-const isSSRCheckField = (id) => {
-    return ssrCheckFields.has(id.node.name) && isGlobal(id);
-};
-const promiseCallbackMethods = new Set(['then', 'catch', 'finally']);
-const getPropertyName = (path) => {
-    if (path.isIdentifier()) {
-        return path.node.name;
-    }
-    if (path.isStringLiteral()) {
-        return path.node.value;
-    }
-    return null;
-};
-const isPromiseCallbackArgument = (path, ref) => {
-    return path
-        .get('arguments')
-        .some((arg) => arg === ref || arg.isAncestor(ref));
-};
-const findPromiseCallbackOwner = (path) => {
-    const owner = path.findParent((parent) => {
-        if (parent.isNewExpression()) {
-            const callee = parent.get('callee');
-            return (callee.isIdentifier({ name: 'Promise' }) &&
-                isPromiseCallbackArgument(parent, path));
-        }
-        if (parent.isCallExpression()) {
-            const callee = parent.get('callee');
-            if (!callee.isMemberExpression())
-                return false;
-            const propName = getPropertyName(callee.get('property'));
-            return (propName !== null &&
-                promiseCallbackMethods.has(propName) &&
-                isPromiseCallbackArgument(parent, path));
-        }
-        return false;
-    });
-    return owner;
-};
-const removeForbiddenGlobal = (path) => {
-    const promiseOwner = findPromiseCallbackOwner(path);
-    if (promiseOwner) {
-        (0, scopeHelpers_1.removeWithRelated)([promiseOwner]);
-    }
-    else {
-        (0, scopeHelpers_1.removeWithRelated)([path]);
-    }
-};
-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.
-        CallExpression: {
-            enter(p) {
-                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: {
-            enter: JSXElementsRemover_1.JSXElementsRemover,
-        },
-        JSXFragment: {
-            enter: JSXElementsRemover_1.JSXElementsRemover,
-        },
-        MemberExpression(p, state) {
-            const obj = p.get('object');
-            const prop = p.get('property');
-            if (!obj.isIdentifier({ name: 'window' })) {
-                return;
-            }
-            const name = getPropertyName(prop);
-            if (!name) {
-                return;
-            }
-            state.windowScoped.add(name);
-            // eslint-disable-next-line no-param-reassign
-            state.globals = state.globals.filter((id) => {
-                if (id.node.name === name) {
-                    (0, scopeHelpers_1.removeWithRelated)([id]);
-                    return false;
-                }
-                return true;
-            });
-        },
-        MetaProperty(p) {
-            // Remove all references to `import.meta`
-            (0, scopeHelpers_1.removeWithRelated)([p]);
-        },
-        Identifier(p, state) {
-            if (p.find((parent) => parent.isTSTypeReference())) {
-                // don't mess with TS type references
-                return;
-            }
-            if (isBrowserGlobal(p)) {
-                if (p.find((parentPath) => parentPath.isUnaryExpression({ operator: 'typeof' }) ||
-                    parentPath.isTSTypeQuery())) {
-                    // Ignore `typeof window` expressions
-                    return;
-                }
-                if (p.parentPath.isClassProperty()) {
-                    // ignore class property decls
-                    return;
-                }
-                if (p.parentPath.isMemberExpression() && p.key === 'property') {
-                    // ignore e.g this.fetch()
-                    // window.fetch will be handled by the windowScoped block below
-                    return;
-                }
-                removeForbiddenGlobal(p);
-                return;
-            }
-            if (state.windowScoped.has(p.node.name)) {
-                removeForbiddenGlobal(p);
-            }
-            else if (isGlobal(p)) {
-                state.globals.push(p);
-            }
-        },
-        // Since we can use happy-dom, typical SSR checks may not work as expected.
-        // We need to detect them and replace with an "undefined" literal.
-        UnaryExpression(p) {
-            if (p.node.operator !== 'typeof') {
-                return;
-            }
-            const arg = p.get('argument');
-            if (!arg.isIdentifier() || !isSSRCheckField(arg)) {
-                return;
-            }
-            (0, scopeHelpers_1.applyAction)([
-                'replace',
-                p,
-                { 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(),
-    });
-};
-exports.removeDangerousCode = removeDangerousCode;

package/types/utils/replaceImportMetaEnv.d.ts

@@ -1,3 +0,0 @@
-import type { NodePath } from '@babel/traverse';
-import type { Core } from '../babel';
-export declare function replaceImportMetaEnv(programPath: NodePath, t: Core['types']): void;

package/types/utils/replaceImportMetaEnv.js

@@ -1,39 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.replaceImportMetaEnv = replaceImportMetaEnv;
-const IMPORT_META_ENV = '__wyw_import_meta_env';
-const isRecord = (obj) => typeof obj === 'object' && obj !== null;
-function isImportMeta(obj) {
-    if (!isRecord(obj)) {
-        return false;
-    }
-    const { meta, property } = obj;
-    if (!isRecord(meta) || !isRecord(property)) {
-        return false;
-    }
-    return meta.name === 'import' && property.name === 'meta';
-}
-function isImportMetaEnv(node) {
-    const { computed, object, property } = node;
-    if (computed) {
-        return false;
-    }
-    if (!isImportMeta(object)) {
-        return false;
-    }
-    return property.type === 'Identifier' && property.name === 'env';
-}
-function replaceImportMetaEnv(programPath, t) {
-    programPath.traverse({
-        MemberExpression(path) {
-            if (isImportMetaEnv(path.node)) {
-                path.replaceWith(t.identifier(IMPORT_META_ENV));
-            }
-        },
-        OptionalMemberExpression(path) {
-            if (isImportMetaEnv(path.node)) {
-                path.replaceWith(t.identifier(IMPORT_META_ENV));
-            }
-        },
-    });
-}

package/types/utils/scopeHelpers.d.ts

@@ -1,12 +0,0 @@
-import type { Binding, NodePath } from '@babel/traverse';
-import type { Identifier, JSXIdentifier, Node } from '@babel/types';
-export declare function reference(path: NodePath<Identifier | JSXIdentifier>, referencePath?: NodePath, force?: boolean): void;
-export declare function dereference(path: NodePath<Identifier | JSXIdentifier>): Binding | null;
-export declare function referenceAll(path: NodePath): void;
-type ReplaceAction = [action: 'replace', what: NodePath, by: Node];
-type RemoveAction = [action: 'remove', what: NodePath];
-export declare function findActionForNode(path: NodePath): RemoveAction | ReplaceAction | null;
-declare function applyAction(action: ReplaceAction | RemoveAction): void;
-declare function removeWithRelated(paths: NodePath[]): void;
-declare function mutate<T extends NodePath>(path: T, fn: (p: T) => NodePath[] | void): void;
-export { applyAction, mutate, removeWithRelated };