How to use glob

glob.sync(`${rootDir}{/**/*.ts,/**/*.tsx}`, {
      ignore: [
        '**/node_modules/**',
        '**/.git/**',
        '**/ElectronClient/lib/**',
        '**/CliClient/build/lib/**',
        '**/CliClient/tests-build/lib/**',
        '**/ElectronClient/dist/**',
        '**/Modules/TinyMCE/JoplinLists/**',
        '**/Modules/TinyMCE/IconPack/**',
      ],
    }).map(f => f.substr(rootDir.length + 1))

const getSourceFilePaths = () => {
 return new Promise((resolve, reject) => {
  glob(SOURCE_PATTERN, (error, files) => {
   if (error) {
    reject(error);
    return;
   }

   resolve(files.map(filePath => path.join(process.cwd(), filePath)));
  });
 });
}

// Helper to get init source config
const getInitSourceConfig = dirs => _(dirs)
 .filter(dir => fs.existsSync(dir))
 .flatMap(dir => glob.sync(path.join(dir, '*.js')))
 .map(file => require(file))
 .flatMap(source => source.sources)
 .value()

// Helper to get init config
const getInitConfig = dirs => _(dirs)
 .filter(dir => fs.existsSync(dir))
 .flatMap(dir => glob.sync(path.join(dir, '*', 'init.js')))
 .map(file => require(file))
 .value()

describe('test/lib/plugins/logrotator.test.js', () => {
 let app;
 before(() => {
  app = utils.app('apps/logrotator-app');
  return app.ready();
 });

 after(() => app.close());

 it('should rotate log file default', async () => {
  const file = require.resolve('egg-logrotator/app/schedule/rotate_by_file.js');
  await app.runSchedule(file);
  const files = glob.sync(path.join(app.config.logger.dir, '*.log.*'));
  assert(files.length > 0);
  files.forEach(file => {
   assert(/\.log\.\d{4}-\d{2}-\d{2}$/.test(file));
  });
 });
});

static resolveAssetFiles () {
  let assets = new Map([
   ['hooks', undefined],
   ['widgets', undefined]
  ])

  let hooksMap = new Map()
  let widgetsMap = new Map()

  glob.sync(config.hooks).forEach((item) => {
   hooksMap.set(this.formatAsset(item), require(item))
  })

  glob.sync(config.widgets).forEach((item) => {
   widgetsMap.set(this.formatAsset(item), require(item))
  })

  assets.set('hooks', hooksMap)
  assets.set('widgets', widgetsMap)

  return assets
 }

/*
 * Helper to bootstrap app stuffs
 */
const bootstrapApp = lando => {
 const Factory = require('./factory');
 const Yaml = require('./yaml');
 lando.factory = new Factory();
 lando.yaml = new Yaml(lando.log);
 // Load in all our builders in the correct order
 const builders = _(['compose', 'types', 'services', 'recipes'])
  .flatMap(type => _.map(lando.config.plugins, plugin => plugin[type]))
  .filter(dir => fs.existsSync(dir))
  .flatMap(dir => glob.sync(path.join(dir, '*', 'builder.js')))
  .map(file => lando.factory.add(require(file)).name)
  .value();
 // Log
 _.forEach(builders, builder => lando.log.debug('autoloaded builder %s', builder));
}

/**
   * Load services from a folder
   *
   * @param {string} [folder="./services"]        Folder of services
   * @param {string} [fileMask="**\/*.service.js"]    Service filename mask
   * @returns    {Number}                            Number of found services
   *
   * @memberof ServiceBroker
   */
  loadServices(folder = "./services", fileMask = "**/*.service.js") {
    this.logger.debug(`Search services in '${folder}/${fileMask}'...`);

    let serviceFiles;

    if (Array.isArray(fileMask))
      serviceFiles = fileMask.map(f => path.join(folder, f));
    else
      serviceFiles = glob.sync(path.join(folder, fileMask));

    if (serviceFiles)
      serviceFiles.forEach(filename => this.loadService(filename));

    return serviceFiles.length;
  }

// Protocol files are imported on demand depending on the APIs supported by Kafka,
// but this behavior doesn't help Jest. Therefore, all files are eagerly imported
// when running tests
glob
 .sync('src/protocol/requests/**/v*/@(request|response).js')
 .map(file => path.resolve(file))
 .map(require)

};
const files1 = glob.sync(`${dir1}/**/*`, globOptions).filter(filterFiles).map(f => f.substr(dir1.length + 1));
const files2 = glob.sync(`${dir2}/**/*`, globOptions).filter(filterFiles).map(f => f.substr(dir2.length + 1));

    this.watchFolders.push(svcPath);
  files = glob(svcPath + "/" + fileMask, { absolute: true });
  if (files.length == 0)
    return this.broker.logger.warn(kleur.yellow().bold(`There is no service files in directory: '${svcPath}'`));
} else {
  files = glob(p, { cwd: svcDir, absolute: true });
  if (files.length == 0)
    this.broker.logger.warn(kleur.yellow().bold(`There is no matched file for pattern: '${p}'`));

_.forEach(files.matches[0],function(n,key){
       files.path = key;
     });

function loadConfig(path) {
  var glob = require('glob');
  var object = {};
  var key;

  glob.sync('*', {cwd: path}).forEach(function(option) {
   key = option.replace(/\.js$/,'');
   object[key] = require(path + option);
  });

 return object;
}

function getMigrations(){
  return new Promise((resolve, reject) => {
    glob(require("path").join(__dirname, './versions/*.js'), (err, files) => {
      let migrationVersions = files.reduce((acc, file) => {
        console.log(file);
        let version = file.split("/").pop().slice(0, -3);
         acc[version] = require(file);
         return acc;
      },{});
      resolve(migrationVersions);
    })
  })
}

function generateSassPath (fp, imports) {
 var res = [];
 imports.forEach(function (item) {
  var find = glob.sync(path.join(fp, '**', '?(_)' + item + '.+(scss|sass)'), {});
  res = res.concat(find);
 });
 return res;
}