searchFiles(current: any) {
		if (current === undefined) {
			for (let sub of this.subProjects) sub.searchFiles(undefined);
			this.searchFiles(this.basedir);
			// std::set<std::string> starts;
			// for (std::string include : includes) {
			//     if (!isAbsolute(include)) continue;
			//     std::string start = include.substr(0, firstIndexOf(include, '*'));
			//     if (starts.count(start) > 0) continue;
			//     starts.insert(start);
			//     searchFiles(Paths::get(start));
			// }
			return;
		}

		let files = fs.readdirSync(current);
		nextfile: for (let f in files) {
			let file = path.join(current, files[f]);
			if (fs.statSync(file).isDirectory()) continue;
			// if (!current.isAbsolute())
			file = path.relative(this.basedir, file);
			for (let exclude of this.excludes) {
				if (this.matches(this.stringify(file), exclude)) continue nextfile;
			}
			for (let includeobject of this.includes) {
				let include = includeobject.file;
				if (isAbsolute(include)) {
					let inc = include;
					inc = path.relative(this.basedir, inc);
					include = inc;
				}
				if (this.matches(this.stringify(file), include)) {
					this.addFileForReal(this.stringify(file), includeobject.options);
				}
			}
		}

		let dirs = fs.readdirSync(current);
		nextdir: for (let d of dirs) {
			let dir = path.join(current, d);
			if (d.startsWith('.')) continue;
			if (!fs.statSync(dir).isDirectory()) continue;
			for (let exclude of this.excludes) {
				if (this.matchesAllSubdirs(path.relative(this.basedir, dir), exclude)) {
					continue nextdir;
				}
			}
			this.searchFiles(dir);
		}
	}

 return new Promise((resolve, reject) => {
   const [fileName] = fs.readdirSync(dir).filter(name => name.match(regex));
   if (!fileName) {
     reject(new Error(`File ${regex} was expected to exist but not found...`));
   }
   resolve(fileName);
 });

export function getFoldersInFolder(
  folder: string,
  filter: ((folder: string) => boolean) | null,
  recursive: boolean,
  subFolder: string,
) {
  const fullFolder =
    typeof subFolder === 'undefined' ? folder : path.join(folder, subFolder);
  const folderFiles = fs.readdirSync(fullFolder);

  let folders: string[] = [];
  folderFiles.forEach(function(file: string) {
    if (filter && filter(file)) {
      console.log(path.join(fullFolder, file) + ' removed by filter');
      return;
    }

    const stat = fs.statSync(path.join(fullFolder, file));
    const subFolderFileName =
      typeof subFolder === 'undefined' ? file : path.join(subFolder, file);

    if (stat.isDirectory()) {
      folders.push(subFolderFileName);
      if (recursive) {
        folders = folders.concat(
          getFilesInFolder(folder, filter, recursive, subFolderFileName),
        );
      }
    }
  });

  return folders.map(function(folder) {
    return folder.replace(/\\/g, '/');
  });
}

function compileShader(projectDir, type, from, to, temp, platform, nokrafix) {
	let compiler = '';
	
	if (Project.koreDir !== '') {
		if (nokrafix) {
			compiler = path.resolve(Project.koreDir, 'Tools', 'kfx', 'kfx' + exec.sys());
		}
		else {
			compiler = path.resolve(Project.koreDir, 'Tools', 'krafix', 'krafix' + exec.sys());
		}
	}

	if (fs.existsSync(path.join(projectDir.toString(), 'Backends'))) {
		let libdirs = fs.readdirSync(path.join(projectDir.toString(), 'Backends'));
		for (let ld in libdirs) {
			let libdir = path.join(projectDir.toString(), 'Backends', libdirs[ld]);
			if (fs.statSync(libdir).isDirectory()) {
				let exe = path.join(libdir, 'krafix', 'krafix-' + platform + '.exe');
				if (fs.existsSync(exe)) {
					compiler = exe;
				}
			}
		}
	}

	if (compiler !== '') {
		child_process.spawnSync(compiler, [type, from, to, temp, platform]);
	}
}

export function emptyDirectory (dirPath: string, opts: { excludes: string[] } = { excludes: [] }) {
  if (fs.existsSync(dirPath)) {
    fs.readdirSync(dirPath).forEach(file => {
      const curPath = path.join(dirPath, file)
      if (fs.lstatSync(curPath).isDirectory()) {
        let removed = false
        let i = 0 // retry counter
        do {
          try {
            if (!opts.excludes.length || !opts.excludes.some(item => curPath.indexOf(item) >= 0)) {
              emptyDirectory(curPath)
              fs.rmdirSync(curPath)
            }
            removed = true
          } catch (e) {
          } finally {
            if (++i < retries) {
              continue
            }
          }
        } while (!removed)
      } else {
        fs.unlinkSync(curPath)
      }
    })
  }
}

function init() {
    if (!fs.existsSync(rootPath)) {
        return;
    }
    console.log('init------start ');
    let fileList: string[] = fs.readdirSync(rootPath);
    docsLoadingState = false;
    asyncjs.eachSeries(fileList, (file, callback) => {
        if (!fs.statSync(rootPath + file).isDirectory()) {
            return callback(null);
        }
        fs.readFile(rootPath + file + '/db.json', { encoding: 'utf-8' }, (err, data) => {
            if (err) {
                console.log('load file ' + file + 'error:' + err);
            } else {
                docsDB[file] = JSON.parse(data);
            }
            callback(null);
        });
    }, err => {
        if (!err) {
            docsLoadingState = true;
        }
        console.log('init------end ');
    });
}

 taroSelfComponents.forEach(c => {
   const cPath = path.join(taroJsQuickAppComponentsPath, c)
   const cMainPath = path.join(cPath, 'index')
   const cFiles = fs.readdirSync(cPath).map(item => path.join(cPath, item))
   copyFilesFromSrcToOutput(cFiles, (sourceFilePath, outputFilePath) => {
     if (fs.existsSync(sourceFilePath)) {
       const fileContent = fs.readFileSync(sourceFilePath).toString()
       const match = SCRIPT_CONTENT_REG.exec(fileContent)
       if (match) {
         const scriptContent = match[1]
         const transformResult: IWxTransformResult = wxTransformer({
           code: scriptContent,
           sourcePath: sourceFilePath,
           sourceDir: getBuildData().sourceDir,
           outputPath: outputFilePath,
           isNormal: true,
           isTyped: false,
           adapter: BUILD_TYPES.QUICKAPP
         })
         const res = parseAst(PARSE_AST_TYPE.NORMAL, transformResult.ast, [], sourceFilePath, outputFilePath)
         const newFileContent = fileContent.replace(SCRIPT_CONTENT_REG, `<script>${res.code}</script>`)
         fs.ensureDirSync(path.dirname(outputFilePath))
         fs.writeFileSync(outputFilePath, newFileContent)
       }
     }
   })
   const cRelativePath = promoteRelativePath(path.relative(filePath, cMainPath.replace(BuildData.nodeModulesPath, BuildData.npmOutputDir)))
   importTaroSelfComponents.add({
     path: cRelativePath,
     name: c
   })
 })

function getSiblingSassFiles(componentPath: string, sassConfig: SassConfig) {
  return readdirSync(componentPath).filter(f => {
    return isValidSassFile(f, sassConfig);
  }).map(f => {
    return join(componentPath, f);
  });
}

function walkFolder(targetFolder: string, cb: (fileName: string) => void) {
	let items = fse.readdirSync(targetFolder)

	let files: string[] = []
	let folders: string[] = []

	items.forEach(item => {
		let itemPath = path.join(targetFolder, item)
		let stat = fse.statSync(itemPath)

		if (stat.isDirectory()) {
			folders.push(itemPath)
		} else {
			files.push(itemPath)
		}
	})

	for (const item of files) {
		if (path.extname(item) === '.json') {
			cb(item)
		}
	}

	for (const item of folders) {
		walkFolder(item, cb)
	}
}

/**
 * Invoke the supplied callback for each file (not directories) in the supplied directory.
 *
 * @package util
 */
export default function eachFile(dirpath: string, fn: (childpath: string) => void): void {
  fs.readdirSync(dirpath).forEach((childpath) => {
    let absolutepath = path.join(dirpath, childpath);
    if (fs.statSync(absolutepath).isFile()) {
      fn(childpath);
    }
  });
}