Read only
    function transform(file, { j }, options) {
      const root = j(file.source);
      let dirtyFlag = false;
    
      const { identifier } = removeImport('array.prototype.splice', root, j);
    
      root
        .find(j.CallExpression, {
          callee: {
            type: 'Identifier',
            name: identifier
          }
        })
        .forEach((path) => {
          const args = path.value.arguments;
          if (args.length > 1) {
            const [array, ...elements] = args;
    
            const newExpression = j.callExpression(
              //@ts-ignore
              j.memberExpression(array, j.identifier('splice')),
              [...elements]
            );
            j(path).replaceWith(newExpression);
            dirtyFlag = true;
          }
        });
    
      return dirtyFlag ? root.toSource(options) : file.source;
    }
    
    function removeImport(name, root, j) {
      // Find the import or require statement for 'is-boolean-object'
      const importDeclaration = root.find(j.ImportDeclaration, {
        source: {
          value: name
        }
      });
    
      const requireDeclaration = root
        .find(j.CallExpression, {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        })
        .closest(j.VariableDeclarator);
    
      // Require statements without declarations like `Object.is = require("object-is");`
      const requireAssignment = root.find(j.AssignmentExpression, {
        operator: '=',
        right: {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        }
      });
    
      // Side effect requires statements like `require("error-cause/auto");`
      const sideEffectRequireExpression = root.find(j.ExpressionStatement, {
        expression: {
          callee: {
            name: 'require'
          },
          arguments: [
            {
              value: name
            }
          ]
        }
      });
    
      // Return the identifier name, e.g. 'fn' in `import { fn } from 'is-boolean-object'`
      // or `var fn = require('is-boolean-object')`
      const identifier =
        importDeclaration.paths().length > 0
          ? importDeclaration.get().node.specifiers[0].local.name
          : requireDeclaration.paths().length > 0
            ? requireDeclaration.find(j.Identifier).get().node.name
            : requireAssignment.paths().length > 0
              ? requireAssignment.find(j.Identifier).get().node.name
              : null;
    
      importDeclaration.remove();
      requireDeclaration.remove();
      requireAssignment.remove();
      sideEffectRequireExpression.remove();
    
      const dirtyFlag =
        importDeclaration.length > 0 ||
        requireDeclaration.length > 0 ||
        requireAssignment.length > 0 ||
        sideEffectRequireExpression.length > 0;
    
      return { identifier, dirtyFlag };
    }
    
    
    export default transform;
    
    
    Input
    var splice = require('array.prototype.splice');
    var assert = require('assert');
    
    var a = [1, 1, 1];
    assert.deepEqual(splice(a, 1, 2), [1, 1]);
    assert.deepEqual(a, [1]);
    Output
    loading
    Read-only
    Open on CodeSandboxOpen Sandbox