How to use detective - 9 common examples

function expose(map, origSrc) {
  var regex, keys, id;
  var src = origSrc;

  keys = Object.keys(map);

  // ensure that at least one of the require statements we want to replace is in the code
  // before we perform the expensive operation of finding them by creating an AST
  var hasMatchingRequires = keys.some(function (id) {
    regex = new RegExp('require\\(\\s*[\'"]' + id + '[\'"]\\s*\\)');
    return regex.test(src)
  });
  if (!hasMatchingRequires) return src;

  var requires = detective.find(src, { nodes: true, parse: { range: true } });
  if (!requires.strings.length) return src;

  var replacements = keys
    .reduce(function (acc, id) {
      var r = getReplacements(id, map[id], requires);
      return acc.concat(r);
    }, [])
    .sort(rangeComparator);

  var offset = 0;
  return replacements
    .reduce(function(acc, replacement) {
      var from = replacement.from + offset
        , to   = replacement.to + offset
        , code = replacement.code;

function expose(map, origSrc) {
  var regex, keys, id;
  var src = origSrc;

  keys = Object.keys(map);

  // ensure that at least one of the require statements we want to replace is in the code
  // before we perform the expensive operation of finding them by creating an AST
  var hasMatchingRequires = keys.some(function (id) {
    regex = new RegExp('require\\(\\s*[\'"]' + id + '[\'"]\\s*\\)');
    return regex.test(src)
  });
  if (!hasMatchingRequires) return src;

  var requires = detective.find(src, { nodes: true, parse: { range: true } });
  if (!requires.strings.length) return src;

  var replacements = keys
    .reduce(function (acc, id) {
      var r = getReplacements(id, map[id], requires);
      return acc.concat(r);
    }, [])
    .sort(rangeComparator);

  var offset = 0;
  return replacements
    .reduce(function(acc, replacement) {
      var from = replacement.from + offset
        , to   = replacement.to + offset
        , code = replacement.code;

return;
  }

  const file = files[resolvedPath];
  if (file !== undefined) {
    const content = file.toString('utf8');
    mutableResult[resolvedPath] = content;
    const dtsFilePath = nodePath.join(nodePath.dirname(resolvedPath), `${nodePath.basename(resolvedPath, '.js')}.d.ts`);
    const dtsFile = files[dtsFilePath];
    if (dtsFile !== undefined) {
      mutableResult[dtsFilePath] = dtsFile.toString('utf8');
    }

    let requires: ReadonlyArray | undefined;
    try {
      requires = detective(content);
    } catch {
      // do nothing
    }

    if (requires !== undefined) {
      requires
        .filter((req): req is string => typeof req === 'string')
        .filter((req) => req.startsWith('.'))
        .map((req) => nodePath.resolve(nodePath.dirname(resolvedPath), req))
        .forEach((req) => {
          resolveJavaScriptFiles(files, req, mapping, mutableResult);
        });
    }
  }
};

deputy.find = function (src) {
        var h = hash(src);
        var c = cache[h];
        if (c) return c;
        else {
            c = detective.find(src);
            save(h, c);
            return c;
        }
    };

function getAsyncRequires(source){
  var amdRequires = detective.find(source, {nodes: true});
  var amdRequireArray = amdRequires.expressions.map(function(arrString){
    var exps = require('esprima').parse(arrString).body[0].expression;
    var array = require('static-eval')(exps);
    return array;
  });
  return _.flatten(amdRequireArray);
}

Require.prototype.require = function (module, opts) {
  var self = this;
  
  opts = opts || {};
  var file = resolve.sync(module, opts);
  var dir = path.dirname(file);
  var src = fs.readFileSync(file, 'utf-8');
  var reqs = detective.find(src);
  
  reqs.strings.forEach(function(req) {
    self.require(req, {
      basedir: dir
    });
  });
  
  this.modules[module] = {
    module: module,
    path: dir,
    body: src
  };
};

fs.readFile(options.target, function(err, data){
    if(err) return callback(err);

    var files;

    try {
      files = detective.find(data.toString('utf8'));
    } catch(e){
      return callback(err);
    }

    files.strings.forEach(function(name){
      if(name in options.packages) return;

      options.packages[name] = true;

      var absolutePath = analyzer.resolve(name, options.target);
      if(!absolutePath || path.relative(options.target, absolutePath).indexOf('node_modules') >= 0){
        return;
      }

      remaining++;

const parseNodeImports = (
  filePath: string,
  src: string
): IParseImportsResult => {
  return detective.find(src, { nodes: true });
};